Line data Source code
1 : /******************************************************************************************************
2 :
3 : (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
4 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
5 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
6 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
7 : contributors to this repository. All Rights Reserved.
8 :
9 : This software is protected by copyright law and by international treaties.
10 : The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
11 : Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
12 : Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
13 : Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
14 : contributors to this repository retain full ownership rights in their respective contributions in
15 : the software. This notice grants no license of any kind, including but not limited to patent
16 : license, nor is any license granted by implication, estoppel or otherwise.
17 :
18 : Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
19 : contributions.
20 :
21 : This software is provided "AS IS", without any express or implied warranties. The software is in the
22 : development stage. It is intended exclusively for experts who have experience with such software and
23 : solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
24 : and fitness for a particular purpose are hereby disclaimed and excluded.
25 :
26 : Any dispute, controversy or claim arising under or in relation to providing this software shall be
27 : submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
28 : accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
29 : the United Nations Convention on Contracts on the International Sales of Goods.
30 :
31 : *******************************************************************************************************/
32 :
33 : #include <stdint.h>
34 : #include "options.h"
35 : #include "ivas_cnst.h"
36 : #include "prot.h"
37 : #include "ivas_prot.h"
38 : #include "ivas_prot_rend.h"
39 : #include "ivas_stat_com.h"
40 : #include "ivas_rom_com.h"
41 : #include "ivas_rom_dec.h"
42 : #include <math.h>
43 : #ifdef DEBUGGING
44 : #include "debug.h"
45 : #endif
46 : #include "wmc_auto.h"
47 :
48 :
49 : /*-------------------------------------------------------------------------*
50 : * ivas_ism_renderer_open()
51 : *
52 : * Open struct for object rendering, reserve memory, and init values.
53 : *-------------------------------------------------------------------------*/
54 :
55 1281 : ivas_error ivas_ism_renderer_open(
56 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
57 : )
58 : {
59 : int16_t i;
60 : uint16_t interpolator_length;
61 : uint16_t init_interpolator_length;
62 : ivas_error error;
63 :
64 1281 : if ( ( st_ivas->hIsmRendererData = (ISM_RENDERER_HANDLE) malloc( sizeof( ISM_RENDERER_DATA ) ) ) == NULL )
65 : {
66 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for ISM renderer\n" ) );
67 : }
68 :
69 1281 : if ( st_ivas->hIntSetup.is_loudspeaker_setup &&
70 645 : st_ivas->hDecoderConfig->output_config != IVAS_AUDIO_CONFIG_STEREO &&
71 552 : st_ivas->hIntSetup.ls_azimuth != NULL && st_ivas->hIntSetup.ls_elevation != NULL &&
72 552 : st_ivas->hEFAPdata == NULL )
73 : {
74 552 : if ( ( error = efap_init_data( &( st_ivas->hEFAPdata ), st_ivas->hIntSetup.ls_azimuth, st_ivas->hIntSetup.ls_elevation, st_ivas->hIntSetup.nchan_out_woLFE, EFAP_MODE_EFAP ) ) != IVAS_ERR_OK )
75 : {
76 0 : return error;
77 : }
78 : }
79 :
80 6405 : for ( i = 0; i < MAX_NUM_OBJECTS; i++ )
81 : {
82 5124 : set_f( st_ivas->hIsmRendererData->prev_gains[i], 0.0f, MAX_OUTPUT_CHANNELS );
83 5124 : set_f( st_ivas->hIsmRendererData->gains[i], 0.0f, MAX_OUTPUT_CHANNELS );
84 : }
85 :
86 1281 : if ( st_ivas->hDecoderConfig->Opt_tsm )
87 : {
88 303 : init_interpolator_length = NS2SA( st_ivas->hDecoderConfig->output_Fs, MAX_JBM_CLDFB_TIMESLOTS * CLDFB_SLOT_NS );
89 303 : interpolator_length = (uint16_t) ( st_ivas->hDecoderConfig->output_Fs / FRAMES_PER_SEC );
90 : }
91 : else
92 : {
93 978 : init_interpolator_length = (uint16_t) ( st_ivas->hDecoderConfig->output_Fs / FRAMES_PER_SEC );
94 978 : interpolator_length = init_interpolator_length;
95 : }
96 :
97 1281 : if ( ( st_ivas->hIsmRendererData->interpolator = (float *) malloc( sizeof( float ) * init_interpolator_length ) ) == NULL )
98 : {
99 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for ISM renderer interpolator\n" ) );
100 : }
101 :
102 1054401 : for ( i = 0; i < interpolator_length; i++ )
103 : {
104 1053120 : st_ivas->hIsmRendererData->interpolator[i] = (float) i / ( (float) interpolator_length - 1 );
105 : }
106 :
107 1281 : return IVAS_ERR_OK;
108 : }
109 :
110 :
111 : /*-------------------------------------------------------------------------*
112 : * ivas_ism_renderer_close()
113 : *
114 : * Close struct for object rendering.
115 : *-------------------------------------------------------------------------*/
116 :
117 9816 : void ivas_ism_renderer_close(
118 : ISM_RENDERER_HANDLE *hIsmRendererData /* i/o: ISM renderer handle */
119 : )
120 : {
121 9816 : if ( hIsmRendererData == NULL || *hIsmRendererData == NULL )
122 : {
123 6996 : return;
124 : }
125 :
126 2820 : if ( ( *hIsmRendererData )->interpolator != NULL )
127 : {
128 2820 : free( ( *hIsmRendererData )->interpolator );
129 2820 : ( *hIsmRendererData )->interpolator = NULL;
130 : }
131 :
132 2820 : free( *hIsmRendererData );
133 2820 : *hIsmRendererData = NULL;
134 :
135 2820 : return;
136 : }
137 :
138 :
139 : /*-------------------------------------------------------------------------*
140 : * ivas_ism_render_sf()
141 : *
142 : * Object rendering process
143 : *-------------------------------------------------------------------------*/
144 :
145 188283 : void ivas_ism_render_sf(
146 : Decoder_Struct *st_ivas, /* i/o: IVAS decoder structure */
147 : const RENDERER_TYPE renderer_type, /* i : active renderer type */
148 : float *output_f[], /* i/o: core-coder transport channels/object output */
149 : const int16_t n_samples_to_render /* i : output frame length per channel */
150 : )
151 : {
152 : int16_t i, j, k, j2;
153 : float *g1, g2, *tc;
154 : int16_t num_objects, nchan_out_woLFE, lfe_index;
155 : int16_t azimuth, elevation;
156 : int16_t tc_offset;
157 : int16_t interp_offset;
158 : float gain, prev_gain;
159 : float tc_local[MAX_NUM_OBJECTS][L_FRAME48k];
160 : float *p_tc[MAX_NUM_OBJECTS];
161 : int16_t ism_md_subframe_update_jbm, slots_to_render, first_sf, last_sf, subframe_idx;
162 : int16_t n_samples_rendered_loop;
163 :
164 : /* loop for synthesis, assume we always have to render in multiples of 5ms subframes with spills */
165 188283 : slots_to_render = min( st_ivas->hTcBuffer->num_slots - st_ivas->hTcBuffer->slots_rendered, n_samples_to_render / st_ivas->hTcBuffer->n_samples_granularity );
166 188283 : first_sf = st_ivas->hTcBuffer->subframes_rendered;
167 188283 : last_sf = first_sf;
168 188283 : n_samples_rendered_loop = 0;
169 :
170 506757 : while ( slots_to_render > 0 )
171 : {
172 318474 : slots_to_render -= st_ivas->hTcBuffer->subframe_nbslots[last_sf];
173 318474 : last_sf++;
174 : }
175 : #ifdef DEBUGGING
176 : assert( slots_to_render == 0 );
177 : assert( last_sf <= st_ivas->hTcBuffer->nb_subframes );
178 : #endif
179 188283 : num_objects = st_ivas->nchan_ism;
180 :
181 188283 : nchan_out_woLFE = st_ivas->hIntSetup.nchan_out_woLFE;
182 :
183 188283 : tc_offset = st_ivas->hTcBuffer->n_samples_rendered;
184 188283 : interp_offset = st_ivas->hTcBuffer->n_samples_rendered;
185 :
186 : /* Number of subframes to delay metadata to sync with audio */
187 188283 : if ( st_ivas->hDecoderConfig->Opt_delay_comp )
188 : {
189 171801 : ism_md_subframe_update_jbm = max( 0, st_ivas->hTcBuffer->nb_subframes - 3 );
190 : }
191 : else
192 : {
193 16482 : ism_md_subframe_update_jbm = st_ivas->hTcBuffer->nb_subframes - 2;
194 : }
195 :
196 703775 : for ( i = 0; i < num_objects; i++ )
197 : {
198 515492 : mvr2r( &output_f[i][tc_offset], tc_local[i], n_samples_to_render );
199 515492 : p_tc[i] = tc_local[i];
200 : }
201 :
202 1899815 : for ( i = 0; i < nchan_out_woLFE + st_ivas->hIntSetup.num_lfe; i++ )
203 : {
204 1711532 : set_f( output_f[i], 0.0f, n_samples_to_render );
205 : }
206 :
207 506757 : for ( subframe_idx = first_sf; subframe_idx < last_sf; subframe_idx++ )
208 : {
209 : int16_t n_samples_in_subframe;
210 :
211 318474 : n_samples_in_subframe = st_ivas->hTcBuffer->n_samples_granularity * st_ivas->hTcBuffer->subframe_nbslots[subframe_idx];
212 :
213 318474 : if ( st_ivas->hCombinedOrientationData && st_ivas->hCombinedOrientationData->enableCombinedOrientation[st_ivas->hCombinedOrientationData->subframe_idx] == 1 )
214 : {
215 35976 : ivas_jbm_dec_get_adapted_linear_interpolator( n_samples_in_subframe, n_samples_in_subframe, st_ivas->hIsmRendererData->interpolator );
216 35976 : interp_offset = 0;
217 : }
218 :
219 1189284 : for ( i = 0; i < num_objects; i++ )
220 : {
221 : /* Combined rotation: rotate the object positions depending the head and external orientations */
222 870810 : if ( st_ivas->hCombinedOrientationData != NULL && st_ivas->hCombinedOrientationData->enableCombinedOrientation[st_ivas->hCombinedOrientationData->subframe_idx] == 1 )
223 : {
224 35976 : if ( subframe_idx >= ism_md_subframe_update_jbm )
225 : {
226 26982 : rotateAziEle( st_ivas->hIsmMetaData[i]->edited_azimuth, st_ivas->hIsmMetaData[i]->edited_elevation, &azimuth, &elevation, st_ivas->hCombinedOrientationData->Rmat[st_ivas->hCombinedOrientationData->subframe_idx], st_ivas->hIntSetup.is_planar_setup );
227 : }
228 : else
229 : {
230 8994 : rotateAziEle( st_ivas->hIsmMetaData[i]->edited_azimuth, st_ivas->hIsmMetaData[i]->edited_elevation, &azimuth, &elevation, st_ivas->hCombinedOrientationData->Rmat[st_ivas->hCombinedOrientationData->subframe_idx], st_ivas->hIntSetup.is_planar_setup );
231 : }
232 :
233 35976 : if ( st_ivas->hEFAPdata != NULL )
234 : {
235 35976 : efap_determine_gains( st_ivas->hEFAPdata, st_ivas->hIsmRendererData->gains[i], azimuth, elevation, EFAP_MODE_EFAP );
236 35976 : v_multc( st_ivas->hIsmRendererData->gains[i], st_ivas->hIsmMetaData[i]->edited_gain, st_ivas->hIsmRendererData->gains[i], nchan_out_woLFE );
237 : }
238 : }
239 :
240 870810 : lfe_index = 0;
241 8101977 : for ( j = 0, j2 = 0; j < nchan_out_woLFE; j++, j2++ )
242 : {
243 7231167 : if ( ( st_ivas->hIntSetup.num_lfe > 0 ) && ( st_ivas->hIntSetup.index_lfe[lfe_index] == j ) )
244 : {
245 533361 : ( lfe_index < ( st_ivas->hIntSetup.num_lfe - 1 ) ) ? ( lfe_index++, j2++ ) : j2++;
246 : }
247 :
248 7231167 : gain = st_ivas->hIsmRendererData->gains[i][j];
249 7231167 : prev_gain = st_ivas->hIsmRendererData->prev_gains[i][j];
250 7231167 : if ( fabsf( gain ) > 0.0f || fabsf( prev_gain ) > 0.0f )
251 : {
252 3653355 : g1 = &st_ivas->hIsmRendererData->interpolator[interp_offset];
253 3653355 : tc = p_tc[i];
254 796874715 : for ( k = 0; k < n_samples_in_subframe; k++ )
255 : {
256 793221360 : g2 = 1.0f - *g1;
257 793221360 : output_f[j2][k + n_samples_rendered_loop] += ( *( g1++ ) * gain + g2 * prev_gain ) * *( tc++ );
258 : }
259 : }
260 :
261 : /* update here only in case of head rotation */
262 7231167 : if ( st_ivas->hCombinedOrientationData != NULL && st_ivas->hCombinedOrientationData->enableCombinedOrientation[st_ivas->hCombinedOrientationData->subframe_idx] == 1 )
263 : {
264 395736 : st_ivas->hIsmRendererData->prev_gains[i][j] = gain;
265 : }
266 : }
267 870810 : p_tc[i] += n_samples_in_subframe;
268 : }
269 :
270 : /* update combined orientation access index */
271 318474 : ivas_combined_orientation_update_index( st_ivas->hCombinedOrientationData, n_samples_in_subframe );
272 :
273 318474 : n_samples_rendered_loop += n_samples_in_subframe;
274 : /* update rendered subframe and slots info for all cases apart from a following crend call, the update will
275 : then happen in the crend call*/
276 318474 : if ( renderer_type != RENDERER_BINAURAL_MIXER_CONV_ROOM )
277 : {
278 188883 : st_ivas->hTcBuffer->subframes_rendered += 1;
279 188883 : st_ivas->hTcBuffer->slots_rendered += st_ivas->hTcBuffer->subframe_nbslots[subframe_idx];
280 : }
281 318474 : tc_offset += n_samples_in_subframe;
282 318474 : interp_offset += n_samples_in_subframe;
283 : }
284 :
285 188283 : return;
286 : }
287 :
288 :
289 : /*-------------------------------------------------------------------------*
290 : * ivas_ism_get_stereo_gains()
291 : *
292 : *
293 : *-------------------------------------------------------------------------*/
294 :
295 3046104 : void ivas_ism_get_stereo_gains(
296 : const float azimuth, /* i : object azimuth */
297 : const float elevation, /* i : object elevation */
298 : float *left_gain, /* o : left channel gain */
299 : float *right_gain /* o : right channel gain */
300 : )
301 : {
302 : float aziRad, eleRad;
303 : float y, mappedX, aziRadMapped, A, A2, A3;
304 3046104 : const float LsAngleRad = 30.0f * PI_OVER_180;
305 :
306 : /* Convert azi and ele to an azi value of the cone of confusion */
307 3046104 : aziRad = azimuth * PI_OVER_180;
308 3046104 : eleRad = elevation * PI_OVER_180;
309 3046104 : y = ( sinf( aziRad ) * cosf( eleRad ) );
310 3046104 : mappedX = sqrtf( max( 0.0f, 1.0f - ( y * y ) ) );
311 3046104 : aziRadMapped = atan2f( y, mappedX );
312 :
313 : /* Determine the amplitude panning gains */
314 3046104 : if ( aziRadMapped >= LsAngleRad )
315 : { /* Left side */
316 248552 : *left_gain = 1.0f;
317 248552 : *right_gain = 0.0f;
318 : }
319 2797552 : else if ( aziRadMapped <= -LsAngleRad )
320 : { /* Right side */
321 257488 : *left_gain = 0.0f;
322 257488 : *right_gain = 1.0f;
323 : }
324 : else /* Tangent panning law */
325 : {
326 2540064 : A = tanf( aziRadMapped ) / tanf( LsAngleRad );
327 2540064 : A2 = ( A - 1.0f ) / max( 0.001f, A + 1.0f );
328 2540064 : A3 = 1.0f / ( A2 * A2 + 1.0f );
329 2540064 : *left_gain = sqrtf( A3 );
330 2540064 : *right_gain = sqrtf( 1.0f - A3 );
331 : }
332 :
333 3046104 : return;
334 : }
335 :
336 :
337 : /*-------------------------------------------------------------------------*
338 : * ivas_omasa_separate_object_renderer_open()
339 : *
340 : * Open structures, reserve memory, and init values.
341 : *-------------------------------------------------------------------------*/
342 :
343 1485 : ivas_error ivas_omasa_separate_object_renderer_open(
344 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
345 : )
346 : {
347 : int16_t interpolator_length;
348 : int16_t i;
349 : int16_t init_interpolator_length;
350 :
351 1485 : if ( ( st_ivas->hIsmRendererData = (ISM_RENDERER_HANDLE) malloc( sizeof( ISM_RENDERER_DATA ) ) ) == NULL )
352 : {
353 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Cannot allocate memory for MASA ISM renderer \n" ) );
354 : }
355 :
356 7425 : for ( i = 0; i < MAX_NUM_OBJECTS; i++ )
357 : {
358 5940 : set_f( st_ivas->hIsmRendererData->prev_gains[i], 0.0f, MAX_OUTPUT_CHANNELS );
359 : }
360 :
361 1485 : init_interpolator_length = (int16_t) ( st_ivas->hDecoderConfig->output_Fs / FRAMES_PER_SEC / MAX_PARAM_SPATIAL_SUBFRAMES );
362 1485 : interpolator_length = init_interpolator_length;
363 1485 : if ( ( st_ivas->hIsmRendererData->interpolator = (float *) malloc( sizeof( float ) * init_interpolator_length ) ) == NULL )
364 : {
365 0 : return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Cannot allocate memory for MASA ISM renderer interpolator \n" ) );
366 : }
367 :
368 357165 : for ( i = 0; i < interpolator_length; i++ )
369 : {
370 355680 : st_ivas->hIsmRendererData->interpolator[i] = (float) i / ( (float) interpolator_length );
371 : }
372 1485 : st_ivas->hIsmRendererData->interpolator_length = interpolator_length;
373 :
374 1485 : return IVAS_ERR_OK;
375 : }
376 :
377 :
378 : /*-------------------------------------------------------------------------*
379 : * ivas_omasa_separate_object_renderer_close()
380 : *
381 : * Close structures, free memory.
382 : *-------------------------------------------------------------------------*/
383 :
384 6012 : void ivas_omasa_separate_object_renderer_close(
385 : Decoder_Struct *st_ivas /* i/o: IVAS decoder structure */
386 : )
387 : {
388 : int16_t i;
389 :
390 6012 : if ( st_ivas->hMasaIsmData != NULL )
391 : {
392 6012 : if ( st_ivas->hMasaIsmData->delayBuffer != NULL )
393 : {
394 5184 : for ( i = 0; i < st_ivas->hMasaIsmData->delayBuffer_nchan; i++ )
395 : {
396 3441 : if ( st_ivas->hMasaIsmData->delayBuffer[i] != NULL )
397 : {
398 3441 : free( st_ivas->hMasaIsmData->delayBuffer[i] );
399 3441 : st_ivas->hMasaIsmData->delayBuffer[i] = NULL;
400 : }
401 : }
402 :
403 1743 : free( st_ivas->hMasaIsmData->delayBuffer );
404 1743 : st_ivas->hMasaIsmData->delayBuffer = NULL;
405 : }
406 : }
407 :
408 6012 : ivas_ism_renderer_close( &st_ivas->hIsmRendererData );
409 :
410 6012 : return;
411 : }
412 :
413 :
414 : /*-------------------------------------------------------------------------*
415 : * ivas_omasa_separate_object_render_jbm()
416 : *
417 : * Rendering separated objects and mixing them to the parametrically rendered signals for JBM
418 : *-------------------------------------------------------------------------*/
419 :
420 18845 : void ivas_omasa_separate_object_render_jbm(
421 : Decoder_Struct *st_ivas, /* i/o: IVAS decoder structure */
422 : const uint16_t nSamplesRendered, /* i : number of samples rendered */
423 : float input_f_in[][L_FRAME48k], /* i : separated object signal */
424 : float *output_f[], /* o : rendered time signal */
425 : const int16_t subframes_rendered /* i : number of subframes rendered */
426 : )
427 : {
428 : VBAP_HANDLE hVBAPdata;
429 : DIRAC_REND_HANDLE hDirACRend;
430 : SPAT_PARAM_REND_COMMON_DATA_HANDLE hSpatParamRendCom;
431 : int16_t nchan_out_woLFE, num_lfe;
432 : ISM_RENDERER_HANDLE hRendererData;
433 : int16_t j, k, j2;
434 : int16_t obj;
435 : float gains[MAX_OUTPUT_CHANNELS];
436 : float g1, g2;
437 : int16_t lfe_index;
438 : int16_t azimuth, elevation;
439 : int16_t num_objects;
440 : uint8_t single_separated;
441 : float *input_f[MAX_TRANSPORT_CHANNELS];
442 : float *output_f_local[MAX_OUTPUT_CHANNELS];
443 : int16_t offsetSamples;
444 : int16_t n_samples_sf, md_idx;
445 : int16_t slots_to_render, first_sf, last_sf, subframe_idx;
446 :
447 18845 : hVBAPdata = st_ivas->hVBAPdata;
448 18845 : hDirACRend = st_ivas->hDirACRend;
449 18845 : hSpatParamRendCom = st_ivas->hSpatParamRendCom;
450 18845 : nchan_out_woLFE = st_ivas->hIntSetup.nchan_out_woLFE;
451 18845 : num_lfe = st_ivas->hIntSetup.num_lfe;
452 18845 : hRendererData = st_ivas->hIsmRendererData;
453 18845 : lfe_index = hDirACRend->hOutSetup.index_lfe[0];
454 :
455 18845 : if ( st_ivas->ism_mode == ISM_MASA_MODE_MASA_ONE_OBJ || st_ivas->ism_mode == ISM_MASA_MODE_PARAM_ONE_OBJ )
456 : {
457 10491 : single_separated = 1;
458 10491 : num_objects = 1;
459 : }
460 : else
461 : {
462 8354 : single_separated = 0;
463 8354 : num_objects = st_ivas->nchan_ism;
464 : }
465 :
466 191755 : for ( j = 0; j < nchan_out_woLFE + num_lfe; j++ )
467 : {
468 172910 : output_f_local[j] = output_f[j];
469 : }
470 :
471 49619 : for ( obj = 0; obj < num_objects; obj++ )
472 : {
473 30774 : input_f[obj] = input_f_in[obj];
474 : }
475 :
476 18845 : slots_to_render = nSamplesRendered / hSpatParamRendCom->slot_size;
477 18845 : first_sf = subframes_rendered;
478 18845 : last_sf = first_sf;
479 :
480 49949 : while ( slots_to_render > 0 )
481 : {
482 31104 : slots_to_render -= hSpatParamRendCom->subframe_nbslots[last_sf];
483 31104 : last_sf++;
484 : }
485 :
486 49619 : for ( obj = 0; obj < num_objects; obj++ )
487 : {
488 30774 : offsetSamples = 0;
489 :
490 81369 : for ( subframe_idx = first_sf; subframe_idx < last_sf; subframe_idx++ )
491 : {
492 50595 : n_samples_sf = hSpatParamRendCom->subframe_nbslots[subframe_idx] * hSpatParamRendCom->slot_size;
493 50595 : if ( n_samples_sf != hRendererData->interpolator_length )
494 : {
495 743036 : for ( k = 0; k < n_samples_sf; k++ )
496 : {
497 738720 : hRendererData->interpolator[k] = (float) k / ( (float) n_samples_sf );
498 : }
499 4316 : hRendererData->interpolator_length = n_samples_sf;
500 : }
501 :
502 50595 : md_idx = hSpatParamRendCom->render_to_md_map[subframe_idx];
503 :
504 50595 : if ( single_separated )
505 : {
506 17325 : if ( st_ivas->ism_mode == ISM_MASA_MODE_PARAM_ONE_OBJ && st_ivas->hMasaIsmData->ism_dir_is_edited[st_ivas->hMasaIsmData->idx_separated_ism] )
507 : {
508 0 : azimuth = st_ivas->hMasaIsmData->azimuth_ism_edited[st_ivas->hMasaIsmData->idx_separated_ism];
509 0 : elevation = st_ivas->hMasaIsmData->elevation_ism_edited[st_ivas->hMasaIsmData->idx_separated_ism];
510 : }
511 : else
512 : {
513 17325 : azimuth = st_ivas->hMasaIsmData->azimuth_separated_ism[md_idx];
514 17325 : elevation = st_ivas->hMasaIsmData->elevation_separated_ism[md_idx];
515 : }
516 : }
517 : else
518 : {
519 33270 : if ( st_ivas->hMasaIsmData->ism_dir_is_edited[obj] )
520 : {
521 4200 : azimuth = st_ivas->hMasaIsmData->azimuth_ism_edited[obj];
522 4200 : elevation = st_ivas->hMasaIsmData->elevation_ism_edited[obj];
523 : }
524 : else
525 : {
526 29070 : azimuth = st_ivas->hMasaIsmData->azimuth_ism[obj][md_idx];
527 29070 : elevation = st_ivas->hMasaIsmData->elevation_ism[obj][md_idx];
528 : }
529 : }
530 :
531 50595 : if ( st_ivas->hOutSetup.is_planar_setup )
532 : {
533 : /* If no elevation support in output format, then rendering should be done with zero elevation */
534 2175 : elevation = 0;
535 : }
536 :
537 50595 : if ( hVBAPdata != NULL )
538 : {
539 18477 : vbap_determine_gains( hVBAPdata, gains, azimuth, elevation, 1 );
540 : }
541 : else
542 : {
543 32118 : ivas_dirac_dec_get_response( azimuth, elevation, gains, hDirACRend->hOutSetup.ambisonics_order );
544 : }
545 :
546 538494 : for ( j = 0; j < nchan_out_woLFE; j++ )
547 : {
548 487899 : if ( hDirACRend->hOutSetup.num_lfe > 0 )
549 : {
550 156315 : j2 = j + ( j >= lfe_index );
551 : }
552 : else
553 : {
554 331584 : j2 = j;
555 : }
556 :
557 487899 : if ( fabsf( gains[j] ) > 0.0f || fabsf( hRendererData->prev_gains[obj][j] ) > 0.0f )
558 : {
559 74929161 : for ( k = 0; k < n_samples_sf; k++ )
560 : {
561 74551980 : g1 = hRendererData->interpolator[k];
562 74551980 : g2 = 1.0f - g1;
563 74551980 : output_f_local[j2][k + offsetSamples] += ( g1 * gains[j] + g2 * hRendererData->prev_gains[obj][j] ) * input_f[obj][k + offsetSamples];
564 : }
565 : }
566 487899 : hRendererData->prev_gains[obj][j] = gains[j];
567 : }
568 :
569 50595 : offsetSamples += n_samples_sf;
570 : }
571 : }
572 :
573 18845 : return;
574 : }
|
