Merge branch '145-static-memory-of-fastconv-binaural-handle' into 'main' (7ae1c8fb) · Commits · IVAS Codec Public Collaboration / IVAS Codec

lib_com/ivas_prot.h

+13 −2

Original line number	Diff line number	Diff line
		@@ -3235,12 +3235,23 @@ void ivas_dirac_dec_binaural(
		const int16_t nchan_transport /* i : number of transport channels */
		);

		#ifdef SRAM_REDUCTION_BINRENDERER_ROOM
		ivas_error ivas_binaural_reverb_open(
		REVERB_STRUCT_HANDLE hReverbPr, / i/o: binaural reverb handle */
		const int16_t numBins, /* i : number of CLDFB bins */
		const int16_t numCldfbSlotsPerFrame /* i : number of CLDFB slots per frame, i.e., reverberator block size */
		const int16_t numCldfbSlotsPerFrame, /* i : number of CLDFB slots per frame */
		ivas_roomAcoustics_t roomAcoustics, / i/o: room acoustics parameters */
		const AUDIO_CONFIG output_config, /* i : output audio configuration */
		const int32_t sampling_rate, /* i : sampling rate */
		const RENDERER_TYPE renderer_type /* i : renderer type */
		);

		#else
		ivas_error ivas_binaural_reverb_open(
		REVERB_STRUCT_HANDLE hReverbPr, / i/o: binaural reverb handle */
		const int16_t numBins, /* i : number of CLDFB bins */
		const int16_t numCldfbSlotsPerFrame /* i : number of CLDFB slots per frame */
		);
		#endif
		void ivas_binaural_reverb_close(
		REVERB_STRUCT_HANDLE hReverb / i/o: binaural reverb handle */
		);

lib_com/options.h

100644 → 100755

+2 −0

Original line number	Diff line number	Diff line
		@@ -152,6 +152,8 @@
		#define FIX_DIRAC_CHANNELS /* Issue 71: lower number of DirAC analysis channels */
		#define HARMONIZE_SBA_NCHAN_TRANSPORT /* harmonize setting of number of transport channels in SBA */
		#define FIX_I13_TCX_TNS_ISSUE /* Issue 13: Fix reported artifacts. Bug in TNS with TCX5 */
		#define SRAM_REDUCTION_BINRENDERER /* Issue 145: reduction of static RAM usage in fastconv binaural renderer */
		#define SRAM_REDUCTION_BINRENDERER_ROOM /* Issue 145: reduction of static RAM usage in fastconv binaural room renderer */
		#define FIX_I120_INV_SQRT /* Issue 120: inv_sqrt() shall be used instead of 1 / sqrt() to measure the correct complexity */

lib_dec/ivas_binauralRenderer.c

+191 −5

