Commit 89c969b3 authored by Sandesh Venkatesh's avatar Sandesh Venkatesh
Browse files

Merge branch 'ivas_reverb_filer_design_fxd' into 'main' 

Converted functions in reverb filter design.

See merge request !182
parents 9754b5ff 9a8f0a3b

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       /*  10*log10(2)  in Q13                 */

#define LG10_s3_0                             16440       /* 10*log10(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;

}