extlzham 0.0.1.PROTOTYPE

data/contrib/lzham/lzhamdecomp/lzham_lzdecompbase.cpp

@@ -0,0 +1,131 @@
+// File: lzham_lzdecompbase.cpp
+// See Copyright Notice and license at the end of include/lzham.h
+#include "lzham_core.h"
+#include "lzham_lzdecompbase.h"
+
+namespace lzham
+{
+	// Keep in sync with LZHAM_DEFAULT_ADAPT_RATE, and LZHAM_DEFAULT_TABLE_UPDATE_RATE, etc.
+	table_update_settings g_table_update_settings[] =
+	{
+		{ 4, 32 },   // crazy slow!
+		{ 5, 33 },
+		{ 6, 34 },
+		{ 7, 35 },
+		{ 8, 36 },
+      
+		{ 16, 48 },
+		{ 32, 72 },
+		{ 64, 64 }, // codec's internal default
+		{ 98, 80 },
+		{ 128, 96 },
+      
+		{ 192, 112 },
+		{ 256, 128 },
+      { 512, 128+16*2 },
+      { 1024, 128+16*4 },
+      { 2048, 128+16*6 },
+      
+      { 2048, 128+16*8 },
+      { 2048, 128+16*10 },
+      { 2048, 128+16*12 },
+      { 2048, 128+16*14 },
+      { 2048, 128+16*16 }
+	};
+
+	uint CLZDecompBase::m_lzx_position_base[CLZDecompBase::cLZXMaxPositionSlots] = 
+	{
+		0x0, 0x1, 0x2, 0x3, 0x4, 0x6, 0x8, 0xC, 0x10, 0x18, 0x20, 0x30, 0x40, 0x60, 0x80, 0xC0,
+		0x100, 0x180, 0x200, 0x300, 0x400, 0x600, 0x800, 0xC00, 0x1000, 0x1800, 0x2000, 0x3000, 0x4000, 0x6000, 0x8000, 0xC000,
+		0x10000, 0x18000, 0x20000, 0x30000, 0x40000, 0x60000, 0x80000, 0xC0000, 0x100000, 0x180000, 0x200000, 0x300000, 0x400000, 0x600000, 0x800000, 0xC00000,
+		0x1000000, 0x1800000, 0x2000000, 0x3000000, 0x4000000, 0x6000000, 0x8000000, 0xA000000, 0xC000000, 0xE000000, 0x10000000, 0x12000000, 0x14000000, 0x16000000, 0x18000000, 0x1A000000,
+		0x1C000000, 0x1E000000, 0x20000000, 0x22000000, 0x24000000, 0x26000000, 0x28000000, 0x2A000000, 0x2C000000, 0x2E000000, 0x30000000, 0x32000000, 0x34000000, 0x36000000, 0x38000000, 0x3A000000,
+		0x3C000000, 0x3E000000, 0x40000000, 0x42000000, 0x44000000, 0x46000000, 0x48000000, 0x4A000000, 0x4C000000, 0x4E000000, 0x50000000, 0x52000000, 0x54000000, 0x56000000, 0x58000000, 0x5A000000,
+		0x5C000000, 0x5E000000, 0x60000000, 0x62000000, 0x64000000, 0x66000000, 0x68000000, 0x6A000000, 0x6C000000, 0x6E000000, 0x70000000, 0x72000000, 0x74000000, 0x76000000, 0x78000000, 0x7A000000,
+		0x7C000000, 0x7E000000, 0x80000000, 0x82000000, 0x84000000, 0x86000000, 0x88000000, 0x8A000000, 0x8C000000, 0x8E000000, 0x90000000, 0x92000000, 0x94000000, 0x96000000, 0x98000000, 0x9A000000,
+	};
+
+	uint CLZDecompBase::m_lzx_position_extra_mask[CLZDecompBase::cLZXMaxPositionSlots] =
+	{
+		0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x3, 0x3, 0x7, 0x7, 0xF, 0xF, 0x1F, 0x1F, 0x3F, 0x3F,
+		0x7F, 0x7F, 0xFF, 0xFF, 0x1FF, 0x1FF, 0x3FF, 0x3FF, 0x7FF, 0x7FF, 0xFFF, 0xFFF, 0x1FFF, 0x1FFF, 0x3FFF, 0x3FFF,
+		0x7FFF, 0x7FFF, 0xFFFF, 0xFFFF, 0x1FFFF, 0x1FFFF, 0x3FFFF, 0x3FFFF, 0x7FFFF, 0x7FFFF, 0xFFFFF, 0xFFFFF, 0x1FFFFF, 0x1FFFFF, 0x3FFFFF, 0x3FFFFF,
+		0x7FFFFF, 0x7FFFFF, 0xFFFFFF, 0xFFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF,
+		0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF,
+		0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF,
+		0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF,
+		0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF, 0x1FFFFFF
+	};
+
+	uint8 CLZDecompBase::m_lzx_position_extra_bits[CLZDecompBase::cLZXMaxPositionSlots] =
+	{
+		0x0, 0x0, 0x0, 0x0, 0x1, 0x1, 0x2, 0x2, 0x3, 0x3, 0x4, 0x4, 0x5, 0x5, 0x6, 0x6,
+		0x7, 0x7, 0x8, 0x8, 0x9, 0x9, 0xA, 0xA, 0xB, 0xB, 0xC, 0xC, 0xD, 0xD, 0xE, 0xE,
+		0xF, 0xF, 0x10, 0x10, 0x11, 0x11, 0x12, 0x12, 0x13, 0x13, 0x14, 0x14, 0x15, 0x15, 0x16, 0x16,
+		0x17, 0x17, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+		0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+		0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+		0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
+		0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19
+	};
+
+	static const uint8 g_num_lzx_position_slots[] = { 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 58, 66 };
+
+   void CLZDecompBase::init_position_slots(uint dict_size_log2)
+   {
+		LZHAM_ASSERT(dict_size_log2 >= LZHAM_MIN_DICT_SIZE_LOG2);
+		LZHAM_ASSERT(dict_size_log2 <= LZHAM_MAX_DICT_SIZE_LOG2_X64);
+		LZHAM_ASSERT((sizeof(g_table_update_settings) / sizeof(g_table_update_settings[0])) == LZHAM_FASTEST_TABLE_UPDATE_RATE);
+
+		//for (dict_size_log2 = LZHAM_MIN_DICT_SIZE_LOG2; dict_size_log2 <= LZHAM_MAX_DICT_SIZE_LOG2_X64; dict_size_log2++) {
+
+      m_dict_size_log2 = dict_size_log2;
+      m_dict_size = 1U << dict_size_log2;
+		m_num_lzx_slots = g_num_lzx_position_slots[dict_size_log2  - LZHAM_MIN_DICT_SIZE_LOG2];
+
+#if 0
+		int i, j;
+      for (i = 0, j = 0; i < cLZXMaxPositionSlots; i += 2) 
+      {
+         m_lzx_position_extra_bits[i] = (uint8)j;
+         m_lzx_position_extra_bits[i + 1] = (uint8)j; 
+
+         if ((i != 0) && (j < 25))  
+            j++; 
+      }
+
+      for (i = 0, j = 0; i < cLZXMaxPositionSlots; i++) 
+      {
+         m_lzx_position_base[i] = j;
+         m_lzx_position_extra_mask[i] = (1 << m_lzx_position_extra_bits[i]) - 1;
+         j += (1 << m_lzx_position_extra_bits[i]);
+      }
+
+		for (uint i = 0; i < cLZXMaxPositionSlots; i++)
+		{
+			printf("0x%X, ", m_lzx_position_base[i]);
+			if ((i & 15) == 15) printf("\n");
+		}
+#endif
+
+#if 0
+      m_num_lzx_slots = 0;         
+      
+      const uint largest_dist = m_dict_size - 1;
+      for (i = 0; i < cLZXMaxPositionSlots; i++)
+      {
+         if ( (largest_dist >= m_lzx_position_base[i]) &&
+              (largest_dist < (m_lzx_position_base[i] + (1 << m_lzx_position_extra_bits[i])) ) )
+         {
+            m_num_lzx_slots = i + 1;
+            break;
+         }              
+      }
+      
+      LZHAM_VERIFY(m_num_lzx_slots);
+#endif
+
+		//printf("%u, ", m_num_lzx_slots); }
+   }
+	  
+} //namespace lzham

