glue_memory.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2004 Ocean Blue Software Ltd
 * Copyright © 2000 Koninklijke Philips Electronics N.V
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 *
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 *
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include <stdlib.h>
#ifdef TRACING
#include <stdio.h>
#endif
#include <string.h>
#include "stb_os.h"
#include "glue_debug.h"
#include "glue_memory.h"

/*---constant definitions for this file--------------------------------------*/

#define MallocFunc      STB_MemAlloc
#define FreeFunc        STB_MemFree


#define MAX_BLK_STRS    0x80 /* 128 memory blocks */
#define VTINY_BITS      2
#define MIGIT_BITS      3
#define SMALL_BITS      4
#define MEDUM_BITS      5
#define LARGE_BITS      6
#define STR_DATA_SIZE(bz)    (MAX_BLK_STRS << bz)
#define STR_BLCK_SIZE(bz)    STR_DATA_SIZE(bz) + sizeof(S_STRINGS_BLOCK)
#define CONTROL_SIZE    (MAX_BLK_STRS >> 3)

#define BlkStrFree( head, bz, data ) \
   {  S_STRINGS_BLOCK *pBlk = head; \
      do { \
         unsigned char *blk_data = (unsigned char *)pBlk + sizeof(S_STRINGS_BLOCK); \
         if (data >= blk_data \
             && data < blk_data + STR_DATA_SIZE(bz)) \
         {  int tmp; \
            tmp = (data - blk_data) >> bz; \
            pBlk->control[tmp >> 3] &= (U8BIT) ~(1 << (tmp & 7)); \
            break; \
         } \
         pBlk = pBlk->next; \
      } while (pBlk != NULL); \
      if (pBlk == NULL) { TRACE(TERROR, ("Not freed %x", data)) } \
   }

typedef struct s_strings_block
{
   struct s_strings_block *next;
   U8BIT control[CONTROL_SIZE];
#ifdef MHG_TRACK_MEM
   U16BIT line[MAX_BLK_STRS];
#endif
} S_STRINGS_BLOCK;


#ifdef MHG_TRACK_MEM
   #define MH5EMT_MAGIC 0xE579A36D

typedef struct _mh5emtEntry_struct mh5emtEntry_t, *pMh5emtEntry_t;

struct _mh5emtEntry_struct
{
   pMh5emtEntry_t addr;
   pMh5emtEntry_t prev;
   pMh5emtEntry_t next;
   const char *callingFunc;
   unsigned int size;
   int line;
   int src;
   int magic;
};
#endif

/*---local (static) variable declarations for this file----------------------*/
S_STRINGS_BLOCK *vtiny_strmem_head = NULL;
S_STRINGS_BLOCK *migit_strmem_head = NULL;
S_STRINGS_BLOCK *small_strmem_head = NULL;
S_STRINGS_BLOCK *medum_strmem_head = NULL;
S_STRINGS_BLOCK *large_strmem_head = NULL;

#ifdef TRACING
   #define TOTAL_GRPS 24
static int mem_prints = 0;
static int mem_alloc_failed[TOTAL_GRPS];
static int mem_alloc_counts[TOTAL_GRPS];
static int mem_grp_max_sz[TOTAL_GRPS];
#endif

#ifdef MHG_TRACK_MEM
static void *mh5emt_mutex = NULL;
static mh5emtEntry_t mh5emt_listHead;
static pMh5emtEntry_t pMh5emt_listTail = NULL;

const char *mem_strings[MAX_MEM_SRCS] = {
   "TOTALMEM", "SYSTEM  ", "DSM-CC  ", "SI_QUERY", "SSFCACHE", "FREETYPE", "MHENGINE", "GRAPHICS", "SURFACES"
};

static unsigned long cur_mem_total[MAX_MEM_SRCS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
static unsigned long max_mem_total[MAX_MEM_SRCS] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };

   #ifdef _WINDOWS
   #define MAX_SAVED_MALLOCS 0x1000
mh5emtEntry_t saved_mallocs[MAX_SAVED_MALLOCS];
int saved_malloc_cnt = 0;
   #endif

#endif


/*---local function definitions----------------------------------------------*/

/*---global function definitions---------------------------------------------*/

