Commit 6e6a1280 authored by vaclav's avatar vaclav
Browse files

- removal of multiplied code; so far under FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2 

- fixes
parent 00dc70ac

lib_com/options.h

+1 −0
Original line number Diff line number Diff line
@@ -164,6 +164,7 @@ 
#define TMP_FIX_1119_SPLIT_RENDERING_VOIP               /* FhG: Add error check for unsupported config: split rendering with VoIP mode */

#define FIX_1209_SID_SIGNALING                          /* VA: issue 1209: remove dead code in IVAS SID signaling */

#define FIX_1226_FASTCONV_HRTF_LOADING_OPTIM            /* VA: issue 1226: for FastConv binaural renderer in decoder, load only HTRT coefficient set that is needed */

#define FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2          /* removal of multiplied code */



/* #################### End BE switches ################################## */

lib_dec/ivas_binRenderer_internal.c

+189 −1
Original line number Diff line number Diff line
@@ -165,10 +165,16 @@ static ivas_error ivas_binRenderer_convModuleOpen( 
        hBinRenderer->nInChannels = ( audioCfg2channels( input_config ) - isLoudspeaker );

    }



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

    hBinRenConvModule->numTaps = hHrtf->ntaps;

#endif



    if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )

    {

#ifndef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

        hBinRenConvModule->numTaps = hHrtf->ntaps_brir;



#endif

        /* Use variable order filtering */

        bandIdx = 0;

        for ( ; bandIdx < 5; bandIdx++ )
@@ -194,6 +200,7 @@ static ivas_error ivas_binRenderer_convModuleOpen( 
    }

    else

    {

#ifndef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

        if ( hBinRenderer->ivas_format == SBA_FORMAT )

        {

            if ( input_config == IVAS_AUDIO_CONFIG_HOA3 )
@@ -218,6 +225,7 @@ static ivas_error ivas_binRenderer_convModuleOpen( 
            hBinRenConvModule->numTaps = hHrtf->ntaps_hrir;

        }



#endif

        /* Use fixed order filtering */

        bandIdx = 0;

        for ( ; bandIdx < hBinRenderer->conv_band; bandIdx++ )
@@ -326,6 +334,9 @@ static ivas_error ivas_binRenderer_convModuleOpen( 
        {

            int16_t tmp = 0;



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            tmp = chIdx;

#endif

            if ( isLoudspeaker )

            {

                if ( input_config == IVAS_AUDIO_CONFIG_5_1 )
@@ -356,6 +367,12 @@ static ivas_error ivas_binRenderer_convModuleOpen( 
#endif

            }



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            hBinRenConvModule->filterTapsLeftReal[bandIdx][chIdx] = hHrtf->leftReal[bandIdx][tmp];

            hBinRenConvModule->filterTapsLeftImag[bandIdx][chIdx] = hHrtf->leftImag[bandIdx][tmp];

            hBinRenConvModule->filterTapsRightReal[bandIdx][chIdx] = hHrtf->rightReal[bandIdx][tmp];

            hBinRenConvModule->filterTapsRightImag[bandIdx][chIdx] = hHrtf->rightImag[bandIdx][tmp];

#else

            if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )

            {
@@ -419,6 +436,7 @@ static ivas_error ivas_binRenderer_convModuleOpen( 
                    }

                }

            }

#endif

        }

    }
@@ -453,6 +471,17 @@ void ivas_init_binaural_hrtf( 
{

    int16_t i;



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

    HrtfFastConv->leftReal = NULL;

    HrtfFastConv->leftImag = NULL;

    HrtfFastConv->rightReal = NULL;

    HrtfFastConv->rightImag = NULL;

    HrtfFastConv->FASTCONV_latency_s = 0x00;



    HrtfFastConv->n_channels = 0;

    HrtfFastConv->allocate_init_flag = 0x00;

    HrtfFastConv->ntaps = 0;

#else

    HrtfFastConv->leftHRIRReal_HOA3 = NULL;

    HrtfFastConv->leftHRIRImag_HOA3 = NULL;

    HrtfFastConv->rightHRIRReal_HOA3 = NULL;
@@ -489,6 +518,7 @@ void ivas_init_binaural_hrtf( 
    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++ )

    {
@@ -559,6 +589,57 @@ ivas_error ivas_allocate_binaural_hrtf( 
    const int16_t allocate_init_flag                    /* i  : Memory allocation flag      */

)

{

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

    int16_t n_channels = 0;



    if ( ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM && bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED ) ||

         ( ( renderer_type == RENDERER_BINAURAL_FASTCONV || renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM ) && input_config != IVAS_AUDIO_CONFIG_INVALID ) )

    {

        n_channels = HRTF_LS_CHANNELS;

    }



    if ( renderer_type == RENDERER_BINAURAL_FASTCONV )

    {

        if ( input_config == IVAS_AUDIO_CONFIG_HOA3 || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_HOA3 || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )

        {

            n_channels = HOA3_CHANNELS;

        }

        else if ( input_config == IVAS_AUDIO_CONFIG_HOA2 || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_HOA2 )

        {

            n_channels = HOA2_CHANNELS;

        }

        else if ( input_config == IVAS_AUDIO_CONFIG_FOA || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_FOA )

        {

            n_channels = FOA_CHANNELS;

        }

    }



    HrtfFastConv->n_channels = n_channels;



    if ( ( HrtfFastConv->leftReal != NULL ) && ( HrtfFastConv->leftImag != NULL ) && ( HrtfFastConv->rightReal != NULL ) && ( HrtfFastConv->rightImag != NULL ) )

    {

        return IVAS_ERR_OK;

    }

    else

    {

        if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftReal, BINAURAL_CONVBANDS, n_channels, HrtfFastConv->ntaps, allocate_init_flag ) )

        {

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HrtfFastConv->leftReal" );

        }

        if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftImag, BINAURAL_CONVBANDS, n_channels, HrtfFastConv->ntaps, allocate_init_flag ) )

        {

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HrtfFastConv->leftImag" );

        }

        if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightReal, BINAURAL_CONVBANDS, n_channels, HrtfFastConv->ntaps, allocate_init_flag ) )

        {

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HrtfFastConv->rightReal" );

        }

        if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightImag, BINAURAL_CONVBANDS, n_channels, HrtfFastConv->ntaps, allocate_init_flag ) )

        {

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HrtfFastConv->rightImag" );

        }

    }

