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 589 : 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 589 : 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 589 : if ( st_ivas->hIntSetup.is_loudspeaker_setup &&
70 215 : st_ivas->hDecoderConfig->output_config != IVAS_AUDIO_CONFIG_STEREO &&
71 184 : st_ivas->hIntSetup.ls_azimuth != NULL && st_ivas->hIntSetup.ls_elevation != NULL &&
72 184 : st_ivas->hEFAPdata == NULL )
73 : {
74 184 : 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 2945 : for ( i = 0; i < MAX_NUM_OBJECTS; i++ )
81 : {
82 2356 : set_f( st_ivas->hIsmRendererData->prev_gains[i], 0.0f, MAX_OUTPUT_CHANNELS );
83 2356 : set_f( st_ivas->hIsmRendererData->gains[i], 0.0f, MAX_OUTPUT_CHANNELS );
84 : }
85 :
86 589 : if ( st_ivas->hDecoderConfig->Opt_tsm )
87 : {
88 195 : init_interpolator_length = NS2SA( st_ivas->hDecoderConfig->output_Fs, MAX_JBM_CLDFB_TIMESLOTS * CLDFB_SLOT_NS );
89 195 : interpolator_length = (uint16_t) ( st_ivas->hDecoderConfig->output_Fs / FRAMES_PER_SEC );
90 : }
91 : else
92 : {
93 394 : init_interpolator_length = (uint16_t) ( st_ivas->hDecoderConfig->output_Fs / FRAMES_PER_SEC );
94 394 : interpolator_length = init_interpolator_length;
95 : }
96 :
97 589 : 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 507149 : for ( i = 0; i < interpolator_length; i++ )
103 : {
104 506560 : st_ivas->hIsmRendererData->interpolator[i] = (float) i / ( (float) interpolator_length - 1 );
105 : }
106 :
107 589 : return IVAS_ERR_OK;
108 : }
109 :
110 :
111 : /*-------------------------------------------------------------------------*
112 : * ivas_ism_renderer_close()
113 : *
114 : * Close struct for object rendering.
115 : *-------------------------------------------------------------------------*/
116 :
117 4467 : void ivas_ism_renderer_close(
118 : ISM_RENDERER_HANDLE *hIsmRendererData /* i/o: ISM renderer handle */
119 : )
120 : {
121 4467 : if ( hIsmRendererData == NULL || *hIsmRendererData == NULL )
122 : {
123 3365 : return;
124 : }
125 :
126 1102 : if ( ( *hIsmRendererData )->interpolator != NULL )
127 : {
128 1102 : free( ( *hIsmRendererData )->interpolator );
129 1102 : ( *hIsmRendererData )->interpolator = NULL;
130 : }
131 :
132 1102 : free( *hIsmRendererData );
133 1102 : *hIsmRendererData = NULL;
134 :
135 1102 : return;
136 : }
137 :
138 :
139 : /*-------------------------------------------------------------------------*
140 : * ivas_ism_render_sf()
141 : *
142 : * Object rendering process
143 : *-------------------------------------------------------------------------*/
144 :
145 27911 : 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 27911 : 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 27911 : first_sf = st_ivas->hTcBuffer->subframes_rendered;
167 27911 : last_sf = first_sf;
168 27911 : n_samples_rendered_loop = 0;
169 :
170 134069 : while ( slots_to_render > 0 )
171 : {
172 106158 : slots_to_render -= st_ivas->hTcBuffer->subframe_nbslots[last_sf];
173 106158 : last_sf++;
174 : }
175 : #ifdef DEBUGGING
176 : assert( slots_to_render == 0 );
177 : assert( last_sf <= st_ivas->hTcBuffer->nb_subframes );
178 : #endif
179 27911 : num_objects = st_ivas->nchan_ism;
180 :
181 27911 : nchan_out_woLFE = st_ivas->hIntSetup.nchan_out_woLFE;
182 :
183 27911 : tc_offset = st_ivas->hTcBuffer->n_samples_rendered;
184 27911 : interp_offset = st_ivas->hTcBuffer->n_samples_rendered;
185 :
186 : /* Number of subframes to delay metadata to sync with audio */
187 27911 : if ( st_ivas->hDecoderConfig->Opt_delay_comp )
188 : {
189 24543 : ism_md_subframe_update_jbm = max( 0, st_ivas->hTcBuffer->nb_subframes - 3 );
190 : }
191 : else
192 : {
193 3368 : ism_md_subframe_update_jbm = st_ivas->hTcBuffer->nb_subframes - 2;
194 : }
195 :
196 104593 : for ( i = 0; i < num_objects; i++ )
197 : {
198 76682 : mvr2r( &output_f[i][tc_offset], tc_local[i], n_samples_to_render );
199 76682 : p_tc[i] = tc_local[i];
200 : }
201 :
202 280275 : for ( i = 0; i < nchan_out_woLFE + st_ivas->hIntSetup.num_lfe; i++ )
203 : {
204 252364 : set_f( output_f[i], 0.0f, n_samples_to_render );
205 : }
206 :
207 134069 : for ( subframe_idx = first_sf; subframe_idx < last_sf; subframe_idx++ )
208 : {
209 : int16_t n_samples_in_subframe;
210 :
211 106158 : n_samples_in_subframe = st_ivas->hTcBuffer->n_samples_granularity * st_ivas->hTcBuffer->subframe_nbslots[subframe_idx];
212 :
213 106158 : if ( st_ivas->hCombinedOrientationData && st_ivas->hCombinedOrientationData->enableCombinedOrientation[st_ivas->hCombinedOrientationData->subframe_idx] == 1 )
214 : {
215 11992 : ivas_jbm_dec_get_adapted_linear_interpolator( n_samples_in_subframe, n_samples_in_subframe, st_ivas->hIsmRendererData->interpolator );
216 11992 : interp_offset = 0;
217 : }
218 :
219 396428 : for ( i = 0; i < num_objects; i++ )
220 : {
221 : /* Combined rotation: rotate the object positions depending the head and external orientations */
222 290270 : if ( st_ivas->hCombinedOrientationData != NULL && st_ivas->hCombinedOrientationData->enableCombinedOrientation[st_ivas->hCombinedOrientationData->subframe_idx] == 1 )
223 : {
224 11992 : if ( subframe_idx >= ism_md_subframe_update_jbm )
225 : {
226 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 );
227 : }
228 : else
229 : {
230 2998 : 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 11992 : if ( st_ivas->hEFAPdata != NULL )
234 : {
235 11992 : efap_determine_gains( st_ivas->hEFAPdata, st_ivas->hIsmRendererData->gains[i], azimuth, elevation, EFAP_MODE_EFAP );
236 11992 : 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 290270 : lfe_index = 0;
241 2700659 : for ( j = 0, j2 = 0; j < nchan_out_woLFE; j++, j2++ )
242 : {
243 2410389 : if ( ( st_ivas->hIntSetup.num_lfe > 0 ) && ( st_ivas->hIntSetup.index_lfe[lfe_index] == j ) )
244 : {
245 177787 : ( lfe_index < ( st_ivas->hIntSetup.num_lfe - 1 ) ) ? ( lfe_index++, j2++ ) : j2++;
246 : }
247 :
248 2410389 : gain = st_ivas->hIsmRendererData->gains[i][j];
249 2410389 : prev_gain = st_ivas->hIsmRendererData->prev_gains[i][j];
250 2410389 : if ( fabsf( gain ) > 0.0f || fabsf( prev_gain ) > 0.0f )
251 : {
252 1217721 : g1 = &st_ivas->hIsmRendererData->interpolator[interp_offset];
253 1217721 : tc = p_tc[i];
254 265609801 : for ( k = 0; k < n_samples_in_subframe; k++ )
255 : {
256 264392080 : g2 = 1.0f - *g1;
257 264392080 : 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 2410389 : if ( st_ivas->hCombinedOrientationData != NULL && st_ivas->hCombinedOrientationData->enableCombinedOrientation[st_ivas->hCombinedOrientationData->subframe_idx] == 1 )
263 : {
264 131912 : st_ivas->hIsmRendererData->prev_gains[i][j] = gain;
265 : }
266 : }
267 290270 : p_tc[i] += n_samples_in_subframe;
268 : }
269 :
270 : /* update combined orientation access index */
271 106158 : ivas_combined_orientation_update_index( st_ivas->hCombinedOrientationData, n_samples_in_subframe );
272 :
273 106158 : 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 106158 : if ( renderer_type != RENDERER_BINAURAL_MIXER_CONV_ROOM )
277 : {
278 62961 : st_ivas->hTcBuffer->subframes_rendered += 1;
279 62961 : st_ivas->hTcBuffer->slots_rendered += st_ivas->hTcBuffer->subframe_nbslots[subframe_idx];
280 : }
281 106158 : tc_offset += n_samples_in_subframe;
282 106158 : interp_offset += n_samples_in_subframe;
283 : }
284 :
285 27911 : return;
286 : }
287 :
288 :
289 : /*-------------------------------------------------------------------------*
290 : * ivas_ism_get_stereo_gains()
291 : *
292 : *
293 : *-------------------------------------------------------------------------*/
294 :
295 169460 : 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 169460 : const float LsAngleRad = 30.0f * PI_OVER_180;
305 :
306 : /* Convert azi and ele to an azi value of the cone of confusion */
307 169460 : aziRad = azimuth * PI_OVER_180;
308 169460 : eleRad = elevation * PI_OVER_180;
309 169460 : y = ( sinf( aziRad ) * cosf( eleRad ) );
310 169460 : mappedX = sqrtf( max( 0.0f, 1.0f - ( y * y ) ) );
311 169460 : aziRadMapped = atan2f( y, mappedX );
312 :
313 : /* Determine the amplitude panning gains */
314 169460 : if ( aziRadMapped >= LsAngleRad )
315 : { /* Left side */
316 34440 : *left_gain = 1.0f;
317 34440 : *right_gain = 0.0f;
318 : }
319 135020 : else if ( aziRadMapped <= -LsAngleRad )
320 : { /* Right side */
321 35891 : *left_gain = 0.0f;
322 35891 : *right_gain = 1.0f;
323 : }
324 : else /* Tangent panning law */
325 : {
326 99129 : A = tanf( aziRadMapped ) / tanf( LsAngleRad );
327 99129 : A2 = ( A - 1.0f ) / max( 0.001f, A + 1.0f );
328 99129 : A3 = 1.0f / ( A2 * A2 + 1.0f );
329 99129 : *left_gain = sqrtf( A3 );
330 99129 : *right_gain = sqrtf( 1.0f - A3 );
331 : }
332 :
333 169460 : return;
334 : }
335 :
336 :
337 : /*-------------------------------------------------------------------------*
338 : * ivas_omasa_separate_object_renderer_open()
339 : *
340 : * Open structures, reserve memory, and init values.
341 : *-------------------------------------------------------------------------*/
342 :
343 495 : 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 495 : 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 2475 : for ( i = 0; i < MAX_NUM_OBJECTS; i++ )
357 : {
358 1980 : set_f( st_ivas->hIsmRendererData->prev_gains[i], 0.0f, MAX_OUTPUT_CHANNELS );
359 : }
360 :
361 495 : init_interpolator_length = (int16_t) ( st_ivas->hDecoderConfig->output_Fs / FRAMES_PER_SEC / MAX_PARAM_SPATIAL_SUBFRAMES );
362 495 : interpolator_length = init_interpolator_length;
363 495 : 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 119055 : for ( i = 0; i < interpolator_length; i++ )
369 : {
370 118560 : st_ivas->hIsmRendererData->interpolator[i] = (float) i / ( (float) interpolator_length );
371 : }
372 495 : st_ivas->hIsmRendererData->interpolator_length = interpolator_length;
373 :
374 495 : return IVAS_ERR_OK;
375 : }
376 :
377 :
378 : /*-------------------------------------------------------------------------*
379 : * ivas_omasa_separate_object_renderer_close()
380 : *
381 : * Close structures, free memory.
382 : *-------------------------------------------------------------------------*/
383 :
384 2133 : 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 2133 : if ( st_ivas->hMasaIsmData != NULL )
391 : {
392 2133 : if ( st_ivas->hMasaIsmData->delayBuffer != NULL )
393 : {
394 1804 : for ( i = 0; i < st_ivas->hMasaIsmData->delayBuffer_nchan; i++ )
395 : {
396 1204 : if ( st_ivas->hMasaIsmData->delayBuffer[i] != NULL )
397 : {
398 1204 : free( st_ivas->hMasaIsmData->delayBuffer[i] );
399 1204 : st_ivas->hMasaIsmData->delayBuffer[i] = NULL;
400 : }
401 : }
402 :
403 600 : free( st_ivas->hMasaIsmData->delayBuffer );
404 600 : st_ivas->hMasaIsmData->delayBuffer = NULL;
405 : }
406 : }
407 :
408 2133 : ivas_ism_renderer_close( &st_ivas->hIsmRendererData );
409 :
410 2133 : 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 2979 : 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 2979 : hVBAPdata = st_ivas->hVBAPdata;
448 2979 : hDirACRend = st_ivas->hDirACRend;
449 2979 : hSpatParamRendCom = st_ivas->hSpatParamRendCom;
450 2979 : nchan_out_woLFE = st_ivas->hIntSetup.nchan_out_woLFE;
451 2979 : num_lfe = st_ivas->hIntSetup.num_lfe;
452 2979 : hRendererData = st_ivas->hIsmRendererData;
453 2979 : lfe_index = hDirACRend->hOutSetup.index_lfe[0];
454 :
455 2979 : if ( st_ivas->ism_mode == ISM_MASA_MODE_MASA_ONE_OBJ || st_ivas->ism_mode == ISM_MASA_MODE_PARAM_ONE_OBJ )
456 : {
457 1652 : single_separated = 1;
458 1652 : num_objects = 1;
459 : }
460 : else
461 : {
462 1327 : single_separated = 0;
463 1327 : num_objects = st_ivas->nchan_ism;
464 : }
465 :
466 29421 : for ( j = 0; j < nchan_out_woLFE + num_lfe; j++ )
467 : {
468 26442 : output_f_local[j] = output_f[j];
469 : }
470 :
471 7896 : for ( obj = 0; obj < num_objects; obj++ )
472 : {
473 4917 : input_f[obj] = input_f_in[obj];
474 : }
475 :
476 2979 : slots_to_render = nSamplesRendered / hSpatParamRendCom->slot_size;
477 2979 : first_sf = subframes_rendered;
478 2979 : last_sf = first_sf;
479 :
480 13511 : while ( slots_to_render > 0 )
481 : {
482 10532 : slots_to_render -= hSpatParamRendCom->subframe_nbslots[last_sf];
483 10532 : last_sf++;
484 : }
485 :
486 7896 : for ( obj = 0; obj < num_objects; obj++ )
487 : {
488 4917 : offsetSamples = 0;
489 :
490 22054 : for ( subframe_idx = first_sf; subframe_idx < last_sf; subframe_idx++ )
491 : {
492 17137 : n_samples_sf = hSpatParamRendCom->subframe_nbslots[subframe_idx] * hSpatParamRendCom->slot_size;
493 17137 : if ( n_samples_sf != hRendererData->interpolator_length )
494 : {
495 448223 : for ( k = 0; k < n_samples_sf; k++ )
496 : {
497 445620 : hRendererData->interpolator[k] = (float) k / ( (float) n_samples_sf );
498 : }
499 2603 : hRendererData->interpolator_length = n_samples_sf;
500 : }
501 :
502 17137 : md_idx = hSpatParamRendCom->render_to_md_map[subframe_idx];
503 :
504 17137 : if ( single_separated )
505 : {
506 5885 : 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 5885 : azimuth = st_ivas->hMasaIsmData->azimuth_separated_ism[md_idx];
514 5885 : elevation = st_ivas->hMasaIsmData->elevation_separated_ism[md_idx];
515 : }
516 : }
517 : else
518 : {
519 11252 : if ( st_ivas->hMasaIsmData->ism_dir_is_edited[obj] )
520 : {
521 1400 : azimuth = st_ivas->hMasaIsmData->azimuth_ism_edited[obj];
522 1400 : elevation = st_ivas->hMasaIsmData->elevation_ism_edited[obj];
523 : }
524 : else
525 : {
526 9852 : azimuth = st_ivas->hMasaIsmData->azimuth_ism[obj][md_idx];
527 9852 : elevation = st_ivas->hMasaIsmData->elevation_ism[obj][md_idx];
528 : }
529 : }
530 :
531 17137 : 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 725 : elevation = 0;
535 : }
536 :
537 17137 : if ( hVBAPdata != NULL )
538 : {
539 6431 : vbap_determine_gains( hVBAPdata, gains, azimuth, elevation, 1 );
540 : }
541 : else
542 : {
543 10706 : ivas_dirac_dec_get_response( azimuth, elevation, gains, hDirACRend->hOutSetup.ambisonics_order );
544 : }
545 :
546 181674 : for ( j = 0; j < nchan_out_woLFE; j++ )
547 : {
548 164537 : if ( hDirACRend->hOutSetup.num_lfe > 0 )
549 : {
550 54009 : j2 = j + ( j >= lfe_index );
551 : }
552 : else
553 : {
554 110528 : j2 = j;
555 : }
556 :
557 164537 : if ( fabsf( gains[j] ) > 0.0f || fabsf( hRendererData->prev_gains[obj][j] ) > 0.0f )
558 : {
559 24980464 : for ( k = 0; k < n_samples_sf; k++ )
560 : {
561 24853780 : g1 = hRendererData->interpolator[k];
562 24853780 : g2 = 1.0f - g1;
563 24853780 : output_f_local[j2][k + offsetSamples] += ( g1 * gains[j] + g2 * hRendererData->prev_gains[obj][j] ) * input_f[obj][k + offsetSamples];
564 : }
565 : }
566 164537 : hRendererData->prev_gains[obj][j] = gains[j];
567 : }
568 :
569 17137 : offsetSamples += n_samples_sf;
570 : }
571 : }
572 :
573 2979 : return;
574 : }
|
