diff --git a/lib_com/options.h b/lib_com/options.h
index 222333bc33f7bf9e3756855525e6bce239b61f46..d371a424f5f939265aa523b37cafe4a7130ac304 100644
--- a/lib_com/options.h
+++ b/lib_com/options.h
@@ -158,6 +158,8 @@
 
 #define ALIGN_SID_SIZE                                  /* Issue 111: make all DTX modes use one SID frame bitrate (5.2 kbps) */
 
+#define FIX_I78                                         /* Issue 78: replace malloc by count_malloc to fix memory counting in DirAC*/
+
 /* ################## End DEVELOPMENT switches ######################### */
 /* clang-format on */
 #endif
diff --git a/lib_dec/ivas_dirac_dec.c b/lib_dec/ivas_dirac_dec.c
index 162002852b00b71c83d712dac0772086f5731525..5bca49c962da81b2ef4884513c3d4a1832fd0e5b 100644
--- a/lib_dec/ivas_dirac_dec.c
+++ b/lib_dec/ivas_dirac_dec.c
@@ -1120,16 +1120,37 @@ static void ivas_dirac_alloc_mem(
     hDirAC_mem->frame_dec_f = NULL;
     if ( hDirAC->synthesisConf != DIRAC_SYNTHESIS_GAIN_SHD )
     {
+#ifdef FIX_I78
+        hDirAC_mem->cy_auto_dir_smooth = (float *) count_malloc( sizeof( float ) * size );
+#else
         hDirAC_mem->cy_auto_dir_smooth = (float *) malloc( sizeof( float ) * size );
+#endif
         set_zero( hDirAC_mem->cy_auto_dir_smooth, size );
+#ifdef FIX_I78
+        hDirAC_mem->proto_power_smooth = (float *) count_malloc( sizeof( float ) * size );
+#else
         hDirAC_mem->proto_power_smooth = (float *) malloc( sizeof( float ) * size );
+#endif
         set_zero( hDirAC_mem->proto_power_smooth, size );
+#ifdef FIX_I78
+        hDirAC_mem->proto_power_diff_smooth = (float *) count_malloc( sizeof( float ) * size );
+#else
         hDirAC_mem->proto_power_diff_smooth = (float *) malloc( sizeof( float ) * size );
+#endif
         set_zero( hDirAC_mem->proto_power_diff_smooth, size );
+#ifdef FIX_I78
+        hDirAC_mem->direct_responses_square = (float *) count_malloc( sizeof( float ) * size );
+#else
         hDirAC_mem->direct_responses_square = (float *) malloc( sizeof( float ) * size );
+#endif
+
         set_zero( hDirAC_mem->direct_responses_square, size );
 
+#ifdef FIX_I78
+        hDirAC_mem->frame_dec_f = (float *) count_malloc( sizeof( float ) * 2 * num_outputs_diff * num_freq_bands );
+#else
         hDirAC_mem->frame_dec_f = (float *) malloc( sizeof( float ) * 2 * num_outputs_diff * num_freq_bands );
+#endif
     }
     hDirAC->h_output_synthesis_psd_state.proto_power_smooth = hDirAC_mem->proto_power_smooth;
     hDirAC->h_output_synthesis_psd_state.proto_power_diff_smooth = hDirAC_mem->proto_power_diff_smooth;
@@ -1137,42 +1158,75 @@ static void ivas_dirac_alloc_mem(
     hDirAC->h_output_synthesis_psd_state.direct_responses_square = hDirAC_mem->direct_responses_square;
 
     /* Target and smoothed nrg factors/gains */
+#ifdef FIX_I78
+    hDirAC_mem->cy_cross_dir_smooth = (float *) count_malloc( sizeof( float ) * size );
+#else
     hDirAC_mem->cy_cross_dir_smooth = (float *) malloc( sizeof( float ) * size );
+#endif
     set_zero( hDirAC_mem->cy_cross_dir_smooth, size );
     if ( hDirAC->synthesisConf != DIRAC_SYNTHESIS_GAIN_SHD )
     {
+#ifdef FIX_I78
+        hDirAC_mem->cy_auto_diff_smooth = (float *) count_malloc( sizeof( float ) * size );
+#else
         hDirAC_mem->cy_auto_diff_smooth = (float *) malloc( sizeof( float ) * size );
+#endif
         set_zero( hDirAC_mem->cy_auto_diff_smooth, size );
     }
     else
     {
+#ifdef FIX_I78
+        hDirAC_mem->cy_auto_diff_smooth = (float *) count_malloc( sizeof( float ) * num_outputs_diff * num_freq_bands_diff );
+#else
         hDirAC_mem->cy_auto_diff_smooth = (float *) malloc( sizeof( float ) * num_outputs_diff * num_freq_bands_diff );
+#endif
         set_zero( hDirAC_mem->cy_auto_diff_smooth, num_outputs_diff * num_freq_bands_diff );
     }
     hDirAC->h_output_synthesis_psd_state.cy_cross_dir_smooth = hDirAC_mem->cy_cross_dir_smooth;
     hDirAC->h_output_synthesis_psd_state.cy_auto_diff_smooth = hDirAC_mem->cy_auto_diff_smooth;
 
     /*Responses (gains/factors)*/
+#ifdef FIX_I78
+    hDirAC_mem->direct_responses = (float *) count_malloc( sizeof( float ) * size );
+#else
     hDirAC_mem->direct_responses = (float *) malloc( sizeof( float ) * size );
+#endif
     set_zero( hDirAC_mem->direct_responses, size );
     hDirAC->h_output_synthesis_psd_state.direct_responses = hDirAC_mem->direct_responses;
 
-    /* Prototypes */
+/* Prototypes */
+#ifdef FIX_I78
+    hDirAC_mem->proto_direct_buffer_f = (float *) count_malloc( sizeof( float ) * 2 * MAX_PARAM_SPATIAL_SUBFRAMES * num_protos_dir * num_freq_bands );
+#else
     hDirAC_mem->proto_direct_buffer_f = (float *) malloc( sizeof( float ) * 2 * MAX_PARAM_SPATIAL_SUBFRAMES * num_protos_dir * num_freq_bands );
+#endif
     if ( hDirAC->synthesisConf == DIRAC_SYNTHESIS_PSD_SHD )
     {
+#ifdef FIX_I78
+        hDirAC_mem->proto_diffuse_buffer_f = (float *) count_malloc( sizeof( float ) * 2 * MAX_PARAM_SPATIAL_SUBFRAMES * size );
+#else
         hDirAC_mem->proto_diffuse_buffer_f = (float *) malloc( sizeof( float ) * 2 * MAX_PARAM_SPATIAL_SUBFRAMES * size );
+#endif
     }
     else
     {
+#ifdef FIX_I78
+        hDirAC_mem->proto_diffuse_buffer_f = (float *) count_malloc( sizeof( float ) * 2 * MAX_PARAM_SPATIAL_SUBFRAMES * num_outputs_diff * num_freq_bands );
+#else
         hDirAC_mem->proto_diffuse_buffer_f = (float *) malloc( sizeof( float ) * 2 * MAX_PARAM_SPATIAL_SUBFRAMES * num_outputs_diff * num_freq_bands );
+#endif
     }
     hDirAC->h_output_synthesis_psd_state.proto_direct_buffer_f = hDirAC_mem->proto_direct_buffer_f;
     hDirAC->h_output_synthesis_psd_state.proto_diffuse_buffer_f = hDirAC_mem->proto_diffuse_buffer_f;
 
     /* Gains/power factors*/
+#ifdef FIX_I78
+    hDirAC_mem->direct_power_factor = (float *) count_malloc( sizeof( float ) * num_freq_bands );
+    hDirAC_mem->diffuse_power_factor = (float *) count_malloc( sizeof( float ) * num_freq_bands );
+#else
     hDirAC_mem->direct_power_factor = (float *) malloc( sizeof( float ) * num_freq_bands );
     hDirAC_mem->diffuse_power_factor = (float *) malloc( sizeof( float ) * num_freq_bands );
+#endif
     hDirAC->h_output_synthesis_psd_state.direct_power_factor = hDirAC_mem->direct_power_factor;
     hDirAC->h_output_synthesis_psd_state.diffuse_power_factor = hDirAC_mem->diffuse_power_factor;
 
@@ -1180,20 +1234,37 @@ static void ivas_dirac_alloc_mem(
     hDirAC_mem->onset_filter = NULL;
     if ( hDirAC->synthesisConf != DIRAC_SYNTHESIS_GAIN_SHD )
     {
+#ifdef FIX_I78
+        hDirAC_mem->reference_power = (float *) count_malloc( sizeof( float ) * 2 * num_freq_bands );
+        hDirAC_mem->onset_filter = (float *) count_malloc( sizeof( float ) * num_outputs_diff * num_freq_bands );
+#else
         hDirAC_mem->reference_power = (float *) malloc( sizeof( float ) * 2 * num_freq_bands );
         hDirAC_mem->onset_filter = (float *) malloc( sizeof( float ) * num_outputs_diff * num_freq_bands );
+#endif
     }
     else
     {
         if ( num_protos_dir > 2 )
         {
+#ifdef FIX_I78
+            hDirAC_mem->reference_power = (float *) count_malloc( sizeof( float ) * 5 * num_freq_bands );
+#else
             hDirAC_mem->reference_power = (float *) malloc( sizeof( float ) * 5 * num_freq_bands );
+#endif
         }
         else
         {
+#ifdef FIX_I78
+            hDirAC_mem->reference_power = (float *) count_malloc( sizeof( float ) * num_freq_bands );
+#else
             hDirAC_mem->reference_power = (float *) malloc( sizeof( float ) * num_freq_bands );
+#endif
         }
+#ifdef FIX_I78
+        hDirAC_mem->onset_filter = (float *) count_malloc( sizeof( float ) * 2 * num_freq_bands );
+#else
         hDirAC_mem->onset_filter = (float *) malloc( sizeof( float ) * 2 * num_freq_bands );
+#endif
     }
 
     return;
@@ -1205,59 +1276,115 @@ static void ivas_dirac_free_mem(
 {
     if ( hDirAC_mem->cy_auto_dir_smooth != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->cy_auto_dir_smooth );
+#else
         free( hDirAC_mem->cy_auto_dir_smooth );
+#endif
     }
     if ( hDirAC_mem->proto_power_smooth != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->proto_power_smooth );
+#else
         free( hDirAC_mem->proto_power_smooth );
+#endif
     }
     if ( hDirAC_mem->proto_power_diff_smooth != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->proto_power_diff_smooth );
+#else
         free( hDirAC_mem->proto_power_diff_smooth );
+#endif
     }
     if ( hDirAC_mem->direct_responses_square != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->direct_responses_square );
+#else
         free( hDirAC_mem->direct_responses_square );
+#endif
     }
     if ( hDirAC_mem->frame_dec_f != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->frame_dec_f );
+#else
         free( hDirAC_mem->frame_dec_f );
+#endif
     }
     if ( hDirAC_mem->cy_cross_dir_smooth != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->cy_cross_dir_smooth );