#ifdef MHG_TRACK_MEM
void mh5emt_init(void)
{
#ifdef TRACING
   int g, sz, ts = 0;
   for (g = 0, sz = 2; g != TOTAL_GRPS; g++)
   {
      mem_grp_max_sz[g] = sz;
      if ((sz >= 32) && (sz <= 1024))
      {
         if (ts)
         {
            sz += ts;
            ts = 0;
         }
         else
         {
            ts = sz >> 1;
            sz += ts;
         }
      }
      else
      {
         sz <<= 1;   /* multiply by 2 */
      }
   }
#endif
   if (pMh5emt_listTail == NULL)
   {
      mh5emt_mutex = STB_OSCreateMutex();

      /* -- Initialise engine memory tracking */
      mh5emt_listHead.magic = 0;
      mh5emt_listHead.callingFunc = NULL;
      mh5emt_listHead.size = 0;
      mh5emt_listHead.addr = NULL;
      mh5emt_listHead.prev = NULL;
      mh5emt_listHead.next = NULL;

      pMh5emt_listTail = &mh5emt_listHead;
   }
}

void mh5emt_close(void)
{
}

#endif  /* MHG_TRACK_MEM */

void MHEG5freeMemFunc(void *what)
{
#ifdef MHG_TRACK_MEM
   pMh5emtEntry_t pEmtHdr = (pMh5emtEntry_t)what;
   /* -- Debug code for tracking engine memory usage */
   if (what == 0)
   {
      TRACE(TERROR, ("**** WARNING: Attempt to free NULL MHEG5 memory block ****"))
   }
   else
   {
      unsigned char *pByte = (unsigned char *)what;

      /* -- Get actual start of memory block (debug header) */
      pEmtHdr--;

      STB_OSMutexLock( mh5emt_mutex );

      if ((pEmtHdr->magic == MH5EMT_MAGIC) &&
          (pEmtHdr->addr == pEmtHdr) &&
          (pEmtHdr->prev != NULL))
      {
         /* -- Remove block from allocated list */
         pEmtHdr->prev->next = pEmtHdr->next;
         if (pEmtHdr->next)
         {
            pEmtHdr->next->prev = pEmtHdr->prev;
         }
         else
         {
            /* -- Block is at tail of list so re-assign tail */
            pMh5emt_listTail = pEmtHdr->prev;
         }

         if (cur_mem_total[0] < pEmtHdr->size)
         {
            TRACE(TERROR, ("now=%ld, size=%ld", cur_mem_total[0], pEmtHdr->size))
         }
         else
         {
            cur_mem_total[0] -= pEmtHdr->size;

            if (pEmtHdr->src > 0 && pEmtHdr->src < MAX_MEM_SRCS)
            {
               if (cur_mem_total[pEmtHdr->src] < pEmtHdr->size)
               {
                  TRACE(TERROR, ("src=%d, now=%ld, size=%ld", pEmtHdr->src, cur_mem_total[pEmtHdr->src], pEmtHdr->size))
               }
               else
               {
                  cur_mem_total[pEmtHdr->src] -= pEmtHdr->size;
               }
            }
            else
            {
               TRACE(TERROR, ("free with invalid src id %d", pEmtHdr->src))
            }
         }
         pByte += pEmtHdr->size;
         if (pByte[0] != 'e' || pByte[1] != 'n' || pByte[2] != 'd' || pByte[3] != 'm')
         {
            TRACE(TERROR, ("**** ERROR: free MHEG5 memory block with data corruption ****"))
         }
         /* -- NULL debug header contents */
         pEmtHdr->magic = 0;
         pEmtHdr->callingFunc = NULL;
         pEmtHdr->size = 0;
         pEmtHdr->src = 0;
         pEmtHdr->line = 0;
         pEmtHdr->addr = NULL;
         pEmtHdr->prev = NULL;
         pEmtHdr->next = NULL;
      }
      else
      {
         TRACE(TERROR, ("**** ERROR: Attempt to free invalid MHEG5 memory block ****"))
         assert(0);
      }

      STB_OSMutexUnlock( mh5emt_mutex );

      /* -- Free the actual block */
      what = pEmtHdr;
   }
#endif
   FreeFunc(what);
}

