first version of writing FASTCONV data to file (92c3c136) · Commits · IVAS Codec Public Collaboration / IVAS Codec

scripts/binauralRenderer_interface/.gitignore

0 → 100644

+6 −0

Original line number	Diff line number	Diff line
		*.cmake
		CMake*
		Externals/
		Table_Format_Converter/CMake*
		Table_Format_Converter/build*

scripts/binauralRenderer_interface/Table_Format_Converter/CMakeLists.txt

+13 −10

Original line number	Diff line number	Diff line
		@@ -12,20 +12,23 @@ if(WIN32)
		string(REGEX REPLACE "/W3" "/W4" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
		endif()

		set(IVAS_TRUNK_PATH "${PROJECT_SOURCE_DIR}/../../..")
		set(IVAS_TRUNK_UTIL_PATH ${IVAS_TRUNK_PATH}/lib_util)
		set(IVAS_TRUNK_DEC_PATH ${IVAS_TRUNK_PATH}/lib_dec)
		set(IVAS_TRUNK_ENC_PATH ${IVAS_TRUNK_PATH}/lib_enc)
		set(IVAS_TRUNK_COM_PATH ${IVAS_TRUNK_PATH}/lib_com)
		set(IVAS_TRUNK_DEBUG_PATH ${IVAS_TRUNK_PATH}/lib_debug)
		set(IVAS_PATH "${PROJECT_SOURCE_DIR}/../../..")
		set(IVAS_UTIL_PATH ${IVAS_PATH}/lib_util)
		set(IVAS_DEC_PATH ${IVAS_PATH}/lib_dec)
		set(IVAS_ENC_PATH ${IVAS_PATH}/lib_enc)
		set(IVAS_COM_PATH ${IVAS_PATH}/lib_com)
		set(IVAS_REND_PATH ${IVAS_PATH}/lib_rend)
		set(IVAS_DEBUG_PATH ${IVAS_PATH}/lib_debug)

		include_directories(${IVAS_TRUNK_UTIL_PATH} ${IVAS_TRUNK_ENC_PATH} ${IVAS_TRUNK_DEC_PATH} ${IVAS_TRUNK_COM_PATH} ${IVAS_TRUNK_DEBUG_PATH})
		include_directories(${IVAS_UTIL_PATH} ${IVAS_ENC_PATH} ${IVAS_DEC_PATH} ${IVAS_COM_PATH} ${IVAS_REND_PATH} ${IVAS_DEBUG_PATH})

		set(SOURCE_FILES_C
		${IVAS_TRUNK_DEC_PATH}/ivas_rom_binaural_crend_head.c)
		${IVAS_REND_PATH}/ivas_rom_binauralRenderer.c
		${IVAS_REND_PATH}/ivas_rom_binaural_crend_head.c)

		set(SOURCE_FILES_H
		${IVAS_TRUNK_DEC_PATH}/ivas_rom_binaural_crend_head.h)
		${IVAS_REND_PATH}/ivas_rom_binauralRenderer.h
		${IVAS_REND_PATH}/ivas_rom_binaural_crend_head.h)

		add_library(${PROJECT_NAME}_lib STATIC ${SOURCE_FILES_C} ${SOURCE_FILES_H})

scripts/binauralRenderer_interface/Table_Format_Converter/generate_tables_from_rom_to_bin.c

+230 −5

