[cleanup] accept FIX_1123_CREND_FLTFX_BE, FIX_1123_FASTCONV_16BIT_FMT (eab3359f) · Commits · IVAS Codec Public Collaboration / IVAS Codec

lib_com/options.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -170,8 +170,6 @@
		#define TMP_FIX_1119_SPLIT_RENDERING_VOIP /* FhG: Add error check for unsupported config: split rendering with VoIP mode */

		#define FIX_POINT_ROM_CONST /* Ora: issue #1150 HRTF ROM tables should be defined as 'const'*/
		#define FIX_1123_CREND_FLTFX_BE /* Ora: make CREND FLT ROM tables BE to FX file */
		#define FIX_1123_FASTCONV_16BIT_FMT /* FhG: issue 1123: update FastConv binary file format and scripts to 16 bit */
		#define FIX_RETURN /* VA: fix location of function returns */
		#define FIX_1135_EXT_RENDERER_HANDLES /* VA: issue 1135: Memory usage reduction in external renderer: Allocate only handles that are really needed. */
		#define FIX_1158_FASTCONV_REVERB_HRTF /* Philips: issue 1158: Rendering with FastConv to BINAURAL_ROOM_REVERB uses BRIR convolution instead of HRTF */

lib_dec/ivas_binRenderer_internal.c

+0 −117

