Ticket #66: tracemem.patch

build/linux/lib/TLibCommon/makefile

@@ -54 +54 @@
                         $(OBJ_DIR)/TComSlice.o \
                         $(OBJ_DIR)/TComTrQuant.o \
                         $(OBJ_DIR)/TComYuv.o \
+                        $(OBJ_DIR)/tool_tracemem.o \
 
 LIBS                            = -lpthread
 

build/vc8/TLibCommon_vc8.vcproj

@@ -363 +363 @@
                                 RelativePath="..\..\source\Lib\TLibCommon\TComYuv.cpp"
                                 >
                         </File>
+                        <File
+                                RelativePath="..\..\source\Lib\TLibCommon\tool_tracemem.cpp"
+                                >
+                        </File>
                 </Filter>
                 <Filter
                         Name="Header Files"
@@ -478 +482 @@
                                 >
                         </File>
                         <File
+                                RelativePath="..\..\source\Lib\TLibCommon\tool_tracemem.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\source\Lib\TLibCommon\TypeDef.h"
                                 >
                         </File>

build/vc9/TLibCommon_vc9.vcproj

@@ -366 +366 @@
                                 RelativePath="..\..\source\Lib\TLibCommon\TComYuv.cpp"
                                 >
                         </File>
+                        <File
+                                RelativePath="..\..\source\Lib\TLibCommon\tool_tracemem.cpp"
+                                >
+                        </File>
                 </Filter>
                 <Filter
                         Name="Header Files"
@@ -481 +485 @@
                                 >
                         </File>
                         <File
+                                RelativePath="..\..\source\Lib\TLibCommon\tool_tracemem.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\source\Lib\TLibCommon\TypeDef.h"
                                 >
                         </File>

source/App/TAppCommon/program_options_lite.cpp

@@ -15 +15 @@
 Options::~Options()
 {
         for(Options::NamesPtrList::iterator it = opt_list.begin(); it != opt_list.end(); it++) {
-                delete *it;
+                MEMDELETE( *it );
         }
 }
 
 void Options::addOption(OptionBase *opt)
 {
-        Names* names = new Names();
+        Names* names = MEMNEW Names();
         names->opt = opt;
         string& opt_string = opt->opt_string;
 

source/App/TAppCommon/program_options_lite.h

@@ -4 +4 @@
 #include <list>
 #include <map>
 
+#include "../../Lib/TLibCommon/tool_tracemem.h"
+
 namespace df {
 namespace program_options_lite {
 
@@ -100 +102 @@
                 Names() : opt(0) {};
                 ~Names() {
                         if (opt)
-                                delete opt;
+                                MEMDELETE( opt );
                 }
                 std::list<std::string> opt_long;
                 std::list<std::string> opt_short;
@@ -132 +134 @@
         template<typename T>
         OptionSpecific&
         operator()(const std::string& name, T& storage, T default_val, const std::string& desc = "") {
-                parent.addOption(new Option<T>(name, storage, default_val, desc));
+                parent.addOption(MEMNEW Option<T>(name, storage, default_val, desc));
                 return *this;
         }
 
@@ -145 +147 @@
          */
         OptionSpecific&
         operator()(const std::string& name, OptionFunc::Func *func, const std::string& desc = "") {
-                parent.addOption(new OptionFunc(name, parent, func, desc));
+                parent.addOption(MEMNEW OptionFunc(name, parent, func, desc));
                 return *this;
         }
 private:

source/App/TAppDecoder/decmain.cpp

@@ -37 +37 @@
 #include <time.h>
 #include "TAppDecTop.h"
 
+#include <cassert>
+#include "../../Lib/TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Main function
 // ====================================================================================================================
 
 int main(int argc, char* argv[])
 {
-  TAppDecTop  cTAppDecTop;
+  TAppDecTop  * pTAppDecTop = MEMNEW TAppDecTop;
+  assert( pTAppDecTop != NULL );
 
   // print information
   fprintf( stdout, "\n" );
@@ -54 +58 @@
   fprintf( stdout, "\n" );
 
   // create application decoder class
-  cTAppDecTop.create();
+  pTAppDecTop->create();
 
   // parse configuration
-  if(!cTAppDecTop.parseCfg( argc, argv ))
+  if(!pTAppDecTop->parseCfg( argc, argv ))
   {
-    cTAppDecTop.destroy();
+    pTAppDecTop->destroy();
     return 1;
   }
 
@@ -68 +72 @@
   long lBefore = clock();
 
   // call decoding function
-  cTAppDecTop.decode();
+  pTAppDecTop->decode();
 
   // ending time
   dResult = (double)(clock()-lBefore) / CLOCKS_PER_SEC;
   printf("\n Total Time: %12.3f sec.\n", dResult);
 
   // destroy application decoder class
-  cTAppDecTop.destroy();
+  pTAppDecTop->destroy();
+  MEMDELETE( pTAppDecTop );
+  pTAppDecTop = NULL;
 
+  // memory log
+  MEMTRACEINFO( stdout );
+
   return 0;
 }
 

source/App/TAppDecoder/TAppDecCfg.cpp

@@ -35 +35 @@
 
 #include "TAppDecCfg.h"
 
+#include "../../Lib/TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Public member functions
 // ====================================================================================================================
@@ -62 +64 @@
   if( ! m_apcOpt->hasOptions() || !m_apcOpt->getValue( 'b' ) )
   {
     m_apcOpt->printUsage();
-    delete m_apcOpt;
+    MEMDELETE( m_apcOpt );
     m_apcOpt = NULL;
     return false;
   }

source/App/TAppDecoder/TAppDecOption.cpp

@@ -66 +66 @@
 #include <cstring>
 #include "TAppDecOption.h"
 
+#include "../../Lib/TLibCommon/tool_tracemem.h"
+
 TAppOption::TAppOption()
 {
   init();
@@ -961 +963 @@
   length = int( is.tellg() );
   is.seekg (0, ios::beg);
 //        buffer = (char*) malloc(length*sizeof(char));
-  buffer = new char[length]; //kolya
+  buffer = MEMNEWARRAY char[length]; //kolya
   is.read (buffer, length);
   is.close();
   return buffer;
@@ -1001 +1003 @@
     cursor++; /* keep moving */
     linelength++;
   }
-  delete [] buffer; //kolya
+  MEMDELETEARRAY( buffer ); //kolya
   buffer = NULL;
   return true;
 }
@@ -1031 +1033 @@
 TAppOption::processLine( char *theline, int length  )
 {
   bool found = false;
-  char *pline = new char[length+1];
+  char *pline = MEMNEWARRAY char[length+1];
   for( int i = 0 ; i < length ; i ++ )
     pline[i]= *(theline++);
   pline[length] = nullterminate;
@@ -1055 +1057 @@
     if( !found ) /* not a pair */
       justValue( pline );
   }
-  delete [] pline;
+  MEMDELETEARRAY( pline );
   pline = NULL;
 }
 

source/App/TAppDecoder/TAppDecTop.cpp

@@ -61 +61 @@
 
 Void TAppDecTop::create()
 {
-  m_apcOpt        = new TAppOption();
-  m_apcBitstream  = new TComBitstream;
+  m_apcOpt        = MEMNEW TAppOption();
+  m_apcBitstream  = MEMNEW TComBitstream;
 
   m_apcBitstream->create( BITS_BUF_SIZE );
 }
@@ -71 +71 @@
 {
   if ( m_apcOpt )
   {
-    delete m_apcOpt;
+    MEMDELETE( m_apcOpt );
     m_apcOpt = NULL;
   }
   if ( m_apcBitstream )
   {
     m_apcBitstream->destroy();
-    delete m_apcBitstream;
+    MEMDELETE( m_apcBitstream );
     m_apcBitstream = NULL;
   }
 }

source/App/TAppEncoder/encmain.cpp

@@ -36 +36 @@
 #include <time.h>
 #include "TAppEncTop.h"
 
+#include <cassert>
+#include "../../Lib/TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Main function
 // ====================================================================================================================
 
 int main(int argc, char* argv[])
 {
-  TAppEncTop  cTAppEncTop;
+  TAppEncTop  * pTAppEncTop = MEMNEW TAppEncTop;
+  assert( pTAppEncTop != NULL );
 
   // print information
   fprintf( stdout, "\n" );
@@ -53 +57 @@
   fprintf( stdout, "\n" );
 
   // create application encoder class
-  cTAppEncTop.create();
+  pTAppEncTop->create();
 
   // parse configuration
-  if(!cTAppEncTop.parseCfg( argc, argv ))
+  if(!pTAppEncTop->parseCfg( argc, argv ))
   {
-    cTAppEncTop.destroy();
+    pTAppEncTop->destroy();
     return 1;
   }
 
@@ -67 +71 @@
   long lBefore = clock();
 
   // call encoding function
-  cTAppEncTop.encode();
+  pTAppEncTop->encode();
 
   // ending time
   dResult = (double)(clock()-lBefore) / CLOCKS_PER_SEC;
   printf("\n Total Time: %12.3f sec.\n", dResult);
 
   // destroy application encoder class
-  cTAppEncTop.destroy();
+  pTAppEncTop->destroy();
+  MEMDELETE( pTAppEncTop );
+  pTAppEncTop = NULL;
 
+  // memory log
+  MEMTRACEINFO( stdout );
+
   return 0;
 }
 

source/App/TAppEncoder/TAppEncCfg.cpp

@@ -40 +40 @@
 #include "TAppEncCfg.h"
 #include "../../App/TAppCommon/program_options_lite.h"
 
+#include "../../Lib/TLibCommon/tool_tracemem.h"
+
 #ifdef WIN32
 #define strdup _strdup
 #endif
@@ -75 +77 @@
 {
   if ( m_aidQP )
   {
-    delete[] m_aidQP;
+    MEMDELETEARRAY( m_aidQP );
   }
 }
 
@@ -289 +291 @@
   m_iSourceHeight += m_aiPad[1];
 
   // allocate slice-based dQP values
-  m_aidQP = new Int[ m_iFrameToBeEncoded + m_iRateGOPSize + 1 ];
+  m_aidQP = MEMNEWARRAY Int[ m_iFrameToBeEncoded + m_iRateGOPSize + 1 ];
   ::memset( m_aidQP, 0, sizeof(Int)*( m_iFrameToBeEncoded + m_iRateGOPSize + 1 ) );
 
   // handling of floating-point QP values

source/App/TAppEncoder/TAppEncTop.cpp

@@ -199 +199 @@
  */
 Void TAppEncTop::encode()
 {
-  TComPicYuv*       pcPicYuvOrg = new TComPicYuv;
+  TComPicYuv*       pcPicYuvOrg = MEMNEW TComPicYuv;
   TComPicYuv*       pcPicYuvRec = NULL;
   TComBitstream*    pcBitstream = NULL;
 
@@ -242 +242 @@
 
   // delete original YUV buffer
   pcPicYuvOrg->destroy();
-  delete pcPicYuvOrg;
+  MEMDELETE( pcPicYuvOrg );
   pcPicYuvOrg = NULL;
 
   // delete used buffers in encoder class
@@ -271 +271 @@
   {
     if (m_cListPicYuvRec.size() == 0)
     {
-      rpcPicYuvRec = new TComPicYuv;
-      rpcBitStream = new TComBitstream;
+      rpcPicYuvRec = MEMNEW TComPicYuv;
+      rpcBitStream = MEMNEW TComBitstream;
 
       rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
       rpcBitStream->create( (m_iSourceWidth * m_iSourceHeight * 3) >> 1 );
@@ -300 +300 @@
   }
   else
   {
-    rpcPicYuvRec = new TComPicYuv;
-    rpcBitStream = new TComBitstream;
+    rpcPicYuvRec = MEMNEW TComPicYuv;
+    rpcBitStream = MEMNEW TComBitstream;
 
     rpcPicYuvRec->create( m_iSourceWidth, m_iSourceHeight, m_uiMaxCUWidth, m_uiMaxCUHeight, m_uiMaxCUDepth );
     rpcBitStream->create( (m_iSourceWidth * m_iSourceHeight * 3) >> 1 );
@@ -325 +325 @@
     pcPicYuvRec->destroy();
     pcBitstream->destroy();
 
-    delete pcPicYuvRec; pcPicYuvRec = NULL;
-    delete pcBitstream; pcBitstream = NULL;
+    MEMDELETE( pcPicYuvRec ); pcPicYuvRec = NULL;
+    MEMDELETE( pcBitstream ); pcBitstream = NULL;
   }
 
 }

source/Lib/TLibCommon/CommonDef.h

@@ -122 +122 @@
 #define ClipMax(x)                  ( Min(g_uiBASE_MAX, x            ) )                              ///< clip with max. value
 #define Clip3( MinVal, MaxVal, a)   ( ((a)<(MinVal)) ? (MinVal) : (((a)>(MaxVal)) ? (MaxVal) :(a)) )  ///< general min/max clip
 
+#ifdef CTRL_USE_TRACEMEM
+#define xMalloc( type, len )        MEMNEWARRAY type[len]
+#define xFree( ptr )                MEMDELETEARRAY( ptr )
+#define calloc( num , size )            MEMNEW char[num*size]
+#define free( ptr )                                     MEMDELETE( ptr )
+#else
 #define DATA_ALIGN                  1                                                                 ///< use 32-bit aligned malloc/free
 #if     DATA_ALIGN && _WIN32 && ( _MSC_VER > 1300 )
 #define xMalloc( type, len )        _aligned_malloc( sizeof(type)*(len), 32 )
@@ -130 +136 @@
 #define xMalloc( type, len )        malloc   ( sizeof(type)*(len) )
 #define xFree( ptr )                free     ( ptr )
 #endif
+#endif
 
 // ====================================================================================================================
 // Bug fixes

source/Lib/TLibCommon/ContextModel3DBuffer.cpp

@@ -35 +35 @@
 
 #include "ContextModel3DBuffer.h"
 
+#include "tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / initialization / destroy
 // ====================================================================================================================
@@ -47 +49 @@
 
 {
   // allocate 3D buffer
-  m_pcContextModel = new ContextModel[ uiSizeZ * m_uiSizeY * m_uiSizeX ];
+  m_pcContextModel = MEMNEWARRAY ContextModel[ uiSizeZ * m_uiSizeY * m_uiSizeX ];
 }
 
 ContextModel3DBuffer::~ContextModel3DBuffer()
 {
   // delete 3D buffer
-  delete [] m_pcContextModel;
+  MEMDELETEARRAY( m_pcContextModel );
   m_pcContextModel = NULL;
 }
 

source/Lib/TLibCommon/TComAdaptiveLoopFilter.cpp

@@ -39 +39 @@
 #include <stdio.h>
 #include <math.h>
 
+#include "tool_tracemem.h"
+
 #if HHI_ALF
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
@@ -53 +55 @@
 {
   if ( !m_pcTempPicYuv )
   {
-    m_pcTempPicYuv = new TComPicYuv;
+    m_pcTempPicYuv = MEMNEW TComPicYuv;
     m_pcTempPicYuv->create( iPicWidth, iPicHeight, uiMaxCUWidth, uiMaxCUHeight, uiMaxCUDepth );
   }
 }
@@ -63 +65 @@
   if ( m_pcTempPicYuv )
   {
     m_pcTempPicYuv->destroy();
-    delete m_pcTempPicYuv;
+    MEMDELETE( m_pcTempPicYuv );
   }
 }
 
@@ -81 +83 @@
   pAlfParam->pcQuadTree = NULL;
   pAlfParam->bSeparateQt = false;
 
-  pAlfParam->acHorizontalAlfFilter   = new AlfFilter[ ALF_FILT_FOR_CHROMA +1 ];
-  pAlfParam->acVerticalAlfFilter     = new AlfFilter[ ALF_FILT_FOR_CHROMA +1 ];
+  pAlfParam->acHorizontalAlfFilter   = MEMNEWARRAY AlfFilter[ ALF_FILT_FOR_CHROMA +1 ];
+  pAlfParam->acVerticalAlfFilter     = MEMNEWARRAY AlfFilter[ ALF_FILT_FOR_CHROMA +1 ];
 
   ::memset(pAlfParam->acHorizontalAlfFilter,  0, sizeof(AlfFilter)*( ALF_FILT_FOR_CHROMA +1 ) );
   ::memset(pAlfParam->acVerticalAlfFilter  ,  0, sizeof(AlfFilter)*( ALF_FILT_FOR_CHROMA +1 ) );
@@ -90 +92 @@
 
   pAlfParam->acHorizontalAlfFilter[ 0 ].bIsHorizontal         = true;
   pAlfParam->acHorizontalAlfFilter[ 0 ].bIsVertical           = false;
-  pAlfParam->acHorizontalAlfFilter[ 0 ].aiQuantFilterCoeffs   = new Int[ALF_MAX_NUM_COEF];
-  pAlfParam->acHorizontalAlfFilter[ 0 ].aiTapCoeffMapping     = new Int[ALF_MAX_NUM_COEF];
-  pAlfParam->acHorizontalAlfFilter[ 0 ].aiCoeffWeights        = new Int[ALF_MAX_NUM_COEF];
+  pAlfParam->acHorizontalAlfFilter[ 0 ].aiQuantFilterCoeffs   = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+  pAlfParam->acHorizontalAlfFilter[ 0 ].aiTapCoeffMapping     = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+  pAlfParam->acHorizontalAlfFilter[ 0 ].aiCoeffWeights        = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
   pAlfParam->acVerticalAlfFilter  [ 0 ].bIsHorizontal         = false;
   pAlfParam->acVerticalAlfFilter  [ 0 ].bIsVertical           = true;
-  pAlfParam->acVerticalAlfFilter  [ 0 ].aiQuantFilterCoeffs   = new Int[ALF_MAX_NUM_COEF];
-  pAlfParam->acVerticalAlfFilter  [ 0 ].aiTapCoeffMapping     = new Int[ALF_MAX_NUM_COEF];
-  pAlfParam->acVerticalAlfFilter  [ 0 ].aiCoeffWeights        = new Int[ALF_MAX_NUM_COEF];
+  pAlfParam->acVerticalAlfFilter  [ 0 ].aiQuantFilterCoeffs   = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+  pAlfParam->acVerticalAlfFilter  [ 0 ].aiTapCoeffMapping     = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+  pAlfParam->acVerticalAlfFilter  [ 0 ].aiCoeffWeights        = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
   ::memset( pAlfParam->acHorizontalAlfFilter[ 0 ].aiQuantFilterCoeffs , 0 , sizeof(Int) * ALF_MAX_NUM_COEF );
   ::memset( pAlfParam->acHorizontalAlfFilter[ 0 ].aiTapCoeffMapping   , 0 , sizeof(Int) * ALF_MAX_NUM_COEF );
   ::memset( pAlfParam->acHorizontalAlfFilter[ 0 ].aiCoeffWeights      , 0 , sizeof(Int) * ALF_MAX_NUM_COEF );
@@ -109 +111 @@
   {
     pAlfParam->acHorizontalAlfFilter[ uiIndx ].bIsHorizontal         = true;
     pAlfParam->acHorizontalAlfFilter[ uiIndx ].bIsVertical           = false;
-    pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiQuantFilterCoeffs   = new Int[ALF_MAX_NUM_COEF];
+    pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiQuantFilterCoeffs   = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
     pAlfParam->acVerticalAlfFilter  [ uiIndx ].bIsHorizontal         = false;
     pAlfParam->acVerticalAlfFilter  [ uiIndx ].bIsVertical           = true;
-    pAlfParam->acVerticalAlfFilter  [ uiIndx ].aiQuantFilterCoeffs   = new Int[ALF_MAX_NUM_COEF];
-    pAlfParam->acVerticalAlfFilter  [ uiIndx ].aiTapCoeffMapping     = new Int[ALF_MAX_NUM_COEF];
-    pAlfParam->acVerticalAlfFilter  [ uiIndx ].aiCoeffWeights        = new Int[ALF_MAX_NUM_COEF];
-    pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiTapCoeffMapping     = new Int[ALF_MAX_NUM_COEF];
-    pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiCoeffWeights        = new Int[ALF_MAX_NUM_COEF];
+    pAlfParam->acVerticalAlfFilter  [ uiIndx ].aiQuantFilterCoeffs   = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+    pAlfParam->acVerticalAlfFilter  [ uiIndx ].aiTapCoeffMapping     = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+    pAlfParam->acVerticalAlfFilter  [ uiIndx ].aiCoeffWeights        = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+    pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiTapCoeffMapping     = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+    pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiCoeffWeights        = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
     ::memset( pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiQuantFilterCoeffs , 0 , sizeof(Int) * ALF_MAX_NUM_COEF );
     ::memset( pAlfParam->acVerticalAlfFilter  [ uiIndx ].aiQuantFilterCoeffs , 0 , sizeof(Int) * ALF_MAX_NUM_COEF );
     ::memset( pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiTapCoeffMapping   , 0 , sizeof(Int) * ALF_MAX_NUM_COEF );
@@ -138 +140 @@
     {
       if( pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiQuantFilterCoeffs != NULL )
       {
-        delete[] pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiQuantFilterCoeffs;
+        MEMDELETEARRAY( pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiQuantFilterCoeffs );
         pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiQuantFilterCoeffs = NULL;
       }
       if( pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiTapCoeffMapping != NULL )
       {
-        delete[] pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiTapCoeffMapping;
+        MEMDELETEARRAY( pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiTapCoeffMapping );
         pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiTapCoeffMapping = NULL;
       }
       if( pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiCoeffWeights != NULL )
       {
-        delete[] pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiCoeffWeights;
+        MEMDELETEARRAY( pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiCoeffWeights );
         pAlfParam->acHorizontalAlfFilter[ uiIndx ].aiCoeffWeights = NULL;
       }
     }
-    delete[] pAlfParam->acHorizontalAlfFilter;
+    MEMDELETEARRAY( pAlfParam->acHorizontalAlfFilter );
     pAlfParam->acHorizontalAlfFilter = NULL;
   }
 
@@ -163 +165 @@
       {
         if( pAlfParam->acVerticalAlfFilter[ uiIndx ].aiQuantFilterCoeffs != NULL )
         {
-          delete[] pAlfParam->acVerticalAlfFilter[ uiIndx ].aiQuantFilterCoeffs;
+          MEMDELETEARRAY( pAlfParam->acVerticalAlfFilter[ uiIndx ].aiQuantFilterCoeffs );
           pAlfParam->acVerticalAlfFilter[ uiIndx ].aiQuantFilterCoeffs = NULL;
         }
         if( pAlfParam->acVerticalAlfFilter[ uiIndx ].aiTapCoeffMapping != NULL )
         {
-          delete[] pAlfParam->acVerticalAlfFilter[ uiIndx ].aiTapCoeffMapping;
+          MEMDELETEARRAY( pAlfParam->acVerticalAlfFilter[ uiIndx ].aiTapCoeffMapping );
           pAlfParam->acVerticalAlfFilter[ uiIndx ].aiTapCoeffMapping = NULL;
         }
         if( pAlfParam->acVerticalAlfFilter[ uiIndx ].aiCoeffWeights != NULL )
         {
-          delete[] pAlfParam->acVerticalAlfFilter[ uiIndx ].aiCoeffWeights;
+          MEMDELETEARRAY( pAlfParam->acVerticalAlfFilter[ uiIndx ].aiCoeffWeights );
           pAlfParam->acVerticalAlfFilter[ uiIndx ].aiCoeffWeights = NULL;
         }
       }
-      delete[] pAlfParam->acVerticalAlfFilter;
+      MEMDELETEARRAY( pAlfParam->acVerticalAlfFilter );
       pAlfParam->acVerticalAlfFilter = NULL;
     }
 
