Commit 7bdd2869 authored by emerit's avatar emerit
Browse files

fix bugs and add renderer tests

parent 5995a13e

.gitignore

0 → 100644
+86 −0
Original line number Diff line number Diff line 
# .gitignore for IVAS public collaboration Git repository



# Compiler output Unix

IVAS_cod

IVAS_dec

IVAS_rend

obj/

*.a

*.o

*.P



# default CMake

build*/**/*



# Compiler output VS2017

IVAS_cod.exe

IVAS_dec.exe

IVAS_rend.exe

*.user

.vs/

Debug_*/

Release_*/

*.obj

*.pdb



# Standalone TD object renderer

scripts/td_object_renderer/object_renderer_standalone/renderer_standalone

scripts/td_object_renderer/object_renderer_standalone/renderer_standalone.exe



# General/scripts

.DS_Store

.vscode

.cache

.idea

*.log

*.bak

.\#*

scripts/c-code_instrument/

scripts/ifdef_instrument.list

scripts/ref/

scripts/test/

scripts/out/

scripts/self_test_summary.txt

scripts/cppp/

binary/

tests/**/[c|d]ut

tests/**/ref

tests/*/testv

tests/hrtf_binary_loading/bitstream/*

tests/hrtf_binary_loading/dec_out_*/*

scripts/testv/*_cut*.pcm

scripts/testv/*_cut*.wav

scripts/testv/stvOMASA_*.met

scripts/testv/stvOMASA_*.csv

scripts/testv/stvOMASA_2ISM_1MASA1TC48c.wav

scripts/testv/stvOMASA_3ISM_1MASA1TC48c.wav

# default reference binary name

IVAS_cod_ref*

IVAS_dec_ref*

IVAS_rend_ref*



# Python files that pop up when running scripts

__pycache__/

*.py[cod]

*$py.class



# history

.history/



#externals

Externals/



# coan output files that are created when cleaning out switches

coan_out_*

/COMPLEXITY

/res

/tv

/wmops

/Workspace_msvc/renderer.args.json

/Workspace_msvc/encoder.args.json

/Workspace_msvc/decoder.args.json

/scripts/mem_analysis_enc_VBR_5k9.csv

/scripts/mem_analysis_enc_STEREO_sw.png

/scripts/mem_analysis_enc_STEREO_sw.csv

/scripts/mem_analysis_enc_STEREO_16k4_DTX.csv

*.pwv

lib_com/ivas_prot.h

+12 −0
Original line number Diff line number Diff line
@@ -6118,6 +6118,18 @@ void ivas_init_binaural_hrtf( 
  HRTFS_FASTCONV *HrtfFastConv                                  /* i/o: FASTCONV HRTF structure                         */

);



#ifdef FIX_CREND_CHANGES

#ifdef IVAS_FLOAT_FIXED

ivas_error ivas_allocate_binaural_hrtf_fx(

    HRTFS_FASTCONV *HrtfFastConv,                               /* i/o: FASTCONV HRTF structure */

    const AUDIO_CONFIG input_config,                            /* i  : input audio configuration                       */

    const BINAURAL_INPUT_AUDIO_CONFIG bin_input_config,         /* i  : binaural input audio config                     */

    const RENDERER_TYPE renderer_type,                          /* i  : renderer type                                   */

    const int16_t allocate_init_flag                            /* i  : Memory allocation flag                          */

);

#endif

#endif



ivas_error ivas_allocate_binaural_hrtf(

    HRTFS_FASTCONV *HrtfFastConv,                               /* i/o: FASTCONV HRTF structure */

    const AUDIO_CONFIG input_config,                            /* i  : input audio configuration                       */

lib_dec/ivas_binRenderer_internal.c

+304 −44
Original line number Diff line number Diff line
@@ -772,17 +772,59 @@ static ivas_error ivas_alloc_pppMem( 
        return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF memory" );

    }



    FOR( i = 0; i < dim1; i++ )

    FOR( i = 0; i < dim1; i++ ){

        IF( ( localMem[i] = (float **) malloc( dim2 * sizeof( float * ) ) ) == NULL ){

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF memory" );

}

IF( allocate_init_flag == 0 )

{

    FOR( j = 0; j < dim2; j++ )

    {

        IF( ( localMem[i][j] = (float *) malloc( dim3 * sizeof( float ) ) ) == NULL )

        {

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF memory" );

        }

    }

}

}



*pppMem = localMem;



return IVAS_ERR_OK;

}



