diff --git a/source/LibMemory.h b/source/LibMemory.h
new file mode 100644
index 0000000..8b5a40d
--- /dev/null
+++ b/source/LibMemory.h
@@ -0,0 +1,228 @@
+/*    This file is a part of plaYUVer project
+ *    Copyright (C) 2014  by plaYUVer developers
+ *
+ *    This program is free software; you can redistribute it and/or modify
+ *    it under the terms of the GNU General Public License as published by
+ *    the Free Software Foundation; either version 2 of the License, or
+ *    (at your option) any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this program; if not, write to the Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/**
+ * \file     LibMemory.cpp
+ * \brief    Memory allocation functions
+ */
+
+#ifndef __LIBMEMORY_H__
+#define __LIBMEMORY_H__
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+namespace plaYUVer
+{
+
+typedef void Void;
+typedef char Char;
+typedef int Int;
+typedef size_t SizeT;
+
+#ifdef _MSC_VER
+typedef __int64 Int64;
+#if _MSC_VER <= 1200 // MS VC6
+typedef __int64 UInt64;   // MS VC6 does not support unsigned __int64 to double conversion
+#else
+typedef unsigned __int64 UInt64;
+#endif
+#else
+typedef long long Int64;
+typedef unsigned long long UInt64;
+#endif
+
+static inline Void* xMallocMem( SizeT nitems )
+{
+  Void *d;
+  if ( (d = malloc( nitems )) == NULL )
+  {
+    printf( "malloc failed.\n" );
+    return NULL;
+  }
+  return d;
+}
+
+static inline Void* xCallocMem( SizeT nitems, SizeT size )
+{
+  size_t padded_size = nitems * size;
+  Void *d = xMallocMem( padded_size );
+  memset( d, 0, (int) padded_size );
+  return d;
+}
+
+static inline Void xFreePointer( Void *pointer )
+{
+  if ( pointer != NULL )
+  {
+    free( pointer );
+    pointer = NULL;
+  }
+}
+
+static inline Void xFreeMem( Void *mem )
+{
+  xFreePointer( mem );
+}
+
+template<typename T>
+Int getMem1D( T **array1D, int dim0 )
+{
+  if( ( *array1D = ( T* )mem_calloc( dim0, sizeof(T) ) ) == NULL )
+    return 0;
+
+  return ( sizeof(T*) + dim0 * sizeof(T) );
+}
+
+template<typename T>
+Int getMem2D( T*** array2D, Int dim0, Int dim1 )
+{
+  Int i;
+
+  if ( (*array2D = (T**) xMallocMem( dim0 * sizeof(T*) )) == NULL ) printf(
+      "get_mem2Dint: array2D" );
+  if ( (*(*array2D) = (T*) xCallocMem( dim0 * dim1, sizeof(T) )) == NULL ) printf(
+      "get_mem2Dint: array2D" );
+
+  for ( i = 1; i < dim0; i++ )
+    (*array2D)[i] = (*array2D)[i - 1] + dim1;
+
+  return dim0 * (sizeof(T*) + dim1 * sizeof(T));
+}
+
+template<typename T>
+Int getMem3D( T**** array3D, Int dim0, Int dim1, Int dim2 )
+{
+  Int i, mem_size = dim0 * sizeof(T**);
+
+  if ( ((*array3D) = (T***) xMallocMem( dim0 * sizeof(T**) )) == NULL ) printf(
+      "get_mem3Dint: array3D" );
+
+  mem_size += getMem2D( *array3D, dim0 * dim1, dim2 );
+
+  for ( i = 1; i < dim0; i++ )
+    (*array3D)[i] = (*array3D)[i - 1] + dim1;
+
+  return mem_size;
+}
+
+template<typename T>
+Int getMem4D( T***** array4D, Int dim0, Int dim1, Int dim2, Int dim3 )
+{
+  int i, mem_size = dim0 * sizeof(int***);
+
+  if ( ((*array4D) = (T****) xMallocMem( dim0 * sizeof(T***) )) == NULL ) printf(
+      "get_mem4Dint: array4D" );
+
+  mem_size += getMem3D( *array4D, dim0 * dim1, dim2, dim3 );
+
+  for ( i = 1; i < dim0; i++ )
+    (*array4D)[i] = (*array4D)[i - 1] + dim1;
+
+  return mem_size;
+}
+
+template<typename T>
+Int getMem5D( T****** array5D, Int dim0, Int dim1, Int dim2, Int dim3, Int dim4 )
+{
+  int i, mem_size = dim0 * sizeof(T****);
+
+  if ( ((*array5D) = (T*****) xMallocMem( dim0 * sizeof(T****) )) == NULL ) printf(
+      "get_mem5Dint: array5D" );
+
+  mem_size += getMem4D( *array5D, dim0 * dim1, dim2, dim3, dim4 );
+
+  for ( i = 1; i < dim0; i++ )
+    (*array5D)[i] = (*array5D)[i - 1] + dim1;
+
+  return mem_size;
+}
+
+template<typename T>
+Void freeMem1D( T *array1D )
+{
+  if( array1D )
+  {
+    mem_free( array1D );
+  }
+}
+
+template<typename T>
+Void freeMem2D( T** array2D )
+{
+  if ( array2D )
+  {
+    if ( *array2D )
+      xFreeMem( *array2D );
+    else
+      printf( "free_mem2Dint: trying to free unused memory" );
+
+    xFreeMem( array2D );
+  }
+  else
+  {
+    printf( "free_mem2Dint: trying to free unused memory" );
+  }
+}
+
+template<typename T>
+Void freeMem3D( T*** array3D )
+{
+  if ( array3D )
+  {
+    freeMem2D( *array3D );
+    xFreeMem( array3D );
+  }
+  else
+  {
+    printf( "free_mem3Dint: trying to free unused memory" );
+  }
+}
+
+template<typename T>
+Void freeMem4D( T**** array4D )
+{
+  if ( array4D )
+  {
+    freeMem3D( *array4D );
+    xFreeMem( array4D );
+  }
+  else
+  {
+    printf( "free_mem4Dint: trying to free unused memory" );
+  }
+}
+
+template<typename T>
+Void freeMem5D( T***** array5D )
+{
+  if ( array5D )
+  {
+    freeMem4D( *array5D );
+    xFreeMem( array5D );
+  }
+  else
+  {
+    printf( "free_mem5Dint: trying to free unused memory" );
+  }
+}
+
+}  // NAMESPACE
+
+#endif //  __LIBMEMORY_H__