diff --git a/lib_com/ivas_prot.h b/lib_com/ivas_prot.h index 885de082817bae5459551d03c98c3aaf853071b5..f841cbb1b6a1bb2d89dc163b92b7ce59c90bf3a5 100644 --- a/lib_com/ivas_prot.h +++ b/lib_com/ivas_prot.h @@ -5041,6 +5041,24 @@ void ivas_binRenderer_close( BINAURAL_RENDERER_HANDLE *hBinRenderer /* i/o: decoder binaural renderer handle */ ); +#ifdef FIX_1720_HRTF_FASTCONV +void ivas_binaural_hrtf_close( + HRTFS_FASTCONV_HANDLE *hHrtfFastConv /* i/o: decoder binaural hrtf handle */ +); + +ivas_error ivas_init_binaural_hrtf( + HRTFS_FASTCONV *HrtfFastConv /* i/o: FASTCONV HRTF structure */ +); + +ivas_error ivas_allocate_binaural_hrtf( + HRTFS_FASTCONV *HrtfFastConv, /* i/o: FASTCONV HRTF structure */ + AUDIO_CONFIG input_config, /* i : input audio configuration */ + BINAURAL_INPUT_AUDIO_CONFIG bin_input_config, /* i : binaural input audio config */ + RENDERER_TYPE renderer_type, /* i : renderer type */ + int16_t allocate_init_flag /* i : Memory allocation flag */ +); +#endif + #ifdef JBM_PARAMUPMIX void ivas_binaural_cldfb( Decoder_Struct *st_ivas, /* i/o: IVAS decoder structure */ diff --git a/lib_com/options.h b/lib_com/options.h index 1a8b3343fb2d0ee59ded96e6c8ab71442919e5b7..17eb804cf33c768392aa117d402cca9762fc3e86 100755 --- a/lib_com/options.h +++ b/lib_com/options.h @@ -174,6 +174,7 @@ #define COVARIANCE_MEMORY_OPT /* Dlb : Issue 231: define SPAR covariance buffers in stack instead of inter-frame heap */ #define NONBE_FIX_589_JBM_TC_OFFSETS /* FhG: issue 589: wrong offset into the TC buffers is used in some rendering paths in the JBM main rendering function */ #define FIX_MEM_REALLOC_IND_LIST /* VA: issue 601: failure of the automatic memory re-allocation mechanism when ind_list[] buffer is depleted in MASA mode with 2 TC*/ +#define FIX_1720_HRTF_FASTCONV /* Dlb : Binaural and Binaural room format RAM saving in SBA mode */ #define JBM_PARAMUPMIX /* Dlb: Issue 471: Integrate the Multichannel Parametric Upmix into the JBM path */ #define FIX_194_LFE_DELAY_EXTREND /* FhG: Issue 194: Fix delay alignment of LFE in external renderer */ #define FIX_582_INDEX_OUT_OF_BOUNDS_SNS_AVQ_DEC /* FhG: fix an undefined behaviour error in SNS AVQ decoding */ diff --git a/lib_dec/ivas_binRenderer_internal.c b/lib_dec/ivas_binRenderer_internal.c index 1c7372c9329b39a71f5b7f9ebd411e8c89105438..808e12471301e0672925bbb713ff39105b8118ef 100644 --- a/lib_dec/ivas_binRenderer_internal.c +++ b/lib_dec/ivas_binRenderer_internal.c @@ -485,6 +485,246 @@ static ivas_error ivas_binRenderer_convModuleOpen( return IVAS_ERR_OK; } +#ifdef FIX_1720_HRTF_FASTCONV +/*-------------------------------------------------------------------------* + * ivas_init_binaural_hrtf() + * + * initialize memory for HrtfFastConv structure elements + *-------------------------------------------------------------------------*/ + +ivas_error ivas_init_binaural_hrtf( + HRTFS_FASTCONV *HrtfFastConv /* i/o: FASTCONV HRTF structure */ +) +{ + int16_t i; + HrtfFastConv->leftHRIRReal_HOA3 = NULL; + HrtfFastConv->leftHRIRImag_HOA3 = NULL; + HrtfFastConv->rightHRIRReal_HOA3 = NULL; + HrtfFastConv->rightHRIRImag_HOA3 = NULL; + HrtfFastConv->FASTCONV_HOA3_latency_s = 0x00; + + HrtfFastConv->leftHRIRReal = NULL; + HrtfFastConv->leftHRIRImag = NULL; + HrtfFastConv->rightHRIRReal = NULL; + HrtfFastConv->rightHRIRImag = NULL; + HrtfFastConv->FASTCONV_HRIR_latency_s = 0x00; + + HrtfFastConv->leftBRIRReal = NULL; + HrtfFastConv->leftBRIRImag = NULL; + HrtfFastConv->rightBRIRReal = NULL; + HrtfFastConv->rightBRIRImag = NULL; + HrtfFastConv->FASTCONV_BRIR_latency_s = 0x00; + + HrtfFastConv->leftHRIRReal_HOA2 = NULL; + HrtfFastConv->leftHRIRImag_HOA2 = NULL; + HrtfFastConv->rightHRIRReal_HOA2 = NULL; + HrtfFastConv->rightHRIRImag_HOA2 = NULL; + HrtfFastConv->FASTCONV_HOA2_latency_s = 0x00; + + HrtfFastConv->leftHRIRReal_FOA = NULL; + HrtfFastConv->leftHRIRImag_FOA = NULL; + HrtfFastConv->rightHRIRReal_FOA = NULL; + HrtfFastConv->rightHRIRImag_FOA = NULL; + HrtfFastConv->FASTCONV_FOA_latency_s = 0x00; + + HrtfFastConv->allocate_init_flag = 0x00; + + for ( i = 0; i < CLDFB_NO_CHANNELS_MAX; i++ ) + { + HrtfFastConv->fastconvReverberationEneCorrections[i] = 0x00; + HrtfFastConv->fastconvReverberationEneCorrections[i] = 0x00; + } + + return IVAS_ERR_OK; +} + +/*-------------------------------------------------------------------------* + * ivas_alloc_pppMem() + * + * Allocate memory for tripple pointer elements + *-------------------------------------------------------------------------*/ + +static ivas_error ivas_alloc_pppMem( float ****pppMem, int32_t dim1, int32_t dim2, int32_t dim3, int16_t allocate_init_flag ) +{ + int32_t i, j; + float ***localMem = NULL; + + if ( ( localMem = (float ***) malloc( dim1 * sizeof( float ** ) ) ) == NULL ) + { + return IVAS_ERR_FAILED_ALLOC; + } + for ( i = 0; i < dim1; i++ ) + { + if ( ( localMem[i] = (float **) malloc( dim2 * sizeof( float * ) ) ) == NULL ) + { + return IVAS_ERR_FAILED_ALLOC; + } + if ( allocate_init_flag == 0 ) + { + for ( j = 0; j < dim2; j++ ) + { + if ( ( localMem[i][j] = (float *) malloc( dim3 * sizeof( float ) ) ) == NULL ) + { + return IVAS_ERR_FAILED_ALLOC; + } + } + } + } + + *pppMem = localMem; + + return IVAS_ERR_OK; +} + +/*-------------------------------------------------------------------------* + * ivas_allocate_binaural_hrtf() + * + * Allocate memory for HrtfFastConv structure elements + *-------------------------------------------------------------------------*/ + +ivas_error ivas_allocate_binaural_hrtf( + HRTFS_FASTCONV *HrtfFastConv, /* i/o: FASTCONV HRTF structure */ + AUDIO_CONFIG input_config, /* i : input audio configuration */ + BINAURAL_INPUT_AUDIO_CONFIG bin_input_config, /* i : binaural input audio config */ + RENDERER_TYPE renderer_type, /* i : renderer type */ + int16_t allocate_init_flag /* i : Memory allocation flag */ +) +{ + if ( input_config == AUDIO_CONFIG_HOA3 || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_HOA3 ) + { + if ( ( HrtfFastConv->leftHRIRReal_HOA3 != NULL ) && ( HrtfFastConv->leftHRIRImag_HOA3 != NULL ) && ( HrtfFastConv->rightHRIRReal_HOA3 != NULL ) && ( HrtfFastConv->rightHRIRImag_HOA3 != NULL ) ) + { + return IVAS_ERR_OK; + } + else + { + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_HOA3" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRImag_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_HOA3" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRReal_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_HOA3" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRImag_HOA3, BINAURAL_CONVBANDS, HOA3_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_HOA3" ); + } + } + } + if ( input_config == AUDIO_CONFIG_HOA2 || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_HOA2 ) + { + if ( ( HrtfFastConv->leftHRIRReal_HOA2 != NULL ) && ( HrtfFastConv->leftHRIRImag_HOA2 != NULL ) && ( HrtfFastConv->rightHRIRReal_HOA2 != NULL ) && ( HrtfFastConv->rightHRIRImag_HOA2 != NULL ) ) + { + return IVAS_ERR_OK; + } + else + { + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_HOA2" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRImag_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_HOA2" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRReal_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_HOA2" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRImag_HOA2, BINAURAL_CONVBANDS, HOA2_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_HOA2" ); + } + } + } + if ( input_config == AUDIO_CONFIG_FOA || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_FOA ) + { + if ( ( HrtfFastConv->leftHRIRReal_FOA != NULL ) && ( HrtfFastConv->leftHRIRImag_FOA != NULL ) && ( HrtfFastConv->rightHRIRReal_FOA != NULL ) && ( HrtfFastConv->rightHRIRImag_FOA != NULL ) ) + { + return IVAS_ERR_OK; + } + else + { + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal_FOA" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRImag_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag_FOA" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRReal_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal_FOA" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRImag_FOA, BINAURAL_CONVBANDS, FOA_CHANNELS, BINAURAL_NTAPS_SBA, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag_FOA" ); + } + } + } + if ( renderer_type == RENDERER_BINAURAL_FASTCONV || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED ) + { + if ( ( HrtfFastConv->leftHRIRReal != NULL ) && ( HrtfFastConv->leftHRIRImag != NULL ) && ( HrtfFastConv->rightHRIRReal != NULL ) && ( HrtfFastConv->rightHRIRImag != NULL ) ) + { + return IVAS_ERR_OK; + } + else + { + + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRReal" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftHRIRImag, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftHRIRImag" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRReal" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightHRIRImag, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightHRIRImag" ); + } + } + } + if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM || bin_input_config == BINAURAL_INPUT_AUDIO_CONFIG_COMBINED ) + { + if ( ( HrtfFastConv->leftBRIRReal != NULL ) && ( HrtfFastConv->leftBRIRImag != NULL ) && ( HrtfFastConv->rightBRIRReal != NULL ) && ( HrtfFastConv->rightBRIRImag != NULL ) ) + { + return IVAS_ERR_OK; + } + else + { + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftBRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftBRIRReal" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->leftBRIRImag, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for leftBRIRImag" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightBRIRReal, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightBRIRReal" ); + } + if ( IVAS_ERR_OK != ivas_alloc_pppMem( &HrtfFastConv->rightBRIRImag, BINAURAL_CONVBANDS, HRTF_LS_CHANNELS, BINAURAL_NTAPS_MAX, allocate_init_flag ) ) + { + return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for rightBRIRImag" ); + } + } + } + return IVAS_ERR_OK; +} +#endif + /*-------------------------------------------------------------------------* * ivas_binaural_HRTF_open() * @@ -492,7 +732,12 @@ static ivas_error ivas_binRenderer_convModuleOpen( *-------------------------------------------------------------------------*/ static ivas_error ivas_binaural_hrtf_open( - HRTFS_FASTCONV_HANDLE *hHrtfFastConv /* i : fastconv HRTF handle */ + HRTFS_FASTCONV_HANDLE *hHrtfFastConv /* i : fastconv HRTF handle */ +#ifdef FIX_1720_HRTF_FASTCONV + , + AUDIO_CONFIG input_config, /* i : output configuration */ + RENDERER_TYPE renderer_type /* i : renderer type */ +#endif ) { int16_t i, j; @@ -511,14 +756,93 @@ static ivas_error ivas_binaural_hrtf_open( return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for FastConv HRTF tables" ); } + +#ifdef FIX_1720_HRTF_FASTCONV + ivas_init_binaural_hrtf( HrtfFastConv ); + if ( input_config == AUDIO_CONFIG_BINAURAL || renderer_type == RENDERER_BINAURAL_FASTCONV ) + { + HrtfFastConv->FASTCONV_HRIR_latency_s = FASTCONV_HRIR_latency_s; + } + if ( input_config == AUDIO_CONFIG_HOA2 ) + { + HrtfFastConv->FASTCONV_HOA2_latency_s = FASTCONV_HOA2_latency_s; + } + if ( input_config == AUDIO_CONFIG_HOA3 ) + { + HrtfFastConv->FASTCONV_HOA3_latency_s = FASTCONV_HOA3_latency_s; + } + if ( input_config == AUDIO_CONFIG_FOA ) + { + HrtfFastConv->FASTCONV_FOA_latency_s = FASTCONV_FOA_latency_s; + } + if ( input_config == AUDIO_CONFIG_BINAURAL || renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM ) + { + HrtfFastConv->FASTCONV_BRIR_latency_s = FASTCONV_BRIR_latency_s; + } + HrtfFastConv->allocate_init_flag = 1; + ivas_allocate_binaural_hrtf( HrtfFastConv, input_config, BINAURAL_INPUT_AUDIO_CONFIG_INVALID, renderer_type, HrtfFastConv->allocate_init_flag ); +#else HrtfFastConv->FASTCONV_HRIR_latency_s = FASTCONV_HRIR_latency_s; HrtfFastConv->FASTCONV_HOA3_latency_s = FASTCONV_HOA3_latency_s; HrtfFastConv->FASTCONV_HOA2_latency_s = FASTCONV_HOA2_latency_s; HrtfFastConv->FASTCONV_FOA_latency_s = FASTCONV_FOA_latency_s; HrtfFastConv->FASTCONV_BRIR_latency_s = FASTCONV_BRIR_latency_s; +#endif for ( i = 0; i < BINAURAL_CONVBANDS; i++ ) { +#ifdef FIX_1720_HRTF_FASTCONV + if ( renderer_type == RENDERER_BINAURAL_FASTCONV ) + { + for ( j = 0; j < HRTF_LS_CHANNELS; j++ ) + { + HrtfFastConv->leftHRIRReal[i][j] = leftHRIRReal[i][j]; + HrtfFastConv->leftHRIRImag[i][j] = leftHRIRImag[i][j]; + HrtfFastConv->rightHRIRReal[i][j] = rightHRIRReal[i][j]; + HrtfFastConv->rightHRIRImag[i][j] = rightHRIRImag[i][j]; + } + } + else if ( renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM ) + { + for ( j = 0; j < HRTF_LS_CHANNELS; j++ ) + { + HrtfFastConv->leftBRIRReal[i][j] = leftBRIRReal[i][j]; + HrtfFastConv->leftBRIRImag[i][j] = leftBRIRImag[i][j]; + HrtfFastConv->rightBRIRReal[i][j] = rightBRIRReal[i][j]; + HrtfFastConv->rightBRIRImag[i][j] = rightBRIRImag[i][j]; + } + } + if ( input_config == AUDIO_CONFIG_HOA3 ) + { + for ( j = 0; j < HOA3_CHANNELS; j++ ) + { + HrtfFastConv->leftHRIRReal_HOA3[i][j] = leftHRIRReal_HOA3[i][j]; + HrtfFastConv->leftHRIRImag_HOA3[i][j] = leftHRIRImag_HOA3[i][j]; + HrtfFastConv->rightHRIRReal_HOA3[i][j] = rightHRIRReal_HOA3[i][j]; + HrtfFastConv->rightHRIRImag_HOA3[i][j] = rightHRIRImag_HOA3[i][j]; + } + } + if ( input_config == AUDIO_CONFIG_HOA2 ) + { + for ( j = 0; j < HOA2_CHANNELS; j++ ) + { + HrtfFastConv->leftHRIRReal_HOA2[i][j] = leftHRIRReal_HOA2[i][j]; + HrtfFastConv->leftHRIRImag_HOA2[i][j] = leftHRIRImag_HOA2[i][j]; + HrtfFastConv->rightHRIRReal_HOA2[i][j] = rightHRIRReal_HOA2[i][j]; + HrtfFastConv->rightHRIRImag_HOA2[i][j] = rightHRIRImag_HOA2[i][j]; + } + } + if ( input_config == AUDIO_CONFIG_FOA ) + { + for ( j = 0; j < FOA_CHANNELS; j++ ) + { + HrtfFastConv->leftHRIRReal_FOA[i][j] = leftHRIRReal_FOA[i][j]; + HrtfFastConv->leftHRIRImag_FOA[i][j] = leftHRIRImag_FOA[i][j]; + HrtfFastConv->rightHRIRReal_FOA[i][j] = rightHRIRReal_FOA[i][j]; + HrtfFastConv->rightHRIRImag_FOA[i][j] = rightHRIRImag_FOA[i][j]; + } + } +#else for ( j = 0; j < HRTF_LS_CHANNELS; j++ ) { mvr2r( leftHRIRReal[i][j], HrtfFastConv->leftHRIRReal[i][j], BINAURAL_NTAPS ); @@ -532,7 +856,6 @@ static ivas_error ivas_binaural_hrtf_open( mvr2r( rightBRIRReal[i][j], HrtfFastConv->rightBRIRReal[i][j], BINAURAL_NTAPS_MAX ); mvr2r( rightBRIRImag[i][j], HrtfFastConv->rightBRIRImag[i][j], BINAURAL_NTAPS_MAX ); } - #ifdef UPDATE_FASTCONV_SBA_FILTER for ( j = 0; j < HOA3_CHANNELS; j++ ) { @@ -577,9 +900,9 @@ static ivas_error ivas_binaural_hrtf_open( mvr2r( rightHRIRReal_FOA[i][j], HrtfFastConv->rightHRIRReal_FOA[i][j], BINAURAL_NTAPS ); mvr2r( rightHRIRImag_FOA[i][j], HrtfFastConv->rightHRIRImag_FOA[i][j], BINAURAL_NTAPS ); } +#endif #endif } - mvr2r( fastconvReverberationTimes, HrtfFastConv->fastconvReverberationTimes, CLDFB_NO_CHANNELS_MAX ); mvr2r( fastconvReverberationEneCorrections, HrtfFastConv->fastconvReverberationEneCorrections, CLDFB_NO_CHANNELS_MAX ); @@ -777,7 +1100,12 @@ ivas_error ivas_rend_openCldfbRend( hBinRenderer->numPoses = 1; } /* Load HRTF tables */ +#ifdef FIX_1720_HRTF_FASTCONV + ivas_binaural_hrtf_open( &pCldfbRend->hHrtfFastConv, hBinRenderer->hInputSetup->output_config, RENDERER_BINAURAL_FASTCONV ); +#else ivas_binaural_hrtf_open( &pCldfbRend->hHrtfFastConv ); +#endif + /* Allocate memories and buffers needed for convolutional module */ if ( ( error = ivas_binRenderer_convModuleOpen( hBinRenderer, RENDERER_BINAURAL_FASTCONV, hBinRenderer->hInputSetup->is_loudspeaker_setup, in_config, @@ -878,7 +1206,11 @@ ivas_error ivas_binRenderer_open( } /* Load HRTF tables */ +#ifdef FIX_1720_HRTF_FASTCONV + ivas_binaural_hrtf_open( &st_ivas->hHrtfFastConv, st_ivas->hIntSetup.output_config, st_ivas->renderer_type ); +#else ivas_binaural_hrtf_open( &st_ivas->hHrtfFastConv ); +#endif if ( st_ivas->renderer_type == RENDERER_BINAURAL_FASTCONV_ROOM && ( st_ivas->hIntSetup.is_loudspeaker_setup == 0 ) ) { @@ -1207,6 +1539,76 @@ void ivas_binRenderer_close( return; } +#ifdef FIX_1720_HRTF_FASTCONV +/*------------------------------------------------------------------------- + * ivas_free_pppHrtfMem() + * + * Free fastconv binaural renderer hrtf memories + *------------------------------------------------------------------------*/ +static void ivas_free_pppHrtfMem( float ****ppppHRIR, int16_t dim, int16_t alloc_init ) +{ + int16_t i, j; + if ( *ppppHRIR != NULL ) + { + for ( i = 0; i < BINAURAL_CONVBANDS; i++ ) + { + if ( alloc_init == 0 ) + { + for ( j = 0; j < dim; j++ ) + { + free( ( *ppppHRIR )[i][j] ); + ( *ppppHRIR )[i][j] = NULL; + } + } + free( ( *ppppHRIR )[i] ); + ( *ppppHRIR )[i] = NULL; + } + free( *ppppHRIR ); + *ppppHRIR = NULL; + } +} +/*------------------------------------------------------------------------- + * ivas_binaural_hrtf_close() + * + * Close fastconv binaural renderer hrtf memories + *------------------------------------------------------------------------*/ + +void ivas_binaural_hrtf_close( + HRTFS_FASTCONV_HANDLE *hHrtfFastConv /* i : fastconv HRTF handle */ +) +{ + int16_t allocate_init_flag; + if ( hHrtfFastConv == NULL || *hHrtfFastConv == NULL ) + { + return; + } + allocate_init_flag = ( *hHrtfFastConv )->allocate_init_flag; + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRReal, HRTF_LS_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRImag, HRTF_LS_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRReal, HRTF_LS_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRImag, HRTF_LS_CHANNELS, allocate_init_flag ); + + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftBRIRReal, HRTF_LS_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftBRIRImag, HRTF_LS_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightBRIRReal, HRTF_LS_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightBRIRImag, HRTF_LS_CHANNELS, allocate_init_flag ); + + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRReal_HOA3, HOA3_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRImag_HOA3, HOA3_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRReal_HOA3, HOA3_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRImag_HOA3, HOA3_CHANNELS, allocate_init_flag ); + + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRReal_HOA2, HOA2_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRImag_HOA2, HOA2_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRReal_HOA2, HOA2_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRImag_HOA2, HOA2_CHANNELS, allocate_init_flag ); + + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRReal_FOA, FOA_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->leftHRIRImag_FOA, FOA_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRReal_FOA, FOA_CHANNELS, allocate_init_flag ); + ivas_free_pppHrtfMem( &( *hHrtfFastConv )->rightHRIRImag_FOA, FOA_CHANNELS, allocate_init_flag ); +} +#endif /*-------------------------------------------------------------------------* * ivas_binaural_add_LFE() diff --git a/lib_dec/ivas_init_dec.c b/lib_dec/ivas_init_dec.c index 616069f25fbe1000500cd49ff6179189ab351bcd..48733a8846d6f8a28e41360e0733adc1724998e4 100644 --- a/lib_dec/ivas_init_dec.c +++ b/lib_dec/ivas_init_dec.c @@ -2037,7 +2037,10 @@ void ivas_destroy_dec( /* CRend binaural renderer handle */ ivas_HRTF_CRend_binary_close( &st_ivas->hSetOfHRTF ); - +#ifdef FIX_1720_HRTF_FASTCONV + /* Fastconv HRTF memories */ + ivas_binaural_hrtf_close( &st_ivas->hHrtfFastConv ); +#endif /* Fastconv HRTF filters */ ivas_HRTF_fastconv_binary_close( &st_ivas->hHrtfFastConv ); diff --git a/lib_rend/ivas_hrtf.c b/lib_rend/ivas_hrtf.c index 136873668bb2731f44a63badd6a9c7c32b4f27b2..a64867ea6ba32d644d69eb26b51ff1fa9b9d5dbc 100644 --- a/lib_rend/ivas_hrtf.c +++ b/lib_rend/ivas_hrtf.c @@ -36,6 +36,9 @@ #include "ivas_prot_rend.h" #include "ivas_error.h" #include "wmc_auto.h" +#ifdef FIX_1720_HRTF_FASTCONV +#include "ivas_prot.h" +#endif /*-----------------------------------------------------------------------* * ivas_HRTF_binary_open() @@ -139,7 +142,9 @@ ivas_error ivas_HRTF_fastconv_binary_open( { return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for FASTCONV HRTF tables!" ); } - +#ifdef FIX_1720_HRTF_FASTCONV + ivas_init_binaural_hrtf( *hHrtfFastConv ); +#endif return IVAS_ERR_OK; } diff --git a/lib_rend/ivas_stat_rend.h b/lib_rend/ivas_stat_rend.h index 36c4a1783654583e146ceeaa66ccc38ad58840d6..5a9cf2d02883073d1df545d1f57225f86a113b28 100644 --- a/lib_rend/ivas_stat_rend.h +++ b/lib_rend/ivas_stat_rend.h @@ -1348,13 +1348,39 @@ typedef struct ivas_hrtfs_crend_structure typedef struct ivas_hrtfs_fastconv_struct { + float FASTCONV_HOA3_latency_s; float FASTCONV_HRIR_latency_s; - float leftHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS]; - float leftHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS]; - float rightHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS]; - float rightHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS]; +#ifdef FIX_1720_HRTF_FASTCONV + float ***leftHRIRReal_HOA3; + float ***leftHRIRImag_HOA3; + float ***rightHRIRReal_HOA3; + float ***rightHRIRImag_HOA3; + + float ***leftHRIRReal; + float ***leftHRIRImag; + float ***rightHRIRReal; + float ***rightHRIRImag; + + float ***leftBRIRReal; + float ***leftBRIRImag; + float ***rightBRIRReal; + float ***rightBRIRImag; + float FASTCONV_BRIR_latency_s; - float FASTCONV_HOA3_latency_s; + float ***leftHRIRReal_HOA2; + float ***leftHRIRImag_HOA2; + float ***rightHRIRReal_HOA2; + float ***rightHRIRImag_HOA2; + float FASTCONV_HOA2_latency_s; + + float ***leftHRIRReal_FOA; + float ***leftHRIRImag_FOA; + float ***rightHRIRReal_FOA; + float ***rightHRIRImag_FOA; + float FASTCONV_FOA_latency_s; + + int16_t allocate_init_flag; /*Memory allocation flag 0: if the hrtf pointers are allocated at application level , 1: of allocated at ivas_binaural_hrtf_open() */ +#else #ifdef UPDATE_FASTCONV_SBA_FILTER float leftHRIRReal_HOA3[BINAURAL_CONVBANDS][HOA3_CHANNELS][BINAURAL_NTAPS_SBA]; float leftHRIRImag_HOA3[BINAURAL_CONVBANDS][HOA3_CHANNELS][BINAURAL_NTAPS_SBA]; @@ -1376,12 +1402,11 @@ typedef struct ivas_hrtfs_fastconv_struct float rightHRIRReal_HOA3[BINAURAL_CONVBANDS][HRTF_SH_CHANNELS][BINAURAL_NTAPS]; float rightHRIRImag_HOA3[BINAURAL_CONVBANDS][HRTF_SH_CHANNELS][BINAURAL_NTAPS]; - float FASTCONV_HOA2_latency_s; float leftHRIRReal_HOA2[BINAURAL_CONVBANDS][9][BINAURAL_NTAPS]; float leftHRIRImag_HOA2[BINAURAL_CONVBANDS][9][BINAURAL_NTAPS]; float rightHRIRReal_HOA2[BINAURAL_CONVBANDS][9][BINAURAL_NTAPS]; float rightHRIRImag_HOA2[BINAURAL_CONVBANDS][9][BINAURAL_NTAPS]; - float FASTCONV_FOA_latency_s; + float leftHRIRReal_FOA[BINAURAL_CONVBANDS][4][BINAURAL_NTAPS]; float leftHRIRImag_FOA[BINAURAL_CONVBANDS][4][BINAURAL_NTAPS]; float rightHRIRReal_FOA[BINAURAL_CONVBANDS][4][BINAURAL_NTAPS]; @@ -1393,6 +1418,12 @@ typedef struct ivas_hrtfs_fastconv_struct float rightBRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX]; float rightBRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS_MAX]; + float leftHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS]; + float leftHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS]; + float rightHRIRReal[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS]; + float rightHRIRImag[BINAURAL_CONVBANDS][HRTF_LS_CHANNELS][BINAURAL_NTAPS]; +#endif + float fastconvReverberationTimes[CLDFB_NO_CHANNELS_MAX]; float fastconvReverberationEneCorrections[CLDFB_NO_CHANNELS_MAX]; diff --git a/lib_util/hrtf_file_reader.c b/lib_util/hrtf_file_reader.c index 1488c892b50c6bcb3c44fb24b5cbd4d363f391b7..df2c5c66f30c1f67e84b5196a89e6c025cfe7a7d 100644 --- a/lib_util/hrtf_file_reader.c +++ b/lib_util/hrtf_file_reader.c @@ -35,6 +35,9 @@ #include "prot.h" #include "ivas_prot_rend.h" +#ifdef FIX_1720_HRTF_FASTCONV +#include "ivas_prot.h" +#endif /*---------------------------------------------------------------------* * Local structures @@ -1025,7 +1028,6 @@ static ivas_error init_fastconv_HRTF_handle( } } - hHrtf->FASTCONV_BRIR_latency_s = 0; for ( i = 0; i < BINAURAL_CONVBANDS; i++ ) { @@ -1054,6 +1056,10 @@ static ivas_error create_fastconv_HRTF_from_rawdata( { int16_t i, j; char *hrtf_data_rptr; +#ifdef FIX_1720_HRTF_FASTCONV + ( *hHRTF )->allocate_init_flag = 0; + ivas_allocate_binaural_hrtf( *hHRTF, 0, input_cfg, rend_type, ( *hHRTF )->allocate_init_flag ); +#endif // if ( hHRTF == NULL ) // { @@ -1164,7 +1170,6 @@ static ivas_error create_fastconv_HRTF_from_rawdata( } #endif hrtf_data_rptr += sizeof( uint16_t ); - for ( i = 0; i < BINAURAL_CONVBANDS; i++ ) { #ifdef UPDATE_FASTCONV_SBA_FILTER @@ -1231,7 +1236,6 @@ static ivas_error create_fastconv_HRTF_from_rawdata( /* HRIR_HOA2 */ ( *hHRTF )->FASTCONV_HOA2_latency_s = *( (float *) ( hrtf_data_rptr ) ); hrtf_data_rptr += sizeof( float ); - #ifdef UPDATE_FASTCONV_SBA_FILTER if ( HOA2_CHANNELS != *( (uint16_t *) ( hrtf_data_rptr ) ) ) { @@ -1324,7 +1328,6 @@ static ivas_error create_fastconv_HRTF_from_rawdata( /* HRIR_FOA */ ( *hHRTF )->FASTCONV_FOA_latency_s = *( (float *) ( hrtf_data_rptr ) ); hrtf_data_rptr += sizeof( float ); - #ifdef UPDATE_FASTCONV_SBA_FILTER if ( FOA_CHANNELS != *( (uint16_t *) ( hrtf_data_rptr ) ) ) { @@ -1523,9 +1526,9 @@ ivas_error load_fastconv_HRTF_from_binary( } /* Read & load */ - +#ifndef FIX_1720_HRTF_FASTCONV memset( hHrtfFastConv, 0x00, sizeof( HRTFS_FASTCONV ) ); - +#endif for ( hrtf_id = 0; hrtf_id < hrtfs_file_header.nb_hrtf; hrtf_id++ ) { if ( read_hrtf_binary_header( &hrtf_header, f_hrtf ) != IVAS_ERR_OK ) @@ -1533,7 +1536,23 @@ ivas_error load_fastconv_HRTF_from_binary( free( hrtf_data ); return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "HRTF binary file not compliant (number of HRTF)" ); } +#ifdef FIX_1720_HRTF_FASTCONV + if ( ( 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 ) + { + free( hrtf_data ); + return IVAS_ERROR( IVAS_ERR_FAILED_FILE_READ, "Error in HRTF file reading" ); + } + /* Create the HRTF reading the raw data from the binary file */ + if ( ( create_fastconv_HRTF_from_rawdata( &hHrtfFastConv, hrtf_data, hrtf_header.rend_type, hrtf_header.input_cfg ) ) != IVAS_ERR_OK ) + { + free( hrtf_data ); + return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Could not create HRTF from binary file" ); + } + } +#else if ( ( hrtf_header.frequency == 48000 ) && ( ( hrtf_header.rend_type == RENDERER_BINAURAL_FASTCONV ) || ( hrtf_header.rend_type == RENDERER_BINAURAL_FASTCONV_ROOM ) ) ) { @@ -1542,7 +1561,6 @@ ivas_error load_fastconv_HRTF_from_binary( free( hrtf_data ); return IVAS_ERROR( IVAS_ERR_FAILED_FILE_READ, "Error in HRTF file reading" ); } - /* Create the HRTF reading the raw data from the binary file */ if ( ( create_fastconv_HRTF_from_rawdata( &hHrtfFastConv, hrtf_data, hrtf_header.rend_type, hrtf_header.input_cfg ) ) != IVAS_ERR_OK ) { @@ -1550,6 +1568,7 @@ ivas_error load_fastconv_HRTF_from_binary( return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Could not create HRTF from binary file" ); } } +#endif else { fseek( f_hrtf, hrtf_header.data_size, SEEK_CUR ); @@ -1809,13 +1828,18 @@ ivas_error create_SetOfHRTF_from_binary( } free( hrtf_data ); - if ( ( ( *hSetOfHRTF ).hHRTF_hrir_combined == NULL ) || ( ( *hSetOfHRTF ).hHRTF_brir_combined == NULL ) || ( ( *hSetOfHRTF ).hHRTF_hrir_hoa3 == NULL ) ) { +#ifdef FIX_1720_HRTF_FASTCONV + if ( destroy_SetOfHRTF( hSetOfHRTF ) != IVAS_ERR_OK ) + { + return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Could not create all the HRTF from binary file" ); + } +#else destroy_SetOfHRTF( hSetOfHRTF ); return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Could not create all the HRTF from binary file" ); +#endif } - return IVAS_ERR_OK; }