#ifdef FIX_CREND_CHANGES

#ifdef IVAS_FLOAT_FIXED

/*-------------------------------------------------------------------------*

 * ivas_alloc_pppMem_fx()

 *

 * Allocate memory for tripple pointer elements

 *-------------------------------------------------------------------------*/



static ivas_error ivas_alloc_pppMem_fx(

    Word32 ****pppMem,

    const Word16 dim1,

    const Word16 dim2,

    const Word16 dim3,

    const Word16 allocate_init_flag )

{

        IF( ( localMem[i] = (float **) malloc( dim2 * sizeof( float * ) ) ) == NULL )

    Word16 i, j;

    Word32 ***localMem = NULL;



    IF( ( localMem = (Word32 ***) malloc( dim1 * sizeof( Word32 ** ) ) ) == NULL )

    {

        return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF memory" );

    }



    FOR( i = 0; i < dim1; i++ ){

        IF( ( localMem[i] = (Word32 **) malloc( dim2 * sizeof( Word32 * ) ) ) == NULL ){

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF memory" );

}

IF( allocate_init_flag == 0 )

{

    FOR( j = 0; j < dim2; j++ )

    {

                IF( ( localMem[i][j] = (float *) malloc( dim3 * sizeof( float ) ) ) == NULL )

        IF( ( localMem[i][j] = (Word32 *) malloc( dim3 * sizeof( Word32 ) ) ) == NULL )

        {

            return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF memory" );

        }
@@ -795,7 +837,196 @@ static ivas_error ivas_alloc_pppMem( 
return IVAS_ERR_OK;

}



/*-------------------------------------------------------------------------

 * ivas_free_pppHrtfMem_fx()

 *

 * Free fastconv binaural renderer hrtf memories

 *------------------------------------------------------------------------*/



static void ivas_free_pppHrtfMem_fx(

    Word32 ****ppppHRIR,

    const Word16 dim,

    const Word16 alloc_init )

{

    Word16 i, j;



    IF( *ppppHRIR != NULL )

    {

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

        {

            IF( alloc_init == 0 )

            {

                FOR( j = 0; j < dim; j++ )

                {

                    free( ( *ppppHRIR )[i][j] );

                    ( *ppppHRIR )[i][j] = NULL;

                }

            }

            free( ( *ppppHRIR )[i] );

            ( *ppppHRIR )[i] = NULL;

        }

        free( *ppppHRIR );

        *ppppHRIR = NULL;

    }



    return;

}



/*-------------------------------------------------------------------------*

 * ivas_allocate_binaural_hrtf_fx()

 *

 * Allocate memory for HrtfFastConv structure elements

 *-------------------------------------------------------------------------*/



ivas_error ivas_allocate_binaural_hrtf_fx(

    HRTFS_FASTCONV *HrtfFastConv,                       /* i/o: FASTCONV HRTF structure     */

    const AUDIO_CONFIG input_config,                    /* i  : input audio configuration   */

    const BINAURAL_INPUT_AUDIO_CONFIG bin_input_config, /* i  : binaural input audio config */

    const RENDERER_TYPE renderer_type,                  /* i  : renderer type               */

    const Word16 allocate_init_flag                     /* i  : Memory allocation flag      */

)

{

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

    {

        IF( ( HrtfFastConv->leftHRIRReal_HOA3_fx != NULL ) && ( HrtfFastConv->leftHRIRImag_HOA3_fx != NULL ) && ( HrtfFastConv->rightHRIRReal_HOA3_fx != NULL ) && ( HrtfFastConv->rightHRIRImag_HOA3_fx != NULL ) )

        {

            return IVAS_ERR_OK;

        }

        ELSE

        {

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftHRIRReal_HOA3_fx, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_HOA3" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftHRIRImag_HOA3_fx, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_HOA3" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightHRIRReal_HOA3_fx, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_HOA3" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightHRIRImag_HOA3_fx, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_HOA3" );

            }

        }

    }



    IF( input_config == IVAS_AUDIO_CONFIG_HOA2 || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_HOA2 )

    {

        IF( ( HrtfFastConv->leftHRIRReal_HOA2 != NULL ) && ( HrtfFastConv->leftHRIRImag_HOA2_fx != NULL ) && ( HrtfFastConv->rightHRIRReal_HOA2_fx != NULL ) && ( HrtfFastConv->rightHRIRImag_HOA2_fx != NULL ) )

        {

            return IVAS_ERR_OK;

        }

        ELSE

        {

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftHRIRReal_HOA2_fx, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_HOA2" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftHRIRImag_HOA2_fx, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_HOA2" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightHRIRReal_HOA2_fx, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_HOA2" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightHRIRImag_HOA2_fx, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_HOA2" );

            }

        }

    }



    IF( input_config == IVAS_AUDIO_CONFIG_FOA || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_FOA )

    {

        IF( ( HrtfFastConv->leftHRIRReal_FOA_fx != NULL ) && ( HrtfFastConv->leftHRIRImag_FOA_fx != NULL ) && ( HrtfFastConv->rightHRIRReal_FOA_fx != NULL ) && ( HrtfFastConv->rightHRIRImag_FOA_fx != NULL ) )

        {

            return IVAS_ERR_OK;

        }

        ELSE

        {

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftHRIRReal_FOA_fx, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_FOA" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftHRIRImag_FOA_fx, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_FOA" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightHRIRReal_FOA_fx, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_FOA" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightHRIRImag_FOA_fx, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_FOA" );

            }

        }

    }



    IF( renderer_type == RENDERER_BINAURAL_FASTCONV || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )

    {

        IF( ( HrtfFastConv->leftHRIRReal_fx != NULL ) && ( HrtfFastConv->leftHRIRImag_fx != NULL ) && ( HrtfFastConv->rightHRIRReal_fx != NULL ) && ( HrtfFastConv->rightHRIRImag_fx != NULL ) )

        {

            return IVAS_ERR_OK;

        }

        ELSE

        {



            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftHRIRReal_fx, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftHRIRImag_fx, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightHRIRReal_fx, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightHRIRImag_fx, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag" );

            }

        }

    }



    IF( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )

    {

        IF( ( HrtfFastConv->leftBRIRReal_fx != NULL ) && ( HrtfFastConv->leftBRIRImag_fx != NULL ) && ( HrtfFastConv->rightBRIRReal_fx != NULL ) && ( HrtfFastConv->rightBRIRImag_fx != NULL ) )

        {

            return IVAS_ERR_OK;

        }

        ELSE

        {

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftBRIRReal_fx, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftBRIRReal" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->leftBRIRImag_fx, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftBRIRImag" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightBRIRReal_fx, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightBRIRReal" );

            }

            IF( IVAS_ERR_OK != ivas_alloc_pppMem_fx( &HrtfFastConv->rightBRIRImag_fx, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightBRIRImag" );

            }

        }

    }



    return IVAS_ERR_OK;

}