Original line number	Diff line number	Diff line
		@@ -167,11 +167,7 @@ static ivas_error ivas_binRenderer_convModuleOpen(

		if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )
		{
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		hBinRenConvModule->numTaps = hHrtf->ntaps_brir;
		#else
		hBinRenConvModule->numTaps = BINAURAL_NTAPS_MAX;
		#endif

		/* Use variable order filtering */
		bandIdx = 0;
		@@ -200,7 +196,6 @@ static ivas_error ivas_binRenderer_convModuleOpen(
		{
		if ( hBinRenderer->ivas_format == SBA_FORMAT )
		{
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		if ( input_config == IVAS_AUDIO_CONFIG_HOA3 )
		{
		hBinRenConvModule->numTaps = hHrtf->ntaps_hrir_hoa3;
		@@ -217,17 +212,10 @@ static ivas_error ivas_binRenderer_convModuleOpen(
		{
		return IVAS_ERR_INVALID_INPUT_FORMAT;
		}
		#else
		hBinRenConvModule->numTaps = BINAURAL_NTAPS_SBA;
		#endif
		}
		else
		{
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		hBinRenConvModule->numTaps = hHrtf->ntaps_hrir;
		#else
		hBinRenConvModule->numTaps = BINAURAL_NTAPS;
		#endif
		}

		/* Use fixed order filtering */
		@@ -492,13 +480,11 @@ void ivas_init_binaural_hrtf(
		HrtfFastConv->FASTCONV_FOA_latency_s = 0x00;

		HrtfFastConv->allocate_init_flag = 0x00;
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		HrtfFastConv->ntaps_hrir = BINAURAL_NTAPS;
		HrtfFastConv->ntaps_hrir_foa = BINAURAL_NTAPS_SBA;
		HrtfFastConv->ntaps_hrir_hoa2 = BINAURAL_NTAPS_SBA;
		HrtfFastConv->ntaps_hrir_hoa3 = BINAURAL_NTAPS_SBA;
		HrtfFastConv->ntaps_brir = BINAURAL_NTAPS_MAX;
		#endif

		for ( i = 0; i < CLDFB_NO_CHANNELS_MAX; i++ )
		{
		@@ -577,7 +563,6 @@ ivas_error ivas_allocate_binaural_hrtf(
		}
		else
		{
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, HrtfFastConv->ntaps_hrir_hoa3, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_HOA3" );
		@@ -594,24 +579,6 @@ ivas_error ivas_allocate_binaural_hrtf(
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_HOA3" );
		}
		#else
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_HOA3" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRImag_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_HOA3" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRReal_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_HOA3" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRImag_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_HOA3" );
		}
		#endif
		}
		}

		@@ -623,7 +590,6 @@ ivas_error ivas_allocate_binaural_hrtf(
		}
		else
		{
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, HrtfFastConv->ntaps_hrir_hoa2, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_HOA2" );
		@@ -640,24 +606,6 @@ ivas_error ivas_allocate_binaural_hrtf(
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_HOA2" );
		}
		#else
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_HOA2" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRImag_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_HOA2" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRReal_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_HOA2" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRImag_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_HOA2" );
		}
		#endif
		}
		}

		@@ -669,7 +617,6 @@ ivas_error ivas_allocate_binaural_hrtf(
		}
		else
		{
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, HrtfFastConv->ntaps_hrir_foa, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_FOA" );
		@@ -686,36 +633,13 @@ ivas_error ivas_allocate_binaural_hrtf(
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_FOA" );
		}
		#else
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_FOA" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRImag_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_FOA" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRReal_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_FOA" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRImag_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_FOA" );
		}
		#endif
		}
		}

		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		else if ( ( renderer_type == RENDERER_BINAURAL_FASTCONV && bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED ) \|\| ( renderer_type == RENDERER_BINAURAL_FASTCONV && input_config != IVAS_AUDIO_CONFIG_INVALID ) )
		#else
		if ( renderer_type == RENDERER_BINAURAL_FASTCONV \|\| bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )
		#endif
		{
		if ( ( HrtfFastConv->leftHRIRReal == NULL ) && ( HrtfFastConv->leftHRIRImag == NULL ) && ( HrtfFastConv->rightHRIRReal == NULL ) && ( HrtfFastConv->rightHRIRImag == NULL ) )
		{
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, HrtfFastConv->ntaps_hrir, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal" );
		@@ -732,36 +656,13 @@ ivas_error ivas_allocate_binaural_hrtf(
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag" );
		}
		#else
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRImag, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRImag, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag" );
		}
		#endif
		}
		}

		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		else if ( ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM && bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED ) \|\| ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM && input_config != IVAS_AUDIO_CONFIG_INVALID ) )
		#else
		if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM \|\| bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )
		#endif
		{
		if ( ( HrtfFastConv->leftBRIRReal == NULL ) && ( HrtfFastConv->leftBRIRImag == NULL ) && ( HrtfFastConv->rightBRIRReal == NULL ) && ( HrtfFastConv->rightBRIRImag == NULL ) )
		{
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftBRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, HrtfFastConv->ntaps_brir, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftBRIRReal" );
		@@ -778,24 +679,6 @@ ivas_error ivas_allocate_binaural_hrtf(
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightBRIRImag" );
		}
		#else
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftBRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftBRIRReal" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftBRIRImag, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftBRIRImag" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightBRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightBRIRReal" );
		}
		if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightBRIRImag, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightBRIRImag" );
		}
		#endif
		}
		}

lib_rend/ivas_stat_rend.h

+0 −7