#ifdef MHG_TRACK_MEM
void* MHEG5getMemFunc(void *callingFunction, int size, int line, int src)
#else
void * MHEG5getMemFunc(int size)
#endif
{
   void *rc = 0;
   #ifdef TRACING
   int grp;
   #endif
   #ifdef MHG_TRACK_MEM
   pMh5emtEntry_t pEmtHdr;
   unsigned char *pByte;

   if (pMh5emt_listTail == NULL)
   {
      mh5emt_init();
   }
   #define theMemSize   size + sizeof(mh5emtEntry_t) + 4
   #else
   #define theMemSize   size
   #endif

   if (size <= 0)
   {
      #ifdef MHG_TRACK_MEM
      TRACE(TERROR, ("%s:%d requested size: %d\n", (const char *)callingFunction, line, size));
      #else
      TRACE(TERROR, ("requested size: %d", size));
      #endif
      return 0;              /*** RETURN ***/
   }

    #ifdef TRACING
   grp = 0;
   while ((mem_grp_max_sz[grp] < size) && (grp != TOTAL_GRPS - 1))
   {
      grp++;
   }
    #endif

   /* -- Allocate a bigger block to store debug header */
   rc = MallocFunc(theMemSize);
   if (!rc)
   {
      TRACER(mem_alloc_failed[grp]++; )
      TRACE(TERROR, ("ERROR: Failed to alloc memory, sz=%d\n", size))
        #ifdef MHEG5LOG
      MHEG5LogPrintf(MHEG5ERROR, "*** Out of memory Error *** Calling Function: %p , requested size: %d\n", callingFunction, size);
        #endif /* #ifdef MHEG5LOG */
        #ifdef MHG_TRACK_MEM
      TRACE(TMEMORY, ("*** Out of memory (total %ld) *** %s:%d size: %d\n", cur_mem_total[0], (const char *)callingFunction, line, size))
      mh5emt_print(0xf);
        #endif
   }
   else
   {
      TRACER(mem_alloc_counts[grp]++; )
        #ifdef MHG_TRACK_MEM
      assert( src > 0 && src < MAX_MEM_SRCS );
      assert( size > 0 );
      pEmtHdr = (pMh5emtEntry_t)rc;
      /* -- Memory pointer passed to engine is after debug header */
      rc = pEmtHdr + 1;
      pByte = (unsigned char *)rc;
      pByte += size;
      pByte[0] = 'e'; pByte[1] = 'n'; pByte[2] = 'd'; pByte[3] = 'm';
      /* -- Store debug header contents */
      pEmtHdr->magic = MH5EMT_MAGIC;
      pEmtHdr->callingFunc = (const char *)callingFunction;
      pEmtHdr->line = line;
      pEmtHdr->src = src;
      pEmtHdr->size = (unsigned int)size;
      pEmtHdr->addr = pEmtHdr;

      cur_mem_total[src] += (unsigned int)size;
      if (cur_mem_total[src] > max_mem_total[src])
         max_mem_total[src] = cur_mem_total[src];
      cur_mem_total[0] += (unsigned int)size;
      if (cur_mem_total[0] > max_mem_total[0])
         max_mem_total[0] = cur_mem_total[0];

      /* -- Put block on tail of list */
      STB_OSMutexLock( mh5emt_mutex );
      pEmtHdr->prev = pMh5emt_listTail;
      pEmtHdr->next = NULL;
      pMh5emt_listTail->next = pEmtHdr;

      /* -- Move tail of list to new block */
      pMh5emt_listTail = pEmtHdr;
      STB_OSMutexUnlock( mh5emt_mutex );

          #ifdef _WINDOWS
      saved_mallocs[saved_malloc_cnt].next = pEmtHdr;
      saved_malloc_cnt++;
      if (saved_malloc_cnt == MAX_SAVED_MALLOCS)
      {
         saved_malloc_cnt = 1;
      }
      memcpy(saved_mallocs + saved_malloc_cnt, pEmtHdr, sizeof(mh5emtEntry_t));
          #endif
        #endif
   }
   return rc;
}





/*
   static void BlkInit( S_STRINGS_BLOCK* pBlk, int dbits )
   {
   int cx;
   pBlk->next = NULL;
   for( cx = 0; cx != (CONTROL_SIZE-1); cx++ )
   {
      pBlk->control[cx] = 0x0;
   }
   pBlk->control[CONTROL_SIZE-1] = TOP_CONTROL(dbits);
   }
 */