data/contrib/lzham/lzhamdecomp/lzham_lzdecompbase.h

@@ -0,0 +1,89 @@
+// File: lzham_lzdecompbase.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+//#define LZHAM_LZDEBUG
+
+#define LZHAM_IS_MATCH_MODEL_INDEX(cur_state) (cur_state)
+
+namespace lzham
+{
+	struct table_update_settings
+	{
+		uint16 m_max_update_interval;
+		uint16 m_slow_rate;
+	};
+	extern table_update_settings g_table_update_settings[];
+
+   struct CLZDecompBase
+   {
+      enum 
+      {
+         cMinMatchLen = 2U,
+         cMaxMatchLen = 257U,
+         
+         cMaxHugeMatchLen = 65536,
+                           
+         cMinDictSizeLog2 = 15,
+         cMaxDictSizeLog2 = 29,
+                  
+         cMatchHistSize = 4,
+         cMaxLen2MatchDist = 2047
+      };
+         
+      enum 
+      {
+         cLZXNumSecondaryLengths = 249,
+         
+         cNumHugeMatchCodes = 1,
+         cMaxHugeMatchCodeBits = 16,
+                                    
+         cLZXNumSpecialLengths = 2,
+         
+         cLZXLowestUsableMatchSlot = 1,
+         cLZXMaxPositionSlots = 128
+      };
+      
+      enum
+      {
+         cLZXSpecialCodeEndOfBlockCode = 0,
+         cLZXSpecialCodePartialStateReset = 1
+      };
+      
+      enum
+      {  
+         cLZHAMDebugSyncMarkerValue = 666,
+         cLZHAMDebugSyncMarkerBits = 12
+      };
+
+      enum
+      {
+         cBlockHeaderBits = 2,
+         cBlockCheckBits = 4,
+         cBlockFlushTypeBits = 2,
+         
+         cSyncBlock = 0,
+         cCompBlock = 1,
+         cRawBlock = 2,
+         cEOFBlock = 3
+      };
+      
+      enum
+      {
+         cNumStates = 12,
+         cNumLitStates = 7,
+      };
+				      
+      uint m_dict_size_log2;
+      uint m_dict_size;
+      
+      uint m_num_lzx_slots;
+
+      static uint m_lzx_position_base[cLZXMaxPositionSlots];
+      static uint m_lzx_position_extra_mask[cLZXMaxPositionSlots];
+      static uint8 m_lzx_position_extra_bits[cLZXMaxPositionSlots];
+		            
+      void init_position_slots(uint dict_size_log2);
+   };
+   
+} // namespace lzham

