Converted functions in reverb filter design (9a8f0a3b) · Commits · SA4 / Audio / IVAS BASOP

lib_com/cnst.h

+4 −0

Original line number	Diff line number	Diff line
		@@ -2640,6 +2640,8 @@ enum
		#define LG10_G_CODE_MIN_TC_Q14 LG10_G_CODE_MIN_Q14 /* log10(0.02) Q15*/
		#define LG10_G_CODE_MAX_TC_Q13 LG10_G_CODE_MAX_Q13

		#define LN_2_Q31 (1488521848 )

		/* AVQ (RE8) related consatnts */
		#define QR 32768
		#define Q_AVQ_OUT 6 /* AVQ_output scaling currently Q9, but may change */
		@@ -2678,6 +2680,8 @@ enum

		#define LG10 24660 /* 10log10(2) in Q13 /
		#define LG10_s3_0 16440 /* 10log10(2)/1.55 = 1.00343331 in Q14 /
		#define LOG2_10 27213 /* log base 2 of 10 in Q12 */
		#define LOG10_2 646456993 /* log base 10 of 2 in Q31 */

		#define MU_MA_FX 10923 /* original prediction factor for the AMR WB tables (Q15) */

lib_rend/ivas_prot_rend.h

+88 −14

Original line number	Diff line number	Diff line
		@@ -1537,14 +1537,34 @@ void ivas_reverb_fft_filter_ConvertFFTWF_2_FFTR(
		float *fft_real,
		const int16_t fft_size
		);

		#ifdef IVAS_FLOAT_FIXED
		void ivas_reverb_define_window_fft_fx(
		Word32 *pWindow, //output in Q31
		const Word16 transitionStart,
		const Word16 transitionLength,
		const Word16 spectrumLength
		);
		#else
		void ivas_reverb_define_window_fft(
		float *pWindow,
		const int16_t transitionStart,
		const int16_t transitionLength,
		const int16_t spectrumLength
		);

		#endif
		#if 0
		Word16 ivas_reverb_calc_color_filters_fx(
		const Word32 *pTargetL,
		const Word32 *pTargetR,
		const Word32 *pWindow,
		const Word16 fft_size,
		const Word32 delay,
		Word32 **pBeqL,
		Word32 **pBeqR,
		Word16 *q_pBeqL,
		Word16 *q_pBeqR
		);
		#else
		int16_t ivas_reverb_calc_color_filters(
		const float *pTargetL,
		const float *pTargetR,
		@@ -1554,7 +1574,19 @@ int16_t ivas_reverb_calc_color_filters(
		rv_fftwf_type_complex *pBeqL,
		rv_fftwf_type_complex *pBeqR
		);

		#endif
		#ifdef IVAS_FLOAT_FIXED
		Word16 ivas_reverb_calc_correl_filters_fx(
		Word32 *pTargetICC, //input in Q30
		const Word32 *pWindow, //input in Q30
		const Word16 fft_size,
		const Word16 delay,
		Word32 **pU, //input in Q31
		Word32 **pV, //input in Q31
		Word16 *q_pU, //Output q
		Word16 *q_pV //output q
		);
		#else
		int16_t ivas_reverb_calc_correl_filters(
		const float *pTargetICC,
		const float *pWindow,
		@@ -1563,7 +1595,21 @@ int16_t ivas_reverb_calc_correl_filters(
		rv_fftwf_type_complex *pU,
		rv_fftwf_type_complex *pV
		);

		#endif
		#ifdef IVAS_FLOAT_FIXED
		void ivas_reverb_calc_color_levels_fx(
		const Word32 output_Fs,
		const Word16 freq_count,
		const Word16 loop_count,
		const Word32 *pFc, //input in Q14
		const Word32 *pAcoustic_dsr, //input in Q31
		const Word32 *pHrtf_avg_pwr_L, //input in Q28
		const Word32 *pHrtf_avg_pwr_R, //input in Q28
		const Word16 *pLoop_delays,
		const Word32 *pT60_filter_coeff, //input in Q31
		Word32 *pTarget_color_L, //output in Q30
		Word32 *pTarget_color_R); //output in Q30
		#else
		void ivas_reverb_calc_color_levels(
		const int32_t output_Fs,
		const int16_t freq_count,
		@@ -1577,7 +1623,7 @@ void ivas_reverb_calc_color_levels(
		float *pTarget_color_L,
		float *pTarget_color_R
		);

		#endif
		ivas_error ivas_reverb_prepare_cldfb_params(
		IVAS_ROOM_ACOUSTICS_CONFIG_DATA *pInput_params,
		const HRTFS_FASTCONV_HANDLE hHrtfFastConv,
		@@ -1586,7 +1632,20 @@ ivas_error ivas_reverb_prepare_cldfb_params(
		const int32_t output_Fs,
		float *pOutput_t60,
		float *pOutput_ene );

		#ifdef IVAS_FLOAT_FIXED
		void ivas_reverb_interpolate_acoustic_data_fx(
		const Word16 input_table_size,
		const Word32 *pInput_fc, //input in Q16
		const Word32 *pInput_t60, //input in Q26
		const Word32 *pInput_dsr, //input in Q30
		const Word16 output_table_size,
		const Word32 *pOutput_fc,
		Word32 *pOutput_t60,
		Word32 *pOutput_dsr,
		Word16 *pOutput_t60_e, //output e
		Word16 *pOutput_dsr_e //output e
		);
		#else
		void ivas_reverb_interpolate_acoustic_data(
		const int16_t input_table_size,
		const float *pInput_fc,
		@@ -1597,7 +1656,22 @@ void ivas_reverb_interpolate_acoustic_data(
		float *pOutput_t60,
		float *pOutput_dsr
		);

		#endif
		#ifdef IVAS_FLOAT_FIXED
		void ivas_reverb_get_hrtf_set_properties_fx(
		Word32 **ppHrtf_set_L_re,
		Word32 **ppHrtf_set_L_im,
		Word32 **ppHrtf_set_R_re,
		Word32 **ppHrtf_set_R_im,
		const AUDIO_CONFIG input_audio_config,
		const Word16 hrtf_count,
		const Word16 in_freq_count,
		const Word16 out_freq_count,
		Word32 *pOut_avg_pwr_L, //output in Q23
		Word32 *pOut_avg_pwr_R, //output in Q23
		Word32 *out_i_a_coherence //output in Q27
		);
		#else
		void ivas_reverb_get_hrtf_set_properties(
		float **ppHrtf_set_L_re,
		float **ppHrtf_set_L_im,
		@@ -1611,7 +1685,7 @@ void ivas_reverb_get_hrtf_set_properties(
		float *pOut_avg_pwr_R,
		float *pOut_i_a_coherence
		);

		#endif

		/---------------------------------------------------------------------------------
		* Shoebox Prototypes

lib_rend/ivas_reverb.c

+236 −10

Original line number	Diff line number	Diff line
		@@ -1386,10 +1386,17 @@ static void set_reverb_acoustic_data(
		{
		int16_t nr_out_ch, hrtf_idx, offset, iter_idx, bin_idx;
		float ln_1e6_inverted, delay_diff, exp_argument;
		#ifdef IVAS_FLOAT_FIXED
		Word32 *pHrtf_set_l_re_fx[MAX_INTERN_CHANNELS];
		Word32 *pHrtf_set_l_im_fx[MAX_INTERN_CHANNELS];
		Word32 *pHrtf_set_r_re_fx[MAX_INTERN_CHANNELS];
		Word32 *pHrtf_set_r_im_fx[MAX_INTERN_CHANNELS];
		#else
		float *pHrtf_set_l_re[MAX_INTERN_CHANNELS];
		float *pHrtf_set_l_im[MAX_INTERN_CHANNELS];
		float *pHrtf_set_r_re[MAX_INTERN_CHANNELS];
		float *pHrtf_set_r_im[MAX_INTERN_CHANNELS];
		#endif

		/* use crend hrtf filters */
		if ( hHrtf != NULL )
		@@ -1408,30 +1415,96 @@ static void set_reverb_acoustic_data(

		if ( nr_out_ch == 0 )
		{
		#ifdef IVAS_FLOAT_FIXED
		pHrtf_set_l_re_fx[hrtf_idx] = &hHrtf->pOut_to_bin_re_fx[hrtf_idx][0][offset];
		pHrtf_set_l_im_fx[hrtf_idx] = &hHrtf->pOut_to_bin_im_fx[hrtf_idx][0][offset];
		#else
		pHrtf_set_l_re[hrtf_idx] = &hHrtf->pOut_to_bin_re[hrtf_idx][0][offset];
		pHrtf_set_l_im[hrtf_idx] = &hHrtf->pOut_to_bin_im[hrtf_idx][0][offset];
		#endif
		}
		else
		{
		#ifdef IVAS_FLOAT_FIXED
		pHrtf_set_r_re_fx[hrtf_idx] = &hHrtf->pOut_to_bin_re_fx[hrtf_idx][1][offset];
		pHrtf_set_r_im_fx[hrtf_idx] = &hHrtf->pOut_to_bin_im_fx[hrtf_idx][1][offset];
		#else
		pHrtf_set_r_re[hrtf_idx] = &hHrtf->pOut_to_bin_re[hrtf_idx][1][offset];
		pHrtf_set_r_im[hrtf_idx] = &hHrtf->pOut_to_bin_im[hrtf_idx][1][offset];
		#endif
		}
		}
		}

		/* Compute HRTF set properties using frequency-domain HRTF data */
		#ifdef IVAS_FLOAT_FIXED
		Word32 pHrtf_avg_pwr_response_l_fx = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));
		Word32 pHrtf_avg_pwr_response_r_fx = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));
		Word32 pHrtf_inter_aural_coherence_fx = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));
		ivas_reverb_get_hrtf_set_properties_fx(pHrtf_set_l_re_fx, pHrtf_set_l_im_fx, pHrtf_set_r_re_fx, pHrtf_set_r_im_fx, input_audio_config, hHrtf->max_num_ir, subframe_len,
		nr_fc_fft_filter, pHrtf_avg_pwr_response_l_fx, pHrtf_avg_pwr_response_r_fx, pHrtf_inter_aural_coherence_fx);

		for (int i = 0; i < nr_fc_fft_filter; i++)
		{
		pParams->pHrtf_avg_pwr_response_l[i] = (float)pHrtf_avg_pwr_response_l_fx[i] / (ONE_IN_Q23);
		pParams->pHrtf_avg_pwr_response_r[i] = (float)pHrtf_avg_pwr_response_r_fx[i] / (ONE_IN_Q23);
		pParams->pHrtf_inter_aural_coherence[i] = (float)pHrtf_inter_aural_coherence_fx[i] / (ONE_IN_Q27);
		}

		free(pHrtf_avg_pwr_response_l_fx);
		free(pHrtf_avg_pwr_response_r_fx);
		free(pHrtf_inter_aural_coherence_fx);
		#else
		ivas_reverb_get_hrtf_set_properties( pHrtf_set_l_re, pHrtf_set_l_im, pHrtf_set_r_re, pHrtf_set_r_im, input_audio_config, hHrtf->max_num_ir, subframe_len,
		nr_fc_fft_filter, pParams->pHrtf_avg_pwr_response_l, pParams->pHrtf_avg_pwr_response_r, pParams->pHrtf_inter_aural_coherence );

		#endif
		pParams->pHrtf_avg_pwr_response_l_const = (const float *) pParams->pHrtf_avg_pwr_response_l;
		pParams->pHrtf_avg_pwr_response_r_const = (const float *) pParams->pHrtf_avg_pwr_response_r;
		pParams->pHrtf_inter_aural_coherence_const = (const float *) pParams->pHrtf_inter_aural_coherence;
		}

		/* interpolate input table data for T60 and DSR to the FFT filter grid */
		#ifdef IVAS_FLOAT_FIXED
		Word32* pFc_input_fx = (Word32)malloc(60 sizeof(Word32*));
		Word32* pAcoustic_rt60_fx = (Word32)malloc(60 sizeof(Word32*));
		Word32* pAcoustic_dsr_fx = (Word32)malloc(60 sizeof(Word32*));

		Word32* pFc_fx = (Word32)malloc(nr_fc_fft_filter sizeof(Word32*));
		Word32* pRt60_fx = (Word32)malloc(nr_fc_fft_filter sizeof(Word32*));
		Word16* pRt60_e = (Word16)malloc(nr_fc_fft_filter sizeof(Word16*));
		Word32* pDsr_fx = (Word32)malloc(nr_fc_fft_filter sizeof(Word32*));
		Word16* pDsr_e = (Word16)malloc(nr_fc_fft_filter sizeof(Word16*));

		for (int i = 0; i < 60; i++)
		{
		pFc_input_fx[i] = (Word32)(pRoomAcoustics->pFc_input[i] * ONE_IN_Q16);
		pAcoustic_rt60_fx[i] = (Word32)((pRoomAcoustics->pAcoustic_rt60[i]) * ONE_IN_Q26);
		pAcoustic_dsr_fx[i] = (Word32)(pRoomAcoustics->pAcoustic_dsr[i] * ONE_IN_Q30);
		}

		for (int i = 0; i < nr_fc_fft_filter; i++)
		{
		pFc_fx[i] = (Word32)(pParams->pFc[i] * ONE_IN_Q16);
		}

		ivas_reverb_interpolate_acoustic_data_fx(nr_fc_input, pFc_input_fx, pAcoustic_rt60_fx, pAcoustic_dsr_fx,
		nr_fc_fft_filter, pFc_fx, pRt60_fx, pDsr_fx, pRt60_e, pDsr_e);
		for (int i = 0; i < nr_fc_fft_filter; i++) {
		pParams->pRt60[i] = fabsf(me2f(pRt60_fx[i], pRt60_e[i]));
		pParams->pDsr[i] = fabsf(me2f(pDsr_fx[i], pDsr_e[i]));
		}
		free(pFc_input_fx);
		free(pAcoustic_rt60_fx);
		free(pAcoustic_dsr_fx);
		free(pFc_fx);
		free(pRt60_fx);
		free(pRt60_e);
		free(pDsr_fx);
		free(pDsr_e);
		#else
		ivas_reverb_interpolate_acoustic_data( nr_fc_input, pRoomAcoustics->pFc_input, pRoomAcoustics->pAcoustic_rt60, pRoomAcoustics->pAcoustic_dsr,
		nr_fc_fft_filter, pParams->pFc, pParams->pRt60, pParams->pDsr );

		#endif
		/* adjust DSR for the delay difference */
		delay_diff = pRoomAcoustics->inputPreDelay - pRoomAcoustics->acousticPreDelay;
		ln_1e6_inverted = 1.0f / logf( 1e06f );
		@@ -1698,9 +1771,45 @@ ivas_error ivas_reverb_open(
		}

		/* Compute target levels (gains) for the coloration filters */
		#ifdef IVAS_FLOAT_FIXED
		Word32 pFc = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));
		Word32 pDsr = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));
		Word32 pHrtf_avg_pwr_response_l_const = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));
		Word32 pHrtf_avg_pwr_response_r_const = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));
		Word32 pT60_filter_coeff = (Word32)malloc((params.nr_loops * 4 + 4) * sizeof(Word32*));
		Word32 pColor_target_l_fx = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));
		Word32 pColor_target_r_fx = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));


		for (int i = 0; i < nr_fc_fft_filter; i++)
		{
		pFc[i] = (Word32)(params.pFc[i] * ONE_IN_Q14);
		pDsr[i] = (Word32)(params.pDsr[i] * ONE_IN_Q31);
		pHrtf_avg_pwr_response_l_const[i] = (Word32)(params.pHrtf_avg_pwr_response_l_const[i] * ONE_IN_Q28);
		pHrtf_avg_pwr_response_r_const[i] = (Word32)(params.pHrtf_avg_pwr_response_r_const[i] * ONE_IN_Q28);
		}
		for (int i = 0; i < params.nr_loops * 4 + 4; i++)
		{
		pT60_filter_coeff[i] = (Word32)(params.pT60_filter_coeff[i] * ONE_IN_Q31);
		}
		ivas_reverb_calc_color_levels_fx(output_Fs, nr_fc_fft_filter, params.nr_loops, pFc, pDsr, pHrtf_avg_pwr_response_l_const, pHrtf_avg_pwr_response_r_const,
		params.pLoop_delays, pT60_filter_coeff, pColor_target_l_fx, pColor_target_r_fx);
		for (int i = 0; i < nr_fc_fft_filter; i++)
		{
		pColor_target_l[i] = (float)pColor_target_l_fx[i] / ONE_IN_Q30;
		pColor_target_r[i] = (float)pColor_target_r_fx[i] / ONE_IN_Q30;
		}
		free(pFc);
		free(pDsr);
		free(pHrtf_avg_pwr_response_l_const);
		free(pHrtf_avg_pwr_response_r_const);
		free(pT60_filter_coeff);
		free(pColor_target_l_fx);
		free(pColor_target_r_fx);
		#else
		ivas_reverb_calc_color_levels( output_Fs, nr_fc_fft_filter, params.nr_loops, params.pFc, params.pDsr, params.pHrtf_avg_pwr_response_l_const, params.pHrtf_avg_pwr_response_r_const,
		params.pLoop_delays, params.pT60_filter_coeff, pColor_target_l, pColor_target_r );

		#endif
		/* Defining appropriate windowing parameters for FFT filters to prevent aliasing */
		fft_hist_size = pState->fft_size - pState->fft_subblock_size;

		@@ -1708,8 +1817,16 @@ ivas_error ivas_reverb_open(
		transition_length = (int16_t) roundf( FFT_FILTER_WND_TRANS_REGION * fft_hist_size );

		/* Compute the window used for FFT filters */
		#ifdef IVAS_FLOAT_FIXED
		Word32 pTime_window_fx = (Word32)malloc(512 * sizeof(Word32*));
		ivas_reverb_define_window_fft_fx(pTime_window_fx, transition_start, transition_length, nr_fc_fft_filter);
		for (int i = 0; i < RV_FILTER_MAX_FFT_SIZE; i++) {
		pTime_window[i] = (float)pTime_window_fx[i] / ONE_IN_Q31;
		}
		free(pTime_window_fx);
		#else
		ivas_reverb_define_window_fft( pTime_window, transition_start, transition_length, nr_fc_fft_filter );

		#endif

		/* === Now, copy parameters from ivas_reverb_params_t into DSP blocks === */
		/* === to be used for subsequent audio signal processing === */
		@@ -1725,8 +1842,61 @@ ivas_error ivas_reverb_open(
		if ( pState->do_corr_filter )
		{
		/* Computing correlation filters on the basis of target IA coherence */
		ivas_reverb_calc_correl_filters( params.pHrtf_inter_aural_coherence_const, pTime_window, pState->fft_size, 0.0f, pFft_wf_filter_ch0, pFft_wf_filter_ch1 );
		#ifdef IVAS_FLOAT_FIXED
		Word32 pFft_wf_filter_ch0_fx = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));

		for (int i = 0; i < nr_fc_fft_filter; i++) {
		pFft_wf_filter_ch0_fx[i] = (Word32)malloc(2 sizeof(Word32));
		}

		Word32 pFft_wf_filter_ch1_fx = (Word32)malloc(nr_fc_fft_filter * sizeof(Word32*));

		for (int i = 0; i < nr_fc_fft_filter; i++) {
		pFft_wf_filter_ch1_fx[i] = (Word32)malloc(2 sizeof(Word32));
		}
		Word32* pWindow_fx = (Word32)malloc(512 sizeof(Word32));

		Word16 q_pFft_wf_filter_ch0_fx, q_pFft_wf_filter_ch1_fx;

		for (int i = 0; i < nr_fc_fft_filter; i++) {
		pFft_wf_filter_ch0_fx[i][0] = ((Word32)pFft_wf_filter_ch0[i][0] * ONE_IN_Q31);
		pFft_wf_filter_ch0_fx[i][1] = ((Word32)pFft_wf_filter_ch0[i][1] * ONE_IN_Q31);
		}
		for (int i = 0; i < nr_fc_fft_filter; i++) {
		pFft_wf_filter_ch1_fx[i][0] = (Word32)(pFft_wf_filter_ch1_fx[i][0] * ONE_IN_Q31);
		pFft_wf_filter_ch1_fx[i][1] = (Word32)(pFft_wf_filter_ch1_fx[i][1] * ONE_IN_Q31);
		}
		for (int i = 0; i < RV_FILTER_MAX_FFT_SIZE; i++) {
		pWindow_fx[i] = (Word32)(pTime_window[i] * ONE_IN_Q30);
		}

		Word32* pHrtf_inter_aural_coherence_const = (Word32)malloc(nr_fc_fft_filter sizeof(Word32));
		for (int i = 0; i < nr_fc_fft_filter; i++) {
		pHrtf_inter_aural_coherence_const[i] = (Word32)(params.pHrtf_inter_aural_coherence_const[i] * ONE_IN_Q30);
		}
		ivas_reverb_calc_correl_filters_fx(pHrtf_inter_aural_coherence_const, pWindow_fx, pState->fft_size, 0, pFft_wf_filter_ch0_fx, pFft_wf_filter_ch1_fx, &q_pFft_wf_filter_ch0_fx, &q_pFft_wf_filter_ch1_fx);

		for (int i = 0; i < nr_fc_fft_filter; i++) {
		pFft_wf_filter_ch0[i][0] = (float)pFft_wf_filter_ch0_fx[i][0] / (1u << q_pFft_wf_filter_ch0_fx);
		pFft_wf_filter_ch0[i][1] = (float)pFft_wf_filter_ch0_fx[i][1] / (1u << q_pFft_wf_filter_ch0_fx);
		}

		for (int i = 0; i < nr_fc_fft_filter; i++) {
		pFft_wf_filter_ch1[i][0] = (float)pFft_wf_filter_ch1_fx[i][0] / (1u << q_pFft_wf_filter_ch1_fx);
		pFft_wf_filter_ch1[i][1] = (float)pFft_wf_filter_ch1_fx[i][1] / (1u << q_pFft_wf_filter_ch1_fx);
		}

		for (int i = 0; i < nr_fc_fft_filter; i++) {
		free(pFft_wf_filter_ch1_fx[i]);
		free(pFft_wf_filter_ch0_fx[i]);
		}
		free(pFft_wf_filter_ch1_fx);
		free(pFft_wf_filter_ch0_fx);
		free(pWindow_fx);
		free(pHrtf_inter_aural_coherence_const);
		#else
		ivas_reverb_calc_correl_filters( params.pHrtf_inter_aural_coherence_const, pTime_window, pState->fft_size, 0.0f, pFft_wf_filter_ch0, pFft_wf_filter_ch1 );
		#endif
		/* Copying the computed FFT correlation filters to the fft_filter components */
		if ( ( error = set_correl_fft_filter( pState, 0, pFft_wf_filter_ch0 ) ) != IVAS_ERR_OK )
		{
		@@ -1740,8 +1910,64 @@ ivas_error ivas_reverb_open(
		}

		/* Computing coloration filters on the basis of target responses */
		ivas_reverb_calc_color_filters( pColor_target_l, pColor_target_r, pTime_window, pState->fft_size, 0.0f, pFft_wf_filter_ch0, pFft_wf_filter_ch1 );
		#if 0
		Word32 pFft_wf_filter_ch0_fx = (Word32)malloc(257 * sizeof(Word32*));

		for (int i = 0; i < 257; i++) {
		pFft_wf_filter_ch0_fx[i] = (Word32)malloc(2 sizeof(Word32));
		}

		Word32 pFft_wf_filter_ch1_fx = (Word32)malloc(257 * sizeof(Word32*));

		for (int i = 0; i < 257; i++) {
		pFft_wf_filter_ch1_fx[i] = (Word32)malloc(2 sizeof(Word32));
		}
		Word32* pWindow_fx = (Word32)malloc(RV_FILTER_MAX_FFT_SIZE sizeof(Word32));

		Word16 q_pFft_wf_filter_ch0_fx, q_pFft_wf_filter_ch1_fx;

		for (int i = 0; i < 257; i++) {
		pFft_wf_filter_ch0_fx[i][0] = pFft_wf_filter_ch0[i][0] * 2147483648;
		pFft_wf_filter_ch0_fx[i][1] = pFft_wf_filter_ch0[i][1] * 2147483648;
		}
		for (int i = 0; i < 257; i++) {
		pFft_wf_filter_ch1_fx[i][0] = pFft_wf_filter_ch1_fx[i][0] * 2147483648;
		pFft_wf_filter_ch1_fx[i][1] = pFft_wf_filter_ch1_fx[i][1] * 2147483648;
		}
		for (int i = 0; i < RV_FILTER_MAX_FFT_SIZE; i++) {
		pWindow_fx[i] = pTime_window[i] * (1 << 30);
		}

		Word32* pColor_target_l_fx = (Word32)malloc(pState->fft_size sizeof(Word32));
		Word32* pColor_target_r_fx = (Word32)malloc(pState->fft_size sizeof(Word32));
		for (int i = 0; i < RV_FILTER_MAX_FFT_SIZE; i++) {
		pColor_target_l_fx[i] = pColor_target_l[i] * ONE_IN_Q30;
		pColor_target_r_fx[i] = pColor_target_r[i] * ONE_IN_Q30;
		}
		ivas_reverb_calc_color_filters_fx(pColor_target_l_fx, pColor_target_r_fx, pWindow_fx, pState->fft_size, 0, pFft_wf_filter_ch0_fx, pFft_wf_filter_ch1_fx, &q_pFft_wf_filter_ch0_fx, &q_pFft_wf_filter_ch1_fx);

		for (int i = 0; i < 257; i++) {
		pFft_wf_filter_ch0[i][0] = (float)pFft_wf_filter_ch0_fx[i][0] / (1u << q_pFft_wf_filter_ch0_fx);
		pFft_wf_filter_ch0[i][1] = (float)pFft_wf_filter_ch0_fx[i][1] / (1u << q_pFft_wf_filter_ch0_fx);
		}

		for (int i = 0; i < 257; i++) {
		pFft_wf_filter_ch1[i][0] = (float)pFft_wf_filter_ch1_fx[i][0] / (1u << q_pFft_wf_filter_ch1_fx);
		pFft_wf_filter_ch1[i][1] = (float)pFft_wf_filter_ch1_fx[i][1] / (1u << q_pFft_wf_filter_ch1_fx);
		}

		for (int i = 0; i < 257; i++) {
		free(pFft_wf_filter_ch1_fx[i]);
		free(pFft_wf_filter_ch0_fx[i]);
		}
		free(pFft_wf_filter_ch1_fx);
		free(pFft_wf_filter_ch0_fx);
		free(pWindow_fx);
		free(pColor_target_r_fx);
		free(pColor_target_l_fx);
		#else
		ivas_reverb_calc_color_filters( pColor_target_l, pColor_target_r, pTime_window, pState->fft_size, 0.0f, pFft_wf_filter_ch0, pFft_wf_filter_ch1 );
		#endif
		/* Copying the computed FFT colorations filters to the fft_filter components */
		if ( ( error = set_color_fft_filter( pState, 0, pFft_wf_filter_ch0 ) ) != IVAS_ERR_OK )
		{

lib_rend/ivas_reverb_filter_design.c

+881 −3

File changed.

Preview size limit exceeded, changes collapsed.

lib_rend/ivas_reverb_utils.c

+77 −3

Original line number	Diff line number	Diff line
		@@ -37,7 +37,7 @@
		#include "ivas_rom_rend.h"
		#include <math.h>
		#include "wmc_auto.h"

		#include "prot_fx2.h"

		/-----------------------------------------------------------------------------------------
		* Local constants
		@@ -95,9 +95,46 @@ ivas_error ivas_reverb_prepare_cldfb_params(
		{
		fc[idx] = ( (float) idx + 0.5f ) * ( (float) MAX_SAMPLING_RATE / (float) ( 2 * CLDFB_NO_CHANNELS_MAX ) );
		}
		#ifdef IVAS_FLOAT_FIXED
		Word32* pFc_input_fx = (Word32)malloc(60 sizeof(Word32*));
		Word32* pAcoustic_rt60_fx = (Word32)malloc(60 sizeof(Word32*));
		Word32* pAcoustic_dsr_fx = (Word32)malloc(60 sizeof(Word32*));

		ivas_reverb_interpolate_acoustic_data( pInput_params->nBands, pInput_params->pFc_input, pInput_params->pAcoustic_rt60, pInput_params->pAcoustic_dsr, CLDFB_NO_CHANNELS_MAX, fc, pOutput_t60, pOutput_ene );
		Word32* fc_fx = (Word32)malloc(pInput_params->nBands sizeof(Word32*));
		Word32* pOutput_t60_fx = (Word32)malloc(pInput_params->nBands sizeof(Word32*));
		Word16* pOutput_t60_e = (Word16)malloc(pInput_params->nBands sizeof(Word16*));
		Word32* pOutput_ene_fx = (Word32)malloc(pInput_params->nBands sizeof(Word32*));
		Word16* pOutput_ene_e = (Word16)malloc(pInput_params->nBands sizeof(Word16*));

		for (int i = 0; i < 60; i++)
		{
		pFc_input_fx[i] = (Word32)pInput_params->pFc_input[i] * ONE_IN_Q16;
		pAcoustic_rt60_fx[i] = (Word32)(pInput_params->pAcoustic_rt60[i]) * ONE_IN_Q26;
		pAcoustic_dsr_fx[i] = (Word32)pInput_params->pAcoustic_dsr[i] * ONE_IN_Q30;
		}

		for (int i = 0; i < pInput_params->nBands; i++)
		{
		fc_fx[i] = (Word32)fc[i] * ONE_IN_Q16;
		}

		ivas_reverb_interpolate_acoustic_data_fx(pInput_params->nBands, pFc_input_fx, pAcoustic_rt60_fx, pAcoustic_dsr_fx,
		CLDFB_NO_CHANNELS_MAX, fc_fx, pOutput_t60_fx, pOutput_ene_fx, pOutput_t60_e, pOutput_ene_e);
		for (int i = 0; i < pInput_params->nBands; i++) {
		pOutput_t60[i] = (float)fabs(me2f(pOutput_t60_fx[i], pOutput_t60_e[i]));
		pOutput_ene[i] = (float)fabs(me2f(pOutput_ene_fx[i], pOutput_ene_e[i]));
		}
		free(pFc_input_fx);
		free(pAcoustic_rt60_fx);
		free(pAcoustic_dsr_fx);
		free(fc_fx);
		free(pOutput_t60_fx);
		free(pOutput_t60_e);
		free(pOutput_ene_fx);
		free(pOutput_ene_e);
		#else
		ivas_reverb_interpolate_acoustic_data( pInput_params->nBands, pInput_params->pFc_input, pInput_params->pAcoustic_rt60, pInput_params->pAcoustic_dsr, CLDFB_NO_CHANNELS_MAX, fc, pOutput_t60, pOutput_ene );
		#endif
		/* adjust DSR for the delay difference */
		delay_diff = pInput_params->inputPreDelay - pInput_params->acousticPreDelay;
		ln_1e6_inverted = 1.0f / logf( 1e06f );
		@@ -507,8 +544,45 @@ static ivas_error ivas_reverb_get_fastconv_hrtf_set_energies(
		{
		return error;
		}
		#ifdef IVAS_FLOAT_FIXED
		Word32* input_fc_fx = (Word32)malloc(60 sizeof(Word32*));
		Word32* avg_pwr_left_fft_fx = (Word32)malloc(60 sizeof(Word32*));
		Word32* avg_pwr_right_fft_fx = (Word32)malloc(60 sizeof(Word32*));

		ivas_reverb_interpolate_acoustic_data( FFT_SPECTRUM_SIZE, input_fc, avg_pwr_left_fft, avg_pwr_right_fft, CLDFB_NO_CHANNELS_MAX, output_fc, avg_pwr_left, avg_pwr_right );
		Word32* output_fc_fx = (Word32)malloc(257 sizeof(Word32*));
		Word32* avg_pwr_left_fx = (Word32)malloc(257 sizeof(Word32*));
		Word16* avg_pwr_left_e = (Word16)malloc(257 sizeof(Word16*));
		Word32* avg_pwr_right_fx = (Word32)malloc(257 sizeof(Word32*));
		Word16* avg_pwr_right_e = (Word16)malloc(257 sizeof(Word16*));

		for (int i = 0; i < 60; i++)
		{
		input_fc_fx[i] = (Word32)input_fc[i] * (1 << 16);
		avg_pwr_left_fft_fx[i] = (Word32)(avg_pwr_left_fft[i]) * ONE_IN_Q26;
		avg_pwr_right_fft_fx[i] = (Word32)avg_pwr_right_fft[i] * ONE_IN_Q30;
		}

		for (int i = 0; i < 257; i++)
		{
		output_fc_fx[i] = (Word32)input_fc[i] * ONE_IN_Q16;
		}

		ivas_reverb_interpolate_acoustic_data_fx(FFT_SPECTRUM_SIZE, input_fc_fx, avg_pwr_left_fft_fx, avg_pwr_right_fft_fx,
		CLDFB_NO_CHANNELS_MAX, output_fc_fx, avg_pwr_left_fx, avg_pwr_right_fx, avg_pwr_left_e, avg_pwr_right_e);
		for (int i = 0; i < 257; i++) {
		avg_pwr_left[i] = (float)fabs(me2f(avg_pwr_left_fx[i], avg_pwr_left_e[i]));
		avg_pwr_right[i] =(float)fabs(me2f(avg_pwr_right_fx[i], avg_pwr_right_e[i]));
		}
		free(input_fc_fx);
		free(avg_pwr_left_fft_fx);
		free(avg_pwr_right_fft_fx);
		free(output_fc_fx);
		free(avg_pwr_left_fx);
		free(avg_pwr_left_e);
		free(avg_pwr_right_fx);
		free(avg_pwr_right_e);
		#else
		ivas_reverb_interpolate_acoustic_data( FFT_SPECTRUM_SIZE, input_fc, avg_pwr_left_fft, avg_pwr_right_fft, CLDFB_NO_CHANNELS_MAX, output_fc, avg_pwr_left, avg_pwr_right );
		#endif
		return IVAS_ERR_OK;
		}