[WIP] loading from ROM should be complete and BE, loading from file needs further work (3d9c9caf) · Commits · IVAS Codec Public Collaboration / IVAS Codec

lib_com/options.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -162,7 +162,7 @@
		#define HRTF_BINARY_FILE /* HRTF filters' binary file used for binaural rendering. */
		#ifdef HRTF_BINARY_FILE
		#define HRTF_BINARY_FASTCONV /* Enable loading HRTF tables from file for FastConv renderer */
		//#define HRTF_BINARY_PARAM /* Enable loading HRTF tables from file for Parametric renderer */
		#define HRTF_BINARY_PARAM /* Enable loading HRTF tables from file for Parametric renderer */
		#endif

		/* ################## End DEVELOPMENT switches ######################### */

lib_dec/ivas_stat_dec.h

+9 −8

Original line number	Diff line number	Diff line
		@@ -1269,10 +1269,10 @@ typedef struct ivas_binaural_rendering_conv_module_struct
		typedef struct ivas_hrtfs_fastconv_struct
		{
		float FASTCONV_HRIR_latency_s;
		float leftHRIRReal[BINAURAL_CONVBANDS][15][7];
		float leftHRIRImag[BINAURAL_CONVBANDS][15][7];
		float rightHRIRReal[BINAURAL_CONVBANDS][15][7];
		float rightHRIRImag[BINAURAL_CONVBANDS][15][7];
		float leftHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7];
		float leftHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7];
		float rightHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7];
		float rightHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7];

		float FASTCONV_HOA3_latency_s;
		float leftHRIRReal_HOA3[BINAURAL_CONVBANDS][HRTF_SH_CHANNELS][7];
		@@ -1281,14 +1281,15 @@ typedef struct ivas_hrtfs_fastconv_struct
		float rightHRIRImag_HOA3[BINAURAL_CONVBANDS][HRTF_SH_CHANNELS][7];

		float FASTCONV_BRIR_latency_s;
		float leftBRIRReal[BINAURAL_CONVBANDS][15][7];
		float leftBRIRImag[BINAURAL_CONVBANDS][15][7];
		float rightBRIRReal[BINAURAL_CONVBANDS][15][7];
		float rightBRIRImag[BINAURAL_CONVBANDS][15][7];
		float leftBRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX];
		float leftBRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX];
		float rightBRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX];
		float rightBRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX];

		float fastconvReverberationTimes[CLDFB_NO_CHANNELS_MAX];
		float fastconvReverberationEneCorrections[CLDFB_NO_CHANNELS_MAX];
		} HRTFS_FASTCONV, *HRTFS_FASTCONV_HANDLE;

		#endif
		typedef struct ivas_binaural_rendering_struct
		{

lib_rend/ivas_binauralRenderer.c

+38 −19

Original line number	Diff line number	Diff line
		@@ -384,45 +384,65 @@ static ivas_error ivas_binRenderer_convModuleOpen(

		static ivas_error ivas_binaural_hrtf_open(
		BINAURAL_RENDERER_HANDLE hBinRenderer, /* i/o: fastconv binaural renderer handle */
		HRTFS_FASTCONV_HANDLE hHrtfFastConv /* i : fastconv HRTF handle */
		HRTFS_FASTCONV_HANDLE hHrtfFastConv / i : fastconv HRTF handle */
		)
		{
		int16_t i, j;
		if ( hHrtfFastConv != NULL )
		if ( hHrtfFastConv != NULL && *hHrtfFastConv != NULL )
		{
		/* Use tables loaded from file */
		hBinRenderer->hHrtfFastConv = hHrtfFastConv;
		hBinRenderer->hHrtfFastConv = *hHrtfFastConv;
		}
		else
		{
		if ( ( hBinRenderer->hHrtfFastConv = (HRTFS_FASTCONV_HANDLE) count_malloc( sizeof( HRTFS_FASTCONV ) ) ) == NULL )
		/* Use tables from ROM */
		HRTFS_FASTCONV *HrtfFastConv;

		if ( ( HrtfFastConv = (HRTFS_FASTCONV *) count_malloc( sizeof( HRTFS_FASTCONV ) ) ) == NULL )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for FastConv HRTF tables" );
		}


		/* Use tables from ROM */
		hHrtfFastConv->FASTCONV_HRIR_latency_s = FASTCONV_HRIR_latency_s;
		HrtfFastConv->FASTCONV_HRIR_latency_s = FASTCONV_HRIR_latency_s;
		HrtfFastConv->FASTCONV_HOA3_latency_s = FASTCONV_HOA3_latency_s;
		HrtfFastConv->FASTCONV_BRIR_latency_s = FASTCONV_BRIR_latency_s;

		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < 15; j++ )
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		mvr2r( leftHRIRReal[i][j], hHrtfFastConv->leftHRIRReal[i][j], 7 );
		mvr2r( leftHRIRImag[i][j], hHrtfFastConv->leftHRIRImag[i][j], 7 );
		mvr2r( rightHRIRReal[i][j], hHrtfFastConv->rightHRIRReal[i][j], 7 );
		mvr2r( rightHRIRImag[i][j], hHrtfFastConv->rightHRIRImag[i][j], 7 );
		mvr2r( leftHRIRReal[i][j], HrtfFastConv->leftHRIRReal[i][j], 7 );
		mvr2r( leftHRIRImag[i][j], HrtfFastConv->leftHRIRImag[i][j], 7 );
		mvr2r( rightHRIRReal[i][j], HrtfFastConv->rightHRIRReal[i][j], 7 );
		mvr2r( rightHRIRImag[i][j], HrtfFastConv->rightHRIRImag[i][j], 7 );

		mvr2r( leftBRIRReal[i][j], HrtfFastConv->leftBRIRReal[i][j], BINAURAL_NTAPS_MAX );
		mvr2r( leftBRIRImag[i][j], HrtfFastConv->leftBRIRImag[i][j], BINAURAL_NTAPS_MAX );
		mvr2r( rightBRIRReal[i][j], HrtfFastConv->rightBRIRReal[i][j], BINAURAL_NTAPS_MAX );
		mvr2r( rightBRIRImag[i][j], HrtfFastConv->rightBRIRImag[i][j], BINAURAL_NTAPS_MAX );
		}

		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		mvr2r( leftHRIRReal_HOA3[i][j], HrtfFastConv->leftHRIRReal_HOA3[i][j], 7 );
		mvr2r( leftHRIRImag_HOA3[i][j], HrtfFastConv->leftHRIRImag_HOA3[i][j], 7 );
		mvr2r( rightHRIRReal_HOA3[i][j], HrtfFastConv->rightHRIRReal_HOA3[i][j], 7 );
		mvr2r( rightHRIRImag_HOA3[i][j], HrtfFastConv->rightHRIRImag_HOA3[i][j], 7 );
		}
		}

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

		// TODO tmu finalize other tables
		*hHrtfFastConv = HrtfFastConv;
		hBinRenderer->hHrtfFastConv = HrtfFastConv;
		}

		return IVAS_ERR_OK;
		}

		static void ivas_binaural_hrtf_close(
		HRTFS_FASTCONV_HANDLE hHrtfFastConv /* i/o: fastconv HRTF handle */
		HRTFS_FASTCONV_HANDLE hHrtfFastConv / i/o: fastconv HRTF handle */
		)
		{
		if ( hHrtfFastConv == NULL )
		@@ -430,8 +450,7 @@ static void ivas_binaural_hrtf_close(
		return;
		}

		count_free( hHrtfFastConv );
		hHrtfFastConv = NULL;
		count_free( ( *hHrtfFastConv ) );

		return;
		}
		@@ -625,7 +644,7 @@ ivas_error ivas_binRenderer_open(

		#ifdef HRTF_BINARY_FASTCONV
		/* Load HRTF tables */
		ivas_binaural_hrtf_open( hBinRenderer, st_ivas->hHrtfFastConv );
		ivas_binaural_hrtf_open( hBinRenderer, &st_ivas->hHrtfFastConv );
		#endif

		if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM && ( st_ivas->hIntSetup.is_loudspeaker_setup == 0 ) )
		@@ -823,7 +842,7 @@ void ivas_binRenderer_close(
		// TODO tmu check
		if ( ( *hBinRenderer )->hHrtfFastConv != NULL )
		{
		ivas_binaural_hrtf_close( ( *hBinRenderer )->hHrtfFastConv );
		ivas_binaural_hrtf_close( &( *hBinRenderer )->hHrtfFastConv );
		}
		#endif

lib_util/hrtf_file_reader.c

+26 −23

Original line number	Diff line number	Diff line
		@@ -170,7 +170,13 @@ static ivas_error read_and_check_hrtf_binary_file_header( ivas_hrtfs_file_header
		static ivas_error check_hrtf_binary_header( ivas_hrtfs_header_t *hrtf_header )
		{
		// Check the renderer type
		#ifdef HRTF_BINARY_FASTCONV
		if ( ( hrtf_header->rend_type != RENDERER_BINAURAL_MIXER_CONV ) && ( hrtf_header->rend_type != RENDERER_BINAURAL_MIXER_CONV_ROOM ) &&
		( hrtf_header->rend_type != RENDERER_BINAURAL_FASTCONV ) && ( hrtf_header->rend_type != RENDERER_BINAURAL_FASTCONV_ROOM ) &&
		( hrtf_header->rend_type != RENDERER_BINAURAL_OBJECTS_TD ) )
		#else
		if ( ( hrtf_header->rend_type != RENDERER_BINAURAL_MIXER_CONV ) && ( hrtf_header->rend_type != RENDERER_BINAURAL_MIXER_CONV_ROOM ) && ( hrtf_header->rend_type != RENDERER_BINAURAL_OBJECTS_TD ) )
		#endif
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Header of HRTF binary file not compliant (renderer type)" );
		}
		@@ -882,7 +888,7 @@ static ivas_error create_fastconv_HRTF_from_rawdata(
		int i, j;
		char *hrtf_data_rptr;

		if ( *hHRTF == NULL )
		if ( hHRTF == NULL )
		{
		if ( ( ( *hHRTF ) = (HRTFS_FASTCONV_HANDLE) count_malloc( sizeof( HRTFS_FASTCONV ) ) ) == NULL )
		{
		@@ -1082,6 +1088,7 @@ ivas_error load_fastconv_HRTF_from_binary(
		ivas_hrtfs_file_header_t hrtfs_file_header;
		int16_t hrtf_id;

		hHRTF = NULL;
		f_hrtf = hrtfReader->file;

		if ( ( header_check_result = read_and_check_hrtf_binary_file_header( &hrtfs_file_header, f_hrtf ) ) != IVAS_ERR_OK )
		@@ -1115,13 +1122,11 @@ ivas_error load_fastconv_HRTF_from_binary(
		count_free( hrtf_data );
		return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "HRTF binary file not compliant (number of HRTF)" );
		}
		}

		hHRTF = NULL;
		// TODO tmu needs review, probably all covered under one renderer type
		if ( ( hrtf_header.frequency == 48000 ) &&
		( ( hrtf_header.rend_type == RENDERER_BINAURAL_FASTCONV ) \|\| ( hrtf_header.rend_type == RENDERER_BINAURAL_FASTCONV_ROOM ) ) )
		{

		if ( fread( hrtf_data, 1, hrtf_header.data_size, f_hrtf ) != hrtf_header.data_size )
		{
		count_free( hrtf_data );
		@@ -1133,18 +1138,16 @@ ivas_error load_fastconv_HRTF_from_binary(
		// Create the HRTF reading the raw data from the binary file
		if ( ( create_fastconv_HRTF_from_rawdata( hHRTF, hrtf_data ) ) != IVAS_ERR_OK )
		{
		count_free( hrtf_data );
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Could not create HRTF from binary file" );
		}
		}
		}
		else
		{
		count_free( hrtf_data );
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Error in HRTF file reading" );
		}

		count_free( hrtf_data );

		hHrtfFastConv = *hHRTF;

		return IVAS_ERR_OK;
		}
		#endif

scripts/binauralRenderer_interface/Table_Format_Converter/generate_tables_from_rom_to_bin.c

+16 −11

Original line number	Diff line number	Diff line
		@@ -57,15 +57,16 @@
		#define DEFAULT_BIN_FILE_EXT ".bin"
		#define DECLARATION_NAME "CRendBin"

		#define IVAS_NB_RENDERER_TYPE 7
		#define IVAS_NB_RENDERER_TYPE 5
		#define IVAS_NB_AUDIO_CONFIG 2
		#define IVAS_NB_SAMPLERATE 3

		const RENDERER_TYPE rend_types[IVAS_NB_RENDERER_TYPE] = {
		RENDERER_BINAURAL_FASTCONV,
		RENDERER_BINAURAL_FASTCONV_ROOM,
		RENDERER_BINAURAL_PARAMETRIC,
		RENDERER_BINAURAL_PARAMETRIC_ROOM,
		// TODO @Nokia
		// RENDERER_BINAURAL_PARAMETRIC,
		// RENDERER_BINAURAL_PARAMETRIC_ROOM,
		RENDERER_BINAURAL_MIXER_CONV,
		RENDERER_BINAURAL_MIXER_CONV_ROOM,
		RENDERER_BINAURAL_OBJECTS_TD
		@@ -740,7 +741,7 @@ char *create_hrtf_fastconv(
		uint16_t binaural_convbands;
		uint16_t hrtf_channels;
		uint16_t num_taps;
		uint16_t cldfb_no_col_max;
		uint16_t cldfb_nchan_max;
		float latency_s;

		hrtf_data_size = 0;
		@@ -791,9 +792,9 @@ char *create_hrtf_fastconv(
		hrtf_data_size += 4 * ( BINAURAL_CONVBANDS * HRTF_SH_CHANNELS * 7 * sizeof( float ) ); // HRIR_HOA3
		hrtf_data_size += 4 * ( BINAURAL_CONVBANDS * HRTF_LS_CHANNELS * BINAURAL_NTAPS_MAX * sizeof( float ) ); // BRIR

		hrtf_data_size += sizeof( uint16_t ); // CLDFB_NO_COL_MAX
		hrtf_data_size += CLDFB_NO_COL_MAX * sizeof( float ); // fastconvReverberationTimes
		hrtf_data_size += CLDFB_NO_COL_MAX * sizeof( float ); // fastconvEneCorrections
		hrtf_data_size += sizeof( uint16_t ); // CLDFB_NO_CHANNELS_MAX
		hrtf_data_size += CLDFB_NO_CHANNELS_MAX * sizeof( float ); // fastconvReverberationTimes
		hrtf_data_size += CLDFB_NO_CHANNELS_MAX * sizeof( float ); // fastconvEneCorrections

		// Allocate memory
		*hrtf_size = sizeof( ivas_hrtfs_header_t ) + hrtf_data_size;
		@@ -982,11 +983,11 @@ char *create_hrtf_fastconv(
		}

		// Reverb Parameters
		cldfb_no_col_max = CLDFB_NO_COL_MAX;
		memcpy( hrtf_wptr, &( cldfb_no_col_max ), sizeof( uint16_t ) ); // cldfb_ncol => int16_t
		cldfb_nchan_max = CLDFB_NO_CHANNELS_MAX;
		memcpy( hrtf_wptr, &( cldfb_nchan_max ), sizeof( uint16_t ) ); // cldfb_ncol => int16_t
		hrtf_wptr += sizeof( uint16_t );

		data_size_tmp = cldfb_no_col_max * sizeof( float );
		data_size_tmp = cldfb_nchan_max * sizeof( float );
		memcpy( hrtf_wptr, &( fastconvReverberationTimes ), data_size_tmp ); // fastconvReverberationTimes
		memcpy( hrtf_wptr, &( fastconvReverberationEneCorrections ), data_size_tmp ); // fastconvEneCorrections

		@@ -1517,8 +1518,12 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		hrtf_tables_dimensions tabs_dims;
		hrtf_tables_pointers tabs_ptrs;

		if ( rend_type == RENDERER_BINAURAL_OBJECTS_TD )
		if ( rend_type == RENDERER_BINAURAL_OBJECTS_TD \|\|
		rend_type == RENDERER_BINAURAL_FASTCONV \|\| rend_type == RENDERER_BINAURAL_FASTCONV_ROOM )
		{
		return 0;
		}
		// TODO tmu is a check necessary?

		memset( &tabs_dims, 0x00, sizeof( hrtf_tables_dimensions ) );
		memset( &tabs_ptrs, 0x00, sizeof( hrtf_tables_pointers ) );