static BOOLEAN STR_Initialise(void)
{
   unsigned char *heads;

   heads = MHEG5getMem( STR_BLCK_SIZE(VTINY_BITS) +
         STR_BLCK_SIZE(MIGIT_BITS) +
         STR_BLCK_SIZE(SMALL_BITS) +
         STR_BLCK_SIZE(MEDUM_BITS) +
         STR_BLCK_SIZE(LARGE_BITS));
   if (heads == NULL)
   {
      TRACE(TERROR, ("failed to allocate string memory"))
      return FALSE;
   }

   vtiny_strmem_head = (S_STRINGS_BLOCK *)heads;
   memset( heads, 0, sizeof(S_STRINGS_BLOCK));
   heads += STR_BLCK_SIZE(VTINY_BITS);

   migit_strmem_head = (S_STRINGS_BLOCK *)heads;
   memset( heads, 0, sizeof(S_STRINGS_BLOCK));
   heads += STR_BLCK_SIZE(MIGIT_BITS);

   small_strmem_head = (S_STRINGS_BLOCK *)heads;
   memset( heads, 0, sizeof(S_STRINGS_BLOCK));
   heads += STR_BLCK_SIZE(SMALL_BITS);

   medum_strmem_head = (S_STRINGS_BLOCK *)heads;
   memset( heads, 0, sizeof(S_STRINGS_BLOCK));
   heads += STR_BLCK_SIZE(MEDUM_BITS);

   large_strmem_head = (S_STRINGS_BLOCK *)heads;
   memset( heads, 0, sizeof(S_STRINGS_BLOCK));

   return TRUE;
}

static void FreeStrBlocks( S_STRINGS_BLOCK *pBlk, int dbits )
{
   S_STRINGS_BLOCK *next = pBlk->next;

   #ifdef MHG_TRACK_MEM
   unsigned char *data;
   int cx, bx, bbits;
   /* Check the string allocations are all gone in head block */
   for (cx = 0; cx != CONTROL_SIZE; cx++)
   {
      if (pBlk->control[cx] != 0x00)
      {
         for (bbits = 1, bx = 0; bbits != 0x100; bbits <<= 1, bx++)
         {
            if ((pBlk->control[cx] & bbits))
            {
               data = (unsigned char *)pBlk + sizeof(S_STRINGS_BLOCK) + (((cx << 3) + bx) << dbits);
               TRACE(TMEMORY, ("(%d,%d) line=%d Not freed \"%s\"", cx, bx, pBlk->line[(cx << 3) + bx], data))
            }
         }
      }
   }
   #endif

   while (next != NULL)
   {
      pBlk = next;
      #ifdef MHG_TRACK_MEM
      /* Check the string allocations are all gone */
      for (cx = 0; cx != CONTROL_SIZE; cx++)
      {
         if (pBlk->control[cx] != 0x00)
         {
            for (bbits = 1, bx = 0; bbits != 0x100; bbits <<= 1, bx++)
            {
               if ((pBlk->control[cx] & bbits))
               {
                  data = (unsigned char *)pBlk + sizeof(S_STRINGS_BLOCK) + (((cx << 3) + bx) << dbits);
                  TRACE(TMEMORY, ("(%d,%d) line=%d Not freed \"%s\"", cx, bx, pBlk->line[(cx << 3) + bx], data))
               }
            }
         }
      }
      #endif
      next = pBlk->next;
      MHEG5freeMem( pBlk );
   }
}

void STR_Shutdown(void)
{
   TRACE(TMEMORY, ("freeing extra string memory"))
   FreeStrBlocks( large_strmem_head, LARGE_BITS );
   FreeStrBlocks( medum_strmem_head, MEDUM_BITS );
   FreeStrBlocks( small_strmem_head, SMALL_BITS );
   FreeStrBlocks( migit_strmem_head, MIGIT_BITS );
   FreeStrBlocks( vtiny_strmem_head, VTINY_BITS );

   TRACE(TMEMORY, ("freeing header string memory"))
   MHEG5freeMem( vtiny_strmem_head );
}

static void ReleaseAnyFreeStrBlocks( S_STRINGS_BLOCK *pBlk, int dbits )
{
   int cx;
   S_STRINGS_BLOCK *prev;
   /* always leave the first 'header' block for each */
   while (pBlk->next != NULL)
   {
      prev = pBlk;
      pBlk = pBlk->next;
      /* Check the string allocations are all gone in head block */
      cx = 0;
      while (cx != CONTROL_SIZE && pBlk->control[cx] == 0x00)
         cx++;
      if (cx == CONTROL_SIZE)
      {
         prev->next = pBlk->next;
         MHEG5freeMem( pBlk );
         pBlk = prev;
      }
   }
}