@@ -188 +190 @@
 Void TComAdaptiveLoopFilter::destroyQuadTree(ALFParam* pcAlfParam)
 {
   pcAlfParam->pcQuadTree->destroy();
-  delete pcAlfParam->pcQuadTree;
+  MEMDELETE( pcAlfParam->pcQuadTree );
   pcAlfParam->pcQuadTree = NULL;
 }
 
@@ -383 +385 @@
   if(pcAlfParam->cu_control_flag && iPlane ==0 )
   {
     // block-adaptive ALF process
-    TComPicYuv* pcTempPicYuv2 = new TComPicYuv;
+    TComPicYuv* pcTempPicYuv2 = MEMNEW TComPicYuv;
     pcTempPicYuv2->create( pcPicRest->getWidth(), pcPicRest->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
     pcPicRest->copyToPicLuma( pcTempPicYuv2 );
     xApplyFrame      ( pcPicRest, m_pcTempPicYuv , pcAlfParam->acVerticalAlfFilter  [0] );
@@ -391 +393 @@
     //xCUAdaptive      ( m_pcAlfQuadTree, pcAlfParam->acHorizontalAlfFilter[0] , m_pcTempPicYuv, pcPicRest );
     xCopyDecToRestCUs( pcAlfParam->pcQuadTree ,  pcTempPicYuv2 , pcPicRest );
     pcTempPicYuv2->destroy();
-    delete pcTempPicYuv2;
+    MEMDELETE( pcTempPicYuv2 );
   }
   else
   {
@@ -1261 +1263 @@
 {
         if ( !m_pcTempPicYuv )
         {
-                m_pcTempPicYuv = new TComPicYuv;
+                m_pcTempPicYuv = MEMNEW TComPicYuv;
                 m_pcTempPicYuv->create( iPicWidth, iPicHeight, uiMaxCUWidth, uiMaxCUHeight, uiMaxCUDepth );
         }
 #if QC_ALF
@@ -1285 +1287 @@
         if ( m_pcTempPicYuv )
         {
                 m_pcTempPicYuv->destroy();
-                delete m_pcTempPicYuv;
+                MEMDELETE( m_pcTempPicYuv );
         }
 #if QC_ALF
         destroyMatrix_imgpel(imgY_var); 
@@ -1313 +1315 @@
 {
   pAlfParam->alf_flag = 0;
 
-  pAlfParam->coeff                              = new Int[ALF_MAX_NUM_COEF];
-  pAlfParam->coeff_chroma = new Int[ALF_MAX_NUM_COEF_C];
+  pAlfParam->coeff                              = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
+  pAlfParam->coeff_chroma = MEMNEWARRAY Int[ALF_MAX_NUM_COEF_C];
 
   ::memset(pAlfParam->coeff,                            0, sizeof(Int)*ALF_MAX_NUM_COEF         );
   ::memset(pAlfParam->coeff_chroma, 0, sizeof(Int)*ALF_MAX_NUM_COEF_C   );
 #if QC_ALF
-  pAlfParam->coeffmulti = new Int*[NO_VAR_BINS];
+  pAlfParam->coeffmulti = MEMNEWARRAY Int*[NO_VAR_BINS];
   for (int i=0; i<NO_VAR_BINS; i++)
   {
-    pAlfParam->coeffmulti[i] = new Int[ALF_MAX_NUM_COEF];
+    pAlfParam->coeffmulti[i] = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
     ::memset(pAlfParam->coeffmulti[i],                          0, sizeof(Int)*ALF_MAX_NUM_COEF         );
   }
 #endif
@@ -1334 +1336 @@
 
   if (pAlfParam->coeff != NULL)
   {
-    delete[] pAlfParam->coeff;
+    MEMDELETEARRAY( pAlfParam->coeff );
     pAlfParam->coeff = NULL;
   }
 
   if (pAlfParam->coeff_chroma != NULL)
   {
-    delete[] pAlfParam->coeff_chroma;
+    MEMDELETEARRAY( pAlfParam->coeff_chroma );
     pAlfParam->coeff_chroma = NULL;
   }
 #if QC_ALF
   for (int i=0; i<NO_VAR_BINS; i++)
   {
-    delete[] pAlfParam->coeffmulti[i];
+    MEMDELETEARRAY( pAlfParam->coeffmulti[i] );
     pAlfParam->coeffmulti[i] = NULL;
   }
-  delete[] pAlfParam->coeffmulti;
+  MEMDELETEARRAY( pAlfParam->coeffmulti );
   pAlfParam->coeffmulti = NULL;
 #endif
 }

source/Lib/TLibCommon/TComBitBuffer.cpp

@@ -35 +35 @@
 
 #include "TComBitBuffer.h"
 
+#include "tool_tracemem.h"
 
 TComBitBuffer::TComBitBuffer()
-: m_puiBuffer   ( new UInt [ STD_BIT_BUFFER_ALLOC_SIZE ] )
+: m_puiBuffer   ( MEMNEWARRAY UInt [ STD_BIT_BUFFER_ALLOC_SIZE ] )
 , m_uiBufferSize( STD_BIT_BUFFER_ALLOC_SIZE )
 , m_uiWriteElemIdx  (  0 )
 , m_uiWriteAvailBits( 32 )
@@ -48 +49 @@
 
 TComBitBuffer::~TComBitBuffer()
 {
-  delete [] m_puiBuffer;
+  MEMDELETEARRAY( m_puiBuffer );
 }
 
 Void
 TComBitBuffer::xIncreaseBufferSize()
 {
   UInt  uiNewBufferSize = ( m_uiBufferSize << 1 );
-  UInt* puiNewBuffer    = new UInt [ uiNewBufferSize ];
+  UInt* puiNewBuffer    = MEMNEWARRAY UInt [ uiNewBufferSize ];
   ::memcpy( puiNewBuffer, m_puiBuffer, m_uiBufferSize * sizeof( UInt ) );
-  delete [] m_puiBuffer;
+  MEMDELETEARRAY( m_puiBuffer );
   m_puiBuffer     = puiNewBuffer;
   m_uiBufferSize  = uiNewBufferSize;
 }

source/Lib/TLibCommon/TComBitStream.cpp

@@ -36 +36 @@
 #include "TComBitStream.h"
 #include <memory.h>
 
+#include "tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
 // ====================================================================================================================
@@ -44 +46 @@
 {
   UInt uiSize = uiSizeInBytes / sizeof(UInt);
   
-  m_apulStreamPacketBegin = new UInt[uiSize];
+  m_apulStreamPacketBegin = MEMNEWARRAY UInt[uiSize];
   m_uiBufSize       = uiSize;
   m_uiBitSize       = 0;
   m_iValidBits      = 32;
@@ -57 +59 @@
 
 Void TComBitstream::destroy()
 {
-  delete [] m_apulStreamPacketBegin;     m_apulStreamPacketBegin = NULL;
+  MEMDELETEARRAY( m_apulStreamPacketBegin );     m_apulStreamPacketBegin = NULL;
 }
 
 // ====================================================================================================================
@@ -313 +315 @@
   //make sure start pos is inside the buffer
 //  assert( uiStartPos > uiBytesInBuffer );
   
-  UChar* pucRead = new UChar[ uiBytesInBuffer ];
+  UChar* pucRead = MEMNEWARRAY UChar[ uiBytesInBuffer ];
   //th this is not nice but ...
   memcpy( pucRead, getStartStream(), uiBytesInBuffer );
 
@@ -340 +342 @@
     }
   }
 
-  delete [] pucRead;
+  MEMDELETEARRAY( pucRead );
   m_uiBitsWritten = uiWriteOffset << 3;
 }
 #endif

source/Lib/TLibCommon/TComLoopFilter.cpp

@@ -37 +37 @@
 #include "TComSlice.h"
 #include "TComMv.h"
 
+#include "tool_tracemem.h"
+
 // ====================================================================================================================
 // Constants
 // ====================================================================================================================
@@ -112 +114 @@
   for( UInt uiDir = 0; uiDir < 2; uiDir++ )
     for( UInt uiPlane = 0; uiPlane < 3; uiPlane++ )
     {
-      m_aapucBS       [uiDir][uiPlane] = new UChar[m_uiNumPartitions];
-      m_aapbEdgeFilter[uiDir][uiPlane] = new Bool [m_uiNumPartitions];
+      m_aapucBS       [uiDir][uiPlane] = MEMNEWARRAY UChar[m_uiNumPartitions];
+      m_aapbEdgeFilter[uiDir][uiPlane] = MEMNEWARRAY Bool [m_uiNumPartitions];
     }
 }
 
@@ -122 +124 @@
   for( UInt uiDir = 0; uiDir < 2; uiDir++ )
     for( UInt uiPlane = 0; uiPlane < 3; uiPlane++ )
     {
-      delete [] m_aapucBS       [uiDir][uiPlane];
-      delete [] m_aapbEdgeFilter[uiDir][uiPlane];
+      MEMDELETEARRAY( m_aapucBS       [uiDir][uiPlane] );
+      MEMDELETEARRAY( m_aapbEdgeFilter[uiDir][uiPlane] );
     }
 }
 #endif

source/Lib/TLibCommon/TComPic.cpp

@@ -35 +35 @@
 
 #include "TComPic.h"
 
+#include "tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
 // ====================================================================================================================
@@ -59 +61 @@
 
 Void TComPic::create( Int iWidth, Int iHeight, UInt uiMaxWidth, UInt uiMaxHeight, UInt uiMaxDepth, Bool bIsVirtual )
 {
-  m_apcPicSym     = new TComPicSym;  m_apcPicSym   ->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
+  m_apcPicSym     = MEMNEW TComPicSym;  m_apcPicSym   ->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
   if (!bIsVirtual)
   {
-    m_apcPicYuv[0]  = new TComPicYuv;  m_apcPicYuv[0]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
+    m_apcPicYuv[0]  = MEMNEW TComPicYuv;  m_apcPicYuv[0]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
   }
-  m_apcPicYuv[1]  = new TComPicYuv;  m_apcPicYuv[1]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
+  m_apcPicYuv[1]  = MEMNEW TComPicYuv;  m_apcPicYuv[1]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
 
 #if HHI_INTERP_FILTER
   // buffer for filtered reconstructed pic
-  m_apcPicYuv[2]  = new TComPicYuv;  m_apcPicYuv[2]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
+  m_apcPicYuv[2]  = MEMNEW TComPicYuv;  m_apcPicYuv[2]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth );
 #endif
 
   return;
@@ -79 +81 @@
   if (m_apcPicSym)
   {
     m_apcPicSym->destroy();
-    delete m_apcPicSym;
+    MEMDELETE( m_apcPicSym );
     m_apcPicSym = NULL;
   }
 
   if (m_apcPicYuv[0])
   {
     m_apcPicYuv[0]->destroy();
-    delete m_apcPicYuv[0];
+    MEMDELETE( m_apcPicYuv[0] );
     m_apcPicYuv[0]  = NULL;
   }
 
   if (m_apcPicYuv[1])
   {
     m_apcPicYuv[1]->destroy();
-    delete m_apcPicYuv[1];
+    MEMDELETE( m_apcPicYuv[1] );
     m_apcPicYuv[1]  = NULL;
   }
 
@@ -101 +103 @@
   if (m_apcPicYuv[2])
   {
     m_apcPicYuv[2]->destroy();
-    delete m_apcPicYuv[2];
+    MEMDELETE( m_apcPicYuv[2] );
     m_apcPicYuv[2]  = NULL;
   }
 #endif

source/Lib/TLibCommon/TComPicSym.cpp

@@ -35 +35 @@
 
 #include "TComPicSym.h"
 
+#include "tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
 // ====================================================================================================================
@@ -43 +45 @@
 {
   UInt i;
 
-  m_apcTComSlice      = new TComSlice;
+  m_apcTComSlice      = MEMNEW TComSlice;
 
   m_uhTotalDepth      = uiMaxDepth;
   m_uiNumPartitions   = 1<<(m_uhTotalDepth<<1);
@@ -61 +63 @@
   m_uiHeightInCU      = ( iPicHeight%m_uiMaxCUHeight ) ? iPicHeight/m_uiMaxCUHeight + 1 : iPicHeight/m_uiMaxCUHeight;
 
   m_uiNumCUsInFrame   = m_uiWidthInCU * m_uiHeightInCU;
-  m_apcTComDataCU     = new TComDataCU*[m_uiNumCUsInFrame];
+  m_apcTComDataCU     = MEMNEWARRAY TComDataCU*[m_uiNumCUsInFrame];
 
   for ( i=0; i<m_uiNumCUsInFrame ; i++ )
   {
-    m_apcTComDataCU[i] = new TComDataCU;
+    m_apcTComDataCU[i] = MEMNEW TComDataCU;
     m_apcTComDataCU[i]->create( m_uiNumPartitions, m_uiMaxCUWidth, m_uiMaxCUHeight, false );
   }
 }
@@ -74 +76 @@
 {
   Int i;
 
-  delete m_apcTComSlice;
+  MEMDELETE( m_apcTComSlice );
   m_apcTComSlice = NULL;
 
 
@@ -82 +84 @@
   for (i = 0; i < m_uiNumCUsInFrame; i++)
   {
     m_apcTComDataCU[i]->destroy();
-    delete m_apcTComDataCU[i];
+    MEMDELETE( m_apcTComDataCU[i] );
     m_apcTComDataCU[i] = NULL;
   }
-  delete [] m_apcTComDataCU;
+  MEMDELETEARRAY( m_apcTComDataCU );
   m_apcTComDataCU = NULL;
 }
 

source/Lib/TLibCommon/TComPredFilterMOMS.cpp

@@ -36 +36 @@
 
 #include "TComPredFilterMOMS.h"
 
+#include "tool_tracemem.h"
+
 #if HHI_INTERP_FILTER
 
 // predict luma block for a given motion vector for motion compensation