Original line number	Diff line number	Diff line
		@@ -1260,17 +1260,12 @@ typedef struct ivas_hrtfs_crend_structure
		typedef struct ivas_hrtfs_fastconv_struct
		{
		float FASTCONV_HOA3_latency_s;
		#ifndef FIX_1123_FASTCONV_16BIT_FMT
		float FASTCONV_HRIR_latency_s;
		#endif
		float ***leftHRIRReal_HOA3;
		float ***leftHRIRImag_HOA3;
		float ***rightHRIRReal_HOA3;
		float ***rightHRIRImag_HOA3;

		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		float FASTCONV_HRIR_latency_s;
		#endif
		float ***leftHRIRReal;
		float ***leftHRIRImag;
		float ***rightHRIRReal;
		@@ -1295,13 +1290,11 @@ typedef struct ivas_hrtfs_fastconv_struct
		float FASTCONV_FOA_latency_s;

		int16_t allocate_init_flag; /Memory allocation flag 0: if the hrtf pointers are allocated at application level , 1: of allocated at ivas_binaural_hrtf_open() /
		#ifdef FIX_1123_FASTCONV_16BIT_FMT
		uint16_t ntaps_hrir;
		uint16_t ntaps_hrir_hoa3;
		uint16_t ntaps_hrir_hoa2;
		uint16_t ntaps_hrir_foa;
		uint16_t ntaps_brir;
		#endif

		float fastconvReverberationTimes[CLDFB_NO_CHANNELS_MAX];
		float fastconvReverberationEneCorrections[CLDFB_NO_CHANNELS_MAX];

lib_util/hrtf_file_reader.c

+0 −431

File changed.

Preview size limit exceeded, changes collapsed.

scripts/binauralRenderer_interface/generate_crend_ivas_tables_from_sofa.c

+0 −38

Original line number	Diff line number	Diff line
		@@ -128,13 +128,8 @@ void usage_gen_crend_tables( void );
		void get_ls_layout_config( AUDIO_CONFIG ls_layout_config, struct ivas_layout_config *ls_struct );
		int generate_crend_ivas_tables_from_sofa( const char sofa_file_path, ConfigReader cfgReader );
		void update_h_file( HRTFS_DATA *hrtf, struct ivas_layout_config lscfg, const int32_t samplerate, const int16_t frame_len );
		#ifdef FIX_1123_CREND_FLTFX_BE
		void update_c_file( HRTFS_DATA *hrtf, struct ivas_layout_config lscfg, const int32_t samplerate, const int16_t frame_len, int16_t factorQ[3] );
		void update_c_file_with_reverb( float pEner_l, float pEner_r, float pCoherence, int16_t pEner_l_fx, int16_t pEner_r_fx, int16_t pCoherence_fx, int16_t factorQ, const int32_t samplerate, const int16_t len );
		#else
		void update_c_file( HRTFS_DATA *hrtf, struct ivas_layout_config lscfg, const int32_t samplerate, const int16_t frame_len );
		void update_c_file_with_reverb( float pEner_l, float pEner_r, float *pCoherence, const int32_t samplerate, const int16_t len );
		#endif
		void update_h_file_with_reverb( const int32_t samplerate );
		int generate_reverb_ivas_tables_from_sofa( const char *file_path );

		@@ -1286,24 +1281,14 @@ int generate_crend_ivas_tables_from_sofa( const char file_path, ConfigReader c
		}


		#ifdef FIX_1123_CREND_FLTFX_BE
		int16_t factorQ[3];
		make_fx_be( &hrtf_data, lscfg, sample_rates[indSR], frame_len, factorQ );
		#endif
		if ( lib_rend_path != NULL )
		{
		update_h_file( &hrtf_data, lscfg, sample_rates[indSR], frame_len );
		#ifdef FIX_1123_CREND_FLTFX_BE
		update_c_file( &hrtf_data, lscfg, sample_rates[indSR], frame_len, factorQ );
		#else
		update_c_file( &hrtf_data, lscfg, sample_rates[indSR], frame_len );
		#endif
		}

		#if !defined( FIX_1123_CREND_FLTFX_BE )
		int16_t factorQ[3];
		make_fx_be( &hrtf_data, lscfg, sample_rates[indSR], frame_len, factorQ );
		#endif
		if ( binary_file_path != NULL )
		{
		if ( write_binary_file( &hrtf_data, lscfg, sample_rates[indSR], frame_len, factorQ ) != IVAS_ERR_OK )
		@@ -1870,7 +1855,6 @@ int generate_reverb_ivas_tables_from_sofa( const char *file_path )
		ivas_reverb_get_hrtf_set_properties( pHrtf_set_l_re, pHrtf_set_l_im, pHrtf_set_r_re, pHrtf_set_r_im, IVAS_AUDIO_CONFIG_5_1, sofa_M, nr_fc_fft_filter,
		nr_fc_fft_filter, p_avg_lr, &p_avg_lr[nr_fc_fft_filter], pCoherence );

		#ifdef FIX_1123_CREND_FLTFX_BE
		make_reverb_fx_be( p_avg_lr, &p_avg_lr[nr_fc_fft_filter], pCoherence, sample_rates[indSR], &factorQ );
		for ( i = 0; i < nr_fc_fft_filter; i++ )
		{
		@@ -1878,25 +1862,11 @@ int generate_reverb_ivas_tables_from_sofa( const char *file_path )
		p_avg_lr_fx[i + nr_fc_fft_filter] = float2int16_t( p_avg_lr[i + nr_fc_fft_filter], factorQ );
		pCoherence_fx[i] = float2int16_t( pCoherence[i], factorQ );
		}
		#endif
		if ( lib_rend_path != NULL )
		{
		update_h_file_with_reverb( sample_rates[indSR] );
		#ifdef FIX_1123_CREND_FLTFX_BE
		update_c_file_with_reverb( p_avg_lr, &p_avg_lr[nr_fc_fft_filter], pCoherence, p_avg_lr_fx, &p_avg_lr_fx[nr_fc_fft_filter], pCoherence_fx, factorQ, sample_rates[indSR], nr_fc_fft_filter );
		#else
		update_c_file_with_reverb( p_avg_lr, &p_avg_lr[nr_fc_fft_filter], pCoherence, sample_rates[indSR], nr_fc_fft_filter );
		#endif
		}
		#if !defined( FIX_1123_CREND_FLTFX_BE )
		make_reverb_fx_be( p_avg_lr, &p_avg_lr[nr_fc_fft_filter], pCoherence, sample_rates[indSR], &factorQ );
		for ( i = 0; i < nr_fc_fft_filter; i++ )
		{
		p_avg_lr_fx[i] = float2int16_t( p_avg_lr[i], factorQ );
		p_avg_lr_fx[i + nr_fc_fft_filter] = float2int16_t( p_avg_lr[i + nr_fc_fft_filter], factorQ );
		pCoherence_fx[i] = float2int16_t( pCoherence[i], factorQ );
		}
		#endif
		if ( binary_file_path != NULL )
		{
		if ( write_reverb_to_binary_file( p_avg_lr, &p_avg_lr[nr_fc_fft_filter], pCoherence, factorQ, sample_rates[indSR] ) != IVAS_ERR_OK )
		@@ -2179,11 +2149,7 @@ void write_array_int16_t_to_file( FILE fp, int16_t vec, int32_t size_vec, int3
		/---------------------------------------------------------------------
		*update_c_file_with_reverb();
		---------------------------------------------------------------------/
		#ifdef FIX_1123_CREND_FLTFX_BE
		void update_c_file_with_reverb( float pEner_l, float pEner_r, float pCoherence, int16_t pEner_l_fx, int16_t pEner_r_fx, int16_t pCoherence_fx, int16_t factorQ, const int32_t samplerate, const int16_t len )
		#else
		void update_c_file_with_reverb( float pEner_l, float pEner_r, float *pCoherence, const int32_t samplerate, const int16_t len )
		#endif
		{
		char len_str[26] = "LR_IAC_LENGTH_NR_FC";
		if ( samplerate == 16000 )
		@@ -2239,11 +2205,7 @@ void update_c_file_with_reverb( float pEner_l, float pEner_r, float *pCoherenc
		/---------------------------------------------------------------------
		*update_c_file();
		---------------------------------------------------------------------/
		#ifdef FIX_1123_CREND_FLTFX_BE
		void update_c_file( HRTFS_DATA *hrtf, struct ivas_layout_config lscfg, const int32_t samplerate, const int16_t frame_len, int16_t factorQ[3] )
		#else
		void update_c_file( HRTFS_DATA *hrtf, struct ivas_layout_config lscfg, const int32_t samplerate, const int16_t frame_len )
		#endif
		{

		if ( c_file_path == NULL )