Commit 588e1da8 authored by emerit's avatar emerit
Browse files

on going merge with last float

parent a7eb4da7

apps/decoder.c

+269 −103
Original line number Diff line number Diff line
@@ -123,6 +123,25 @@ typedef struct 


} DecArguments;



#ifdef FIX_POINT_HRTF_FILE_FORMAT

typedef struct

{

    hrtfFileReader *hrtfReader;

    char *hrtfFileName;



    IVAS_DEC_HRTF_HANDLE *hHrtfTD;



    IVAS_DEC_HRTF_STATISTICS_HANDLE *hHrtfStatistics;



    IVAS_BIN_RENDERER_TYPE binaural_renderer;

    IVAS_BIN_RENDERER_TYPE binaural_renderer_old;

    IVAS_BIN_RENDERER_TYPE binaural_renderer_sec;

    IVAS_BIN_RENDERER_TYPE binaural_renderer_sec_old;



    IVAS_AUDIO_CONFIG hrtf_set_audio_cfg;



} IVAS_DEC_HRTF_BINARY_WRAPPER;

#endif



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

 * Local functions prototypes
@@ -130,9 +149,15 @@ typedef struct 


static bool parseCmdlIVAS_dec( int16_t argc, char **argv, DecArguments *arg );

static void usage_dec( void );



#ifdef FIX_POINT_HRTF_FILE_FORMAT

static ivas_error decodeG192( DecArguments arg, BS_READER_HANDLE hBsReader, IVAS_DEC_HRTF_BINARY_WRAPPER *hHrtf, RotFileReader *headRotReader, RotFileReader *externalOrientationFileReader, RotFileReader *refRotReader, Vector3PairFileReader *referenceVectorReader, IVAS_DEC_HANDLE hIvasDec, int16_t *pcmBuf );

static ivas_error decodeVoIP( DecArguments arg, BS_READER_HANDLE hBsReader, IVAS_DEC_HRTF_BINARY_WRAPPER *hHrtf, RotFileReader *headRotReader, RotFileReader *externalOrientationFileReader, RotFileReader *refRotReader, Vector3PairFileReader *referenceVectorReader, IVAS_DEC_HANDLE hIvasDec );

static ivas_error load_hrtf_from_file( IVAS_DEC_HRTF_BINARY_WRAPPER *hHrtfBinary, IVAS_DEC_HANDLE hIvasDec, const IVAS_AUDIO_CONFIG OutputConfig, const int32_t output_Fs );

#else

static ivas_error decodeG192( DecArguments arg, BS_READER_HANDLE hBsReader, RotFileReader *headRotReader, RotFileReader *externalOrientationFileReader, RotFileReader *refRotReader, Vector3PairFileReader *referenceVectorReader, IVAS_DEC_HANDLE hIvasDec, int16_t *pcmBuf );

static ivas_error decodeVoIP( DecArguments arg, BS_READER_HANDLE hBsReader, RotFileReader *headRotReader, RotFileReader *externalOrientationFileReader, RotFileReader *refRotReader, Vector3PairFileReader *referenceVectorReader, IVAS_DEC_HANDLE hIvasDec );



#endif



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

 * main()
