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 "prot_fx.h"
37 : #include "ivas_prot_rend_fx.h"
38 : #include "ivas_cnst.h"
39 : #include "ivas_rom_rend.h"
40 : #include "ivas_rom_binaural_crend_head.h"
41 : #include "ivas_stat_rend.h"
42 : #include "lib_rend.h"
43 : #include "ivas_prot_fx.h"
44 : #include "wmc_auto.h"
45 : #ifdef DEBUGGING
46 : #include "debug.h"
47 : #endif
48 :
49 :
50 : /*-------------------------------------------------------------------------
51 : * ivas_Crend_hrtf_init()
52 : *
53 : * Initialize hHrtf handle
54 : *------------------------------------------------------------------------*/
55 :
56 503 : ivas_error ivas_Crend_hrtf_init_fx(
57 : HRTFS_CREND_DATA *hHrtf /* i/o: HRTF handle */
58 : )
59 : {
60 : Word16 i, j;
61 :
62 503 : IF( hHrtf == NULL )
63 : {
64 0 : return IVAS_ERR_WRONG_PARAMS;
65 : }
66 :
67 503 : hHrtf->latency_s_fx = 0;
68 503 : hHrtf->gain_lfe_fx = 0;
69 503 : hHrtf->max_num_ir = 0;
70 503 : hHrtf->max_num_iterations = 0;
71 503 : hHrtf->index_frequency_max_diffuse = 0;
72 503 : hHrtf->same_inv_diffuse_weight = 1;
73 503 : move16();
74 503 : move32();
75 503 : move16();
76 503 : move16();
77 503 : move16();
78 503 : move16();
79 503 : hHrtf->factor_Q_latency_s_fx = 0;
80 503 : move16();
81 503 : hHrtf->factor_Q_inv_diffuse_weight = 0;
82 503 : move16();
83 503 : hHrtf->factor_Q_pOut_to_bin = 0;
84 503 : move16();
85 :
86 8551 : FOR( i = 0; i < MAX_INTERN_CHANNELS; i++ )
87 : {
88 24144 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
89 : {
90 16096 : hHrtf->inv_diffuse_weight_fx[j][i] = 0;
91 16096 : move16();
92 16096 : hHrtf->num_iterations[i][j] = 0;
93 16096 : move16();
94 16096 : hHrtf->pIndex_frequency_max[i][j] = NULL;
95 16096 : hHrtf->pOut_to_bin_re_fx[i][j] = NULL;
96 16096 : hHrtf->pOut_to_bin_im_fx[i][j] = NULL;
97 : }
98 : }
99 :
100 1509 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
101 : {
102 1006 : hHrtf->num_iterations_diffuse[j] = 0;
103 1006 : move16();
104 1006 : hHrtf->pIndex_frequency_max_diffuse[j] = NULL;
105 :
106 1006 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = NULL;
107 1006 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = NULL;
108 : }
109 :
110 503 : hHrtf->init_from_rom = 1;
111 503 : move16();
112 :
113 503 : return IVAS_ERR_OK;
114 : }
115 :
116 :
117 : /*-------------------------------------------------------------------------
118 : * ivas_hrtf_open()
119 : *
120 : * Open hHrtf handle for Crend renderer
121 : *------------------------------------------------------------------------*/
122 :
123 475 : static ivas_error ivas_hrtf_open_fx(
124 : HRTFS_CREND_HANDLE *hHrtf_out /* o : HRTF handle */
125 : )
126 : {
127 : HRTFS_CREND_HANDLE hHrtf;
128 : ivas_error error;
129 :
130 475 : IF( *hHrtf_out == NULL )
131 : {
132 475 : IF( ( hHrtf = (HRTFS_CREND_HANDLE) malloc( sizeof( HRTFS_CREND_DATA ) ) ) == NULL )
133 : {
134 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend HRTFS Handle\n" );
135 : }
136 :
137 475 : IF( ( error = ivas_Crend_hrtf_init_fx( hHrtf ) ) != IVAS_ERR_OK )
138 : {
139 0 : return error;
140 : }
141 :
142 475 : *hHrtf_out = hHrtf;
143 : }
144 : ELSE
145 : {
146 0 : return IVAS_ERR_INTERNAL;
147 : }
148 :
149 475 : return IVAS_ERR_OK;
150 : }
151 :
152 :
153 : /*-------------------------------------------------------------------------
154 : * ivas_hrtf_close()
155 : *
156 : * Close hHrtf handle
157 : *------------------------------------------------------------------------*/
158 :
159 475 : static void ivas_hrtf_close(
160 : HRTFS_CREND_HANDLE *hHrtf /* i/o: Crend HRTF handle */
161 : )
162 : {
163 475 : test();
164 475 : IF( hHrtf == NULL || *hHrtf == NULL )
165 : {
166 0 : return;
167 : }
168 :
169 475 : free( *hHrtf );
170 475 : *hHrtf = NULL;
171 :
172 475 : return;
173 : }
174 :
175 :
176 : /*-------------------------------------------------------------------------
177 : * ivas_rend_initCrend()
178 : *
179 : * Allocate and initialize crend renderer handle
180 : *------------------------------------------------------------------------*/
181 :
182 503 : static ivas_error ivas_rend_initCrend_fx(
183 : CREND_WRAPPER *pCrend,
184 : const AUDIO_CONFIG inConfig,
185 : const AUDIO_CONFIG outConfig,
186 : HRTFS_CREND_HANDLE hHrtfCrend,
187 : const Word16 ext_rend_flag,
188 : const Word32 output_Fs )
189 : {
190 : Word16 i, j, tmp, tmp2;
191 : Word16 nchan_in;
192 : IVAS_REND_AudioConfigType inConfigType;
193 : HRTFS_CREND_HANDLE hHrtf;
194 : ivas_error error;
195 :
196 503 : inConfigType = getAudioConfigType( inConfig );
197 503 : hHrtf = pCrend->hHrtfCrend;
198 :
199 : /* Do all error checks up front so that the nested if later is easier */
200 503 : test();
201 503 : IF( NE_16( inConfigType, IVAS_REND_AUDIO_CONFIG_TYPE_CHANNEL_BASED ) && NE_16( inConfigType, IVAS_REND_AUDIO_CONFIG_TYPE_AMBISONICS ) )
202 : {
203 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Encountered unsupported input config in Crend" );
204 : }
205 :
206 503 : test();
207 503 : test();
208 503 : IF( NE_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL ) && NE_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) && NE_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB ) && NE_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_CODED ) && NE_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_SPLIT_PCM ) )
209 : {
210 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Encountered unsupported output type in Crend" );
211 : }
212 :
213 503 : IF( hHrtf == NULL )
214 : {
215 503 : test();
216 503 : IF( hHrtfCrend != NULL && ext_rend_flag == 0 )
217 : {
218 : /* HRTF set loaded from binary file */
219 28 : hHrtf = hHrtfCrend;
220 28 : hHrtf->init_from_rom = 0;
221 28 : move16();
222 : }
223 : ELSE
224 : {
225 : /* create new handle when HRTF is loaded from ROM, or external renderer is used */
226 475 : IF( NE_32( ( error = ivas_hrtf_open_fx( &hHrtf ) ), IVAS_ERR_OK ) )
227 : {
228 0 : return error;
229 : }
230 :
231 475 : hHrtf->init_from_rom = 1;
232 475 : move16();
233 475 : IF( hHrtfCrend != NULL )
234 : {
235 0 : hHrtf->init_from_rom = 0;
236 0 : move16();
237 : }
238 : }
239 : }
240 :
241 503 : IF( NE_32( ( error = getAudioConfigNumChannels( inConfig, &nchan_in ) ), IVAS_ERR_OK ) )
242 : {
243 0 : return error;
244 : }
245 503 : hHrtf->max_num_ir = nchan_in;
246 503 : move16();
247 :
248 503 : IF( hHrtf->max_num_ir <= 0 )
249 : {
250 0 : return IVAS_ERR_INTERNAL_FATAL;
251 : }
252 :
253 503 : IF( hHrtf->init_from_rom )
254 : {
255 475 : IF( EQ_32( inConfigType, IVAS_REND_AUDIO_CONFIG_TYPE_CHANNEL_BASED ) )
256 : {
257 450 : hHrtf->max_num_ir = sub( hHrtf->max_num_ir, 1 ); /* subtract LFE */
258 450 : move16();
259 450 : hHrtf->gain_lfe_fx = GAIN_LFE_FX; // Q14
260 450 : move16();
261 :
262 450 : IF( EQ_32( output_Fs, 48000 ) )
263 : {
264 310 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
265 : {
266 230 : hHrtf->latency_s_fx = CRendBin_Combined_BRIR_latency_s_fx; // Q31
267 230 : hHrtf->max_num_iterations = CRendBin_Combined_BRIR_max_num_iterations_48kHz; // Q0
268 230 : hHrtf->index_frequency_max_diffuse = CRendBin_Combined_BRIR_index_frequency_max_diffuse_48kHz; // Q0
269 230 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_Combined_BRIR_Q_latency_s_fx;
270 230 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_Combined_BRIR_inv_diffuse_weight_Q_48kHz_fx;
271 230 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_Combined_BRIR_coeff_Q_48kHz_fx;
272 : }
273 : ELSE
274 : {
275 80 : hHrtf->latency_s_fx = CRendBin_Combined_HRIR_latency_s_fx; // Q31
276 80 : hHrtf->max_num_iterations = CRendBin_Combined_HRIR_max_num_iterations_48kHz; // Q0
277 80 : hHrtf->index_frequency_max_diffuse = CRendBin_Combined_HRIR_index_frequency_max_diffuse_48kHz; // Q0
278 80 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_Combined_HRIR_Q_latency_s_fx;
279 80 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_Combined_HRIR_inv_diffuse_weight_Q_48kHz_fx;
280 80 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_Combined_HRIR_coeff_Q_48kHz_fx;
281 : }
282 310 : move32();
283 310 : move16();
284 310 : move16();
285 310 : move16();
286 310 : move16();
287 310 : move16();
288 :
289 930 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
290 : {
291 620 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
292 : {
293 460 : hHrtf->num_iterations_diffuse[j] = CRendBin_Combined_BRIR_num_iterations_diffuse_48kHz[j]; // Q0
294 460 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_Combined_BRIR_pIndex_frequency_max_diffuse_48kHz[j]; // Q0
295 :
296 460 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_Combined_BRIR_coeff_diffuse_re_48kHz_fx[j]; // Q31
297 460 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_Combined_BRIR_coeff_diffuse_im_48kHz_fx[j]; // Q31
298 : }
299 : ELSE
300 : {
301 160 : hHrtf->num_iterations_diffuse[j] = CRendBin_Combined_HRIR_num_iterations_diffuse_48kHz[j]; // Q0
302 160 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_Combined_HRIR_pIndex_frequency_max_diffuse_48kHz[j]; // Q0
303 :
304 160 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_Combined_HRIR_coeff_diffuse_re_48kHz_fx[j]; // Q31
305 160 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_Combined_HRIR_coeff_diffuse_im_48kHz_fx[j]; // Q31
306 : }
307 620 : move32();
308 620 : move32();
309 620 : move16();
310 620 : move16();
311 : }
312 : }
313 140 : ELSE IF( EQ_32( output_Fs, 32000 ) )
314 : {
315 75 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
316 : {
317 75 : hHrtf->latency_s_fx = CRendBin_Combined_BRIR_latency_s_fx; // Q31
318 75 : hHrtf->max_num_iterations = CRendBin_Combined_BRIR_max_num_iterations_32kHz; // Q0
319 75 : hHrtf->index_frequency_max_diffuse = CRendBin_Combined_BRIR_index_frequency_max_diffuse_32kHz; // Q0
320 75 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_Combined_BRIR_Q_latency_s_fx;
321 75 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_Combined_BRIR_inv_diffuse_weight_Q_32kHz_fx;
322 75 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_Combined_BRIR_coeff_Q_32kHz_fx;
323 : }
324 : ELSE
325 : {
326 0 : hHrtf->latency_s_fx = CRendBin_Combined_HRIR_latency_s_fx; // Q31
327 0 : hHrtf->max_num_iterations = CRendBin_Combined_HRIR_max_num_iterations_32kHz; // Q0
328 0 : hHrtf->index_frequency_max_diffuse = CRendBin_Combined_HRIR_index_frequency_max_diffuse_32kHz; // Q0
329 0 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_Combined_HRIR_Q_latency_s_fx;
330 0 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_Combined_HRIR_inv_diffuse_weight_Q_32kHz_fx;
331 0 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_Combined_HRIR_coeff_Q_32kHz_fx;
332 : }
333 75 : move32();
334 75 : move16();
335 75 : move16();
336 75 : move16();
337 75 : move16();
338 75 : move16();
339 :
340 225 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
341 : {
342 150 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
343 : {
344 150 : hHrtf->num_iterations_diffuse[j] = CRendBin_Combined_BRIR_num_iterations_diffuse_32kHz[j]; // Q0
345 150 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_Combined_BRIR_pIndex_frequency_max_diffuse_32kHz[j]; // Q0
346 :
347 150 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_Combined_BRIR_coeff_diffuse_re_32kHz_fx[j]; // Q31
348 150 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_Combined_BRIR_coeff_diffuse_im_32kHz_fx[j]; // Q31
349 : }
350 : ELSE
351 : {
352 0 : hHrtf->num_iterations_diffuse[j] = CRendBin_Combined_HRIR_num_iterations_diffuse_32kHz[j]; // Q0
353 0 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_Combined_HRIR_pIndex_frequency_max_diffuse_32kHz[j]; // Q0
354 :
355 0 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_Combined_HRIR_coeff_diffuse_re_32kHz_fx[j]; // Q31
356 0 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_Combined_HRIR_coeff_diffuse_im_32kHz_fx[j]; // Q31
357 : }
358 150 : move32();
359 150 : move32();
360 150 : move16();
361 150 : move16();
362 : }
363 : }
364 65 : ELSE IF( EQ_32( output_Fs, 16000 ) )
365 : {
366 65 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
367 : {
368 4 : hHrtf->latency_s_fx = CRendBin_Combined_BRIR_latency_s_fx; // Q31
369 4 : hHrtf->max_num_iterations = CRendBin_Combined_BRIR_max_num_iterations_16kHz;
370 4 : hHrtf->index_frequency_max_diffuse = CRendBin_Combined_BRIR_index_frequency_max_diffuse_16kHz;
371 4 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_Combined_BRIR_Q_latency_s_fx;
372 4 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_Combined_BRIR_inv_diffuse_weight_Q_16kHz_fx;
373 4 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_Combined_BRIR_coeff_Q_16kHz_fx;
374 : }
375 : ELSE
376 : {
377 61 : hHrtf->latency_s_fx = CRendBin_Combined_HRIR_latency_s_fx; // Q31
378 61 : hHrtf->max_num_iterations = CRendBin_Combined_HRIR_max_num_iterations_16kHz;
379 61 : hHrtf->index_frequency_max_diffuse = CRendBin_Combined_HRIR_index_frequency_max_diffuse_16kHz;
380 61 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_Combined_HRIR_Q_latency_s_fx;
381 61 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_Combined_HRIR_inv_diffuse_weight_Q_16kHz_fx;
382 61 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_Combined_HRIR_coeff_Q_16kHz_fx;
383 : }
384 65 : move32();
385 65 : move16();
386 65 : move16();
387 65 : move16();
388 65 : move16();
389 65 : move16();
390 :
391 195 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
392 : {
393 130 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
394 : {
395 8 : hHrtf->num_iterations_diffuse[j] = CRendBin_Combined_BRIR_num_iterations_diffuse_16kHz[j];
396 8 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_Combined_BRIR_pIndex_frequency_max_diffuse_16kHz[j];
397 :
398 8 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_Combined_BRIR_coeff_diffuse_re_16kHz_fx[j]; // Q31
399 8 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_Combined_BRIR_coeff_diffuse_im_16kHz_fx[j]; // Q31
400 : }
401 : ELSE
402 : {
403 122 : hHrtf->num_iterations_diffuse[j] = CRendBin_Combined_HRIR_num_iterations_diffuse_16kHz[j];
404 122 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_Combined_HRIR_pIndex_frequency_max_diffuse_16kHz[j];
405 :
406 122 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_Combined_HRIR_coeff_diffuse_re_16kHz_fx[j]; // Q31
407 122 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_Combined_HRIR_coeff_diffuse_im_16kHz_fx[j]; // Q31
408 : }
409 130 : move32();
410 130 : move32();
411 130 : move16();
412 130 : move16();
413 : }
414 : }
415 : ELSE
416 : {
417 0 : return IVAS_ERROR( IVAS_ERR_INVALID_SAMPLING_RATE, "Encountered Unsupported sampling rate in Crend" );
418 : }
419 :
420 4300 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
421 : {
422 3850 : IF( EQ_16( inConfig, IVAS_AUDIO_CONFIG_5_1 ) )
423 : {
424 810 : tmp = channelIndex_CICP6[i];
425 : }
426 3040 : ELSE IF( EQ_16( inConfig, IVAS_AUDIO_CONFIG_7_1 ) )
427 : {
428 63 : tmp = channelIndex_CICP12[i];
429 : }
430 2977 : ELSE IF( EQ_16( inConfig, IVAS_AUDIO_CONFIG_5_1_2 ) )
431 : {
432 112 : tmp = channelIndex_CICP14[i];
433 : }
434 2865 : ELSE IF( EQ_16( inConfig, IVAS_AUDIO_CONFIG_5_1_4 ) )
435 : {
436 126 : tmp = channelIndex_CICP16[i];
437 : }
438 2739 : ELSE IF( EQ_16( inConfig, IVAS_AUDIO_CONFIG_7_1_4 ) )
439 : {
440 2739 : tmp = channelIndex_CICP19[i];
441 : }
442 : ELSE
443 : {
444 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: Channel configuration not specified!\n\n" );
445 : }
446 3850 : move16();
447 :
448 3850 : IF( EQ_32( output_Fs, 48000 ) )
449 : {
450 8076 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
451 : {
452 5384 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
453 : {
454 4152 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_Combined_BRIR_inv_diffuse_weight_48kHz_fx[j][tmp];
455 4152 : hHrtf->num_iterations[i][j] = CRendBin_Combined_BRIR_num_iterations_48kHz[tmp][j];
456 4152 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_Combined_BRIR_pIndex_frequency_max_48kHz[tmp][j];
457 :
458 4152 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_Combined_BRIR_coeff_re_48kHz_fx[tmp][j]; // Q29
459 4152 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_Combined_BRIR_coeff_im_48kHz_fx[tmp][j]; // Q29
460 : }
461 : ELSE
462 : {
463 1232 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_Combined_HRIR_inv_diffuse_weight_48kHz_fx[j][tmp];
464 1232 : hHrtf->num_iterations[i][j] = CRendBin_Combined_HRIR_num_iterations_48kHz[tmp][j];
465 1232 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_Combined_HRIR_pIndex_frequency_max_48kHz[tmp][j];
466 :
467 1232 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_Combined_HRIR_coeff_re_48kHz_fx[tmp][j]; // Q29
468 1232 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_Combined_HRIR_coeff_im_48kHz_fx[tmp][j]; // Q29
469 : }
470 5384 : move32();
471 5384 : move32();
472 5384 : move16();
473 5384 : move16();
474 : }
475 : }
476 1158 : ELSE IF( EQ_32( output_Fs, 32000 ) )
477 : {
478 2475 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
479 : {
480 1650 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
481 : {
482 1650 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_Combined_BRIR_inv_diffuse_weight_32kHz_fx[j][tmp];
483 1650 : hHrtf->num_iterations[i][j] = CRendBin_Combined_BRIR_num_iterations_32kHz[tmp][j];
484 1650 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_Combined_BRIR_pIndex_frequency_max_32kHz[tmp][j];
485 :
486 1650 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_Combined_BRIR_coeff_re_32kHz_fx[tmp][j]; // Q29
487 1650 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_Combined_BRIR_coeff_im_32kHz_fx[tmp][j]; // Q29
488 : }
489 : ELSE
490 : {
491 0 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_Combined_HRIR_inv_diffuse_weight_32kHz_fx[j][tmp];
492 0 : hHrtf->num_iterations[i][j] = CRendBin_Combined_HRIR_num_iterations_32kHz[tmp][j];
493 0 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_Combined_HRIR_pIndex_frequency_max_32kHz[tmp][j];
494 :
495 0 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_Combined_HRIR_coeff_re_32kHz_fx[tmp][j]; // Q29
496 0 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_Combined_HRIR_coeff_im_32kHz_fx[tmp][j]; // Q29
497 : }
498 1650 : move32();
499 1650 : move32();
500 1650 : move16();
501 1650 : move16();
502 : }
503 : }
504 333 : ELSE IF( EQ_32( output_Fs, 16000 ) )
505 : {
506 999 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
507 : {
508 666 : IF( EQ_16( outConfig, IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR ) )
509 : {
510 56 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_Combined_BRIR_inv_diffuse_weight_16kHz_fx[j][tmp];
511 56 : hHrtf->num_iterations[i][j] = CRendBin_Combined_BRIR_num_iterations_16kHz[tmp][j];
512 56 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_Combined_BRIR_pIndex_frequency_max_16kHz[tmp][j];
513 :
514 56 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_Combined_BRIR_coeff_re_16kHz_fx[tmp][j]; // Q29
515 56 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_Combined_BRIR_coeff_im_16kHz_fx[tmp][j]; // Q29
516 : }
517 : ELSE
518 : {
519 610 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_Combined_HRIR_inv_diffuse_weight_16kHz_fx[j][tmp];
520 610 : hHrtf->num_iterations[i][j] = CRendBin_Combined_HRIR_num_iterations_16kHz[tmp][j];
521 610 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_Combined_HRIR_pIndex_frequency_max_16kHz[tmp][j];
522 :
523 610 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_Combined_HRIR_coeff_re_16kHz_fx[tmp][j]; // Q29
524 610 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_Combined_HRIR_coeff_im_16kHz_fx[tmp][j]; // Q29
525 : }
526 666 : move32();
527 666 : move32();
528 666 : move16();
529 666 : move16();
530 : }
531 : }
532 : ELSE
533 : {
534 0 : return IVAS_ERROR( IVAS_ERR_INVALID_SAMPLING_RATE, "Encountered Unsupported sampling rate in Crend" );
535 : }
536 : }
537 : }
538 25 : ELSE IF( EQ_16( inConfigType, IVAS_REND_AUDIO_CONFIG_TYPE_AMBISONICS ) )
539 : {
540 25 : IF( EQ_16( inConfig, IVAS_AUDIO_CONFIG_HOA3 ) )
541 : {
542 9 : IF( EQ_32( output_Fs, 48000 ) )
543 : {
544 9 : hHrtf->latency_s_fx = CRendBin_HOA3_HRIR_latency_s_fx; // Q31
545 9 : hHrtf->max_num_iterations = CRendBin_HOA3_HRIR_max_num_iterations_48kHz;
546 9 : hHrtf->index_frequency_max_diffuse = CRendBin_HOA3_HRIR_index_frequency_max_diffuse_48kHz;
547 9 : move32();
548 9 : move16();
549 9 : move16();
550 9 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_HOA3_HRIR_Q_latency_s_fx;
551 9 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_HOA3_HRIR_inv_diffuse_weight_Q_48kHz_fx;
552 9 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_HOA3_HRIR_coeff_Q_48kHz_fx;
553 9 : move16();
554 9 : move16();
555 9 : move16();
556 :
557 153 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
558 : {
559 432 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
560 : {
561 288 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_HOA3_HRIR_inv_diffuse_weight_48kHz_fx[j][i]; // Q15
562 288 : move16();
563 288 : hHrtf->num_iterations[i][j] = CRendBin_HOA3_HRIR_num_iterations_48kHz[i][j];
564 288 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_HOA3_HRIR_pIndex_frequency_max_48kHz[i][j];
565 :
566 288 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_HOA3_HRIR_coeff_re_48kHz_fx[i][j]; // Q29
567 288 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_HOA3_HRIR_coeff_im_48kHz_fx[i][j]; // Q29
568 288 : move32();
569 288 : move32();
570 288 : move16();
571 288 : move16();
572 : }
573 : }
574 27 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
575 : {
576 18 : hHrtf->num_iterations_diffuse[j] = CRendBin_HOA3_HRIR_num_iterations_diffuse_48kHz[j];
577 18 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_HOA3_HRIR_pIndex_frequency_max_diffuse_48kHz[j];
578 :
579 18 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_HOA3_HRIR_coeff_diffuse_re_48kHz_fx[j]; // Q31
580 18 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_HOA3_HRIR_coeff_diffuse_im_48kHz_fx[j]; // Q31
581 18 : move32();
582 18 : move32();
583 18 : move16();
584 18 : move16();
585 : }
586 : }
587 0 : ELSE IF( EQ_32( output_Fs, 32000 ) )
588 : {
589 0 : hHrtf->latency_s_fx = CRendBin_HOA3_HRIR_latency_s_fx; // Q31
590 0 : hHrtf->max_num_iterations = CRendBin_HOA3_HRIR_max_num_iterations_32kHz;
591 0 : hHrtf->index_frequency_max_diffuse = CRendBin_HOA3_HRIR_index_frequency_max_diffuse_32kHz;
592 0 : move32();
593 0 : move16();
594 0 : move16();
595 0 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_HOA3_HRIR_Q_latency_s_fx;
596 0 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_HOA3_HRIR_inv_diffuse_weight_Q_32kHz_fx;
597 0 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_HOA3_HRIR_coeff_Q_32kHz_fx;
598 0 : move16();
599 0 : move16();
600 0 : move16();
601 :
602 0 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
603 : {
604 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
605 : {
606 0 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_HOA3_HRIR_inv_diffuse_weight_32kHz_fx[j][i]; // Q15
607 0 : move16();
608 0 : hHrtf->num_iterations[i][j] = CRendBin_HOA3_HRIR_num_iterations_32kHz[i][j];
609 0 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_HOA3_HRIR_pIndex_frequency_max_32kHz[i][j];
610 :
611 0 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_HOA3_HRIR_coeff_re_32kHz_fx[i][j]; // Q29
612 0 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_HOA3_HRIR_coeff_im_32kHz_fx[i][j]; // Q29
613 0 : move32();
614 0 : move32();
615 0 : move16();
616 0 : move16();
617 : }
618 : }
619 :
620 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
621 : {
622 0 : hHrtf->num_iterations_diffuse[j] = CRendBin_HOA3_HRIR_num_iterations_diffuse_32kHz[j];
623 0 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_HOA3_HRIR_pIndex_frequency_max_diffuse_32kHz[j];
624 :
625 0 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_HOA3_HRIR_coeff_diffuse_re_32kHz_fx[j]; // Q31
626 0 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_HOA3_HRIR_coeff_diffuse_im_32kHz_fx[j]; // Q31
627 0 : move32();
628 0 : move32();
629 0 : move16();
630 0 : move16();
631 : }
632 : }
633 0 : ELSE IF( EQ_32( output_Fs, 16000 ) )
634 : {
635 0 : hHrtf->latency_s_fx = CRendBin_HOA3_HRIR_latency_s_fx; // Q31
636 0 : hHrtf->max_num_iterations = CRendBin_HOA3_HRIR_max_num_iterations_16kHz;
637 0 : hHrtf->index_frequency_max_diffuse = CRendBin_HOA3_HRIR_index_frequency_max_diffuse_16kHz;
638 0 : move32();
639 0 : move16();
640 0 : move16();
641 0 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_HOA3_HRIR_Q_latency_s_fx;
642 0 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_HOA3_HRIR_inv_diffuse_weight_Q_16kHz_fx;
643 0 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_HOA3_HRIR_coeff_Q_16kHz_fx;
644 0 : move16();
645 0 : move16();
646 0 : move16();
647 :
648 0 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
649 : {
650 :
651 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
652 : {
653 0 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_HOA3_HRIR_inv_diffuse_weight_16kHz_fx[j][i]; // Q15
654 0 : move16();
655 0 : hHrtf->num_iterations[i][j] = CRendBin_HOA3_HRIR_num_iterations_16kHz[i][j];
656 0 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_HOA3_HRIR_pIndex_frequency_max_16kHz[i][j];
657 :
658 0 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_HOA3_HRIR_coeff_re_16kHz_fx[i][j]; // Q29
659 0 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_HOA3_HRIR_coeff_im_16kHz_fx[i][j]; // Q29
660 0 : move32();
661 0 : move32();
662 0 : move16();
663 0 : move16();
664 : }
665 : }
666 :
667 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
668 : {
669 0 : hHrtf->num_iterations_diffuse[j] = CRendBin_HOA3_HRIR_num_iterations_diffuse_16kHz[j];
670 0 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_HOA3_HRIR_pIndex_frequency_max_diffuse_16kHz[j];
671 :
672 0 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_HOA3_HRIR_coeff_diffuse_re_16kHz_fx[j]; // Q31
673 0 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_HOA3_HRIR_coeff_diffuse_im_16kHz_fx[j]; // Q31
674 0 : move32();
675 0 : move32();
676 0 : move16();
677 0 : move16();
678 : }
679 : }
680 : ELSE
681 : {
682 0 : return IVAS_ERROR( IVAS_ERR_INVALID_SAMPLING_RATE, "Encountered Unsupported sampling rate in Crend" );
683 : }
684 : }
685 16 : ELSE IF( EQ_16( inConfig, IVAS_AUDIO_CONFIG_HOA2 ) )
686 : {
687 8 : IF( EQ_32( output_Fs, 48000 ) )
688 : {
689 8 : hHrtf->latency_s_fx = CRendBin_HOA2_HRIR_latency_s_fx; // Q31
690 8 : hHrtf->max_num_iterations = CRendBin_HOA2_HRIR_max_num_iterations_48kHz;
691 8 : hHrtf->index_frequency_max_diffuse = CRendBin_HOA2_HRIR_index_frequency_max_diffuse_48kHz;
692 8 : move32();
693 8 : move16();
694 8 : move16();
695 8 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_HOA2_HRIR_Q_latency_s_fx;
696 8 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_HOA2_HRIR_inv_diffuse_weight_Q_48kHz_fx;
697 8 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_HOA2_HRIR_coeff_Q_48kHz_fx;
698 8 : move16();
699 8 : move16();
700 8 : move16();
701 :
702 80 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
703 : {
704 216 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
705 : {
706 144 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_HOA2_HRIR_inv_diffuse_weight_48kHz_fx[j][i]; // Q15
707 144 : move16();
708 144 : hHrtf->num_iterations[i][j] = CRendBin_HOA2_HRIR_num_iterations_48kHz[i][j];
709 144 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_HOA2_HRIR_pIndex_frequency_max_48kHz[i][j];
710 :
711 144 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_HOA2_HRIR_coeff_re_48kHz_fx[i][j]; // Q29
712 144 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_HOA2_HRIR_coeff_im_48kHz_fx[i][j]; // Q29
713 144 : move32();
714 144 : move32();
715 144 : move16();
716 144 : move16();
717 : }
718 : }
719 24 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
720 : {
721 16 : hHrtf->num_iterations_diffuse[j] = CRendBin_HOA2_HRIR_num_iterations_diffuse_48kHz[j];
722 16 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_HOA2_HRIR_pIndex_frequency_max_diffuse_48kHz[j];
723 :
724 16 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_HOA2_HRIR_coeff_diffuse_re_48kHz_fx[j]; // Q31
725 16 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_HOA2_HRIR_coeff_diffuse_im_48kHz_fx[j]; // Q31
726 16 : move32();
727 16 : move32();
728 16 : move16();
729 16 : move16();
730 : }
731 : }
732 0 : ELSE IF( EQ_32( output_Fs, 32000 ) )
733 : {
734 0 : hHrtf->latency_s_fx = CRendBin_HOA2_HRIR_latency_s_fx; // Q31
735 0 : hHrtf->max_num_iterations = CRendBin_HOA2_HRIR_max_num_iterations_32kHz;
736 0 : hHrtf->index_frequency_max_diffuse = CRendBin_HOA2_HRIR_index_frequency_max_diffuse_32kHz;
737 0 : move32();
738 0 : move16();
739 0 : move16();
740 0 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_HOA2_HRIR_Q_latency_s_fx;
741 0 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_HOA2_HRIR_inv_diffuse_weight_Q_32kHz_fx;
742 0 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_HOA2_HRIR_coeff_Q_32kHz_fx;
743 0 : move16();
744 0 : move16();
745 0 : move16();
746 :
747 0 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
748 : {
749 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
750 : {
751 0 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_HOA2_HRIR_inv_diffuse_weight_32kHz_fx[j][i]; // Q15
752 0 : move16();
753 0 : hHrtf->num_iterations[i][j] = CRendBin_HOA2_HRIR_num_iterations_32kHz[i][j];
754 0 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_HOA2_HRIR_pIndex_frequency_max_32kHz[i][j];
755 :
756 0 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_HOA2_HRIR_coeff_re_32kHz_fx[i][j]; // Q29
757 0 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_HOA2_HRIR_coeff_im_32kHz_fx[i][j]; // Q29
758 0 : move32();
759 0 : move32();
760 0 : move16();
761 0 : move16();
762 : }
763 : }
764 :
765 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
766 : {
767 0 : hHrtf->num_iterations_diffuse[j] = CRendBin_HOA2_HRIR_num_iterations_diffuse_32kHz[j];
768 0 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_HOA2_HRIR_pIndex_frequency_max_diffuse_32kHz[j];
769 :
770 0 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_HOA2_HRIR_coeff_diffuse_re_32kHz_fx[j]; // Q31
771 0 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_HOA2_HRIR_coeff_diffuse_im_32kHz_fx[j]; // Q31
772 0 : move32();
773 0 : move32();
774 0 : move16();
775 0 : move16();
776 : }
777 : }
778 0 : ELSE IF( EQ_32( output_Fs, 16000 ) )
779 : {
780 0 : hHrtf->latency_s_fx = CRendBin_HOA2_HRIR_latency_s_fx; // Q31
781 0 : hHrtf->max_num_iterations = CRendBin_HOA2_HRIR_max_num_iterations_16kHz;
782 0 : hHrtf->index_frequency_max_diffuse = CRendBin_HOA2_HRIR_index_frequency_max_diffuse_16kHz;
783 0 : move32();
784 0 : move16();
785 0 : move16();
786 0 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_HOA2_HRIR_Q_latency_s_fx;
787 0 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_HOA2_HRIR_inv_diffuse_weight_Q_16kHz_fx;
788 0 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_HOA2_HRIR_coeff_Q_16kHz_fx;
789 0 : move16();
790 0 : move16();
791 0 : move16();
792 :
793 0 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
794 : {
795 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
796 : {
797 0 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_HOA2_HRIR_inv_diffuse_weight_16kHz_fx[j][i]; // Q15
798 0 : move16();
799 0 : hHrtf->num_iterations[i][j] = CRendBin_HOA2_HRIR_num_iterations_16kHz[i][j];
800 0 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_HOA2_HRIR_pIndex_frequency_max_16kHz[i][j];
801 :
802 0 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_HOA2_HRIR_coeff_re_16kHz_fx[i][j]; // Q29
803 0 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_HOA2_HRIR_coeff_im_16kHz_fx[i][j]; // Q29
804 0 : move32();
805 0 : move32();
806 0 : move16();
807 0 : move16();
808 : }
809 : }
810 :
811 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
812 : {
813 0 : hHrtf->num_iterations_diffuse[j] = CRendBin_HOA2_HRIR_num_iterations_diffuse_16kHz[j];
814 0 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_HOA2_HRIR_pIndex_frequency_max_diffuse_16kHz[j];
815 :
816 0 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_HOA2_HRIR_coeff_diffuse_re_16kHz_fx[j]; // Q31
817 0 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_HOA2_HRIR_coeff_diffuse_im_16kHz_fx[j]; // Q31
818 0 : move32();
819 0 : move32();
820 0 : move16();
821 0 : move16();
822 : }
823 : }
824 : ELSE
825 : {
826 0 : return IVAS_ERROR( IVAS_ERR_INVALID_SAMPLING_RATE, "Encountered Unsupported sampling rate in Crend" );
827 : }
828 : }
829 8 : ELSE IF( EQ_16( inConfig, IVAS_AUDIO_CONFIG_FOA ) )
830 : {
831 8 : IF( EQ_32( output_Fs, 48000 ) )
832 : {
833 8 : hHrtf->latency_s_fx = CRendBin_FOA_HRIR_latency_s_fx; // Q31
834 8 : hHrtf->max_num_iterations = CRendBin_FOA_HRIR_max_num_iterations_48kHz;
835 8 : hHrtf->index_frequency_max_diffuse = CRendBin_FOA_HRIR_index_frequency_max_diffuse_48kHz;
836 8 : move32();
837 8 : move16();
838 8 : move16();
839 8 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_FOA_HRIR_Q_latency_s_fx;
840 8 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_FOA_HRIR_inv_diffuse_weight_Q_48kHz_fx;
841 8 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_FOA_HRIR_coeff_Q_48kHz_fx;
842 8 : move16();
843 8 : move16();
844 8 : move16();
845 :
846 40 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
847 : {
848 96 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
849 : {
850 64 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_FOA_HRIR_inv_diffuse_weight_48kHz_fx[j][i]; // Q15
851 64 : move16();
852 64 : hHrtf->num_iterations[i][j] = CRendBin_FOA_HRIR_num_iterations_48kHz[i][j];
853 64 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_FOA_HRIR_pIndex_frequency_max_48kHz[i][j];
854 :
855 64 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_FOA_HRIR_coeff_re_48kHz_fx[i][j]; // Q29
856 64 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_FOA_HRIR_coeff_im_48kHz_fx[i][j]; // Q29
857 64 : move32();
858 64 : move32();
859 64 : move16();
860 64 : move16();
861 : }
862 : }
863 24 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
864 : {
865 16 : hHrtf->num_iterations_diffuse[j] = CRendBin_FOA_HRIR_num_iterations_diffuse_48kHz[j];
866 16 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_FOA_HRIR_pIndex_frequency_max_diffuse_48kHz[j];
867 :
868 16 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_FOA_HRIR_coeff_diffuse_re_48kHz_fx[j]; // Q31
869 16 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_FOA_HRIR_coeff_diffuse_im_48kHz_fx[j]; // Q31
870 16 : move32();
871 16 : move32();
872 16 : move16();
873 16 : move16();
874 : }
875 : }
876 0 : ELSE IF( EQ_32( output_Fs, 32000 ) )
877 : {
878 0 : hHrtf->latency_s_fx = CRendBin_FOA_HRIR_latency_s_fx; // Q31
879 0 : hHrtf->max_num_iterations = CRendBin_FOA_HRIR_max_num_iterations_32kHz;
880 0 : hHrtf->index_frequency_max_diffuse = CRendBin_FOA_HRIR_index_frequency_max_diffuse_32kHz;
881 0 : move32();
882 0 : move16();
883 0 : move16();
884 0 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_FOA_HRIR_Q_latency_s_fx;
885 0 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_FOA_HRIR_inv_diffuse_weight_Q_32kHz_fx;
886 0 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_FOA_HRIR_coeff_Q_32kHz_fx;
887 0 : move16();
888 0 : move16();
889 0 : move16();
890 :
891 0 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
892 : {
893 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
894 : {
895 0 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_FOA_HRIR_inv_diffuse_weight_32kHz_fx[j][i]; // Q15
896 0 : move16();
897 0 : hHrtf->num_iterations[i][j] = CRendBin_FOA_HRIR_num_iterations_32kHz[i][j];
898 0 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_FOA_HRIR_pIndex_frequency_max_32kHz[i][j];
899 :
900 0 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_FOA_HRIR_coeff_re_32kHz_fx[i][j]; // Q29
901 0 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_FOA_HRIR_coeff_im_32kHz_fx[i][j]; // Q29
902 0 : move32();
903 0 : move32();
904 0 : move16();
905 0 : move16();
906 : }
907 : }
908 :
909 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
910 : {
911 0 : hHrtf->num_iterations_diffuse[j] = CRendBin_FOA_HRIR_num_iterations_diffuse_32kHz[j];
912 0 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_FOA_HRIR_pIndex_frequency_max_diffuse_32kHz[j];
913 :
914 0 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_FOA_HRIR_coeff_diffuse_re_32kHz_fx[j]; // Q31
915 0 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_FOA_HRIR_coeff_diffuse_im_32kHz_fx[j]; // Q31
916 0 : move32();
917 0 : move32();
918 0 : move16();
919 0 : move16();
920 : }
921 : }
922 0 : ELSE IF( EQ_32( output_Fs, 16000 ) )
923 : {
924 0 : hHrtf->latency_s_fx = CRendBin_FOA_HRIR_latency_s_fx; // Q31
925 0 : hHrtf->max_num_iterations = CRendBin_FOA_HRIR_max_num_iterations_16kHz;
926 0 : hHrtf->index_frequency_max_diffuse = CRendBin_FOA_HRIR_index_frequency_max_diffuse_16kHz;
927 0 : move32();
928 0 : move16();
929 0 : move16();
930 0 : hHrtf->factor_Q_latency_s_fx = Q31 - CRendBin_FOA_HRIR_Q_latency_s_fx;
931 0 : hHrtf->factor_Q_inv_diffuse_weight = Q15 - CRendBin_FOA_HRIR_inv_diffuse_weight_Q_16kHz_fx;
932 0 : hHrtf->factor_Q_pOut_to_bin = Q15 - CRendBin_FOA_HRIR_coeff_Q_16kHz_fx;
933 0 : move16();
934 0 : move16();
935 0 : move16();
936 :
937 0 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
938 : {
939 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
940 : {
941 0 : hHrtf->inv_diffuse_weight_fx[j][i] = CRendBin_FOA_HRIR_inv_diffuse_weight_16kHz_fx[j][i]; // Q15
942 0 : move16();
943 0 : hHrtf->num_iterations[i][j] = CRendBin_FOA_HRIR_num_iterations_16kHz[i][j];
944 0 : hHrtf->pIndex_frequency_max[i][j] = CRendBin_FOA_HRIR_pIndex_frequency_max_16kHz[i][j];
945 :
946 0 : hHrtf->pOut_to_bin_re_fx[i][j] = CRendBin_FOA_HRIR_coeff_re_16kHz_fx[i][j]; // Q29
947 0 : hHrtf->pOut_to_bin_im_fx[i][j] = CRendBin_FOA_HRIR_coeff_im_16kHz_fx[i][j]; // Q29
948 0 : move32();
949 0 : move32();
950 0 : move16();
951 0 : move16();
952 : }
953 : }
954 :
955 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
956 : {
957 0 : hHrtf->num_iterations_diffuse[j] = CRendBin_FOA_HRIR_num_iterations_diffuse_16kHz[j];
958 0 : hHrtf->pIndex_frequency_max_diffuse[j] = CRendBin_FOA_HRIR_pIndex_frequency_max_diffuse_16kHz[j];
959 :
960 0 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = CRendBin_FOA_HRIR_coeff_diffuse_re_16kHz_fx[j]; // Q31
961 0 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = CRendBin_FOA_HRIR_coeff_diffuse_im_16kHz_fx[j]; // Q31
962 0 : move32();
963 0 : move32();
964 0 : move16();
965 0 : move16();
966 : }
967 : }
968 : ELSE
969 : {
970 0 : return IVAS_ERROR( IVAS_ERR_INVALID_SAMPLING_RATE, "Encountered Unsupported sampling rate in Crend" );
971 : }
972 : }
973 : ELSE
974 : {
975 0 : return IVAS_ERROR( IVAS_ERR_INVALID_INPUT_FORMAT, "Encountered unsupported input config in Crend" );
976 : }
977 : }
978 : ELSE
979 : {
980 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL, "Unsupported renderer type in Crend" );
981 : }
982 : }
983 : ELSE
984 : {
985 28 : IF( inConfigType == IVAS_REND_AUDIO_CONFIG_TYPE_CHANNEL_BASED )
986 : {
987 28 : hHrtf->max_num_ir = sub( hHrtf->max_num_ir, 1 ); /* subtract LFE */
988 28 : move16();
989 28 : hHrtf->gain_lfe_fx = GAIN_LFE_FX;
990 28 : move16();
991 : }
992 :
993 28 : IF( EQ_16( ext_rend_flag, 1 ) )
994 : {
995 0 : IF( hHrtfCrend == NULL )
996 : {
997 0 : return IVAS_ERROR( IVAS_ERR_UNEXPECTED_NULL_POINTER, "Invalid function parameters " );
998 : }
999 0 : hHrtf->latency_s_fx = hHrtfCrend->latency_s_fx;
1000 0 : hHrtf->max_num_iterations = hHrtfCrend->max_num_iterations;
1001 0 : hHrtf->index_frequency_max_diffuse = hHrtfCrend->index_frequency_max_diffuse;
1002 0 : move16();
1003 0 : move16();
1004 0 : move16();
1005 0 : hHrtf->factor_Q_inv_diffuse_weight = hHrtfCrend->factor_Q_inv_diffuse_weight;
1006 0 : hHrtf->factor_Q_latency_s_fx = hHrtfCrend->factor_Q_latency_s_fx;
1007 0 : hHrtf->factor_Q_pOut_to_bin = hHrtfCrend->factor_Q_pOut_to_bin;
1008 0 : move16();
1009 0 : move16();
1010 0 : move16();
1011 :
1012 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
1013 : {
1014 0 : hHrtf->num_iterations_diffuse[j] = hHrtfCrend->num_iterations_diffuse[j];
1015 0 : hHrtf->pIndex_frequency_max_diffuse[j] = hHrtfCrend->pIndex_frequency_max_diffuse[j];
1016 0 : hHrtf->pOut_to_bin_diffuse_re_fx[j] = hHrtfCrend->pOut_to_bin_diffuse_re_fx[j];
1017 0 : hHrtf->pOut_to_bin_diffuse_im_fx[j] = hHrtfCrend->pOut_to_bin_diffuse_im_fx[j];
1018 : }
1019 : }
1020 :
1021 28 : test();
1022 28 : IF( EQ_32( inConfig, IVAS_AUDIO_CONFIG_7_1 ) && EQ_16( ext_rend_flag, 0 ) )
1023 : {
1024 : /* hack to enable pointers swapping - needed when indexes of 'channelIndex_CICPx[]' are not in increasing order */
1025 0 : FOR( i = 5; i < hHrtf->max_num_ir; i++ )
1026 : {
1027 0 : tmp = channelIndex_CICP12[i];
1028 0 : tmp2 = channelIndex_CICP14[i];
1029 0 : move16();
1030 0 : move16();
1031 :
1032 0 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
1033 : {
1034 0 : hHrtf->inv_diffuse_weight_fx[j][tmp2] = hHrtfCrend->inv_diffuse_weight_fx[j][tmp];
1035 0 : hHrtf->num_iterations[tmp2][j] = hHrtfCrend->num_iterations[tmp][j];
1036 0 : hHrtf->pIndex_frequency_max[tmp2][j] = hHrtfCrend->pIndex_frequency_max[tmp][j];
1037 0 : hHrtf->pOut_to_bin_re_fx[tmp2][j] = hHrtfCrend->pOut_to_bin_re_fx[tmp][j];
1038 0 : hHrtf->pOut_to_bin_im_fx[tmp2][j] = hHrtfCrend->pOut_to_bin_im_fx[tmp][j];
1039 : }
1040 : }
1041 : }
1042 :
1043 332 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
1044 : {
1045 304 : IF( EQ_32( inConfig, IVAS_AUDIO_CONFIG_5_1 ) )
1046 : {
1047 0 : tmp = channelIndex_CICP6[i];
1048 0 : move16();
1049 : }
1050 304 : ELSE IF( EQ_32( inConfig, IVAS_AUDIO_CONFIG_7_1 ) )
1051 : {
1052 0 : IF( EQ_16( ext_rend_flag, 0 ) )
1053 : {
1054 0 : tmp = channelIndex_CICP14[i];
1055 0 : move16();
1056 : }
1057 : ELSE
1058 : {
1059 0 : tmp = channelIndex_CICP12[i];
1060 0 : move16();
1061 : }
1062 : }
1063 304 : ELSE IF( EQ_32( inConfig, IVAS_AUDIO_CONFIG_5_1_2 ) )
1064 : {
1065 0 : tmp = channelIndex_CICP14[i];
1066 0 : move16();
1067 : }
1068 304 : ELSE IF( EQ_32( inConfig, IVAS_AUDIO_CONFIG_5_1_4 ) )
1069 : {
1070 18 : tmp = channelIndex_CICP16[i];
1071 18 : move16();
1072 : }
1073 286 : ELSE IF( EQ_32( inConfig, IVAS_AUDIO_CONFIG_7_1_4 ) )
1074 : {
1075 286 : tmp = channelIndex_CICP19[i];
1076 286 : move16();
1077 : }
1078 0 : ELSE IF( EQ_32( inConfigType, IVAS_REND_AUDIO_CONFIG_TYPE_AMBISONICS ) )
1079 : {
1080 0 : tmp = i;
1081 0 : move16();
1082 : }
1083 : ELSE
1084 : {
1085 0 : return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error: Channel configuration not specified!\n\n" );
1086 : }
1087 :
1088 912 : FOR( j = 0; j < BINAURAL_CHANNELS; j++ )
1089 : {
1090 608 : hHrtf->inv_diffuse_weight_fx[j][i] = hHrtfCrend->inv_diffuse_weight_fx[j][tmp];
1091 608 : hHrtf->num_iterations[i][j] = hHrtfCrend->num_iterations[tmp][j];
1092 :
1093 608 : IF( ext_rend_flag == 0 )
1094 : {
1095 : /* in case of HRTF handle reuse, swap the pointers for correct deallocation at the exit */
1096 : #define WMC_TOOL_SKIP
1097 608 : swap( hHrtf->pIndex_frequency_max[i][j], hHrtf->pIndex_frequency_max[tmp][j], const Word16 * );
1098 : MOVE( 3 );
1099 608 : swap( hHrtf->pOut_to_bin_re_fx[i][j], hHrtf->pOut_to_bin_re_fx[tmp][j], const Word16 * );
1100 : MOVE( 3 );
1101 608 : swap( hHrtf->pOut_to_bin_im_fx[i][j], hHrtf->pOut_to_bin_im_fx[tmp][j], const Word16 * );
1102 : MOVE( 3 );
1103 : #undef WMC_TOOL_SKIP
1104 : }
1105 : ELSE
1106 : {
1107 0 : hHrtf->pIndex_frequency_max[i][j] = hHrtfCrend->pIndex_frequency_max[tmp][j];
1108 0 : hHrtf->pOut_to_bin_re_fx[i][j] = hHrtfCrend->pOut_to_bin_re_fx[tmp][j];
1109 0 : hHrtf->pOut_to_bin_im_fx[i][j] = hHrtfCrend->pOut_to_bin_im_fx[tmp][j];
1110 : }
1111 : }
1112 : }
1113 : }
1114 :
1115 503 : hHrtf->same_inv_diffuse_weight = 1;
1116 4905 : for ( i = 0; i < hHrtf->max_num_ir; i++ )
1117 : {
1118 4402 : if ( outConfig == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR )
1119 : {
1120 3147 : if ( hHrtf->inv_diffuse_weight_fx[0][i] != hHrtf->inv_diffuse_weight_fx[1][i] )
1121 : {
1122 0 : hHrtf->same_inv_diffuse_weight = 0;
1123 0 : break;
1124 : }
1125 : }
1126 : }
1127 :
1128 503 : pCrend->hHrtfCrend = hHrtf;
1129 :
1130 503 : return IVAS_ERR_OK;
1131 : }
1132 :
1133 : /*-------------------------------------------------------------------------
1134 : * ivas_shoebox_data_init()
1135 : *
1136 : * Initialize shoebox_data_t handle
1137 : *------------------------------------------------------------------------*/
1138 :
1139 16 : static ivas_error ivas_shoebox_data_init(
1140 : shoebox_data_t *hShoeboxData /* i/o: shoebox_data_t handle */
1141 : )
1142 : {
1143 : Word16 i;
1144 :
1145 16 : IF( hShoeboxData == NULL )
1146 : {
1147 0 : return IVAS_ERR_WRONG_PARAMS;
1148 : }
1149 :
1150 2416 : FOR( i = 0; i < 150; i++ )
1151 : {
1152 2400 : hShoeboxData->data_fx[i] = 0;
1153 2400 : move32();
1154 : }
1155 32 : FOR( i = 0; i < 1; i++ )
1156 : {
1157 16 : hShoeboxData->size[i] = 0;
1158 16 : move16();
1159 : }
1160 16 : return IVAS_ERR_OK;
1161 : }
1162 :
1163 : /*-------------------------------------------------------------------------
1164 : * ivas_shoebox_output_init()
1165 : *
1166 : * Initialize shoebox_output_t handle
1167 : *------------------------------------------------------------------------*/
1168 4 : static ivas_error ivas_shoebox_output_init(
1169 : shoebox_output_t *hShoeboxOutput /* i/o: shoebox_output_t handle */
1170 : )
1171 : {
1172 : ivas_error error;
1173 :
1174 4 : IF( hShoeboxOutput == NULL )
1175 : {
1176 0 : return IVAS_ERR_WRONG_PARAMS;
1177 : }
1178 :
1179 4 : hShoeboxOutput->n_sources = 0;
1180 4 : hShoeboxOutput->n_ref = 0;
1181 4 : move16();
1182 4 : move16();
1183 :
1184 4 : IF( NE_32( ( error = ivas_shoebox_data_init( &hShoeboxOutput->times ) ), IVAS_ERR_OK ) )
1185 : {
1186 0 : return error;
1187 : }
1188 :
1189 4 : IF( NE_32( ( error = ivas_shoebox_data_init( &hShoeboxOutput->gains ) ), IVAS_ERR_OK ) )
1190 : {
1191 0 : return error;
1192 : }
1193 :
1194 4 : IF( NE_32( ( error = ivas_shoebox_data_init( &hShoeboxOutput->az_angle ) ), IVAS_ERR_OK ) )
1195 : {
1196 0 : return error;
1197 : }
1198 :
1199 4 : IF( NE_32( ( error = ivas_shoebox_data_init( &hShoeboxOutput->el_angle ) ), IVAS_ERR_OK ) )
1200 : {
1201 0 : return error;
1202 : }
1203 :
1204 4 : return IVAS_ERR_OK;
1205 : }
1206 :
1207 :
1208 : /*-------------------------------------------------------------------------
1209 : * ivas_shoebox_config_init()
1210 : *
1211 : * Initialize shoebox_config_t handle
1212 : *------------------------------------------------------------------------*/
1213 :
1214 4 : static ivas_error ivas_shoebox_config_init_params(
1215 : shoebox_config_t *hShoeboxConfig /* i/o: shoebox_config_t handle */
1216 : )
1217 : {
1218 : Word16 i;
1219 :
1220 4 : IF( hShoeboxConfig == NULL )
1221 : {
1222 0 : return IVAS_ERR_WRONG_PARAMS;
1223 : }
1224 :
1225 4 : hShoeboxConfig->room_L_fx = 0;
1226 4 : hShoeboxConfig->room_W_fx = 0;
1227 4 : hShoeboxConfig->room_H_fx = 0;
1228 4 : move32();
1229 4 : move32();
1230 4 : move32();
1231 28 : FOR( i = 0; i < IVAS_ROOM_ABS_COEFF; i++ )
1232 : {
1233 24 : hShoeboxConfig->abs_coeff_fx[i] = 0;
1234 24 : move32();
1235 : }
1236 16 : FOR( i = 0; i < 3; i++ )
1237 : {
1238 12 : hShoeboxConfig->list_orig_fx[i] = 0;
1239 12 : move32();
1240 : }
1241 4 : return IVAS_ERR_OK;
1242 : }
1243 :
1244 :
1245 : /*-------------------------------------------------------------------------
1246 : * ivas_shoebox_obj_init()
1247 : *
1248 : * Initialize shoebox_obj_t handle
1249 : *------------------------------------------------------------------------*/
1250 :
1251 4 : static ivas_error ivas_shoebox_obj_init(
1252 : shoebox_obj_t *hShoeboxObj /* i/o: shoebox_obj_t handle */
1253 : )
1254 : {
1255 : Word16 i;
1256 : ivas_error error;
1257 :
1258 4 : IF( hShoeboxObj == NULL )
1259 : {
1260 0 : return IVAS_ERR_WRONG_PARAMS;
1261 : }
1262 :
1263 4 : hShoeboxObj->isCartesian = 0;
1264 4 : hShoeboxObj->isRelative = 0;
1265 4 : hShoeboxObj->isZHeight = 0;
1266 4 : hShoeboxObj->isRadians = 0;
1267 4 : hShoeboxObj->MAX_SOURCES = 0;
1268 4 : hShoeboxObj->max_bands = 0;
1269 4 : hShoeboxObj->REF_ORDER = 0;
1270 4 : move16();
1271 4 : move16();
1272 4 : move16();
1273 4 : move16();
1274 4 : move16();
1275 4 : move16();
1276 4 : move16();
1277 304 : FOR( i = 0; i < 75; i++ )
1278 : {
1279 300 : hShoeboxObj->src_pos_fx[i] = 0;
1280 300 : move32();
1281 : }
1282 104 : FOR( i = 0; i < 25; i++ )
1283 : {
1284 100 : hShoeboxObj->src_dist_fx[i] = 0;
1285 100 : move32();
1286 : }
1287 16 : FOR( i = 0; i < 3; i++ )
1288 : {
1289 12 : hShoeboxObj->list_pos_fx[i] = 0;
1290 12 : move32();
1291 : }
1292 :
1293 4 : hShoeboxObj->nSrc = 0;
1294 4 : hShoeboxObj->radius_fx = 0;
1295 4 : hShoeboxObj->min_wall_dist_fx = 0;
1296 4 : hShoeboxObj->soundspeed_fx = 0;
1297 4 : hShoeboxObj->air_coeff_fx = 0;
1298 4 : move16();
1299 4 : move32();
1300 4 : move32();
1301 4 : move32();
1302 4 : move32();
1303 :
1304 4 : IF( NE_32( ( error = ivas_shoebox_config_init_params( &hShoeboxObj->cal ) ), IVAS_ERR_OK ) )
1305 : {
1306 0 : return error;
1307 : }
1308 :
1309 4 : return IVAS_ERR_OK;
1310 : }
1311 :
1312 :
1313 : /*-------------------------------------------------------------------------
1314 : * ivas_er_init_handle()
1315 : *
1316 : * Initialize early reflections handle
1317 : *------------------------------------------------------------------------*/
1318 :
1319 4 : static ivas_error ivas_er_init_handle(
1320 : er_struct_t *reflections /* i/o: early reflections handle */
1321 : )
1322 : {
1323 : Word16 i;
1324 : ivas_error error;
1325 4 : IF( reflections == NULL )
1326 : {
1327 0 : return IVAS_ERR_WRONG_PARAMS;
1328 : }
1329 4 : reflections->audio_config = IVAS_AUDIO_CONFIG_INVALID;
1330 4 : reflections->use_er = 0;
1331 4 : reflections->is_ready = 0;
1332 4 : reflections->circ_len = 0;
1333 4 : reflections->circ_insert = 0;
1334 4 : reflections->n_total_reflections = 0;
1335 4 : reflections->is_cartesian = 0;
1336 4 : reflections->is_relative = 0;
1337 4 : reflections->max_frame_size = 0;
1338 4 : reflections->output_Fs_fx = 0;
1339 4 : move16();
1340 4 : move16();
1341 4 : move16();
1342 4 : move16();
1343 4 : move16();
1344 4 : move16();
1345 4 : move16();
1346 4 : move32();
1347 4 : move32();
1348 4 : move32();
1349 304 : FOR( i = 0; i < 75; i++ )
1350 : {
1351 300 : reflections->source_positions_fx[i] = 0;
1352 300 : move16();
1353 : }
1354 16 : FOR( i = 0; i < 3; i++ )
1355 : {
1356 12 : reflections->user_origin_fx[i] = 0;
1357 12 : move32();
1358 12 : if ( EQ_16( i, 2 ) )
1359 : {
1360 4 : reflections->user_origin_fx[i] = ER_LIST_HEIGHT_FX; // Q22
1361 4 : move32();
1362 : }
1363 : }
1364 4 : reflections->circ_buffers = NULL;
1365 4 : reflections->closest_ch_idx = NULL;
1366 :
1367 4 : IF( NE_32( ( error = ivas_shoebox_output_init( &reflections->shoebox_data ) ), IVAS_ERR_OK ) )
1368 : {
1369 0 : return error;
1370 : }
1371 4 : IF( NE_32( ( error = ivas_shoebox_obj_init( &reflections->shoebox_lib ) ), IVAS_ERR_OK ) )
1372 : {
1373 0 : return error;
1374 : }
1375 :
1376 4 : return IVAS_ERR_OK;
1377 : }
1378 :
1379 :
1380 : /*-------------------------------------------------------------------------
1381 : * ivas_rend_initCrendWrapper()
1382 : *
1383 : * Allocate and initialize crend renderer handle
1384 : *------------------------------------------------------------------------*/
1385 :
1386 503 : ivas_error ivas_rend_initCrendWrapper_fx(
1387 : CREND_WRAPPER_HANDLE *pCrend,
1388 : const Word16 num_poses )
1389 : {
1390 : Word16 i;
1391 : CREND_HANDLE hCrend;
1392 : Word16 pos_idx;
1393 :
1394 503 : IF( pCrend == NULL )
1395 : {
1396 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for renderer handle" );
1397 : }
1398 :
1399 503 : IF( ( *pCrend = (CREND_WRAPPER_HANDLE) malloc( sizeof( CREND_WRAPPER ) ) ) == NULL )
1400 : {
1401 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend Wrapper\n" );
1402 : }
1403 :
1404 503 : ( *pCrend )->binaural_latency_ns = 0;
1405 503 : move32();
1406 503 : ( *pCrend )->hHrtfCrend = NULL;
1407 503 : ( *pCrend )->io_qfactor = 0;
1408 503 : move16();
1409 503 : ( *pCrend )->p_io_qfactor = &( *pCrend )->io_qfactor;
1410 :
1411 4527 : FOR( pos_idx = 0; pos_idx < MAX_HEAD_ROT_POSES; pos_idx++ )
1412 : {
1413 4024 : ( *pCrend )->hCrend[pos_idx] = NULL;
1414 : }
1415 :
1416 1006 : FOR( pos_idx = 0; pos_idx < num_poses; pos_idx++ )
1417 : {
1418 503 : hCrend = NULL;
1419 503 : IF( ( hCrend = (CREND_HANDLE) malloc( sizeof( CREND_DATA ) ) ) == NULL )
1420 : {
1421 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for renderer handle" );
1422 : }
1423 :
1424 503 : hCrend->lfe_delay_line_fx = NULL;
1425 :
1426 8551 : FOR( i = 0; i < MAX_INTERN_CHANNELS; i++ )
1427 : {
1428 8048 : hCrend->freq_buffer_re_fx[i] = NULL;
1429 8048 : hCrend->freq_buffer_im_fx[i] = NULL;
1430 : }
1431 :
1432 1509 : FOR( i = 0; i < BINAURAL_CHANNELS; i++ )
1433 : {
1434 1006 : hCrend->prev_out_buffer_fx[i] = NULL;
1435 : }
1436 :
1437 503 : hCrend->hTrack = NULL;
1438 503 : hCrend->freq_buffer_re_diffuse_fx[0] = NULL;
1439 503 : hCrend->freq_buffer_re_diffuse_fx[1] = NULL;
1440 503 : hCrend->freq_buffer_im_diffuse_fx[0] = NULL;
1441 503 : hCrend->freq_buffer_im_diffuse_fx[1] = NULL;
1442 503 : hCrend->hReverb = NULL;
1443 503 : hCrend->reflections = NULL;
1444 503 : hCrend->delay_line_rw_index = 0;
1445 503 : hCrend->diffuse_delay_line_rw_index = 0;
1446 503 : move16();
1447 503 : move16();
1448 503 : hCrend->m_fYaw_fx = 0;
1449 503 : hCrend->m_fPitch_fx = 0;
1450 503 : hCrend->m_fRoll_fx = 0;
1451 503 : move32();
1452 503 : move32();
1453 503 : move32();
1454 :
1455 503 : ( *pCrend )->hCrend[pos_idx] = hCrend;
1456 : }
1457 :
1458 503 : return IVAS_ERR_OK;
1459 : }
1460 :
1461 :
1462 : /*-------------------------------------------------------------------------
1463 : * ivas_rend_openMultiBinCrend()
1464 : *
1465 : * Allocate and initialize crend renderer handle
1466 : *------------------------------------------------------------------------*/
1467 :
1468 0 : ivas_error ivas_rend_openMultiBinCrend(
1469 : CREND_WRAPPER_HANDLE *pCrend,
1470 : const AUDIO_CONFIG inConfig,
1471 : const AUDIO_CONFIG outConfig,
1472 : const MULTI_BIN_REND_POSE_DATA *pMultiBinPoseData,
1473 : const Word32 output_Fs )
1474 : {
1475 0 : return ivas_rend_openCrend_fx( pCrend, inConfig, outConfig, NULL /*hRendCfg*/, NULL, NULL /* hHrtfStatistics */, output_Fs, 0, pMultiBinPoseData->num_poses );
1476 : }
1477 :
1478 :
1479 : /*-------------------------------------------------------------------------
1480 : * ivas_rend_openCrend()
1481 : *
1482 : * Allocate and initialize crend renderer handle
1483 : *------------------------------------------------------------------------*/
1484 :
1485 503 : ivas_error ivas_rend_openCrend_fx(
1486 : CREND_WRAPPER_HANDLE *pCrend,
1487 : const AUDIO_CONFIG inConfig,
1488 : const AUDIO_CONFIG outConfig,
1489 : RENDER_CONFIG_DATA *hRendCfg,
1490 : HRTFS_CREND_HANDLE hHrtfCrend,
1491 : HRTFS_STATISTICS_HANDLE hHrtfStatistics,
1492 : const Word32 output_Fs,
1493 : const Word16 ext_rend_flag,
1494 : const Word16 num_poses )
1495 : {
1496 : Word16 i, subframe_length;
1497 : Word32 max_total_ir_len;
1498 : HRTFS_CREND_HANDLE hHrtf;
1499 : CREND_HANDLE hCrend;
1500 : ivas_error error;
1501 : Word16 pos_idx;
1502 :
1503 503 : IF( ( error = ivas_rend_initCrendWrapper_fx( pCrend, num_poses ) ) != IVAS_ERR_OK )
1504 : {
1505 0 : return error;
1506 : }
1507 :
1508 503 : subframe_length = extract_l( Mult_32_16( output_Fs, 164 ) ); /*( output_Fs / FRAMES_PER_SEC ) / MAX_PARAM_SPATIAL_SUBFRAMES(i/o:164=(32768/FRAMES_PER_SEC)/MAX_PARAM_SPATIAL_SUBFRAMES*/
1509 :
1510 503 : IF( ( *pCrend )->hHrtfCrend == NULL )
1511 : {
1512 503 : IF( NE_32( ( error = ivas_rend_initCrend_fx( *pCrend, inConfig, outConfig, hHrtfCrend, ext_rend_flag, output_Fs ) ), IVAS_ERR_OK ) )
1513 : {
1514 0 : return error;
1515 : }
1516 : }
1517 :
1518 1006 : FOR( pos_idx = 0; pos_idx < num_poses; pos_idx++ )
1519 : {
1520 503 : hCrend = ( *pCrend )->hCrend[pos_idx];
1521 503 : hHrtf = ( *pCrend )->hHrtfCrend;
1522 :
1523 503 : IF( hHrtf != NULL )
1524 : {
1525 503 : max_total_ir_len = L_mult0( hHrtf->max_num_iterations, subframe_length );
1526 :
1527 4905 : FOR( i = 0; i < hHrtf->max_num_ir; i++ )
1528 : {
1529 4402 : IF( ( hCrend->freq_buffer_re_fx[i] = (Word32 *) malloc( sizeof( Word32 ) * max_total_ir_len ) ) == NULL )
1530 : {
1531 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend" );
1532 : }
1533 4402 : set_zero2_fx( hCrend->freq_buffer_re_fx[i], max_total_ir_len );
1534 :
1535 4402 : IF( ( hCrend->freq_buffer_im_fx[i] = (Word32 *) malloc( sizeof( Word32 ) * max_total_ir_len ) ) == NULL )
1536 : {
1537 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend" );
1538 : }
1539 4402 : set_zero2_fx( hCrend->freq_buffer_im_fx[i], max_total_ir_len );
1540 : }
1541 :
1542 1509 : FOR( i = 0; i < BINAURAL_CHANNELS; i++ )
1543 : {
1544 1006 : IF( ( hCrend->prev_out_buffer_fx[i] = (Word32 *) malloc( sizeof( Word32 ) * subframe_length ) ) == NULL )
1545 : {
1546 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend" );
1547 : }
1548 1006 : set_zero_fx( hCrend->prev_out_buffer_fx[i], subframe_length );
1549 : }
1550 :
1551 503 : max_total_ir_len = L_mult0( (Word16) hHrtf->num_iterations_diffuse[0], subframe_length );
1552 :
1553 503 : IF( max_total_ir_len > 0 )
1554 : {
1555 329 : IF( ( hCrend->freq_buffer_re_diffuse_fx[0] = (Word32 *) malloc( sizeof( Word32 ) * max_total_ir_len ) ) == NULL )
1556 : {
1557 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend" );
1558 : }
1559 329 : IF( hHrtf->same_inv_diffuse_weight == 0 )
1560 : {
1561 0 : IF( ( hCrend->freq_buffer_re_diffuse_fx[1] = (Word32 *) malloc( sizeof( Word32 ) * max_total_ir_len ) ) == NULL )
1562 : {
1563 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend" );
1564 : }
1565 : }
1566 : ELSE
1567 : {
1568 329 : hCrend->freq_buffer_re_diffuse_fx[1] = NULL;
1569 : }
1570 329 : set_zero2_fx( hCrend->freq_buffer_re_diffuse_fx[0], max_total_ir_len );
1571 329 : IF( hCrend->freq_buffer_re_diffuse_fx[1] != NULL )
1572 : {
1573 0 : set_zero2_fx( hCrend->freq_buffer_re_diffuse_fx[1], max_total_ir_len );
1574 : }
1575 329 : IF( ( hCrend->freq_buffer_im_diffuse_fx[0] = (Word32 *) malloc( sizeof( Word32 ) * max_total_ir_len ) ) == NULL )
1576 : {
1577 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend" );
1578 : }
1579 329 : IF( hHrtf->same_inv_diffuse_weight == 0 )
1580 : {
1581 0 : IF( ( hCrend->freq_buffer_im_diffuse_fx[1] = (Word32 *) malloc( sizeof( Word32 ) * max_total_ir_len ) ) == NULL )
1582 : {
1583 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend" );
1584 : }
1585 : }
1586 : ELSE
1587 : {
1588 329 : hCrend->freq_buffer_im_diffuse_fx[1] = NULL;
1589 : }
1590 329 : set_zero2_fx( hCrend->freq_buffer_im_diffuse_fx[0], max_total_ir_len );
1591 329 : IF( hCrend->freq_buffer_im_diffuse_fx[1] != NULL )
1592 : {
1593 0 : set_zero2_fx( hCrend->freq_buffer_im_diffuse_fx[1], max_total_ir_len );
1594 : }
1595 : }
1596 : ELSE
1597 : {
1598 174 : hCrend->freq_buffer_re_diffuse_fx[0] = NULL;
1599 174 : hCrend->freq_buffer_im_diffuse_fx[0] = NULL;
1600 174 : hCrend->freq_buffer_re_diffuse_fx[1] = NULL;
1601 174 : hCrend->freq_buffer_im_diffuse_fx[1] = NULL;
1602 : }
1603 :
1604 503 : max_total_ir_len = add( extract_l( L_shr( L_add( L_shl( Mult_32_32( hHrtf->latency_s_fx, output_Fs ), 1 ), 1 ), 1 ) ), subframe_length ); /*(int16_t) ( hHrtf->latency_s * output_Fs + 0.5f ) + subframe_length;*/
1605 503 : IF( max_total_ir_len > 0 )
1606 : {
1607 503 : IF( ( hCrend->lfe_delay_line_fx = (Word32 *) malloc( sizeof( Word32 ) * max_total_ir_len ) ) == NULL )
1608 : {
1609 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Crend" );
1610 : }
1611 503 : set_zero2_fx( hCrend->lfe_delay_line_fx, max_total_ir_len );
1612 : }
1613 : ELSE
1614 : {
1615 0 : hCrend->lfe_delay_line_fx = NULL;
1616 : }
1617 :
1618 503 : IF( outConfig == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
1619 : {
1620 111 : IF( NE_32( ( error = ivas_reverb_open_fx( &( hCrend->hReverb ), hHrtfStatistics, hRendCfg, output_Fs ) ), IVAS_ERR_OK ) )
1621 : {
1622 0 : return error;
1623 : }
1624 :
1625 111 : IF( EQ_16( hRendCfg->roomAcoustics.use_er, 1 ) )
1626 : {
1627 :
1628 : /* Allocate memory for reflections */
1629 4 : hCrend->reflections = (er_struct_t *) malloc( sizeof( er_struct_t ) );
1630 4 : IF( !hCrend->reflections )
1631 : {
1632 0 : return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Early Reflections" );
1633 : }
1634 4 : IF( NE_32( ( error = ivas_er_init_handle( hCrend->reflections ) ), IVAS_ERR_OK ) )
1635 : {
1636 0 : return error;
1637 : }
1638 :
1639 4 : hCrend->reflections->use_er = hRendCfg->roomAcoustics.use_er;
1640 4 : hCrend->reflections->lowComplexity = hRendCfg->roomAcoustics.lowComplexity;
1641 4 : move16();
1642 4 : move32();
1643 :
1644 : /* Set sample rate and frame size */
1645 :
1646 4 : hCrend->reflections->output_Fs_fx = output_Fs; // Q0
1647 4 : move32();
1648 :
1649 4 : hCrend->reflections->max_frame_size = extract_l( Mult_32_16( output_Fs, INV_FRAME_PER_SEC_Q15 ) );
1650 4 : move32();
1651 :
1652 : /* Init Shoebox */
1653 4 : ivas_shoebox_config_init( &hCrend->reflections->shoebox_lib.cal, hRendCfg );
1654 :
1655 : /* Init and compute Reflections */
1656 4 : IF( NE_32( ( error = ivas_er_init( hCrend->reflections, inConfig ) ), IVAS_ERR_OK ) )
1657 : {
1658 0 : return error;
1659 : }
1660 : }
1661 : ELSE
1662 : {
1663 107 : hCrend->reflections = NULL;
1664 : }
1665 : }
1666 : ELSE
1667 : {
1668 392 : hCrend->hReverb = NULL;
1669 : }
1670 503 : ( *pCrend )->binaural_latency_ns = L_shr_r( Mpy_32_32_r( ( *pCrend )->hHrtfCrend->latency_s_fx, (Word32) 1000000000 ), ( *pCrend )->hHrtfCrend->factor_Q_latency_s_fx );
1671 503 : move32();
1672 : }
1673 :
1674 503 : ( *pCrend )->hCrend[pos_idx] = hCrend;
1675 : }
1676 :
1677 503 : return IVAS_ERR_OK;
1678 : }
1679 :
1680 :
1681 : /*-------------------------------------------------------------------------
1682 : * ivas_rend_closeCrend()
1683 : *
1684 : * Deallocate Crend renderer handle
1685 : *------------------------------------------------------------------------*/
1686 :
1687 40282 : void ivas_rend_closeCrend_fx(
1688 : CREND_WRAPPER_HANDLE *pCrend )
1689 : {
1690 : Word16 i;
1691 : Word16 pos_idx;
1692 : CREND_HANDLE hCrend;
1693 :
1694 40282 : test();
1695 40282 : IF( pCrend == NULL || *pCrend == NULL )
1696 : {
1697 39779 : return;
1698 : }
1699 :
1700 503 : test();
1701 503 : IF( ( *pCrend )->hHrtfCrend != NULL && ( *pCrend )->hHrtfCrend->init_from_rom )
1702 : {
1703 475 : ivas_hrtf_close( &( *pCrend )->hHrtfCrend );
1704 : }
1705 :
1706 4527 : FOR( pos_idx = 0; pos_idx < MAX_HEAD_ROT_POSES; pos_idx++ )
1707 : {
1708 4024 : hCrend = ( *pCrend )->hCrend[pos_idx];
1709 4024 : IF( hCrend != NULL )
1710 : {
1711 8551 : FOR( i = 0; i < MAX_INTERN_CHANNELS; i++ )
1712 : {
1713 8048 : IF( hCrend->freq_buffer_re_fx[i] != NULL )
1714 : {
1715 4402 : free( hCrend->freq_buffer_re_fx[i] );
1716 4402 : hCrend->freq_buffer_re_fx[i] = NULL;
1717 : }
1718 8048 : IF( hCrend->freq_buffer_im_fx[i] != NULL )
1719 : {
1720 4402 : free( hCrend->freq_buffer_im_fx[i] );
1721 4402 : hCrend->freq_buffer_im_fx[i] = NULL;
1722 : }
1723 : }
1724 :
1725 1509 : FOR( i = 0; i < BINAURAL_CHANNELS; i++ )
1726 : {
1727 1006 : IF( hCrend->prev_out_buffer_fx[i] != NULL )
1728 : {
1729 1006 : free( hCrend->prev_out_buffer_fx[i] );
1730 1006 : hCrend->prev_out_buffer_fx[i] = NULL;
1731 : }
1732 : }
1733 :
1734 503 : IF( hCrend->lfe_delay_line_fx != NULL )
1735 : {
1736 503 : free( hCrend->lfe_delay_line_fx );
1737 503 : hCrend->lfe_delay_line_fx = NULL;
1738 : }
1739 503 : IF( hCrend->freq_buffer_re_diffuse_fx[0] != NULL )
1740 : {
1741 329 : free( hCrend->freq_buffer_re_diffuse_fx[0] );
1742 329 : hCrend->freq_buffer_re_diffuse_fx[0] = NULL;
1743 : }
1744 :
1745 503 : IF( hCrend->freq_buffer_im_diffuse_fx[0] != NULL )
1746 : {
1747 329 : free( hCrend->freq_buffer_im_diffuse_fx[0] );
1748 329 : hCrend->freq_buffer_im_diffuse_fx[0] = NULL;
1749 : }
1750 :
1751 503 : IF( hCrend->freq_buffer_re_diffuse_fx[1] != NULL )
1752 : {
1753 0 : free( hCrend->freq_buffer_re_diffuse_fx[1] );
1754 0 : hCrend->freq_buffer_re_diffuse_fx[1] = NULL;
1755 : }
1756 :
1757 503 : IF( hCrend->freq_buffer_im_diffuse_fx[1] != NULL )
1758 : {
1759 0 : free( hCrend->freq_buffer_im_diffuse_fx[1] );
1760 0 : hCrend->freq_buffer_im_diffuse_fx[1] = NULL;
1761 : }
1762 503 : IF( hCrend->hTrack != NULL )
1763 : {
1764 0 : free( hCrend->hTrack );
1765 0 : hCrend->hTrack = NULL;
1766 : }
1767 :
1768 503 : ivas_reverb_close_fx( &hCrend->hReverb );
1769 :
1770 503 : IF( hCrend->reflections != NULL )
1771 : {
1772 4 : IF( hCrend->reflections->closest_ch_idx != NULL )
1773 : {
1774 4 : free( hCrend->reflections->closest_ch_idx );
1775 4 : hCrend->reflections->closest_ch_idx = NULL;
1776 : }
1777 4 : IF( hCrend->reflections->circ_buffers != NULL )
1778 : {
1779 4 : free( hCrend->reflections->circ_buffers );
1780 4 : hCrend->reflections->circ_buffers = NULL;
1781 : }
1782 4 : free( hCrend->reflections );
1783 4 : hCrend->reflections = NULL;
1784 : }
1785 503 : free( hCrend );
1786 503 : hCrend = NULL;
1787 503 : ( *pCrend )->hCrend[pos_idx] = hCrend;
1788 : }
1789 : }
1790 :
1791 503 : free( *pCrend );
1792 503 : *pCrend = NULL;
1793 :
1794 503 : return;
1795 : }
1796 :
1797 :
1798 : /*-------------------------------------------------------------------------
1799 : * ivas_rend_closeCldfbRend()
1800 : *
1801 : * Close CLDFB based fastconv binaural renderer memories
1802 : *------------------------------------------------------------------------*/
1803 :
1804 0 : void ivas_rend_closeCldfbRend(
1805 : CLDFB_REND_WRAPPER *pCldfbRend )
1806 : {
1807 0 : IF( pCldfbRend->hCldfbRend->hInputSetup != NULL )
1808 : {
1809 0 : free( pCldfbRend->hCldfbRend->hInputSetup );
1810 0 : pCldfbRend->hCldfbRend->hInputSetup = NULL;
1811 : }
1812 :
1813 0 : ivas_binRenderer_close_fx( &pCldfbRend->hCldfbRend );
1814 0 : ivas_binaural_hrtf_close_fx( &pCldfbRend->hHrtfFastConv );
1815 0 : ivas_HRTF_fastconv_binary_close_fx( &pCldfbRend->hHrtfFastConv );
1816 :
1817 0 : return;
1818 : }
1819 :
1820 :
1821 : /*-----------------------------------------------------------------------------------------*
1822 : * Function ivas_rend_crendConvolver()
1823 : *
1824 : * Convolver block
1825 : *-----------------------------------------------------------------------------------------*/
1826 :
1827 581191 : static ivas_error ivas_rend_crendConvolver_fx(
1828 : const CREND_WRAPPER *pCrend,
1829 : AUDIO_CONFIG inConfig,
1830 : AUDIO_CONFIG outConfig,
1831 : Word32 *pcm_in[], // Qx
1832 : Word32 *pcm_out[], // Qx
1833 : const Word32 output_Fs,
1834 : const Word16 i_ts,
1835 : const Word16 pos_idx )
1836 : {
1837 : Word16 i, j, k, m;
1838 : Word16 subframe_length, idx_in, index_in;
1839 : Word16 lfe_idx_in;
1840 : Word32 offset, offset_in, offset_diffuse;
1841 : Word16 nchan_in, nchan_out;
1842 : const Word32 *pIn;
1843 : Word32 *pFreq_buf_re, *pFreq_buf_im;
1844 581191 : Word32 *pFreq_buf2_re = NULL, *pFreq_buf2_im = NULL;
1845 581191 : Word32 *pFreq_buf3_re = NULL, *pFreq_buf3_im = NULL;
1846 : const Word16 *pFreq_filt_re, *pFreq_filt_im;
1847 : Word32 pOut[2 /*Re,Im*/ * L_FRAME48k / MAX_PARAM_SPATIAL_SUBFRAMES];
1848 : Word32 tmp_out_re[L_FRAME48k / MAX_PARAM_SPATIAL_SUBFRAMES], tmp_out_im[L_FRAME48k / MAX_PARAM_SPATIAL_SUBFRAMES];
1849 : CREND_HANDLE hCrend;
1850 : ivas_error error;
1851 :
1852 581191 : hCrend = pCrend->hCrend[pos_idx];
1853 :
1854 581191 : IF( NE_32( ( error = getAudioConfigNumChannels( inConfig, &nchan_in ) ), IVAS_ERR_OK ) )
1855 : {
1856 0 : return error;
1857 : }
1858 :
1859 581191 : IF( NE_32( ( error = getAudioConfigNumChannels( outConfig, &nchan_out ) ), IVAS_ERR_OK ) )
1860 : {
1861 0 : return error;
1862 : }
1863 :
1864 : /* subframe_length = (int16_t) ( output_Fs / FRAMES_PER_SEC ) / MAX_PARAM_SPATIAL_SUBFRAMES; */
1865 581191 : subframe_length = extract_l( Mpy_32_32_r( output_Fs, 10737418 /* 1 / ( FRAMES_PER_SEC * MAX_PARAM_SPATIAL_SUBFRAMES ) in Q31 */ ) );
1866 :
1867 581191 : lfe_idx_in = -1;
1868 581191 : move16();
1869 581191 : IF( EQ_32( getAudioConfigType( inConfig ), IVAS_REND_AUDIO_CONFIG_TYPE_CHANNEL_BASED ) )
1870 : {
1871 484531 : IF( NE_32( inConfig, IVAS_AUDIO_CONFIG_LS_CUSTOM ) )
1872 : {
1873 484531 : lfe_idx_in = LFE_CHANNEL;
1874 484531 : move16();
1875 : }
1876 : ELSE
1877 : {
1878 0 : assert( 0 && "Custom LS not supported in CRend" );
1879 : }
1880 : }
1881 :
1882 581191 : offset = L_mult0( hCrend->delay_line_rw_index, subframe_length ); /* subframe_length * ( pCrend->hHrtfCrend->max_num_iterations - 1 ); */
1883 581191 : offset_diffuse = L_mult0( hCrend->diffuse_delay_line_rw_index, subframe_length ); /* subframe_length *( pCrend->hHrtfCrend->num_iterations_diffuse[0] - 1 ); */
1884 :
1885 581191 : IF( pCrend->hHrtfCrend->num_iterations_diffuse[0] > 0 )
1886 : {
1887 400977 : pFreq_buf2_re = &hCrend->freq_buffer_re_diffuse_fx[0][offset_diffuse];
1888 400977 : pFreq_buf2_im = &hCrend->freq_buffer_im_diffuse_fx[0][offset_diffuse];
1889 400977 : set_val_Word32( &hCrend->freq_buffer_re_diffuse_fx[0][offset_diffuse], 0, subframe_length );
1890 400977 : set_val_Word32( &hCrend->freq_buffer_im_diffuse_fx[0][offset_diffuse], 0, subframe_length );
1891 400977 : IF( pCrend->hHrtfCrend->same_inv_diffuse_weight == 0 )
1892 : {
1893 0 : set_val_Word32( &hCrend->freq_buffer_re_diffuse_fx[1][offset_diffuse], 0, subframe_length );
1894 0 : set_val_Word32( &hCrend->freq_buffer_im_diffuse_fx[1][offset_diffuse], 0, subframe_length );
1895 0 : pFreq_buf3_re = &hCrend->freq_buffer_re_diffuse_fx[1][offset_diffuse];
1896 0 : pFreq_buf3_im = &hCrend->freq_buffer_im_diffuse_fx[1][offset_diffuse];
1897 : }
1898 : }
1899 :
1900 581191 : i = 0;
1901 6797199 : FOR( idx_in = 0; idx_in < nchan_in; idx_in++ )
1902 : {
1903 6216008 : pIn = &pcm_in[idx_in][i_ts * subframe_length];
1904 6216008 : pFreq_buf_re = &hCrend->freq_buffer_re_fx[i][offset];
1905 6216008 : pFreq_buf_im = &hCrend->freq_buffer_im_fx[i][offset];
1906 6216008 : IF( NE_16( idx_in, lfe_idx_in ) )
1907 : {
1908 5731477 : IF( pCrend->hHrtfCrend->num_iterations_diffuse[0] > 0 )
1909 : {
1910 411414538 : FOR( k = 0; k < pCrend->hHrtfCrend->index_frequency_max_diffuse; k++ )
1911 : {
1912 407256991 : pFreq_buf2_re[k] = Madd_32_16( pFreq_buf2_re[k], pFreq_buf_re[k], pCrend->hHrtfCrend->inv_diffuse_weight_fx[0][i] );
1913 407256991 : pFreq_buf2_im[k] = Madd_32_16( pFreq_buf2_im[k], pFreq_buf_im[k], pCrend->hHrtfCrend->inv_diffuse_weight_fx[0][i] );
1914 : }
1915 4157547 : IF( pCrend->hHrtfCrend->same_inv_diffuse_weight == 0 )
1916 : {
1917 0 : FOR( k = 0; k < pCrend->hHrtfCrend->index_frequency_max_diffuse; k++ )
1918 : {
1919 0 : pFreq_buf3_re[k] = Madd_32_16( pFreq_buf3_re[k], pFreq_buf_re[k], pCrend->hHrtfCrend->inv_diffuse_weight_fx[1][i] );
1920 0 : pFreq_buf3_im[k] = Madd_32_16( pFreq_buf3_im[k], pFreq_buf_im[k], pCrend->hHrtfCrend->inv_diffuse_weight_fx[1][i] );
1921 : }
1922 : }
1923 : }
1924 :
1925 5731477 : ivas_mdft_fx( pIn, pFreq_buf_re, pFreq_buf_im, subframe_length, subframe_length );
1926 5731477 : i = add( i, 1 );
1927 : }
1928 : }
1929 :
1930 581191 : IF( pCrend->hHrtfCrend->num_iterations_diffuse[0] > 0 )
1931 : {
1932 39675998 : FOR( k = 0; k < pCrend->hHrtfCrend->index_frequency_max_diffuse; k++ )
1933 : {
1934 39275021 : pFreq_buf2_re[k] = L_shl( pFreq_buf2_re[k], pCrend->hHrtfCrend->factor_Q_inv_diffuse_weight );
1935 39275021 : pFreq_buf2_im[k] = L_shl( pFreq_buf2_im[k], pCrend->hHrtfCrend->factor_Q_inv_diffuse_weight );
1936 : }
1937 400977 : IF( pCrend->hHrtfCrend->same_inv_diffuse_weight == 0 )
1938 : {
1939 0 : FOR( k = 0; k < pCrend->hHrtfCrend->index_frequency_max_diffuse; k++ )
1940 : {
1941 0 : pFreq_buf2_re[k] = L_shl( pFreq_buf2_re[k], pCrend->hHrtfCrend->factor_Q_inv_diffuse_weight );
1942 0 : pFreq_buf2_im[k] = L_shl( pFreq_buf2_im[k], pCrend->hHrtfCrend->factor_Q_inv_diffuse_weight );
1943 0 : pFreq_buf3_re[k] = L_shl( pFreq_buf3_re[k], pCrend->hHrtfCrend->factor_Q_inv_diffuse_weight );
1944 0 : pFreq_buf3_im[k] = L_shl( pFreq_buf3_im[k], pCrend->hHrtfCrend->factor_Q_inv_diffuse_weight );
1945 : }
1946 : }
1947 : }
1948 :
1949 1743573 : FOR( j = 0; j < nchan_out; j++ )
1950 : {
1951 1162382 : set_zero_fx( tmp_out_re, subframe_length );
1952 1162382 : set_zero_fx( tmp_out_im, subframe_length );
1953 1162382 : i = 0;
1954 1162382 : move16();
1955 13594398 : FOR( idx_in = 0; idx_in < nchan_in; idx_in++ )
1956 : {
1957 12432016 : IF( NE_16( idx_in, lfe_idx_in ) )
1958 : {
1959 11462954 : offset = 0;
1960 11462954 : move16();
1961 197557042 : FOR( m = 0; m < pCrend->hHrtfCrend->num_iterations[i][j]; m++ )
1962 : {
1963 186094088 : index_in = add( add( hCrend->delay_line_rw_index, sub( pCrend->hHrtfCrend->max_num_iterations, pCrend->hHrtfCrend->num_iterations[i][j] ) ), add( m, 1 ) );
1964 186094088 : index_in = index_in % ( pCrend->hHrtfCrend->max_num_iterations );
1965 186094088 : offset_in = L_mult0( index_in, subframe_length );
1966 186094088 : pFreq_buf_re = &hCrend->freq_buffer_re_fx[i][offset_in];
1967 186094088 : pFreq_buf_im = &hCrend->freq_buffer_im_fx[i][offset_in];
1968 186094088 : pFreq_filt_re = &pCrend->hHrtfCrend->pOut_to_bin_re_fx[i][j][offset];
1969 186094088 : pFreq_filt_im = &pCrend->hHrtfCrend->pOut_to_bin_im_fx[i][j][offset];
1970 :
1971 24847302116 : FOR( k = 0; k < pCrend->hHrtfCrend->pIndex_frequency_max[i][j][m]; k++ )
1972 : {
1973 24661208028 : tmp_out_re[k] = L_add( tmp_out_re[k], Msub_32_16( Mpy_32_16_r( pFreq_buf_re[k], pFreq_filt_re[k] ), pFreq_buf_im[k], pFreq_filt_im[k] ) );
1974 24661208028 : tmp_out_im[k] = L_add( tmp_out_im[k], Madd_32_16( Mpy_32_16_r( pFreq_buf_re[k], pFreq_filt_im[k] ), pFreq_buf_im[k], pFreq_filt_re[k] ) );
1975 : }
1976 186094088 : offset = L_add( offset, k );
1977 186094088 : move32();
1978 : }
1979 11462954 : i = add( i, 1 );
1980 : }
1981 : }
1982 :
1983 1162382 : offset = 0;
1984 1162382 : move16();
1985 33240542 : FOR( m = 0; m < pCrend->hHrtfCrend->num_iterations_diffuse[j]; m++ )
1986 : {
1987 32078160 : index_in = add( hCrend->diffuse_delay_line_rw_index, add( m, 1 ) );
1988 32078160 : index_in = index_in % pCrend->hHrtfCrend->num_iterations_diffuse[0];
1989 32078160 : offset_diffuse = L_mult0( index_in, subframe_length );
1990 32078160 : IF( pCrend->hHrtfCrend->same_inv_diffuse_weight )
1991 : {
1992 32078160 : pFreq_buf_re = &hCrend->freq_buffer_re_diffuse_fx[0][offset_diffuse];
1993 32078160 : pFreq_buf_im = &hCrend->freq_buffer_im_diffuse_fx[0][offset_diffuse];
1994 : }
1995 : ELSE
1996 : {
1997 0 : pFreq_buf_re = &hCrend->freq_buffer_re_diffuse_fx[j][offset_diffuse];
1998 0 : pFreq_buf_im = &hCrend->freq_buffer_im_diffuse_fx[j][offset_diffuse];
1999 : }
2000 32078160 : pFreq_filt_re = &pCrend->hHrtfCrend->pOut_to_bin_diffuse_re_fx[j][offset];
2001 32078160 : pFreq_filt_im = &pCrend->hHrtfCrend->pOut_to_bin_diffuse_im_fx[j][offset];
2002 :
2003 2344920080 : FOR( k = 0; k < pCrend->hHrtfCrend->pIndex_frequency_max_diffuse[j][m]; k++ )
2004 : {
2005 2312841920 : tmp_out_re[k] = L_add( tmp_out_re[k], Msub_32_16( Mpy_32_16_r( pFreq_buf_re[k], pFreq_filt_re[k] ), pFreq_buf_im[k], pFreq_filt_im[k] ) );
2006 2312841920 : tmp_out_im[k] = L_add( tmp_out_im[k], Madd_32_16( Mpy_32_16_r( pFreq_buf_re[k], pFreq_filt_im[k] ), pFreq_buf_im[k], pFreq_filt_re[k] ) );
2007 : }
2008 32078160 : offset = L_add( offset, k );
2009 : }
2010 :
2011 1162382 : ivas_imdft_fx( tmp_out_re, tmp_out_im, pOut, subframe_length );
2012 :
2013 1162382 : pFreq_buf_re = &pcm_out[j][L_mult0( i_ts, subframe_length )];
2014 277406862 : FOR( k = 0; k < subframe_length; k++ )
2015 : {
2016 276244480 : pFreq_buf_re[k] = L_shl( L_add( pOut[k], hCrend->prev_out_buffer_fx[j][k] ), pCrend->hHrtfCrend->factor_Q_pOut_to_bin );
2017 276244480 : hCrend->prev_out_buffer_fx[j][k] = pOut[k + subframe_length];
2018 : }
2019 : }
2020 :
2021 581191 : hCrend->delay_line_rw_index = add( hCrend->delay_line_rw_index, 1 );
2022 581191 : hCrend->delay_line_rw_index = hCrend->delay_line_rw_index % ( pCrend->hHrtfCrend->max_num_iterations );
2023 581191 : IF( pCrend->hHrtfCrend->num_iterations_diffuse[0] > 0 )
2024 : {
2025 400977 : hCrend->diffuse_delay_line_rw_index = add( hCrend->diffuse_delay_line_rw_index, 1 );
2026 400977 : hCrend->diffuse_delay_line_rw_index = hCrend->diffuse_delay_line_rw_index % ( pCrend->hHrtfCrend->num_iterations_diffuse[0] );
2027 : }
2028 :
2029 581191 : return IVAS_ERR_OK;
2030 : }
2031 :
2032 :
2033 : /*-----------------------------------------------------------------------------------------*
2034 : * Function ivas_rend_crendProcessSubframe()
2035 : *
2036 : *
2037 : *-----------------------------------------------------------------------------------------*/
2038 :
2039 327515 : ivas_error ivas_rend_crendProcessSubframe_fx(
2040 : const CREND_WRAPPER *pCrend, /* i/o: Crend wrapper handle */
2041 : const AUDIO_CONFIG inConfig, /* i : input audio configuration */
2042 : const AUDIO_CONFIG outConfig, /* i : output audio configuration */
2043 : const DECODER_CONFIG_HANDLE hDecoderConfig, /* i : decoder config. structure */
2044 : const COMBINED_ORIENTATION_HANDLE hCombinedOrientationData, /* i : combined orientation handle */
2045 : const IVAS_OUTPUT_SETUP_HANDLE hIntSetup, /* i : internal setup handle */
2046 : const EFAP_HANDLE hEFAPdata, /* i : EFAP handle */
2047 : DECODER_TC_BUFFER_HANDLE hTcBuffer, /* i/o: JBM handle */
2048 : Word32 *input_f[], /* i : transport channels Qx */
2049 : Word32 *output[], /* i/o: input/output audio channels Qx */
2050 : const Word16 n_samples_to_render, /* i : output frame length per channel */
2051 : const Word32 output_Fs, /* i : output sampling rate */
2052 : const Word16 pos_idx )
2053 : {
2054 : Word16 subframe_idx, subframe_len;
2055 : Word16 nchan_out, nchan_in, ch, first_sf, last_sf, slot_size, slots_to_render;
2056 : Word32 *tc_local_fx[MAX_OUTPUT_CHANNELS];
2057 : Word32 *p_output_fx[BINAURAL_CHANNELS];
2058 : Word32 pcm_tmp_fx[BINAURAL_CHANNELS][L_FRAME48k / MAX_PARAM_SPATIAL_SUBFRAMES];
2059 : Word32 *p_pcm_tmp_fx[BINAURAL_CHANNELS];
2060 : IVAS_REND_AudioConfigType inConfigType;
2061 : ivas_error error;
2062 : Word8 combinedOrientationEnabled;
2063 : CREND_HANDLE hCrend;
2064 327515 : hCrend = pCrend->hCrend[pos_idx];
2065 :
2066 327515 : combinedOrientationEnabled = 0;
2067 327515 : move16();
2068 327515 : IF( hCombinedOrientationData != NULL )
2069 : {
2070 4150 : if ( hCombinedOrientationData->enableCombinedOrientation[0] != 0 )
2071 : {
2072 4150 : combinedOrientationEnabled = 1;
2073 4150 : move16();
2074 : }
2075 : }
2076 :
2077 327515 : push_wmops( "ivas_rend_crendProcessSubframe" );
2078 327515 : inConfigType = getAudioConfigType( inConfig );
2079 :
2080 327515 : IF( NE_32( ( error = getAudioConfigNumChannels( outConfig, &nchan_out ) ), IVAS_ERR_OK ) )
2081 : {
2082 0 : return error;
2083 : }
2084 :
2085 327515 : IF( NE_32( ( error = getAudioConfigNumChannels( inConfig, &nchan_in ) ), IVAS_ERR_OK ) )
2086 : {
2087 0 : return error;
2088 : }
2089 :
2090 3888703 : FOR( ch = 0; ch < nchan_in; ch++ )
2091 : {
2092 3561188 : tc_local_fx[ch] = input_f[ch];
2093 : }
2094 982545 : FOR( ch = 0; ch < BINAURAL_CHANNELS; ch++ )
2095 : {
2096 655030 : p_pcm_tmp_fx[ch] = pcm_tmp_fx[ch];
2097 655030 : p_output_fx[ch] = output[ch];
2098 : }
2099 :
2100 327515 : IF( hTcBuffer != NULL )
2101 : {
2102 24971 : slot_size = hTcBuffer->n_samples_granularity;
2103 24971 : move16();
2104 :
2105 : /* loop for synthesis, assume we always have to render in multiples of 5ms subframes with spills */
2106 24971 : slots_to_render = s_min( sub( hTcBuffer->num_slots, hTcBuffer->slots_rendered ), idiv1616( n_samples_to_render, slot_size ) );
2107 24971 : first_sf = hTcBuffer->subframes_rendered;
2108 24971 : move16();
2109 24971 : last_sf = first_sf;
2110 24971 : move16();
2111 :
2112 122052 : WHILE( slots_to_render > 0 )
2113 : {
2114 97081 : slots_to_render = sub( slots_to_render, hTcBuffer->subframe_nbslots[last_sf] );
2115 97081 : last_sf = add( last_sf, 1 );
2116 : }
2117 :
2118 24971 : subframe_len = -1; /* will be set later */
2119 24971 : move16();
2120 : }
2121 : ELSE
2122 : {
2123 : Word16 n_den, den, last_sf_tmp;
2124 :
2125 302544 : SWITCH( output_Fs )
2126 : {
2127 302544 : case 48000:
2128 302544 : subframe_len = L_SUBFRAME_48k;
2129 302544 : move16();
2130 302544 : BREAK;
2131 0 : case 32000:
2132 0 : subframe_len = L_SUBFRAME_32k;
2133 0 : move16();
2134 0 : BREAK;
2135 0 : case 16000:
2136 : default:
2137 0 : subframe_len = L_SUBFRAME_16k;
2138 0 : move16();
2139 0 : BREAK;
2140 : }
2141 :
2142 302544 : first_sf = 0;
2143 302544 : move16();
2144 302544 : last_sf = idiv1616( n_samples_to_render, subframe_len );
2145 :
2146 302544 : n_den = norm_s( subframe_len );
2147 302544 : den = shl( subframe_len, n_den );
2148 302544 : last_sf_tmp = div_s( n_samples_to_render, den );
2149 302544 : last_sf = shr( last_sf_tmp, sub( 15, n_den ) );
2150 : }
2151 :
2152 908706 : FOR( subframe_idx = first_sf; subframe_idx < last_sf; subframe_idx++ )
2153 : {
2154 581191 : if ( hTcBuffer != NULL )
2155 : {
2156 97081 : subframe_len = imult1616( hTcBuffer->subframe_nbslots[subframe_idx], hTcBuffer->n_samples_granularity );
2157 : }
2158 :
2159 : /* Early Reflections */
2160 581191 : IF( hCrend->reflections != NULL )
2161 : {
2162 5800 : test();
2163 5800 : IF( EQ_32( hCrend->reflections->use_er, 1 ) && EQ_32( hCrend->reflections->is_ready, 1 ) )
2164 : {
2165 5800 : IF( NE_32( ( error = ivas_er_process( hCrend->reflections, subframe_len, 0, tc_local_fx, inConfig ) ), IVAS_ERR_OK ) )
2166 : {
2167 0 : return error;
2168 : }
2169 : }
2170 : }
2171 :
2172 581191 : test();
2173 581191 : IF( hDecoderConfig && combinedOrientationEnabled )
2174 : {
2175 : /* Rotation in SHD for:
2176 : MC with elevation (5_1_2 / 5_1_4 / 7_1_4) -> BINAURAL
2177 : SBA SPAR -> BINAURAL or BINAURAL_ROOM
2178 : */
2179 16600 : test();
2180 16600 : test();
2181 16600 : test();
2182 16600 : IF( EQ_32( inConfig, IVAS_AUDIO_CONFIG_FOA ) || EQ_32( inConfig, IVAS_AUDIO_CONFIG_HOA2 ) || EQ_32( inConfig, IVAS_AUDIO_CONFIG_HOA3 ) )
2183 : {
2184 600 : rotateFrame_shd( hCombinedOrientationData, tc_local_fx, subframe_len, *hIntSetup, 0 );
2185 : }
2186 : /* Rotation in SD for MC -> BINAURAL_ROOM */
2187 16000 : ELSE IF( ( hIntSetup != NULL ) && hIntSetup->is_loudspeaker_setup )
2188 : {
2189 16000 : rotateFrame_sd( hCombinedOrientationData, tc_local_fx, subframe_len, *hIntSetup, hEFAPdata, 0 );
2190 : }
2191 : }
2192 :
2193 581191 : test();
2194 581191 : IF( EQ_32( inConfigType, IVAS_REND_AUDIO_CONFIG_TYPE_CHANNEL_BASED ) || EQ_32( inConfigType, IVAS_REND_AUDIO_CONFIG_TYPE_AMBISONICS ) )
2195 : {
2196 581191 : IF( NE_32( ( error = ivas_rend_crendConvolver_fx( pCrend, inConfig, outConfig, tc_local_fx, p_pcm_tmp_fx, output_Fs, 0, pos_idx ) ), IVAS_ERR_OK ) )
2197 : {
2198 0 : return error;
2199 : }
2200 :
2201 581191 : IF( pCrend->hCrend[0]->hReverb != NULL )
2202 : {
2203 103880 : IF( NE_32( ( error = ivas_reverb_process_fx( pCrend->hCrend[pos_idx]->hReverb, inConfig, 1, tc_local_fx, p_pcm_tmp_fx, 0 ) ), IVAS_ERR_OK ) )
2204 : {
2205 0 : return error;
2206 : }
2207 : }
2208 :
2209 6797199 : FOR( ch = 0; ch < nchan_in; ch++ )
2210 : {
2211 6216008 : tc_local_fx[ch] += subframe_len;
2212 : }
2213 :
2214 581191 : if ( hTcBuffer != NULL )
2215 : {
2216 97081 : hTcBuffer->slots_rendered = add( hTcBuffer->subframe_nbslots[subframe_idx], hTcBuffer->slots_rendered );
2217 97081 : move16();
2218 : }
2219 : }
2220 : ELSE
2221 : {
2222 0 : return IVAS_ERR_INVALID_INPUT_FORMAT;
2223 : }
2224 :
2225 1743573 : FOR( ch = 0; ch < BINAURAL_CHANNELS; ch++ )
2226 : {
2227 : /* move to output */
2228 1162382 : Copy32( pcm_tmp_fx[ch], p_output_fx[ch], subframe_len );
2229 :
2230 1162382 : p_output_fx[ch] += subframe_len;
2231 : }
2232 :
2233 : /* update combined orientation access index */
2234 581191 : ivas_combined_orientation_update_index( hCombinedOrientationData, subframe_len );
2235 : }
2236 :
2237 327515 : IF( pCrend->hCrend[0]->hReverb != NULL )
2238 : {
2239 57926 : *pCrend->p_io_qfactor = sub( *pCrend->p_io_qfactor, 2 );
2240 57926 : move16();
2241 503198 : FOR( Word16 i = nchan_out; i < nchan_in; i++ )
2242 : {
2243 181913272 : FOR( Word16 j = 0; j < n_samples_to_render; j++ )
2244 : {
2245 181468000 : output[i][j] = L_shr( output[i][j], 2 ); // Q = *pCrend->p_io_qfactor
2246 181468000 : move32();
2247 : }
2248 : }
2249 : }
2250 :
2251 327515 : if ( hTcBuffer != NULL )
2252 : {
2253 24971 : hTcBuffer->subframes_rendered = last_sf;
2254 24971 : move16();
2255 : }
2256 :
2257 327515 : pop_wmops();
2258 :
2259 327515 : return IVAS_ERR_OK;
2260 : }
2261 :
2262 :
2263 : /*-----------------------------------------------------------------------------------------*
2264 : * Function ivas_rend_crend_ProcessSubframesSplitBin()
2265 : *
2266 : * Process call for IVAS Crend renderer
2267 : *-----------------------------------------------------------------------------------------*/
2268 :
2269 0 : ivas_error ivas_rend_crendProcessSubframesSplitBin(
2270 : const CREND_WRAPPER *pCrend, /* i/o: Crend wrapper handle */
2271 : const AUDIO_CONFIG inConfig, /* i : input audio configuration */
2272 : const AUDIO_CONFIG outConfig, /* i : output audio configuration */
2273 : const MULTI_BIN_REND_POSE_DATA *pMultiBinPoseData,
2274 : const DECODER_CONFIG_HANDLE hDecoderConfig, /* i : decoder config. structure */
2275 : const COMBINED_ORIENTATION_HANDLE hCombinedOrientationData, /* i : combined orientation handle */
2276 : const IVAS_OUTPUT_SETUP_HANDLE hIntSetup, /* i : internal setup handle */
2277 : const EFAP_HANDLE hEFAPdata, /* i : EFAP handle */
2278 : DECODER_TC_BUFFER_HANDLE hTcBuffer, /* i/o: JBM handle */
2279 : Word32 *input_f[], /* i : transport channels */
2280 : Word32 *output[], /* i/o: input/output audio channels */
2281 : const Word16 n_samples_to_render, /* i : output frame length per channel */
2282 : const Word32 output_Fs /* i : output sampling rate */
2283 : )
2284 : {
2285 : Word16 i, j;
2286 : Word16 sf;
2287 : Word16 pos_idx;
2288 : ivas_error error;
2289 : Word16 gain_lfe;
2290 : Word32 tmpLfeBuffer[L_FRAME48k];
2291 : Word16 original_subframes_rendered, original_slots_rendered;
2292 : Word32 tmpInputBuffer[MAX_OUTPUT_CHANNELS][L_FRAME48k];
2293 : Word32 *p_tmpInputBuffer[MAX_OUTPUT_CHANNELS];
2294 : Word32 tmpSplitBinBuffer[MAX_OUTPUT_CHANNELS][L_FRAME48k];
2295 :
2296 : COMBINED_ORIENTATION_DATA combinedOrientationDataLocal;
2297 : COMBINED_ORIENTATION_HANDLE pCombinedOrientationDataLocal;
2298 :
2299 : /* save current head positions */
2300 0 : pCombinedOrientationDataLocal = hCombinedOrientationData;
2301 0 : combinedOrientationDataLocal = *pCombinedOrientationDataLocal;
2302 0 : original_subframes_rendered = hTcBuffer->subframes_rendered;
2303 0 : move16();
2304 0 : original_slots_rendered = hTcBuffer->slots_rendered;
2305 0 : move16();
2306 :
2307 : /* copy input */
2308 0 : FOR( i = 0; i < hIntSetup->nchan_out_woLFE; ++i )
2309 : {
2310 0 : Copy32( input_f[i], tmpInputBuffer[i], n_samples_to_render );
2311 : }
2312 :
2313 0 : FOR( i = 0; i < MAX_OUTPUT_CHANNELS; ++i )
2314 : {
2315 0 : p_tmpInputBuffer[i] = tmpInputBuffer[i];
2316 0 : move32();
2317 : }
2318 :
2319 : /* save current head positions */
2320 0 : pCombinedOrientationDataLocal = hCombinedOrientationData;
2321 0 : combinedOrientationDataLocal = *pCombinedOrientationDataLocal;
2322 0 : move32();
2323 0 : move32();
2324 0 : IF( EQ_32( pMultiBinPoseData->poseCorrectionMode, ISAR_SPLIT_REND_POSE_CORRECTION_MODE_CLDFB ) )
2325 : {
2326 0 : FOR( sf = 1; sf < hCombinedOrientationData->num_subframes; ++sf )
2327 : {
2328 0 : Copy_Quat_fx( &combinedOrientationDataLocal.Quaternions[0], &combinedOrientationDataLocal.Quaternions[sf] );
2329 0 : FOR( i = 0; i < 3; i++ )
2330 : {
2331 0 : FOR( j = 0; j < 3; j++ )
2332 : {
2333 0 : combinedOrientationDataLocal.Rmat_fx[sf][i][j] = combinedOrientationDataLocal.Rmat_fx[0][i][j];
2334 0 : move32();
2335 : }
2336 : }
2337 : }
2338 : }
2339 :
2340 : /* copy LFE to tmpLfeBuffer and apply gain only once */
2341 0 : IF( GT_16( hIntSetup->num_lfe, 0 ) && NE_16( hIntSetup->index_lfe[0], -1 ) )
2342 : {
2343 0 : Copy32( output[hIntSetup->index_lfe[0]], tmpLfeBuffer, n_samples_to_render );
2344 0 : gain_lfe = ( ( pCrend != NULL ) && ( pCrend->hHrtfCrend != NULL ) ) ? pCrend->hHrtfCrend->gain_lfe_fx : GAIN_LFE_FX;
2345 0 : v_multc_fx_16( tmpLfeBuffer, gain_lfe, tmpLfeBuffer, n_samples_to_render ); // q_input_fx - 1
2346 0 : Scale_sig32( tmpLfeBuffer, n_samples_to_render, 1 ); // q_input_fx
2347 : }
2348 : ELSE
2349 : {
2350 0 : set32_fx( tmpLfeBuffer, 0, n_samples_to_render );
2351 : }
2352 :
2353 0 : FOR( pos_idx = 0; pos_idx < pMultiBinPoseData->num_poses; ++pos_idx )
2354 : {
2355 : /* Update head positions */
2356 : IVAS_QUATERNION Quaternions_orig[MAX_PARAM_SPATIAL_SUBFRAMES], Quaternions_abs;
2357 :
2358 0 : FOR( i = 0; i < hCombinedOrientationData->num_subframes; i++ )
2359 : {
2360 0 : Copy_Quat_fx( &combinedOrientationDataLocal.Quaternions[i], &Quaternions_orig[i] );
2361 0 : Quaternions_abs.w_fx = L_negate( 12582912 ); // Q22
2362 0 : move32();
2363 0 : modify_Quat_q_fx( &combinedOrientationDataLocal.Quaternions[i], &combinedOrientationDataLocal.Quaternions[i], Q22 );
2364 0 : Quat2EulerDegree_fx( combinedOrientationDataLocal.Quaternions[i], &Quaternions_abs.z_fx, &Quaternions_abs.y_fx, &Quaternions_abs.x_fx ); /*order in Quat2Euler seems to be reversed ?*/
2365 :
2366 0 : Quaternions_abs.x_fx = L_add( Quaternions_abs.x_fx, pMultiBinPoseData->relative_head_poses_fx[pos_idx][0] );
2367 0 : Quaternions_abs.y_fx = L_add( Quaternions_abs.y_fx, pMultiBinPoseData->relative_head_poses_fx[pos_idx][1] );
2368 0 : Quaternions_abs.z_fx = L_add( Quaternions_abs.z_fx, pMultiBinPoseData->relative_head_poses_fx[pos_idx][2] );
2369 0 : combinedOrientationDataLocal.Quaternions[i] = Quaternions_abs;
2370 0 : move32();
2371 0 : move32();
2372 0 : move32();
2373 0 : move32();
2374 0 : Euler2Quat_fx( deg2rad_fx( combinedOrientationDataLocal.Quaternions[i].x_fx ),
2375 : deg2rad_fx( combinedOrientationDataLocal.Quaternions[i].y_fx ),
2376 : deg2rad_fx( combinedOrientationDataLocal.Quaternions[i].z_fx ),
2377 0 : &combinedOrientationDataLocal.Quaternions[i] );
2378 0 : modify_Quat_q_fx( &combinedOrientationDataLocal.Quaternions[i], &combinedOrientationDataLocal.Quaternions[i], Quaternions_orig[i].q_fact );
2379 0 : QuatToRotMat_fx( combinedOrientationDataLocal.Quaternions[i], combinedOrientationDataLocal.Rmat_fx[i] );
2380 0 : modify_Rmat_q_fx( combinedOrientationDataLocal.Rmat_fx[i], combinedOrientationDataLocal.Rmat_fx[i], sub( shl( Quaternions_orig[i].q_fact, 1 ), 32 ), Q30 );
2381 : }
2382 :
2383 :
2384 0 : pCombinedOrientationDataLocal = &combinedOrientationDataLocal;
2385 0 : move32();
2386 :
2387 0 : hTcBuffer->subframes_rendered = original_subframes_rendered;
2388 0 : hTcBuffer->slots_rendered = original_slots_rendered;
2389 0 : move16();
2390 0 : move16();
2391 :
2392 : /* update combined orientation access index */
2393 0 : ivas_combined_orientation_set_to_start_index( pCombinedOrientationDataLocal );
2394 :
2395 0 : FOR( i = 0; i < 3; i++ )
2396 : {
2397 0 : Copy32( hCombinedOrientationData->Rmat_prev_fx[pos_idx][i], pCombinedOrientationDataLocal->Rmat_prev_fx[0][i], 3 );
2398 : }
2399 :
2400 0 : IF( ( error = ivas_rend_crendProcessSubframe_fx( pCrend, inConfig, outConfig, hDecoderConfig, pCombinedOrientationDataLocal,
2401 : hIntSetup, hEFAPdata, hTcBuffer, p_tmpInputBuffer, p_tmpInputBuffer, n_samples_to_render, output_Fs, pos_idx ) ) != IVAS_ERR_OK )
2402 : {
2403 0 : return error;
2404 : }
2405 :
2406 0 : FOR( i = 0; i < 3; i++ )
2407 : {
2408 0 : Copy32( pCombinedOrientationDataLocal->Rmat_prev_fx[0][i], hCombinedOrientationData->Rmat_prev_fx[pos_idx][i], 3 );
2409 : }
2410 :
2411 0 : FOR( i = 0; i < BINAURAL_CHANNELS; ++i )
2412 : {
2413 : /* accumulate LFE to output */
2414 0 : v_add_fx( tmpInputBuffer[i], tmpLfeBuffer, tmpInputBuffer[i], n_samples_to_render );
2415 :
2416 : /* move to split bin output buffer */
2417 0 : Copy32( tmpInputBuffer[i], tmpSplitBinBuffer[add( i_mult( pos_idx, BINAURAL_CHANNELS ), i )], n_samples_to_render );
2418 : }
2419 :
2420 : /* overwrite rendered channels with input again for next iteration */
2421 0 : FOR( i = 0; i < hIntSetup->nchan_out_woLFE; ++i )
2422 : {
2423 0 : Copy32( output[i], tmpInputBuffer[i], n_samples_to_render );
2424 : }
2425 :
2426 : /* restore original headrotation data */
2427 0 : FOR( i = 0; i < hCombinedOrientationData->num_subframes; i++ )
2428 : {
2429 0 : Copy_Quat_fx( &Quaternions_orig[i], &combinedOrientationDataLocal.Quaternions[i] );
2430 : }
2431 : }
2432 :
2433 : /* copy split binaural rendered signals to final output */
2434 0 : FOR( i = 0; i < i_mult( BINAURAL_CHANNELS, pMultiBinPoseData->num_poses ); ++i )
2435 : {
2436 0 : Copy32( tmpSplitBinBuffer[i], output[i], n_samples_to_render );
2437 : }
2438 :
2439 : /* update main combined orientation access index */
2440 0 : ivas_combined_orientation_update_index( hCombinedOrientationData, n_samples_to_render );
2441 :
2442 0 : return IVAS_ERR_OK;
2443 : }
|