Original line number	Diff line number	Diff line
		@@ -186,6 +186,89 @@ static ivas_error ivas_binRenderer_convModuleOpen(
		}
		}

		#ifdef SRAM_REDUCTION_BINRENDERER
		/* allocate memory for filter states */
		if ( ( hBinRenConvModule->filterTapsLeftReal = (float **) count_malloc( hBinRenderer->conv_band sizeof( float ** ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterTapsLeftImag = (float **) count_malloc( hBinRenderer->conv_band sizeof( float ** ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterTapsRightReal = (float **) count_malloc( hBinRenderer->conv_band sizeof( float ** ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterTapsRightImag = (float **) count_malloc( hBinRenderer->conv_band sizeof( float ** ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		for ( bandIdx = 0; bandIdx < hBinRenderer->conv_band; bandIdx++ )
		{
		if ( ( hBinRenConvModule->filterTapsLeftReal[bandIdx] = (float *) count_malloc( hBinRenderer->nInChannels sizeof( float * ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterTapsLeftImag[bandIdx] = (float *) count_malloc( hBinRenderer->nInChannels sizeof( float * ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterTapsRightReal[bandIdx] = (float *) count_malloc( hBinRenderer->nInChannels sizeof( float * ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterTapsRightImag[bandIdx] = (float *) count_malloc( hBinRenderer->nInChannels sizeof( float * ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}
		}

		if ( ( hBinRenConvModule->filterStatesLeftReal = (float **) count_malloc( hBinRenderer->conv_band sizeof( float ** ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterStatesLeftImag = (float **) count_malloc( hBinRenderer->conv_band sizeof( float ** ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		for ( bandIdx = 0; bandIdx < hBinRenderer->conv_band; bandIdx++ )
		{
		if ( ( hBinRenConvModule->filterStatesLeftReal[bandIdx] = (float *) count_malloc( hBinRenderer->nInChannels sizeof( float * ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterStatesLeftImag[bandIdx] = (float *) count_malloc( hBinRenderer->nInChannels sizeof( float * ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		for ( chIdx = 0; chIdx < hBinRenderer->nInChannels; chIdx++ )
		{
		if ( ( hBinRenConvModule->filterStatesLeftReal[bandIdx][chIdx] = (float ) count_malloc( hBinRenConvModule->numTapsArray[bandIdx] sizeof( float ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}

		if ( ( hBinRenConvModule->filterStatesLeftImag[bandIdx][chIdx] = (float ) count_malloc( hBinRenConvModule->numTapsArray[bandIdx] sizeof( float ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Convolution Module \n" ) );
		}
		}
		}
		#endif

		/* set memories */
		for ( bandIdx = 0; bandIdx < hBinRenderer->conv_band; bandIdx++ )
		{
		for ( chIdx = 0; chIdx < hBinRenderer->nInChannels; chIdx++ )
		@@ -225,8 +308,13 @@ static ivas_error ivas_binRenderer_convModuleOpen(
		if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM && hRenderConfig->roomAcoustics.use_brir )
		{
		/* set the memories to zero */
		#ifdef SRAM_REDUCTION_BINRENDERER
		set_zero( hBinRenConvModule->filterStatesLeftReal[bandIdx][chIdx], hBinRenConvModule->numTapsArray[bandIdx] );
		set_zero( hBinRenConvModule->filterStatesLeftImag[bandIdx][chIdx], hBinRenConvModule->numTapsArray[bandIdx] );
		#else
		set_zero( hBinRenConvModule->filterStatesLeftReal[bandIdx][chIdx], hBinRenConvModule->numTaps );
		set_zero( hBinRenConvModule->filterStatesLeftImag[bandIdx][chIdx], hBinRenConvModule->numTaps );
		#endif

		if ( isLoudspeaker )
		{
		@@ -290,6 +378,9 @@ static void ivas_binaural_obtain_DMX(
		{
		int16_t chIdx, bandIdx, k;

		#ifdef SRAM_REDUCTION_BINRENDERER_ROOM
		// ToDo: hBinRenderer->ivas_format is never set to ISM_FORMAT -> TBV
		#endif
		if ( hBinRenderer->ivas_format == MC_FORMAT \|\| hBinRenderer->ivas_format == ISM_FORMAT )
		{
		/* Obtain the downmix */
		@@ -405,8 +496,10 @@ ivas_error ivas_binRenderer_open(
		{
		BINAURAL_RENDERER_HANDLE hBinRenderer;
		int16_t convBand, chIdx, k;
		#ifndef SRAM_REDUCTION_BINRENDERER_ROOM
		float t60[CLDFB_NO_CHANNELS_MAX];
		float ene[CLDFB_NO_CHANNELS_MAX];
		#endif
		ivas_error error;

		error = IVAS_ERR_OK;
		@@ -500,10 +593,17 @@ ivas_error ivas_binRenderer_open(
		/* Allocate memories needed for reverb module */
		if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM && st_ivas->hRenderConfig->roomAcoustics.late_reverb_on )
		{
		#ifdef SRAM_REDUCTION_BINRENDERER_ROOM
		if ( ( error = ivas_binaural_reverb_open( &( hBinRenderer->hReverb ), hBinRenderer->conv_band, hBinRenderer->timeSlots, &( st_ivas->hRenderConfig->roomAcoustics ), st_ivas->hIntSetup.output_config, st_ivas->hDecoderConfig->output_Fs, RENDERER_BINAURAL_FASTCONV_ROOM ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		#else
		if ( ( error = ivas_binaural_reverb_open( &( hBinRenderer->hReverb ), hBinRenderer->conv_band, hBinRenderer->timeSlots ) ) != IVAS_ERR_OK )
		{
		return error;
		}

		if ( !st_ivas->hRenderConfig->roomAcoustics.override )
		{
		ivas_binaural_reverb_setReverbTimes( hBinRenderer->hReverb, st_ivas->hDecoderConfig->output_Fs, fastconvReverberationTimes, fastconvReverberationEneCorrections );
		@@ -517,6 +617,8 @@ ivas_error ivas_binRenderer_open(
		}

		hBinRenderer->hReverb->useBinauralCoherence = 1;
		#endif

		/* initialize the dmx matrix */
		for ( chIdx = 0; chIdx < BINAURAL_CHANNELS; chIdx++ )
		{
		@@ -560,6 +662,86 @@ ivas_error ivas_binRenderer_open(
		return error;
		}

		#ifdef SRAM_REDUCTION_BINRENDERER
		/*-------------------------------------------------------------------------
		* ivas_binRenderer_convModuleClose()
		*
		* Close convolution module handle of fastconv binaural renderer
		------------------------------------------------------------------------/

		static void ivas_binRenderer_convModuleClose(
		BINAURAL_RENDERER_HANDLE hBinRenderer / i/o: fastconv binaural renderer handle */
		)
		{
		int16_t bandIdx, chIdx;
		BINRENDERER_CONV_MODULE_HANDLE hBinRenConvModule;

		hBinRenConvModule = ( *hBinRenderer )->hBinRenConvModule;

		if ( hBinRenConvModule == NULL )
		{
		return;
		}

		for ( bandIdx = 0; bandIdx < ( *hBinRenderer )->conv_band; bandIdx++ )
		{
		count_free( hBinRenConvModule->filterTapsLeftReal[bandIdx] );
		hBinRenConvModule->filterTapsLeftReal[bandIdx] = NULL;

		count_free( hBinRenConvModule->filterTapsLeftImag[bandIdx] );
		hBinRenConvModule->filterTapsLeftImag[bandIdx] = NULL;

		count_free( hBinRenConvModule->filterTapsRightReal[bandIdx] );
		hBinRenConvModule->filterTapsRightReal[bandIdx] = NULL;

		count_free( hBinRenConvModule->filterTapsRightImag[bandIdx] );
		hBinRenConvModule->filterTapsRightImag[bandIdx] = NULL;
		}

		count_free( hBinRenConvModule->filterTapsLeftReal );
		hBinRenConvModule->filterTapsLeftReal = NULL;

		count_free( hBinRenConvModule->filterTapsLeftImag );
		hBinRenConvModule->filterTapsLeftImag = NULL;

		count_free( hBinRenConvModule->filterTapsRightReal );
		hBinRenConvModule->filterTapsRightReal = NULL;

		count_free( hBinRenConvModule->filterTapsRightImag );
		hBinRenConvModule->filterTapsRightImag = NULL;


		for ( bandIdx = 0; bandIdx < ( *hBinRenderer )->conv_band; bandIdx++ )
		{
		for ( chIdx = 0; chIdx < ( *hBinRenderer )->nInChannels; chIdx++ )
		{
		count_free( hBinRenConvModule->filterStatesLeftReal[bandIdx][chIdx] );
		hBinRenConvModule->filterStatesLeftReal[bandIdx][chIdx] = NULL;

		count_free( hBinRenConvModule->filterStatesLeftImag[bandIdx][chIdx] );
		hBinRenConvModule->filterStatesLeftImag[bandIdx][chIdx] = NULL;
		}

		count_free( hBinRenConvModule->filterStatesLeftReal[bandIdx] );
		hBinRenConvModule->filterStatesLeftReal[bandIdx] = NULL;

		count_free( hBinRenConvModule->filterStatesLeftImag[bandIdx] );
		hBinRenConvModule->filterStatesLeftImag[bandIdx] = NULL;
		}

		count_free( hBinRenConvModule->filterStatesLeftReal );
		hBinRenConvModule->filterStatesLeftReal = NULL;

		count_free( hBinRenConvModule->filterStatesLeftImag );
		hBinRenConvModule->filterStatesLeftImag = NULL;


		count_free( ( *hBinRenderer )->hBinRenConvModule );
		( *hBinRenderer )->hBinRenConvModule = NULL;

		return;
		}
		#endif

		/*-------------------------------------------------------------------------
		* ivas_binRenderer_close()
		@@ -578,8 +760,12 @@ void ivas_binRenderer_close(

		if ( ( *hBinRenderer )->hBinRenConvModule != NULL )
		{
		#ifdef SRAM_REDUCTION_BINRENDERER
		ivas_binRenderer_convModuleClose( hBinRenderer );
		#else
		count_free( ( *hBinRenderer )->hBinRenConvModule );
		( *hBinRenderer )->hBinRenConvModule = NULL;
		#endif
		}

		if ( ( *hBinRenderer )->hReverb != NULL )
		@@ -775,10 +961,10 @@ void ivas_binRenderer(
		/* Obtain the binaural dmx and compute the reverb */
		if ( hBinRenderer->hReverb != NULL )
		{
		float reverbRe[2][CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
		float reverbIm[2][CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
		float inRe[2][CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
		float inIm[2][CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
		float reverbRe[BINAURAL_CHANNELS][CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
		float reverbIm[BINAURAL_CHANNELS][CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
		float inRe[BINAURAL_CHANNELS][CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];
		float inIm[BINAURAL_CHANNELS][CLDFB_NO_COL_MAX][CLDFB_NO_CHANNELS_MAX];

		ivas_binaural_obtain_DMX( numTimeSlots, hBinRenderer, RealBuffer, ImagBuffer, inRe, inIm );

		@@ -791,7 +977,7 @@ void ivas_binRenderer(
		}
		}

		ivas_binaural_reverb_processFrame( hBinRenderer->hReverb, 2, inRe, inIm, reverbRe, reverbIm, 0u );
		ivas_binaural_reverb_processFrame( hBinRenderer->hReverb, BINAURAL_CHANNELS, inRe, inIm, reverbRe, reverbIm, 0u );

		/* Add the conv module and reverb module output */
		for ( chIdx = 0; chIdx < BINAURAL_CHANNELS; chIdx++ )

lib_dec/ivas_binaural_reverb.c

+144 −2

Original line number	Diff line number	Diff line
		@@ -36,6 +36,9 @@
		#include "ivas_prot.h"
		#include "prot.h"
		#include "ivas_rom_com.h"
		#ifdef SRAM_REDUCTION_BINRENDERER_ROOM
		#include "ivas_rom_binauralRenderer.h"
		#endif
		#ifdef DEBUGGING
		#include "debug.h"
		#endif
		@@ -312,12 +315,13 @@ void ivas_binaural_reverb_setReverbTimes(
		}
		hReverb->binauralCoherenceDirectGains[bin] = sqrtf( 1.0f - fabsf( tmpVal ) );

		#ifndef SRAM_REDUCTION_BINRENDERER_ROOM
		/* Determine loop buffer length. The following formula is manually tuned to generate sufficiently long
		* but not excessively long loops to generate reverberation. */
		/* Note: the resulted length is very sensitive to the precision of the constants below (e.g. 1.45 vs. 1.45f) */
		hReverb->loopBufLength[bin] = (int16_t) ( 1.45 * (int16_t) ( revTimes[bin] * 150.0 ) + 1 );
		hReverb->loopBufLength[bin] = min( hReverb->loopBufLength[bin], hReverb->loopBufLengthMax[bin] );

		#endif
		/* Determine attenuation factor that generates the appropriate energy decay according to reverberation time */
		attenuationFactorPerSample = powf( 10.0f, -3.0f * ( 1.0f / ( (float) CLDFB_SLOTS_PER_SECOND * revTimes[bin] ) ) );
		hReverb->loopAttenuationFactor[bin] = powf( attenuationFactorPerSample, hReverb->loopBufLength[bin] );
		@@ -371,6 +375,144 @@ void ivas_binaural_reverb_setReverbTimes(
		* Allocate and initialize binaural room reverberator handle
		------------------------------------------------------------------------/

		#ifdef SRAM_REDUCTION_BINRENDERER_ROOM
		ivas_error ivas_binaural_reverb_open(
		REVERB_STRUCT_HANDLE hReverbPr, / i/o: binaural reverb handle */
		const int16_t numBins, /* i : number of CLDFB bins */
		const int16_t numCldfbSlotsPerFrame, /* i : number of CLDFB slots per frame */
		ivas_roomAcoustics_t roomAcoustics, / i/o: room acoustics parameters */
		const AUDIO_CONFIG output_config, /* i : output audio configuration */
		const int32_t sampling_rate, /* i : sampling rate */
		const RENDERER_TYPE renderer_type /* i : renderer type */
		)
		{
		int16_t bin, chIdx, k, len;
		REVERB_STRUCT_HANDLE hReverb;
		const float *revTimes;
		float t60[CLDFB_NO_CHANNELS_MAX];
		float ene[CLDFB_NO_CHANNELS_MAX];

		if ( ( *hReverbPr = (REVERB_STRUCT_HANDLE) count_malloc( sizeof( REVERB_STRUCT ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural Reverberator\n" ) );
		}

		hReverb = *hReverbPr;

		hReverb->useBinauralCoherence = 1;
		hReverb->preDelayBufferLength = 1;
		hReverb->preDelayBufferIndex = 0;

		hReverb->numBins = numBins;
		hReverb->blockSize = numCldfbSlotsPerFrame;

		for ( k = 0; k < REVERB_PREDELAY_MAX + 1; k++ )
		{
		set_f( hReverb->preDelayBufferReal[k], 0.0f, hReverb->numBins );
		set_f( hReverb->preDelayBufferImag[k], 0.0f, hReverb->numBins );
		}

		if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
		{
		if ( !roomAcoustics->override )
		{
		revTimes = fastconvReverberationTimes;
		}
		else
		{
		revTimes = t60;
		}
		}
		else
		{
		revTimes = parametricReverberationTimes;
		}

		for ( bin = 0; bin < hReverb->numBins; bin++ )
		{
		/* Loop Buffer */
		hReverb->loopBufLengthMax[bin] = (int16_t) ( 500 / ( 1 + bin ) + ( CLDFB_NO_CHANNELS_MAX - bin ) );

		len = hReverb->loopBufLengthMax[bin] + hReverb->blockSize;
		if ( ( hReverb->loopBufReal[bin] = (float ) count_malloc( len sizeof( float ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural Reverberator\n" ) );
		}

		if ( ( hReverb->loopBufImag[bin] = (float ) count_malloc( len sizeof( float ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural Reverberator\n" ) );
		}

		set_f( hReverb->loopBufReal[bin], 0.0f, len );
		set_f( hReverb->loopBufImag[bin], 0.0f, len );

		/* Determine loop buffer length. The following formula is manually tuned to generate sufficiently long
		* but not excessively long loops to generate reverberation. */
		/* Note: the resulted length is very sensitive to the precision of the constants below (e.g. 1.45 vs. 1.45f) */
		hReverb->loopBufLength[bin] = (int16_t) ( 1.45 * (int16_t) ( revTimes[bin] * 150.0 ) + 1 );
		hReverb->loopBufLength[bin] = min( hReverb->loopBufLength[bin], hReverb->loopBufLengthMax[bin] );

		/* Sparse Filter Tap Locations */
		for ( chIdx = 0; chIdx < BINAURAL_CHANNELS; chIdx++ )
		{
		len = hReverb->loopBufLength[bin];

		if ( ( hReverb->tapPhaseShiftType[bin][chIdx] = (int16_t ) count_malloc( len sizeof( int16_t ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural Reverberator\n" ) );
		}
		set_s( hReverb->tapPhaseShiftType[bin][chIdx], 0, len );

		if ( ( hReverb->tapPointersReal[bin][chIdx] = (float *) count_malloc( len sizeof( float * ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural Reverberator\n" ) );
		}

		if ( ( hReverb->tapPointersImag[bin][chIdx] = (float *) count_malloc( len sizeof( float * ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural Reverberator\n" ) );
		}

		len = hReverb->blockSize;
		if ( ( hReverb->outputBufferReal[bin][chIdx] = (float ) count_malloc( len sizeof( float ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural Reverberator\n" ) );
		}

		if ( ( hReverb->outputBufferImag[bin][chIdx] = (float ) count_malloc( len sizeof( float ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural Reverberator\n" ) );
		}

		set_f( hReverb->outputBufferReal[bin][chIdx], 0.0f, len );
		set_f( hReverb->outputBufferImag[bin][chIdx], 0.0f, len );
		}
		}

		if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
		{
		if ( !roomAcoustics->override )
		{
		ivas_binaural_reverb_setReverbTimes( hReverb, sampling_rate, fastconvReverberationTimes, fastconvReverberationEneCorrections );
		ivas_binaural_reverb_setPreDelay( hReverb, 10 );
		}
		else
		{
		ivas_reverb_prepare_cldfb_params( roomAcoustics, output_config, roomAcoustics->use_brir, sampling_rate, t60, ene );
		ivas_binaural_reverb_setReverbTimes( hReverb, sampling_rate, t60, ene );
		ivas_binaural_reverb_setPreDelay( hReverb, (int16_t) roundf( 48000.0f * roomAcoustics->acousticPreDelay / CLDFB_NO_CHANNELS_MAX ) );
		}
		}
		else
		{
		ivas_binaural_reverb_setReverbTimes( hReverb, sampling_rate, parametricReverberationTimes, parametricReverberationEneCorrections );
		ivas_binaural_reverb_setPreDelay( hReverb, 10 );
		}

		return IVAS_ERR_OK;
		}
		#else
		ivas_error ivas_binaural_reverb_open(
		REVERB_STRUCT_HANDLE hReverbPr, / i/o: binaural reverb handle */
		const int16_t numBins, /* i : number of CLDFB bins */
		@@ -459,7 +601,7 @@ ivas_error ivas_binaural_reverb_open(

		return IVAS_ERR_OK;
		}

		#endif

		/*-------------------------------------------------------------------------
		* ivas_binaural_reverb_close()

lib_dec/ivas_dirac_dec_binaural_functions.c

+18 −0

Original line number	Diff line number	Diff line
		@@ -188,6 +188,22 @@ ivas_error ivas_dirac_dec_init_binaural_data(
		else if ( renderer_type == RENDERER_BINAURAL_PARAMETRIC_ROOM ) /* Indication of binaural rendering with room effect */
		{
		mvr2r( parametricEarlyPartEneCorrection, hBinaural->earlyPartEneCorrection, nBins );
		#ifdef SRAM_REDUCTION_BINRENDERER_ROOM
		if ( hBinaural->useSubframeMode )
		{
		if ( ( error = ivas_binaural_reverb_open( &hBinaural->hReverb, nBins, CLDFB_NO_COL_MAX / MAX_PARAM_SPATIAL_SUBFRAMES, NULL, st_ivas->hIntSetup.output_config, output_Fs, RENDERER_BINAURAL_PARAMETRIC_ROOM ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		}
		else
		{
		if ( ( error = ivas_binaural_reverb_open( &hBinaural->hReverb, nBins, CLDFB_NO_COL_MAX, NULL, st_ivas->hIntSetup.output_config, output_Fs, RENDERER_BINAURAL_PARAMETRIC_ROOM ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		}
		#else
		if ( hBinaural->useSubframeMode )
		{
		if ( ( error = ivas_binaural_reverb_open( &hBinaural->hReverb, nBins, CLDFB_NO_COL_MAX / MAX_PARAM_SPATIAL_SUBFRAMES ) ) != IVAS_ERR_OK )
		@@ -202,9 +218,11 @@ ivas_error ivas_dirac_dec_init_binaural_data(
		return error;
		}
		}

		ivas_binaural_reverb_setReverbTimes( hBinaural->hReverb, output_Fs, parametricReverberationTimes, parametricReverberationEneCorrections );
		hBinaural->hReverb->useBinauralCoherence = 1;
		ivas_binaural_reverb_setPreDelay( hBinaural->hReverb, 10 );
		#endif
		}
		else if ( renderer_type == RENDERER_STEREO_PARAMETRIC )
		{

Admin message