calyp/source/lib/LibMemory.h

/*    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__