.gitlab-ci.yml

@@ -1267,10 +1267,11 @@ test-long-self-test:
     - ivas-linux-fast
   artifacts:
     name: "$CI_JOB_NAME--main--sha-$CI_COMMIT_SHORT_SHA"
-    expire_in: 1 week
+    expire_in: 2 weeks
     when: always
     paths:
       - ep_015.g192
+      - dly_profile.dat
       - ./LOGS_PLC
       - ./LOGS_noPLC
 

.gitlab/issue_templates/sanitizer_error.md

@@ -4,7 +4,7 @@
 
 ### Bug description
 
-Clang (msan/asan?) sanitizer test in pipeline found an error:
+Clang (m,a,u)san sanitizer test in pipeline found an error:
 
 <!--- Copy sanitizer traceback from command line here -->
 ```
@@ -20,7 +20,7 @@ Using the [scripts](https://forge.3gpp.org/rep/ivas-codec-pc/ivas-codec/-/wikis/
 <!--- check correct sanitizer type -->
 <!--- add error pattern if needed -->
 ```
-python3 scripts/IvasBuildAndRunChecks.py --checks CLANGX -m MODE -p /path/to/my/local/ci_linux_ltv_local.json
+python3 scripts/IvasBuildAndRunChecks.py --checks CLANGX -m MODE -p /path/to/my/local/ci_linux_ltv_local.json --usan_supp_file scripts/ubsan.supp
 ```
 or directly:
 

apps/decoder.c

@@ -797,6 +797,18 @@ int main(
 #ifdef NONBE_FIX_BINARY_BINAURAL_READING
         if ( ( error = create_SetOfHRTF_from_binary( *hSetOfHRTF, hrtfReader, arg.output_Fs ) ) != IVAS_ERR_OK )
         {
+#ifdef FIX_OLD_BINARY_FORMAT
+            cleanup_SetOfHRTF( hSetOfHRTF );
+            hrtfFileReader_close( &hrtfReader );
+            strcat( arg.hrtfFileName, "new" );
+
+            if ( hrtfFileReader_open( arg.hrtfFileName, &hrtfReader ) != IVAS_ERR_OK )
+            {
+                fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );
+                goto cleanup;
+            }
+            if ( ( error = create_SetOfHRTF_from_binary( *hSetOfHRTF, hrtfReader, arg.output_Fs ) ) != IVAS_ERR_OK )
+            {
                 if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )
                 {
                     fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );
@@ -807,6 +819,18 @@ int main(
                     destroy_SetOfHRTF( hSetOfHRTF );
                 }
             }
+#else
+            if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )
+            {
+                fprintf( stderr, "\nError in loading HRTF binary file %s \n\n", arg.hrtfFileName );
+                goto cleanup;
+            }
+            else
+            {
+                destroy_SetOfHRTF( hSetOfHRTF );
+            }
+#endif
+        }
 #else
         if ( ( error = create_SetOfHRTF_from_binary( hSetOfHRTF, hrtfReader, arg.output_Fs ) ) != IVAS_ERR_OK )
         {

apps/renderer.c

@@ -1094,6 +1094,28 @@ int main(
 
             if ( ( error = create_SetOfHRTF_from_binary( *hSetOfHRTF, hrtfFileReader, args.sampleRate ) ) != IVAS_ERR_OK )
             {
+#ifdef FIX_OLD_BINARY_FORMAT
+                cleanup_SetOfHRTF( hSetOfHRTF );
+                hrtfFileReader_close( &hrtfFileReader );
+                strcat( args.customHrtfFilePath, "new" );
+                if ( hrtfFileReader_open( args.customHrtfFilePath, &hrtfFileReader ) != IVAS_ERR_OK )
+                {
+                    fprintf( stderr, "\nError in loading HRTF binary file %s: %s \n\n", args.customHrtfFilePath, ivas_error_to_string( error ) );
+                    goto cleanup;
+                }
+                if ( ( error = create_SetOfHRTF_from_binary( *hSetOfHRTF, hrtfFileReader, args.sampleRate ) ) != IVAS_ERR_OK )
+                {
+                    if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )
+                    {
+                        fprintf( stderr, "\nError in loading HRTF binary file %s:%s \n\n", args.customHrtfFilePath, ivas_error_to_string( error ) );
+                        goto cleanup;
+                    }
+                    else
+                    {
+                        destroy_SetOfHRTF( hSetOfHRTF );
+                    }
+                }
+#else
                 if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )
                 {
                     fprintf( stderr, "\nError in loading HRTF binary file %s:%s \n\n", args.customHrtfFilePath, ivas_error_to_string( error ) );
@@ -1103,6 +1125,7 @@ int main(
                 {
                     destroy_SetOfHRTF( hSetOfHRTF );
                 }
+#endif
             }
 
             if ( ( error = IVAS_REND_GetHrtfFastConvHandle( hIvasRend, &hHrtfFastConv ) ) != IVAS_ERR_OK )

lib_com/options.h

@@ -155,6 +155,9 @@
 #define FIX_638_ENERGIE_IAC_ROM_TABLES                  /* Orange : Missing left/right and coherence late reverb tables in binary format*/
 #define FIX_OLD_BINARY_FORMAT                           /* Orange: temporary to maintain bitexactness */
 #define FIX_WARNING_RENDER_CONFIG                       /* Orange: fix warning on windows build */
+#define FIX_WARNING_SPLIT_RENDER                        /* Orange: fix warning on windows build vscode */
+#define FIX_INV_DIFFUSE_WEIGHT                          /* Orange : Fix error in energy compensation in late binaural reverb*/
+#define FIX_20_MS_FRAME_LEN_TABLES_CONVERTER            /* Orange : generate_tables_converter tools can generate rom for 5 and 20 ms frame length */
 #define FIX_958_667_DISABLE_INITIAL_PLC_SUPPRESSION     /* Ericsson: Fix related to issue 667 in IVAS BASOP. Handling of initial lost frame in IVAS causes non-BE on EVS BASOP 26.444 */ 
 #define FIX_957_REMOVE_PANNING_DEAD_CODE                /* VA: Remove obsolete non-diegetic panning related code. */
 #define FIX_956_DECODER_COMMAND_LINE_FIX                /* VA: Output correct error message when the decoder command-line has too many mandatory arguments. */

lib_rend/ivas_rom_binaural_crend_head.h

@@ -60,7 +60,11 @@ extern uint16_t CRendBin_Combined_HRIR_num_iterations_48kHz[HRTF_LS_CHANNELS][BI
 extern uint16_t CRendBin_Combined_HRIR_num_iterations_diffuse_48kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_Combined_HRIR_pIndex_frequency_max_48kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_Combined_HRIR_index_frequency_max_diffuse_48kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_Combined_HRIR_inv_diffuse_weight_48kHz[BINAURAL_CHANNELS][HRTF_LS_CHANNELS];
+#else
 extern float CRendBin_Combined_HRIR_inv_diffuse_weight_48kHz[HRTF_LS_CHANNELS];
+#endif
 extern uint16_t *CRendBin_Combined_HRIR_pIndex_frequency_max_diffuse_48kHz[BINAURAL_CHANNELS];
 extern float CRendBin_Combined_HRIR_coeff_re_48kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][240];
 extern float CRendBin_Combined_HRIR_coeff_im_48kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][240];
@@ -74,7 +78,11 @@ extern uint16_t CRendBin_Combined_HRIR_num_iterations_32kHz[HRTF_LS_CHANNELS][BI
 extern uint16_t CRendBin_Combined_HRIR_num_iterations_diffuse_32kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_Combined_HRIR_pIndex_frequency_max_32kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_Combined_HRIR_index_frequency_max_diffuse_32kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_Combined_HRIR_inv_diffuse_weight_32kHz[BINAURAL_CHANNELS][HRTF_LS_CHANNELS];
+#else
 extern float CRendBin_Combined_HRIR_inv_diffuse_weight_32kHz[HRTF_LS_CHANNELS];
+#endif
 extern uint16_t *CRendBin_Combined_HRIR_pIndex_frequency_max_diffuse_32kHz[BINAURAL_CHANNELS];
 extern float CRendBin_Combined_HRIR_coeff_re_32kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][160];
 extern float CRendBin_Combined_HRIR_coeff_im_32kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][160];
@@ -88,7 +96,11 @@ extern uint16_t CRendBin_Combined_HRIR_num_iterations_16kHz[HRTF_LS_CHANNELS][BI
 extern uint16_t CRendBin_Combined_HRIR_num_iterations_diffuse_16kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_Combined_HRIR_pIndex_frequency_max_16kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_Combined_HRIR_index_frequency_max_diffuse_16kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_Combined_HRIR_inv_diffuse_weight_16kHz[BINAURAL_CHANNELS][HRTF_LS_CHANNELS];
+#else
 extern float CRendBin_Combined_HRIR_inv_diffuse_weight_16kHz[HRTF_LS_CHANNELS];
+#endif
 extern uint16_t *CRendBin_Combined_HRIR_pIndex_frequency_max_diffuse_16kHz[BINAURAL_CHANNELS];
 extern float CRendBin_Combined_HRIR_coeff_re_16kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][80];
 extern float CRendBin_Combined_HRIR_coeff_im_16kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][80];
@@ -108,7 +120,11 @@ extern uint16_t CRendBin_FOA_HRIR_num_iterations_48kHz[FOA_CHANNELS][BINAURAL_CH
 extern uint16_t CRendBin_FOA_HRIR_num_iterations_diffuse_48kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_FOA_HRIR_pIndex_frequency_max_48kHz[FOA_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_FOA_HRIR_index_frequency_max_diffuse_48kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_FOA_HRIR_inv_diffuse_weight_48kHz[BINAURAL_CHANNELS][FOA_CHANNELS];
+#else
 extern float CRendBin_FOA_HRIR_inv_diffuse_weight_48kHz[FOA_CHANNELS];
+#endif
 extern uint16_t *CRendBin_FOA_HRIR_pIndex_frequency_max_diffuse_48kHz[BINAURAL_CHANNELS];
 extern float CRendBin_FOA_HRIR_coeff_re_48kHz[FOA_CHANNELS][BINAURAL_CHANNELS][240];
 extern float CRendBin_FOA_HRIR_coeff_im_48kHz[FOA_CHANNELS][BINAURAL_CHANNELS][240];
@@ -122,7 +138,11 @@ extern uint16_t CRendBin_FOA_HRIR_num_iterations_32kHz[FOA_CHANNELS][BINAURAL_CH
 extern uint16_t CRendBin_FOA_HRIR_num_iterations_diffuse_32kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_FOA_HRIR_pIndex_frequency_max_32kHz[FOA_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_FOA_HRIR_index_frequency_max_diffuse_32kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_FOA_HRIR_inv_diffuse_weight_32kHz[BINAURAL_CHANNELS][FOA_CHANNELS];
+#else
 extern float CRendBin_FOA_HRIR_inv_diffuse_weight_32kHz[FOA_CHANNELS];
+#endif
 extern uint16_t *CRendBin_FOA_HRIR_pIndex_frequency_max_diffuse_32kHz[BINAURAL_CHANNELS];
 extern float CRendBin_FOA_HRIR_coeff_re_32kHz[FOA_CHANNELS][BINAURAL_CHANNELS][160];
 extern float CRendBin_FOA_HRIR_coeff_im_32kHz[FOA_CHANNELS][BINAURAL_CHANNELS][160];
@@ -136,7 +156,11 @@ extern uint16_t CRendBin_FOA_HRIR_num_iterations_16kHz[FOA_CHANNELS][BINAURAL_CH
 extern uint16_t CRendBin_FOA_HRIR_num_iterations_diffuse_16kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_FOA_HRIR_pIndex_frequency_max_16kHz[FOA_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_FOA_HRIR_index_frequency_max_diffuse_16kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_FOA_HRIR_inv_diffuse_weight_16kHz[BINAURAL_CHANNELS][FOA_CHANNELS];
+#else
 extern float CRendBin_FOA_HRIR_inv_diffuse_weight_16kHz[FOA_CHANNELS];
+#endif
 extern uint16_t *CRendBin_FOA_HRIR_pIndex_frequency_max_diffuse_16kHz[BINAURAL_CHANNELS];
 extern float CRendBin_FOA_HRIR_coeff_re_16kHz[FOA_CHANNELS][BINAURAL_CHANNELS][80];
 extern float CRendBin_FOA_HRIR_coeff_im_16kHz[FOA_CHANNELS][BINAURAL_CHANNELS][80];
@@ -156,7 +180,11 @@ extern uint16_t CRendBin_HOA2_HRIR_num_iterations_48kHz[HOA2_CHANNELS][BINAURAL_
 extern uint16_t CRendBin_HOA2_HRIR_num_iterations_diffuse_48kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_HOA2_HRIR_pIndex_frequency_max_48kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_HOA2_HRIR_index_frequency_max_diffuse_48kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_HOA2_HRIR_inv_diffuse_weight_48kHz[BINAURAL_CHANNELS][HOA2_CHANNELS];
+#else
 extern float CRendBin_HOA2_HRIR_inv_diffuse_weight_48kHz[HOA2_CHANNELS];
+#endif
 extern uint16_t *CRendBin_HOA2_HRIR_pIndex_frequency_max_diffuse_48kHz[BINAURAL_CHANNELS];
 extern float CRendBin_HOA2_HRIR_coeff_re_48kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][240];
 extern float CRendBin_HOA2_HRIR_coeff_im_48kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][240];
@@ -170,7 +198,11 @@ extern uint16_t CRendBin_HOA2_HRIR_num_iterations_32kHz[HOA2_CHANNELS][BINAURAL_
 extern uint16_t CRendBin_HOA2_HRIR_num_iterations_diffuse_32kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_HOA2_HRIR_pIndex_frequency_max_32kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_HOA2_HRIR_index_frequency_max_diffuse_32kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_HOA2_HRIR_inv_diffuse_weight_32kHz[BINAURAL_CHANNELS][HOA2_CHANNELS];
+#else
 extern float CRendBin_HOA2_HRIR_inv_diffuse_weight_32kHz[HOA2_CHANNELS];
+#endif
 extern uint16_t *CRendBin_HOA2_HRIR_pIndex_frequency_max_diffuse_32kHz[BINAURAL_CHANNELS];
 extern float CRendBin_HOA2_HRIR_coeff_re_32kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][160];
 extern float CRendBin_HOA2_HRIR_coeff_im_32kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][160];
@@ -184,7 +216,11 @@ extern uint16_t CRendBin_HOA2_HRIR_num_iterations_16kHz[HOA2_CHANNELS][BINAURAL_
 extern uint16_t CRendBin_HOA2_HRIR_num_iterations_diffuse_16kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_HOA2_HRIR_pIndex_frequency_max_16kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_HOA2_HRIR_index_frequency_max_diffuse_16kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_HOA2_HRIR_inv_diffuse_weight_16kHz[BINAURAL_CHANNELS][HOA2_CHANNELS];
+#else
 extern float CRendBin_HOA2_HRIR_inv_diffuse_weight_16kHz[HOA2_CHANNELS];
+#endif
 extern uint16_t *CRendBin_HOA2_HRIR_pIndex_frequency_max_diffuse_16kHz[BINAURAL_CHANNELS];
 extern float CRendBin_HOA2_HRIR_coeff_re_16kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][80];
 extern float CRendBin_HOA2_HRIR_coeff_im_16kHz[HOA2_CHANNELS][BINAURAL_CHANNELS][80];
@@ -204,7 +240,11 @@ extern uint16_t CRendBin_HOA3_HRIR_num_iterations_48kHz[HOA3_CHANNELS][BINAURAL_
 extern uint16_t CRendBin_HOA3_HRIR_num_iterations_diffuse_48kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_HOA3_HRIR_pIndex_frequency_max_48kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_HOA3_HRIR_index_frequency_max_diffuse_48kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_HOA3_HRIR_inv_diffuse_weight_48kHz[BINAURAL_CHANNELS][HOA3_CHANNELS];
+#else
 extern float CRendBin_HOA3_HRIR_inv_diffuse_weight_48kHz[HOA3_CHANNELS];
+#endif
 extern uint16_t *CRendBin_HOA3_HRIR_pIndex_frequency_max_diffuse_48kHz[BINAURAL_CHANNELS];
 extern float CRendBin_HOA3_HRIR_coeff_re_48kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][240];
 extern float CRendBin_HOA3_HRIR_coeff_im_48kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][240];
@@ -218,7 +258,11 @@ extern uint16_t CRendBin_HOA3_HRIR_num_iterations_32kHz[HOA3_CHANNELS][BINAURAL_
 extern uint16_t CRendBin_HOA3_HRIR_num_iterations_diffuse_32kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_HOA3_HRIR_pIndex_frequency_max_32kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_HOA3_HRIR_index_frequency_max_diffuse_32kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_HOA3_HRIR_inv_diffuse_weight_32kHz[BINAURAL_CHANNELS][HOA3_CHANNELS];
+#else
 extern float CRendBin_HOA3_HRIR_inv_diffuse_weight_32kHz[HOA3_CHANNELS];
+#endif
 extern uint16_t *CRendBin_HOA3_HRIR_pIndex_frequency_max_diffuse_32kHz[BINAURAL_CHANNELS];
 extern float CRendBin_HOA3_HRIR_coeff_re_32kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][160];
 extern float CRendBin_HOA3_HRIR_coeff_im_32kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][160];
@@ -232,7 +276,11 @@ extern uint16_t CRendBin_HOA3_HRIR_num_iterations_16kHz[HOA3_CHANNELS][BINAURAL_
 extern uint16_t CRendBin_HOA3_HRIR_num_iterations_diffuse_16kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_HOA3_HRIR_pIndex_frequency_max_16kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][1];
 extern uint16_t CRendBin_HOA3_HRIR_index_frequency_max_diffuse_16kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_HOA3_HRIR_inv_diffuse_weight_16kHz[BINAURAL_CHANNELS][HOA3_CHANNELS];
+#else
 extern float CRendBin_HOA3_HRIR_inv_diffuse_weight_16kHz[HOA3_CHANNELS];
+#endif
 extern uint16_t *CRendBin_HOA3_HRIR_pIndex_frequency_max_diffuse_16kHz[BINAURAL_CHANNELS];
 extern float CRendBin_HOA3_HRIR_coeff_re_16kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][80];
 extern float CRendBin_HOA3_HRIR_coeff_im_16kHz[HOA3_CHANNELS][BINAURAL_CHANNELS][80];
@@ -252,7 +300,11 @@ extern uint16_t CRendBin_Combined_BRIR_num_iterations_48kHz[HRTF_LS_CHANNELS][BI
 extern uint16_t CRendBin_Combined_BRIR_num_iterations_diffuse_48kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_Combined_BRIR_pIndex_frequency_max_48kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][22];
 extern uint16_t CRendBin_Combined_BRIR_index_frequency_max_diffuse_48kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_Combined_BRIR_inv_diffuse_weight_48kHz[BINAURAL_CHANNELS][HRTF_LS_CHANNELS];
+#else
 extern float CRendBin_Combined_BRIR_inv_diffuse_weight_48kHz[HRTF_LS_CHANNELS];
+#endif
 extern uint16_t CRendBin_Combined_BRIR_pIndex_frequency_max_diffuse_48kHz[BINAURAL_CHANNELS][40];
 extern float CRendBin_Combined_BRIR_coeff_re_48kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][2955];
 extern float CRendBin_Combined_BRIR_coeff_im_48kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][2955];
@@ -266,7 +318,11 @@ extern uint16_t CRendBin_Combined_BRIR_num_iterations_32kHz[HRTF_LS_CHANNELS][BI
 extern uint16_t CRendBin_Combined_BRIR_num_iterations_diffuse_32kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_Combined_BRIR_pIndex_frequency_max_32kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][22];
 extern uint16_t CRendBin_Combined_BRIR_index_frequency_max_diffuse_32kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_Combined_BRIR_inv_diffuse_weight_32kHz[BINAURAL_CHANNELS][HRTF_LS_CHANNELS];
+#else
 extern float CRendBin_Combined_BRIR_inv_diffuse_weight_32kHz[HRTF_LS_CHANNELS];
+#endif
 extern uint16_t CRendBin_Combined_BRIR_pIndex_frequency_max_diffuse_32kHz[BINAURAL_CHANNELS][40];
 extern float CRendBin_Combined_BRIR_coeff_re_32kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][2818];
 extern float CRendBin_Combined_BRIR_coeff_im_32kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][2818];
@@ -280,7 +336,11 @@ extern uint16_t CRendBin_Combined_BRIR_num_iterations_16kHz[HRTF_LS_CHANNELS][BI
 extern uint16_t CRendBin_Combined_BRIR_num_iterations_diffuse_16kHz[BINAURAL_CHANNELS];
 extern uint16_t CRendBin_Combined_BRIR_pIndex_frequency_max_16kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][23];
 extern uint16_t CRendBin_Combined_BRIR_index_frequency_max_diffuse_16kHz;
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+extern float CRendBin_Combined_BRIR_inv_diffuse_weight_16kHz[BINAURAL_CHANNELS][HRTF_LS_CHANNELS];
+#else
 extern float CRendBin_Combined_BRIR_inv_diffuse_weight_16kHz[HRTF_LS_CHANNELS];
+#endif
 extern uint16_t CRendBin_Combined_BRIR_pIndex_frequency_max_diffuse_16kHz[BINAURAL_CHANNELS][40];
 extern float CRendBin_Combined_BRIR_coeff_re_16kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][1799];
 extern float CRendBin_Combined_BRIR_coeff_im_16kHz[HRTF_LS_CHANNELS][BINAURAL_CHANNELS][1799];

lib_rend/ivas_stat_rend.h

@@ -1201,7 +1201,12 @@ typedef struct ivas_hrtfs_structure
 #ifdef NONBE_FIX_BINARY_BINAURAL_READING
     int16_t init_from_rom;
 #endif
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+    float inv_diffuse_weight[BINAURAL_CHANNELS][MAX_INTERN_CHANNELS]; /* inverse diffuse weights array, access one inverse weight by pInvDiffuseWeight[channel] */
+    int16_t same_inv_diffuse_weight;
+#else
     float inv_diffuse_weight[MAX_INTERN_CHANNELS]; /* inverse diffuse weights array, access one inverse weight by pInvDiffuseWeight[channel] */
+#endif
     float gain_lfe;
 
 } HRTFS_DATA, *HRTFS_HANDLE;
@@ -1212,8 +1217,13 @@ typedef struct ivas_crend_state_t
 {
     float *freq_buffer_re[MAX_INTERN_CHANNELS];
     float *freq_buffer_im[MAX_INTERN_CHANNELS];
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+    float *freq_buffer_re_diffuse[BINAURAL_CHANNELS];
+    float *freq_buffer_im_diffuse[BINAURAL_CHANNELS];
+#else
     float *freq_buffer_re_diffuse;
     float *freq_buffer_im_diffuse;
+#endif
     float *prev_out_buffer[BINAURAL_CHANNELS];
     float *lfe_delay_line;
     float m_fYaw;

lib_rend/lib_rend.c

@@ -2880,7 +2880,13 @@ static ivas_error setRendInputActiveSplitPostRend(
 #ifdef NONBE_FIX_BINARY_BINAURAL_READING
     ,
 #if defined _MSC_VER && !defined __clang__
+#ifdef _MSC_VER
+#pragma warning( disable : 4100 )
+#endif
     hrtf_handles *hrtfs
+#ifdef _MSC_VER
+#pragma warning( default : 4100 )
+#endif
 #else
     hrtf_handles *hrtfs __attribute__( ( unused ) ) /* avoid unused parameter warning when compiling with clang */
 #endif

lib_util/hrtf_file_reader.c

@@ -929,7 +929,7 @@ static void HRTF_energy_sections_precalc(
 
 #ifdef NONBE_FIX_BINARY_BINAURAL_READING
 /*---------------------------------------------------------------------*
- * dealloc_HRTF_binary()
+ * destroy_td_hrtf()
  *
  * Deallocated memory allocated by load_HRTF_binary
  *---------------------------------------------------------------------*/
@@ -1190,11 +1190,36 @@ static ivas_error create_HRTF_from_rawdata(
     hrtf_data_rptr += sizeof( uint16_t );
 
     /* inv_diffuse_weight */
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+    for ( i = 0; i < ( *hHRTF )->max_num_ir; i++ )
+    {
+        ( *hHRTF )->inv_diffuse_weight[0][i] = *( (float *) ( hrtf_data_rptr ) );
+        hrtf_data_rptr += sizeof( float );
+    }
+    for ( i = 0; i < ( *hHRTF )->max_num_ir; i++ )
+    {
+        ( *hHRTF )->inv_diffuse_weight[1][i] = *( (float *) ( hrtf_data_rptr ) );
+        hrtf_data_rptr += sizeof( float );
+    }
+#else
     for ( i = 0; i < ( *hHRTF )->max_num_ir; i++ )
     {
         ( *hHRTF )->inv_diffuse_weight[i] = *( (float *) ( hrtf_data_rptr ) );
         hrtf_data_rptr += sizeof( float );
     }
+#endif
+
+#ifdef FIX_OLD_BINARY_FORMAT
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+    for ( i = 0; i < ( *hHRTF )->max_num_ir; i++ )
+    {
+        if ( ( *hHRTF )->inv_diffuse_weight[1][i] != ( *hHRTF )->inv_diffuse_weight[0][i] )
+        {
+            return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "HRTF binary file format not compliant (BINAURAL_CHANNELS)" );
+        }
+    }
+#endif
+#endif
 
     /* max_total_num_fsamp_per_iteration */
     max_total_num_fsamp_per_iteration = *( (uint16_t *) ( hrtf_data_rptr ) );
@@ -2004,6 +2029,7 @@ ivas_error create_SetOfHRTF_from_binary(
     {
         if ( read_hrtf_binary_header( &hrtf_header, f_hrtf ) != IVAS_ERR_OK )
         {
+            free( hrtf_data );
             return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "HRTF binary file not compliant (number of HRTF)" );
         }
 
@@ -2048,6 +2074,7 @@ ivas_error create_SetOfHRTF_from_binary(
 
         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" );
         }
 
@@ -2056,6 +2083,7 @@ ivas_error create_SetOfHRTF_from_binary(
             /* Create the HRTF reading the raw data from the binary file */
             if ( ( create_HRTF_from_rawdata( hHRTF, hrtf_data ) ) != IVAS_ERR_OK )
             {
+                free( hrtf_data );
                 return IVAS_ERROR( IVAS_ERR_INTERNAL_FATAL, "Could not create HRTF from binary file" );
             }
         }
@@ -2144,13 +2172,36 @@ static ivas_error destroy_HRTF(
 }
 
 
+#ifdef NONBE_FIX_BINARY_BINAURAL_READING
 /*---------------------------------------------------------------------*
  * destroy_SetOfHRTF()
  *
  * Destroy the HRTF data set.
  *---------------------------------------------------------------------*/
+#ifdef FIX_OLD_BINARY_FORMAT
+/*---------------------------------------------------------------------*
+ * cleanup_SetOfHRTF()
+ *
+ * Destroy the HRTF data set.
+ *---------------------------------------------------------------------*/
+
+void cleanup_SetOfHRTF(
+    HRTFS_CREND_HANDLE *hSetOfHRTF /* i/o: Set of HRTF CRend handle */
+)
+{
+    if ( ( hSetOfHRTF != NULL ) && ( *hSetOfHRTF != NULL ) )
+    {
+        destroy_HRTF( &( ( *hSetOfHRTF )->hHRTF_hrir_combined ) );
+        destroy_HRTF( &( ( *hSetOfHRTF )->hHRTF_hrir_hoa3 ) );
+        destroy_HRTF( &( ( *hSetOfHRTF )->hHRTF_hrir_hoa2 ) );
+        destroy_HRTF( &( ( *hSetOfHRTF )->hHRTF_hrir_foa ) );
+        destroy_HRTF( &( ( *hSetOfHRTF )->hHRTF_brir_combined ) );
+    }
+
+    return;
+}
+#endif
 
-#ifdef NONBE_FIX_BINARY_BINAURAL_READING
 void destroy_SetOfHRTF(
     HRTFS_CREND_HANDLE *hSetOfHRTF /* i/o: Set of HRTF CRend handle */
 )

lib_util/hrtf_file_reader.h

@@ -117,6 +117,17 @@ ivas_error create_SetOfHRTF_from_binary(
     int32_t output_Fs                      /* i  : Output sampling frequency            */
 );
 
+#ifdef FIX_OLD_BINARY_FORMAT
+/*---------------------------------------------------------------------*
+ * cleanup_SetOfHRTF()
+ *
+ * Destroy the HRTF data set.
+ *---------------------------------------------------------------------*/
+
+void cleanup_SetOfHRTF(
+    IVAS_DEC_HRTF_CREND_HANDLE *hSetOfHRTF /* i/o: Set of HRTF CRend handle */
+);
+#endif
 
 /*---------------------------------------------------------------------*
  * destroy_SetOfHRTF()

lib_util/split_render_file_read_write.c

@@ -298,7 +298,11 @@ ivas_error split_rend_read_bits_from_file(
         return IVAS_ERR_FAILED_FILE_READ;
     }
 
+#ifdef FIX_WARNING_SPLIT_RENDER
+    header_len = (int32_t) strlen( header );
+#else
     header_len = strlen( header );
+#endif
 
     /* read frame header */
     for ( i = 0; i < header_len; i++ )

scripts/IvasBuildAndRunChecks.py

@@ -120,6 +120,11 @@ class IvasBuildAndRunChecks(IvasScriptsCommon.IvasScript):
         else:
             checks = self.args["checks"]
 
+        usan_supp_file = None
+        # need to convert to abs path as runtime dir will be different from calling dir
+        if self.args["usan_supp_file"] is not None:
+            usan_supp_file = os.path.abspath(self.args["usan_supp_file"])
+
         if self.args["svn"]:
             br = IvasBuilderAndRunner.fromSvn(
                 self.args["svn"],
@@ -161,7 +166,7 @@ class IvasBuildAndRunChecks(IvasScriptsCommon.IvasScript):
                     format_select_list=modes,
                     formats_fname=self.args["format_file"],
                     max_workers=self.args["max_workers"],
-                    usan_supp_file=self.args["usan_supp_file"],
+                    usan_supp_file=usan_supp_file,
                 )
             IvasScriptsCommon.runner_setup(
                 br.build_and_run_dict[check]["runner"], self.args

scripts/binauralRenderer_interface/Table_Format_Converter/generate_tables_from_rom_to_bin.c

@@ -2346,7 +2346,11 @@ int16_t check_hrtf_data( RENDERER_TYPE rend_type, BINAURAL_INPUT_AUDIO_CONFIG in
     hrtf_data_in_rptr += sizeof( uint16_t );
 
     // inv_diffuse_weight
+#ifdef FIX_INV_DIFFUSE_WEIGHT
+    ctrl_size = tabs_dims.max_num_ir * BINAURAL_CHANNELS * sizeof( float );
+#else
     ctrl_size = tabs_dims.max_num_ir * sizeof( float );
+#endif
     if ( memcmp( tabs_ptrs.inv_diffuse_weight, hrtf_data_in_rptr, ctrl_size ) != 0 )
     {
         fprintf( stderr, "check_hrtf_data of binary file failed: bad inv_diffuse_weight!\n\n" );