update binaural table writing/reading (d496fd89) · Commits · IVAS Codec Public Collaboration / IVAS Codec

lib_com/ivas_cnst.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -1359,6 +1359,9 @@ typedef enum

		#define HRTF_SH_ORDER 3
		#define HRTF_SH_CHANNELS 16
		#ifdef HRTF_BINARY_FASTCONV
		#define HRTF_LS_CHANNELS 15
		#endif
		#define HRTF_NUM_BINS 60
		#define REVERB_PREDELAY_MAX 20 /* Max input delay for reverb module */
		#define GAIN_LFE 1.88364911f /* Gain applied to LFE during renderering */

lib_rend/ivas_rom_binauralRenderer.c

+32 −0

Original line number	Diff line number	Diff line
		@@ -3685,7 +3685,11 @@ const float rightHRIRImag_HOA3[BINAURAL_CONVBANDS][16][7]=
		};

		const float FASTCONV_HRIR_latency_s = 0.000666667f;
		#ifdef HRTF_BINARY_FASTCONV
		const float leftHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7]=
		#else
		const float leftHRIRReal[BINAURAL_CONVBANDS][15][7]=
		#endif
		{
		{
		{+0.331798f, +0.500334f, +0.042057f, -0.000623f, -0.000260f},
		@@ -4539,7 +4543,11 @@ const float leftHRIRReal[BINAURAL_CONVBANDS][15][7]=
		}
		};

		#ifdef HRTF_BINARY_FASTCONV
		const float leftHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7]=
		#else
		const float leftHRIRImag[BINAURAL_CONVBANDS][15][7]=
		#endif
		{
		{
		{-0.346479f, +0.553523f, -0.074098f, +0.001288f, +0.000309f},
		@@ -5393,7 +5401,11 @@ const float leftHRIRImag[BINAURAL_CONVBANDS][15][7]=
		}
		};

		#ifdef HRTF_BINARY_FASTCONV
		const float rightHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7]=
		#else
		const float rightHRIRReal[BINAURAL_CONVBANDS][15][7]=
		#endif
		{
		{
		{+0.065097f, +0.755993f, -0.042308f, -0.016140f, -0.000353f},
		@@ -6247,7 +6259,11 @@ const float rightHRIRReal[BINAURAL_CONVBANDS][15][7]=
		}
		};

		#ifdef HRTF_BINARY_FASTCONV
		const float rightHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7]=
		#else
		const float rightHRIRImag[BINAURAL_CONVBANDS][15][7]=
		#endif
		{
		{
		{-0.179291f, +0.196331f, +0.055128f, -0.017382f, +0.000411f},
		@@ -7633,7 +7649,11 @@ const float hrtfShCoeffsIm[BINAURAL_CHANNELS][HRTF_SH_CHANNELS][HRTF_NUM_BINS]=
		/* Binaural rendering data set based on BRIRs */
		/* Tables derived from Mozart IIS BRIRs.*/
		const float FASTCONV_BRIR_latency_s = 0.000937500f;
		#ifdef HRTF_BINARY_FASTCONV
		const float leftBRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX]=
		#else
		const float leftBRIRReal[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX]=
		#endif
		{
		{
		{
		@@ -16737,7 +16757,11 @@ const float leftBRIRReal[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX]=
		}
		};

		#ifdef HRTF_BINARY_FASTCONV
		const float leftBRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX]=
		#else
		const float leftBRIRImag[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX]=
		#endif
		{
		{
		{
		@@ -25841,7 +25865,11 @@ const float leftBRIRImag[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX]=
		}
		};

		#ifdef HRTF_BINARY_FASTCONV
		const float rightBRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX]=
		#else
		const float rightBRIRReal[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX]=
		#endif
		{
		{
		{
		@@ -34945,7 +34973,11 @@ const float rightBRIRReal[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX]=
		}
		};

		#ifdef HRTF_BINARY_FASTCONV
		const float rightBRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX]=
		#else
		const float rightBRIRImag[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX]=
		#endif
		{
		{
		{

lib_rend/ivas_rom_binauralRenderer.h

+14 −0

Original line number	Diff line number	Diff line
		@@ -56,10 +56,17 @@ extern float rightHRIRReal_HOA3[BINAURAL_CONVBANDS][16][7];
		extern float rightHRIRImag_HOA3[BINAURAL_CONVBANDS][16][7];
		#endif

		#ifdef HRTF_BINARY_FASTCONV
		extern float leftHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7];
		extern float leftHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7];
		extern float rightHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7];
		extern float rightHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][7];
		#else
		extern float leftHRIRReal[BINAURAL_CONVBANDS][15][7];
		extern float leftHRIRImag[BINAURAL_CONVBANDS][15][7];
		extern float rightHRIRReal[BINAURAL_CONVBANDS][15][7];
		extern float rightHRIRImag[BINAURAL_CONVBANDS][15][7];
		#endif

		extern float FASTCONV_HOA3_latency_s;
		extern float hrtfShCoeffsRe[BINAURAL_CHANNELS][HRTF_SH_CHANNELS][HRTF_NUM_BINS];
		@@ -68,10 +75,17 @@ extern float hrtfShCoeffsIm[BINAURAL_CHANNELS][HRTF_SH_CHANNELS][HRTF_NUM_BINS];

		/* Binaural rendering data set based on BRIRs */
		extern const float FASTCONV_BRIR_latency_s;
		#ifdef HRTF_BINARY_FASTCONV
		extern float leftBRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX];
		extern float leftBRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX];
		extern float rightBRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX];
		extern float rightBRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX];
		#else
		extern float leftBRIRReal[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX];
		extern float leftBRIRImag[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX];
		extern float rightBRIRReal[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX];
		extern float rightBRIRImag[BINAURAL_CONVBANDS][15][BINAURAL_NTAPS_MAX];
		#endif

		/* Reverberation parameters based on BRIRs for fastconv */
		extern float fastconvReverberationTimes[CLDFB_NO_CHANNELS_MAX];