data/contrib/lzham/lzhamdecomp/lzham_math.h

@@ -0,0 +1,142 @@
+// File: lzham_math.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+#if defined(LZHAM_USE_MSVC_INTRINSICS) && !defined(__MINGW32__)
+   #include <intrin.h>
+   #if defined(_MSC_VER)
+      #pragma intrinsic(_BitScanReverse)
+   #endif
+#endif
+
+namespace lzham
+{
+   namespace math
+   {
+      // Yes I know these should probably be pass by ref, not val:
+      // http://www.stepanovpapers.com/notes.pdf
+      // Just don't use them on non-simple (non built-in) types!
+      template<typename T> inline T minimum(T a, T b) { return (a < b) ? a : b; }
+
+      template<typename T> inline T minimum(T a, T b, T c) { return minimum(minimum(a, b), c); }
+
+      template<typename T> inline T maximum(T a, T b) { return (a > b) ? a : b; }
+
+      template<typename T> inline T maximum(T a, T b, T c) { return maximum(maximum(a, b), c); }
+
+      template<typename T> inline T clamp(T value, T low, T high) { return (value < low) ? low : ((value > high) ? high : value); }
+
+      inline bool is_power_of_2(uint32 x) { return x && ((x & (x - 1U)) == 0U); }
+      inline bool is_power_of_2(uint64 x) { return x && ((x & (x - 1U)) == 0U); }
+
+      template<typename T> inline T align_up_pointer(T p, uint alignment)
+      {
+         LZHAM_ASSERT(is_power_of_2(alignment));
+         ptr_bits_t q = reinterpret_cast<ptr_bits_t>(p);
+         q = (q + alignment - 1) & (~((uint_ptr)alignment - 1));
+         return reinterpret_cast<T>(q);
+      }
+
+      // From "Hackers Delight"
+      // val remains unchanged if it is already a power of 2.
+      inline uint32 next_pow2(uint32 val)
+      {
+         val--;
+         val |= val >> 16;
+         val |= val >> 8;
+         val |= val >> 4;
+         val |= val >> 2;
+         val |= val >> 1;
+         return val + 1;
+      }
+
+      // val remains unchanged if it is already a power of 2.
+      inline uint64 next_pow2(uint64 val)
+      {
+         val--;
+         val |= val >> 32;
+         val |= val >> 16;
+         val |= val >> 8;
+         val |= val >> 4;
+         val |= val >> 2;
+         val |= val >> 1;
+         return val + 1;
+      }
+
+      inline uint floor_log2i(uint v)
+      {
+         uint l = 0;
+         while (v > 1U)
+         {
+            v >>= 1;
+            l++;
+         }
+         return l;
+      }
+
+      inline uint ceil_log2i(uint v)
+      {
+         uint l = floor_log2i(v);
+         if ((l != cIntBits) && (v > (1U << l)))
+            l++;
+         return l;
+      }
+
+      // Returns the total number of bits needed to encode v.
+      inline uint total_bits(uint v)
+      {
+         unsigned long l = 0;
+#if defined(__MINGW32__)
+         if (v)
+         {
+            l = 32 -__builtin_clz(v);
+         }
+#elif defined(LZHAM_USE_MSVC_INTRINSICS)
+         if (_BitScanReverse(&l, v))
+         {
+            l++;
+         }
+         else
+         {
+            l = 0;
+         }
+#else
+         while (v > 0U)
+         {
+            v >>= 1;
+            l++;
+         }
+#endif
+         return static_cast<uint>(l);
+      }
+
+		inline uint compute_mask_size(uint x)
+		{
+			uint l = 0;
+			while (x)
+			{
+				x &= (x - 1);
+				l++;
+			}
+			return l;
+		}
+
+		inline uint compute_mask_shift(uint x)
+		{
+			if (!x)
+				return 0;
+
+			uint l = 0;
+			while ((x & 1) == 0)
+			{
+				x >>= 1;
+				l++;
+			}
+
+			return l;
+		}
+
+   }
+
+} // namespace lzham
+