#else

    if ( input_config == IVAS_AUDIO_CONFIG_HOA3 || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_HOA3 )

    {

        if ( ( HrtfFastConv->leftHRIRReal_HOA3 != NULL ) && ( HrtfFastConv->leftHRIRImag_HOA3 != NULL ) && ( HrtfFastConv->rightHRIRReal_HOA3 != NULL ) && ( HrtfFastConv->rightHRIRImag_HOA3 != NULL ) )
@@ -685,6 +766,7 @@ ivas_error ivas_allocate_binaural_hrtf( 
            }

        }

    }

#endif



    return IVAS_ERR_OK;

}
@@ -725,23 +807,48 @@ static ivas_error ivas_binaural_hrtf_open( 


        if ( input_config == IVAS_AUDIO_CONFIG_BINAURAL || renderer_type == RENDERER_BINAURAL_FASTCONV )

        {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            HrtfFastConv->FASTCONV_latency_s = FASTCONV_HRIR_latency_s;

            HrtfFastConv->ntaps = BINAURAL_NTAPS;

#else

            HrtfFastConv->FASTCONV_HRIR_latency_s = FASTCONV_HRIR_latency_s;

#endif

        }

        if ( input_config == IVAS_AUDIO_CONFIG_HOA2 )

        {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            HrtfFastConv->FASTCONV_latency_s = FASTCONV_HOA2_latency_s;

            HrtfFastConv->ntaps = BINAURAL_NTAPS_SBA;

#else

            HrtfFastConv->FASTCONV_HOA2_latency_s = FASTCONV_HOA2_latency_s;

#endif

        }

        if ( input_config == IVAS_AUDIO_CONFIG_HOA3 )

        {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            HrtfFastConv->FASTCONV_latency_s = FASTCONV_HOA3_latency_s;

            HrtfFastConv->ntaps = BINAURAL_NTAPS_SBA;

#else

            HrtfFastConv->FASTCONV_HOA3_latency_s = FASTCONV_HOA3_latency_s;

#endif

        }

        if ( input_config == IVAS_AUDIO_CONFIG_FOA )

        {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            HrtfFastConv->FASTCONV_latency_s = FASTCONV_FOA_latency_s;

            HrtfFastConv->ntaps = BINAURAL_NTAPS_SBA;

#else

            HrtfFastConv->FASTCONV_FOA_latency_s = FASTCONV_FOA_latency_s;

#endif

        }

        if ( input_config == IVAS_AUDIO_CONFIG_BINAURAL || renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )

        {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            HrtfFastConv->FASTCONV_latency_s = FASTCONV_BRIR_latency_s;

            HrtfFastConv->ntaps = BINAURAL_NTAPS_MAX;

#else

            HrtfFastConv->FASTCONV_BRIR_latency_s = FASTCONV_BRIR_latency_s;

#endif

        }



        HrtfFastConv->allocate_init_flag = 1;
@@ -753,60 +860,116 @@ static ivas_error ivas_binaural_hrtf_open( 


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

        {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            if ( renderer_type == RENDERER_BINAURAL_FASTCONV && HrtfFastConv->n_channels == HRTF_LS_CHANNELS )

#else

            if ( renderer_type == RENDERER_BINAURAL_FASTCONV )

#endif

            {

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

                {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

                    HrtfFastConv->leftReal[i][j] = leftHRIRReal[i][j];

                    HrtfFastConv->leftImag[i][j] = leftHRIRImag[i][j];

                    HrtfFastConv->rightReal[i][j] = rightHRIRReal[i][j];

                    HrtfFastConv->rightImag[i][j] = rightHRIRImag[i][j];

#else

                    HrtfFastConv->leftHRIRReal[i][j] = leftHRIRReal[i][j];

                    HrtfFastConv->leftHRIRImag[i][j] = leftHRIRImag[i][j];

                    HrtfFastConv->rightHRIRReal[i][j] = rightHRIRReal[i][j];

                    HrtfFastConv->rightHRIRImag[i][j] = rightHRIRImag[i][j];

#endif

                }

            }

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            else if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM && HrtfFastConv->n_channels == HRTF_LS_CHANNELS )

#else

            else if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM )

#endif

            {

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

                {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

                    HrtfFastConv->leftReal[i][j] = leftBRIRReal[i][j];

                    HrtfFastConv->leftImag[i][j] = leftBRIRImag[i][j];

                    HrtfFastConv->rightReal[i][j] = rightBRIRReal[i][j];

                    HrtfFastConv->rightImag[i][j] = rightBRIRImag[i][j];

#else

                    HrtfFastConv->leftBRIRReal[i][j] = leftBRIRReal[i][j];

                    HrtfFastConv->leftBRIRImag[i][j] = leftBRIRImag[i][j];

                    HrtfFastConv->rightBRIRReal[i][j] = rightBRIRReal[i][j];

                    HrtfFastConv->rightBRIRImag[i][j] = rightBRIRImag[i][j];

#endif

                }

            }



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            if ( input_config == IVAS_AUDIO_CONFIG_HOA3 && HrtfFastConv->n_channels == HOA3_CHANNELS )

#else

            if ( input_config == IVAS_AUDIO_CONFIG_HOA3 )

#endif

            {

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

                {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

                    HrtfFastConv->leftReal[i][j] = leftHRIRReal_HOA3[i][j];

                    HrtfFastConv->leftImag[i][j] = leftHRIRImag_HOA3[i][j];

                    HrtfFastConv->rightReal[i][j] = rightHRIRReal_HOA3[i][j];

                    HrtfFastConv->rightImag[i][j] = rightHRIRImag_HOA3[i][j];

#else

                    HrtfFastConv->leftHRIRReal_HOA3[i][j] = leftHRIRReal_HOA3[i][j];

                    HrtfFastConv->leftHRIRImag_HOA3[i][j] = leftHRIRImag_HOA3[i][j];

                    HrtfFastConv->rightHRIRReal_HOA3[i][j] = rightHRIRReal_HOA3[i][j];

                    HrtfFastConv->rightHRIRImag_HOA3[i][j] = rightHRIRImag_HOA3[i][j];

#endif

                }

            }



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            /* Note: IVAS_AUDIO_CONFIG_HOA2 and IVAS_AUDIO_CONFIG_FOA input configs. are not relevant in internal renderer

            as SBA to binaural always synthesizes HOA3 output for binauralization. However, the external renderer can use them. */

#endif

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            if ( input_config == IVAS_AUDIO_CONFIG_HOA2 && HrtfFastConv->n_channels == HOA2_CHANNELS )

#else

            if ( input_config == IVAS_AUDIO_CONFIG_HOA2 )

#endif

            {

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

                {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

                    HrtfFastConv->leftReal[i][j] = leftHRIRReal_HOA2[i][j];

                    HrtfFastConv->leftImag[i][j] = leftHRIRImag_HOA2[i][j];

                    HrtfFastConv->rightReal[i][j] = rightHRIRReal_HOA2[i][j];

                    HrtfFastConv->rightImag[i][j] = rightHRIRImag_HOA2[i][j];

#else

                    HrtfFastConv->leftHRIRReal_HOA2[i][j] = leftHRIRReal_HOA2[i][j];

                    HrtfFastConv->leftHRIRImag_HOA2[i][j] = leftHRIRImag_HOA2[i][j];

                    HrtfFastConv->rightHRIRReal_HOA2[i][j] = rightHRIRReal_HOA2[i][j];

                    HrtfFastConv->rightHRIRImag_HOA2[i][j] = rightHRIRImag_HOA2[i][j];

#endif

                }

            }



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

            if ( input_config == IVAS_AUDIO_CONFIG_FOA && HrtfFastConv->n_channels == FOA_CHANNELS )

#else

            if ( input_config == IVAS_AUDIO_CONFIG_FOA )

#endif

            {

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

                {

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

                    HrtfFastConv->leftReal[i][j] = leftHRIRReal_FOA[i][j];

                    HrtfFastConv->leftImag[i][j] = leftHRIRImag_FOA[i][j];

                    HrtfFastConv->rightReal[i][j] = rightHRIRReal_FOA[i][j];

                    HrtfFastConv->rightImag[i][j] = rightHRIRImag_FOA[i][j];

#else

                    HrtfFastConv->leftHRIRReal_FOA[i][j] = leftHRIRReal_FOA[i][j];

                    HrtfFastConv->leftHRIRImag_FOA[i][j] = leftHRIRImag_FOA[i][j];

                    HrtfFastConv->rightHRIRReal_FOA[i][j] = rightHRIRReal_FOA[i][j];

                    HrtfFastConv->rightHRIRImag_FOA[i][j] = rightHRIRImag_FOA[i][j];

#endif

                }

            }

        }
