diff --git a/apps/decoder.c b/apps/decoder.c
index f6b55ba00f5851cf9aa35d911047ba98f45b2059..28ad8fe7cbb50aef461f50c155047a7a2418f318 100644
--- a/apps/decoder.c
+++ b/apps/decoder.c
@@ -159,10 +159,11 @@ typedef struct
     hrtfFileReader *hrtfReader;
     char *hrtfFileName;
 
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     IVAS_DEC_HRTF_TD_HANDLE *hHrtfTD;
 
     IVAS_DEC_HRTF_STATISTICS_HANDLE *hHrtfStatistics;
-
+#endif
     IVAS_BIN_RENDERER_TYPE binaural_renderer;
     IVAS_BIN_RENDERER_TYPE binaural_renderer_old;
     IVAS_BIN_RENDERER_TYPE binaural_renderer_sec;
@@ -242,9 +243,10 @@ int main(
     enable_float_exception_trap( FLE_MASK_DENORM | FLE_MASK_UNDERFLOW );
 #endif
 
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     hHrtfBinary.hHrtfTD = NULL;         /* just to avoid compilation warning */
     hHrtfBinary.hHrtfStatistics = NULL; /* just to avoid compilation warning */
-
+#endif
     splitRendBits.bits_buf = splitRendBitsBuf;
 
     /*------------------------------------------------------------------------------------------*
@@ -849,11 +851,13 @@ cleanup:
     IVAS_DEC_GetSbaDebugParams( hIvasDec, &numOutChannels, &numTransportChannels, &pca_ingest_channels );
 
 #endif
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     if ( arg.hrtfReaderEnabled )
     {
         destroy_td_hrtf( hHrtfBinary.hHrtfTD );
         destroy_hrtf_statistics( hHrtfBinary.hHrtfStatistics );
     }
+#endif
 
     IVAS_DEC_Close( &hIvasDec );
     CustomLsReader_close( &hLsCustomReader );
@@ -4147,11 +4151,12 @@ static ivas_error load_hrtf_from_file(
          * Release HRTF binary data
          *------------------------------------------------------------------------------------------*/
 
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
         if ( !( binaural_renderer == IVAS_BIN_RENDERER_TYPE_TDREND || binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT ) && binaural_renderer_sec != IVAS_BIN_RENDERER_TYPE_TDREND && hHrtfBinary->hHrtfTD != NULL )
         {
             destroy_td_hrtf( hHrtfBinary->hHrtfTD );
         }
-
+#endif
         if ( ( error = IVAS_DEC_HRTF_binary_close( hIvasDec, hHrtfBinary->binaural_renderer_old ) ) != IVAS_ERR_OK )
         {
             return error;
@@ -4173,13 +4178,23 @@ static ivas_error load_hrtf_from_file(
 
         if ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_TDREND || binaural_renderer_sec == IVAS_BIN_RENDERER_TYPE_TDREND || binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT )
         {
+
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            IVAS_DEC_HRTF_TD_HANDLE *hHrtfTD = NULL;
+            if ( ( error = IVAS_DEC_GetHrtfTDrendHandle( hIvasDec, &hHrtfTD ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = IVAS_DEC_GetHrtfTDrendHandle( hIvasDec, &hHrtfBinary->hHrtfTD ) ) != IVAS_ERR_OK )
+#endif
             {
                 fprintf( stderr, "\nIVAS_DEC_GetHrtfTDrendHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );
                 return error;
             }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            if ( ( error = load_TDrend_HRTF_binary( *hHrtfTD, output_Fs, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = load_TDrend_HRTF_binary( *hHrtfBinary->hHrtfTD, output_Fs, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )
+#endif
             {
                 if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )
                 {
@@ -4188,7 +4203,11 @@ static ivas_error load_hrtf_from_file(
                 }
                 else
                 {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+                    destroy_td_hrtf( hHrtfTD );
+#else
                     destroy_td_hrtf( hHrtfBinary->hHrtfTD );
+#endif
                 }
             }
         }
@@ -4261,17 +4280,32 @@ static ivas_error load_hrtf_from_file(
                 }
             }
         }
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     }
+#endif
 
-    if ( hHrtfBinary->hHrtfStatistics == NULL && ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_FASTCONV || binaural_renderer == IVAS_BIN_RENDERER_TYPE_CREND ) && OutputConfig == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    if ( ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_FASTCONV || binaural_renderer == IVAS_BIN_RENDERER_TYPE_CREND ) && OutputConfig == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
+#else
+        if ( hHrtfBinary->hHrtfStatistics == NULL && ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_FASTCONV || binaural_renderer == IVAS_BIN_RENDERER_TYPE_CREND ) && OutputConfig == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
+#endif
     {
-        if ( ( error = IVAS_DEC_GetHrtfStatisticsHandle( hIvasDec, &hHrtfBinary->hHrtfStatistics ) ) != IVAS_ERR_OK )
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+        IVAS_DEC_HRTF_STATISTICS_HANDLE *hHrtfStatistics = NULL;
+        if ( ( error = IVAS_DEC_GetHrtfStatisticsHandle( hIvasDec, &hHrtfStatistics ) ) != IVAS_ERR_OK )
+#else
+            if ( ( error = IVAS_DEC_GetHrtfStatisticsHandle( hIvasDec, &hHrtfBinary->hHrtfStatistics ) ) != IVAS_ERR_OK )
+#endif
         {
             fprintf( stderr, "\nIVAS_DEC_GetHrtfStatisticsHandle failed: %s\n\n", IVAS_DEC_GetErrorMessage( error ) );
             return error;
         }
 
-        if ( ( error = load_reverb_binary( *hHrtfBinary->hHrtfStatistics, output_Fs, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+        if ( ( error = load_reverb_binary( *hHrtfStatistics, output_Fs, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )
+#else
+            if ( ( error = load_reverb_binary( *hHrtfBinary->hHrtfStatistics, output_Fs, hHrtfBinary->hrtfReader ) ) != IVAS_ERR_OK )
+#endif
         {
             if ( error != IVAS_ERR_BINARY_FILE_WITHOUT_BINAURAL_RENDERER_DATA )
             {
@@ -4280,12 +4314,19 @@ static ivas_error load_hrtf_from_file(
             }
             else
             {
-                destroy_hrtf_statistics( hHrtfBinary->hHrtfStatistics );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+                destroy_hrtf_statistics( hHrtfStatistics );
+#else
+                    destroy_hrtf_statistics( hHrtfBinary->hHrtfStatistics );
+#endif
             }
         }
     }
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+}
+#endif
 
-    return IVAS_ERR_OK;
+return IVAS_ERR_OK;
 }
 
 
diff --git a/apps/renderer.c b/apps/renderer.c
index 491433d645a25ba2da700da30c92c9187391f336..10a9ab958947d8feafa20b77fafde021a3105185 100644
--- a/apps/renderer.c
+++ b/apps/renderer.c
@@ -2082,8 +2082,10 @@ cleanup:
     RotationFileReader_close( &referenceRotReader );
 
     Vector3PairFileReader_close( &referenceVectorReader );
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     destroy_td_hrtf( hHrtfTD );
     destroy_hrtf_statistics( hHrtfStatistics );
+#endif
     IVAS_REND_Close( &hIvasRend );
     IsmPositionProvider_close( positionProvider );
     RenderConfigReader_close( &renderConfigReader );
diff --git a/lib_com/options.h b/lib_com/options.h
index fc3d5173a82f8f79fefbdca257ef0af5236f60b2..767286f6ae81c5fa970ead4c08182f92e68ee548 100644
--- a/lib_com/options.h
+++ b/lib_com/options.h
@@ -172,6 +172,7 @@
 #define FIX_2287_MCT_MDCT_STEREO_DATA_MALLOC_SIZE       /* FhG: correct allocation size for STEREO_MDCT_DEC_DATA struct */
 #define FIX_2271_OOB_INDEXING_IN_PIT_OL2                /* VA: Fix for issue 2271, to silence clang18 */
 #define FIX_2273_OOB_INDEXING_IN_PIT_FR4                /* VA: Fix to silence clang on ptr init */
+#define FIX_2249_MEMORY_LEAK_IN_SBA                     /* OR : issue 2249 : Memory leak in SBA to BINAURAL_ROOM_REVERB with memory instrumentation */
 
 /* #################### End BE switches ################################## */
 
diff --git a/lib_dec/ivas_init_dec.c b/lib_dec/ivas_init_dec.c
index a3d954ef2f3d770751f34017e087449b914f5d1f..bb3326de18c3b02092a20b73920d950b0ad49c39 100644
--- a/lib_dec/ivas_init_dec.c
+++ b/lib_dec/ivas_init_dec.c
@@ -1500,11 +1500,17 @@ ivas_error ivas_init_decoder(
 
     if ( st_ivas->hOutSetup.output_config == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
     {
-        /* Init HRTF statistics */
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+        if ( ( error = ivas_reverb_HRTF_statistics_open( &( st_ivas->hHrtfStatistics ), output_Fs ) ) != IVAS_ERR_OK )
+        {
+            return error;
+        }
+#else
         if ( ( error = ivas_HRTF_statistics_init( &st_ivas->hHrtfStatistics, output_Fs ) ) != IVAS_ERR_OK )
         {
             return error;
         }
+#endif
 
         /* Get default reverb values based on format, if custom values were not given */
         if ( st_ivas->hDecoderConfig->Opt_RendConfigCustom == 0 )
@@ -2983,6 +2989,10 @@ void ivas_destroy_dec(
     ivas_combined_orientation_close( &st_ivas->hCombinedOrientationData );
 
     /* Time Domain binaural renderer handle */
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_td_binaural_close( &st_ivas->hBinRendererTd );
+    ivas_HRTF_td_binary_close( &st_ivas->hHrtfTD );
+#else
     if ( st_ivas->hBinRendererTd != NULL )
     {
         ivas_td_binaural_close( &st_ivas->hBinRendererTd );
@@ -2991,15 +3001,17 @@ void ivas_destroy_dec(
     if ( st_ivas->hHrtfTD != NULL )
     {
         BSplineModelEvalDealloc( &st_ivas->hHrtfTD->ModelParams, &st_ivas->hHrtfTD->ModelEval );
-
         ivas_HRTF_binary_close( &st_ivas->hHrtfTD );
     }
+#endif
 
     /* CRend binaural renderer handle */
     ivas_HRTF_CRend_binary_close( &st_ivas->hHrtfCrend );
 
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     /* Fastconv HRTF memories */
     ivas_binaural_hrtf_close( &st_ivas->hHrtfFastConv );
+#endif
 
     /* Fastconv HRTF filters */
     ivas_HRTF_fastconv_binary_close( &st_ivas->hHrtfFastConv );
@@ -3008,7 +3020,11 @@ void ivas_destroy_dec(
     ivas_HRTF_parambin_binary_close( &st_ivas->hHrtfParambin );
 
     /* HRTF statistics */
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_statistics_binary_close( &st_ivas->hHrtfStatistics );
+#else
     ivas_HRTF_statistics_close( &st_ivas->hHrtfStatistics );
+#endif
 
     /* Config. Renderer */
     ivas_render_config_close( &( st_ivas->hRenderConfig ) );
diff --git a/lib_dec/lib_dec.c b/lib_dec/lib_dec.c
index 17342a454a8dbd8c28acdf6ade2e3088f8eb1236..3a4a45d15d2d6c5ed3f0bad507264bd3582a838e 100644
--- a/lib_dec/lib_dec.c
+++ b/lib_dec/lib_dec.c
@@ -2950,7 +2950,11 @@ ivas_error IVAS_DEC_HRTF_binary_open(
         /* TD binaural renderer */
         if ( ( binaural_renderer == IVAS_BIN_RENDERER_TYPE_TDREND || binaural_renderer == IVAS_BIN_RENDERER_TYPE_DEFAULT ) && st_ivas->hHrtfTD == NULL )
         {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            if ( ( error = ivas_HRTF_td_binary_open( &( st_ivas->hHrtfTD ) ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = ivas_HRTF_binary_open( &( st_ivas->hHrtfTD ) ) ) != IVAS_ERR_OK )
+#endif
             {
                 return error;
             }
@@ -3020,7 +3024,11 @@ ivas_error IVAS_DEC_HRTF_binary_close(
     {
         if ( !( binaural_renderer_old == IVAS_BIN_RENDERER_TYPE_TDREND || binaural_renderer_old == IVAS_BIN_RENDERER_TYPE_DEFAULT ) )
         {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            ivas_HRTF_td_binary_close( &st_ivas->hHrtfTD );
+#else
             ivas_HRTF_binary_close( &st_ivas->hHrtfTD );
+#endif
         }
 
         if ( !( binaural_renderer_old == IVAS_BIN_RENDERER_TYPE_CREND || binaural_renderer_old == IVAS_BIN_RENDERER_TYPE_DEFAULT ) )
@@ -3031,9 +3039,10 @@ ivas_error IVAS_DEC_HRTF_binary_close(
 
         if ( !( binaural_renderer_old == IVAS_BIN_RENDERER_TYPE_FASTCONV || binaural_renderer_old == IVAS_BIN_RENDERER_TYPE_DEFAULT ) )
         {
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
             /* 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_crend.c b/lib_rend/ivas_crend.c
index 5341118e3c2aafe6cbbcb2f4563392eb06930e1b..2eef3f723ca7c84e40471c3409dbe593d321067f 100644
--- a/lib_rend/ivas_crend.c
+++ b/lib_rend/ivas_crend.c
@@ -138,7 +138,6 @@ static ivas_error ivas_hrtf_open(
     return IVAS_ERR_OK;
 }
 
-
 /*-------------------------------------------------------------------------
  * ivas_hrtf_close()
  *
@@ -1477,7 +1476,10 @@ void ivas_rend_closeCldfbRend(
     }
 
     ivas_binRenderer_close( &pCldfbRend->hCldfbRend );
+
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     ivas_binaural_hrtf_close( &pCldfbRend->hHrtfFastConv );
+#endif
     ivas_HRTF_fastconv_binary_close( &pCldfbRend->hHrtfFastConv );
 
     return;
diff --git a/lib_rend/ivas_hrtf.c b/lib_rend/ivas_hrtf.c
index 66c3ca0206ee88ba7c445604527bc07f456f4e33..46eaf2401c139128782e98c75d30371a904b2678 100644
--- a/lib_rend/ivas_hrtf.c
+++ b/lib_rend/ivas_hrtf.c
@@ -37,16 +37,24 @@
 #include "ivas_error.h"
 #include "wmc_auto.h"
 #include "ivas_prot.h"
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
 #include "ivas_rom_binaural_crend_head.h"
+#endif
+
 
 /*-----------------------------------------------------------------------*
- * ivas_HRTF_binary_open()
+ * ivas_HRTF_td_binary_open()
  *
  * Allocate HRTF binary handle for TD renderer
  *-----------------------------------------------------------------------*/
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_HRTF_td_binary_open(
+    TDREND_HRFILT_FiltSet_t **hHrtfTD )
+#else
 ivas_error ivas_HRTF_binary_open(
     TDREND_HRFILT_FiltSet_t **hHrtfTD )
+#endif
 {
     /* Allocate HR filter set for headphones configuration */
     *hHrtfTD = (TDREND_HRFILT_FiltSet_t *) malloc( sizeof( TDREND_HRFILT_FiltSet_t ) );
@@ -67,21 +75,80 @@ ivas_error ivas_HRTF_binary_open(
  * Close HRTF binary handle for TD renderer
  *-------------------------------------------------------------------*/
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+void ivas_HRTF_td_binary_close(
+    TDREND_HRFILT_FiltSet_t **hHrtfTD )
+#else
 void ivas_HRTF_binary_close(
     TDREND_HRFILT_FiltSet_t **hHrtfTD )
+#endif
 {
     if ( hHrtfTD == NULL || *hHrtfTD == NULL )
     {
         return;
     }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    int16_t i;
+
+    if ( ( *hHrtfTD )->ModelParams.modelROM )
+    {
+        BSplineModelEvalDealloc( &( *hHrtfTD )->ModelParams, &( *hHrtfTD )->ModelEval );
+    }
+    else
+    {
+        if ( ( *hHrtfTD )->ModelParams.UseItdModel )
+        {
+            free( ( *hHrtfTD )->ModelParamsITD.elevKSeq_dyn );
+            free( ( *hHrtfTD )->ModelParamsITD.azimKSeq_dyn );
+            free( ( *hHrtfTD )->ModelParamsITD.W_dyn );
+            free( ( *hHrtfTD )->ModelParamsITD.azimBsShape_dyn );
+            free( ( *hHrtfTD )->ModelParamsITD.elevBsShape_dyn );
+            free( ( *hHrtfTD )->ModelParamsITD.azimBsLen_dyn );
+            free( ( *hHrtfTD )->ModelParamsITD.azimBsStart_dyn );
+            free( ( *hHrtfTD )->ModelParamsITD.elevBsLen_dyn );
+            free( ( *hHrtfTD )->ModelParamsITD.elevBsStart_dyn );
+        }
+        free( ( *hHrtfTD )->ModelParams.elevKSeq_dyn );
+        free( ( *hHrtfTD )->ModelParams.azim_start_idx_dyn );
+        free( ( *hHrtfTD )->ModelParams.azimDim3_dyn );
+        free( ( *hHrtfTD )->ModelParams.AlphaL_dyn );
+        free( ( *hHrtfTD )->ModelParams.AlphaR_dyn );
+        free( ( *hHrtfTD )->ModelParams.azimSegSamples_dyn );
+
+        free( ( *hHrtfTD )->ModelParams.azimShapeIdx_dyn );
+        free( ( *hHrtfTD )->ModelParams.azimShapeSampFactor_dyn );
+        free( ( *hHrtfTD )->ModelParams.elevBsLen_dyn );
+        free( ( *hHrtfTD )->ModelParams.elevBsStart_dyn );
+        free( ( *hHrtfTD )->ModelParams.elevBsShape_dyn );
+
+        for ( i = 0; i < ( *hHrtfTD )->ModelParams.num_unique_azim_splines; i++ )
+        {
+            free( ( *hHrtfTD )->ModelParams.azimBsShape_dyn[i] );
+        }
+        free( ( *hHrtfTD )->ModelParams.azimBsShape_dyn );
+
+        free( (void *) ( *hHrtfTD )->ModelParams.azimBsShape ); /* void* cast needed to please both gcc and Visual studio compilers. Deallocating const float** should be fine and gcc agrees, but Visual studio complains. */
+        for ( i = 0; i < ( *hHrtfTD )->ModelParams.elevDim3; i++ )
+        {
+            free( ( *hHrtfTD )->ModelParams.azimKSeq[i] );
+        }
+        free( ( *hHrtfTD )->ModelParams.azimKSeq );
+
+        free( ( *hHrtfTD )->ModelParams.EL_dyn );
+        free( ( *hHrtfTD )->ModelParams.ER_dyn );
+
+        free( ( *hHrtfTD )->ModelEval.hrfModL );
+        free( ( *hHrtfTD )->ModelEval.hrfModR );
+    }
+#endif
+
     free( *hHrtfTD );
     *hHrtfTD = NULL;
 
     return;
 }
 
-
 /*-----------------------------------------------------------------------*
  * ivas_HRTF_CRend_binary_open()
  *
@@ -106,17 +173,48 @@ ivas_error ivas_HRTF_CRend_binary_open(
     return IVAS_ERR_OK;
 }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+
+/*-----------------------------------------------------------------------*
+ * ivas_HRTF_binary_open_buffers_int16()
+ *
+ * Allocate buffer with dynamic length for HRTF binary tables
+ *-----------------------------------------------------------------------*/
+
+ivas_error ivas_HRTF_binary_open_buffers_int16(
+    int16_t **buffer,       /* o  : buffer to allocate      */
+    const uint32_t mem_size /* i  : size of buffer          */
+)
+{
+    *buffer = (int16_t *) malloc( mem_size );
+
+    if ( *buffer == NULL )
+    {
+        return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF binary data\n" );
+    }
+
+    return IVAS_ERR_OK;
+}
+
+#endif
 
 /*-----------------------------------------------------------------------*
- * ivas_HRTF_CRend_binary_open_buffers_uint16()
+ * ivas_HRTF_binary_open_buffers_uint16()
  *
- * Allocate buffer with dynamic length for HRTF binary Crend handle
+ * Allocate buffer with dynamic length for HRTF binary tables
  *-----------------------------------------------------------------------*/
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_HRTF_binary_open_buffers_uint16(
+    uint16_t **buffer,      /* o  : buffer to allocate      */
+    const uint32_t mem_size /* i  : size of buffer          */
+)
+#else
 ivas_error ivas_HRTF_CRend_binary_open_buffers_uint16(
     uint16_t **buffer,      /* o  : buffer to allocate      */
     const uint32_t mem_size /* i  : size of buffer          */
 )
+#endif
 {
     *buffer = (uint16_t *) malloc( mem_size );
 
@@ -130,15 +228,22 @@ ivas_error ivas_HRTF_CRend_binary_open_buffers_uint16(
 
 
 /*-----------------------------------------------------------------------*
- * ivas_HRTF_CRend_binary_open_buffers_float()
+ * ivas_HRTF_binary_open_buffers_float()
  *
- * Allocate buffer with dynamic length for HRTF binary Crend handle
+ * Allocate buffer with dynamic length for HRTF binary tables
  *-----------------------------------------------------------------------*/
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_HRTF_binary_open_buffers_float(
+    float **buffer,         /* o  : buffer to allocate      */
+    const uint32_t mem_size /* i  : size of buffer          */
+)
+#else
 ivas_error ivas_HRTF_CRend_binary_open_buffers_float(
     float **buffer,         /* o  : buffer to allocate      */
     const uint32_t mem_size /* i  : size of buffer          */
 )
+#endif
 {
     *buffer = (float *) malloc( mem_size );
 
@@ -150,6 +255,52 @@ ivas_error ivas_HRTF_CRend_binary_open_buffers_float(
     return IVAS_ERR_OK;
 }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+
+/*-----------------------------------------------------------------------*
+ * ivas_HRTF_binary_open_buffers_float_ptr()
+ *
+ * Allocate buffer with dynamic length for HRTF binary tables
+ *-----------------------------------------------------------------------*/
+
+ivas_error ivas_HRTF_binary_open_buffers_float_ptr(
+    float ***buffer,        /* o  : buffer to allocate      */
+    const uint32_t mem_size /* i  : size of buffer          */
+)
+{
+    *buffer = (float **) malloc( mem_size );
+
+    if ( *buffer == NULL )
+    {
+        return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF binary data\n" );
+    }
+
+    return IVAS_ERR_OK;
+}
+
+
+/*-----------------------------------------------------------------------*
+ * ivas_HRTF_binary_open_buffers_float_ptr()
+ *
+ * Allocate buffer with dynamic length for HRTF binary tables
+ *-----------------------------------------------------------------------*/
+
+ivas_error ivas_HRTF_binary_open_buffers_float_ptr_const(
+    const float ***buffer,  /* o  : buffer to allocate      */
+    const uint32_t mem_size /* i  : size of buffer          */
+)
+{
+    *buffer = (const float **) malloc( mem_size );
+
+    if ( *buffer == NULL )
+    {
+        return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for HRTF binary data\n" );
+    }
+
+    return IVAS_ERR_OK;
+}
+#endif
+
 
 /*-------------------------------------------------------------------*
  * ivas_HRTF_CRend_binary_close()
@@ -243,6 +394,11 @@ void ivas_HRTF_fastconv_binary_close(
         return;
     }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    /* Fastconv HRTF memories */
+    ivas_binaural_hrtf_close( hHrtfFastConv );
+#endif
+
     free( *hHrtfFastConv );
     *hHrtfFastConv = NULL;
 
@@ -306,6 +462,10 @@ ivas_error ivas_HRTF_statistics_binary_open(
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for statistics HRTF tables!" );
     }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    set_c( (int8_t *) ( *hHrtfStatistics ), 0, (int32_t) sizeof( HRTFS_STATISTICS ) );
+#endif
+
     return IVAS_ERR_OK;
 }
 
@@ -316,30 +476,92 @@ ivas_error ivas_HRTF_statistics_binary_open(
  * Close HRTF binary handle for statistics handler
  *-----------------------------------------------------------------------*/
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+void ivas_HRTF_statistics_binary_close(
+    HRTFS_STATISTICS **hHrtfStatistics )
+#else
 void ivas_HRTF_statistics_close(
     HRTFS_STATISTICS **hHrtfStatistics )
+#endif
 {
     if ( hHrtfStatistics == NULL || *hHrtfStatistics == NULL )
     {
         return;
     }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    if ( ( hHrtfStatistics != NULL ) && ( *hHrtfStatistics != NULL ) && ( ( *hHrtfStatistics )->fromROM == FALSE ) )
+    {
+        if ( ( *hHrtfStatistics )->average_energy_l_dyn != NULL )
+        {
+            free( ( *hHrtfStatistics )->average_energy_l_dyn );
+        }
+        if ( ( *hHrtfStatistics )->average_energy_r_dyn != NULL )
+        {
+            free( ( *hHrtfStatistics )->average_energy_r_dyn );
+        }
+        if ( ( *hHrtfStatistics )->inter_aural_coherence_dyn != NULL )
+        {
+            free( ( *hHrtfStatistics )->inter_aural_coherence_dyn );
+        }
+    }
+#endif
+
     free( *hHrtfStatistics );
     *hHrtfStatistics = NULL;
 
     return;
 }
 
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
 /*-----------------------------------------------------------------------*
- * ivas_HRTF_statistics_init()
+ * ivas_HRTF_statistics_init_from_rom()
  *
  * Allocates HRTF statistics handle and initializes from ROM
  *-----------------------------------------------------------------------*/
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_HRTF_statistics_init_from_rom(
+    HRTFS_STATISTICS_HANDLE *hHrtfStatistics,
+    const int32_t sampleRate )
+#else
 ivas_error ivas_HRTF_statistics_init(
     HRTFS_STATISTICS_HANDLE *hHrtfStatistics,
     const int32_t sampleRate )
+#endif
 {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    if ( hHrtfStatistics == NULL || *hHrtfStatistics == NULL )
+    {
+        /* Tables not initialised */
+        return IVAS_ERR_UNEXPECTED_NULL_POINTER;
+    }
+
+    switch ( sampleRate )
+    {
+        case 48000:
+            ( *hHrtfStatistics )->average_energy_l = defaultHRIR_left_avg_power_48kHz;
+            ( *hHrtfStatistics )->average_energy_r = defaultHRIR_right_avg_power_48kHz;
+            ( *hHrtfStatistics )->inter_aural_coherence = defaultHRIR_coherence_48kHz;
+            break;
+        case 32000:
+            ( *hHrtfStatistics )->average_energy_l = defaultHRIR_left_avg_power_32kHz;
+            ( *hHrtfStatistics )->average_energy_r = defaultHRIR_right_avg_power_32kHz;
+            ( *hHrtfStatistics )->inter_aural_coherence = defaultHRIR_coherence_32kHz;
+            break;
+        case 16000:
+            ( *hHrtfStatistics )->average_energy_l = defaultHRIR_left_avg_power_16kHz;
+            ( *hHrtfStatistics )->average_energy_r = defaultHRIR_right_avg_power_16kHz;
+            ( *hHrtfStatistics )->inter_aural_coherence = defaultHRIR_coherence_16kHz;
+            break;
+        default:
+            ( *hHrtfStatistics )->average_energy_l = NULL;
+            ( *hHrtfStatistics )->average_energy_r = NULL;
+            ( *hHrtfStatistics )->inter_aural_coherence = NULL;
+            break;
+    }
+    ( *hHrtfStatistics )->fromROM = TRUE;
+#else
     HRTFS_STATISTICS *HrtfStatistics;
 
     if ( hHrtfStatistics != NULL && *hHrtfStatistics != NULL )
@@ -380,5 +602,7 @@ ivas_error ivas_HRTF_statistics_init(
 
     *hHrtfStatistics = HrtfStatistics;
 
+#endif
     return IVAS_ERR_OK;
 }
+#endif
diff --git a/lib_rend/ivas_objectRenderer_mix.c b/lib_rend/ivas_objectRenderer_mix.c
index 3c63594709cdeabcb1d12542c63f31f628cd5784..d9120b60c89dbbd809ef6d94b6d25f1c3aa62548 100644
--- a/lib_rend/ivas_objectRenderer_mix.c
+++ b/lib_rend/ivas_objectRenderer_mix.c
@@ -144,6 +144,7 @@ void TDREND_MIX_Dealloc(
         {
             BSplineModelEvalDealloc( &hBinRendererTd->HrFiltSet_p->ModelParams, &hBinRendererTd->HrFiltSet_p->ModelEval );
         }
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
         else
         {
             if ( hBinRendererTd->HrFiltSet_p->Elev_p != NULL )
@@ -167,6 +168,7 @@ void TDREND_MIX_Dealloc(
                 hBinRendererTd->HrFiltSet_p->RightFiltSet_p = NULL;
             }
         }
+#endif
 
         if ( hBinRendererTd->HrFiltSet_p->ModelParams.modelROM == 1 )
         {
diff --git a/lib_rend/ivas_prot_rend.h b/lib_rend/ivas_prot_rend.h
index 2cd33f685ecbdde277565dce3af1f181f33eb05c..00c0bf1ce40a16e8120527a8ce0120bcaa8d18ae 100644
--- a/lib_rend/ivas_prot_rend.h
+++ b/lib_rend/ivas_prot_rend.h
@@ -555,6 +555,15 @@ void ivas_masa_ext_dirac_render(
  * HRTF
  *----------------------------------------------------------------------------------*/
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_HRTF_td_binary_open(
+    TDREND_HRFILT_FiltSet_t **hHrtfTD                           /* i/o: TD renderer HRTF handle                 */
+);
+
+void ivas_HRTF_td_binary_close(
+    TDREND_HRFILT_FiltSet_t **hHrtfTD                           /* i/o: TD renderer HRTF handle                 */
+);
+#else
 ivas_error ivas_HRTF_binary_open(
     TDREND_HRFILT_FiltSet_t **hHrtfTD                           /* i/o: TD renderer HRTF handle                 */
 );
@@ -562,6 +571,7 @@ ivas_error ivas_HRTF_binary_open(
 void ivas_HRTF_binary_close(
     TDREND_HRFILT_FiltSet_t **hHrtfTD                           /* i/o: TD renderer HRTF handle                 */
 );
+#endif
 
 ivas_error ivas_HRTF_fastconv_binary_open(
     HRTFS_FASTCONV **hHrtfFastConv                              /* i/o: FASTCONV HRTF structure */
@@ -583,28 +593,70 @@ ivas_error ivas_HRTF_CRend_binary_open(
     HRTFS_CREND_DATA **hHrtfCrend                               /* i/o: Crend HRTF handle                       */
 );
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_HRTF_binary_open_buffers_uint16(
+    uint16_t **buffer,                                          /* o  : buffer to allocate                      */
+    const uint32_t mem_size                                     /* i  : size of buffer                          */
+);
+
+ivas_error ivas_HRTF_binary_open_buffers_int16(
+    int16_t **buffer,                                           /* o  : buffer to allocate                      */
+    const uint32_t mem_size                                     /* i  : size of buffer                          */
+);
+#else
 ivas_error ivas_HRTF_CRend_binary_open_buffers_uint16(
     uint16_t **buffer,                                          /* o  : buffer to allocate                      */
     const uint32_t mem_size                                     /* i  : size of buffer                          */
 );
+#endif
+
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_HRTF_binary_open_buffers_float(
+    float **buffer,                                             /* o  : buffer to allocate                      */
+    const uint32_t mem_size                                     /* i  : size of buffer                          */
+);
 
+ivas_error ivas_HRTF_binary_open_buffers_float_ptr(
+    float ***buffer,                                             /* o  : buffer to allocate                      */
+    const uint32_t mem_size                                     /* i  : size of buffer                          */
+);
+
+ivas_error ivas_HRTF_binary_open_buffers_float_ptr_const(
+    const float ***buffer,                                             /* o  : buffer to allocate                      */
+    const uint32_t mem_size                                     /* i  : size of buffer                          */
+);
+
+#else
 ivas_error ivas_HRTF_CRend_binary_open_buffers_float(
     float **buffer,                                             /* o  : buffer to allocate                      */
     const uint32_t mem_size                                     /* i  : size of buffer                          */
 );
+#endif
 
 void ivas_HRTF_CRend_binary_close(
     HRTFS_CREND_DATA **hHrtfCrend                               /* i/o: Crend HRTF handle                       */
 );
 
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_HRTF_statistics_init_from_rom(
+    HRTFS_STATISTICS_HANDLE *hHrtfStatistics,                   /* i/o: HRTF statistics structure               */
+    const int32_t sampleRate );                                 /* i  : Sample rate                             */
+#else
 ivas_error ivas_HRTF_statistics_init(
     HRTFS_STATISTICS_HANDLE *hHrtfStatistics,                   /* i/o: HRTF statistics structure               */
     const int32_t sampleRate                                    /* i  : Sample rate                             */
 );
-
-void ivas_HRTF_statistics_close(
+#endif
+#endif
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+void ivas_HRTF_statistics_binary_close(
+    HRTFS_STATISTICS **hHrtfStatistics );                       /* i/o: HRTF statistics structure               */
+#else
+    void ivas_HRTF_statistics_close(
     HRTFS_STATISTICS **hHrtfStatistics                          /* i/o: HRTF statistics structure               */
 );
+#endif
 
 ivas_error ivas_HRTF_statistics_binary_open(
     HRTFS_STATISTICS **hHrtfStatistics                          /* i/o: HRTF statistics structure               */
@@ -964,6 +1016,13 @@ void ivas_binaural_reverb_processSubframe(
     float outImag[][CLDFB_SLOTS_PER_SUBFRAME][CLDFB_NO_CHANNELS_MAX]  /* o  : output CLDFB data imag            */
 );
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+ivas_error ivas_reverb_HRTF_statistics_open( 
+    HRTFS_STATISTICS_HANDLE *hHrtfStatistics,                   /* o  : HRTF statistics handle                  */
+    const int32_t output_Fs                                     /* i  : output sampling rate                    */
+);
+
+#endif
 ivas_error ivas_reverb_open( 
     REVERB_HANDLE *hReverb,                                     /* i/o: Reverberator handle                     */
     const HRTFS_STATISTICS_HANDLE hHrtfStatistics,              /* i  : HRTF statistics handle                  */
diff --git a/lib_rend/ivas_reverb.c b/lib_rend/ivas_reverb.c
index 3f9e3aef0ffee1397b9fdf2fe79797cde5c8da37..c0956405f05f8e639bfdecb54ea825aed5952e3e 100644
--- a/lib_rend/ivas_reverb.c
+++ b/lib_rend/ivas_reverb.c
@@ -34,6 +34,9 @@
 #include "options.h"
 #include "prot.h"
 #include "ivas_prot_rend.h"
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+#include "ivas_rom_binaural_crend_head.h"
+#endif
 #include "ivas_cnst.h"
 #ifdef DEBUGGING
 #include "debug.h"
@@ -123,6 +126,66 @@ typedef struct ivas_reverb_params_t
 
 static ivas_error calc_jot_t60_coeffs( float *pH_dB, const uint16_t nrFrequencies, float *pFrequencies, float *pCoeffA, float *pCoeffB, const float fNyquist );
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+
+/*-------------------------------------------------------------------------
+ * ivas_reverb_HRTF_statistics_open()
+ *
+ * Open and initialize HRTF statistics handle from ROM tables
+ *------------------------------------------------------------------------*/
+
+ivas_error ivas_reverb_HRTF_statistics_open(
+    HRTFS_STATISTICS_HANDLE *hHrtfStatistics, /* o  : HRTF statistics handle    */
+    const int32_t output_Fs                   /* i  : output sampling rate      */
+)
+{
+    if ( *hHrtfStatistics != NULL )
+    {
+        if ( ( *hHrtfStatistics )->fromROM == TRUE )
+        {
+            return IVAS_ERROR( IVAS_ERR_INTERNAL, "HRTF statistics allocated but not initialized from binary file!\n" );
+        }
+
+        /* HRTF statistics loaded from binary file */
+        return IVAS_ERR_OK;
+    }
+
+    if ( ( *hHrtfStatistics = (HRTFS_STATISTICS *) malloc( sizeof( HRTFS_STATISTICS ) ) ) == NULL )
+    {
+        return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for statistics HRTF tables!" );
+    }
+
+    /* Init HRTF statistics from ROM */
+    switch ( output_Fs )
+    {
+        case 48000:
+            ( *hHrtfStatistics )->average_energy_l = defaultHRIR_left_avg_power_48kHz;
+            ( *hHrtfStatistics )->average_energy_r = defaultHRIR_right_avg_power_48kHz;
+            ( *hHrtfStatistics )->inter_aural_coherence = defaultHRIR_coherence_48kHz;
+            break;
+        case 32000:
+            ( *hHrtfStatistics )->average_energy_l = defaultHRIR_left_avg_power_32kHz;
+            ( *hHrtfStatistics )->average_energy_r = defaultHRIR_right_avg_power_32kHz;
+            ( *hHrtfStatistics )->inter_aural_coherence = defaultHRIR_coherence_32kHz;
+            break;
+        case 16000:
+            ( *hHrtfStatistics )->average_energy_l = defaultHRIR_left_avg_power_16kHz;
+            ( *hHrtfStatistics )->average_energy_r = defaultHRIR_right_avg_power_16kHz;
+            ( *hHrtfStatistics )->inter_aural_coherence = defaultHRIR_coherence_16kHz;
+            break;
+        default:
+            ( *hHrtfStatistics )->average_energy_l = NULL;
+            ( *hHrtfStatistics )->average_energy_r = NULL;
+            ( *hHrtfStatistics )->inter_aural_coherence = NULL;
+            break;
+    }
+
+    ( *hHrtfStatistics )->fromROM = TRUE;
+
+    return IVAS_ERR_OK;
+}
+
+#endif
 
 /*-------------------------------------------------------------------------
  * binRend_rand()
diff --git a/lib_rend/ivas_stat_rend.h b/lib_rend/ivas_stat_rend.h
index e935c9f9bc6839568c908bd95be431d127d4de94..2edcd53c24256e17388ab0f1dd3d3cc8200097cd 100644
--- a/lib_rend/ivas_stat_rend.h
+++ b/lib_rend/ivas_stat_rend.h
@@ -1035,13 +1035,17 @@ typedef struct ivas_hrtf_TDREND_HRFILT_FiltSet_struct
     int16_t NumPos;
     int16_t NumElev;
     float Dist;
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     float *ItdSet_p;
+#endif
     int16_t FiltLength;
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     float *Azim_p;
     float *Elev_p;
     float *ItdSetNominal_p;
     float *LeftFiltSet_p;
     float *RightFiltSet_p;
+#endif
     ModelParams_t ModelParams;
     ModelEval_t ModelEval;
     ModelParamsITD_t ModelParamsITD;
diff --git a/lib_rend/lib_rend.c b/lib_rend/lib_rend.c
index 9462886b3f5cb2f9ef8b63108d43f4eb17cdf841..1d22c004ad195f2bf022bb6cfa5769d7e641a97a 100644
--- a/lib_rend/lib_rend.c
+++ b/lib_rend/lib_rend.c
@@ -3239,7 +3239,11 @@ ivas_error IVAS_REND_Open(
     hIvasRend->hHrtfs.hHrtfStatistics = NULL;
     if ( asHrtfBinary )
     {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+        if ( ( error = ivas_HRTF_td_binary_open( &( hIvasRend->hHrtfs.hHrtfTD ) ) ) != IVAS_ERR_OK )
+#else
         if ( ( error = ivas_HRTF_binary_open( &( hIvasRend->hHrtfs.hHrtfTD ) ) ) != IVAS_ERR_OK )
+#endif
         {
             return error;
         }
@@ -3263,10 +3267,21 @@ ivas_error IVAS_REND_Open(
 
     if ( outConfig == IVAS_AUDIO_CONFIG_BINAURAL_ROOM_REVERB )
     {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+        if ( hIvasRend->hHrtfs.hHrtfStatistics == NULL )
+        {
+            /* Allocate and init HRTF statistics */
+            if ( ( error = ivas_reverb_HRTF_statistics_open( &( hIvasRend->hHrtfs.hHrtfStatistics ), outputSampleRate ) ) != IVAS_ERR_OK )
+            {
+                return error;
+            }
+        }
+#else
         if ( ( error = ivas_HRTF_statistics_init( &( hIvasRend->hHrtfs.hHrtfStatistics ), hIvasRend->sampleRateOut ) ) != IVAS_ERR_OK )
         {
             return error;
         }
+#endif
     }
 
     return IVAS_ERR_OK;
@@ -8239,16 +8254,25 @@ void IVAS_REND_Close(
     ivas_external_orientation_close( &hIvasRend->hExternalOrientationData );
     ivas_combined_orientation_close( &hIvasRend->hCombinedOrientationData );
 
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     /* Fastconv HRTF memories */
     ivas_binaural_hrtf_close( &hIvasRend->hHrtfs.hHrtfFastConv );
+#endif
 
     /* Parametric binauralizer HRTF filters */
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_td_binary_close( &( hIvasRend->hHrtfs.hHrtfTD ) );
+#else
     ivas_HRTF_binary_close( &( hIvasRend->hHrtfs.hHrtfTD ) );
+#endif
     ivas_HRTF_CRend_binary_close( &( hIvasRend->hHrtfs.hHrtfCrend ) );
     ivas_HRTF_fastconv_binary_close( &( hIvasRend->hHrtfs.hHrtfFastConv ) );
     ivas_HRTF_parambin_binary_close( &( hIvasRend->hHrtfs.hHrtfParambin ) );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_statistics_binary_close( &( hIvasRend->hHrtfs.hHrtfStatistics ) );
+#else
     ivas_HRTF_statistics_close( &( hIvasRend->hHrtfs.hHrtfStatistics ) );
-
+#endif
     free( hIvasRend );
     *phIvasRend = NULL;
 
diff --git a/lib_util/hrtf_file_reader.c b/lib_util/hrtf_file_reader.c
index e0cb53b09ead9d7abe7820a50981726a491770bc..c560e44c3bed20d522c07385844c5b121b585b51 100644
--- a/lib_util/hrtf_file_reader.c
+++ b/lib_util/hrtf_file_reader.c
@@ -296,7 +296,11 @@ static ivas_error TDREND_LoadBSplineBinaryITD(
     }
 
     fread( &modelITD->elevDim3, sizeof( int16_t ), 1, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &modelITD->elevKSeq_dyn, ( modelITD->elevDim3 - 2 ) * sizeof( float ) );
+#else
     modelITD->elevKSeq_dyn = (float *) malloc( ( modelITD->elevDim3 - 2 ) * sizeof( float ) );
+#endif
     v_tmp16 = (int16_t *) malloc( ( modelITD->elevDim3 - 2 ) * sizeof( int16_t ) );
     if ( modelITD->elevKSeq_dyn == NULL || v_tmp16 == NULL )
     {
@@ -312,7 +316,11 @@ static ivas_error TDREND_LoadBSplineBinaryITD(
     free( v_tmp16 );
 
     fread( &modelITD->azimDim3, sizeof( int16_t ), 1, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &modelITD->azimKSeq_dyn, ( ( modelITD->azimDim3 + 1 ) / 2 - 2 ) * sizeof( float ) );
+#else
     modelITD->azimKSeq_dyn = (float *) malloc( ( ( modelITD->azimDim3 + 1 ) / 2 - 2 ) * sizeof( float ) ); /* basis functions are flipped around 180 deg, number of basis functions above/below is (N+1)/2 */
+#endif
     v_tmp16 = (int16_t *) malloc( ( ( modelITD->azimDim3 + 1 ) / 2 - 2 ) * sizeof( int16_t ) );
     if ( modelITD->azimKSeq_dyn == NULL || v_tmp16 == NULL )
     {
@@ -328,7 +336,11 @@ static ivas_error TDREND_LoadBSplineBinaryITD(
     free( v_tmp16 );
 
     fread( &tmp, sizeof( int16_t ), 1, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &modelITD->W_dyn, tmp * sizeof( float ) );
+#else
     modelITD->W_dyn = (float *) malloc( tmp * sizeof( float ) );
+#endif
     if ( modelITD->W_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -349,13 +361,21 @@ static ivas_error TDREND_LoadBSplineBinaryITD(
     free( v_tmp16 );
 
     /* azimuth */
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &modelITD->azimBsLen_dyn, HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#else
     modelITD->azimBsLen_dyn = (int16_t *) malloc( HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#endif
     if ( modelITD->azimBsLen_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
     }
     fread( modelITD->azimBsLen_dyn, sizeof( int16_t ), HRTF_MODEL_BSPLINE_NUM_COEFFS, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &modelITD->azimBsStart_dyn, HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#else
     modelITD->azimBsStart_dyn = (int16_t *) malloc( HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#endif
     if ( modelITD->azimBsStart_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -363,7 +383,11 @@ static ivas_error TDREND_LoadBSplineBinaryITD(
     fread( modelITD->azimBsStart_dyn, sizeof( int16_t ), HRTF_MODEL_BSPLINE_NUM_COEFFS, f_hrtf );
     fread( &tmp, sizeof( int16_t ), 1, f_hrtf );
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &modelITD->azimBsShape_dyn, tmp * sizeof( float ) );
+#else
     modelITD->azimBsShape_dyn = (float *) malloc( tmp * sizeof( float ) );
+#endif
     v_tmp16 = (int16_t *) malloc( tmp * sizeof( int16_t ) );
     if ( modelITD->azimBsShape_dyn == NULL || v_tmp16 == NULL )
     {
@@ -380,14 +404,22 @@ static ivas_error TDREND_LoadBSplineBinaryITD(
 
     fread( &modelITD->azimSegSamples, sizeof( int16_t ), 1, f_hrtf );
 
-    /* elevation */
+/* elevation */
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &modelITD->elevBsLen_dyn, HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#else
     modelITD->elevBsLen_dyn = (int16_t *) malloc( HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#endif
     if ( modelITD->elevBsLen_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
     }
     fread( modelITD->elevBsLen_dyn, sizeof( int16_t ), HRTF_MODEL_BSPLINE_NUM_COEFFS, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &modelITD->elevBsStart_dyn, HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#else
     modelITD->elevBsStart_dyn = (int16_t *) malloc( HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#endif
     if ( modelITD->elevBsStart_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -395,7 +427,11 @@ static ivas_error TDREND_LoadBSplineBinaryITD(
     fread( modelITD->elevBsStart_dyn, sizeof( int16_t ), HRTF_MODEL_BSPLINE_NUM_COEFFS, f_hrtf );
     fread( &tmp, sizeof( int16_t ), 1, f_hrtf );
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &modelITD->elevBsShape_dyn, tmp * sizeof( float ) );
+#else
     modelITD->elevBsShape_dyn = (float *) malloc( tmp * sizeof( float ) );
+#endif
     if ( modelITD->elevBsShape_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -494,7 +530,11 @@ static ivas_error TDREND_LoadBSplineBinary(
 
     fread( &model->K, sizeof( int16_t ), 1, f_hrtf );
     fread( &model->elevDim3, sizeof( int16_t ), 1, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &model->elevKSeq_dyn, ( model->elevDim3 - 2 ) * sizeof( float ) );
+#else
     model->elevKSeq_dyn = (float *) malloc( ( model->elevDim3 - 2 ) * sizeof( float ) );
+#endif
 
     v_tmp16 = (int16_t *) malloc( ( model->elevDim3 - 2 ) * sizeof( int16_t ) );
     if ( model->elevKSeq_dyn == NULL || v_tmp16 == NULL )
@@ -509,10 +549,22 @@ static ivas_error TDREND_LoadBSplineBinary(
         model->elevKSeq_dyn[j] = v_tmp16[j] * q_scale;
     }
     free( v_tmp16 );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &model->azimDim3_dyn, model->elevDim3 * sizeof( int16_t ) );
+#else
     model->azimDim3_dyn = (int16_t *) malloc( model->elevDim3 * sizeof( int16_t ) );
+#endif
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &model->azim_start_idx_dyn, model->elevDim3 * sizeof( int16_t ) );
+#else
     model->azim_start_idx_dyn = (int16_t *) malloc( model->elevDim3 * sizeof( int16_t ) );
+#endif
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float_ptr( &model->azimKSeq, model->elevDim3 * sizeof( float * ) );
+#else
     model->azimKSeq = (float **) malloc( model->elevDim3 * sizeof( float * ) );
+#endif
     if ( model->azimDim3_dyn == NULL || model->azim_start_idx_dyn == NULL || model->azimKSeq == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -522,7 +574,11 @@ static ivas_error TDREND_LoadBSplineBinary(
     {
         fread( &model->azimDim3_dyn[i], sizeof( int16_t ), 1, f_hrtf );
         fread( &model->azim_start_idx_dyn[i], sizeof( int16_t ), 1, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+        ivas_HRTF_binary_open_buffers_float( &model->azimKSeq[i], ( model->azimDim3_dyn[i] + 1 ) * sizeof( float ) );
+#else
         model->azimKSeq[i] = (float *) malloc( ( model->azimDim3_dyn[i] + 1 ) * sizeof( float ) );
+#endif
 
         v_tmp16 = (int16_t *) malloc( ( model->azimDim3_dyn[i] + 1 ) * sizeof( int16_t ) );
         if ( model->azimKSeq[i] == NULL || v_tmp16 == NULL )
@@ -539,8 +595,11 @@ static ivas_error TDREND_LoadBSplineBinary(
         free( v_tmp16 );
     }
     fread( &model->AlphaN, sizeof( int16_t ), 1, f_hrtf );
-
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &model->AlphaL_dyn, model->AlphaN * model->K * sizeof( float ) );
+#else
     model->AlphaL_dyn = (float *) malloc( model->AlphaN * model->K * sizeof( float ) );
+#endif
 
     v_tmp16 = (int16_t *) malloc( model->AlphaN * model->K * sizeof( int16_t ) );
     if ( model->AlphaL_dyn == NULL || v_tmp16 == NULL )
@@ -555,7 +614,11 @@ static ivas_error TDREND_LoadBSplineBinary(
     {
         model->AlphaL_dyn[j] = v_tmp16[j] * q_scale; /* Q14 */
     }
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &model->AlphaR_dyn, model->AlphaN * model->K * sizeof( float ) );
+#else
     model->AlphaR_dyn = (float *) malloc( model->AlphaN * model->K * sizeof( float ) );
+#endif
     if ( model->AlphaR_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -571,9 +634,21 @@ static ivas_error TDREND_LoadBSplineBinary(
 
     /* azimuth */
     fread( &model->num_unique_azim_splines, sizeof( int16_t ), 1, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float_ptr_const( &model->azimBsShape, model->num_unique_azim_splines * sizeof( float * ) );
+#else
     model->azimBsShape = (const float **) malloc( model->num_unique_azim_splines * sizeof( float * ) );
+#endif
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float_ptr( &model->azimBsShape_dyn, model->num_unique_azim_splines * sizeof( float * ) );
+#else
     model->azimBsShape_dyn = (float **) malloc( model->num_unique_azim_splines * sizeof( float * ) );
+#endif
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &model->azimSegSamples_dyn, model->num_unique_azim_splines * sizeof( int16_t ) );
+#else
     model->azimSegSamples_dyn = (int16_t *) malloc( model->num_unique_azim_splines * sizeof( int16_t ) );
+#endif
     if ( model->azimBsShape == NULL || model->azimBsShape_dyn == NULL || model->azimSegSamples_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -582,7 +657,11 @@ static ivas_error TDREND_LoadBSplineBinary(
     for ( i = 0; i < model->num_unique_azim_splines; i++ )
     {
         fread( &tmp, sizeof( int16_t ), 1, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+        ivas_HRTF_binary_open_buffers_float( &model->azimBsShape_dyn[i], tmp * sizeof( float ) );
+#else
         model->azimBsShape_dyn[i] = (float *) malloc( tmp * sizeof( float ) );
+#endif
         if ( model->azimBsShape_dyn[i] == NULL )
         {
             return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -604,13 +683,21 @@ static ivas_error TDREND_LoadBSplineBinary(
         free( v_tmp16 );
     }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &model->azimShapeIdx_dyn, model->elevDim3 * sizeof( int16_t ) );
+#else
     model->azimShapeIdx_dyn = (int16_t *) malloc( model->elevDim3 * sizeof( int16_t ) );
+#endif
     if ( model->azimShapeIdx_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
     }
     fread( model->azimShapeIdx_dyn, sizeof( int16_t ), model->elevDim3, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &model->azimShapeSampFactor_dyn, model->elevDim3 * sizeof( int16_t ) );
+#else
     model->azimShapeSampFactor_dyn = (int16_t *) malloc( model->elevDim3 * sizeof( int16_t ) );
+#endif
     if ( model->azimShapeSampFactor_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -618,13 +705,21 @@ static ivas_error TDREND_LoadBSplineBinary(
     fread( model->azimShapeSampFactor_dyn, sizeof( int16_t ), model->elevDim3, f_hrtf );
 
     /* elevation */
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &model->elevBsLen_dyn, HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#else
     model->elevBsLen_dyn = (int16_t *) malloc( HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#endif
     if ( model->elevBsLen_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
     }
     fread( model->elevBsLen_dyn, sizeof( int16_t ), HRTF_MODEL_BSPLINE_NUM_COEFFS, f_hrtf );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_int16( &model->elevBsStart_dyn, HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#else
     model->elevBsStart_dyn = (int16_t *) malloc( HRTF_MODEL_BSPLINE_NUM_COEFFS * sizeof( int16_t ) );
+#endif
     if ( model->elevBsStart_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -633,7 +728,11 @@ static ivas_error TDREND_LoadBSplineBinary(
     fread( &tmp, sizeof( int16_t ), 1, f_hrtf );
 
     v_tmp16 = (int16_t *) malloc( tmp * sizeof( int16_t ) );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &model->elevBsShape_dyn, tmp * sizeof( float ) );
+#else
     model->elevBsShape_dyn = (float *) malloc( tmp * sizeof( float ) );
+#endif
     if ( model->elevBsShape_dyn == NULL || v_tmp16 == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -650,7 +749,11 @@ static ivas_error TDREND_LoadBSplineBinary(
 
     fread( &model->elevSegSamples, sizeof( int16_t ), 1, f_hrtf );
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &model->EL_dyn, model->AlphaN * HRTF_MODEL_N_SECTIONS * sizeof( float ) );
+#else
     model->EL_dyn = (float *) malloc( model->AlphaN * HRTF_MODEL_N_SECTIONS * sizeof( float ) );
+#endif
     if ( model->EL_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -664,7 +767,11 @@ static ivas_error TDREND_LoadBSplineBinary(
         model->EL_dyn[j] = ( (int32_t *) model->EL_dyn )[j] * q_scale; /* Q14 */
     }
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &model->ER_dyn, model->AlphaN * HRTF_MODEL_N_SECTIONS * sizeof( float ) );
+#else
     model->ER_dyn = (float *) malloc( model->AlphaN * HRTF_MODEL_N_SECTIONS * sizeof( float ) );
+#endif
     if ( model->ER_dyn == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -698,8 +805,13 @@ static ivas_error TDREND_LoadBSplineBinary(
     HRTF_model_precalc( model );
     HrFiltSet_p->FiltLength = HrFiltSet_p->ModelParams.K;
 
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_binary_open_buffers_float( &HrFiltSet_p->ModelEval.hrfModL, model->K * sizeof( float ) );
+    ivas_HRTF_binary_open_buffers_float( &HrFiltSet_p->ModelEval.hrfModR, model->K * sizeof( float ) );
+#else
     HrFiltSet_p->ModelEval.hrfModL = (float *) malloc( model->K * sizeof( float ) );
     HrFiltSet_p->ModelEval.hrfModR = (float *) malloc( model->K * sizeof( float ) );
+#endif
     if ( HrFiltSet_p->ModelEval.hrfModL == NULL || HrFiltSet_p->ModelEval.hrfModR == NULL )
     {
         return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -813,9 +925,15 @@ static ivas_error load_reverb_from_binary(
 
     if ( is_reverb )
     {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+        ivas_HRTF_binary_open_buffers_float( &hHrtfStatistics->average_energy_l_dyn, lr_iac_len * sizeof( float ) );
+        ivas_HRTF_binary_open_buffers_float( &hHrtfStatistics->average_energy_r_dyn, lr_iac_len * sizeof( float ) );
+        ivas_HRTF_binary_open_buffers_float( &hHrtfStatistics->inter_aural_coherence_dyn, lr_iac_len * sizeof( float ) );
+#else
         hHrtfStatistics->average_energy_l_dyn = (float *) malloc( lr_iac_len * sizeof( float ) );
         hHrtfStatistics->average_energy_r_dyn = (float *) malloc( lr_iac_len * sizeof( float ) );
         hHrtfStatistics->inter_aural_coherence_dyn = (float *) malloc( lr_iac_len * sizeof( float ) );
+#endif
         if ( hHrtfStatistics->average_energy_l_dyn == NULL || hHrtfStatistics->average_energy_r_dyn == NULL || hHrtfStatistics->inter_aural_coherence_dyn == NULL )
         {
             return IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Could not allocate memory for hrtf data" );
@@ -1036,6 +1154,9 @@ void destroy_td_hrtf(
     IVAS_DEC_HRTF_TD_HANDLE *hHrtf /* i/o: TD rend. HRTF handle */
 )
 {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_td_binary_close( hHrtf );
+#else
     int16_t i;
 
     if ( ( hHrtf == NULL ) || ( *hHrtf == NULL ) )
@@ -1091,7 +1212,7 @@ void destroy_td_hrtf(
     }
 
     ivas_HRTF_binary_close( hHrtf );
-
+#endif
     return;
 }
 
@@ -1164,7 +1285,11 @@ static ivas_error create_Crend_HRTF_from_rawdata(
     {
         for ( j = 0; j < BINAURAL_CHANNELS; j++ )
         {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            if ( ( error = ivas_HRTF_binary_open_buffers_uint16( &( *hHRTF )->pIndex_frequency_max_dyn[i][j], mem_size ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = ivas_HRTF_CRend_binary_open_buffers_uint16( &( *hHRTF )->pIndex_frequency_max_dyn[i][j], mem_size ) ) != IVAS_ERR_OK )
+#endif
             {
                 return error;
             }
@@ -1191,7 +1316,11 @@ static ivas_error create_Crend_HRTF_from_rawdata(
         for ( j = 0; j < BINAURAL_CHANNELS; j++ )
         {
             mem_size = ( *hHRTF )->num_iterations_diffuse[j] * sizeof( uint16_t );
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            if ( ( error = ivas_HRTF_binary_open_buffers_uint16( &( *hHRTF )->pIndex_frequency_max_diffuse_dyn[j], mem_size ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = ivas_HRTF_CRend_binary_open_buffers_uint16( &( *hHRTF )->pIndex_frequency_max_diffuse_dyn[j], mem_size ) ) != IVAS_ERR_OK )
+#endif
             {
                 return error;
             }
@@ -1235,7 +1364,11 @@ static ivas_error create_Crend_HRTF_from_rawdata(
     {
         for ( j = 0; j < BINAURAL_CHANNELS; j++ )
         {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            if ( ( error = ivas_HRTF_binary_open_buffers_float( &( *hHRTF )->pOut_to_bin_re_dyn[i][j], mem_size_buf ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = ivas_HRTF_CRend_binary_open_buffers_float( &( *hHRTF )->pOut_to_bin_re_dyn[i][j], mem_size_buf ) ) != IVAS_ERR_OK )
+#endif
             {
                 return error;
             }
@@ -1262,7 +1395,11 @@ static ivas_error create_Crend_HRTF_from_rawdata(
     {
         for ( j = 0; j < BINAURAL_CHANNELS; j++ )
         {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            if ( ( error = ivas_HRTF_binary_open_buffers_float( &( *hHRTF )->pOut_to_bin_im_dyn[i][j], mem_size_buf ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = ivas_HRTF_CRend_binary_open_buffers_float( &( *hHRTF )->pOut_to_bin_im_dyn[i][j], mem_size_buf ) ) != IVAS_ERR_OK )
+#endif
             {
                 return error;
             }
@@ -1297,7 +1434,11 @@ static ivas_error create_Crend_HRTF_from_rawdata(
         /* coeff_diffuse_re : The size depends on pIndex_frequency_max_diffuse */
         for ( j = 0; j < BINAURAL_CHANNELS; j++ )
         {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            if ( ( error = ivas_HRTF_binary_open_buffers_float( &( *hHRTF )->pOut_to_bin_diffuse_re_dyn[j], mem_size_buf ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = ivas_HRTF_CRend_binary_open_buffers_float( &( *hHRTF )->pOut_to_bin_diffuse_re_dyn[j], mem_size_buf ) ) != IVAS_ERR_OK )
+#endif
             {
                 return error;
             }
@@ -1322,7 +1463,11 @@ static ivas_error create_Crend_HRTF_from_rawdata(
         /* coeff_diffuse_im : The size depends on pIndex_frequency_max_diffuse */
         for ( j = 0; j < BINAURAL_CHANNELS; j++ )
         {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+            if ( ( error = ivas_HRTF_binary_open_buffers_float( &( *hHRTF )->pOut_to_bin_diffuse_im_dyn[j], mem_size_buf ) ) != IVAS_ERR_OK )
+#else
             if ( ( error = ivas_HRTF_CRend_binary_open_buffers_float( &( *hHRTF )->pOut_to_bin_diffuse_im_dyn[j], mem_size_buf ) ) != IVAS_ERR_OK )
+#endif
             {
                 return error;
             }
@@ -2016,6 +2161,9 @@ void destroy_crend_hrtf(
     IVAS_DEC_HRTF_CREND_HANDLE *hHrtfCrend /* i/o: Crend HRTF handle   */
 )
 {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_CRend_binary_close( hHrtfCrend );
+#else
     uint16_t i, j;
 
     if ( *hHrtfCrend != NULL && hHrtfCrend != NULL )
@@ -2057,6 +2205,7 @@ void destroy_crend_hrtf(
         free( *hHrtfCrend );
         *hHrtfCrend = NULL;
     }
+#endif
 
     return;
 }
@@ -2072,8 +2221,10 @@ void destroy_fastconv_hrtf(
     IVAS_DEC_HRTF_FASTCONV_HANDLE *hHrtfFastConv /* i/o: FastConv HRTF handle   */
 )
 {
+#ifndef FIX_2249_MEMORY_LEAK_IN_SBA
     /* Fastconv HRTF memories */
     ivas_binaural_hrtf_close( hHrtfFastConv );
+#endif
 
     /* Fastconv HRTF filters */
     ivas_HRTF_fastconv_binary_close( hHrtfFastConv );
@@ -2108,6 +2259,9 @@ void destroy_hrtf_statistics(
     IVAS_DEC_HRTF_STATISTICS_HANDLE *hHrtfStatistics /* i/o: HRTF statistics handle  */
 )
 {
+#ifdef FIX_2249_MEMORY_LEAK_IN_SBA
+    ivas_HRTF_statistics_binary_close( hHrtfStatistics );
+#else
     if ( ( hHrtfStatistics != NULL ) && ( *hHrtfStatistics != NULL ) && ( ( *hHrtfStatistics )->fromROM == FALSE ) )
     {
         if ( ( *hHrtfStatistics )->average_energy_l != NULL )
@@ -2125,6 +2279,6 @@ void destroy_hrtf_statistics(
     }
 
     ivas_HRTF_statistics_close( hHrtfStatistics );
-
+#endif
     return;
 }