/* free 'string' block memory no longer required */
void STR_TidyUp(void)
{
   assert( vtiny_strmem_head );
   ReleaseAnyFreeStrBlocks( large_strmem_head, LARGE_BITS );
   ReleaseAnyFreeStrBlocks( medum_strmem_head, MEDUM_BITS );
   ReleaseAnyFreeStrBlocks( small_strmem_head, SMALL_BITS );
   ReleaseAnyFreeStrBlocks( migit_strmem_head, MIGIT_BITS );
   ReleaseAnyFreeStrBlocks( vtiny_strmem_head, VTINY_BITS );
}

#ifndef MHG_TRACK_MEM
#define BlkStrAlloc(bk, bz, ln) BlkStrAlloc(bk, bz)
#endif

static unsigned char* BlkStrAlloc( S_STRINGS_BLOCK *pBlk, int dbits, int line )
{
   unsigned char *data = NULL;
   int cx, bx, bbits;
   do
   {
      for (cx = 0; cx != CONTROL_SIZE; cx++)
      {
         if (pBlk->control[cx] != 0xff)
         {
            for (bbits = 1, bx = 0; bbits != 0x100; bbits <<= 1, bx++)
            {
               if (!(pBlk->control[cx] & bbits))
               {
                  pBlk->control[cx] |= bbits;
                  data = (unsigned char *)pBlk + sizeof(S_STRINGS_BLOCK) + (((cx << 3) + bx) << dbits);
                  #ifdef MHG_TRACK_MEM
                  pBlk->line[(cx << 3) + bx] = (U16BIT)line;
                  #endif
                  break;
               }
            }
            break;
         }
      }
      if (cx == CONTROL_SIZE)
      {
         if (pBlk->next == NULL)
         {
            pBlk->next = (S_STRINGS_BLOCK *)MHEG5getMem( STR_BLCK_SIZE(dbits));
            if (pBlk->next)
            {
               memset( pBlk->next, 0, sizeof(S_STRINGS_BLOCK));
            }
            else
            {
               data = NULL;
            }
         }
         pBlk = pBlk->next;
      }
   }
   while ((cx == CONTROL_SIZE) && (pBlk != NULL));
   return data;
}

#ifdef MHG_TRACK_MEM
unsigned char* STR_DataAllocFunc( unsigned int len, int line )
#else
unsigned char * STR_DataAlloc( unsigned int len )
#endif
{
   unsigned char *data;
   if (len < (1 << SMALL_BITS))
   {
      if (len < (1 << MIGIT_BITS))
      {
         if (len < (1 << VTINY_BITS))
         {
            data = BlkStrAlloc( vtiny_strmem_head, VTINY_BITS, line );
         }
         else
         {
            data = BlkStrAlloc( migit_strmem_head, MIGIT_BITS, line );
         }
      }
      else
      {
         data = BlkStrAlloc( small_strmem_head, SMALL_BITS, line );
      }
   }
   else
   {
      if (len < (1 << MEDUM_BITS))
      {
         data = BlkStrAlloc( medum_strmem_head, MEDUM_BITS, line );
      }
      else
      {
         if (len < (1 << LARGE_BITS))
         {
            data = BlkStrAlloc( large_strmem_head, LARGE_BITS, line );
         }
         else
         {
            data = (unsigned char *)MHEG5getMem( len + 1 );
         }
      }
   }
   if (data != NULL)
   {
      data[len] = 0; /*null terminate string*/
   }
   return data;
}

#ifndef BlkStrFree
static void BlkStrFree( S_STRINGS_BLOCK *pBlk, int bz, unsigned char *data )
{
   do
   {
      unsigned char *blk_data = (unsigned char *)pBlk + sizeof(S_STRINGS_BLOCK);
      if (data >= blk_data &&
          data < blk_data + STR_DATA_SIZE(bz))
      {
         int tmp;
         tmp = (data - blk_data) >> bz;
         pBlk->control[tmp >> 3] &= (U8BIT) ~(1 << (tmp & 7));
         break;
      }
      pBlk = pBlk->next;
   }
   while (pBlk != NULL);
   if (pBlk == NULL)
   {
      TRACE(TERROR, ("Not freed %x", data))
   }
}

#endif /*BlkStrFree*/