@@ -346 +348 @@
 Void TComPredFilter6TapMOMS::interpolate( Pel* pcDst, Int iDstStride, Pel* pcSrc, Int iSrcStride, Int iDstYMax, Int iDstXMax, Int iDx, Int iDy, Int iDstStep )
 {
   // temp buffer
-  Pel* pcTmpBufOrg         = new Pel[iDstXMax*(iDstYMax+5)];
+  Pel* pcTmpBufOrg         = MEMNEWARRAY Pel[iDstXMax*(iDstYMax+5)];
 #if HHI_INTERP_FILTER_KERNEL_FIX
   const Int iQ6Gain        = Int( pow((54.545454545454550),2) * pow(2.0,6) + 0.5 );
 #else
@@ -431 +433 @@
     }
   }
 
-  delete[] pcTmpBufOrg;
+  MEMDELETEARRAY( pcTmpBufOrg );
 }
 
 
@@ -467 +469 @@
 Void TComPredFilter4TapMOMS::interpolate( Pel* pcDst, Int iDstStride, Pel* pcSrc, Int iSrcStride, Int iDstYMax, Int iDstXMax, Int iDx, Int iDy, Int iDstStep )
 {
   // temp buffer
-  Pel* pcTmpBufOrg         = new Pel[iDstXMax*(iDstYMax+3)];
+  Pel* pcTmpBufOrg         = MEMNEWARRAY Pel[iDstXMax*(iDstYMax+3)];
 
   // interpolation in horizontal direction
   {
@@ -535 +537 @@
     }
   }
 
-  delete[] pcTmpBufOrg;
+  MEMDELETEARRAY( pcTmpBufOrg );
 }
 
 

source/Lib/TLibCommon/TComPrediction.cpp

@@ -36 +36 @@
 #include <memory.h>
 #include "TComPrediction.h"
 
+#include "tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / initialize
 // ====================================================================================================================
@@ -53 +55 @@
 {
   m_cYuvExt.destroy();
 
-  delete[] m_piYuvExt;
+  MEMDELETEARRAY( m_piYuvExt );
 #ifdef EDGE_BASED_PREDICTION
-  delete[] m_piYExtEdgeBased;
+  MEMDELETEARRAY( m_piYExtEdgeBased );
 #endif //EDGE_BASED_PREDICTION
 
   m_acYuvPred[0].destroy();
@@ -63 +65 @@
 
   m_cYuvPredTemp.destroy();
 #ifdef EDGE_BASED_PREDICTION
-  delete EdgeBasedPred;
+  MEMDELETE( EdgeBasedPred );
 #endif //EDGE_BASED_PREDICTION
 
 }
@@ -76 +78 @@
     m_iYuvExtStride = ((g_uiMaxCUWidth  + 12) << 4);
 
     m_cYuvExt.create( m_iYuvExtStride, m_iYuvExtHeight );
-    m_piYuvExt = new Int[ m_iYuvExtStride * m_iYuvExtHeight ];
+    m_piYuvExt = MEMNEWARRAY Int[ m_iYuvExtStride * m_iYuvExtHeight ];
 
     // new structure
     m_acYuvPred[0] .create( g_uiMaxCUWidth, g_uiMaxCUHeight );
@@ -90 +92 @@
   }
 #ifdef EDGE_BASED_PREDICTION
   if( m_piYExtEdgeBased == NULL )
-    m_piYExtEdgeBased = new Int[ ((g_uiMaxCUWidth<<1)+4) * ((g_uiMaxCUHeight<<1)+4) ];
+    m_piYExtEdgeBased = MEMNEWARRAY Int[ ((g_uiMaxCUWidth<<1)+4) * ((g_uiMaxCUHeight<<1)+4) ];
 #endif //EDGE_BASED_PREDICTION
 
   m_iDIFHalfTap   = ( m_iDIFTap  >> 1 );
 #ifdef EDGE_BASED_PREDICTION
-  EdgeBasedPred = new TComEdgeBased;
+  EdgeBasedPred = MEMNEW TComEdgeBased;
 #endif //EDGE_BASED_PREDICTION
 }
 

source/Lib/TLibCommon/TComRdCost.cpp

@@ -37 +37 @@
 #include <assert.h>
 #include "TComRdCost.h"
 
+#include "tool_tracemem.h"
+
 TComRdCost::TComRdCost()
 {
   init();
@@ -235 +237 @@
 
     m_iSearchLimit = iSubPelSearchLimit;
 
-    m_puiComponentCostOriginP = new UInt[ 4 * iSubPelSearchLimit ];
+    m_puiComponentCostOriginP = MEMNEWARRAY UInt[ 4 * iSubPelSearchLimit ];
     iSubPelSearchLimit *= 2;
 
     m_puiComponentCost = m_puiComponentCostOriginP + iSubPelSearchLimit;
@@ -251 +253 @@
 {
   if( NULL != m_puiComponentCostOriginP )
   {
-    delete [] m_puiComponentCostOriginP;
+    MEMDELETEARRAY( m_puiComponentCostOriginP );
     m_puiComponentCostOriginP = NULL;
   }
 }

source/Lib/TLibCommon/TComRom.cpp

@@ -37 +37 @@
 #include <memory.h>
 #include <stdlib.h>
 #include <stdio.h>
+
+#include "tool_tracemem.h"
+
 // ====================================================================================================================
 // Initialize / destroy functions
 // ====================================================================================================================
@@ -64 +67 @@
 #endif
   for ( i=0; i<MAX_CU_DEPTH; i++ )
   {
-    g_auiFrameScanXY[ i ] = new UInt[ c*c ];
-    g_auiFrameScanX [ i ] = new UInt[ c*c ];
-    g_auiFrameScanY [ i ] = new UInt[ c*c ];
+    g_auiFrameScanXY[ i ] = MEMNEWARRAY UInt[ c*c ];
+    g_auiFrameScanX [ i ] = MEMNEWARRAY UInt[ c*c ];
+    g_auiFrameScanY [ i ] = MEMNEWARRAY UInt[ c*c ];
     initFrameScanXY( g_auiFrameScanXY[i], g_auiFrameScanX[i], g_auiFrameScanY[i], c, c );
     c <<= 1;
   }
@@ -77 +80 @@
   {
     const int   iBlockSize    = 1 << i;
     const UInt  uiNumScanPos  = UInt( iBlockSize * iBlockSize );
-    g_auiSigLastScan[ i ][ 0 ] = new UInt[ uiNumScanPos ];
-    g_auiSigLastScan[ i ][ 1 ] = new UInt[ uiNumScanPos ];
+    g_auiSigLastScan[ i ][ 0 ] = MEMNEWARRAY UInt[ uiNumScanPos ];
+    g_auiSigLastScan[ i ][ 1 ] = MEMNEWARRAY UInt[ uiNumScanPos ];
     initSigLastScanPattern( g_auiSigLastScan[ i ][ 1 ], i, true  );
     initSigLastScanPattern( g_auiSigLastScan[ i ][ 0 ], i, false );
   }
@@ -88 +91 @@
   int ipredmode;
   for(ipredmode=0; ipredmode<9; ipredmode++)
   {
-    scanOrder4x4[ipredmode] = new UInt[ 4*4 ];
-    scanOrder4x4X[ipredmode]= new UInt[ 4*4 ];
-    scanOrder4x4Y[ipredmode]= new UInt[ 4*4 ];
+    scanOrder4x4[ipredmode] = MEMNEWARRAY UInt[ 4*4 ];
+    scanOrder4x4X[ipredmode]= MEMNEWARRAY UInt[ 4*4 ];
+    scanOrder4x4Y[ipredmode]= MEMNEWARRAY UInt[ 4*4 ];
     
-    scanStats4x4[ipredmode] = new UInt[ 4*4 ];
+    scanStats4x4[ipredmode] = MEMNEWARRAY UInt[ 4*4 ];
     
     
-    scanOrder8x8[ipredmode] = new UInt[ 8*8 ];
-    scanOrder8x8X[ipredmode]= new UInt[ 8*8 ];
-    scanOrder8x8Y[ipredmode]= new UInt[ 8*8 ];
+    scanOrder8x8[ipredmode] = MEMNEWARRAY UInt[ 8*8 ];
+    scanOrder8x8X[ipredmode]= MEMNEWARRAY UInt[ 8*8 ];
+    scanOrder8x8Y[ipredmode]= MEMNEWARRAY UInt[ 8*8 ];
     
-    scanStats8x8[ipredmode] = new UInt[ 8*8 ];
+    scanStats8x8[ipredmode] = MEMNEWARRAY UInt[ 8*8 ];
   }
   
   // 16x16
   for (int z=0; z < NUM_SCANS_16x16; z++)
   {
-    scanOrder16x16[z] = new UInt[ 16*16 ];
-    scanOrder16x16X[z] = new UInt[ 16*16 ];
-    scanOrder16x16Y[z] = new UInt[ 16*16 ];
-    scanStats16x16[z] = new UInt[ 16*16 ];
+    scanOrder16x16[z] = MEMNEWARRAY UInt[ 16*16 ];
+    scanOrder16x16X[z] = MEMNEWARRAY UInt[ 16*16 ];
+    scanOrder16x16Y[z] = MEMNEWARRAY UInt[ 16*16 ];
+    scanStats16x16[z] = MEMNEWARRAY UInt[ 16*16 ];
   }
   
   // 32x32
   for (int z=0; z < NUM_SCANS_32x32; z++)
   {
-    scanOrder32x32[z] = new UInt[ 32*32 ];
-    scanOrder32x32X[z] = new UInt[ 32*32 ];
-    scanOrder32x32Y[z] = new UInt[ 32*32 ];
-    scanStats32x32[z] = new UInt[ 32*32 ];
+    scanOrder32x32[z] = MEMNEWARRAY UInt[ 32*32 ];
+    scanOrder32x32X[z] = MEMNEWARRAY UInt[ 32*32 ];
+    scanOrder32x32Y[z] = MEMNEWARRAY UInt[ 32*32 ];
+    scanStats32x32[z] = MEMNEWARRAY UInt[ 32*32 ];
   }
   
   // 64x64
   for (int z=0; z < NUM_SCANS_64x64; z++)
   {
-    scanOrder64x64[z] = new UInt[ 64*64 ];
-    scanOrder64x64X[z] = new UInt[ 64*64 ];
-    scanOrder64x64Y[z] = new UInt[ 64*64 ];
-    scanStats64x64[z] = new UInt[ 64*64 ];
+    scanOrder64x64[z] = MEMNEWARRAY UInt[ 64*64 ];
+    scanOrder64x64X[z] = MEMNEWARRAY UInt[ 64*64 ];
+    scanOrder64x64Y[z] = MEMNEWARRAY UInt[ 64*64 ];
+    scanStats64x64[z] = MEMNEWARRAY UInt[ 64*64 ];
   }
 #endif
 }
@@ -137 +140 @@
 
   for ( i=0; i<MAX_CU_DEPTH; i++ )
   {
-    delete[] g_auiFrameScanXY[i];
-    delete[] g_auiFrameScanX [i];
-    delete[] g_auiFrameScanY [i];
+    MEMDELETEARRAY( g_auiFrameScanXY[i] );
+    MEMDELETEARRAY( g_auiFrameScanX [i] );
+    MEMDELETEARRAY( g_auiFrameScanY [i] );
   }
   
 #if HHI_TRANSFORM_CODING
   for ( i=0; i<MAX_CU_DEPTH+1; i++ )
   {
-    delete[] g_auiSigLastScan[i][0];
-    delete[] g_auiSigLastScan[i][1];
+    MEMDELETEARRAY( g_auiSigLastScan[i][0] );
+    MEMDELETEARRAY( g_auiSigLastScan[i][1] );
   }
 #endif
 
@@ -154 +157 @@
   int ipredmode;
   for(ipredmode=0; ipredmode<9; ipredmode++)
   {       
-    delete [] scanOrder4x4[ipredmode];      
-    delete [] scanOrder4x4X[ipredmode];      
-    delete [] scanOrder4x4Y[ipredmode];
-    delete [] scanStats4x4[ipredmode];
+    MEMDELETEARRAY( scanOrder4x4[ipredmode] );      
+    MEMDELETEARRAY( scanOrder4x4X[ipredmode] );      
+    MEMDELETEARRAY( scanOrder4x4Y[ipredmode] );
+    MEMDELETEARRAY( scanStats4x4[ipredmode] );
     
-    delete [] scanOrder8x8[ipredmode];
-    delete [] scanOrder8x8X[ipredmode];
-    delete [] scanOrder8x8Y[ipredmode];
-    delete [] scanStats8x8[ipredmode];
+    MEMDELETEARRAY( scanOrder8x8[ipredmode] );
+    MEMDELETEARRAY( scanOrder8x8X[ipredmode] );
+    MEMDELETEARRAY( scanOrder8x8Y[ipredmode] );
+    MEMDELETEARRAY( scanStats8x8[ipredmode] );
   }
   
   // 16x16
   for (int z=0; z < NUM_SCANS_16x16; z++)
   {
-    delete [] scanOrder16x16[z];
-    delete [] scanOrder16x16X[z];
-    delete [] scanOrder16x16Y[z];
-    delete [] scanStats16x16[z];
+    MEMDELETEARRAY( scanOrder16x16[z] );
+    MEMDELETEARRAY( scanOrder16x16X[z] );
+    MEMDELETEARRAY( scanOrder16x16Y[z] );
+    MEMDELETEARRAY( scanStats16x16[z] );
   }
   // 32x32
   for (int z=0; z < NUM_SCANS_32x32; z++)
   {
-    delete [] scanOrder32x32[z];
-    delete [] scanOrder32x32X[z];
-    delete [] scanOrder32x32Y[z];
-    delete [] scanStats32x32[z];
+    MEMDELETEARRAY( scanOrder32x32[z] );
+    MEMDELETEARRAY( scanOrder32x32X[z] );
+    MEMDELETEARRAY( scanOrder32x32Y[z] );
+    MEMDELETEARRAY( scanStats32x32[z] );
   }
   // 64x64
   for (int z=0; z < NUM_SCANS_64x64; z++)
   {
-    delete [] scanOrder64x64[z];
-    delete [] scanOrder64x64X[z];
-    delete [] scanOrder64x64Y[z];
-    delete [] scanStats64x64[z];
+    MEMDELETEARRAY( scanOrder64x64[z] );
+    MEMDELETEARRAY( scanOrder64x64X[z] );
+    MEMDELETEARRAY( scanOrder64x64Y[z] );
+    MEMDELETEARRAY( scanStats64x64[z] );
   }
 #endif
 }

source/Lib/TLibCommon/TComTrQuant.cpp

@@ -42 +42 @@
 #endif
 #include "ContextTables.h"
 
+#include "tool_tracemem.h"
+
 // ====================================================================================================================
 // Constants
 // ====================================================================================================================
@@ -243 +245 @@
   m_cQP.clear();
 
   // allocate temporary buffers
-  m_plTempCoeff  = new Long[ MAX_CU_SIZE*MAX_CU_SIZE ];
+  m_plTempCoeff  = MEMNEWARRAY Long[ MAX_CU_SIZE*MAX_CU_SIZE ];
 
   // allocate bit estimation class  (for RDOQ)
-  m_pcEstBitsSbac = new estBitsSbacStruct;
+  m_pcEstBitsSbac = MEMNEW estBitsSbacStruct;
 }
 
 TComTrQuant::~TComTrQuant()
@@ -254 +256 @@
   // delete temporary buffers
   if ( m_plTempCoeff )
   {
-    delete [] m_plTempCoeff;
+    MEMDELETEARRAY( m_plTempCoeff );
     m_plTempCoeff = NULL;
   }
 
   // delete bit estimation class
-  if ( m_pcEstBitsSbac ) delete m_pcEstBitsSbac;
+  if ( m_pcEstBitsSbac ) MEMDELETE( m_pcEstBitsSbac );
 }
 
 /// Including Chroma QP Parameter setting
@@ -6805 +6807 @@
   UInt puiCtxCoeffLevelM1[MAX_CU_SIZE * MAX_CU_SIZE];
   UInt puiBaseCtx[MAX_CU_SIZE * MAX_CU_SIZE / 16];
   
-//  Int*  piCoeff            = new Int [ uiMaxNumCoeff      ];
+//  Int*  piCoeff            = MEMNEWARRAY Int [ uiMaxNumCoeff      ];
 //#if QC_MDDT
-//  Int64* plLevelDouble     = new Int64[ uiMaxNumCoeff      ];
+//  Int64* plLevelDouble     = MEMNEWARRAY Int64[ uiMaxNumCoeff      ];
 //#else
-//  Long* plLevelDouble      = new Long[ uiMaxNumCoeff      ];
+//  Long* plLevelDouble      = MEMNEWARRAY Long[ uiMaxNumCoeff      ];
 //#endif
-//  UInt* puiCtxAbsGreOne    = new UInt[ uiMaxNumCoeff      ];
-//  UInt* puiCtxCoeffLevelM1 = new UInt[ uiMaxNumCoeff      ];
-//  UInt* puiBaseCtx         = new UInt[ uiMaxNumCoeff / 16 ];
+//  UInt* puiCtxAbsGreOne    = MEMNEWARRAY UInt[ uiMaxNumCoeff      ];
+//  UInt* puiCtxCoeffLevelM1 = MEMNEWARRAY UInt[ uiMaxNumCoeff      ];
+//  UInt* puiBaseCtx         = MEMNEWARRAY UInt[ uiMaxNumCoeff / 16 ];
   const UInt uiNumOfSets   = 4;
   const UInt uiNum4x4Blk   = max<UInt>( 1, uiMaxNumCoeff / 16 );
 
@@ -7254 +7256 @@
     }
   }
 
-//  delete[] piCoeff;
-//  delete[] plLevelDouble;
-//  delete[] puiCtxAbsGreOne;
-//  delete[] puiCtxCoeffLevelM1;
-//  delete[] puiBaseCtx;
+//  MEMDELETEARRAY( piCoeff );
+//  MEMDELETEARRAY( plLevelDouble );
+//  MEMDELETEARRAY( puiCtxAbsGreOne );
+//  MEMDELETEARRAY( puiCtxCoeffLevelM1 );
+//  MEMDELETEARRAY( puiBaseCtx );
 #else
 // temporal buffer for speed
 static levelDataStruct slevelData               [ MAX_CU_SIZE*MAX_CU_SIZE ];

source/Lib/TLibCommon/tool_tracemem.cpp