#endif

#endif

/*-------------------------------------------------------------------------*

 * ivas_allocate_binaural_hrtf()

 *
@@ -1818,6 +2049,35 @@ void ivas_binaural_hrtf_close( 
    ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRReal_FOA, FOA_CHANNELS, allocate_init_flag );

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



#ifdef FIX_CREND_CHANGES

#ifdef IVAS_FLOAT_FIXED

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

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftHRIRImag, HRTF_LS_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightHRIRReal_fx, HRTF_LS_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightHRIRImag, HRTF_LS_CHANNELS, allocate_init_flag );



    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftBRIRReal_fx, HRTF_LS_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftBRIRImag_fx, HRTF_LS_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightBRIRReal_fx, HRTF_LS_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightBRIRImag_fx, HRTF_LS_CHANNELS, allocate_init_flag );



    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftHRIRReal_HOA3_fx, HOA3_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftHRIRImag_HOA3_fx, HOA3_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightHRIRReal_HOA3_fx, HOA3_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightHRIRImag_HOA3_fx, HOA3_CHANNELS, allocate_init_flag );



    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftHRIRReal_HOA2_fx, HOA2_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftHRIRImag_HOA2_fx, HOA2_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightHRIRReal_HOA2_fx, HOA2_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightHRIRImag_HOA2_fx, HOA2_CHANNELS, allocate_init_flag );



    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftHRIRReal_FOA_fx, FOA_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->leftHRIRImag_FOA_fx, FOA_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightHRIRReal_FOA_fx, FOA_CHANNELS, allocate_init_flag );

    ivas_free_pppHrtfMem_fx( &( *hHrtfFastConv )->rightHRIRImag_FOA_fx, FOA_CHANNELS, allocate_init_flag );

#endif

#endif



    return;

}
@@ -1853,11 +2113,11 @@ void ivas_binaural_add_LFE( 
        if ( st_ivas->renderer_type == RENDERER_BINAURAL_OBJECTS_TD )

        {

            gain = GAIN_LFE;



        }

        else

        {

            gain = ( ( st_ivas->hCrendWrapper != NULL ) && ( st_ivas->hCrendWrapper->hHrtfCrend != NULL ) ) ? st_ivas->hCrendWrapper->hHrtfCrend->gain_lfe : GAIN_LFE;        }

            gain = ( ( st_ivas->hCrendWrapper != NULL ) && ( st_ivas->hCrendWrapper->hHrtfCrend != NULL ) ) ? st_ivas->hCrendWrapper->hHrtfCrend->gain_lfe : GAIN_LFE;

        }



        for ( idx_lfe = 0; idx_lfe < st_ivas->hIntSetup.num_lfe; idx_lfe++ )

        {

lib_util/hrtf_file_reader.c

+25 −10
Original line number Diff line number Diff line
@@ -554,17 +554,17 @@ static ivas_error load_reverb_from_binary( 


    if ( is_reverb )

    {

        hHrtfStatistics->average_energy_l = (float *) malloc( lr_iac_len * sizeof( float ) );

        hHrtfStatistics->average_energy_r = (float *) malloc( lr_iac_len * sizeof( float ) );

        hHrtfStatistics->inter_aural_coherence = (float *) malloc( lr_iac_len * sizeof( float ) );

#ifdef FIX_FIX_POINT_HRTF_FILE_FORMAT

        if ( is_fx )

        {

            hHrtfStatistics->average_energy_l_fx = (Word16 *) malloc( lr_iac_len * sizeof( Word16 ) );

            hHrtfStatistics->average_energy_r_fx = (Word16 *) malloc( lr_iac_len * sizeof( Word16 ) );

            hHrtfStatistics->inter_aural_coherence_fx = (Word16 *) malloc( lr_iac_len * sizeof( Word16 ) );



        if ( hHrtfStatistics->average_energy_l == NULL || hHrtfStatistics->average_energy_r == NULL || hHrtfStatistics->inter_aural_coherence == NULL )

            if ( hHrtfStatistics->average_energy_l_fx == NULL || hHrtfStatistics->average_energy_r_fx == NULL || hHrtfStatistics->inter_aural_coherence_fx == NULL )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );

            }

#ifdef FIX_FIX_POINT_HRTF_FILE_FORMAT

        if ( is_fx )

        {

            fread( &hHrtfStatistics->factor_Q_energy_fx, sizeof( Word16 ), 1, f_hrtf );

            for ( ind = 0; ind < lr_iac_len; ind++ )

            {
@@ -584,6 +584,14 @@ static ivas_error load_reverb_from_binary( 
        }

        else

        {

            hHrtfStatistics->average_energy_l = (float *) malloc( lr_iac_len * sizeof( float ) );

            hHrtfStatistics->average_energy_r = (float *) malloc( lr_iac_len * sizeof( float ) );

            hHrtfStatistics->inter_aural_coherence = (float *) malloc( lr_iac_len * sizeof( float ) );



            if ( hHrtfStatistics->average_energy_l == NULL || hHrtfStatistics->average_energy_r == NULL || hHrtfStatistics->inter_aural_coherence == NULL )

            {

                return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );

            }

            fread( hHrtfStatistics->average_energy_l, sizeof( const float ), lr_iac_len, f_hrtf );

            fread( hHrtfStatistics->average_energy_r, sizeof( const float ), lr_iac_len, f_hrtf );

            fread( hHrtfStatistics->inter_aural_coherence, sizeof( const float ), lr_iac_len, f_hrtf );
@@ -1440,14 +1448,14 @@ static ivas_error create_fastconv_HRTF_from_rawdata_fx( 


    if ( rend_type == HRTF_READER_RENDERER_BINAURAL_FASTCONV )

    {

        if ( ( error = ivas_allocate_binaural_hrtf( *hHRTF, 0, input_cfg, RENDERER_BINAURAL_FASTCONV, ( *hHRTF )->allocate_init_flag ) ) != IVAS_ERR_OK )

        if ( ( error = ivas_allocate_binaural_hrtf_fx( *hHRTF, 0, input_cfg, RENDERER_BINAURAL_FASTCONV, ( *hHRTF )->allocate_init_flag ) ) != IVAS_ERR_OK )

        {

            return error;

        }

    }

    else if ( rend_type == HRTF_READER_RENDERER_BINAURAL_FASTCONV_ROOM )

    {

        if ( ( error = ivas_allocate_binaural_hrtf( *hHRTF, 0, input_cfg, RENDERER_BINAURAL_FASTCONV_ROOM, ( *hHRTF )->allocate_init_flag ) ) != IVAS_ERR_OK )

        if ( ( error = ivas_allocate_binaural_hrtf_fx( *hHRTF, 0, input_cfg, RENDERER_BINAURAL_FASTCONV_ROOM, ( *hHRTF )->allocate_init_flag ) ) != IVAS_ERR_OK )

        {

            return error;

        }
@@ -2904,6 +2912,13 @@ ivas_error destroy_hrtf_statistics( 
        free( ( *hHrtfStatistics )->average_energy_l );

        free( ( *hHrtfStatistics )->average_energy_r );

        free( ( *hHrtfStatistics )->inter_aural_coherence );

#ifdef FIX_CREND_CHANGES

#ifdef IVAS_FLOAT_FIXED

        free( ( *hHrtfStatistics )->average_energy_l_fx );

        free( ( *hHrtfStatistics )->average_energy_r_fx );

        free( ( *hHrtfStatistics )->inter_aural_coherence_fx );

#endif

#endif

    }

    ivas_HRTF_statistics_close( hHrtfStatistics );

    return IVAS_ERR_OK;

pytest.ini

0 → 100644
+16 −0
Original line number Diff line number Diff line 
# pytest.ini

# note: per convention, this file is placed in the root directory of the repository

[pytest]

# TODO remove ignore after tests are harmonized

addopts = -ra --tb=short --basetemp=./tmp -n auto -v --ignore=tests/renderer --ignore=tests/split_rendering

# Write captured system-out log messages to JUnit report.

junit_logging = system-out

# Do not capture log information for passing tests to JUnit report.

junit_log_passing_tests = False

junit_duration_report = call

junit_family = xunit1

log_file_level = DEBUG

log_format = %(asctime)s %(levelname)s %(message)s

log_date_format = %Y-%m-%d %H:%M:%S

# for pytest-html report: do not log environment variables from the runners

environment_table_redact_list = .*