mh5nvm.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2012 Ocean Blue Software Ltd
 *
 * 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 "mh5memory.h"
#include "mh5debug.h"
#include "mh5profile.h"
#include "mh5nvm.h"
#include "mheg5_nvm.h"
#include "stb_nvm.h"

/*---constant definitions for this file--------------------------------------*/
#define MAX_NAME_LENGTH 8

#define NVM_STORE_FILENAME "NVMFILELIST.dat"


/*---local typedef structs for this file-------------------------------------*/

typedef struct sNvmFile
{
   U32BIT file_size;
   struct sNvmFile *next;
   struct sNvmFile *previous;
   U8BIT name_length;
   U8BIT name[MAX_NAME_LENGTH + 1];
} MHEG5NvmFile;


/*---local (static) variable declarations for this file----------------------*/

static MHEG5NvmFile *file_list_oldest = NULL;
static MHEG5NvmFile *file_list_newest = NULL;
static U32BIT total_filesize = 0;
static U32BIT nvm_store_size = 0;
static MHEG5Bool init = MHEG5FALSE;

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

/*---global function definitions---------------------------------------------*/
static void CreateFileList(U8BIT *encoded_list, U32BIT list_len);
static MHEG5Boolean WriteChanges();
static void DeleteNvmFile(MHEG5NvmFile *file);


void MHEG5nvmInitialise( U32BIT nvmSize )
{
   U32BIT size;
   U8BIT *buffer;
   void *file;

   if(init)
   {
      MHEG5nvmReset();
   }

   nvm_store_size = nvmSize;
   if (STB_NVMFileSize( (U8BIT *) NVM_STORE_FILENAME, &size ))
   {
      file = STB_NVMOpenFile((U8BIT *) NVM_STORE_FILENAME, FILE_MODE_READ);
      if (file != NULL)
      {
         buffer = STB_MemAlloc(size);
         if (STB_NVMReadFile(file, buffer, size) == size)
         {
            CreateFileList(buffer, size);
         }
         STB_MemFree(buffer);
         STB_NVMCloseFile( file );
      }
   }
   init = MHEG5TRUE;
}

MHEG5Bool MHEG5nvmRead(MHEG5String fn, void **buf, MHEG5Int *len)
{
   MHEG5NvmFile *file = file_list_newest;
   MHEG5Bool success = MHEG5FALSE;
   void *fp;

   INFO_PRINT(("BEGIN: MHEG5nvmRead - File [%.*s].\n", fn.len, fn.data));
   if (buf == 0 || len == 0)
   {
      DEBUG_PRINT(("ERROR: MHEG5nvmRead - Bad data variable pointer passed.\n"));
   }
#ifdef INVALIDATE_LONG_NAME
   else if (fn.len > MAX_NAME_LENGTH)
   {
      TRACE(TERROR, ("filename [%.*s] is too long %d ", fn.len, fn.data, fn.len))
   }
#endif
   else
   {
#ifndef INVALIDATE_LONG_NAME
      if (fn.len > MAX_NAME_LENGTH)
      {
         TRACE(TERROR, ("filename too long %d - clipping to \"%.*s\"", fn.len, MAX_NAME_LENGTH, fn.data))
         fn.len = MAX_NAME_LENGTH;
      }
#endif


      while (file)
      {
         if (file->name_length == fn.len &&
             memcmp(file->name, fn.data, fn.len) == 0)
         {
            *len = file->file_size;
            *buf = STB_MemAlloc(file->file_size);

            fp = STB_NVMOpenFile((U8BIT *) fn.data, FILE_MODE_READ);
            if (fp)
            {
               STB_NVMReadFile( fp, *buf, *len );
               STB_NVMCloseFile(fp);
               success = MHEG5TRUE;
            }
            INFO_PRINT(("SUCCESS: MHEG5nvmRead - Found file [%.*s] in list.\n", fn.len, fn.data));

            break;
         }
         file = file->previous;
      }
   }
   INFO_PRINT(("WARNING: MHEG5nvmRead - Unable to find file [%.*s] in list.\n", fn.len, fn.data));
   return success;
}