@@ -161,11 +186,7 @@ int main( 
    int16_t *pcmBuf = NULL;

    IVAS_RENDER_FRAMESIZE asked_frame_size;

#ifdef FIX_POINT_HRTF_FILE_FORMAT

    IVAS_DEC_HRTF_HANDLE *hHrtfTD = NULL;

    IVAS_DEC_HRTF_CREND_HANDLE *hSetOfHRTF = NULL;

    IVAS_DEC_HRTF_FASTCONV_HANDLE *hHrtfFastConv = NULL;

    IVAS_DEC_HRTF_PARAMBIN_HANDLE *hHrtfParambin = NULL;

    IVAS_DEC_HRTF_STATISTICS_HANDLE *hHrtfStatistics = NULL;

    IVAS_DEC_HRTF_BINARY_WRAPPER hHrtfBinary;

#endif



#ifdef WMOPS
@@ -173,6 +194,10 @@ int main( 
    reset_mem( USE_BYTES );

#endif



#ifdef FIX_POINT_HRTF_FILE_FORMAT

    hHrtfBinary.hHrtfTD = NULL;         /* just to avoid compilation warning */

    hHrtfBinary.hHrtfStatistics = NULL; /* just to avoid compilation warning */

#endif

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

     * Parse command-line arguments

     *------------------------------------------------------------------------------------------*/
@@ -345,6 +370,21 @@ int main( 
        }

    }



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

     * Initialize HRTF binary file data

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



#ifdef FIX_POINT_HRTF_FILE_FORMAT

    if ( arg.hrtfReaderEnabled )

    {

        hHrtfBinary.hrtfReader = hrtfReader;

        hHrtfBinary.hrtfFileName = arg.hrtfFileName;

        hHrtfBinary.binaural_renderer = IVAS_BIN_RENDERER_TYPE_NONE;

        hHrtfBinary.binaural_renderer_sec = IVAS_BIN_RENDERER_TYPE_NONE;

        hHrtfBinary.hrtf_set_audio_cfg = IVAS_AUDIO_CONFIG_INVALID;

    }

#endif



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

     * Open renderer configuration reader file

     *------------------------------------------------------------------------------------------*/
@@ -499,67 +539,34 @@ int main( 
        }

    }