@@ +1 @@
+/****************************************************************************
+                          tool_tracemem.cpp
+                          -------------------
+    begin                : Fri Oct 06 2006
+    authors              : Xiang Li
+        email                : xiangli@ieee.org
+****************************************************************************/
+
+/****************************************************************************
+    Implementation of tools for tracing memory allocation.
+****************************************************************************/
+
+#include <stdio.h>
+#include <assert.h>
+#include "tool_tracemem.h"
+
+#ifdef CTRL_USE_TRACEMEM
+
+/***************************************************************************/
+namespace Utilities
+{
+
+#define TRACEMEM_REPORT_MISMATCH_NEWDEL         0
+#define TRACEMEM_THRESHOLD_FILE_TIMESNEW        10000
+#define TRACEMEM_THRESHOLD_FILE_BYTESALLOC      3000000
+#define TRACEMEM_THRESHOLD_FILE_PER                     0.25
+
+CMemoryTrace::CMemoryTrace()
+{
+        m_szMaxRecord = 0;
+        m_szCurUsed = 0;
+        m_szMaxUsed = 0;
+        m_uTimesNew = 0;
+        m_uTimesDelMissed = 0;
+}
+
+CMemoryTrace::~CMemoryTrace()
+{
+
+}
+
+void CMemoryTrace::AddRecord( void * pMemory , size_t sz , char * pFileName , int nLine , bool bArray )
+{
+        if( pMemory != NULL )
+        {
+                assert( m_MemoryNew.find( ( size_t )pMemory ) == m_MemoryNew.end() );
+                
+                // record memory allocation
+                xxGetFileName( pFileName , m_MemoryNew[ ( size_t )pMemory ].strFileNameNew );
+                m_MemoryNew[ ( size_t )pMemory ].nLineNew = nLine;
+                m_MemoryNew[ ( size_t )pMemory ].bArray = bArray;
+                m_MemoryNew[ ( size_t )pMemory ].szSize = sz;
+                m_szCurUsed += sz;
+                if( m_szCurUsed > m_szMaxUsed )
+                        m_szMaxUsed = m_szCurUsed;
+                m_uTimesNew++;
+
+                // record the allocation from a file
+                const std::string & rStr = m_MemoryNew[ ( size_t )pMemory ].strFileNameNew;
+                if( m_MemoryFileNew.find( rStr ) == m_MemoryFileNew.end() )
+                {
+                        // new file
+                        m_MemoryFileNew[ rStr ].strFileNameNew = rStr;
+                        m_MemoryFileNew[ rStr ].szCurAllocated = sz;
+                        m_MemoryFileNew[ rStr ].uTimesNew = 1;
+                        m_MemoryFileNew[ rStr ].szMaxAllocated = sz;
+                }
+                else
+                {
+                        m_MemoryFileNew[ rStr ].szCurAllocated += sz;
+                        m_MemoryFileNew[ rStr ].uTimesNew += 1;
+                        if( m_MemoryFileNew[ rStr ].szMaxAllocated < m_MemoryFileNew[ rStr ].szCurAllocated )
+                                m_MemoryFileNew[ rStr ].szMaxAllocated = m_MemoryFileNew[ rStr ].szCurAllocated;
+                }
+
+                // max number of the records
+                if( m_MemoryNew.size() > m_szMaxRecord )
+                {
+                        m_szMaxRecord = m_MemoryNew.size();
+                }
+
+        }
+}
+
+void CMemoryTrace::DelRecord( void * pMemory , char * pFileName , int nLine , bool bArray )
+{
+        if( pMemory != NULL )
+        {
+                if( m_MemoryNew.empty() == false && m_MemoryNew.find( ( size_t )pMemory ) != m_MemoryNew.end() )
+                {
+
+#if TRACEMEM_REPORT_MISMATCH_NEWDEL
+                        if( m_MemoryNew[ ( size_t )pMemory ].bArray != bArray )
+                        {
+                                // record the item which not paired properly
+                                m_NotPairedNew[ ( size_t )pMemory ] = m_MemoryNew[ ( size_t )pMemory ];
+                                xxGetFileName( pFileName , m_NotPairedNew[ ( size_t )pMemory ].strFileNameDel );
+                                m_NotPairedNew[ ( size_t )pMemory ].nLineDel = nLine;
+                        }
+#endif
+
+                        // file record
+                        const std::string & rStr = m_MemoryNew[ ( size_t )pMemory ].strFileNameNew;
+                        m_MemoryFileNew[ rStr ].szCurAllocated -= m_MemoryNew[ ( size_t )pMemory ].szSize;
+
+                        // global record
+                        m_szCurUsed = m_szCurUsed - m_MemoryNew[ ( size_t )pMemory ].szSize;
+                        m_MemoryNew.erase( ( size_t )pMemory );
+                }
+                else
+                {
+                        xxGetFileName( pFileName , m_MemoryDel[ ( size_t )pMemory ].strFileNameDel );
+                        m_MemoryDel[ ( size_t )pMemory ].nLineDel = nLine;
+                        m_MemoryDel[ ( size_t )pMemory ].bArray = bArray;
+                        m_uTimesDelMissed++;
+                }
+        }
+}
+
+bool CMemoryTrace::HasBeenAllocated( void * pMemory )
+{
+        if( pMemory != NULL && m_MemoryNew.empty() == false )
+                return( m_MemoryNew.find( ( size_t )pMemory ) != m_MemoryNew.end() );
+        else
+                return( false );
+}
+
+void CMemoryTrace::OutputMemTraceInfo( FILE * fpLog )
+{
+        if( fpLog != NULL )
+        {
+                fprintf( fpLog , "\n\n******************** Memory Log ********************" );
+
+                char strMaxMemory[256] , strCurMemory[256];
+
+                if( m_szMaxUsed < 1000 )
+                        sprintf( strMaxMemory , "%d B" , m_szMaxUsed );
+                else if( m_szMaxUsed < 1000000 )
+                        sprintf( strMaxMemory , "%.1lf KB" , m_szMaxUsed / 1000.0 );
+                else 
+                        sprintf( strMaxMemory , "%.2lf MB" , m_szMaxUsed / 1000000.0 );
+
+                if( m_szCurUsed < 1000 )
+                        sprintf( strCurMemory , "%d B" , m_szCurUsed );
+                else if( m_szCurUsed < 1000000 )
+                        sprintf( strCurMemory , "%.1lf KB" , m_szCurUsed / 1000.0 );
+                else 
+                        sprintf( strCurMemory , "%.2lf MB" , m_szCurUsed / 1000000.0 );
+
+                fprintf( fpLog , "\nAllocating memory %lld times, incorrect deleting %lld times." , m_uTimesNew , m_uTimesDelMissed );
+                fprintf( fpLog , "\nMax %s were allocated, %s have not be freed." , strMaxMemory , strCurMemory );
+                fprintf( fpLog , "\nMax %d records." , m_szMaxRecord );
+
+                if( m_MemoryNew.empty() == false )
+                {
+                        fprintf( fpLog , "\n----------------------------------------------------" );
+                        fprintf( fpLog , "\nMemory has not been freed:" );
+                        HASH_MAP < unsigned int , SMemoryRecord >::iterator CurPos = m_MemoryNew.begin();
+                        while( CurPos != m_MemoryNew.end() )
+                        {
+                                fprintf( fpLog , "\nIn %s line %d, memory was allocated at 0x%08x (%dB)." , CurPos->second.strFileNameNew.c_str() ,
+                                        CurPos->second.nLineNew , CurPos->first , CurPos->second.szSize );
+                                CurPos++;
+                        }
+                }
+
+                if( m_MemoryDel.empty() == false )
+                {
+                        fprintf( fpLog , "\n----------------------------------------------------" );
+                        fprintf( fpLog , "\nIncorrect delete:" );
+                        HASH_MAP < unsigned int , SMemoryRecord >::iterator CurPos = m_MemoryDel.begin();
+                        while( CurPos != m_MemoryDel.end() )
+                        {
+                                fprintf( fpLog , "\nIn %s line %d, memory 0x%08x was incorrectly deleted." , CurPos->second.strFileNameDel.c_str() ,
+                                        CurPos->second.nLineDel , CurPos->first );
+                                CurPos++;
+                        }
+                }
+
+#if TRACEMEM_REPORT_MISMATCH_NEWDEL
+                if( m_NotPairedNew.empty() == false )
+                {
+                        fprintf( fpLog , "\n----------------------------------------------------" );
+                        fprintf( fpLog , "\nnew/new[] not paired by proper delete/delete[]:" );
+                        HASH_MAP < unsigned int , SMemoryRecord >::iterator CurPos = m_NotPairedNew.begin();
+                        while( CurPos != m_NotPairedNew.end() )
+                        {
+                                fprintf( fpLog , "\nIn %s line %d, new 0x%08x was by allocated by %s while freed by %s in %s line %d." , 
+                                        CurPos->second.strFileNameNew.c_str() , CurPos->second.nLineNew , CurPos->first ,
+                                        CurPos->second.bArray == false ? "MEMNEW" : "MEMNEWARRAY" ,
+                                        CurPos->second.bArray == true ? "MEMDELETE" : "DELETEARRAY" ,
+                                        CurPos->second.strFileNameDel.c_str() , CurPos->second.nLineDel );
+                                CurPos++;
+                        }
+                }
+#endif
+
+                if( m_MemoryFileNew.empty() == false )
+                {
+                        fprintf( fpLog , "\n----------------------------------------------------" );
+                        fprintf( fpLog , "\nFiles of frequent memory allocation and files using much memory:" );
+                        std::map < std::string , SFileMemory >::iterator CurPos = m_MemoryFileNew.begin();
+                        while( CurPos != m_MemoryFileNew.end() )
+                        {
+                                if( CurPos->second.uTimesNew >= TRACEMEM_THRESHOLD_FILE_TIMESNEW 
+                                        || CurPos->second.uTimesNew >= TRACEMEM_THRESHOLD_FILE_PER * m_uTimesNew
+                                        || CurPos->second.szMaxAllocated >= TRACEMEM_THRESHOLD_FILE_BYTESALLOC
+                                        || CurPos->second.szMaxAllocated >= TRACEMEM_THRESHOLD_FILE_PER * m_szMaxUsed )
+                                {
+                                        const size_t & rMaxUsed = CurPos->second.szMaxAllocated;
+                                        if( rMaxUsed < 1000 )
+                                                sprintf( strMaxMemory , "%d B" , rMaxUsed );
+                                        else if( rMaxUsed < 1000000 )
+                                                sprintf( strMaxMemory , "%.1lf KB" , rMaxUsed / 1000.0 );
+                                        else 
+                                                sprintf( strMaxMemory , "%.2lf MB" , rMaxUsed / 1000000.0 );
+                                        fprintf( fpLog , "\n%s, %lld times (%.2lf%%) allocation, max %s were allocated." , CurPos->second.strFileNameNew.c_str() , 
+                                                CurPos->second.uTimesNew , CurPos->second.uTimesNew * 100.0 / m_uTimesNew , strMaxMemory );
+                                }
+                                CurPos++;
+                        }
+                }
+
+                fprintf( fpLog , "\n****************************************************\n" );
+        }
+
+        xxRelease();
+}
+
+void CMemoryTrace::xxGetFileName( const char * pPathFileName , std::string & rFileName ) const
+{
+        rFileName = pPathFileName;
+        size_t nLast = rFileName.find_last_of( CSLASH );
+        if( nLast + 1 < std::string::npos )
+                rFileName.erase( 0 , nLast + 1 );
+}
+
+void CMemoryTrace::xxRelease()
+{
+        m_MemoryNew.clear();
+        m_MemoryDel.clear();
+        m_NotPairedNew.clear();
+}
+
+} // namespace Utilities
+/***************************************************************************/
+
+/** global variables *******************************************************/
+Utilities::CMemoryTrace gMemoryTrace;
+/***************************************************************************/
+
+/** new and delete *********************************************************/
+void * operator new( size_t sz , char * pFileName , int nLine , bool bArray )
+{
+        void * pMemory = operator new( sz );
+
+        gMemoryTrace.AddRecord( pMemory , sz , pFileName , nLine , bArray );
+
+        return( pMemory );
+}
+
+void * operator new[] ( size_t sz , char * pFileName , int nLine , bool bArray )
+{
+        void * pMemory = operator new( sz );
+
+        gMemoryTrace.AddRecord( pMemory , sz , pFileName , nLine , bArray );
+
+        return( pMemory );
+}
+
+void operator delete( void * pMemory , char * pFileName , int nLine , bool bArray )
+{
+        if( pMemory != NULL )
+        {
+                gMemoryTrace.DelRecord( pMemory , pFileName , nLine , bArray );
+                operator delete ( pMemory );
+        }
+}
+
+void operator delete [] ( void * pMemory , char * pFileName , int nLine , bool bArray )
+{
+        if( pMemory != NULL )
+        {
+                gMemoryTrace.DelRecord( pMemory , pFileName , nLine , bArray );
+                operator delete ( pMemory );
+        }
+}
+
+void OutputMemTraceInfo(  FILE * fpLog )
+{
+        gMemoryTrace.OutputMemTraceInfo( fpLog );
+}
+
+
+/***************************************************************************/
+
+#endif // CTRL_USE_TRACEMEM
+
+double GetMaxMBMemAllocated()
+{
+        double dReturn = 0;
+
+#ifdef CTRL_USE_TRACEMEM
+        dReturn = gMemoryTrace.GetMaxMBMemAllocated();
+#endif
+
+        return( dReturn );
+}
+
+double GetTimesMemAllocation()
+{
+        double dReturn = 0;
+
+#ifdef CTRL_USE_TRACEMEM
+        dReturn = gMemoryTrace.GetTimesMemAllocation();
+#endif
+
+        return( dReturn );
+}
+
+/****************************************************************************
+    end-of-file
+****************************************************************************/

source/Lib/TLibCommon/tool_tracemem.h

@@ +1 @@
+/****************************************************************************
+                          tool_tracemem.h
+                          -------------------
+    begin                : Fri Oct 06 2006
+    authors              : Xiang Li
+    email                : xiangli@ieee.org
+****************************************************************************/
+
+#ifndef __TOOL_TRACEMEM_H__
+#define __TOOL_TRACEMEM_H__
+
+/****************************************************************************
+    Implementations of tools for tracing memory allocation.
+****************************************************************************/
+
+/** standard headers *******************************************************/
+#include <string>
+#include <map>
+#ifdef WIN32
+        #include <hash_map>
+#else
+        #include <ext/hash_map>
+#endif
+/***************************************************************************/
+
+/** control definition *****************************************************/
+#define CTRL_USE_TRACEMEM
+/***************************************************************************/
+
+#ifdef CTRL_USE_TRACEMEM
+
+/***************************************************************************/
+namespace Utilities
+{
+
+#ifdef WIN32
+        #define HASH_MAP stdext::hash_map
+        #define CSLASH   '\\'
+        typedef unsigned __int64 uint64_t; 
+#else
+        #define HASH_MAP __gnu_cxx::hash_map
+        #define CSLASH   '/'
+        typedef unsigned long long uint64_t;
+#endif
+
+//! class for memory tracing
+class CMemoryTrace
+{
+
+public:
+
+/** function members *******************************************************/
+
+        //! constructor
+        CMemoryTrace();
+
+        //! destructor
+        ~CMemoryTrace();
+
+        /***********************************************************************/
+          /*!
+           * \short add a record for the operator new
+           *
+           * \param pMemory, pointer to the memory just newed
+           * \param sz, size of memory to be newed
+           * \param pFileName, indicates the file which calls new
+           * \param nLine, indicates the line where new is called
+           * \param bArray, whether by new []
+           */
+        /***********************************************************************/
+        void AddRecord( void * pMemory , size_t sz , char * pFileName , int nLine , bool bArray );
+
+        /***********************************************************************/
+          /*!
+           * \short add a record for the operator delete
+           *
+           * \param pMemory, pointer to the memory to be deleted
+           * \param pFileName, indicates the file which calls new
+           * \param nLine, indicates the line where new is called
+           * \param bArray, whether by delete []
+           */
+        /***********************************************************************/
+        void DelRecord( void * pMemory , char * pFileName , int nLine , bool bArray );
+
+        /***********************************************************************/
+          /*!
+           * \short check whether the memory has been recorded for the operator new
+           *
+           * \param pMemory, pointer to the memory
+           */
+        /***********************************************************************/
+        bool HasBeenAllocated( void * pMemory );
+
+        /***********************************************************************/
+          /*!
+           * \short output the memory tracing information
+           */
+        /***********************************************************************/
+        void OutputMemTraceInfo( FILE * fpLog );
+
+        /***********************************************************************/
+          /*!
+           * \short Get the memory (in MBytes) has been allocated
+           *
+           * \return memory has been allocated
+           */
+        /***********************************************************************/
+        double GetMaxMBMemAllocated()
+        {
+                return( m_szMaxUsed / 1000000.0 );
+        }
+
+        /***********************************************************************/
+          /*!
+           * \short Get the times of memory allocation
+           *
+           * \return the times of memory allocation
+           */
+        /***********************************************************************/
+        double GetTimesMemAllocation()
+        {
+                return( ( double )( m_uTimesNew ) );
+        }
+
+/***************************************************************************/
+
+private:
+
+/** private structure ******************************************************/
+
+        //! record of memory tracing
+        typedef struct _SMemoryRecord
+        {
+                //! indicates the file which calls new
+                std::string strFileNameNew;
+
+                //! indicates the line where new is called
+                int nLineNew;
+
+                //! the size to be newed
+                size_t szSize;
+
+                //! whether allocated by new []
+                bool bArray;
+
+                //! indicates the file which calls delete
+                std::string strFileNameDel;
+
+                //! indicates the line where delete is called
+                int nLineDel;
+
+        }SMemoryRecord;
+
+        //! statistics of memory allocation from a file
+        typedef struct _SFileMemory
+        {
+                //! indicates the file which calls new
+                std::string strFileNameNew;
+
+                //! max bytes have been allocated from the file
+                size_t  szMaxAllocated;
+
+                //! current bytes have been allocated from the file
+                size_t  szCurAllocated;
+
+                //! number of allocation from the file
+                uint64_t uTimesNew;
+
+        }SFileMemory;
+
+/***************************************************************************/
+
+/** variable members *******************************************************/
+
+        //! max bytes have been allocated
+        size_t  m_szMaxUsed;
+
+        //! current bytes have been allocated
+        size_t  m_szCurUsed;
+
+        //! the times the operator new has been called
+        uint64_t m_uTimesNew;
+
+        //! the times the operator delete has missed (the memory to be deleted was not recorded)
+        uint64_t m_uTimesDelMissed;
+
+        //! max number of elements in m_uTimesNew
+        size_t m_szMaxRecord;
+
+        //! records of new
+        HASH_MAP < size_t , SMemoryRecord > m_MemoryNew;
+
+        //! records of delete
+        HASH_MAP < size_t , SMemoryRecord > m_MemoryDel;
+
+        //! records of new/new[] not paired by proper delete/delete[]
+        HASH_MAP < size_t , SMemoryRecord > m_NotPairedNew;
+
+        //! records of new from a file
+        std::map < std::string , SFileMemory > m_MemoryFileNew;
+
+/***************************************************************************/
+
+/** function members *******************************************************/
+
+        /***********************************************************************/
+          /*!
+           * \short Get file name (remove the path info)
+           *
+           * \param pPathFileName, pointer to the file name with path info
+           * \param rFileName, reference to get the file name
+           */
+        /***********************************************************************/
+        void xxGetFileName( const char * pPathFileName , std::string & rFileName ) const;
+
+        /***********************************************************************/
+          /*!
+           * \short Release the records
+           */
+        /***********************************************************************/
+        void xxRelease();
+
+/***************************************************************************/
+
+};
+
+} // namespace Utilities
+/***************************************************************************/
+
+
+/** functions **************************************************************/
+
+/***************************************************************************/
+  /*!
+   * \short overload operator new to trace memory
+   *
+   * \param sz, size of memory to be newed
+   * \param pFileName, indicates the file which calls new
+   * \param nLine, indicates the line where new is called
+   * \param bArray, whether with []
+   *
+   * \return pointer to the allocated memory
+   */
+/***************************************************************************/
+void * operator new( size_t sz , char * pFileName , int nLine , bool bArray );
+void * operator new [] ( size_t sz , char * pFileName , int nLine , bool bArray );
+
+/***************************************************************************/
+  /*!
+   * \short overload operator delete to trace memory
+   *
+   * \param pMemory, pointer to the memory to be deleted
+   * \param pFileName, indicates the file which calls new
+   * \param nLine, indicates the line where new is called
+   * \param bArray, whether with []
+   *
+   * \return pointer to the allocated memory
+   */
+/***************************************************************************/
+void operator delete( void * pMemory , char * pFileName , int nLine , bool bArray );
+void operator delete [] ( void * pMemory , char * pFileName , int nLine , bool bArray );
+
+/***************************************************************************/
+  /*!
+   * \short template delete function
+   *
+   * \param p, pointer to the object to be deleted
+   * \param pFileName, indicates the file which calls new
+   * \param nLine, indicates the line where new is called
+   * \param bArray, whether with []
+   */
+/***************************************************************************/
+template <class T> inline
+void Delete( T * p , char * pFileName , int nLine , bool bArray )
+{
+        {
+                void * pSingle = ( void * )p;
+                void * pArray = ( void * )( ( size_t )( pSingle ) - sizeof( int ) );
+                extern Utilities::CMemoryTrace gMemoryTrace;
+
+                if( gMemoryTrace.HasBeenAllocated( pSingle ) == true )
+                {
+                        // by normal new
+
+                        // call the destructor of the object
+                        p->~T();
+
+                        // delete the memory
+                        operator delete( pSingle , pFileName , nLine , bArray );
+                }
+                else if( gMemoryTrace.HasBeenAllocated( pArray ) == true )
+                {
+                        // by new []
+
+                        // get the number of components
+                        int nNumber = *( ( int * )pArray );
+
+                        // call the destructor for each object
+                        for( ; nNumber > 0 ; nNumber-- , p++ )
+                                p->~T();
+
+                        // delete the memory
+                        operator delete [] ( pArray , pFileName , nLine , bArray );
+                }
+                else
+                {
+                        // not recorded memory allocation, do nothing but
+                        // save the record by calling DelRecord() 
+                        gMemoryTrace.DelRecord( p , pFileName , nLine , bArray );
+                }
+        }
+}
+
+/***************************************************************************/
+  /*!
+   * \short Output the information of memory tracing
+   *
+   * \param fpLog, pointer to log file
+   */
+/***************************************************************************/
+void OutputMemTraceInfo(  FILE * fpLog );
+
+/***************************************************************************/
+
+/** definitions ************************************************************/
+#define MEMNEW                          new (__FILE__ , __LINE__ , false )
+#define MEMNEWARRAY                     new (__FILE__ , __LINE__ , true )
+#define MEMDELETE(p)            Delete( ( p ) , __FILE__ , __LINE__ , false )
+#define MEMDELETEARRAY(p)       Delete( ( p ) , __FILE__ , __LINE__ , true )
+#define MEMTRACEINFO(p)         OutputMemTraceInfo(p)
+/***************************************************************************/
+
+#else  
+
+/** definitions ************************************************************/
+// use default new and delete
+#define MEMNEW                          new 
+#define MEMNEWARRAY                     new 
+#define MEMDELETE(p)            delete (p)
+#define MEMDELETEARRAY(p)       delete [] (p)
+#define MEMTRACEINFO(p) {}      // do nothing
+/***************************************************************************/
+
+#endif // CTRL_USE_TRACEMEM
+
+/***************************************************************************/
+  /*!
+   * \short Get how much memory (peak value) has been allocated
+   *
+   * \return memory in MBytes
+   */
+/***************************************************************************/
+double GetMaxMBMemAllocated();
+
+/***************************************************************************/
+  /*!
+   * \short Get how many times the memory allocation has been called
+   *
+   * \return the times of memory allocation
+   */
+/***************************************************************************/
+double GetTimesMemAllocation();
+
+#endif //__TOOL_TRACEMEM_H__
+
+/****************************************************************************
+    end-of-file
+****************************************************************************/