+#else
         free( hDirAC_mem->cy_cross_dir_smooth );
+#endif
     }
     if ( hDirAC_mem->cy_auto_diff_smooth != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->cy_auto_diff_smooth );
+#else
         free( hDirAC_mem->cy_auto_diff_smooth );
+#endif
     }
     if ( hDirAC_mem->direct_responses != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->direct_responses );
+#else
         free( hDirAC_mem->direct_responses );
+#endif
     }
     if ( hDirAC_mem->proto_direct_buffer_f != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->proto_direct_buffer_f );
+#else
         free( hDirAC_mem->proto_direct_buffer_f );
+#endif
     }
     if ( hDirAC_mem->proto_diffuse_buffer_f != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->proto_diffuse_buffer_f );
+#else
         free( hDirAC_mem->proto_diffuse_buffer_f );
+#endif
     }
     if ( hDirAC_mem->direct_power_factor != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->direct_power_factor );
+#else
         free( hDirAC_mem->direct_power_factor );
+#endif
     }
     if ( hDirAC_mem->diffuse_power_factor != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->diffuse_power_factor );
+#else
         free( hDirAC_mem->diffuse_power_factor );
+#endif
     }
     if ( hDirAC_mem->reference_power != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->reference_power );
+#else
         free( hDirAC_mem->reference_power );
+#endif
     }
     if ( hDirAC_mem->onset_filter != NULL )
     {
+#ifdef FIX_I78
+        count_free( hDirAC_mem->onset_filter );
+#else
         free( hDirAC_mem->onset_filter );
+#endif
     }
 
     return;