void STR_DataFree( unsigned char *data, unsigned int len )
{
   if (len < (1 << SMALL_BITS))
   {
      if (len < (1 << MIGIT_BITS))
      {
         if (len < (1 << VTINY_BITS))
         {
            BlkStrFree( vtiny_strmem_head, VTINY_BITS, data );
         }
         else
         {
            BlkStrFree( migit_strmem_head, MIGIT_BITS, data );
         }
      }
      else
      {
         BlkStrFree( small_strmem_head, SMALL_BITS, data );
      }
   }
   else
   {
      if (len < (1 << MEDUM_BITS))
      {
         BlkStrFree( medum_strmem_head, MEDUM_BITS, data );
      }
      else
      {
         if (len < (1 << LARGE_BITS))
         {
            BlkStrFree( large_strmem_head, LARGE_BITS, data );
         }
         else
         {
            MHEG5freeMem( data );
         }
      }
   }
}

void MHG_DebugMemStats(int line)
{
#ifdef TRACING
   int nx, last = 0;
   char tmp[64];
   char str[512];
   str[0] = 0;
   for (nx = 0; nx != TOTAL_GRPS; nx++)
   {
      sprintf(tmp, "(%03x-%03x)=%03d  ", last, mem_grp_max_sz[nx] - 1, mem_alloc_counts[nx]);
      last = mem_grp_max_sz[nx];
      strcat(str, tmp);
      if ((nx % 6) == 5)
      {
         TRACE(TMEMORY, ("%s", str))
         str[0] = 0;
      }
      mem_alloc_counts[nx] = 0;
   }
   #ifdef MHG_TRACK_MEM
   for (nx = 0; nx != MAX_MEM_SRCS; nx++)
   {
      TRACE(TMEMORY, ("Src=%s \tNow= %03ld\tMax= %03ld", mem_strings[nx], cur_mem_total[nx], max_mem_total[nx]))
   }
   #endif
   if (mem_prints)
   {
      for (nx = 0; nx != TOTAL_GRPS; nx++)
      {
         if (mem_alloc_failed[nx])
         {
            TRACE(TMEMORY, ("Had failures: %d, %d", nx, mem_alloc_failed[nx]));
            mem_alloc_failed[nx] = 0;
         }
      }
   }
   else
   {
      for (nx = 0; nx != TOTAL_GRPS; nx++)
      {
         mem_alloc_failed[nx] = 0;
      }
      mem_prints++;
   }
#endif /*TRACING*/
}

#ifdef MHG_TRACK_MEM
/* -- Print list of all engine memory blocks currently allocated */
void mh5emt_print(unsigned int which)
{
   const char dig[16] = "0123456789ABCDEF";
   unsigned int ndx;
   U8BIT *pch;
   pMh5emtEntry_t pEmtHdr;
   BOOLEAN src_on[MAX_MEM_SRCS];

   for (ndx = 0; ndx != MAX_MEM_SRCS; ndx++)
   {
      src_on[ndx] = (which & (1 << ndx)) ? TRUE : FALSE;
   }

   MHG_DebugMemStats(0);

   TPRINT(TMEMORY, ("\n#### ALLOCATED ENGINE MEMORY OBJECTS ####\n"))

   STB_OSMutexLock( mh5emt_mutex );
   pEmtHdr = mh5emt_listHead.next;

   while (pEmtHdr != NULL)
   {
      if (src_on[pEmtHdr->src])
      {
         TPRINT(TMEMORY, ("\"\n%s:%d Size: %u, Addr: %p \"",
                          pEmtHdr->callingFunc, pEmtHdr->line, pEmtHdr->size, pEmtHdr->addr))
         pch = (U8BIT *)(pEmtHdr->addr + 1);
         for (ndx = 0; (ndx < pEmtHdr->size); pch++, ndx++)
         {
            if ((*pch >= 0x20) && (*pch < 0x7e) && (*pch != '='))
            {
               TPRINT(TMEMORY, ("%c", *pch))
            }
            else
            {
               TPRINT(TMEMORY, ("=%c%c", dig[*pch >> 4], dig[*pch & 0xf]))
               if (ndx > 8)
                  ndx = pEmtHdr->size;
            }
         }
      }
      pEmtHdr = pEmtHdr->next;
   }
   STB_OSMutexUnlock( mh5emt_mutex );
}

#endif



BOOLEAN MH5GlueMemoryInitialise( void )
{
   BOOLEAN result;

   #ifdef MHG_TRACK_MEM
   /* -- Debug code - initialise engine memory tracking */
   if (pMh5emt_listTail == NULL)
   {
      mh5emt_init();
   }
   #endif

   if (vtiny_strmem_head != NULL)
   {
      result = TRUE;
   }
   else
   {
      result = STR_Initialise();
   }
   return result;
}

