Commit 0c81a95c authored by vaclav's avatar vaclav
Browse files

formal improvements

parent a7c3989e

lib_dec/ivas_binRenderer_internal.c

+52 −42
Original line number Diff line number Diff line
@@ -708,7 +708,7 @@ ivas_error ivas_allocate_binaural_hrtf( 
    }



#ifdef FIX_1123_FASTCONV_16BIT_ROM

    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 ) ) )

    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
@@ -754,7 +754,7 @@ ivas_error ivas_allocate_binaural_hrtf( 
    }



#ifdef FIX_1123_FASTCONV_16BIT_ROM

    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 ) ) )

    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
@@ -817,13 +817,17 @@ static ivas_error ivas_binaural_hrtf_open( 
{

#ifdef FIX_1123_FASTCONV_16BIT_ROM

    int16_t i, j, k;

    float scaleFactor = 1.f;

    float scaleFactorSBA = 1.f;

    float scaleFactor, scaleFactorSBA;

#else

    int16_t i, j;

#endif

    ivas_error error;



#ifdef FIX_1123_FASTCONV_16BIT_ROM

    scaleFactor = 1.f;

    scaleFactorSBA = 1.f;

#endif



    if ( hHrtfFastConv != NULL && *hHrtfFastConv != NULL )

    {

        /* Tables already loaded from file */
@@ -844,7 +848,7 @@ static ivas_error ivas_binaural_hrtf_open( 
        if ( input_config == IVAS_AUDIO_CONFIG_BINAURAL || renderer_type == RENDERER_BINAURAL_FASTCONV )

        {

#ifdef FIX_1123_FASTCONV_16BIT_ROM

            HrtfFastConv->FASTCONV_HRIR_latency_s = (float) FASTCONV_HRIR_latency_s * powf( 2.f, -1.f * (float) FASTCONV_FOA_latency_s_factorQ );

            HrtfFastConv->FASTCONV_HRIR_latency_s = FASTCONV_HRIR_latency_s * powf( 2.f, -1.f * FASTCONV_FOA_latency_s_factorQ );

#else

            HrtfFastConv->FASTCONV_HRIR_latency_s = FASTCONV_HRIR_latency_s;

#endif
@@ -852,7 +856,7 @@ static ivas_error ivas_binaural_hrtf_open( 
        if ( input_config == IVAS_AUDIO_CONFIG_HOA2 )

        {

#ifdef FIX_1123_FASTCONV_16BIT_ROM

            HrtfFastConv->FASTCONV_HOA2_latency_s = (float) FASTCONV_HOA2_latency_s * powf( 2.f, -1.f * (float) FASTCONV_HOA2_latency_s_factorQ );

            HrtfFastConv->FASTCONV_HOA2_latency_s = FASTCONV_HOA2_latency_s * powf( 2.f, -1.f * FASTCONV_HOA2_latency_s_factorQ );

#else

            HrtfFastConv->FASTCONV_HOA2_latency_s = FASTCONV_HOA2_latency_s;

#endif
@@ -860,7 +864,7 @@ static ivas_error ivas_binaural_hrtf_open( 
        if ( input_config == IVAS_AUDIO_CONFIG_HOA3 )

        {

#ifdef FIX_1123_FASTCONV_16BIT_ROM

            HrtfFastConv->FASTCONV_HOA3_latency_s = (float) FASTCONV_HOA3_latency_s * powf( 2.f, -1.f * (float) FASTCONV_HOA3_latency_s_factorQ );

            HrtfFastConv->FASTCONV_HOA3_latency_s = FASTCONV_HOA3_latency_s * powf( 2.f, -1.f * FASTCONV_HOA3_latency_s_factorQ );

#else

            HrtfFastConv->FASTCONV_HOA3_latency_s = FASTCONV_HOA3_latency_s;

#endif
@@ -868,7 +872,7 @@ static ivas_error ivas_binaural_hrtf_open( 
        if ( input_config == IVAS_AUDIO_CONFIG_FOA )

        {

#ifdef FIX_1123_FASTCONV_16BIT_ROM

            HrtfFastConv->FASTCONV_FOA_latency_s = (float) FASTCONV_FOA_latency_s * powf( 2.f, -1.f * (float) FASTCONV_HRIR_latency_s_factorQ );

            HrtfFastConv->FASTCONV_FOA_latency_s = FASTCONV_FOA_latency_s * powf( 2.f, -1.f * FASTCONV_HRIR_latency_s_factorQ );

#else

            HrtfFastConv->FASTCONV_FOA_latency_s = FASTCONV_FOA_latency_s;

#endif
@@ -876,7 +880,7 @@ static ivas_error ivas_binaural_hrtf_open( 
        if ( input_config == IVAS_AUDIO_CONFIG_BINAURAL || renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )

        {

#ifdef FIX_1123_FASTCONV_16BIT_ROM

            HrtfFastConv->FASTCONV_BRIR_latency_s = (float) FASTCONV_BRIR_latency_s * powf( 2.f, -1.f * (float) FASTCONV_BRIR_latency_s_factorQ );

            HrtfFastConv->FASTCONV_BRIR_latency_s = FASTCONV_BRIR_latency_s * powf( 2.f, -1.f * FASTCONV_BRIR_latency_s_factorQ );

#else

            HrtfFastConv->FASTCONV_BRIR_latency_s = FASTCONV_BRIR_latency_s;

#endif
@@ -885,23 +889,23 @@ static ivas_error ivas_binaural_hrtf_open( 
#ifdef FIX_1123_FASTCONV_16BIT_ROM

        if ( renderer_type == RENDERER_BINAURAL_FASTCONV )

        {

            scaleFactor = powf( 2.f, -1.f * (float) FASTCONV_HRIR_factorQ );

            scaleFactor = powf( 2.f, -1.f * FASTCONV_HRIR_factorQ );

        }

        else if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )

        {

            scaleFactor = powf( 2.f, -1.f * (float) FASTCONV_BRIR_factorQ );

            scaleFactor = powf( 2.f, -1.f * FASTCONV_BRIR_factorQ );

        }

        if ( input_config == IVAS_AUDIO_CONFIG_HOA3 )

        {

            scaleFactorSBA = powf( 2.f, -1.f * (float) FASTCONV_HRIR_HOA3_factorQ );

            scaleFactorSBA = powf( 2.f, -1.f * FASTCONV_HRIR_HOA3_factorQ );

        }

        else if ( input_config == IVAS_AUDIO_CONFIG_HOA2 )

        {

            scaleFactorSBA = powf( 2.f, -1.f * (float) FASTCONV_HRIR_HOA2_factorQ );

            scaleFactorSBA = powf( 2.f, -1.f * FASTCONV_HRIR_HOA2_factorQ );

        }

        else if ( input_config == IVAS_AUDIO_CONFIG_FOA )

        {

            scaleFactorSBA = powf( 2.f, -1.f * (float) FASTCONV_HRIR_FOA_factorQ );

            scaleFactorSBA = powf( 2.f, -1.f * FASTCONV_HRIR_FOA_factorQ );

        }

        HrtfFastConv->allocate_init_flag = 0; /* TODO: consider getting rid of this flag entirely? */

#else
@@ -912,6 +916,7 @@ static ivas_error ivas_binaural_hrtf_open( 
        {

            return error;

        }



        for ( i = 0; i < BINAURAL_CONVBANDS; i++ )

        {

            if ( renderer_type == RENDERER_BINAURAL_FASTCONV )
@@ -921,10 +926,10 @@ static ivas_error ivas_binaural_hrtf_open( 
#ifdef FIX_1123_FASTCONV_16BIT_ROM

                    for ( k = 0; k < HrtfFastConv->ntaps_hrir; k++ )

                    {

                        HrtfFastConv->leftHRIRReal[i][j][k] = (float) leftHRIRReal[i][j][k] * scaleFactor;

                        HrtfFastConv->leftHRIRImag[i][j][k] = (float) leftHRIRImag[i][j][k] * scaleFactor;

                        HrtfFastConv->rightHRIRReal[i][j][k] = (float) rightHRIRReal[i][j][k] * scaleFactor;

                        HrtfFastConv->rightHRIRImag[i][j][k] = (float) rightHRIRImag[i][j][k] * scaleFactor;

                        HrtfFastConv->leftHRIRReal[i][j][k] = leftHRIRReal[i][j][k] * scaleFactor;

                        HrtfFastConv->leftHRIRImag[i][j][k] = leftHRIRImag[i][j][k] * scaleFactor;

                        HrtfFastConv->rightHRIRReal[i][j][k] = rightHRIRReal[i][j][k] * scaleFactor;

                        HrtfFastConv->rightHRIRImag[i][j][k] = rightHRIRImag[i][j][k] * scaleFactor;

                    }

#else

                    HrtfFastConv->leftHRIRReal[i][j] = leftHRIRReal[i][j];
@@ -941,10 +946,10 @@ static ivas_error ivas_binaural_hrtf_open( 
#ifdef FIX_1123_FASTCONV_16BIT_ROM

                    for ( k = 0; k < HrtfFastConv->ntaps_brir; k++ )

                    {

                        HrtfFastConv->leftBRIRReal[i][j][k] = (float) leftBRIRReal[i][j][k] * scaleFactor;

                        HrtfFastConv->leftBRIRImag[i][j][k] = (float) leftBRIRImag[i][j][k] * scaleFactor;

                        HrtfFastConv->rightBRIRReal[i][j][k] = (float) rightBRIRReal[i][j][k] * scaleFactor;

                        HrtfFastConv->rightBRIRImag[i][j][k] = (float) rightBRIRImag[i][j][k] * scaleFactor;

                        HrtfFastConv->leftBRIRReal[i][j][k] = leftBRIRReal[i][j][k] * scaleFactor;

                        HrtfFastConv->leftBRIRImag[i][j][k] = leftBRIRImag[i][j][k] * scaleFactor;

                        HrtfFastConv->rightBRIRReal[i][j][k] = rightBRIRReal[i][j][k] * scaleFactor;

                        HrtfFastConv->rightBRIRImag[i][j][k] = rightBRIRImag[i][j][k] * scaleFactor;

                    }

#else

                    HrtfFastConv->leftBRIRReal[i][j] = leftBRIRReal[i][j];
@@ -954,6 +959,7 @@ static ivas_error ivas_binaural_hrtf_open( 
#endif

                }

            }



            if ( input_config == IVAS_AUDIO_CONFIG_HOA3 )

            {

                for ( j = 0; j < HOA3_CHANNELS; j++ )
@@ -961,10 +967,10 @@ static ivas_error ivas_binaural_hrtf_open( 
#ifdef FIX_1123_FASTCONV_16BIT_ROM

                    for ( k = 0; k < HrtfFastConv->ntaps_hrir_hoa3; k++ )

                    {

                        HrtfFastConv->leftHRIRReal_HOA3[i][j][k] = (float) leftHRIRReal_HOA3[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRImag_HOA3[i][j][k] = (float) leftHRIRImag_HOA3[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRReal_HOA3[i][j][k] = (float) rightHRIRReal_HOA3[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRImag_HOA3[i][j][k] = (float) rightHRIRImag_HOA3[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRReal_HOA3[i][j][k] = leftHRIRReal_HOA3[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRImag_HOA3[i][j][k] = leftHRIRImag_HOA3[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRReal_HOA3[i][j][k] = rightHRIRReal_HOA3[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRImag_HOA3[i][j][k] = rightHRIRImag_HOA3[i][j][k] * scaleFactorSBA;

                    }

#else

                    HrtfFastConv->leftHRIRReal_HOA3[i][j] = leftHRIRReal_HOA3[i][j];
@@ -975,19 +981,20 @@ static ivas_error ivas_binaural_hrtf_open( 
                }

            }

#ifdef FIX_1123_FASTCONV_16BIT_ROM

            else

#endif

            else if ( input_config == IVAS_AUDIO_CONFIG_HOA2 )

#else

            if ( input_config == IVAS_AUDIO_CONFIG_HOA2 )

#endif

            {

                for ( j = 0; j < HOA2_CHANNELS; j++ )

                {

#ifdef FIX_1123_FASTCONV_16BIT_ROM

                    for ( k = 0; k < HrtfFastConv->ntaps_hrir_hoa2; k++ )

                    {

                        HrtfFastConv->leftHRIRReal_HOA2[i][j][k] = (float) leftHRIRReal_HOA2[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRImag_HOA2[i][j][k] = (float) leftHRIRImag_HOA2[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRReal_HOA2[i][j][k] = (float) rightHRIRReal_HOA2[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRImag_HOA2[i][j][k] = (float) rightHRIRImag_HOA2[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRReal_HOA2[i][j][k] = leftHRIRReal_HOA2[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRImag_HOA2[i][j][k] = leftHRIRImag_HOA2[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRReal_HOA2[i][j][k] = rightHRIRReal_HOA2[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRImag_HOA2[i][j][k] = rightHRIRImag_HOA2[i][j][k] * scaleFactorSBA;

                    }

#else

                    HrtfFastConv->leftHRIRReal_HOA2[i][j] = leftHRIRReal_HOA2[i][j];
@@ -998,19 +1005,20 @@ static ivas_error ivas_binaural_hrtf_open( 
                }

            }

#ifdef FIX_1123_FASTCONV_16BIT_ROM

            else

#endif

            else if ( input_config == IVAS_AUDIO_CONFIG_FOA )

#else

            if ( input_config == IVAS_AUDIO_CONFIG_FOA )

#endif

            {

                for ( j = 0; j < FOA_CHANNELS; j++ )

                {

#ifdef FIX_1123_FASTCONV_16BIT_ROM

                    for ( k = 0; k < HrtfFastConv->ntaps_hrir_foa; k++ )

                    {

                        HrtfFastConv->leftHRIRReal_FOA[i][j][k] = (float) leftHRIRReal_FOA[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRImag_FOA[i][j][k] = (float) leftHRIRImag_FOA[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRReal_FOA[i][j][k] = (float) rightHRIRReal_FOA[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRImag_FOA[i][j][k] = (float) rightHRIRImag_FOA[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRReal_FOA[i][j][k] = leftHRIRReal_FOA[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->leftHRIRImag_FOA[i][j][k] = leftHRIRImag_FOA[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRReal_FOA[i][j][k] = rightHRIRReal_FOA[i][j][k] * scaleFactorSBA;

                        HrtfFastConv->rightHRIRImag_FOA[i][j][k] = rightHRIRImag_FOA[i][j][k] * scaleFactorSBA;

                    }

#else

                    HrtfFastConv->leftHRIRReal_FOA[i][j] = leftHRIRReal_FOA[i][j];
@@ -1021,16 +1029,18 @@ static ivas_error ivas_binaural_hrtf_open( 
                }

            }

        }



#ifdef FIX_1123_FASTCONV_16BIT_ROM

        scaleFactor = powf( 2.f, -1.f * (float) fastconvReverberationTimes_factorQ );

        scaleFactor = powf( 2.f, -1.f * fastconvReverberationTimes_factorQ );

        for ( i = 0; i < CLDFB_NO_CHANNELS_MAX; i++ )

        {

            HrtfFastConv->fastconvReverberationTimes[i] = (float) fastconvReverberationTimes[i] * scaleFactor;

            HrtfFastConv->fastconvReverberationTimes[i] = fastconvReverberationTimes[i] * scaleFactor;

        }

        scaleFactor = powf( 2.f, -1.f * (float) fastconvReverberationEneCorrections_factorQ );



        scaleFactor = powf( 2.f, -1.f * fastconvReverberationEneCorrections_factorQ );

        for ( i = 0; i < CLDFB_NO_CHANNELS_MAX; i++ )

        {

            HrtfFastConv->fastconvReverberationEneCorrections[i] = (float) fastconvReverberationEneCorrections[i] * scaleFactor;

            HrtfFastConv->fastconvReverberationEneCorrections[i] = fastconvReverberationEneCorrections[i] * scaleFactor;

        }

#else

        mvr2r( fastconvReverberationTimes, HrtfFastConv->fastconvReverberationTimes, CLDFB_NO_CHANNELS_MAX );

lib_rend/ivas_crend.c

+50 −43

File changed.

Preview size limit exceeded, changes collapsed.

lib_rend/ivas_dirac_dec_binaural_functions.c

+12 −9
Original line number Diff line number Diff line
@@ -378,6 +378,7 @@ ivas_error ivas_dirac_dec_binaural_copy_hrtfs( 
#else

    int16_t i, j;

#endif



    if ( hHrtfParambin != NULL && *hHrtfParambin != NULL )

    {

        /* Tables already loaded from file */
@@ -389,11 +390,13 @@ ivas_error ivas_dirac_dec_binaural_copy_hrtfs( 
        HRTFS_PARAMBIN *hrtfParambin;

#ifdef FIX_1123_PARAMBIN_16BIT_ROM

        float shCoef_scale, rt_scale, rene_scale, early_scale;

        shCoef_scale = powf( 2.f, -1.f * (float) hrtfShCoeffs_factorQ );

        rt_scale = powf( 2.f, -1.f * (float) parametricReverberationTimes_factorQ );

        rene_scale = powf( 2.f, -1.f * (float) parametricReverberationEneCorrections_factorQ );

        early_scale = powf( 2.f, -1.f * (float) parametricEarlyPartEneCorrection_factorQ );



        shCoef_scale = powf( 2.f, -1.f * hrtfShCoeffs_factorQ );

        rt_scale = powf( 2.f, -1.f * parametricReverberationTimes_factorQ );

        rene_scale = powf( 2.f, -1.f * parametricReverberationEneCorrections_factorQ );

        early_scale = powf( 2.f, -1.f * parametricEarlyPartEneCorrection_factorQ );

#endif



        if ( ( hrtfParambin = (HRTFS_PARAMBIN *) malloc( sizeof( HRTFS_PARAMBIN ) ) ) == NULL )

        {

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for parametric binauralizer HRTF tables" );
@@ -406,8 +409,8 @@ ivas_error ivas_dirac_dec_binaural_copy_hrtfs( 
#ifdef FIX_1123_PARAMBIN_16BIT_ROM

                for ( k = 0; k < HRTF_NUM_BINS; k++ )

                {

                    hrtfParambin->hrtfShCoeffsRe[i][j][k] = (float) hrtfShCoeffsRe[i][j][k] * shCoef_scale;

                    hrtfParambin->hrtfShCoeffsIm[i][j][k] = (float) hrtfShCoeffsIm[i][j][k] * shCoef_scale;

                    hrtfParambin->hrtfShCoeffsRe[i][j][k] = hrtfShCoeffsRe[i][j][k] * shCoef_scale;

                    hrtfParambin->hrtfShCoeffsIm[i][j][k] = hrtfShCoeffsIm[i][j][k] * shCoef_scale;

                }

#else

                mvr2r( hrtfShCoeffsRe[i][j], hrtfParambin->hrtfShCoeffsRe[i][j], HRTF_NUM_BINS );
@@ -419,9 +422,9 @@ ivas_error ivas_dirac_dec_binaural_copy_hrtfs( 
#ifdef FIX_1123_PARAMBIN_16BIT_ROM

        for ( i = 0; i < CLDFB_NO_CHANNELS_MAX; i++ )

        {

            hrtfParambin->parametricReverberationTimes[i] = (float) parametricReverberationTimes[i] * rt_scale;

            hrtfParambin->parametricReverberationEneCorrections[i] = (float) parametricReverberationEneCorrections[i] * rene_scale;

            hrtfParambin->parametricEarlyPartEneCorrection[i] = (float) parametricEarlyPartEneCorrection[i] * early_scale;

            hrtfParambin->parametricReverberationTimes[i] = parametricReverberationTimes[i] * rt_scale;

            hrtfParambin->parametricReverberationEneCorrections[i] = parametricReverberationEneCorrections[i] * rene_scale;

            hrtfParambin->parametricEarlyPartEneCorrection[i] = parametricEarlyPartEneCorrection[i] * early_scale;

        }

#else

        mvr2r( parametricReverberationTimes, hrtfParambin->parametricReverberationTimes, CLDFB_NO_CHANNELS_MAX );

lib_rend/ivas_objectRenderer_hrFilt.c

+2 −0
Original line number Diff line number Diff line
@@ -529,6 +529,7 @@ void BSplineModelEvalDealloc( 
#ifdef FIX_1123_TDREN_16BIT_ROM

        model->azimBsShape = NULL;

#endif



        for ( i = 0; i < model->elevDim3; i++ )

        {

            free( model->azimKSeq[i] );
@@ -540,6 +541,7 @@ void BSplineModelEvalDealloc( 
#ifdef FIX_1123_TDREN_16BIT_ROM

        model->azimKSeq = NULL;

#endif



        if ( modelEval != NULL )

        {

            free( modelEval->hrfModL );

lib_rend/ivas_objectRenderer_mix.c

+35 −30
Original line number Diff line number Diff line
@@ -217,6 +217,7 @@ void TDREND_MIX_Dealloc( 
            hBinRendererTd->HrFiltSet_p->ModelParams.elevKSeq = NULL;

            hBinRendererTd->HrFiltSet_p->ModelParams.elevBsShape = NULL;

#endif



            free( hBinRendererTd->HrFiltSet_p );

            hBinRendererTd->HrFiltSet_p = NULL;

            *hBinRendererTd->pHrFiltSet_p = NULL;
@@ -446,7 +447,6 @@ static ivas_error DefaultBSplineModel( 
    model = &( HrFiltSet_p->ModelParams );

    modelITD = &( HrFiltSet_p->ModelParamsITD );





    /* Set ROM flag for correct deallocation */

    model->modelROM = TRUE;
@@ -471,10 +471,10 @@ static ivas_error DefaultBSplineModel( 
        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }



    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_elevKSeq_Q );

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_elevKSeq_Q );

    for ( j = 0; j < model->elevDim3 - 2; j++ )

    {

        model->elevKSeq_dyn[j] = (float) defaultHRIR_rom_elevKSeq[j] * q_scale;

        model->elevKSeq_dyn[j] = defaultHRIR_rom_elevKSeq[j] * q_scale;

    }

    model->elevKSeq = (const float *) model->elevKSeq_dyn;
@@ -484,16 +484,17 @@ static ivas_error DefaultBSplineModel( 
        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }



    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_elevBsShape_Q );

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_elevBsShape_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        model->elevBsShape_dyn[j] = (float) defaultHRIR_rom_elevBsShape[j] * q_scale;

        model->elevBsShape_dyn[j] = defaultHRIR_rom_elevBsShape[j] * q_scale;

    }

    model->elevBsShape = (const float *) model->elevBsShape_dyn;

#else

    model->elevKSeq = (const float *) defaultHRIR_rom_elevKSeq;

    model->elevBsShape = (const float *) defaultHRIR_rom_elevBsShape;

#endif



    if ( ( model->azimBsShape = (const float **) malloc( model->num_unique_azim_splines * sizeof( float * ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );
@@ -509,13 +510,12 @@ static ivas_error DefaultBSplineModel( 
    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_azimBsShape_Q );

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_azimBsShape_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        model->azimBsShape_dyn[0][j] = (float) defaultHRIR_rom_azimBsShape[j] * q_scale;

        model->azimBsShape_dyn[0][j] = defaultHRIR_rom_azimBsShape[j] * q_scale;

    }

    model->azimBsShape[0] = (const float *) model->azimBsShape_dyn[0];



#else

    model->azimBsShape[0] = (const float *) defaultHRIR_rom_azimBsShape;

#endif
@@ -524,12 +524,14 @@ static ivas_error DefaultBSplineModel( 
    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }



    for ( i = 0; i < model->elevDim3; i++ )

    {

        if ( ( model->azimKSeq[i] = (float *) malloc( ( model->azimDim3[i] + 1 ) * sizeof( float * ) ) ) == NULL )

        {

            return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

        }



        if ( model->azimShapeIdx[i] < 0 )

        {

            azimSegSamples = 360.0f;
@@ -538,6 +540,7 @@ static ivas_error DefaultBSplineModel( 
        {

            azimSegSamples = defaultHRIR_rom_azimSegSamples[model->azimShapeIdx[i]];

        }



        assert( azimSegSamples == 360.0f / model->azimDim3[i] );

        for ( j = 0; j < model->azimDim3[i] + 1; j++ )

        {
@@ -549,8 +552,8 @@ static ivas_error DefaultBSplineModel( 
    {

        case 48000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_a = powf( 2.f, -1.f * (float) defaultHRIR_rom_Alpha48_Q );

            q_scale_e = powf( 2.f, -1.f * (float) defaultHRIR_rom_E48_Q );

            q_scale_a = powf( 2.f, -1.f * defaultHRIR_rom_Alpha48_Q );

            q_scale_e = powf( 2.f, -1.f * defaultHRIR_rom_E48_Q );

            alphaL_ptr = defaultHRIR_rom_AlphaL48;

            alphaR_ptr = defaultHRIR_rom_AlphaR48;

            elL_ptr = defaultHRIR_rom_EL48;
@@ -569,8 +572,8 @@ static ivas_error DefaultBSplineModel( 
            break;

        case 32000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_a = powf( 2.f, -1.f * (float) defaultHRIR_rom_Alpha32_Q );

            q_scale_e = powf( 2.f, -1.f * (float) defaultHRIR_rom_E32_Q );

            q_scale_a = powf( 2.f, -1.f * defaultHRIR_rom_Alpha32_Q );

            q_scale_e = powf( 2.f, -1.f * defaultHRIR_rom_E32_Q );

            alphaL_ptr = defaultHRIR_rom_AlphaL32;

            alphaR_ptr = defaultHRIR_rom_AlphaR32;

            elL_ptr = defaultHRIR_rom_EL32;
@@ -589,8 +592,8 @@ static ivas_error DefaultBSplineModel( 
            break;

        case 16000:

#ifdef FIX_1123_TDREN_16BIT_ROM

            q_scale_a = powf( 2.f, -1.f * (float) defaultHRIR_rom_Alpha16_Q );

            q_scale_e = powf( 2.f, -1.f * (float) defaultHRIR_rom_E16_Q );

            q_scale_a = powf( 2.f, -1.f * defaultHRIR_rom_Alpha16_Q );

            q_scale_e = powf( 2.f, -1.f * defaultHRIR_rom_E16_Q );

            alphaL_ptr = defaultHRIR_rom_AlphaL16;

            alphaR_ptr = defaultHRIR_rom_AlphaR16;

            elL_ptr = defaultHRIR_rom_EL16;
@@ -621,8 +624,8 @@ static ivas_error DefaultBSplineModel( 
    }

    for ( j = 0; j < model->AlphaN * model->K; j++ )

    {

        model->AlphaL_dyn[j] = (float) alphaL_ptr[j] * q_scale_a;

        model->AlphaR_dyn[j] = (float) alphaR_ptr[j] * q_scale_a;

        model->AlphaL_dyn[j] = alphaL_ptr[j] * q_scale_a;

        model->AlphaR_dyn[j] = alphaR_ptr[j] * q_scale_a;

    }

    model->AlphaL = (const float *) model->AlphaL_dyn;

    model->AlphaR = (const float *) model->AlphaR_dyn;
@@ -632,6 +635,7 @@ static ivas_error DefaultBSplineModel( 
#ifndef FIX_1123_TDREN_16BIT_ROM

    HRTF_energy_sections_precalc( model );

#endif



    if ( ( model->EL_dyn = (float *) malloc( HRTF_MODEL_N_SECTIONS * model->AlphaN * sizeof( float ) ) ) == NULL )

    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );
@@ -642,8 +646,8 @@ static ivas_error DefaultBSplineModel( 
    }

    for ( j = 0; j < HRTF_MODEL_N_SECTIONS * model->AlphaN; j++ )

    {

        model->EL_dyn[j] = (float) elL_ptr[j] * q_scale_e;

        model->ER_dyn[j] = (float) elR_ptr[j] * q_scale_e;

        model->EL_dyn[j] = elL_ptr[j] * q_scale_e;

        model->ER_dyn[j] = elR_ptr[j] * q_scale_e;

    }



    model->EL = (const float *) model->EL_dyn;
@@ -662,10 +666,10 @@ static ivas_error DefaultBSplineModel( 
    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_ITD_elevKSeq_Q );

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_elevKSeq_Q );

    for ( j = 0; j < modelITD->elevDim3 - 2; j++ )

    {

        modelITD->elevKSeq_dyn[j] = (float) defaultHRIR_rom_ITD_elevKSeq[j] * q_scale;

        modelITD->elevKSeq_dyn[j] = defaultHRIR_rom_ITD_elevKSeq[j] * q_scale;

    }

    modelITD->elevKSeq = (const float *) modelITD->elevKSeq_dyn;

#else
@@ -680,10 +684,10 @@ static ivas_error DefaultBSplineModel( 
    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_ITD_azimKSeq_Q );

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_azimKSeq_Q );

    for ( j = 0; j < ( modelITD->azimDim3 + 1 ) / 2 - 2; j++ )

    {

        modelITD->azimKSeq_dyn[j] = (float) defaultHRIR_rom_ITD_azimKSeq[j] * q_scale;

        modelITD->azimKSeq_dyn[j] = defaultHRIR_rom_ITD_azimKSeq[j] * q_scale;

    }

    modelITD->azimKSeq = (const float *) modelITD->azimKSeq_dyn;

#else
@@ -695,10 +699,10 @@ static ivas_error DefaultBSplineModel( 
    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_ITD_W_Q );

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_W_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        modelITD->W_dyn[j] = (float) defaultHRIR_rom_ITD_W[j] * q_scale;

        modelITD->W_dyn[j] = defaultHRIR_rom_ITD_W[j] * q_scale;

    }

    modelITD->W = (const float *) modelITD->W_dyn;
@@ -707,10 +711,10 @@ static ivas_error DefaultBSplineModel( 
    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_ITD_azimBsShape_Q );

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_azimBsShape_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        modelITD->azimBsShape_dyn[j] = (float) defaultHRIR_rom_ITD_azimBsShape[j] * q_scale;

        modelITD->azimBsShape_dyn[j] = defaultHRIR_rom_ITD_azimBsShape[j] * q_scale;

    }

    modelITD->azimBsShape = (const float *) modelITD->azimBsShape_dyn;
@@ -719,10 +723,10 @@ static ivas_error DefaultBSplineModel( 
    {

        return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for Binaural TD renderer\n" ) );

    }

    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_ITD_elevBsShape_Q );

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_ITD_elevBsShape_Q );

    for ( j = 0; j < size_rom_table; j++ )

    {

        modelITD->elevBsShape_dyn[j] = (float) defaultHRIR_rom_ITD_elevBsShape[j] * q_scale;

        modelITD->elevBsShape_dyn[j] = defaultHRIR_rom_ITD_elevBsShape[j] * q_scale;

    }

    modelITD->elevBsShape = (const float *) modelITD->elevBsShape_dyn;

#else
@@ -730,11 +734,12 @@ static ivas_error DefaultBSplineModel( 
    modelITD->azimBsShape = (const float *) defaultHRIR_rom_ITD_azimBsShape;

    modelITD->elevBsShape = (const float *) defaultHRIR_rom_ITD_elevBsShape;

#endif



    HRTF_model_precalc( model );



#ifdef FIX_1123_TDREN_16BIT_ROM

    q_scale = powf( 2.f, -1.f * (float) defaultHRIR_rom_latency_s_Q );

    HrFiltSet_p->latency_s = (float) defaultHRIR_rom_latency_s * q_scale;

    q_scale = powf( 2.f, -1.f * defaultHRIR_rom_latency_s_Q );

    HrFiltSet_p->latency_s = defaultHRIR_rom_latency_s * q_scale;

#else

    HrFiltSet_p->latency_s = defaultHRIR_rom_latency_s;

#endif