lib_util/hrtf_file_reader.c

+126 −20

Original line number	Diff line number	Diff line
		@@ -898,10 +898,6 @@ static ivas_error create_fastconv_HRTF_from_rawdata(

		hrtf_data_rptr = hrtf_data;

		// latency_s
		( hHRTF )->FASTCONV_HRIR_latency_s = ( (float *) ( hrtf_data_rptr ) );
		hrtf_data_rptr += sizeof( float );

		// BINAURAL_CONVBANDS
		if ( BINAURAL_CONVBANDS != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		{
		@@ -909,55 +905,165 @@ static ivas_error create_fastconv_HRTF_from_rawdata(
		}
		hrtf_data_rptr += sizeof( uint16_t );

		// num_ir
		if ( 15 != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		// HRIR
		( hHRTF )->FASTCONV_HRIR_latency_s = ( (float *) ( hrtf_data_rptr ) );
		hrtf_data_rptr += sizeof( float );

		if ( HRTF_LS_CHANNELS != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (num_ir)" );
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (HRTF_LS_CHANNELS)" );
		}
		hrtf_data_rptr += sizeof( uint16_t );

		// num_taps
		if ( 7 != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (num_taps)" );
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (BINAURAL_NTAPS)" );
		}
		hrtf_data_rptr += sizeof( uint16_t );

		// leftHRIRReal
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < 15; j++ )
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->leftHRIRReal[i][j], hrtf_data_rptr, 7 sizeof( float ) );
		hrtf_data_rptr += 7 * sizeof( float );
		}
		}

		// leftHRIRImag
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < 15; j++ )
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->leftHRIRImag[i][j], hrtf_data_rptr, 7 sizeof( float ) );
		hrtf_data_rptr += 7 * sizeof( float );
		}
		}

		// rightHRIRReal
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < 15; j++ )
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->rightHRIRReal[i][j], hrtf_data_rptr, 7 sizeof( float ) );
		hrtf_data_rptr += 7 * sizeof( float );
		}
		}

		// rightHRIRImag
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < 15; j++ )
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->rightHRIRImag[i][j], hrtf_data_rptr, 7 sizeof( float ) );
		hrtf_data_rptr += 7 * sizeof( float );
		}
		}

		// HRIR_HOA3
		( hHRTF )->FASTCONV_HOA3_latency_s = ( (float *) ( hrtf_data_rptr ) );
		hrtf_data_rptr += sizeof( float );

		if ( HRTF_SH_CHANNELS != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (HRTF_SH_CHANNELS)" );
		}
		hrtf_data_rptr += sizeof( uint16_t );

		if ( 7 != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (BINAURAL_NTAPS)" );
		}
		hrtf_data_rptr += sizeof( uint16_t );

		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->leftHRIRReal_HOA3[i][j], hrtf_data_rptr, 7 sizeof( float ) );
		hrtf_data_rptr += 7 * sizeof( float );
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->leftHRIRImag_HOA3[i][j], hrtf_data_rptr, 7 sizeof( float ) );
		hrtf_data_rptr += 7 * sizeof( float );
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->rightHRIRReal_HOA3[i][j], hrtf_data_rptr, 7 sizeof( float ) );
		hrtf_data_rptr += 7 * sizeof( float );
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->rightHRIRImag_HOA3[i][j], hrtf_data_rptr, 7 sizeof( float ) );
		hrtf_data_rptr += 7 * sizeof( float );
		}
		}

		// BRIR
		( hHRTF )->FASTCONV_BRIR_latency_s = ( (float *) ( hrtf_data_rptr ) );
		hrtf_data_rptr += sizeof( float );

		if ( HRTF_LS_CHANNELS != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (HRTF_LS_CHANNELS)" );
		}
		hrtf_data_rptr += sizeof( uint16_t );

		if ( BINAURAL_NTAPS_MAX != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (BINAURAL_NTAPS)" );
		}
		hrtf_data_rptr += sizeof( uint16_t );

		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->leftHRIRReal[i][j], hrtf_data_rptr, BINAURAL_NTAPS_MAX sizeof( float ) );
		hrtf_data_rptr += BINAURAL_NTAPS_MAX * sizeof( float );
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->leftHRIRImag[i][j], hrtf_data_rptr, BINAURAL_NTAPS_MAX sizeof( float ) );
		hrtf_data_rptr += BINAURAL_NTAPS_MAX * sizeof( float );
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->rightHRIRReal[i][j], hrtf_data_rptr, BINAURAL_NTAPS_MAX sizeof( float ) );
		hrtf_data_rptr += BINAURAL_NTAPS_MAX * sizeof( float );
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( ( hHRTF )->rightHRIRImag[i][j], hrtf_data_rptr, BINAURAL_NTAPS_MAX sizeof( float ) );
		hrtf_data_rptr += BINAURAL_NTAPS_MAX * sizeof( float );
		}
		}

		// Reverb Parameters
		if ( CLDFB_NO_COL_MAX != ( (uint16_t ) ( hrtf_data_rptr ) ) )
		{
		return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file not compliant (CLDFB_NO_COL_MAX)" );
		}
		hrtf_data_rptr += sizeof( uint16_t );

		memcpy( ( hHRTF )->fastconvReverberationTimes, hrtf_data_rptr, CLDFB_NO_COL_MAX sizeof( float ) );
		hrtf_data_rptr += CLDFB_NO_COL_MAX * sizeof( float );

		memcpy( ( hHRTF )->fastconvReverberationEneCorrections, hrtf_data_rptr, CLDFB_NO_COL_MAX sizeof( float ) );
		hrtf_data_rptr += CLDFB_NO_COL_MAX * sizeof( float );

		return IVAS_ERR_OK;
		}