@@ -1045,6 +1208,9 @@ ivas_error ivas_rend_openCldfbRend( 
        return error;

    }



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

    pCldfbRend->binaural_latency_ns = (int32_t) ( pCldfbRend->hHrtfFastConv->FASTCONV_latency_s * 1000000000.f );

#else

    if ( inConfig == IVAS_AUDIO_CONFIG_FOA )

    {

        pCldfbRend->binaural_latency_ns = (int32_t) ( pCldfbRend->hHrtfFastConv->FASTCONV_FOA_latency_s * 1000000000.f );
@@ -1062,6 +1228,8 @@ ivas_error ivas_rend_openCldfbRend( 
        /* should never happen for SBA */

        return IVAS_ERR_INVALID_OUTPUT_FORMAT;

    }

#endif



    hBinRenderer->hReverb = NULL;

    hBinRenderer->hEFAPdata = NULL;
@@ -1183,7 +1351,11 @@ ivas_error ivas_binRenderer_open( 
        }



        hBinRenderer->hoa_dec_mtx = st_ivas->hoa_dec_mtx;

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

        st_ivas->binaural_latency_ns = (int32_t) ( st_ivas->hHrtfFastConv->FASTCONV_latency_s * 1000000000.f );

#else

        st_ivas->binaural_latency_ns = (int32_t) ( st_ivas->hHrtfFastConv->FASTCONV_BRIR_latency_s * 1000000000.f );

#endif

    }

    else

    {
@@ -1193,6 +1365,9 @@ ivas_error ivas_binRenderer_open( 
            return error;

        }



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

        st_ivas->binaural_latency_ns = (int32_t) ( st_ivas->hHrtfFastConv->FASTCONV_latency_s * 1000000000.f );

#else

        if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV )

        {

            if ( hBinRenderer->ivas_format == MC_FORMAT )
@@ -1224,6 +1399,7 @@ ivas_error ivas_binRenderer_open( 
            /* same value for MC or HOA both use MC BRIR*/

            st_ivas->binaural_latency_ns = (int32_t) ( st_ivas->hHrtfFastConv->FASTCONV_BRIR_latency_s * 1000000000.f );

        }

#endif

    }



    /* Allocate memories needed for reverb module */