MHEG5Bool MHEG5nvmWrite(MHEG5String fn, void *buf, MHEG5Int len)
{
   MHEG5NvmFile *file = file_list_oldest;
   MHEG5NvmFile *new_file;
   MHEG5Bool success;
   U32BIT size = (U32BIT)len;
   void *fp;
   /* Check that input file not bigger than the total nvm space. */
   if (size > nvm_store_size)
   {
      TRACE(TERROR, ("File [%.*s] too big [0x%x]", fn.len, fn.data, size));
      success = MHEG5FALSE;
   }
   #ifdef INVALIDATE_LONG_NAME
   else if (fn.len > MAX_NAME_LENGTH)
   {
      TRACE(TERROR, ("filename [%.*s] is too long %d ", fn.len, fn.data, fn.len))
      success = MHEG5FALSE;
   }
   #endif
   else
   {
      #ifndef INVALIDATE_LONG_NAME
      if (fn.len > MAX_NAME_LENGTH)
      {
         TRACE(TERROR, ("filename too long %d - clipping to \"%.*s\"", fn.len, MAX_NAME_LENGTH, fn.data))
         fn.len = MAX_NAME_LENGTH;
      }
      #endif

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

      /* Find duplicate file names, and remove. */

      while (file)
      {
         if (file->name_length == fn.len &&
             memcmp(file->name, fn.data, fn.len) == 0)
         {
            MHEG5NvmFile *to_delete = file;
            file = file->next;
            INFO_PRINT(("WARNING: MHEG5nvmWrite - Found duplicate file name [%.*s] in list.\n", fn.len, fn.data));
            /* Remove file from list. */
            DeleteNvmFile(to_delete);
         }
         else
         {
            file = file->next;
         }
      }

      /* Check enough space in list for new file. */
      while ((total_filesize + size > nvm_store_size)
             && file_list_oldest != NULL
             && total_filesize > 0)
      {
         INFO_PRINT(("WARNING: MHEG5nvmWrite - Not enough space in list, deleting files.\n"));
         DeleteNvmFile(file_list_oldest);
      }
      new_file = STB_MemAlloc(sizeof(MHEG5NvmFile));
      if (new_file == NULL)
      {
         success = MHEG5FALSE;
      }
      else
      {
         new_file->file_size = size;
         new_file->name_length = (U8BIT)fn.len;
         memcpy(new_file->name, fn.data, fn.len);
         new_file->name[fn.len] = 0;
         new_file->next = NULL;

         fp = STB_NVMOpenFile((U8BIT *) fn.data, FILE_MODE_OVERWRITE);
         if (fp)
         {
            STB_NVMWriteFile(fp, buf, size);
            STB_NVMCloseFile(fp);

            new_file->previous = file_list_newest;
            if (file_list_newest)
            {
               file_list_newest->next = new_file;
            }
            file_list_newest = new_file;
            if (!file_list_oldest)
            {
               file_list_oldest = new_file;
            }
            total_filesize += size;

            success = MHEG5TRUE;
         }
         else
         {
            STB_MemFree( new_file );
            success = MHEG5FALSE;
         }
      }
      /* Remove deleted files and add new file*/
      WriteChanges();

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

static void DeleteNvmFile(MHEG5NvmFile *file)
{
   if (file->previous)
   {
      file->previous->next = file->next;
   }
   else
   {
      file_list_oldest = file->next;
   }
   if (file->next)
   {
      file->next->previous = file->previous;
   }
   else
   {
      file_list_newest = file->previous;
   }
   STB_NVMDeleteFile(file->name);
   total_filesize -= file->file_size;

   STB_MemFree(file);
}

static void CreateFileList(U8BIT *encoded_list, U32BIT list_len)
{
   U32BIT offset = 0;
   U8BIT name_len;
   U32BIT file_size;
   MHEG5NvmFile *new_file;
   while (offset < list_len)
   {
      name_len = encoded_list[offset];
      offset++;

      file_size = encoded_list[offset];
      offset++;
      file_size += encoded_list[offset] << 8;
      offset++;
      file_size += encoded_list[offset] << 16;
      offset++;
      file_size += encoded_list[offset] << 24;
      offset++;

      new_file = STB_MemAlloc(sizeof(MHEG5NvmFile));
      if (new_file)
      {
         new_file->name_length = name_len;
         new_file->file_size = file_size;

         total_filesize += file_size;

         memcpy(new_file->name, encoded_list + offset, name_len);
         new_file->name[name_len] = '\0';
         offset += name_len;

         new_file->next = NULL;
         new_file->previous = file_list_newest;
         if (file_list_newest)
         {
            file_list_newest->next = new_file;
         }
         if (!file_list_oldest)
         {
            file_list_oldest = new_file;
         }
         file_list_newest = new_file;
      }
   }
}

static MHEG5Boolean WriteChanges(void)
{
   MHEG5NvmFile *current_file = file_list_oldest;
   void *file;
   MHEG5Bool success = MHEG5FALSE;
   file = STB_NVMOpenFile((U8BIT *) NVM_STORE_FILENAME, FILE_MODE_OVERWRITE);
   if (file != NULL)
   {
      while (current_file)
      {
         U8BIT buffer[5];
         buffer[0] = current_file->name_length;

         buffer[1] = current_file->file_size & 0xFF;
         buffer[2] = (current_file->file_size >> 8) & 0xFF;
         buffer[3] = (current_file->file_size >> 16) & 0xFF;
         buffer[4] = (current_file->file_size >> 24) & 0xFF;
         STB_NVMWriteFile(file, buffer, 5);
         STB_NVMWriteFile(file, current_file->name, current_file->name_length);

         current_file = current_file->next;
      }
      success = MHEG5TRUE;
      STB_NVMCloseFile( file );
   }
   return success;
}

void MHEG5nvmReset(void)
{
   MHEG5NvmFile *current_file = file_list_oldest;
   MHEG5NvmFile *next_file;
   while (current_file)
   {
      next_file = current_file->next;
      STB_MemFree(current_file);
      current_file = next_file;
   }
   file_list_oldest = NULL;
   file_list_newest = NULL;
   total_filesize = 0;
   init = MHEG5FALSE;

}