#ifndef FIX_POINT_HRTF_FILE_FORMAT

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

     * Load HRTF binary file data

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



    if ( arg.hrtfReaderEnabled )

    {

#ifndef FIX_POINT_HRTF_FILE_FORMAT

        IVAS_DEC_HRTF_HANDLE hHrtfTD = NULL;

#endif



        if ( ( error = IVAS_DEC_GetHrtfHandle( hIvasDec, &hHrtfTD ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nIVAS_DEC_GetHrtfHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

            goto cleanup;

        }

#ifdef FIX_POINT_HRTF_FILE_FORMAT

        if ( ( error = load_HRTF_binary( *hHrtfTD, hrtfReader ) ) != IVAS_ERR_OK )

        {

            if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

            {

                fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );

                goto cleanup;

            }

            else

            {

                destroy_td_hrtf( hHrtfTD );

            }

        }

#else



        if ( ( error = load_HRTF_binary( hHrtfTD, hrtfReader ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );

            goto cleanup;

        }



#endif



#ifndef FIX_POINT_HRTF_FILE_FORMAT

        IVAS_DEC_HRTF_CREND_HANDLE hSetOfHRTF = NULL;

#endif



        if ( ( error = IVAS_DEC_GetHrtfCRendHandle( hIvasDec, &hSetOfHRTF ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nIVAS_DEC_GetHrtfCRendHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

            goto cleanup;

        }



#ifdef FIX_POINT_HRTF_FILE_FORMAT

        if ( ( error = create_SetOfHRTF_from_binary( *hSetOfHRTF, hrtfReader, arg.output_Fs ) ) != IVAS_ERR_OK )

        {

            if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

            {

                fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );

                goto cleanup;

            }

            else

            {

                destroy_SetOfHRTF( hSetOfHRTF );

            }

        }

#else

        if ( ( error = create_SetOfHRTF_from_binary( hSetOfHRTF, hrtfReader, arg.output_Fs ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nError in loading HRTF binary file %s for CRend \n\n", arg.hrtfFileName );
@@ -567,28 +574,12 @@ int main( 
        }



        IVAS_DEC_HRTF_FASTCONV_HANDLE hHrtfFastConv = NULL;

#endif

        if ( ( error = IVAS_DEC_GetHrtfFastConvHandle( hIvasDec, &hHrtfFastConv ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nIVAS_DEC_GetHrtfFastConvHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

            goto cleanup;

        }



#ifdef FIX_POINT_HRTF_FILE_FORMAT

        if ( ( error = load_fastconv_HRTF_from_binary( *hHrtfFastConv, hrtfReader ) ) != IVAS_ERR_OK )

        {

            if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

            {

                fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );

                goto cleanup;

            }

            else

            {

                destroy_fastconv_hrtf( hHrtfFastConv );

            }

        }



#else

        if ( ( error = load_fastconv_HRTF_from_binary( hHrtfFastConv, hrtfReader ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nError in loading HRTF binary file %s for FastConv \n\n", arg.hrtfFileName );
@@ -596,56 +587,19 @@ int main( 
        }



        IVAS_DEC_HRTF_PARAMBIN_HANDLE hHrtfParambin = NULL;

#endif

        if ( ( error = IVAS_DEC_GetHrtfParamBinHandle( hIvasDec, &hHrtfParambin ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nIVAS_DEC_GetHrtfParamBinHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

            goto cleanup;

        }



#ifdef FIX_POINT_HRTF_FILE_FORMAT

        if ( ( error = load_parambin_HRTF_from_binary( *hHrtfParambin, hrtfReader ) ) != IVAS_ERR_OK )

        {

            if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

            {

                fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );

                goto cleanup;

            }

            else

            {

                destroy_parambin_hrtf( hHrtfParambin );

            }

        }



        if ( ( error = IVAS_DEC_GetHrtfStatisticsHandle( hIvasDec, &hHrtfStatistics ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nIVAS_DEC_GetHrtfHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

            goto cleanup;

        }

#else

        if ( ( error = load_parambin_HRTF_from_binary( hHrtfParambin, hrtfReader ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nError in loading HRTF binary file %s for parametric binauralizer \n\n", arg.hrtfFileName );

            goto cleanup;

        }

#endif



#ifdef FIX_POINT_HRTF_FILE_FORMAT

        if ( ( error = load_reverb_binary( *hHrtfStatistics, arg.output_Fs, hrtfReader ) ) != IVAS_ERR_OK )

        {

            if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

            {

                fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );

                goto cleanup;

            }

            else

            {

                destroy_hrtf_statistics( hHrtfStatistics );

            }

    }

#endif

    }



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

     * Allocate output data buffer

     *------------------------------------------------------------------------------------------*/
@@ -662,6 +616,16 @@ int main( 
    /*-----------------------------------------------------------------*

     * Decoding

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

#ifdef FIX_POINT_HRTF_FILE_FORMAT

    if ( arg.voipMode )

    {

        error = decodeVoIP( arg, hBsReader, &hHrtfBinary, headRotReader, externalOrientationFileReader, refRotReader, referenceVectorReader, hIvasDec );

    }

    else

    {

        error = decodeG192( arg, hBsReader, &hHrtfBinary, headRotReader, externalOrientationFileReader, refRotReader, referenceVectorReader, hIvasDec, pcmBuf );

    }

#else

    if ( arg.voipMode )

    {

        error = decodeVoIP( arg, hBsReader, headRotReader, externalOrientationFileReader, refRotReader, referenceVectorReader, hIvasDec );
@@ -670,6 +634,7 @@ int main( 
    {

        error = decodeG192( arg, hBsReader, headRotReader, externalOrientationFileReader, refRotReader, referenceVectorReader, hIvasDec, pcmBuf );

    }

#endif



    if ( error == IVAS_ERR_OK || error == IVAS_ERR_END_OF_FILE )

    {
@@ -702,14 +667,11 @@ cleanup: 
    if ( arg.hrtfReaderEnabled )

    {

#ifdef FIX_POINT_HRTF_FILE_FORMAT

        IVAS_DEC_GetHrtfHandle( hIvasDec, &hHrtfTD );

        destroy_td_hrtf( hHrtfTD );



        IVAS_DEC_GetHrtfCRendHandle( hIvasDec, &hSetOfHRTF );

        destroy_SetOfHRTF( hSetOfHRTF );



        IVAS_DEC_GetHrtfStatisticsHandle( hIvasDec, &hHrtfStatistics );

        destroy_hrtf_statistics( hHrtfStatistics );

        if ( arg.hrtfReaderEnabled )

        {

            destroy_td_hrtf( hHrtfBinary.hHrtfTD );

            destroy_hrtf_statistics( hHrtfBinary.hHrtfStatistics );

        }

#else

        IVAS_DEC_HRTF_HANDLE hHrtfTD = NULL;

        IVAS_DEC_GetHrtfHandle( hIvasDec, &hHrtfTD );
@@ -1589,6 +1551,9 @@ static ivas_error initOnFirstGoodFrame( 
static ivas_error decodeG192(

    DecArguments arg,

    BS_READER_HANDLE hBsReader,

#ifdef FIX_POINT_HRTF_FILE_FORMAT

    IVAS_DEC_HRTF_BINARY_WRAPPER *hHrtfBinary,

#endif

    RotFileReader *headRotReader,

    RotFileReader *externalOrientationFileReader,

    RotFileReader *refRotReader,
@@ -1786,6 +1751,30 @@ static ivas_error decodeG192( 
                    goto cleanup;

                }

            }



#ifdef FIX_POINT_HRTF_FILE_FORMAT

            /* Read main parameters from the bitstream to set-up the decoder */

            hHrtfBinary->binaural_renderer_old = hHrtfBinary->binaural_renderer;

            hHrtfBinary->binaural_renderer_sec_old = hHrtfBinary->binaural_renderer_sec;

            if ( ( error = IVAS_DEC_ReadFormat( hIvasDec, &hHrtfBinary->binaural_renderer, &hHrtfBinary->binaural_renderer_sec, &hHrtfBinary->hrtf_set_audio_cfg ) ) != IVAS_ERR_OK )

            {

                return error;

            }



            /* Placeholder for memory reallocation */

            /* ... */



            /* Load HRTF binary file data */

            if ( arg.hrtfReaderEnabled )

            {

                if ( ( error = load_hrtf_from_file( hHrtfBinary, hIvasDec, arg.outputConfig, arg.output_Fs ) ) != IVAS_ERR_OK )

                {

                    fprintf( stderr, "\nIVAS_DEC_LoadHrtfFromFile failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

                    goto cleanup;

                }

            }

#endif



            if ( ( error = IVAS_DEC_GetSamples( hIvasDec, nSamplesToRender, ( pcmBuf + nOutChannels * nSamplesRendered ), &nSamplesRendered_loop, &needNewFrame ) ) != IVAS_ERR_OK )



            {
@@ -2131,6 +2120,9 @@ static ivas_error writeJbmTraceFileFrameWrapper( const void *data, void *writer 
static ivas_error decodeVoIP(

    DecArguments arg,

    BS_READER_HANDLE hBsReader,

#ifdef FIX_POINT_HRTF_FILE_FORMAT

    IVAS_DEC_HRTF_BINARY_WRAPPER *hHrtf,

#endif

    RotFileReader *headRotReader,

    RotFileReader *externalOrientationFileReader,

    RotFileReader *refRotReader,
@@ -2648,4 +2640,178 @@ cleanup: 
}





#ifdef FIX_POINT_HRTF_FILE_FORMAT

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

 * load_hrtf_from_file()

 *

 * Load HRTF coefficients from external binary file

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



static ivas_error load_hrtf_from_file(

    IVAS_DEC_HRTF_BINARY_WRAPPER *hHrtfBinary, /* i/o: HRTF binary wrapper handle   */

    IVAS_DEC_HANDLE hIvasDec,                  /* i/o: IVAS decoder handle          */

    const IVAS_AUDIO_CONFIG OutputConfig,      /* i  : output audio configuration   */

    const int32_t output_Fs                    /* i  : output sampling rate         */

)

{

    ivas_error error;

    IVAS_BIN_RENDERER_TYPE binaural_renderer, binaural_renderer_sec;



    if ( hHrtfBinary == NULL || hIvasDec == NULL )

    {

        return IVAS_ERR_UNEXPECTED_NULL_POINTER;

    }



    binaural_renderer = hHrtfBinary->binaural_renderer;

    binaural_renderer_sec = hHrtfBinary->binaural_renderer_sec;



    if ( ( binaural_renderer != hHrtfBinary->binaural_renderer_old ) ||

         ( binaural_renderer_sec != hHrtfBinary->binaural_renderer_sec_old ) ||

         ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT ) )

    {

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

         * Release HRTF binary data

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



        if ( !( binaural_renderer == IVAS_BIN_RENDERER_TYPE_TDREND || binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT ) && binaural_renderer_sec != IVAS_BIN_RENDERER_TYPE_TDREND && hHrtfBinary->hHrtfTD != NULL )

        {

            destroy_td_hrtf( hHrtfBinary->hHrtfTD );

        }



        if ( ( error = IVAS_DEC_HRTF_binary_close( hIvasDec, hHrtfBinary->binaural_renderer_old ) ) != IVAS_ERR_OK )

        {

            return error;

        }



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

         * Load HRTF binary data

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



        if ( ( error = IVAS_DEC_HRTF_binary_open( hIvasDec, binaural_renderer ) ) != IVAS_ERR_OK )

        {

            return error;

        }



        if ( ( error = IVAS_DEC_HRTF_binary_open( hIvasDec, binaural_renderer_sec ) ) != IVAS_ERR_OK )

        {

            return error;

        }



        if ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_TDREND || binaural_renderer_sec == IVAS_BIN_RENDERER_TYPE_TDREND || binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT )

        {

            if ( ( error = IVAS_DEC_GetHrtfTDrendHandle( hIvasDec, &hHrtfBinary->hHrtfTD ) ) != IVAS_ERR_OK )

            {

                fprintf( stderr, "\nIVAS_DEC_GetHrtfTDrendHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

                return error;

            }



            if ( ( error = load_TDrend_HRTF_binary( *hHrtfBinary->hHrtfTD, output_Fs, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )

            {

                if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

                {

                    fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", hHrtfBinary->hrtfFileName );

                    return error;

                }

                else

                {

                    destroy_td_hrtf( hHrtfBinary->hHrtfTD );

                }

            }

        }



        if ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_CREND || binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT )

        {

            IVAS_DEC_HRTF_CREND_HANDLE *hHrtfCrend = NULL;

            if ( ( error = IVAS_DEC_GetHrtfCRendHandle( hIvasDec, &hHrtfCrend ) ) != IVAS_ERR_OK )

            {

                fprintf( stderr, "\nIVAS_DEC_GetHrtfCRendHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

                return error;

            }



            if ( ( error = load_Crend_HRTF_from_binary( *hHrtfCrend, hHrtfBinary->hrtfReader, OutputConfig, hHrtfBinary->hrtf_set_audio_cfg, output_Fs ) ) != IVAS_ERR_OK )

            {

                if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

                {

                    fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", hHrtfBinary->hrtfFileName );

                    return error;

                }

                else

                {

                    destroy_crend_hrtf( hHrtfCrend );

                }

            }

        }



        if ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_FASTCONV || binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT )

        {

            IVAS_DEC_HRTF_FASTCONV_HANDLE *hHrtfFastConv = NULL;

            if ( ( error = IVAS_DEC_GetHrtfFastConvHandle( hIvasDec, &hHrtfFastConv ) ) != IVAS_ERR_OK )

            {

                fprintf( stderr, "\nIVAS_DEC_GetHrtfFastConvHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

                return error;

            }



            if ( ( error = load_fastconv_HRTF_from_binary( *hHrtfFastConv, OutputConfig, hHrtfBinary->hrtf_set_audio_cfg, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )

            {

                if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

                {

                    fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", hHrtfBinary->hrtfFileName );

                    return error;

                }

                else

                {

                    destroy_fastconv_hrtf( hHrtfFastConv );

                }

            }

        }



        if ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_PARAMBIN || binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT )

        {

            IVAS_DEC_HRTF_PARAMBIN_HANDLE *hHrtfParambin = NULL;

            if ( ( error = IVAS_DEC_GetHrtfParamBinHandle( hIvasDec, &hHrtfParambin ) ) != IVAS_ERR_OK )

            {

                fprintf( stderr, "\nIVAS_DEC_GetHrtfParamBinHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

                return error;

            }



            if ( ( error = load_parambin_HRTF_from_binary( *hHrtfParambin, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )

            {

                if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

                {

                    fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", hHrtfBinary->hrtfFileName );

                    return error;

                }

                else

                {

                    destroy_parambin_hrtf( hHrtfParambin );

                }

            }

        }

    }



    if ( hHrtfBinary->hHrtfStatistics == NULL && ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_FASTCONV || binaural_renderer == IVAS_BIN_RENDERER_TYPE_CREND ) && OutputConfig == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )

    {

        if ( ( error = IVAS_DEC_GetHrtfStatisticsHandle( hIvasDec, &hHrtfBinary->hHrtfStatistics ) ) != IVAS_ERR_OK )

        {

            fprintf( stderr, "\nIVAS_DEC_GetHrtfStatisticsHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );

            return error;

        }



        if ( ( error = load_reverb_binary( *hHrtfBinary->hHrtfStatistics, output_Fs, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )

        {

            if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

            {

                fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", hHrtfBinary->hrtfFileName );

                return error;

            }

            else

            {

                destroy_hrtf_statistics( hHrtfBinary->hHrtfStatistics );

            }

        }

    }



    return IVAS_ERR_OK;

}

#endif

#undef WMC_TOOL_SKIP

apps/renderer.c

+12 −7
Original line number Diff line number Diff line
@@ -610,7 +610,7 @@ int main( 
    Vector3PairFileReader *referenceVectorReader = NULL;

    hrtfFileReader *hrtfFileReader = NULL;

#ifdef FIX_POINT_HRTF_FILE_FORMAT

    IVAS_DEC_HRTF_CREND_HANDLE *hSetOfHRTF = NULL;

    IVAS_DEC_HRTF_CREND_HANDLE *hHrtfCrend = NULL;

    IVAS_DEC_HRTF_FASTCONV_HANDLE *hHrtfFastConv = NULL;

    IVAS_DEC_HRTF_PARAMBIN_HANDLE *hHrtfParambin = NULL;

    IVAS_DEC_HRTF_HANDLE *hHrtfTD = NULL;
@@ -846,7 +846,7 @@ int main( 
                goto cleanup;

            }



            if ( ( error = load_HRTF_binary( *hHrtfTD, hrtfFileReader ) ) != IVAS_ERR_OK )

            if ( ( error = load_TDrend_HRTF_binary( *hHrtfTD, args.sampleRate, hrtfFileReader ) ) != IVAS_ERR_OK )

            {

                if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

                {
@@ -860,13 +860,19 @@ int main( 
            }





            if ( ( error = IVAS_REND_GetHrtfCRendHandle( hIvasRend, &hSetOfHRTF ) ) != IVAS_ERR_OK )

            if ( ( error = IVAS_REND_GetHrtfCRendHandle( hIvasRend, &hHrtfCrend ) ) != IVAS_ERR_OK )

            {

                fprintf( stderr, "\nIVAS_Rend_GetHrtfCRendHandle failed: %s\n\n", ivas_error_to_string( error ) );

                goto cleanup;

            }



            if ( ( error = create_SetOfHRTF_from_binary( *hSetOfHRTF, hrtfFileReader, args.sampleRate ) ) != IVAS_ERR_OK )

            IVAS_AUDIO_CONFIG hrtf_set_audio_cfg = IVAS_AUDIO_CONFIG_7_1_4;

            if ( args.inConfig.ambisonicsBuses->audioConfig != IVAS_AUDIO_CONFIG_INVALID && args.outConfig.audioConfig != IVAS_AUDIO_CONFIG_BINAURAL_ROOM_IR )

            {

                hrtf_set_audio_cfg = args.inConfig.ambisonicsBuses->audioConfig;

            }



            if ( ( error = load_Crend_HRTF_from_binary( *hHrtfCrend, hrtfFileReader, args.outConfig.audioConfig, hrtf_set_audio_cfg, args.sampleRate ) ) != IVAS_ERR_OK )

            {

                if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

                {
@@ -875,7 +881,7 @@ int main( 
                }

                else

                {

                    destroy_SetOfHRTF( hSetOfHRTF );

                    destroy_crend_hrtf( hHrtfCrend );

                }

            }
@@ -885,7 +891,7 @@ int main( 
                goto cleanup;

            }



            if ( ( error = load_fastconv_HRTF_from_binary( *hHrtfFastConv, hrtfFileReader ) ) != IVAS_ERR_OK )

            if ( ( error = load_fastconv_HRTF_from_binary( *hHrtfFastConv, args.outConfig.audioConfig, args.inConfig.ambisonicsBuses->audioConfig, hrtfFileReader ) ) != IVAS_ERR_OK )

            {

                if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )

                {
@@ -1741,7 +1747,6 @@ cleanup: 
    Vector3PairFileReader_close( &referenceVectorReader );

#ifdef FIX_POINT_HRTF_FILE_FORMAT

    destroy_td_hrtf( hHrtfTD );

    destroy_SetOfHRTF( hSetOfHRTF );

    destroy_hrtf_statistics( hHrtfStatistics );

#else

    hrtfFileReader_close( &hrtfFileReader );

lib_com/common_api_types.h

+89 −0

File changed.

Preview size limit exceeded, changes collapsed.

lib_com/ivas_cnst.h

+2 −2
Original line number Diff line number Diff line
@@ -1637,6 +1637,7 @@ typedef enum 


#define BINAURAL_COHERENCE_DIFFERENCE_BINS      9                           /* Number of bins for direction-dependent diffuse-field binaural coherence */



#ifndef FIX_1226_FASTCONV_HRTF_LOADING_OPTIM

typedef enum 

{

    BINAURAL_INPUT_AUDIO_CONFIG_INVALID,
@@ -1648,13 +1649,12 @@ typedef enum 


} BINAURAL_INPUT_AUDIO_CONFIG;



#endif

#define HEADROT_ORDER                           3

#define HEADROT_SHMAT_DIM                       ( ( HEADROT_ORDER + 1 ) * ( HEADROT_ORDER + 1 ) )

#define HEADROT_SHMAT_DIM2                      ( HEADROT_SHMAT_DIM * HEADROT_SHMAT_DIM )









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

 * TD Binaural Object renderer

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

lib_com/ivas_error.h

+3 −0
Original line number Diff line number Diff line
@@ -78,6 +78,9 @@ typedef enum 
    IVAS_ERR_DIRECTIVITY_NOT_SUPPORTED,

    IVAS_ERR_ACOUSTIC_ENVIRONMENT_NOT_SUPPORTED,

    IVAS_ERR_INVALID_HRTF,

#ifdef FIX_1228_SAMPLING_RATE_MISMATCH_IN_HRTF_FILE

    IVAS_ERR_INVALID_HRTF_SAMPLING_RATE,

#endif

#ifdef FIX_POINT_HRTF_FILE_FORMAT

    IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA,

#endif