void MH5GlueMemoryTerminate(void)
{
   if (vtiny_strmem_head != NULL)
   {
      STR_Shutdown();
      vtiny_strmem_head = NULL;
   }
#ifdef MHG_TRACK_MEM
   /* -- Debug code - print engine memory tracking state */
   TRACE(TMEMORY, (""))
   mh5emt_print(0xf);
#endif
}

#ifdef MHG_TRACK_MEM
S_STRING MH5GlueStringCopyFunc(S_STRING source, int line )
#else
S_STRING MH5GlueStringCopy(S_STRING source)
#endif
{
   S_STRING rc;

   if (source.zlen != 0)
   {
      #ifdef MHG_TRACK_MEM
      rc.zptr = STR_DataAllocFunc( source.zlen, line + 7000 );
      #else
      rc.zptr = STR_DataAlloc( source.zlen );
      #endif
      if (rc.zptr)
      {
         assert(rc.zptr != source.zptr);
         memcpy(rc.zptr, source.zptr, source.zlen);
         rc.zlen = source.zlen;
      }
      else
      {
         rc.zlen = 0;
      }
   }
   else
   {
      rc.zptr = NULL;
      rc.zlen = 0;
   }
   return rc;
}

#ifdef MHG_TRACK_MEM
S_STRING MH5GlueStringConcatFunc(S_STRING src1, S_STRING src2, int line )
#else
S_STRING MH5GlueStringConcat(S_STRING src1, S_STRING src2)
#endif
{
   S_STRING rc;

   rc.zlen = src1.zlen + src2.zlen;
   if (rc.zlen == 0)
   {
      rc.zptr = NULL;
   }
   else
   {
      #ifdef MHG_TRACK_MEM
      rc.zptr = STR_DataAllocFunc( src1.zlen + src2.zlen, line + 8000 );
      #else
      rc.zptr = STR_DataAlloc( src1.zlen + src2.zlen );
      #endif
      if (rc.zptr)
      {
         if (src1.zptr != NULL && src1.zlen != 0)
         {
            memcpy(rc.zptr, src1.zptr, src1.zlen);
         }
         else
         {
            src1.zlen = 0;
         }
         if (src2.zptr != NULL && src2.zlen != 0)
         {
            memcpy(rc.zptr + src1.zlen, src2.zptr, src2.zlen);
         }
      }
      else
      {
         rc.zlen = 0;
      }
   }
   return rc;
}

#ifdef MHG_TRACK_MEM
S_STRING MH5GlueStringAllocFunc(U32BIT size, int line )
#else
S_STRING MH5GlueStringAlloc(U32BIT size)
#endif
{
   S_STRING rc;

   if (size != 0)
   {
      #ifdef MHG_TRACK_MEM
      rc.zptr = STR_DataAllocFunc( size, line + 6000 );
      #else
      rc.zptr = STR_DataAlloc( size );
      #endif
      if (rc.zptr)
      {
         rc.zlen = size;
      }
      else
      {
         rc.zlen = 0;
      }
   }
   else
   {
      rc.zptr = NULL;
      rc.zlen = 0;
   }
   return rc;
}

#ifdef MHG_TRACK_MEM
S_STRING MH5GlueStringCreateFunc(U32BIT size, U8BIT *data, int line )
#else
S_STRING MH5GlueStringCreate(U32BIT size, U8BIT * data)
#endif
{
   S_STRING rc;

   if (size != 0)
   {
      #ifdef MHG_TRACK_MEM
      rc.zptr = STR_DataAllocFunc( size, line + 6000 );
      #else
      rc.zptr = STR_DataAlloc( size );
      #endif
      if (rc.zptr)
      {
         rc.zlen = size;
         memcpy(rc.zptr, data, size);
      }
      else
      {
         rc.zlen = 0;
      }
   }
   else
   {
      rc.zptr = NULL;
      rc.zlen = 0;
   }
   return rc;
}

void MH5GlueStringFree( S_STRING *pStr )
{
   assert(pStr != NULL);
   if (pStr->zptr != NULL)
   {
      STR_DataFree( pStr->zptr, pStr->zlen );
      pStr->zptr = NULL;
      pStr->zlen = 0;
   }
}

/*EOF*/