First version of tools with direct conversion of HR filters for mixer_conv from sofa to binary. (788d6fd0) · Commits · IVAS Codec Public Collaboration / IVAS Codec

scripts/binauralRenderer_interface/Table_Format_Converter/generate_tables_from_rom_to_bin.c

+337 −84

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>
		#include <math.h>

		#include "ivas_rom_binauralRenderer.h"
		#include "ivas_rom_binaural_crend_head.h"
		@@ -42,6 +43,7 @@


		#define FILE_HEADER
		#define MIXER_CONV_BINARY_FILE_311

		/------------------------------------------------------------------------------------------
		* Constants
		@@ -55,6 +57,12 @@

		#define DEFAULT_INPUT_ROM_FILE "ivas_binaural"
		#define DEFAULT_INPUT_TD_BIN_FILE "hrfilter_model"

		#ifdef MIXER_CONV_BINARY_FILE_311
		#define DEFAULT_INPUT_MIXERCONV_BIN_FILE "ivas_hrfilters_mixerconv"
		#define MIXERCONV_BIN_FILE_CFG_MAX_LEN 8
		#endif // MIXER_CONV_BINARY_FILE_311

		#define DEFAULT_BIN_FILE_EXT ".bin"

		#define IVAS_NB_RENDERER_TYPE 7
		@@ -158,6 +166,10 @@ void usage_tables_format_converter( void )
		"-48 : Select 48 kHz sampling frequency (no multiple values, all frequencies by default).\n" );
		fprintf( stdout, "-input_td_file_path : Path of binary files for time-domain renderer (with separator, used as flag).\n" );
		fprintf( stdout, "-input_td_file_name : Name of input td file (without extension %s, default = '%s').\n", DEFAULT_BIN_FILE_EXT, DEFAULT_INPUT_TD_BIN_FILE );
		#ifdef MIXER_CONV_BINARY_FILE_311
		fprintf( stdout, "-input_mixerconv_file_path : Path of binary files for mixer_conv renderer (with separator, used as flag).\n" );
		fprintf( stdout, "-input_mixerconv_file_name : Name of input mixer_conv file (without extension %s, default = '%s').\n", DEFAULT_BIN_FILE_EXT, DEFAULT_INPUT_MIXERCONV_BIN_FILE );
		#endif
		fprintf( stdout, "\n" );
		}

		@@ -173,6 +185,12 @@ char *input_td_bin_path = NULL;
		char *input_td_bin_file_name = NULL;
		char *full_in_td_path = NULL;

		#ifdef MIXER_CONV_BINARY_FILE_311
		char *input_mixerconv_bin_path = NULL;
		char *input_mixerconv_bin_file_name = NULL;
		char *full_in_mixerconv_path = NULL;
		#endif

		int16_t nb_freq = IVAS_NB_SAMPLERATE;
		const int32_t *freq_ptr = sample_rates;

		@@ -286,6 +304,10 @@ int main( int argc, char *argv[] )
		break;
		case RENDERER_BINAURAL_MIXER_CONV:
		case RENDERER_BINAURAL_MIXER_CONV_ROOM:
		#ifdef MIXER_CONV_BINARY_FILE_311
		if ( full_in_mixerconv_path != NULL )
		#endif // MIXER_CONV_BINARY_FILE_311
		{
		for ( j = 0; j < IVAS_NB_AUDIO_CONFIG; j++ )
		{
		for ( k = 0; k < nb_freq; k++ )
		@@ -314,6 +336,7 @@ int main( int argc, char *argv[] )
		}
		}
		}
		}
		break;
		case RENDERER_BINAURAL_OBJECTS_TD:
		if ( full_in_td_path != NULL )
		@@ -351,6 +374,7 @@ int main( int argc, char *argv[] )
		}

		#ifdef FILE_HEADER

		// Create the file header and write it in the bin file

		// [Declaration of the binary file]
		@@ -391,6 +415,7 @@ int main( int argc, char *argv[] )

		fwrite( file_header, file_header_size, 1, bin_file );
		free( file_header );

		#endif

		// Write each HRTF in the bin file
		@@ -441,6 +466,117 @@ int main( int argc, char *argv[] )
		---------------------------------------------------------------------/
		char create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG input_cfg, int32_t frequency, int32_t hrtf_size )
		{
		int32_t mixerconv_hrtf_header_size, mixerconv_hrtf_data_size;
		char mixerconv_hrtf = NULL, mixerconv_hrtf_wptr;

		#ifdef MIXER_CONV_BINARY_FILE_311

		FILE *input_mixerconv_bin_file = NULL;

		// Get the HRTF raw data

		char renderer_type_name, configuration_name;

		// Example : ivas_hrfilters_mixerconv_Combined_HRIR_48kHz.bin

		if ( rend_type == RENDERER_BINAURAL_MIXER_CONV )
		{
		renderer_type_name = "HRIR";

		if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )
		{
		configuration_name = "Combined";
		}
		else if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_HOA )
		{
		configuration_name = "HOA3";
		}
		}
		else if ( rend_type == RENDERER_BINAURAL_MIXER_CONV_ROOM )
		{
		renderer_type_name = "BRIR";

		if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED )
		{
		configuration_name = "Combined";
		}
		else if ( input_cfg == BINAURAL_INPUT_AUDIO_CONFIG_HOA )
		{
		return NULL;
		}
		}

		sprintf( full_in_mixerconv_path, "%s%s_%s_%s_%dkHz%s", input_mixerconv_bin_path, input_mixerconv_bin_file_name, configuration_name, renderer_type_name, frequency / 1000, DEFAULT_BIN_FILE_EXT );
		input_mixerconv_bin_file = fopen( full_in_mixerconv_path, "rb" );

		if ( input_mixerconv_bin_file != NULL )
		{
		fseek( input_mixerconv_bin_file, 0, SEEK_END );
		mixerconv_hrtf_data_size = ftell( input_mixerconv_bin_file );
		fseek( input_mixerconv_bin_file, 0, SEEK_SET );

		// 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)

		mixerconv_hrtf_header_size = sizeof( int32_t ) + sizeof( int32_t ) + sizeof( int32_t ) + sizeof( uint32_t );
		*hrtf_size = mixerconv_hrtf_header_size + mixerconv_hrtf_data_size;
		mixerconv_hrtf = (char ) malloc( hrtf_size );

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

		memset( mixerconv_hrtf, 0x00, *hrtf_size );
		mixerconv_hrtf_wptr = mixerconv_hrtf;

		// Get the HRTF header

		// Renderer type
		memcpy( mixerconv_hrtf_wptr, &( rend_type ), sizeof( int32_t ) );
		mixerconv_hrtf_wptr += sizeof( int32_t );

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

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

		// Raw data size
		memcpy( mixerconv_hrtf_wptr, &( mixerconv_hrtf_data_size ), sizeof( uint32_t ) );
		mixerconv_hrtf_wptr += sizeof( uint32_t );

		// Get the HRTF raw data

		if ( fread( mixerconv_hrtf_wptr, mixerconv_hrtf_data_size, 1, input_mixerconv_bin_file ) != 1 )
		{
		fprintf( stderr, "Reading of the mixer_conv hrtf failed!\n\n" );
		fclose( input_mixerconv_bin_file );
		free( mixerconv_hrtf );
		*hrtf_size = -1;
		return NULL;
		}

		fclose( input_mixerconv_bin_file );
		input_mixerconv_bin_file = NULL;
		}
		else
		{
		fprintf( stderr, "Opening of file %s failed!\n\n", full_in_mixerconv_path );
		*hrtf_size = -1;
		return NULL;
		}

		#else // MIXER_CONV_BINARY_FILE_311

		crend_hrtf_tables_dimensions tabs_dims;
		crend_hrtf_tables_pointers tabs_ptrs;

		@@ -451,7 +587,6 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		/* uint32_t total_num_fsamp_per_iteration, iIter, iIndex;
		uint32_t total_num_fsamp_per_iteration_diff; */
		float *coeff_rptr;
		char hrtf = NULL, hrtf_wptr;

		memset( &tabs_dims, 0x00, sizeof( crend_hrtf_tables_dimensions ) );
		memset( &tabs_ptrs, 0x00, sizeof( crend_hrtf_tables_pointers ) );
		@@ -490,7 +625,7 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		if ( get_crend_hrtf_tables( rend_type, input_cfg, frequency, &tabs_ptrs, &tabs_dims ) == -1 )
		{
		fprintf( stderr, "Get table failed!\n\n" );
		free( hrtf );
		free( mixerconv_hrtf );
		*hrtf_size = -1;
		return NULL;
		}
		@@ -513,85 +648,85 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		// Raw data size (4 bytes)

		*hrtf_size = sizeof( ivas_hrtfs_header_t ) + hrtf_data_size;
		hrtf = (char ) malloc( hrtf_size );
		if ( hrtf == NULL )
		mixerconv_hrtf = (char ) malloc( hrtf_size );
		if ( mixerconv_hrtf == NULL )
		{
		fprintf( stderr, "Memory allocation for the block failed!\n\n" );
		*hrtf_size = -1;
		return NULL;
		}

		memset( hrtf, 0x00, *hrtf_size );
		hrtf_wptr = hrtf;
		memset( mixerconv_hrtf, 0x00, *hrtf_size );
		mixerconv_hrtf_wptr = mixerconv_hrtf;

		// Write the HRTF header

		// Renderer type
		memcpy( hrtf_wptr, &( rend_type ), sizeof( int32_t ) );
		hrtf_wptr += sizeof( int32_t );
		memcpy( mixerconv_hrtf_wptr, &( rend_type ), sizeof( int32_t ) );
		mixerconv_hrtf_wptr += sizeof( int32_t );

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

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

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

		// Write the HRTF raw data

		memcpy( hrtf_wptr, tabs_ptrs.latency_s, sizeof( float ) ); // latency_s
		hrtf_wptr += sizeof( float );
		memcpy( mixerconv_hrtf_wptr, tabs_ptrs.latency_s, sizeof( float ) ); // latency_s
		mixerconv_hrtf_wptr += sizeof( float );

		memcpy( hrtf_wptr, &( tabs_dims.max_num_ir ), sizeof( uint16_t ) ); // max_num_ir
		hrtf_wptr += sizeof( uint16_t );
		memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_num_ir ), sizeof( uint16_t ) ); // max_num_ir
		mixerconv_hrtf_wptr += sizeof( uint16_t );

		uint16_t nchan_bin = BINAURAL_CHANNELS;
		memcpy( hrtf_wptr, &nchan_bin, sizeof( uint16_t ) ); // BINAURAL_CHANNELS
		hrtf_wptr += sizeof( uint16_t );
		memcpy( mixerconv_hrtf_wptr, &nchan_bin, sizeof( uint16_t ) ); // BINAURAL_CHANNELS
		mixerconv_hrtf_wptr += sizeof( uint16_t );

		memcpy( hrtf_wptr, &( tabs_dims.max_num_iterations ), sizeof( int16_t ) ); // max_num_iterations
		hrtf_wptr += sizeof( int16_t );
		memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_num_iterations ), sizeof( int16_t ) ); // max_num_iterations
		mixerconv_hrtf_wptr += sizeof( int16_t );

		data_size_tmp = tabs_dims.max_num_ir * BINAURAL_CHANNELS * sizeof( uint16_t );
		memcpy( hrtf_wptr, tabs_ptrs.num_iterations, data_size_tmp ); // num_iterations
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, tabs_ptrs.num_iterations, data_size_tmp ); // num_iterations
		mixerconv_hrtf_wptr += data_size_tmp;

		data_size_tmp = tabs_dims.max_num_ir * BINAURAL_CHANNELS * tabs_dims.max_num_iterations * sizeof( uint16_t );
		memcpy( hrtf_wptr, tabs_ptrs.pIndex_frequency_max, data_size_tmp ); // pIndex_frequency_max
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, tabs_ptrs.pIndex_frequency_max, data_size_tmp ); // pIndex_frequency_max
		mixerconv_hrtf_wptr += data_size_tmp;

		memcpy( hrtf_wptr, &( tabs_dims.max_num_iterations_diffuse ), sizeof( int16_t ) ); // max_num_iterations_diffuse
		hrtf_wptr += sizeof( int16_t );
		memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_num_iterations_diffuse ), sizeof( int16_t ) ); // max_num_iterations_diffuse
		mixerconv_hrtf_wptr += sizeof( int16_t );

		if ( tabs_dims.max_num_iterations_diffuse != 0 )
		{
		data_size_tmp = BINAURAL_CHANNELS * sizeof( uint16_t );
		memcpy( hrtf_wptr, tabs_ptrs.num_iterations_diffuse, data_size_tmp ); // num_iterations_diffuse
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, tabs_ptrs.num_iterations_diffuse, data_size_tmp ); // num_iterations_diffuse
		mixerconv_hrtf_wptr += data_size_tmp;

		// pIndex_frequency_max_diffuse (the size depends on num_iterations_diffuse)
		for ( iChan = 0; iChan < BINAURAL_CHANNELS; iChan++ )
		{
		data_size_tmp = tabs_ptrs.num_iterations_diffuse[iChan] * sizeof( uint16_t );
		memcpy( hrtf_wptr, tabs_ptrs.pIndex_frequency_max_diffuse, data_size_tmp );
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, tabs_ptrs.pIndex_frequency_max_diffuse, data_size_tmp );
		mixerconv_hrtf_wptr += data_size_tmp;
		}
		}

		memcpy( hrtf_wptr, tabs_ptrs.index_frequency_max_diffuse, sizeof( uint16_t ) ); // index_frequency_max_diffuse
		hrtf_wptr += sizeof( uint16_t );
		memcpy( mixerconv_hrtf_wptr, tabs_ptrs.index_frequency_max_diffuse, sizeof( uint16_t ) ); // index_frequency_max_diffuse
		mixerconv_hrtf_wptr += sizeof( uint16_t );

		data_size_tmp = tabs_dims.max_num_ir * sizeof( float );
		memcpy( hrtf_wptr, tabs_ptrs.inv_diffuse_weight, data_size_tmp ); // inv_diffuse_weight
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, tabs_ptrs.inv_diffuse_weight, data_size_tmp ); // inv_diffuse_weight
		mixerconv_hrtf_wptr += data_size_tmp;

		memcpy( hrtf_wptr, &( tabs_dims.max_total_num_fsamp_per_iteration ), sizeof( uint16_t ) ); // max_total_num_fsamp_per_iteration
		hrtf_wptr += sizeof( uint16_t );
		memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_total_num_fsamp_per_iteration ), sizeof( uint16_t ) ); // max_total_num_fsamp_per_iteration
		mixerconv_hrtf_wptr += sizeof( uint16_t );

		// coeff_re (The size depends on pIndex_frequency_max)
		for ( iIR = 0, iIndex = 0; iIR < tabs_dims.max_num_ir; iIR++ )
		@@ -602,8 +737,8 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		for ( iIter = 0; iIter < tabs_ptrs.num_iterations[iIR * BINAURAL_CHANNELS + iChan]; iIter++ )
		{
		data_size_tmp = tabs_ptrs.pIndex_frequency_max[iIndex] * sizeof( float );
		memcpy( hrtf_wptr, coeff_rptr, data_size_tmp );
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, coeff_rptr, data_size_tmp );
		mixerconv_hrtf_wptr += data_size_tmp;
		coeff_rptr += tabs_ptrs.pIndex_frequency_max[iIndex++];
		}
		}
		@@ -618,15 +753,15 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		for ( iIter = 0; iIter < tabs_ptrs.num_iterations[iIR * BINAURAL_CHANNELS + iChan]; iIter++ )
		{
		data_size_tmp = tabs_ptrs.pIndex_frequency_max[iIndex] * sizeof( float );
		memcpy( hrtf_wptr, coeff_rptr, data_size_tmp );
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, coeff_rptr, data_size_tmp );
		mixerconv_hrtf_wptr += data_size_tmp;
		coeff_rptr += tabs_ptrs.pIndex_frequency_max[iIndex++];
		}
		}
		}

		memcpy( hrtf_wptr, &( tabs_dims.max_total_num_fsamp_per_iteration_diff ), sizeof( uint16_t ) ); // max_total_num_fsamp_per_iteration_diff
		hrtf_wptr += sizeof( uint16_t );
		memcpy( mixerconv_hrtf_wptr, &( tabs_dims.max_total_num_fsamp_per_iteration_diff ), sizeof( uint16_t ) ); // max_total_num_fsamp_per_iteration_diff
		mixerconv_hrtf_wptr += sizeof( uint16_t );

		if ( tabs_dims.max_total_num_fsamp_per_iteration_diff != 0 )
		{
		@@ -637,8 +772,8 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		for ( iIter = 0; iIter < tabs_ptrs.num_iterations_diffuse[iChan]; iIter++ )
		{
		data_size_tmp = tabs_ptrs.pIndex_frequency_max_diffuse[iIndex] * sizeof( float );
		memcpy( hrtf_wptr, coeff_rptr, data_size_tmp );
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, coeff_rptr, data_size_tmp );
		mixerconv_hrtf_wptr += data_size_tmp;
		coeff_rptr += tabs_ptrs.pIndex_frequency_max_diffuse[iIndex++];
		}
		}
		@@ -650,14 +785,16 @@ char *create_hrtf_crend( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		for ( iIter = 0; iIter < tabs_ptrs.num_iterations_diffuse[iChan]; iIter++ )
		{
		data_size_tmp = tabs_ptrs.pIndex_frequency_max_diffuse[iIndex] * sizeof( float );
		memcpy( hrtf_wptr, coeff_rptr, data_size_tmp );
		hrtf_wptr += data_size_tmp;
		memcpy( mixerconv_hrtf_wptr, coeff_rptr, data_size_tmp );
		mixerconv_hrtf_wptr += data_size_tmp;
		coeff_rptr += tabs_ptrs.pIndex_frequency_max_diffuse[iIndex++];
		}
		}
		}

		return hrtf;
		#endif // MIXER_CONV_BINARY_FILE_311

		return mixerconv_hrtf;
		}

		/---------------------------------------------------------------------
		@@ -1169,6 +1306,7 @@ char create_hrtf_parametric( int32_t hrtf_size )
		return hrtf;
		}


		/---------------------------------------------------------------------
		* get_crend_hrtf_tables()
		*
		@@ -1536,6 +1674,7 @@ int32_t compute_crend_hrtf_data_size( crend_hrtf_tables_pointers *hrtf_table_ptr
		return hrtf_data_size;
		}


		/---------------------------------------------------------------------
		* check_bin_file()
		*
		@@ -1687,14 +1826,6 @@ int16_t check_bin_file( FILE *hrtf_bin_file )

		int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG input_cfg, int32_t frequency, char *hrtf_data_in, int32_t hrtf_size_in )
		{
		int16_t result;
		int32_t hrtf_data_size, ctrl_size, iChan, iIR, iIndex, iIter;
		float *coeff_rptr;
		char *hrtf_data_in_rptr;

		crend_hrtf_tables_dimensions tabs_dims;
		crend_hrtf_tables_pointers tabs_ptrs;

		if ( rend_type == RENDERER_BINAURAL_OBJECTS_TD \|\|
		rend_type == RENDERER_BINAURAL_FASTCONV \|\| rend_type == RENDERER_BINAURAL_FASTCONV_ROOM \|\|
		rend_type == RENDERER_BINAURAL_PARAMETRIC \|\| rend_type == RENDERER_BINAURAL_PARAMETRIC_ROOM )
		@@ -1702,6 +1833,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		return 0;
		}

		int16_t result;
		int32_t hrtf_data_size, ctrl_size, iChan, iIR, iIndex, iIter, iCtrl;
		float *coeff_rptr;
		char *hrtf_data_in_rptr;

		crend_hrtf_tables_dimensions tabs_dims;
		crend_hrtf_tables_pointers tabs_ptrs;

		memset( &tabs_dims, 0x00, sizeof( crend_hrtf_tables_dimensions ) );
		memset( &tabs_ptrs, 0x00, sizeof( crend_hrtf_tables_pointers ) );

		@@ -1830,6 +1969,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		fprintf( stderr, "check_hrtf_data of binary file failed: bad inv_diffuse_weight!\n\n" );
		return -1;
		}
		/*for ( iCtrl = 0; iCtrl < tabs_dims.max_num_ir; iCtrl++)
		{
		if ( fabs( tabs_ptrs.inv_diffuse_weight[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )
		{
		fprintf( stderr, "check_hrtf_data of binary file failed: bad inv_diffuse_weight!\n\n" );
		return -1;
		}
		}*/
		hrtf_data_in_rptr += ctrl_size;

		// max_total_num_fsamp_per_iteration
		@@ -1854,6 +2001,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_re!\n\n" );
		return -1;
		}
		/*for ( iCtrl = 0; iCtrl < tabs_ptrs.pIndex_frequency_max[iIndex]; iCtrl++)
		{
		if ( fabs( coeff_rptr[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )
		{
		fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_re!\n\n" );
		return -1;
		}
		}*/
		hrtf_data_in_rptr += ctrl_size;
		coeff_rptr += tabs_ptrs.pIndex_frequency_max[iIndex++];
		}
		@@ -1875,6 +2030,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_re!\n\n" );
		return -1;
		}
		/*for ( iCtrl = 0; iCtrl < tabs_ptrs.pIndex_frequency_max[iIndex]; iCtrl++)
		{
		if ( fabs( coeff_rptr[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )
		{
		fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_im!\n\n" );
		return -1;
		}
		}*/
		hrtf_data_in_rptr += ctrl_size;
		coeff_rptr += tabs_ptrs.pIndex_frequency_max[iIndex++];
		}
		@@ -1903,6 +2066,14 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_diffuse_re!\n\n" );
		return -1;
		}
		/*for ( iCtrl = 0; iCtrl < tabs_ptrs.pIndex_frequency_max_diffuse[iIndex]; iCtrl++)
		{
		if ( fabs( coeff_rptr[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )
		{
		fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_diffuse_re!\n\n" );
		return -1;
		}
		}*/
		hrtf_data_in_rptr += ctrl_size;
		coeff_rptr += tabs_ptrs.pIndex_frequency_max_diffuse[iIndex++];
		}
		@@ -1916,10 +2087,18 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
		{
		ctrl_size = tabs_ptrs.pIndex_frequency_max_diffuse[iIndex] * sizeof( float );
		if ( memcmp( coeff_rptr, hrtf_data_in_rptr, ctrl_size ) != 0 )
		{
		fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_diffuse_re!\n\n" );
		return -1;
		}
		/*for ( iCtrl = 0; iCtrl < tabs_ptrs.pIndex_frequency_max_diffuse[iIndex]; iCtrl++)
		{
		if ( fabs( coeff_rptr[iCtrl] - ((float*)hrtf_data_in_rptr)[iCtrl] ) > 0.000001 )
		{
		fprintf( stderr, "check_hrtf_data of binary file failed: bad coeff_diffuse_im!\n\n" );
		return -1;
		}
		}*/
		hrtf_data_in_rptr += ctrl_size;
		coeff_rptr += tabs_ptrs.pIndex_frequency_max_diffuse[iIndex++];
		}
		@@ -2049,6 +2228,21 @@ int rom2bin_init( int argc, char *argv[] )
		strcpy( input_td_bin_path, argv[i] );
		i++;
		}
		#ifdef MIXER_CONV_BINARY_FILE_311
		else if ( strcmp( to_upper( argv[i] ), "-INPUT_MIXERCONV_FILE_PATH" ) == 0 )
		{
		i++;
		if ( strlen( argv[i] ) == 0 )
		{
		fprintf( stderr, "Wrong input mixer_conv file path: %s\n\n", argv[i] );
		usage_tables_format_converter();
		return -1;
		}
		input_mixerconv_bin_path = malloc( strlen( argv[i] ) + 1 );
		strcpy( input_mixerconv_bin_path, argv[i] );
		i++;
		}
		#endif
		else if ( strcmp( to_upper( argv[i] ), "-INPUT_TD_FILE_NAME" ) == 0 )
		{
		i++;
		@@ -2062,6 +2256,21 @@ int rom2bin_init( int argc, char *argv[] )
		strcpy( input_td_bin_file_name, argv[i] );
		i++;
		}
		#ifdef MIXER_CONV_BINARY_FILE_311
		else if ( strcmp( to_upper( argv[i] ), "-INPUT_MIXERCONV_FILE_NAME" ) == 0 )
		{
		i++;
		if ( strlen( argv[i] ) == 0 )
		{
		fprintf( stderr, "Wrong input mixer_conv file name: %s\n\n", argv[i] );
		usage_tables_format_converter();
		return -1;
		}
		input_mixerconv_bin_file_name = malloc( strlen( argv[i] ) + 1 );
		strcpy( input_mixerconv_bin_file_name, argv[i] );
		i++;
		}
		#endif
		else
		{
		fprintf( stderr, "Unknown option: %s\n\n", argv[i] );
		@@ -2102,13 +2311,11 @@ int rom2bin_init( int argc, char *argv[] )

		if ( selected_frequency == 0 )
		{

		full_out_path = (char ) malloc( sizeof( char ) ( strlen( output_path ) + strlen( output_file_name ) + strlen( DEFAULT_BIN_FILE_EXT ) + 1 ) );
		sprintf( full_out_path, "%s%s%s", output_path, output_file_name, DEFAULT_BIN_FILE_EXT );
		}
		else
		{

		nb_freq = 1;
		for ( i = 0; i < IVAS_NB_SAMPLERATE; i++ )
		{
		@@ -2133,7 +2340,6 @@ int rom2bin_init( int argc, char *argv[] )

		if ( input_td_bin_path != NULL )
		{

		if ( input_td_bin_file_name == NULL )
		{
		input_td_bin_file_name = (char ) malloc( sizeof( char ) ( strlen( DEFAULT_INPUT_TD_BIN_FILE ) + 1 ) );
		@@ -2158,6 +2364,34 @@ int rom2bin_init( int argc, char *argv[] )
		}
		}

		#ifdef MIXER_CONV_BINARY_FILE_311
		if ( input_mixerconv_bin_path != NULL )
		{
		if ( input_mixerconv_bin_file_name == NULL )
		{
		input_mixerconv_bin_file_name = (char ) malloc( sizeof( char ) ( strlen( DEFAULT_INPUT_MIXERCONV_BIN_FILE ) + 1 ) );
		if ( input_mixerconv_bin_file_name )
		{
		strcpy( input_mixerconv_bin_file_name, DEFAULT_INPUT_MIXERCONV_BIN_FILE );
		}
		else
		{
		fprintf( stderr, "Memory issue for input mixer_conv bin file name!\n\n" );
		rom2bin_terminat();
		return -1;
		}
		}

		full_in_mixerconv_path = (char ) malloc( sizeof( char ) ( strlen( input_mixerconv_bin_path ) + strlen( input_mixerconv_bin_file_name ) + 3 + 2*MIXERCONV_BIN_FILE_CFG_MAX_LEN + 5 + strlen( DEFAULT_BIN_FILE_EXT ) + 1 ) );
		if ( full_in_mixerconv_path == NULL )
		{
		fprintf( stderr, "Memory issue for full input mixer_conv path!\n\n" );
		rom2bin_terminat();
		return -1;
		}
		}
		#endif

		return 0;
		}

		@@ -2197,6 +2431,25 @@ void rom2bin_terminat( void )
		{
		free( full_in_td_path );
		}

		#ifdef MIXER_CONV_BINARY_FILE_311

		if ( input_mixerconv_bin_path != NULL )
		{
		free( input_mixerconv_bin_path );
		}

		if ( input_mixerconv_bin_file_name != NULL )
		{
		free( input_mixerconv_bin_file_name );
		}

		if ( full_in_mixerconv_path != NULL )
		{
		free( full_in_mixerconv_path );
		}

		#endif
		}

		/---------------------------------------------------------------------

scripts/binauralRenderer_interface/generate_crend_ivas_tables_from_sofa.c

+548 −5

File changed.

Preview size limit exceeded, changes collapsed.