scripts/binauralRenderer_interface/Table_Format_Converter/generate_tables_from_rom_to_bin.c

+185 −90

Original line number	Diff line number	Diff line
		@@ -736,36 +736,42 @@ char *create_hrtf_fastconv(
		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;

		int16_t i, j;
		uint16_t binaural_convbands;
		uint16_t hrtf_channels;
		uint16_t num_taps;
		uint16_t cldfb_no_col_max;
		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:
		HRIR_latency_s => float
		HRTF_LS_CHANNELS => uint16_t
		ntaps => int16_t
		leftHRIRReal => float[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][num_taps]
		leftHRIRImag => float[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][num_taps]
		rightHRIRReal => float[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][num_taps]
		rightHRIRImag => float[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][num_taps]

		HRIR_HOA3_latency_s => float
		HRTF_SH_CHANNELS => uint16_t
		ntaps => int16_t
		leftHRIRReal_HOA3 => float[BINAURAL_CONVBANDS][HRTF_SH_CHANNELS][num_taps]
		leftHRIRImag_HOA3 => float[BINAURAL_CONVBANDS][HRTF_SH_CHANNELS][num_taps]
		rightHRIRReal_HOA3 => float[BINAURAL_CONVBANDS][HRTF_SH_CHANNELS][num_taps]
		rightHRIRImag_HOA3 => float[BINAURAL_CONVBANDS][HRTF_SH_CHANNELS][num_taps]

		BRIR_latency_s => float
		HRTF_LS_CHANNELS => uint16_t
		ntaps => int16_t
		leftBRIRReal => float[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][num_taps]
		leftBRIRImag => float[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][num_taps]
		rightBRIRReal => float[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][num_taps]
		rightBRIRImag => float[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][num_taps]

		CLDFB_NO_CHANNELS_MAX => uint16_t

		@@ -773,59 +779,21 @@ char *create_hrtf_fastconv(
		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 += sizeof( uint16_t ); // BINAURAL_CONVBANDS

		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
		hrtf_data_size += 3 * sizeof( float ); // latency_s
		hrtf_data_size += 3 * sizeof( uint16_t ); // HRTF_{SH,LS}_CHANNELS
		hrtf_data_size += 3 * sizeof( uint16_t ); // num_taps
		hrtf_data_size += 4 * ( BINAURAL_CONVBANDS * HRTF_LS_CHANNELS * 7 * sizeof( float ) ); // HRIR
		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

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

		// Allocate memory
		*hrtf_size = sizeof( ivas_hrtfs_header_t ) + hrtf_data_size;
		@@ -847,6 +815,8 @@ char *create_hrtf_fastconv(
		// Raw data size (4 bytes)

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

		// Renderer type
		memcpy( hrtf_wptr, &( rend_type ), sizeof( int32_t ) );
		hrtf_wptr += sizeof( int32_t );
		@@ -865,35 +835,160 @@ char *create_hrtf_fastconv(


		// Write the HRTF raw data
		binaural_convbands = BINAURAL_CONVBANDS;
		memcpy( hrtf_wptr, &( binaural_convbands ), sizeof( uint16_t ) ); // nbands_bin => uint16_t
		hrtf_wptr += sizeof( uint16_t );


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

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

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

		memcpy( hrtf_wptr, &( ntaps ), sizeof( uint16_t ) ); // num_taps => uint16_t
		data_size_tmp = num_taps * sizeof( float );
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &leftHRIRReal[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &leftHRIRImag[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &rightHRIRReal[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &rightHRIRImag[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}

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

		hrtf_channels = HRTF_SH_CHANNELS;
		memcpy( hrtf_wptr, &( hrtf_channels ), sizeof( uint16_t ) ); // hrtf_channels => 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[nbands_bin][nchan_ir][ntaps]
		memcpy( hrtf_wptr, &( leftIRImag ), data_size_tmp ); // leftIRImag => float[nbands_bin][nchan_ir][ntaps]
		memcpy( hrtf_wptr, &( rightIRReal ), data_size_tmp ); // rightIRReal => float[nbands_bin][nchan_ir][ntaps]
		memcpy( hrtf_wptr, &( rightIRImag ), data_size_tmp ); // rightIRImag => float[nbands_bin][nchan_ir][ntaps]
		num_taps = 7;
		memcpy( hrtf_wptr, &( num_taps ), sizeof( uint16_t ) ); // num_taps => uint16_t
		hrtf_wptr += sizeof( uint16_t );

		// TOOD tmu : decide how to write
		if ( rend_type == RENDERER_BINAURAL_FASTCONV_ROOM )
		data_size_tmp = num_taps * sizeof( float );
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &leftHRIRReal_HOA3[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &leftHRIRImag_HOA3[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		memcpy( hrtf_wptr, &( cldfb_ncol ), sizeof( uint16_t ) ); // cldfb_ncol => int16_t
		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &rightHRIRReal_HOA3[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_SH_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &rightHRIRImag_HOA3[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}

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

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

		num_taps = BINAURAL_NTAPS_MAX;
		memcpy( hrtf_wptr, &( num_taps ), sizeof( uint16_t ) ); // num_taps => uint16_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
		data_size_tmp = num_taps * sizeof( float );
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, leftBRIRReal[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &leftBRIRImag[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &rightBRIRReal[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}
		for ( i = 0; i < BINAURAL_CONVBANDS; i++ )
		{
		for ( j = 0; j < HRTF_LS_CHANNELS; j++ )
		{
		memcpy( hrtf_wptr, &rightBRIRImag[i][j], data_size_tmp );
		hrtf_wptr += data_size_tmp;
		}
		}

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

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

		return hrtf;
		}