mh5storage.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 "mh5storage.h"
#include "mh5memory.h"
#include "mh5debug.h"
#include "mh5profile.h"

/*---constant definitions for this file--------------------------------------*/
#define MAXFILES 32


/*---local typedef structs for this file-------------------------------------*/
typedef struct sRamFile
{
   MHEG5String name;
   MHEG5String data;
   MHEG5Bool free;
   struct sRamFile *next, *prev;
} MHEG5RamFile;

/*---local (static) variable declarations for this file----------------------*/
static MHEG5RamFile file_list[MAXFILES];
static MHEG5RamFile *file_list_top;

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

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


static MHEG5Int memUsed(void)
{
   MHEG5Int i, rc = 0;

   /* Add all data lengths. */
   for (i = 0; i < MAXFILES; i++)
   {
      rc += file_list[i].data.len;
   }

   /* Return total size in bytes. */
   return rc;
}

static MHEG5Int numUsed(void)
{
   MHEG5Int i, rc = 0;

   /* Add all data lengths. */
   for (i = 0; i < MAXFILES; i++)
   {
      rc += (file_list[i].free == MHEG5FALSE);
   }

   /* Return total number of slots in use. */
   return rc;
}

void MHEG5InitStore(void)
{
   MHEG5Int i;

   file_list_top = 0;
   for (i = 0; i != MAXFILES; i++)
   {
      file_list[i].data.len = 0;
      file_list[i].name.len = 0;
      file_list[i].next = 0;
      file_list[i].prev = 0;
      file_list[i].free = MHEG5TRUE;
   }
}

void MHEG5ResetStore(void)
{
   /* Local variable. */
   MHEG5Int i;

   /* Check initialised. */
   for (i = 0; i != MAXFILES; i++)
   {
      if (!file_list[i].free)
      {
         MHEG5stringDestruct( &file_list[i].name );
         MHEG5stringDestruct( &file_list[i].data );
         file_list[i].name.len = 0;
         file_list[i].next = 0;
         file_list[i].prev = 0;
         file_list[i].free = MHEG5TRUE;
      }
   }
   file_list_top = 0;
}

MHEG5Bool MHEG5storageWrite(MHEG5String fn, void *buf, MHEG5Int len)
{
   /* Get top of file list. */
   MHEG5RamFile *temp_file;
   MHEG5Int i, count;

   INFO_PRINT(("BEGIN: MHEG5storageWrite - File [%.*s], Length [0x%x].\n", fn.len, fn.data, len));

   /* Check that input file not bigger than total persistent storage unit. */
   if (len > MHEG5STORAGE_MEMSIZE)
   {
      DEBUG_PRINT(("ERROR: MHEG5storageWrite - File [%.*s] too big [0x%x].\n", fn.len, fn.data, len));
      return MHEG5FALSE;
   }

   /* Find duplicate file names, and remove. */
   for (i = 0; i != MAXFILES; i++)
   {
      /* Check if file has same name. */
      if (MHEG5stringEqual(&file_list[i].name, &fn))
      {
         INFO_PRINT(("WARNING: MHEG5storageWrite - Found duplicate file name [%.*s] in list.\n", fn.len, fn.data));
         /* Remove file from list. */
         MHEG5stringDestruct(&file_list[i].name);
         MHEG5stringDestruct(&file_list[i].data);
         file_list[i].free = MHEG5TRUE;

         /* Remove file from chain. */
         if (file_list[i].prev != 0)
         {
            file_list[i].prev->next = file_list[i].next;
         }

         if (file_list[i].next != 0)
         {
            file_list[i].next->prev = file_list[i].prev;
         }

         if (file_list_top == &file_list[i])
         {
            file_list_top = file_list[i].next;
         }

         file_list[i].prev = 0;
         file_list[i].next = 0;
      }
   }

   count = numUsed();

   /* Check enough space in list for new file. */
   while ((memUsed() + len > MHEG5STORAGE_MEMSIZE || count == MAXFILES) &&
          (file_list_top != 0))
   {
      INFO_PRINT(("WARNING: MHEG5storageWrite - Not enough space in list, deleting files.\n"));
      temp_file = file_list_top;
      if (temp_file == 0)
      {
         DEBUG_PRINT(("ERROR: MHEG5storageWrite - Cannot remove from empty list.\n"));
         return MHEG5FALSE;
      }

      while (temp_file->next != 0)
      {
         temp_file = temp_file->next;
      }

      /* Remove file from list. */
      MHEG5stringDestruct(&temp_file->name);
      MHEG5stringDestruct(&temp_file->data);
      temp_file->free = MHEG5TRUE;
      count--;

      if (temp_file->prev != 0)
      {
         temp_file->prev->next = temp_file->next;
      }

      if (file_list_top == temp_file)
      {
         file_list_top = 0;
      }

      temp_file->next = 0;
      temp_file->prev = 0;
   }

   /* Find free file list item. */
   i = 0;
   while (i < MAXFILES && file_list[i].free != MHEG5TRUE)
   {
      i++;
   }

   if (i == MAXFILES)
   {
      DEBUG_PRINT(("ERROR: MHEG5storageWrite - No empty slot in list.\n"));
      return MHEG5FALSE;
   }

   /* Update file details. */
   file_list[i].data.data = STR_DataAlloc( len );
   if (!file_list[i].data.data)
   {
      DEBUG_PRINT(("ERROR: MHEG5storageWrite - Unable to allocate memory for file.\n"));
      return MHEG5FALSE;
   }
   file_list[i].name = MHEG5stringCopy(fn);
   file_list[i].data.len = len;
   file_list[i].free = MHEG5FALSE;
   memcpy(file_list[i].data.data, buf, len);

   /* Add file to list. */
   file_list[i].next = file_list_top;
   if (file_list[i].next != 0)
   {
      file_list[i].next->prev = &file_list[i];
   }
   file_list[i].prev = 0;
   file_list_top = &file_list[i];

   INFO_PRINT(("SUCCESS: MHEG5storageWrite - File [%.*s] added to list.\n", fn.len, fn.data));
   return MHEG5TRUE;
}

MHEG5Bool MHEG5storageRead(MHEG5String fn, void **buf, MHEG5Int *len)
{
   MHEG5Int i;
   INFO_PRINT(("BEGIN: MHEG5storageRead - File [%.*s].\n", fn.len, fn.data));

   if (buf == 0 || len == 0)
   {
      DEBUG_PRINT(("ERROR: MHEG5storageRead - Bad data variable pointer passed.\n"));
      return MHEG5FALSE;
   }
   for (i = 0; i < MAXFILES; i++)
   {
      if (MHEG5stringEqual(&file_list[i].name, &fn))
      {
         *buf = file_list[i].data.data;
         *len = file_list[i].data.len;

         INFO_PRINT(("SUCCESS: MHEG5storageRead - Found file [%.*s] in list.\n", fn.len, fn.data));
         return MHEG5TRUE;
      }
   }
   INFO_PRINT(("WARNING: MHEG5storageRead - Unable to find file [%.*s] in list.\n", fn.len, fn.data));
   return MHEG5FALSE;
}