source/Lib/TLibDecoder/TDecBinCoderPIPE.cpp

@@ -35 +35 @@
 
 #include "TDecBinCoderPIPE.h"
 
+#include "../TLibCommon/tool_tracemem.h"
 
 #if PIPE_LOW_DELAY_OPTION
 V2VDecoder::V2VDecoder( const UInt uiPIPEId, UInt* puiMaxDelayBitCounter )
@@ -117 +118 @@
   for( UInt uiIdx = 0; uiIdx < NUM_V2V_CODERS; uiIdx++ )
   {
 #if PIPE_LOW_DELAY_OPTION
-    m_apcV2VDecoders[ uiIdx ] = new V2VDecoder( uiIdx, &m_uiMaxDelayBitCounter );
+    m_apcV2VDecoders[ uiIdx ] = MEMNEW V2VDecoder( uiIdx, &m_uiMaxDelayBitCounter );
 #else
-    m_apcV2VDecoders[ uiIdx ] = new V2VDecoder( uiIdx );
+    m_apcV2VDecoders[ uiIdx ] = MEMNEW V2VDecoder( uiIdx );
 #endif
   }
 }
@@ -128 +129 @@
 {
   for( UInt uiIdx = 0; uiIdx < NUM_V2V_CODERS; uiIdx++ )
   {
-    delete m_apcV2VDecoders[ uiIdx ];
+    MEMDELETE( m_apcV2VDecoders[ uiIdx ] );
   }
 }
 

source/Lib/TLibDecoder/TDecBinCoderV2VwLB.h

@@ -43 +43 @@
 #include "TDecBinCoder.h"
 #include "TDecV2VTrees.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
 class TDecClearBit : public TDecBinIf {
 
 public:
@@ -170 +172 @@
     virtual Void decodeBinTrm ( UInt& bit ) { bit = retrieveBit(mergedStatesMapping[62]); }
 
 public:
-    TDecClearBuffer() { temp_space = new UChar[TEMP_SIZE]; }
-    ~TDecClearBuffer() { delete [] temp_space; }
+    TDecClearBuffer() { temp_space = MEMNEWARRAY UChar[TEMP_SIZE]; }
+    ~TDecClearBuffer() { MEMDELETEARRAY( temp_space ); }
 
 };
 

source/Lib/TLibDecoder/TDecCu.cpp

@@ -35 +35 @@
 
 #include "TDecCu.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
 // ====================================================================================================================
@@ -65 +67 @@
 {
   m_uiMaxDepth = uiMaxDepth+1;
 
-  m_ppcYuvResi = new TComYuv*[m_uiMaxDepth-1];
-  m_ppcYuvReco = new TComYuv*[m_uiMaxDepth-1];
-  m_ppcCU      = new TComDataCU*[m_uiMaxDepth-1];
+  m_ppcYuvResi = MEMNEWARRAY TComYuv*[m_uiMaxDepth-1];
+  m_ppcYuvReco = MEMNEWARRAY TComYuv*[m_uiMaxDepth-1];
+  m_ppcCU      = MEMNEWARRAY TComDataCU*[m_uiMaxDepth-1];
 
   UInt uiNumPartitions;
   for ( UInt ui = 0; ui < m_uiMaxDepth-1; ui++ )
@@ -76 +78 @@
     UInt uiWidth  = uiMaxWidth  >> ui;
     UInt uiHeight = uiMaxHeight >> ui;
 
-    m_ppcYuvResi[ui] = new TComYuv;    m_ppcYuvResi[ui]->create( uiWidth, uiHeight );
-    m_ppcYuvReco[ui] = new TComYuv;    m_ppcYuvReco[ui]->create( uiWidth, uiHeight );
-    m_ppcCU     [ui] = new TComDataCU; m_ppcCU     [ui]->create( uiNumPartitions, uiWidth, uiHeight, true );
+    m_ppcYuvResi[ui] = MEMNEW TComYuv;    m_ppcYuvResi[ui]->create( uiWidth, uiHeight );
+    m_ppcYuvReco[ui] = MEMNEW TComYuv;    m_ppcYuvReco[ui]->create( uiWidth, uiHeight );
+    m_ppcCU     [ui] = MEMNEW TComDataCU; m_ppcCU     [ui]->create( uiNumPartitions, uiWidth, uiHeight, true );
   }
 
   // initialize partition order.
@@ -94 +96 @@
 {
   for ( UInt ui = 0; ui < m_uiMaxDepth-1; ui++ )
   {
-    m_ppcYuvResi[ui]->destroy(); delete m_ppcYuvResi[ui]; m_ppcYuvResi[ui] = NULL;
-    m_ppcYuvReco[ui]->destroy(); delete m_ppcYuvReco[ui]; m_ppcYuvReco[ui] = NULL;
-    m_ppcCU     [ui]->destroy(); delete m_ppcCU     [ui]; m_ppcCU     [ui] = NULL;
+    m_ppcYuvResi[ui]->destroy(); MEMDELETE( m_ppcYuvResi[ui] ); m_ppcYuvResi[ui] = NULL;
+    m_ppcYuvReco[ui]->destroy(); MEMDELETE( m_ppcYuvReco[ui] ); m_ppcYuvReco[ui] = NULL;
+    m_ppcCU     [ui]->destroy(); MEMDELETE( m_ppcCU     [ui] ); m_ppcCU     [ui] = NULL;
   }
 
-  delete [] m_ppcYuvResi; m_ppcYuvResi = NULL;
-  delete [] m_ppcYuvReco; m_ppcYuvReco = NULL;
-  delete [] m_ppcCU     ; m_ppcCU      = NULL;
+  MEMDELETEARRAY( m_ppcYuvResi ); m_ppcYuvResi = NULL;
+  MEMDELETEARRAY( m_ppcYuvReco ); m_ppcYuvReco = NULL;
+  MEMDELETEARRAY( m_ppcCU      ); m_ppcCU      = NULL;
 }
 
 // ====================================================================================================================

source/Lib/TLibDecoder/TDecEntropy.cpp