@@ -1445,6 +1621,9 @@ void ivas_binaural_hrtf_close( 
)

{

    int16_t allocate_init_flag;

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

    int16_t n_channels;

#endif



    if ( hHrtfFastConv == NULL || *hHrtfFastConv == NULL )

    {
@@ -1452,6 +1631,14 @@ void ivas_binaural_hrtf_close( 
    }



    allocate_init_flag = ( *hHrtfFastConv )->allocate_init_flag;

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

    n_channels = ( *hHrtfFastConv )->n_channels;



    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftReal, n_channels, allocate_init_flag );

    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftImag, n_channels, allocate_init_flag );

    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightReal, n_channels, allocate_init_flag );

    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightImag, n_channels, allocate_init_flag );

#else



    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRReal, HRTF_LS_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRImag, HRTF_LS_CHANNELS, allocate_init_flag );
@@ -1477,6 +1664,7 @@ void ivas_binaural_hrtf_close( 
    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRImag_FOA, FOA_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRReal_FOA, FOA_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRImag_FOA, FOA_CHANNELS, allocate_init_flag );

#endif



    return;

}

lib_dec/lib_dec.c

+23 −5
Original line number Diff line number Diff line
@@ -929,7 +929,11 @@ ivas_error IVAS_DEC_ReadFormat( 
    ISM_MODE ism_mode_old;

    MC_MODE mc_mode_old;

    int16_t nchan_transport_old;

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM

    AUDIO_CONFIG intern_config_old, transport_config_old, output_config;

#else

    AUDIO_CONFIG intern_config_old, transport_config_old;

#endif

    RENDERER_TYPE renderer_type_old;



    if ( hIvasDec == NULL || hIvasDec->st_ivas == NULL )
@@ -946,6 +950,11 @@ ivas_error IVAS_DEC_ReadFormat( 
    transport_config_old = st_ivas->transport_config;

    renderer_type_old = st_ivas->renderer_type;



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM

    output_config = st_ivas->hDecoderConfig->output_config;



#endif



    if ( st_ivas->ivas_format == MONO_FORMAT )

    {

        return IVAS_ERR_OK;
@@ -999,23 +1008,27 @@ ivas_error IVAS_DEC_ReadFormat( 
        }



        *binaural_renderer_sec = IVAS_BIN_RENDERER_TYPE_NONE;

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM

        if ( st_ivas->ivas_format == MASA_ISM_FORMAT && st_ivas->ism_mode == ISM_MASA_MODE_DISC && output_config == IVAS_AUDIO_CONFIG_BINAURAL )

#else

        if ( st_ivas->ivas_format == MASA_ISM_FORMAT && st_ivas->ism_mode == ISM_MASA_MODE_DISC && st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL )

#endif

        {

            *binaural_renderer_sec = IVAS_BIN_RENDERER_TYPE_TDREND;

        }



#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM

        *fastConv_set_cfg = IVAS_AUDIO_CONFIG_INVALID;

        if ( *binaural_renderer == IVAS_BIN_RENDERER_TYPE_FASTCONV || *binaural_renderer == IVAS_BIN_RENDERER_TYPE_FASTCONV )

        if ( *binaural_renderer == IVAS_BIN_RENDERER_TYPE_FASTCONV )

        {

            if ( st_ivas->ivas_format == SBA_FORMAT || st_ivas->ivas_format == SBA_ISM_FORMAT )

            {

                if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL ||

                     st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )

                if ( output_config == IVAS_AUDIO_CONFIG_BINAURAL ||

                     output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )

                {

                    *fastConv_set_cfg = IVAS_AUDIO_CONFIG_HOA3;

                }

                else if ( st_ivas->hDecoderConfig->output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR )

                else if ( output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR )

                {

                    *fastConv_set_cfg = IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR;

                }
@@ -1024,11 +1037,16 @@ ivas_error IVAS_DEC_ReadFormat( 
            {

                *fastConv_set_cfg = IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR;



                if ( output_config == IVAS_AUDIO_CONFIG_BINAURAL || output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )

                {

                    *fastConv_set_cfg = IVAS_AUDIO_CONFIG_LS_CUSTOM; /* hack to signal BINAURAL_INPUT_AUDIO_CONFIG_COMBINED coefs. without ROOM effect */

                }



                if ( st_ivas->hDecoderConfig->Opt_Headrotation )

                {

                    *fastConv_set_cfg = IVAS_AUDIO_CONFIG_HOA3;



                    if ( st_ivas->mc_mode == MC_MODE_PARAMUPMIX )

                    if ( st_ivas->mc_mode == MC_MODE_PARAMUPMIX && output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR )

                    {

                        *fastConv_set_cfg = IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR;

                    }

lib_rend/ivas_stat_rend.h

+13 −0
Original line number Diff line number Diff line
@@ -1257,6 +1257,14 @@ typedef struct ivas_hrtfs_crend_structure 
/* Fastconv binaural data structure */

typedef struct ivas_hrtfs_fastconv_struct

{

#ifdef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM_2

    float FASTCONV_latency_s;

    float ***leftReal;

    float ***leftImag;

    float ***rightReal;

    float ***rightImag;

    int16_t n_channels;

#else

    float FASTCONV_HOA3_latency_s;

    float ***leftHRIRReal_HOA3;

    float ***leftHRIRImag_HOA3;
@@ -1286,13 +1294,18 @@ typedef struct ivas_hrtfs_fastconv_struct 
    float ***rightHRIRReal_FOA;

    float ***rightHRIRImag_FOA;

    float FASTCONV_FOA_latency_s;

#endif



    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_1226_FASTCONV_HRTF_LOADING_OPTIM_2

    uint16_t ntaps;

#else

    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

+81 −3

File changed.

Preview size limit exceeded, changes collapsed.