Original line number	Diff line number	Diff line
		@@ -34,8 +34,9 @@
		#include <stdlib.h>
		#include <string.h>

		#include "ivas_rom_binauralRenderer.h"
		#include "ivas_rom_binaural_crend_head.h"
		#include "lib_dec.h"
		#include "lib_rend.h"
		#include "ivas_stat_dec.h"

		#define FILE_HEADER
		@@ -56,12 +57,23 @@
		#define DEFAULT_BIN_FILE_EXT ".bin"
		#define DECLARATION_NAME "CRendBin"

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

		const RENDERER_TYPE rend_types[IVAS_NB_RENDERER_TYPE] = { RENDERER_BINAURAL_MIXER_CONV, RENDERER_BINAURAL_MIXER_CONV_ROOM, RENDERER_BINAURAL_OBJECTS_TD };
		const BINAURAL_INPUT_AUDIO_CONFIG input_cfgs[IVAS_NB_AUDIO_CONFIG] = { BINAURAL_INPUT_AUDIO_CONFIG_COMBINED, BINAURAL_INPUT_AUDIO_CONFIG_HOA };
		const RENDERER_TYPE rend_types[IVAS_NB_RENDERER_TYPE] = {
		RENDERER_BINAURAL_FASTCONV,
		RENDERER_BINAURAL_FASTCONV_ROOM,
		RENDERER_BINAURAL_PARAMETRIC,
		RENDERER_BINAURAL_PARAMETRIC_ROOM,
		RENDERER_BINAURAL_MIXER_CONV,
		RENDERER_BINAURAL_MIXER_CONV_ROOM,
		RENDERER_BINAURAL_OBJECTS_TD
		};
		const BINAURAL_INPUT_AUDIO_CONFIG input_cfgs[IVAS_NB_AUDIO_CONFIG] = {
		BINAURAL_INPUT_AUDIO_CONFIG_COMBINED,
		BINAURAL_INPUT_AUDIO_CONFIG_HOA
		};
		const int32_t sample_rates[IVAS_NB_SAMPLERATE] = { 48000, 32000, 16000 }; /* Hz / / 8000 Hz not supported by mdft */

		#ifdef FILE_HEADER
		@@ -109,6 +121,12 @@ void rom2bin_terminat( void );
		char to_upper( char str );

		char create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG input_cfg, int32_t frequency, int32_t hrtf_size /OUT/ );
		char *create_hrtf_fastconv(
		RENDERER_TYPE rend_type,
		BINAURAL_INPUT_AUDIO_CONFIG input_cfg,
		int32_t frequency,
		int32_t *hrtf_size );
		char *create_hrtf_parametric( void ); // TODO @Nokia
		char create_hrtf_tdrend( int32_t frequency, int32_t hrtf_size /OUT/ );
		int32_t read_hrtf_size( char *hrtf );
		int16_t check_bin_file( FILE *hrtf_bin_file );
		@@ -207,6 +225,38 @@ int main( int argc, char *argv[] )
		hrtf_size = 0;
		switch ( rend_types[i] )
		{
		case RENDERER_BINAURAL_FASTCONV:
		case RENDERER_BINAURAL_FASTCONV_ROOM:
		for ( j = 0; j < IVAS_NB_AUDIO_CONFIG; j++ )
		{
		/* Only one freq. for fastconv */
		setOfHRTF[nbHRTF] = create_hrtf_fastconv( rend_types[i], input_cfgs[j], freq_ptr[0], &hrtf_size );
		if ( hrtf_size == -1 )
		{
		fprintf( stderr, "Creation of HRTF (%d, %d, %d) failed!\n\n", rend_types[i], input_cfgs[j], freq_ptr[0] );
		for ( l = 0; l < nbHRTF; l++ )
		{
		free( setOfHRTF[l] );
		}
		free( setOfHRTF );
		rom2bin_terminat();
		return -1;
		}
		else
		{
		if ( setOfHRTF[nbHRTF] != NULL )
		{
		nbHRTF++;
		fileSize += hrtf_size;
		if ( hrtf_size_max < hrtf_size )
		hrtf_size_max = hrtf_size;
		}
		}
		}
		break;
		// case RENDERER_BINAURAL_PARAMETRIC:
		// case RENDERER_BINAURAL_PARAMETRIC_ROOM:
		// TODO @Nokia
		case RENDERER_BINAURAL_MIXER_CONV:
		case RENDERER_BINAURAL_MIXER_CONV_ROOM:
		for ( j = 0; j < IVAS_NB_AUDIO_CONFIG; j++ )
		@@ -607,7 +657,6 @@ char create_hrtf_tdrend( int32_t frequency, int32_t hrtf_size )
		fseek( input_td_bin_file, 0, SEEK_END );
		td_hrtf_data_size = ftell( input_td_bin_file );
		fseek( input_td_bin_file, 0, SEEK_SET );
		;

		// Header [Declaration of the HRTF]
		// Renderer type (4 bytes) : See "RENDERER_TYPE"
		@@ -673,6 +722,182 @@ char create_hrtf_tdrend( int32_t frequency, int32_t hrtf_size )
		return td_hrtf;
		}

		/---------------------------------------------------------------------
		* create_hrtf_fastconv()
		*
		---------------------------------------------------------------------/
		char *create_hrtf_fastconv(
		RENDERER_TYPE rend_type,
		BINAURAL_INPUT_AUDIO_CONFIG input_cfg,
		int32_t frequency,
		int32_t *hrtf_size )
		{
		char hrtf = NULL, hrtf_wptr;
		uint32_t hrtf_data_size;
		uint32_t data_size_tmp;

		uint16_t nbands_bin;
		uint16_t nchan_ir;
		uint16_t ntaps;
		uint16_t cldfb_ncol;

		float latency_s;
		float leftIRReal, leftIRImag;
		float rightIRReal, rightIRImag;
		float reverbTimes, reverbEneCorr;

		hrtf_data_size = 0;

		ntaps = 7;
		nbands_bin = BINAURAL_CONVBANDS;
		cldfb_ncol = CLDFB_NO_CHANNELS_MAX;

		/* Binary file - block description :

		latency_s => float

		BINAURAL_CONVBANDS => uint16_t
		num_ir => uint16_t
		num_taps => uint16_t

		leftIRReal => float[BINAURAL_CONVBANDS][num_ir][num_taps]
		leftIRImag => float[BINAURAL_CONVBANDS][num_ir][num_taps]
		rightIRReal => float[BINAURAL_CONVBANDS][num_ir][num_taps]
		rightIRImag => float[BINAURAL_CONVBANDS][num_ir][num_taps]

		OPTIONAL for BRIRs:

		CLDFB_NO_CHANNELS_MAX => uint16_t

		fastConvReverberationTimes => float[CLDFB_NO_CHANNELS_MAX]
		fastConvReverberationEneCorrection => float[CLDFB_NO_CHANNELS_MAX]
		*/

		// Set pointers
		if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )
		{
		nchan_ir = 15;

		if ( rend_type == RENDERER_BINAURAL_FASTCONV )
		{
		latency_s = FASTCONV_HRIR_latency_s;
		leftIRReal = &leftHRIRReal[0][0][0];
		leftIRImag = &leftHRIRImag[0][0][0];
		rightIRReal = &rightHRIRReal[0][0][0];
		rightIRImag = &rightHRIRImag[0][0][0];
		}
		else if ( rend_type == RENDERER_BINAURAL_FASTCONV_ROOM )
		{
		latency_s = FASTCONV_BRIR_latency_s;
		leftIRReal = &leftBRIRReal[0][0][0];
		leftIRImag = &leftBRIRImag[0][0][0];
		rightIRReal = &rightBRIRReal[0][0][0];
		rightIRImag = &rightBRIRImag[0][0][0];
		}
		}
		else if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_HOA )
		{
		nchan_ir = 16;

		latency_s = FASTCONV_HOA3_latency_s;
		leftIRReal = &leftHRIRReal_HOA3[0][0][0];
		leftIRImag = &leftHRIRImag_HOA3[0][0][0];
		rightIRReal = &rightHRIRReal_HOA3[0][0][0];
		rightIRImag = &rightHRIRImag_HOA3[0][0][0];
		}


		// Compute total size of data to write

		hrtf_data_size += sizeof( float ); // latency_s
		hrtf_data_size += sizeof( uint16_t ); // nbands_bin
		hrtf_data_size += sizeof( uint16_t ); // num_ir
		hrtf_data_size += sizeof( uint16_t ); // num_taps

		hrtf_data_size += nbands_bin * nchan_ir * ntaps * sizeof( float ); // leftIRReal
		hrtf_data_size += nbands_bin * nchan_ir * ntaps * sizeof( float ); // leftIRImag
		hrtf_data_size += nbands_bin * nchan_ir * ntaps * sizeof( float ); // rightIRReal
		hrtf_data_size += nbands_bin * nchan_ir * ntaps * sizeof( float ); // rightIRImag

		// TOOD tmu : decide how to write
		if ( rend_type == RENDERER_BINAURAL_FASTCONV_ROOM )
		{
		hrtf_data_size += sizeof( uint16_t ); // cldfb_ncol
		hrtf_data_size += cldfb_ncol * sizeof( float ); // fastconvReverberationTimes
		hrtf_data_size += cldfb_ncol * sizeof( float ); // fastconvEneCorrections
		}

		// Allocate memory
		*hrtf_size = sizeof( ivas_hrtfs_header_t ) + hrtf_data_size;
		hrtf = (char ) malloc( hrtf_size );

		if ( hrtf == NULL )
		{
		fprintf( stderr, "Memory allocation for the block failed!\n\n" );
		*hrtf_size = -1;
		return NULL;
		}

		// Write

		// Header [Declaration of the HRTF]
		// Renderer type (4 bytes) : See "RENDERER_TYPE"
		// Decoder output format (4 bytes) : See "BINAURAL_INPUT_AUDIO_CONFIG"
		// Sampling Frequency (4 bytes)
		// Raw data size (4 bytes)

		memset( hrtf, 0x00, *hrtf_size );
		// Renderer type
		memcpy( hrtf_wptr, &( rend_type ), sizeof( int32_t ) );
		hrtf_wptr += sizeof( int32_t );

		// Decoder output format
		memcpy( hrtf_wptr, &( input_cfg ), sizeof( int32_t ) );
		hrtf_wptr += sizeof( int32_t );

		// Sampling Frequency
		memcpy( hrtf_wptr, &( frequency ), sizeof( int32_t ) );
		hrtf_wptr += sizeof( int32_t );

		// Raw data size
		memcpy( hrtf_wptr, &( hrtf_data_size ), sizeof( uint32_t ) );
		hrtf_wptr += sizeof( uint32_t );


		// Write the HRTF raw data

		memcpy( hrtf_wptr, &( latency_s ), sizeof( uint16_t ) ); // latency_s => float
		hrtf_wptr += sizeof( uint16_t );

		memcpy( hrtf_wptr, &( nbands_bin ), sizeof( uint16_t ) ); // nbands_bin => uint16_t
		hrtf_wptr += sizeof( uint16_t );

		memcpy( hrtf_wptr, &( nchan_ir ), sizeof( uint16_t ) ); // num_ir => uint16_t
		hrtf_wptr += sizeof( uint16_t );

		memcpy( hrtf_wptr, &( ntaps ), sizeof( uint16_t ) ); // num_taps => uint16_t
		hrtf_wptr += sizeof( uint16_t );

		data_size_tmp = nbands_bin * nchan_ir * ntaps * sizeof( float );
		memcpy( hrtf_wptr, &( leftIRReal ), data_size_tmp ); // leftIRReal => float[nchan_bin][nchan_ir][ntaps]
		memcpy( hrtf_wptr, &( leftIRImag ), data_size_tmp ); // leftIRImag => float[nchan_bin][nchan_ir][ntaps]
		memcpy( hrtf_wptr, &( rightIRReal ), data_size_tmp ); // rightIRReal => float[nchan_bin][nchan_ir][ntaps]
		memcpy( hrtf_wptr, &( rightIRImag ), data_size_tmp ); // rightIRImag => float[nchan_bin][nchan_ir][ntaps]

		// TOOD tmu : decide how to write
		if ( rend_type == RENDERER_BINAURAL_FASTCONV_ROOM )
		{
		memcpy( hrtf_wptr, &( cldfb_ncol ), sizeof( uint16_t ) ); // cldfb_ncol => int16_t
		hrtf_wptr += sizeof( uint16_t );

		data_size_tmp = cldfb_ncol * sizeof( float );
		memcpy( hrtf_wptr, &( reverbTimes ), data_size_tmp ); // fastconvReverberationTimes
		memcpy( hrtf_wptr, &( reverbEneCorr ), data_size_tmp ); // fastconvEneCorrections
		}

		return hrtf;
		}

		/---------------------------------------------------------------------
		* get_hrtf_tables()
		*