data/contrib/lzham/lzhamdecomp/lzham_mem.cpp

@@ -0,0 +1,284 @@
+// File: lzham_mem.cpp
+// See Copyright Notice and license at the end of include/lzham.h
+#include "lzham_core.h"
+
+#ifdef __APPLE__
+   #include <malloc/malloc.h>
+#elif defined(__FreeBSD__) || defined(__NetBSD__)
+   #include <malloc_np.h>
+   #if defined(__FreeBSD__)
+      #define malloc(size) aligned_alloc((LZHAM_MIN_ALLOC_ALIGNMENT), (size))
+   #endif
+#else
+   #include <malloc.h>
+#endif
+
+using namespace lzham;
+
+#define LZHAM_MEM_STATS 0
+
+#ifndef LZHAM_USE_WIN32_API
+   #ifndef __APPLE__
+      #define _msize malloc_usable_size
+   #else
+      #define _msize malloc_size
+   #endif
+#endif
+
+namespace lzham
+{
+   #if LZHAM_64BIT_POINTERS
+      const uint64 MAX_POSSIBLE_BLOCK_SIZE = 0x400000000ULL;
+   #else
+      const uint32 MAX_POSSIBLE_BLOCK_SIZE = 0x7FFF0000U;
+   #endif
+
+   #if LZHAM_MEM_STATS
+      #if LZHAM_64BIT_POINTERS
+         typedef atomic64_t mem_stat_t;
+         #define LZHAM_MEM_COMPARE_EXCHANGE atomic_compare_exchange64
+      #else
+         typedef atomic32_t mem_stat_t;
+         #define LZHAM_MEM_COMPARE_EXCHANGE atomic_compare_exchange32
+      #endif
+
+      static volatile atomic32_t g_total_blocks;
+      static volatile mem_stat_t g_total_allocated;
+      static volatile mem_stat_t g_max_allocated;
+
+      static mem_stat_t update_total_allocated(int block_delta, mem_stat_t byte_delta)
+      {
+         atomic32_t cur_total_blocks;
+         for ( ; ; )
+         {
+            cur_total_blocks = g_total_blocks;
+            atomic32_t new_total_blocks = static_cast<atomic32_t>(cur_total_blocks + block_delta);
+            LZHAM_ASSERT(new_total_blocks >= 0);
+            if (atomic_compare_exchange32(&g_total_blocks, new_total_blocks, cur_total_blocks) == cur_total_blocks)
+               break;
+         }
+
+         mem_stat_t cur_total_allocated, new_total_allocated;
+         for ( ; ; )
+         {
+            cur_total_allocated = g_total_allocated;
+            new_total_allocated = static_cast<mem_stat_t>(cur_total_allocated + byte_delta);
+            LZHAM_ASSERT(new_total_allocated >= 0);
+            if (LZHAM_MEM_COMPARE_EXCHANGE(&g_total_allocated, new_total_allocated, cur_total_allocated) == cur_total_allocated)
+               break;
+         }
+         for ( ; ; )
+         {
+            mem_stat_t cur_max_allocated = g_max_allocated;
+            mem_stat_t new_max_allocated = LZHAM_MAX(new_total_allocated, cur_max_allocated);
+            if (LZHAM_MEM_COMPARE_EXCHANGE(&g_max_allocated, new_max_allocated, cur_max_allocated) == cur_max_allocated)
+               break;
+         }
+         return new_total_allocated;
+      }
+   #endif // LZHAM_MEM_STATS
+
+   static void* lzham_default_realloc(void* p, size_t size, size_t* pActual_size, lzham_bool movable, void* pUser_data)
+   {
+      LZHAM_NOTE_UNUSED(pUser_data);
+
+      void* p_new;
+
+      if (!p)
+      {
+         p_new = malloc(size);
+         LZHAM_ASSERT( (reinterpret_cast<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 );
+
+         if (pActual_size)
+            *pActual_size = p_new ? _msize(p_new) : 0;
+      }
+      else if (!size)
+      {
+         free(p);
+         p_new = NULL;
+
+         if (pActual_size)
+            *pActual_size = 0;
+      }
+      else
+      {
+         void* p_final_block = p;
+#ifdef WIN32
+         p_new = _expand(p, size);
+#else
+
+         p_new = NULL;
+#endif
+
+         if (p_new)
+         {
+            LZHAM_ASSERT( (reinterpret_cast<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 );
+            p_final_block = p_new;
+         }
+         else if (movable)
+         {
+            p_new = realloc(p, size);
+
+            if (p_new)
+            {
+               LZHAM_ASSERT( (reinterpret_cast<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0 );
+               p_final_block = p_new;
+            }
+         }
+
+         if (pActual_size)
+            *pActual_size = _msize(p_final_block);
+      }
+
+      return p_new;
+   }
+
+   static size_t lzham_default_msize(void* p, void* pUser_data)
+   {
+      LZHAM_NOTE_UNUSED(pUser_data);
+      return p ? _msize(p) : 0;
+   }
+
+   static lzham_realloc_func        g_pRealloc = lzham_default_realloc;
+   static lzham_msize_func          g_pMSize   = lzham_default_msize;
+   static void*                     g_pUser_data;
+
+   static inline void lzham_mem_error(const char* p_msg)
+   {
+      lzham_assert(p_msg, __FILE__, __LINE__);
+   }
+
+   void* lzham_malloc(size_t size, size_t* pActual_size)
+   {
+      size = (size + sizeof(uint32) - 1U) & ~(sizeof(uint32) - 1U);
+      if (!size)
+         size = sizeof(uint32);
+
+      if (size > MAX_POSSIBLE_BLOCK_SIZE)
+      {
+         lzham_mem_error("lzham_malloc: size too big");
+         return NULL;
+      }
+
+      size_t actual_size = size;
+      uint8* p_new = static_cast<uint8*>((*g_pRealloc)(NULL, size, &actual_size, true, g_pUser_data));
+
+      if (pActual_size)
+         *pActual_size = actual_size;
+
+      if ((!p_new) || (actual_size < size))
+      {
+         lzham_mem_error("lzham_malloc: out of memory");
+         return NULL;
+      }
+
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0);
+
+#if LZHAM_MEM_STATS
+      update_total_allocated(1, static_cast<mem_stat_t>(actual_size));
+#endif
+
+      return p_new;
+   }
+
+   void* lzham_realloc(void* p, size_t size, size_t* pActual_size, bool movable)
+   {
+      if ((ptr_bits_t)p & (LZHAM_MIN_ALLOC_ALIGNMENT - 1))
+      {
+         lzham_mem_error("lzham_realloc: bad ptr");
+         return NULL;
+      }
+
+      if (size > MAX_POSSIBLE_BLOCK_SIZE)
+      {
+         lzham_mem_error("lzham_malloc: size too big");
+         return NULL;
+      }
+
+#if LZHAM_MEM_STATS
+      size_t cur_size = p ? (*g_pMSize)(p, g_pUser_data) : 0;
+#endif
+
+      size_t actual_size = size;
+      void* p_new = (*g_pRealloc)(p, size, &actual_size, movable, g_pUser_data);
+
+      if (pActual_size)
+         *pActual_size = actual_size;
+
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(p_new) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1)) == 0);
+
+#if LZHAM_MEM_STATS
+      int num_new_blocks = 0;
+      if (p)
+      {
+         if (!p_new)
+            num_new_blocks = -1;
+      }
+      else if (p_new)
+      {
+         num_new_blocks = 1;
+      }
+      update_total_allocated(num_new_blocks, static_cast<mem_stat_t>(actual_size) - static_cast<mem_stat_t>(cur_size));
+#endif
+
+      return p_new;
+   }
+
+   void lzham_free(void* p)
+   {
+      if (!p)
+         return;
+
+      if (reinterpret_cast<ptr_bits_t>(p) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1))
+      {
+         lzham_mem_error("lzham_free: bad ptr");
+         return;
+      }
+
+#if LZHAM_MEM_STATS
+      size_t cur_size = (*g_pMSize)(p, g_pUser_data);
+      update_total_allocated(-1, -static_cast<mem_stat_t>(cur_size));
+#endif
+
+      (*g_pRealloc)(p, 0, NULL, true, g_pUser_data);
+   }
+
+   size_t lzham_msize(void* p)
+   {
+      if (!p)
+         return 0;
+
+      if (reinterpret_cast<ptr_bits_t>(p) & (LZHAM_MIN_ALLOC_ALIGNMENT - 1))
+      {
+         lzham_mem_error("lzham_msize: bad ptr");
+         return 0;
+      }
+
+      return (*g_pMSize)(p, g_pUser_data);
+   }
+
+   void LZHAM_CDECL lzham_lib_set_memory_callbacks(lzham_realloc_func pRealloc, lzham_msize_func pMSize, void* pUser_data)
+   {
+      if ((!pRealloc) || (!pMSize))
+      {
+         g_pRealloc = lzham_default_realloc;
+         g_pMSize = lzham_default_msize;
+         g_pUser_data = NULL;
+      }
+      else
+      {
+         g_pRealloc = pRealloc;
+         g_pMSize = pMSize;
+         g_pUser_data = pUser_data;
+      }
+   }
+
+   void lzham_print_mem_stats()
+   {
+#if LZHAM_MEM_STATS
+      printf("Current blocks: %u, allocated: %I64u, max ever allocated: %I64i\n", g_total_blocks, (int64)g_total_allocated, (int64)g_max_allocated);
+#endif
+   }
+
+} // namespace lzham
+