@@ -198 +198 @@
     m_pcEntropyDecoderIf->setMaxAlfCtrlDepth(uiSymbol);
     if( pAlfParam->bSeparateQt )
     {
-      pAlfParam->pcQuadTree = new TComPicSym();
+      pAlfParam->pcQuadTree = MEMNEW TComPicSym();
       pAlfParam->pcQuadTree->create( pcPic->getPicYuvRec()->getWidth(), pcPic->getPicYuvRec()->getHeight(),  g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
       for( UInt uiCUAddr = 0; uiCUAddr < pAlfParam->pcQuadTree->getNumberOfCUsInFrame(); uiCUAddr++ )
       {

source/Lib/TLibDecoder/TDecGop.cpp

@@ -185 +185 @@
 
   Double dDecTime = (double)(clock()-iBeforeTime) / CLOCKS_PER_SEC;
   printf ("[DT %6.3f] ", dDecTime );
+  printf( "[MA %.1lf MB, %.1lf KTimes] " , GetMaxMBMemAllocated() , GetTimesMemAllocation() / 1000 );
 
   for (Int iRefList = 0; iRefList < 2; iRefList++)
   {

source/Lib/TLibDecoder/TDecSlice.cpp

@@ -35 +35 @@
 
 #include "TDecSlice.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
 //////////////////////////////////////////////////////////////////////
 // Construction/Destruction
 //////////////////////////////////////////////////////////////////////
@@ -60 +62 @@
   {
     if(m_apcVirtPic[j][i] == NULL)
     {
-      m_apcVirtPic[j][i] = new TComPic;
+      m_apcVirtPic[j][i] = MEMNEW TComPic;
       m_apcVirtPic[j][i]->create( iWidth, iHeight, uiMaxWidth, uiMaxHeight, uiMaxDepth, true );
     }
   }
@@ -75 +77 @@
     if(m_apcVirtPic[j][i])
     {
       m_apcVirtPic[j][i]->destroy();
-      delete m_apcVirtPic[j][i];
+      MEMDELETE( m_apcVirtPic[j][i] );
       m_apcVirtPic[j][i]=NULL;
     }
   }

source/Lib/TLibDecoder/TDecTop.cpp

@@ -35 +35 @@
 
 #include "TDecTop.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
 TDecTop::TDecTop()
 {
   m_iGopSize      = 0;
@@ -62 +64 @@
 Void TDecTop::create()
 {
   m_cGopDecoder.create();
-  m_apcSlicePilot = new TComSlice;
+  m_apcSlicePilot = MEMNEW TComSlice;
 }
 
 Void TDecTop::destroy()
 {
   m_cGopDecoder.destroy();
 
-  delete m_apcSlicePilot;
+  MEMDELETE( m_apcSlicePilot );
   m_apcSlicePilot = NULL;
 
   m_cSliceDecoder.destroy();
@@ -95 +97 @@
     TComPic* pcPic = *(iterPic++);
     pcPic->destroy();
 
-    delete pcPic;
+    MEMDELETE( pcPic );
     pcPic = NULL;
   }
 
@@ -129 +131 @@
 
   if (m_cListPic.size() < (UInt)m_iMaxRefPicNum)
   {
-    rpcPic = new TComPic;
+    rpcPic = MEMNEW TComPic;
 
     rpcPic->create ( pcSlice->getSPS()->getWidth(), pcSlice->getSPS()->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, true);
     m_cListPic.pushBack( rpcPic );

source/Lib/TLibEncoder/TEncAdaptiveLoopFilter.cpp

@@ -38 +38 @@
 #include <stdio.h>
 #include <math.h>
 
+#include "../TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Constants
 // ====================================================================================================================
@@ -77 +79 @@
 {
   m_pcPic = pcPic;
   m_pcEntropyCoder = pcEntropyCoder;
-  m_pcCoderFixedBits = new TComBitCounter;
+  m_pcCoderFixedBits = MEMNEW TComBitCounter;
   m_pcEntropyCoder->setBitstream( m_pcCoderFixedBits );
   m_pppcRDSbacCoder = pppcRDSbacCoder;
   m_pcRDGoOnSbacCoder = pcRDGoOnSbacCoder;
@@ -105 +107 @@
   Int iWidth  = pcPic->getPicYuvOrg()->getWidth();
   Int iHeight = pcPic->getPicYuvOrg()->getHeight();
 
-  m_pcPicYuvTmp = new TComPicYuv();
+  m_pcPicYuvTmp = MEMNEW TComPicYuv();
   m_pcPicYuvTmp->create(iWidth, iHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
 
-  m_pcPicYuvFiltered = new TComPicYuv();
+  m_pcPicYuvFiltered = MEMNEW TComPicYuv();
   m_pcPicYuvFiltered->create(iWidth, iHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
 
   m_pcPicYuvBest = pcPic->getPicYuvPred();
 
-  m_pcBestAlfParam = new ALFParam;
-  m_pcTempAlfParam = new ALFParam;
+  m_pcBestAlfParam = MEMNEW ALFParam;
+  m_pcTempAlfParam = MEMNEW ALFParam;
   allocALFParam(m_pcBestAlfParam);
   allocALFParam(m_pcTempAlfParam);
 }
@@ -125 +127 @@
   xUninitParam();
 
   m_pcPicYuvFiltered->destroy() ;
-  delete m_pcPicYuvFiltered ;
+  MEMDELETE( m_pcPicYuvFiltered ) ;
 
   m_pcPicYuvTmp->destroy();
-  delete m_pcPicYuvTmp ;
+  MEMDELETE( m_pcPicYuvTmp ) ;
 //  m_pcPicYuvTmp = NULL;
   m_pcPic = NULL;
   m_pcEntropyCoder = NULL;
-  delete m_pcCoderFixedBits;
+  MEMDELETE( m_pcCoderFixedBits );
 
   freeALFParam(m_pcBestAlfParam);
   freeALFParam(m_pcTempAlfParam);
-  delete m_pcBestAlfParam ;
-  delete m_pcTempAlfParam;
+  MEMDELETE( m_pcBestAlfParam ) ;
+  MEMDELETE( m_pcTempAlfParam );
 }
 
 /** \param  pcAlfParam          ALF parameter
@@ -155 +157 @@
   TComPicYuv* pcPicOrg             = m_pcPic->getPicYuvOrg();
   TComPicYuv* pcPicYuvRec          = m_pcPic->getPicYuvRec();
 
-  TComPicYuv* pcPicYuvFiltered = new TComPicYuv ;
+  TComPicYuv* pcPicYuvFiltered = MEMNEW TComPicYuv ;
   pcPicYuvFiltered->create(pcPicOrg->getWidth(), pcPicOrg->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth ) ;
 
   // set min cost
@@ -229 +231 @@
   // store best depth
   ruiMaxAlfCtrlDepth = m_pcEntropyCoder->getMaxAlfCtrlDepth();
   pcPicYuvFiltered->destroy() ;
-  delete pcPicYuvFiltered ;
+  MEMDELETE( pcPicYuvFiltered ) ;
 }
 
 
@@ -294 +296 @@
   UInt64 uiDist   ;
   Double dCmpCost   = rdMinCost;
   
-  TComPicYuv* pcTmpPicVerticallyFiltered = new TComPicYuv;
-  TComPicYuv* pcTmpPicHorizontallyFiltered = new TComPicYuv;
+  TComPicYuv* pcTmpPicVerticallyFiltered = MEMNEW TComPicYuv;
+  TComPicYuv* pcTmpPicHorizontallyFiltered = MEMNEW TComPicYuv;
 
   pcTmpPicVerticallyFiltered->create(pcPicOrg->getWidth(), pcPicOrg->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth) ;
   pcTmpPicHorizontallyFiltered->create(pcPicOrg->getWidth(), pcPicOrg->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth) ;
 
-  ALFParam* pcTmpAlfParams = new ALFParam ;
+  ALFParam* pcTmpAlfParams = MEMNEW ALFParam ;
   allocALFParam( pcTmpAlfParams );
 
   for(Int iPrevPlane=0; iPrevPlane<iPlane; iPrevPlane++)
@@ -337 +339 @@
   }
   pcTmpPicVerticallyFiltered->destroy() ;
   pcTmpPicHorizontallyFiltered->destroy() ;
-  delete pcTmpPicVerticallyFiltered ;
-  delete pcTmpPicHorizontallyFiltered ;
+  MEMDELETE( pcTmpPicVerticallyFiltered ) ;
+  MEMDELETE( pcTmpPicHorizontallyFiltered ) ;
   freeALFParam( pcTmpAlfParams );
-  delete pcTmpAlfParams ;
+  MEMDELETE( pcTmpAlfParams ) ;
 }
 
 Void TEncAdaptiveLoopFilter::xFilterTapDecision(TComPicYuv* pcPicOrg, TComPicYuv* pcPicDec, TComPicYuv* pcPicFiltered, ALFParam* pcAlfParams, UInt64& ruiMinRate, UInt64& ruiMinDist, Double& rdMinCost, Int iPlane)
@@ -352 +354 @@
   // }
   UInt64 uiTmpRate, uiTmpDist;
   Double dTmpCost;
-  TComPicYuv* pcTmpPicVerticallyFiltered = new TComPicYuv;
-  TComPicYuv* pcTmpPicHorizontallyFiltered = new TComPicYuv;
-  ALFParam* pcTmpAlfParams = new ALFParam ;
+  TComPicYuv* pcTmpPicVerticallyFiltered = MEMNEW TComPicYuv;
+  TComPicYuv* pcTmpPicHorizontallyFiltered = MEMNEW TComPicYuv;
+  ALFParam* pcTmpAlfParams = MEMNEW ALFParam ;
   allocALFParam( pcTmpAlfParams );
 
 
@@ -402 +404 @@
   freeALFParam( pcTmpAlfParams );
   pcTmpPicHorizontallyFiltered->destroy();
   pcTmpPicVerticallyFiltered->destroy();
-  delete pcTmpAlfParams;
-  delete pcTmpPicHorizontallyFiltered ;
-  delete pcTmpPicVerticallyFiltered ;
+  MEMDELETE( pcTmpAlfParams );
+  MEMDELETE( pcTmpPicHorizontallyFiltered ) ;
+  MEMDELETE( pcTmpPicVerticallyFiltered ) ;
 
 }
 
@@ -414 +416 @@
   m_pcEntropyCoder->setAlfCtrl(true);
   UInt uiBestDepth = 0;
 
-  ALFParam* pcTmpAlfParam = new ALFParam ;
+  ALFParam* pcTmpAlfParam = MEMNEW ALFParam ;
   allocALFParam(pcTmpAlfParam);
   copyALFParam(pcTmpAlfParam, pcAlfParam);
 
-  ALFParam* pcFrmAlfParam = new ALFParam ;
+  ALFParam* pcFrmAlfParam = MEMNEW ALFParam ;
   allocALFParam(pcFrmAlfParam);
   copyALFParam(pcFrmAlfParam, pcAlfParam);
 
-  TComPicYuv* pcFilteredFrm = new TComPicYuv();
+  TComPicYuv* pcFilteredFrm = MEMNEW TComPicYuv();
   pcFilteredFrm->create(pcPicOrg->getWidth(), pcPicOrg->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
   pcPicFiltered->copyToPic( pcFilteredFrm );
 
-  TComPicYuv* pcTmpPicVerticallyFiltered = new TComPicYuv;
+  TComPicYuv* pcTmpPicVerticallyFiltered = MEMNEW TComPicYuv;
   pcTmpPicVerticallyFiltered->create(pcPicOrg->getWidth(), pcPicOrg->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
-  TComPicYuv* pcTmpPicHorizontallyFiltered = new TComPicYuv;
+  TComPicYuv* pcTmpPicHorizontallyFiltered = MEMNEW TComPicYuv;
   pcTmpPicHorizontallyFiltered->create(pcPicOrg->getWidth(), pcPicOrg->getHeight(), g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
 
   TComPicSym* pcQuadTreeBest;
@@ -436 +438 @@
   TComPicSym* pcQuadTreeHelp;
   if( m_bALFSeparateQt )
   {
-    pcQuadTreeBest = new TComPicSym();
+    pcQuadTreeBest = MEMNEW TComPicSym();
     pcQuadTreeBest->create( pcPicDec->getWidth(), pcPicDec->getHeight(),  g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
-    pcQuadTreeTmp = new TComPicSym();
+    pcQuadTreeTmp = MEMNEW TComPicSym();
     pcQuadTreeTmp->create( pcPicDec->getWidth(), pcPicDec->getHeight(),  g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
     for( UInt uiCUAddr = 0; uiCUAddr < pcQuadTreeBest->getNumberOfCUsInFrame(); uiCUAddr++ )
     {
@@ -528 +530 @@
     if( m_bALFSeparateQt )
     {
       pcQuadTreeBest->destroy();
-      delete pcQuadTreeBest;
+      MEMDELETE( pcQuadTreeBest );
     }
   }
 
   if( m_bALFSeparateQt)
   {
     pcQuadTreeTmp->destroy();
-    delete pcQuadTreeTmp;
+    MEMDELETE( pcQuadTreeTmp );
   }
   else
   {
@@ -543 +545 @@
   }
 
   pcFilteredFrm->destroy();
-  delete pcFilteredFrm;
+  MEMDELETE( pcFilteredFrm );
 
   //
   freeALFParam(pcTmpAlfParam);
-  delete pcTmpAlfParam ;
+  MEMDELETE( pcTmpAlfParam  );
   freeALFParam(pcFrmAlfParam);
-  delete pcFrmAlfParam ;
+  MEMDELETE( pcFrmAlfParam  );
 
   pcTmpPicVerticallyFiltered->destroy() ;
-  delete pcTmpPicVerticallyFiltered ;
+  MEMDELETE( pcTmpPicVerticallyFiltered  );
   pcTmpPicHorizontallyFiltered->destroy() ;
-  delete pcTmpPicHorizontallyFiltered ;
+  MEMDELETE( pcTmpPicHorizontallyFiltered  );
 
 }
 
@@ -578 +580 @@
   }
   else
   {
-    m_ppdAlfCorr = new Double*[ALF_MAX_NUM_COEF];
+    m_ppdAlfCorr = MEMNEWARRAY Double*[ALF_MAX_NUM_COEF];
     for (i = 0; i < ALF_MAX_NUM_COEF; i++)
     {
-      m_ppdAlfCorr[i] = new Double[ALF_MAX_NUM_COEF+1];
+      m_ppdAlfCorr[i] = MEMNEWARRAY Double[ALF_MAX_NUM_COEF+1];
       for (j = 0; j < ALF_MAX_NUM_COEF+1; j++)
       {
         m_ppdAlfCorr[i][j] = 0;
@@ -607 +609 @@
   }
   else
   {
-    m_puiCUVerticalCorr = new UInt***[m_pcPic->getNumCUsInFrame()];
+    m_puiCUVerticalCorr = MEMNEWARRAY UInt***[m_pcPic->getNumCUsInFrame()];
     for (i = 0; i < m_pcPic->getNumCUsInFrame(); i++)
     {
-      m_puiCUVerticalCorr[i] = new UInt**[m_uiNumSCUInCU];
+      m_puiCUVerticalCorr[i] = MEMNEWARRAY UInt**[m_uiNumSCUInCU];
       for (j = 0; j < m_uiNumSCUInCU; j++)
       {
-        m_puiCUVerticalCorr[i][j] = new UInt*[ALF_MAX_NUM_COEF];
+        m_puiCUVerticalCorr[i][j] = MEMNEWARRAY UInt*[ALF_MAX_NUM_COEF];
         for (k = 0; k < ALF_MAX_NUM_COEF; k++)
         {
-          m_puiCUVerticalCorr[i][j][k] = new UInt[ALF_MAX_NUM_COEF+1];
+          m_puiCUVerticalCorr[i][j][k] = MEMNEWARRAY UInt[ALF_MAX_NUM_COEF+1];
           for (l = 0; l< ALF_MAX_NUM_COEF+1; l++)
           {
             m_puiCUVerticalCorr[i][j][k][l] = 0;
@@ -645 +647 @@
   }
   else
   {
-    m_puiCUHorizontalCorr = new UInt***[m_pcPic->getNumCUsInFrame()];
+    m_puiCUHorizontalCorr = MEMNEWARRAY UInt***[m_pcPic->getNumCUsInFrame()];
     for (i = 0; i < m_pcPic->getNumCUsInFrame(); i++)
     {
-      m_puiCUHorizontalCorr[i] = new UInt**[m_uiNumSCUInCU];
+      m_puiCUHorizontalCorr[i] = MEMNEWARRAY UInt**[m_uiNumSCUInCU];
       for (j = 0; j < m_uiNumSCUInCU; j++)
       {
-        m_puiCUHorizontalCorr[i][j] = new UInt*[ALF_MAX_NUM_COEF];
+        m_puiCUHorizontalCorr[i][j] = MEMNEWARRAY UInt*[ALF_MAX_NUM_COEF];
         for (k = 0; k < ALF_MAX_NUM_COEF; k++)
         {
-          m_puiCUHorizontalCorr[i][j][k] = new UInt[ALF_MAX_NUM_COEF+1];
+          m_puiCUHorizontalCorr[i][j][k] = MEMNEWARRAY UInt[ALF_MAX_NUM_COEF+1];
           for (l = 0; l< ALF_MAX_NUM_COEF+1; l++)
           {
             m_puiCUHorizontalCorr[i][j][k][l] = 0;
@@ -674 +676 @@
   }
   else
   {
-    m_pdDoubleAlfCoeff = new Double[ALF_MAX_NUM_COEF];
+    m_pdDoubleAlfCoeff = MEMNEWARRAY Double[ALF_MAX_NUM_COEF];
     for (i = 0; i < ALF_MAX_NUM_COEF; i++)
     {
       m_pdDoubleAlfCoeff[i] = 0;
@@ -690 +692 @@
   {
     for (i = 0; i < ALF_MAX_NUM_COEF; i++)
     {
-      delete[] m_ppdAlfCorr[i];
+      MEMDELETEARRAY( m_ppdAlfCorr[i] );
       m_ppdAlfCorr[i] = NULL;
     }
-    delete[] m_ppdAlfCorr;
+    MEMDELETEARRAY( m_ppdAlfCorr );
     m_ppdAlfCorr = NULL;
   }
 
@@ -705 +707 @@
       {
         for (k = 0; k < ALF_MAX_NUM_COEF; k++)
         {
-          delete[] m_puiCUVerticalCorr[i][j][k];
+          MEMDELETEARRAY( m_puiCUVerticalCorr[i][j][k] );
           m_puiCUVerticalCorr[i][j][k] = NULL;
         }
-        delete[] m_puiCUVerticalCorr[i][j];
+        MEMDELETEARRAY( m_puiCUVerticalCorr[i][j] );
         m_puiCUVerticalCorr[i][j] = NULL;
       }
-      delete[] m_puiCUVerticalCorr[i];
+      MEMDELETEARRAY( m_puiCUVerticalCorr[i] );
       m_puiCUVerticalCorr[i] = NULL;
     }
-    delete[] m_puiCUVerticalCorr;
+    MEMDELETEARRAY( m_puiCUVerticalCorr );
     m_puiCUVerticalCorr = NULL;
   }
 
@@ -726 +728 @@
         {
           for (k = 0; k < ALF_MAX_NUM_COEF; k++)
           {
-            delete[] m_puiCUHorizontalCorr[i][j][k];
+            MEMDELETEARRAY( m_puiCUHorizontalCorr[i][j][k] );
             m_puiCUHorizontalCorr[i][j][k] = NULL;
           }
-          delete[] m_puiCUHorizontalCorr[i][j];
+          MEMDELETEARRAY( m_puiCUHorizontalCorr[i][j] );
           m_puiCUHorizontalCorr[i][j] = NULL;
         }
-        delete[] m_puiCUHorizontalCorr[i];
+        MEMDELETEARRAY( m_puiCUHorizontalCorr[i] );
         m_puiCUHorizontalCorr[i] = NULL;
       }
-      delete[] m_puiCUHorizontalCorr;
+      MEMDELETEARRAY( m_puiCUHorizontalCorr );
       m_puiCUHorizontalCorr = NULL;
     }
 
 
   if (m_pdDoubleAlfCoeff != NULL)
   {
-    delete[] m_pdDoubleAlfCoeff;
+    MEMDELETEARRAY( m_pdDoubleAlfCoeff );
     m_pdDoubleAlfCoeff = NULL;
   }
 }
@@ -1054 +1056 @@
 
   Int* aiQuantCoeffs = rcFilter.aiQuantFilterCoeffs;
 
-  Double* adDelta   = new Double[ iNumCoeffs+1 ];
-  Int*    aiPosIndx = new Int   [ iNumCoeffs+1 ];
+  Double* adDelta   = MEMNEWARRAY Double[ iNumCoeffs+1 ];
+  Int*    aiPosIndx = MEMNEWARRAY Int   [ iNumCoeffs+1 ];
 
 
   dGainNotQuant = 0.0;
@@ -1120 +1122 @@
     aiQuantCoeffs[i] = Max( iMinValue , Min( iMaxValue , aiQuantCoeffs[i] ) );
   }
 
-  delete[] adDelta;
+  MEMDELETEARRAY( adDelta );
   adDelta = NULL;
 
-  delete[] aiPosIndx;
+  MEMDELETEARRAY( aiPosIndx );
   aiPosIndx = NULL;
 }
 
@@ -1139 +1141 @@
 {
   if(pAlfParam != NULL)
   {
-    ALFParam* pcTempAlfParams = new ALFParam ;
+    ALFParam* pcTempAlfParams = MEMNEW ALFParam ;
     allocALFParam( pcTempAlfParams );
     copyALFParam(pcTempAlfParams, pAlfParam);
     xPredictALFCoeff(pcTempAlfParams, 0 );
@@ -1153 +1155 @@
 
     m_pcEntropyCoder->encodeAlfParam( pcTempAlfParams );
     freeALFParam( pcTempAlfParams );
-    delete pcTempAlfParams ;
+    MEMDELETE( pcTempAlfParams  );
     ruiRate = m_pcEntropyCoder->getNumberOfWrittenBits();
   }
   else
@@ -1167 +1169 @@
 {
   if(pAlfParam != NULL)
   {
-    ALFParam* pcTempAlfParams = new ALFParam ;
+    ALFParam* pcTempAlfParams = MEMNEW ALFParam ;
     allocALFParam( pcTempAlfParams );
     copyALFParam(pcTempAlfParams, pAlfParam);
     xPredictALFCoeff(pcTempAlfParams, iPlane );
@@ -1175 +1177 @@
     m_pcEntropyCoder->resetBits();
     m_pcEntropyCoder->encodeAlfParam(pcTempAlfParams);
     freeALFParam( pcTempAlfParams );
-    delete pcTempAlfParams ;
+    MEMDELETE( pcTempAlfParams  );
 
     if(pAlfParam->cu_control_flag)
     {
@@ -1400 +1402 @@
     }
     UInt64* auiFixedBitsCurrBest;
     UInt64* auiFixedBitsNextBest;
-    auiFixedBitsCurrBest = new UInt64[MAX_CU_DEPTH];
-    auiFixedBitsNextBest = new UInt64[MAX_CU_DEPTH];
+    auiFixedBitsCurrBest = MEMNEWARRAY UInt64[MAX_CU_DEPTH];
+    auiFixedBitsNextBest = MEMNEWARRAY UInt64[MAX_CU_DEPTH];
     ::memset( auiFixedBitsCurrBest , 0 , sizeof(UInt64) * MAX_CU_DEPTH );
     ::memset( auiFixedBitsNextBest , 0 , sizeof(UInt64) * MAX_CU_DEPTH );
     for( UInt uiCUAddr = 0; uiCUAddr < pcQuadTree->getNumberOfCUsInFrame() ; uiCUAddr++ )
@@ -1420 +1422 @@
       m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[0][CI_NEXT_BEST] );
     }
     ruiRate = auiFixedBitsNextBest[0] + m_pcEntropyCoder->getNumberOfWrittenBits() ;
-    delete[] auiFixedBitsCurrBest;
-    delete[] auiFixedBitsNextBest;
+    MEMDELETEARRAY( auiFixedBitsCurrBest );
+    MEMDELETEARRAY( auiFixedBitsNextBest );
   }
   else
   {
@@ -1973 +1975 @@
   Int iWidth = pcPic->getPicYuvOrg()->getWidth();
   Int iHeight = pcPic->getPicYuvOrg()->getHeight();
 
-  m_pcPicYuvTmp = new TComPicYuv();
+  m_pcPicYuvTmp = MEMNEW TComPicYuv();
   m_pcPicYuvTmp->createLuma(iWidth, iHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth);
   m_pcPicYuvBest = pcPic->getPicYuvPred();
 
-  m_pcBestAlfParam = new ALFParam;
-  m_pcTempAlfParam = new ALFParam;
+  m_pcBestAlfParam = MEMNEW ALFParam;
+  m_pcTempAlfParam = MEMNEW ALFParam;
   allocALFParam(m_pcBestAlfParam);
   allocALFParam(m_pcTempAlfParam);
 #if QC_ALF
@@ -2005 +2007 @@
   get_mem2Dpel(&maskImg, im_height, im_width);
   
 //  InitALFGlobalBuffers (iWidth, iHeight);
-  ALFp = new ALFParam;
-  tempALFp = new ALFParam;
+  ALFp = MEMNEW ALFParam;
+  tempALFp = MEMNEW ALFParam;
   allocALFParam(ALFp);
   allocALFParam(tempALFp);
   m_pcDummyEntropyCoder = m_pcEntropyCoder;
@@ -2019 +2021 @@
   xDestroyTmpAlfCtrlFlags();
 
   m_pcPicYuvTmp->destroyLuma();
-  delete m_pcPicYuvTmp;
+  MEMDELETE( m_pcPicYuvTmp );
   m_pcPicYuvTmp = NULL;
   m_pcPic = NULL;
   m_pcEntropyCoder = NULL;
 
   freeALFParam(m_pcBestAlfParam);
   freeALFParam(m_pcTempAlfParam);
-  delete m_pcBestAlfParam;
-  delete m_pcTempAlfParam;
+  MEMDELETE( m_pcBestAlfParam );
+  MEMDELETE( m_pcTempAlfParam );
 #if QC_ALF
   free_mem2Dpel (imgY_rec);
   free_mem2Dpel (imgY_org);
@@ -2050 +2052 @@
   //  FreeALFGlobalBurrers();
   freeALFParam(ALFp);
   freeALFParam(tempALFp);
-  delete ALFp;
-  delete tempALFp;
+  MEMDELETE( ALFp );
+  MEMDELETE( tempALFp );
 #endif
 }
 
@@ -2442 +2444 @@
   }
   else
   {
-    m_ppdAlfCorr = new Double*[ALF_MAX_NUM_COEF];
+    m_ppdAlfCorr = MEMNEWARRAY Double*[ALF_MAX_NUM_COEF];
     for (i = 0; i < ALF_MAX_NUM_COEF; i++)
     {
-      m_ppdAlfCorr[i] = new Double[ALF_MAX_NUM_COEF+1];
+      m_ppdAlfCorr[i] = MEMNEWARRAY Double[ALF_MAX_NUM_COEF+1];
       for (j = 0; j < ALF_MAX_NUM_COEF+1; j++)
       {
         m_ppdAlfCorr[i][j] = 0;
@@ -2471 +2473 @@
   }
   else
   {
-    m_puiCUCorr = new CorrBlk*[m_pcPic->getNumCUsInFrame()];
+    m_puiCUCorr = MEMNEWARRAY CorrBlk*[m_pcPic->getNumCUsInFrame()];
     for (i = 0; i < m_pcPic->getNumCUsInFrame(); i++)
     {
-      m_puiCUCorr[i] = new CorrBlk[m_uiNumSCUInCU];
+      m_puiCUCorr[i] = MEMNEWARRAY CorrBlk[m_uiNumSCUInCU];
 
       for (j = 0; j < m_uiNumSCUInCU; j++)
       {
@@ -2498 +2500 @@
   }
   else
   {
-    m_pdDoubleAlfCoeff = new Double[ALF_MAX_NUM_COEF];
+    m_pdDoubleAlfCoeff = MEMNEWARRAY Double[ALF_MAX_NUM_COEF];
     for (i = 0; i < ALF_MAX_NUM_COEF; i++)
     {
       m_pdDoubleAlfCoeff[i] = 0;
@@ -2514 +2516 @@
   {
     for (i = 0; i < ALF_MAX_NUM_COEF; i++)
     {
-      delete[] m_ppdAlfCorr[i];
+      MEMDELETEARRAY( m_ppdAlfCorr[i] );
       m_ppdAlfCorr[i] = NULL;
     }
-    delete[] m_ppdAlfCorr;
+    MEMDELETEARRAY( m_ppdAlfCorr );
     m_ppdAlfCorr = NULL;
   }
 
@@ -2525 +2527 @@
   {
     for (i = 0; i < m_pcPic->getNumCUsInFrame(); i++)
     {
-      delete[] m_puiCUCorr[i];
+      MEMDELETEARRAY( m_puiCUCorr[i] );
       m_puiCUCorr[i] = NULL;
     }
-    delete[] m_puiCUCorr;
+    MEMDELETEARRAY( m_puiCUCorr );
     m_puiCUCorr = NULL;
   }
 
   if (m_pdDoubleAlfCoeff != NULL)
   {
-    delete[] m_pdDoubleAlfCoeff;
+    MEMDELETEARRAY( m_pdDoubleAlfCoeff );
     m_pdDoubleAlfCoeff = NULL;
   }
 }
@@ -2705 +2707 @@
     break;
   }
 
-  UInt* pTerm = new UInt[N];
+  UInt* pTerm = MEMNEWARRAY UInt[N];
 
   Int i, j;
 
@@ -2740 +2742 @@
     }
   }
 
-  delete[] pTerm;
+  MEMDELETEARRAY( pTerm );
   pTerm = NULL;
 }
 
@@ -2771 +2773 @@
     break;
   }
 
-  Pel* pTerm = new Pel[N];
+  Pel* pTerm = MEMNEWARRAY Pel[N];
 
   Int i, j;
 
@@ -2812 +2814 @@
     for(i=j+1; i<N; i++)
       m_ppdAlfCorr[i][j] = m_ppdAlfCorr[j][i];
 
-  delete[] pTerm;
+  MEMDELETEARRAY( pTerm );
   pTerm = NULL;
 }
 
@@ -2843 +2845 @@
     break;
   }
 
-  Pel* pTerm = new Pel[N];
+  Pel* pTerm = MEMNEWARRAY Pel[N];
 
   Int i, j;
 
@@ -2880 +2882 @@
     }
   }
 
-  delete[] pTerm;
+  MEMDELETEARRAY( pTerm );
   pTerm = NULL;
 }
 
@@ -2998 +3000 @@
 
   N = (tap*tap+1)>>1;
 
-  dh = new Double[N];
-  nc = new Int[N];
+  dh = MEMNEWARRAY Double[N];
+  nc = MEMNEWARRAY Int[N];
 
   max_value =   (1<<(1+ALF_NUM_BIT_SHIFT))-1;
   min_value = 0-(1<<(1+ALF_NUM_BIT_SHIFT));
@@ -3087 +3089 @@
   qh[N] =  (h[N]>=0.0)? (Int)( h[N]*(1<<(ALF_NUM_BIT_SHIFT-bit_depth+8)) + 0.5) : -(Int)(-h[N]*(1<<(ALF_NUM_BIT_SHIFT-bit_depth+8)) + 0.5);
   qh[N] = Max(min_value,Min(max_value, qh[N]));
 
-  delete[] dh;
+  MEMDELETEARRAY( dh );
   dh = NULL;
 
-  delete[] nc;
+  MEMDELETEARRAY( nc );
   nc = NULL;
 }
 
@@ -3108 +3110 @@
   if(pAlfParam != NULL)
   {
     Int* piTmpCoef;
-    piTmpCoef = new Int[ALF_MAX_NUM_COEF];
+    piTmpCoef = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
 
     memcpy(piTmpCoef, pAlfParam->coeff, sizeof(Int)*pAlfParam->num_coeff);
 
@@ -3124 +3126 @@
     }
     ruiRate = m_pcEntropyCoder->getNumberOfWrittenBits();
     memcpy(pAlfParam->coeff, piTmpCoef, sizeof(int)*pAlfParam->num_coeff);
-    delete[] piTmpCoef;
+    MEMDELETEARRAY( piTmpCoef );
     piTmpCoef = NULL;
   }
   else
@@ -3140 +3142 @@
   if(pAlfParam != NULL)
   {
     Int* piTmpCoef;
-    piTmpCoef = new Int[ALF_MAX_NUM_COEF];
+    piTmpCoef = MEMNEWARRAY Int[ALF_MAX_NUM_COEF];
 
     memcpy(piTmpCoef, pAlfParam->coeff, sizeof(Int)*pAlfParam->num_coeff);
 
@@ -3156 +3158 @@
     }
     ruiRate = m_pcEntropyCoder->getNumberOfWrittenBits();
     memcpy(pAlfParam->coeff, piTmpCoef, sizeof(int)*pAlfParam->num_coeff);
-    delete[] piTmpCoef;
+    MEMDELETEARRAY( piTmpCoef );
     piTmpCoef = NULL;
   }
   else
@@ -3173 +3175 @@
   if(pAlfParam->chroma_idc)
   {
     Int* piTmpCoef;
-    piTmpCoef = new Int[ALF_MAX_NUM_COEF_C];
+    piTmpCoef = MEMNEWARRAY Int[ALF_MAX_NUM_COEF_C];
 
     memcpy(piTmpCoef, pAlfParam->coeff_chroma, sizeof(Int)*pAlfParam->num_coeff_chroma);
 
@@ -3189 +3191 @@
     }
     ruiRate = m_pcEntropyCoder->getNumberOfWrittenBits();
     memcpy(pAlfParam->coeff_chroma, piTmpCoef, sizeof(int)*pAlfParam->num_coeff_chroma);
-    delete[] piTmpCoef;
+    MEMDELETEARRAY( piTmpCoef );
     piTmpCoef = NULL;
   }
   ruiDist = 0;

source/Lib/TLibEncoder/TEncBinCoderPIPE.cpp

@@ -35 +35 @@
 
 #include "TEncBinCoderPIPE.h"
 
+#include "../TLibCommon/tool_tracemem.h"
 
 #define INVALID  UInt(-1)
 
@@ -88 +89 @@
 CodewordBuffer::CodewordBuffer()
 : m_pcTComBitIf       ( 0 )
 , m_uiBufferSize      ( INIT_CODEWORD_BUFFER_SIZE )
-, m_pacCodewordBuffer ( new CBufEntry [ m_uiBufferSize ] )
+, m_pacCodewordBuffer ( MEMNEWARRAY CBufEntry [ m_uiBufferSize ] )
 #if PIPE_LOW_DELAY_OPTION
 , m_papcV2VEncoders   ( 0 )
 #endif
@@ -97 +98 @@
 
 CodewordBuffer::~CodewordBuffer()
 {
-  delete [] m_pacCodewordBuffer;
+  MEMDELETEARRAY( m_pacCodewordBuffer );
 }
 
 #if PIPE_LOW_DELAY_OPTION
@@ -190 +191 @@
   UInt              uiNewBufferSize       = m_uiBufferSize      + m_uiBufferSize;
   UInt              uiNewNextWriteIdx     = 0;
   UInt              uiNewNextReservedIdx  = m_uiBufferSize      - m_uiNumFreeEntries;
-  CBufEntry*        pacNewCodewordBuffer  = new CBufEntry       [ uiNewBufferSize ];
+  CBufEntry*        pacNewCodewordBuffer  = MEMNEWARRAY CBufEntry       [ uiNewBufferSize ];
   for( UInt uiSrcIdx = m_uiNextWriteIdx, uiDesIdx = uiNewNextWriteIdx; uiDesIdx < uiNewNextReservedIdx; uiDesIdx++, uiSrcIdx = ( uiSrcIdx + 1 ) % m_uiBufferSize )
   {
     pacNewCodewordBuffer[ uiDesIdx ] = m_pacCodewordBuffer[ uiSrcIdx ];
@@ -203 +204 @@
   {
     pacNewCodewordBuffer[ uiDesIdx ].ucCWLength = 0;
   }
-  delete [] m_pacCodewordBuffer;
+  MEMDELETEARRAY( m_pacCodewordBuffer );
   m_uiNextWriteIdx    = uiNewNextWriteIdx;
   m_uiNextReserveIdx  = uiNewNextReservedIdx;
   m_uiBufferSize      = uiNewBufferSize;
@@ -241 +242 @@
 {
   for( UInt uiIdx = 0; uiIdx < NUM_V2V_CODERS; uiIdx++ )
   {
-    m_apcV2VEncoders[ uiIdx ] = new V2VEncoder( uiIdx, m_cCodewordBuffer );
+    m_apcV2VEncoders[ uiIdx ] = MEMNEW V2VEncoder( uiIdx, m_cCodewordBuffer );
   }
 #if PIPE_LOW_DELAY_OPTION
   m_cCodewordBuffer.initDelay( m_apcV2VEncoders, 0 );
@@ -252 +253 @@
 {
   for( UInt uiIdx = 0; uiIdx < NUM_V2V_CODERS; uiIdx++ )
   {
-    delete m_apcV2VEncoders[ uiIdx ];
+    MEMDELETE( m_apcV2VEncoders[ uiIdx ] );
   }
 }
 

source/Lib/TLibEncoder/TEncBinCoderV2VwLB.h

@@ -46 +46 @@
 #include <cstdlib>
 #include <cstring>
 
+#include "../TLibCommon/tool_tracemem.h"
+
 class TEncClearBit : public TEncBinIf {
 
 public:
@@ -132 +134 @@
 
 public:
     TEncClearBuffer() {
-        buffer = new parallel_buffer[BUFFER_SIZE];
-        temp_space = new UChar[TEMP_SIZE];
+        buffer = MEMNEWARRAY parallel_buffer[BUFFER_SIZE];
+        temp_space = MEMNEWARRAY UChar[TEMP_SIZE];
         init();
     }
 
     virtual ~TEncClearBuffer() {
-        delete [] temp_space;
-        delete [] buffer;
+        MEMDELETEARRAY( temp_space );
+        MEMDELETEARRAY( buffer );
     }
 
     Void setState ( UInt* pui ) { memcpy( m_uiState, pui, sizeof(UInt) * StateCount ); }
@@ -173 +175 @@
     virtual void groupStates();
 
 public:
-    TEncV2V() { LB_temp_space = new UChar[TEMP_SIZE]; }
-    ~TEncV2V() { delete [] LB_temp_space; }
+    TEncV2V() { LB_temp_space = MEMNEWARRAY UChar[TEMP_SIZE]; }
+    ~TEncV2V() { MEMDELETEARRAY( LB_temp_space ); }
 };
 
 #endif

source/Lib/TLibEncoder/TEncCu.cpp

@@ -38 +38 @@
 #include "TEncCu.h"
 #include "TEncAnalyze.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
 // ====================================================================================================================
@@ -51 +53 @@
   Int i;
 
   m_uhTotalDepth   = uhTotalDepth + 1;
-  m_ppcBestCU      = new TComDataCU*[m_uhTotalDepth-1];
-  m_ppcTempCU      = new TComDataCU*[m_uhTotalDepth-1];
+  m_ppcBestCU      = MEMNEWARRAY TComDataCU*[m_uhTotalDepth-1];
+  m_ppcTempCU      = MEMNEWARRAY TComDataCU*[m_uhTotalDepth-1];
 
-  m_ppcPredYuvBest = new TComYuv*[m_uhTotalDepth-1];
-  m_ppcResiYuvBest = new TComYuv*[m_uhTotalDepth-1];
-  m_ppcRecoYuvBest = new TComYuv*[m_uhTotalDepth-1];
-  m_ppcPredYuvTemp = new TComYuv*[m_uhTotalDepth-1];
-  m_ppcResiYuvTemp = new TComYuv*[m_uhTotalDepth-1];
-  m_ppcRecoYuvTemp = new TComYuv*[m_uhTotalDepth-1];
-  m_ppcOrigYuv     = new TComYuv*[m_uhTotalDepth-1];
+  m_ppcPredYuvBest = MEMNEWARRAY TComYuv*[m_uhTotalDepth-1];
+  m_ppcResiYuvBest = MEMNEWARRAY TComYuv*[m_uhTotalDepth-1];
+  m_ppcRecoYuvBest = MEMNEWARRAY TComYuv*[m_uhTotalDepth-1];
+  m_ppcPredYuvTemp = MEMNEWARRAY TComYuv*[m_uhTotalDepth-1];
+  m_ppcResiYuvTemp = MEMNEWARRAY TComYuv*[m_uhTotalDepth-1];
+  m_ppcRecoYuvTemp = MEMNEWARRAY TComYuv*[m_uhTotalDepth-1];
+  m_ppcOrigYuv     = MEMNEWARRAY TComYuv*[m_uhTotalDepth-1];
 
   UInt uiNumPartitions;
   for( i=0 ; i<m_uhTotalDepth-1 ; i++)
@@ -69 +71 @@
     UInt uiWidth  = uiMaxWidth  >> i;
     UInt uiHeight = uiMaxHeight >> i;
 
-    m_ppcBestCU[i] = new TComDataCU; m_ppcBestCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false );
-    m_ppcTempCU[i] = new TComDataCU; m_ppcTempCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false );
+    m_ppcBestCU[i] = MEMNEW TComDataCU; m_ppcBestCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false );
+    m_ppcTempCU[i] = MEMNEW TComDataCU; m_ppcTempCU[i]->create( uiNumPartitions, uiWidth, uiHeight, false );
 
-    m_ppcPredYuvBest[i] = new TComYuv; m_ppcPredYuvBest[i]->create(uiWidth, uiHeight);
-    m_ppcResiYuvBest[i] = new TComYuv; m_ppcResiYuvBest[i]->create(uiWidth, uiHeight);
-    m_ppcRecoYuvBest[i] = new TComYuv; m_ppcRecoYuvBest[i]->create(uiWidth, uiHeight);
+    m_ppcPredYuvBest[i] = MEMNEW TComYuv; m_ppcPredYuvBest[i]->create(uiWidth, uiHeight);
+    m_ppcResiYuvBest[i] = MEMNEW TComYuv; m_ppcResiYuvBest[i]->create(uiWidth, uiHeight);
+    m_ppcRecoYuvBest[i] = MEMNEW TComYuv; m_ppcRecoYuvBest[i]->create(uiWidth, uiHeight);
 
-    m_ppcPredYuvTemp[i] = new TComYuv; m_ppcPredYuvTemp[i]->create(uiWidth, uiHeight);
-    m_ppcResiYuvTemp[i] = new TComYuv; m_ppcResiYuvTemp[i]->create(uiWidth, uiHeight);
-    m_ppcRecoYuvTemp[i] = new TComYuv; m_ppcRecoYuvTemp[i]->create(uiWidth, uiHeight);
+    m_ppcPredYuvTemp[i] = MEMNEW TComYuv; m_ppcPredYuvTemp[i]->create(uiWidth, uiHeight);
+    m_ppcResiYuvTemp[i] = MEMNEW TComYuv; m_ppcResiYuvTemp[i]->create(uiWidth, uiHeight);
+    m_ppcRecoYuvTemp[i] = MEMNEW TComYuv; m_ppcRecoYuvTemp[i]->create(uiWidth, uiHeight);
 
-    m_ppcOrigYuv    [i] = new TComYuv; m_ppcOrigYuv    [i]->create(uiWidth, uiHeight);
+    m_ppcOrigYuv    [i] = MEMNEW TComYuv; m_ppcOrigYuv    [i]->create(uiWidth, uiHeight);
   }
 
   // initialize partition order.
@@ -100 +102 @@
   {
     if(m_ppcBestCU[i])
     {
-      m_ppcBestCU[i]->destroy();      delete m_ppcBestCU[i];      m_ppcBestCU[i] = NULL;
+      m_ppcBestCU[i]->destroy();      MEMDELETE( m_ppcBestCU[i] );      m_ppcBestCU[i] = NULL;
     }
     if(m_ppcTempCU[i])
     {
-      m_ppcTempCU[i]->destroy();      delete m_ppcTempCU[i];      m_ppcTempCU[i] = NULL;
+      m_ppcTempCU[i]->destroy();      MEMDELETE( m_ppcTempCU[i] );      m_ppcTempCU[i] = NULL;
     }
     if(m_ppcPredYuvBest[i])
     {
-      m_ppcPredYuvBest[i]->destroy(); delete m_ppcPredYuvBest[i]; m_ppcPredYuvBest[i] = NULL;
+      m_ppcPredYuvBest[i]->destroy(); MEMDELETE( m_ppcPredYuvBest[i] ); m_ppcPredYuvBest[i] = NULL;
     }
     if(m_ppcResiYuvBest[i])
     {
-      m_ppcResiYuvBest[i]->destroy(); delete m_ppcResiYuvBest[i]; m_ppcResiYuvBest[i] = NULL;
+      m_ppcResiYuvBest[i]->destroy(); MEMDELETE( m_ppcResiYuvBest[i] ); m_ppcResiYuvBest[i] = NULL;
     }
     if(m_ppcRecoYuvBest[i])
     {
-      m_ppcRecoYuvBest[i]->destroy(); delete m_ppcRecoYuvBest[i]; m_ppcRecoYuvBest[i] = NULL;
+      m_ppcRecoYuvBest[i]->destroy(); MEMDELETE( m_ppcRecoYuvBest[i] ); m_ppcRecoYuvBest[i] = NULL;
     }
     if(m_ppcPredYuvTemp[i])
     {
-      m_ppcPredYuvTemp[i]->destroy(); delete m_ppcPredYuvTemp[i]; m_ppcPredYuvTemp[i] = NULL;
+      m_ppcPredYuvTemp[i]->destroy(); MEMDELETE( m_ppcPredYuvTemp[i] ); m_ppcPredYuvTemp[i] = NULL;
     }
     if(m_ppcResiYuvTemp[i])
     {
-      m_ppcResiYuvTemp[i]->destroy(); delete m_ppcResiYuvTemp[i]; m_ppcResiYuvTemp[i] = NULL;
+      m_ppcResiYuvTemp[i]->destroy(); MEMDELETE( m_ppcResiYuvTemp[i] ); m_ppcResiYuvTemp[i] = NULL;
     }
     if(m_ppcRecoYuvTemp[i])
     {
-      m_ppcRecoYuvTemp[i]->destroy(); delete m_ppcRecoYuvTemp[i]; m_ppcRecoYuvTemp[i] = NULL;
+      m_ppcRecoYuvTemp[i]->destroy(); MEMDELETE( m_ppcRecoYuvTemp[i] ); m_ppcRecoYuvTemp[i] = NULL;
     }
     if(m_ppcOrigYuv[i])
     {
-      m_ppcOrigYuv[i]->destroy();     delete m_ppcOrigYuv[i];     m_ppcOrigYuv[i] = NULL;
+      m_ppcOrigYuv[i]->destroy();     MEMDELETE( m_ppcOrigYuv[i] );     m_ppcOrigYuv[i] = NULL;
     }
   }
   if(m_ppcBestCU)
   {
-    delete [] m_ppcBestCU;
+    MEMDELETEARRAY( m_ppcBestCU );
     m_ppcBestCU = NULL;
   }
   if(m_ppcTempCU)
   {
-    delete [] m_ppcTempCU;
+    MEMDELETEARRAY( m_ppcTempCU );
     m_ppcTempCU = NULL;
   }
 
   if(m_ppcPredYuvBest)
   {
-    delete [] m_ppcPredYuvBest;
+    MEMDELETEARRAY( m_ppcPredYuvBest );
     m_ppcPredYuvBest = NULL;
   }
   if(m_ppcResiYuvBest)
   {
-    delete [] m_ppcResiYuvBest;
+    MEMDELETEARRAY( m_ppcResiYuvBest );
     m_ppcResiYuvBest = NULL;
   }
   if(m_ppcRecoYuvBest)
   {
-    delete [] m_ppcRecoYuvBest;
+    MEMDELETEARRAY( m_ppcRecoYuvBest );
     m_ppcRecoYuvBest = NULL;
   }
   if(m_ppcPredYuvTemp)
   {
-    delete [] m_ppcPredYuvTemp;
+    MEMDELETEARRAY( m_ppcPredYuvTemp );
     m_ppcPredYuvTemp = NULL;
   }
   if(m_ppcResiYuvTemp)
   {
-    delete [] m_ppcResiYuvTemp;
+    MEMDELETEARRAY( m_ppcResiYuvTemp );
     m_ppcResiYuvTemp = NULL;
   }
   if(m_ppcRecoYuvTemp)
   {
-    delete [] m_ppcRecoYuvTemp;
+    MEMDELETEARRAY( m_ppcRecoYuvTemp );
     m_ppcRecoYuvTemp = NULL;
   }
   if(m_ppcOrigYuv)
   {
-    delete [] m_ppcOrigYuv;
+    MEMDELETEARRAY( m_ppcOrigYuv );
     m_ppcOrigYuv = NULL;
   }
 }

source/Lib/TLibEncoder/TEncGOP.cpp

@@ -39 +39 @@
 
 #include <time.h>
 
+#include "../TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / initialization / destroy
 // ====================================================================================================================
@@ -123 +125 @@
   TComPicYuv      cPicOrg;
   TComPic*        pcOrgRefList[2][MAX_REF_PIC_NUM];
 //stats
-  TComBitstream*  pcOut = new TComBitstream;
+  TComBitstream*  pcOut = MEMNEW TComBitstream;
   pcOut->create( 500000 );
 
   xInitGOP( iPOCLast, iNumPicRcvd, rcListPic, rcListPicYuvRecOut );
@@ -573 +575 @@
   }
 
   pcOut->destroy();
-  delete pcOut;
+  MEMDELETE( pcOut );
 
   assert ( m_iNumPicCoded == iNumPicRcvd );
 }
@@ -993 +995 @@
     uibits );
   printf( "[Y %6.4lf dB    U %6.4lf dB    V %6.4lf dB]  ", dYPSNR, dUPSNR, dVPSNR );
   printf ("[ET %5.0f ] ", dEncTime );
+  printf( "[MA %.1lf MB, %.1lf KTimes] " , GetMaxMBMemAllocated() , GetTimesMemAllocation() / 1000 );
 
   for (Int iRefList = 0; iRefList < 2; iRefList++)
   {

source/Lib/TLibEncoder/TEncSearch.cpp

@@ -37 +37 @@
 #include "../TLibCommon/TComMotionInfo.h"
 #include "TEncSearch.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
+
 #ifdef ROUNDING_CONTROL_BIPRED
 __inline Pel  xClip  (Pel x )      { return ( (x < 0) ? 0 : (x > (Pel)g_uiIBDI_MAX) ? (Pel)g_uiIBDI_MAX : x ); }
 #endif
@@ -119 +122 @@
 {
   if ( m_pTempPel )
   {
-    delete [] m_pTempPel;
+    MEMDELETEARRAY( m_pTempPel );
     m_pTempPel = NULL;
   }
 #if HHI_RQT
@@ -128 +131 @@
     const UInt uiNumLayersAllocated = m_pcEncCfg->getQuadtreeTULog2MaxSize()-m_pcEncCfg->getQuadtreeTULog2MinSize()+1;
     for( UInt ui = 0; ui < uiNumLayersAllocated; ++ui )
     {
-      delete[] m_ppcQTTempCoeffY[ui];
-      delete[] m_ppcQTTempCoeffCb[ui];
-      delete[] m_ppcQTTempCoeffCr[ui];
+      MEMDELETEARRAY( m_ppcQTTempCoeffY[ui] );
+      MEMDELETEARRAY( m_ppcQTTempCoeffCb[ui] );
+      MEMDELETEARRAY( m_ppcQTTempCoeffCr[ui] );
       m_pcQTTempTComYuv[ui].destroy();
     }
-    delete[] m_ppcQTTempCoeffY;
-    delete[] m_ppcQTTempCoeffCb;
-    delete[] m_ppcQTTempCoeffCr;
-    delete[] m_pcQTTempCoeffY;
-    delete[] m_pcQTTempCoeffCb;
-    delete[] m_pcQTTempCoeffCr;
-    delete[] m_puhQTTempTrIdx;
-    delete[] m_puhQTTempCbf[0];
-    delete[] m_puhQTTempCbf[1];
-    delete[] m_puhQTTempCbf[2];
-    delete[] m_pcQTTempTComYuv;
+    MEMDELETEARRAY( m_ppcQTTempCoeffY );
+    MEMDELETEARRAY( m_ppcQTTempCoeffCb );
+    MEMDELETEARRAY( m_ppcQTTempCoeffCr );
+    MEMDELETEARRAY( m_pcQTTempCoeffY );
+    MEMDELETEARRAY( m_pcQTTempCoeffCb );
+    MEMDELETEARRAY( m_pcQTTempCoeffCr );
+    MEMDELETEARRAY( m_puhQTTempTrIdx );
+    MEMDELETEARRAY( m_puhQTTempCbf[0] );
+    MEMDELETEARRAY( m_puhQTTempCbf[1] );
+    MEMDELETEARRAY( m_puhQTTempCbf[2] );
+    MEMDELETEARRAY( m_pcQTTempTComYuv );
   }
 #endif
 }
@@ -194 +197 @@
   
   initTempBuff();
   
-  m_pTempPel = new Pel[g_uiMaxCUWidth*g_uiMaxCUHeight];
+  m_pTempPel = MEMNEWARRAY Pel[g_uiMaxCUWidth*g_uiMaxCUHeight];
   
   m_iDIFTap2 = (m_iDIFTap << 1);
   
@@ -202 +205 @@
   if( pcEncCfg->getQuadtreeTUFlag() )
   {
     const UInt uiNumLayersToAllocate = pcEncCfg->getQuadtreeTULog2MaxSize()-pcEncCfg->getQuadtreeTULog2MinSize()+1;
-    m_ppcQTTempCoeffY  = new TCoeff*[uiNumLayersToAllocate];
-    m_ppcQTTempCoeffCb = new TCoeff*[uiNumLayersToAllocate];
-    m_ppcQTTempCoeffCr = new TCoeff*[uiNumLayersToAllocate];
-    m_pcQTTempCoeffY   = new TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight   ];
-    m_pcQTTempCoeffCb  = new TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
-    m_pcQTTempCoeffCr  = new TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
+    m_ppcQTTempCoeffY  = MEMNEWARRAY TCoeff*[uiNumLayersToAllocate];
+    m_ppcQTTempCoeffCb = MEMNEWARRAY TCoeff*[uiNumLayersToAllocate];
+    m_ppcQTTempCoeffCr = MEMNEWARRAY TCoeff*[uiNumLayersToAllocate];
+    m_pcQTTempCoeffY   = MEMNEWARRAY TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight   ];
+    m_pcQTTempCoeffCb  = MEMNEWARRAY TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
+    m_pcQTTempCoeffCr  = MEMNEWARRAY TCoeff [g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
     
     const UInt uiNumPartitions = 1<<(g_uiMaxCUDepth<<1);
-    m_puhQTTempTrIdx   = new UChar  [uiNumPartitions];
-    m_puhQTTempCbf[0]  = new UChar  [uiNumPartitions];
-    m_puhQTTempCbf[1]  = new UChar  [uiNumPartitions];
-    m_puhQTTempCbf[2]  = new UChar  [uiNumPartitions];
-    m_pcQTTempTComYuv  = new TComYuv[uiNumLayersToAllocate];
+    m_puhQTTempTrIdx   = MEMNEWARRAY UChar  [uiNumPartitions];
+    m_puhQTTempCbf[0]  = MEMNEWARRAY UChar  [uiNumPartitions];
+    m_puhQTTempCbf[1]  = MEMNEWARRAY UChar  [uiNumPartitions];
+    m_puhQTTempCbf[2]  = MEMNEWARRAY UChar  [uiNumPartitions];
+    m_pcQTTempTComYuv  = MEMNEWARRAY TComYuv[uiNumLayersToAllocate];
     for( UInt ui = 0; ui < uiNumLayersToAllocate; ++ui )
     {
-      m_ppcQTTempCoeffY[ui]  = new TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight   ];
-      m_ppcQTTempCoeffCb[ui] = new TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
-      m_ppcQTTempCoeffCr[ui] = new TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
+      m_ppcQTTempCoeffY[ui]  = MEMNEWARRAY TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight   ];
+      m_ppcQTTempCoeffCb[ui] = MEMNEWARRAY TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
+      m_ppcQTTempCoeffCr[ui] = MEMNEWARRAY TCoeff[g_uiMaxCUWidth*g_uiMaxCUHeight>>2];
       m_pcQTTempTComYuv[ui].create( g_uiMaxCUWidth, g_uiMaxCUHeight );
     }
   }

source/Lib/TLibEncoder/TEncSlice.cpp

@@ -36 +36 @@
 #include "TEncTop.h"
 #include "TEncSlice.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
 // ====================================================================================================================
@@ -66 +68 @@
   // create prediction picture
   if ( m_apcPicYuvPred == NULL )
   {
-    m_apcPicYuvPred  = new TComPicYuv;
+    m_apcPicYuvPred  = MEMNEW TComPicYuv;
     m_apcPicYuvPred->create( iWidth, iHeight, iMaxCUWidth, iMaxCUHeight, uhTotalDepth );
   }
 
   // create residual picture
   if( m_apcPicYuvResi == NULL )
   {
-    m_apcPicYuvResi  = new TComPicYuv;
+    m_apcPicYuvResi  = MEMNEW TComPicYuv;
     m_apcPicYuvResi->create( iWidth, iHeight, iMaxCUWidth, iMaxCUHeight, uhTotalDepth );
   }
 }
@@ -84 +86 @@
   if ( m_apcPicYuvPred )
   {
     m_apcPicYuvPred->destroy();
-    delete m_apcPicYuvPred;
+    MEMDELETE( m_apcPicYuvPred );
     m_apcPicYuvPred  = NULL;
   }
 
@@ -92 +94 @@
   if ( m_apcPicYuvResi )
   {
     m_apcPicYuvResi->destroy();
-    delete m_apcPicYuvResi;
+    MEMDELETE( m_apcPicYuvResi );
     m_apcPicYuvResi  = NULL;
   }
 
@@ -103 +105 @@
     if(m_apcVirtPic[j][i])
     {
       m_apcVirtPic[j][i]->destroy();
-      delete m_apcVirtPic[j][i];
+      MEMDELETE( m_apcVirtPic[j][i] );
       m_apcVirtPic[j][i]=NULL;
     }
   }
@@ -158 +160 @@
     {
       if ( m_apcVirtPic[j][i] == NULL)
       {
-        m_apcVirtPic[j][i] = new TComPic;
+        m_apcVirtPic[j][i] = MEMNEW TComPic;
         m_apcVirtPic[j][i]->create( iWidth, iHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth, true );
       }
     }

source/Lib/TLibEncoder/TEncTop.cpp

@@ -36 +36 @@
 #include "../TLibCommon/CommonDef.h"
 #include "TEncTop.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
 // ====================================================================================================================
 // Constructor / destructor / create / destroy
 // ====================================================================================================================
@@ -83 +85 @@
   // if SBAC-based RD optimization is used
   if( m_bUseSBACRD )
   {
-    m_pppcRDSbacCoder = new TEncSbac** [g_uiMaxCUDepth+1];
-    m_pppcBinCoderCABAC = new TEncBinCABAC** [g_uiMaxCUDepth+1];
+    m_pppcRDSbacCoder = MEMNEWARRAY TEncSbac** [g_uiMaxCUDepth+1];
+    m_pppcBinCoderCABAC = MEMNEWARRAY TEncBinCABAC** [g_uiMaxCUDepth+1];
 
     for ( Int iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
     {
-      m_pppcRDSbacCoder[iDepth] = new TEncSbac* [CI_NUM];
-      m_pppcBinCoderCABAC[iDepth] = new TEncBinCABAC* [CI_NUM];
+      m_pppcRDSbacCoder[iDepth] = MEMNEWARRAY TEncSbac* [CI_NUM];
+      m_pppcBinCoderCABAC[iDepth] = MEMNEWARRAY TEncBinCABAC* [CI_NUM];
 
       for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
       {
-        m_pppcRDSbacCoder[iDepth][iCIIdx] = new TEncSbac;
-        m_pppcBinCoderCABAC [iDepth][iCIIdx] = new TEncBinCABAC;
+        m_pppcRDSbacCoder[iDepth][iCIIdx] = MEMNEW TEncSbac;
+        m_pppcBinCoderCABAC [iDepth][iCIIdx] = MEMNEW TEncBinCABAC;
         m_pppcRDSbacCoder   [iDepth][iCIIdx]->init( m_pppcBinCoderCABAC [iDepth][iCIIdx] );
       }
     }
@@ -120 +122 @@
     {
       for (Int iCIIdx = 0; iCIIdx < CI_NUM; iCIIdx ++ )
       {
-        delete m_pppcRDSbacCoder[iDepth][iCIIdx];
-        delete m_pppcBinCoderCABAC[iDepth][iCIIdx];
+        MEMDELETE( m_pppcRDSbacCoder[iDepth][iCIIdx] );
+        MEMDELETE( m_pppcBinCoderCABAC[iDepth][iCIIdx] );
       }
     }
 
     for ( iDepth = 0; iDepth < g_uiMaxCUDepth+1; iDepth++ )
     {
-      delete [] m_pppcRDSbacCoder[iDepth];
-      delete [] m_pppcBinCoderCABAC[iDepth];
+      MEMDELETEARRAY( m_pppcRDSbacCoder[iDepth] );
+      MEMDELETEARRAY( m_pppcBinCoderCABAC[iDepth] );
     }
 
-    delete [] m_pppcRDSbacCoder;
-    delete [] m_pppcBinCoderCABAC;
+    MEMDELETEARRAY( m_pppcRDSbacCoder );
+    MEMDELETEARRAY( m_pppcBinCoderCABAC );
   }
 
   // destroy ROM
@@ -188 +190 @@
     TComPic* pcPic = *(iterPic++);
 
     pcPic->destroy();
-    delete pcPic;
+    MEMDELETE( pcPic );
     pcPic = NULL;
   }
 }
@@ -260 +262 @@
       rpcPic = *(++iterPic);
       if ( abs(rpcPic->getPOC() - m_iPOCLast) <= m_iGOPSize )
       {
-        rpcPic = new TComPic;
+        rpcPic = MEMNEW TComPic;
         rpcPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
       }
       else
@@ -272 +274 @@
   }
   else
   {
-    rpcPic = new TComPic;
+    rpcPic = MEMNEW TComPic;
     rpcPic->create( m_iSourceWidth, m_iSourceHeight, g_uiMaxCUWidth, g_uiMaxCUHeight, g_uiMaxCUDepth );
   }
 

source/Lib/TLibVideoIO/TVideoIOYuv.cpp

@@ -42 +42 @@
 
 #include "TVideoIOYuv.h"
 
+#include "../TLibCommon/tool_tracemem.h"
+
 using namespace std;
 
 // ====================================================================================================================
@@ -104 +106 @@
   iHeight = rpcPicYuv->getHeight() - aiPad[1];
 
   // allocate 8-bit buffer
-  Pxl*  apuchBuf = new Pxl[iWidth];
+  Pxl*  apuchBuf = MEMNEWARRAY Pxl[iWidth];
 
   // Y
   Pel*  pDst = rpcPicYuv->getLumaAddr();
@@ -167 +169 @@
     pDst += iStride;
   }
 
-  delete [] apuchBuf;
+  MEMDELETEARRAY( apuchBuf );
 
   return;
 }
@@ -185 +187 @@
   Int   iStride = pcPicYuv->getStride();
 
   // allocate 8-bit buffer
-  Pxl*  apuchBuf = new Pxl[iWidth];
+  Pxl*  apuchBuf = MEMNEWARRAY Pxl[iWidth];
 
   //  Y
   Pel*  pSrc = pcPicYuv->getLumaAddr();
@@ -218 +220 @@
     pSrc += iStride;
   }
 
-  delete [] apuchBuf;
+  MEMDELETEARRAY( apuchBuf );
 }