mh5fsnvm.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2010 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 <stdio.h>
#include <assert.h>
#include <string.h>

#include <glue_memory.h>
#include <glue_queue.h>

#include "mh5date.h"

#include "mh5fsnvm.h"

#include "mherrors.h"
#include "techtype.h"
#include "dvb_service.h"

#include "stb_nvm.h"

#ifdef INCLUDE_FREESAT

/*---constant definitions for this file--------------------------------------*/
#ifndef NVM_STORAGE_MAX
#define NVM_STORAGE_MAX (256 * 1024)
#endif
#define HEADER_SIZE 7

#ifndef NVM_STORAGE_DIRECTORY
#define NVM_STORAGE_DIRECTORY "nvm/"
#endif
#define NVM_STORAGE_DIRECTORY_LEN strlen(NVM_STORAGE_DIRECTORY)

#define MAX_PATH_LEN             64


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

typedef struct s_nvm_file
{
   MHEG5String fn;
   void *data;
   MHEG5Bool stored;
   MHEG5Int data_len;
   MHEG5Int expires;
   MHEG5Int priority;
   MHEG5Int last_accessed;
   MHEG5Int score;
   struct s_nvm_allocation *allocation;
   struct s_nvm_file *next;
   struct s_nvm_file *previous;
} S_NVM_FILE;

typedef struct s_nvm_allocation
{
   U16BIT id;
   MHEG5Int size;
   MHEG5Int used;
   S_NVM_FILE *first_file;
   struct s_nvm_allocation *next;
   struct s_nvm_allocation *previous;
} S_NVM_ALLOCATION;

/*---local (static) variable declarations for this file----------------------*/
static MHEG5Bool init = MHEG5FALSE;
static MHEG5Bool store_open = MHEG5FALSE;
static S_NVM_ALLOCATION *allocation_list = NULL;
static S_NVM_ALLOCATION scratchpad;
static MHEG5Int total_stored = 0;

/*---local function prototypes for this file---------------------------------*/
static MHEG5String* CreateStorageFilename(MHEG5String fn, U16BIT allocation_id);
static MHEG5Bool WriteToFile(S_NVM_FILE *file);
static MHEG5Bool CheckFreeSpace(S_NVM_FILE *file);
static MHEG5Bool CheckAllocationSize(S_NVM_FILE *file);
static U16BIT ConvertPathToId(MHEG5String fn);
static void InitStore(void);
static void OpenNvmStore(void);
static S_NVM_FILE* FindFile(MHEG5String filename, U16BIT allocation_id);
static MHEG5Bool RemoveFileFromCache(S_NVM_FILE *file_entry);
static MHEG5Bool DeleteFile(S_NVM_FILE *file_entry);
static MHEG5Bool MoveFileToScratch(S_NVM_FILE *file);
static S_NVM_FILE* CreateFile(void *data, MHEG5Int len, MHEG5String *filename,
   U16BIT allocation_id, U32BIT priority);
static MHEG5Bool ReadFromFile(void **data, MHEG5Int *len, S_NVM_FILE *file);
static void CalculateFileScore(S_NVM_FILE *file);
static S_NVM_ALLOCATION* GetAllocationFromId(U16BIT allocation_id);
static void CheckUpdatedAllocation(S_NVM_ALLOCATION *allocation);
static void CacheFile(char *file_name);
static void UpdateHeader( S_NVM_FILE *file);
static void ParseFileHeader(U8BIT *header_data, S_NVM_FILE *file);
static U32BIT FilenameToId(MHEG5String string);
static void ClearFileDataCache(void);
/*---global function definitions---------------------------------------------*/

MHEG5Bool MHEG5FSnvmRead(MHEG5String fn, void **data, MHEG5Int *len,
   MHEG5Int *expires, MHEG5Int *priority)
{
   MHEG5Bool success = MHEG5FALSE;
   MHEG5String *new_filename = NULL;
   U16BIT allocation_id;
   S_NVM_FILE *file;
   //int i;

   if (!init)
   {
      return MHEG5FALSE;
   }

   OpenNvmStore();
   if (fn.len)
   {
      allocation_id = ConvertPathToId(fn);

      new_filename = CreateStorageFilename(fn, allocation_id);
      if (new_filename)
      {
         file = FindFile(*new_filename, allocation_id);
         if (file)
         {
            *priority = file->priority;
            *expires = file->expires;
            success = ReadFromFile(data, len, file);
         }
      }
   }

   return success;
}

MHEG5Bool MHEG5FSnvmWrite(MHEG5String fn, void *data, MHEG5Int len,
   MHEG5Int expires, MHEG5Int priority)
{
   MHEG5Bool success = MHEG5FALSE;
   MHEG5String *new_filename = NULL;
   U16BIT allocation_id;
   MHEG5Int file_priority = priority;
   S32BIT today, throwaway;
   S_NVM_FILE *file;
   //int i;

   if (!init)
   {
      return MHEG5FALSE;
   }

   OpenNvmStore();

   MHEG5getDate(&today, &throwaway);
   allocation_id = ConvertPathToId(fn);
   if (allocation_id == 0xffff)
   {
      /*if the allocation_id was invalid or the current service isn't assigned to it
         FAIL*/
      return MHEG5FALSE;
   }
   new_filename = CreateStorageFilename(fn, allocation_id);
   if (new_filename)
   {
      if (expires)
      {
         file = CreateFile(data, len, new_filename, allocation_id, file_priority);
         if (file)
         {
            file->expires = expires;
            file->last_accessed = today;
            if (CheckAllocationSize(file))
            {
               if (CheckFreeSpace(file))
               {
                  success = WriteToFile(file);
               }
            }
            if (!success)
            {
               RemoveFileFromCache(file);
            }
         }
      }
      else
      {
         file = FindFile(*new_filename, allocation_id);
         if (file)
         {
            success = DeleteFile(file);
         }
      }
   }

   ClearFileDataCache();
   return success;
}

static MHEG5Bool WriteToFile(S_NVM_FILE *file)
{
   void *nvm_file;
   U32BIT bytes_written = 0;
   MHEG5Bool success;

   assert(file);

   /* create header from metadata */
   UpdateHeader(file);

   
   nvm_file = STB_NVMOpenFile(file->fn.data, FILE_MODE_OVERWRITE );
   if (nvm_file)
   {
      bytes_written = STB_NVMWriteFile(nvm_file, file->data, HEADER_SIZE + file->data_len);

      STB_NVMCloseFile(nvm_file);
   }

   if (bytes_written == HEADER_SIZE + file->data_len)
   {
      success = MHEG5TRUE;
   }
   else
   {
      success = MHEG5FALSE;
   }
   return success;
}

static U16BIT ConvertPathToId(MHEG5String fn)
{
   U16BIT current_identifier;
   int i, shift;
   BOOLEAN ok;
   if (!MHEG5strncmp(fn.data, "svc/", 4))
   {
      if (DVB_MhegGetCurrentFSI(&current_identifier) == MHERR_OK)
      {
         return current_identifier;
      }
   }
   else
   {
      current_identifier = 0;
      shift = 12;
      for (i = 0; i < 4; i++)
      {
         if (fn.data[i] >= 'a' && fn.data[i] <= 'f')
         {
            current_identifier += (fn.data[i] + 0xa - 'a') << shift;
         }
         else if (fn.data[i] >= '0' && fn.data[i] <= '9')
         {
            current_identifier += (fn.data[i] - '0') << shift;
         }
         else
         {
            return 0xFFFF;
         }
         shift -= 4;
      }

      if (current_identifier > 0x8000)
      {
         return 0xFFFF;
      }
      else
      {
         DVB_MhegCurrentServiceIsInGroup(current_identifier, &ok);

         if (ok)
         {
            current_identifier |= 0x8000; /*using top bit to indicate a group*/
         }
         else
         {
            current_identifier = 0xffff;
         }
      }
   }
   return current_identifier;
}

static MHEG5Bool CheckFreeSpace(S_NVM_FILE *file)
{
   S_NVM_FILE *file_cursor;
   S_NVM_FILE *lowest_scored_file = NULL;

   assert(file);
   while (total_stored > NVM_STORAGE_MAX && scratchpad.first_file)
   {
      file_cursor = scratchpad.first_file;
      while (file_cursor)
      {
         if (file_cursor == file)
         {
            file_cursor = file_cursor->next;
            continue;
         }

         CalculateFileScore(file_cursor);
         if (!lowest_scored_file)
         {
            lowest_scored_file = file_cursor;
         }
         else if (lowest_scored_file->score > file_cursor->score)
         {
            lowest_scored_file = file_cursor;
         }

         file_cursor = file_cursor->next;
      }

      if (lowest_scored_file)
      {
         DeleteFile(lowest_scored_file);
      }
   }
   if (total_stored <= NVM_STORAGE_MAX)
   {
      return MHEG5TRUE;
   }
   else
   {
      return MHEG5FALSE;
   }
}

static MHEG5Bool CheckAllocationSize(S_NVM_FILE *file)
{
   S_NVM_ALLOCATION *allocation;
   S_NVM_FILE *file_cursor;
   S_NVM_FILE *next_file;

   assert(file);

   /*check if the file has an allocation region set*/
   allocation = file->allocation;
   if (allocation)
   {
      CalculateFileScore(file);
      if (file->allocation == &scratchpad)
      {
         return MoveFileToScratch(file);
      }

      /*if the file will fit into the allocation without moving anything*/
      if (allocation->size >= allocation->used)
      {
         return MHEG5TRUE;
      }
      /*if it is within the total allocation size*/
      else if (file->data_len <= allocation->size)
      {
         /*remove expired files*/
         file_cursor = allocation->first_file;
         while (file_cursor && allocation->size < allocation->used)
         {
            CalculateFileScore(file_cursor);
            next_file = file_cursor->next;
            if (file_cursor != file && !file_cursor->score)
            {
               DeleteFile(file_cursor);
            }
            file_cursor = next_file;
         }
         /*if it still doesn't fit try moving files to scratch*/
         file_cursor = allocation->first_file;
         while (file_cursor && allocation->size < allocation->used)
         {
            next_file = file_cursor->next;
            if (file_cursor != file && file_cursor->score < file->score)
            {
               MoveFileToScratch(file_cursor);
            }
            file_cursor = next_file;
         }
         /*if it still doesn't fit*/
         if (allocation->size < allocation->used)
         {
            file->priority = 0;
            CalculateFileScore(file);
            return MoveFileToScratch(file);
         }
      }
      /*if it is too big for the allocation it must not save at all*/
      else
      {
         RemoveFileFromCache(file);
         return MHEG5FALSE;
      }
   }


   return MHEG5TRUE;
}

static MHEG5String* CreateStorageFilename(MHEG5String fn, U16BIT allocation_id)
{
   MHEG5String *new_fn = NULL;
   int i, shift;
   int name_start;

   for (name_start = 0; name_start < fn.len; name_start++)
   {
      if (fn.data[name_start] == '/')
      {
         name_start++;
         break;
      }
   }
   /*check that the filename is within the 1-8 characters length limit*/
   if (fn.len > name_start && fn.len <= name_start + 7)
   {
      new_fn = MHEG5getMem(sizeof(MHEG5String));
   }
   if (new_fn)
   {
      new_fn->len = fn.len + 5 - name_start;
      new_fn->len += NVM_STORAGE_DIRECTORY_LEN;
      new_fn->data = MHEG5getMem(new_fn->len + NVM_STORAGE_DIRECTORY_LEN + 1);

      if (!new_fn->data)
      {
         MHEG5freeMem(new_fn);
         new_fn = NULL;
      }
      else
      {
         memcpy(new_fn->data, NVM_STORAGE_DIRECTORY, NVM_STORAGE_DIRECTORY_LEN);
         shift = 12;
         for (i = NVM_STORAGE_DIRECTORY_LEN; i != NVM_STORAGE_DIRECTORY_LEN + 4; i++)
         {
            new_fn->data[i] = (allocation_id >> shift) & 0xf;
            if (new_fn->data[i] > 9)
            {
               new_fn->data[i] += 'a' - 0xa;
            }
            else
            {
               new_fn->data[i] += '0';
            }
            shift -= 4;
         }
         new_fn->data[i++] = '_';
         memcpy( &new_fn->data[i], &fn.data[name_start], fn.len - name_start);
         new_fn->data[new_fn->len] = '\0';
      }
   }


   return new_fn;
}

static void InitStore(void)
{
   if (!init)
   {
      assert(!allocation_list);

      scratchpad.id = 0xffff;
      scratchpad.size = NVM_STORAGE_MAX;
      scratchpad.used = 0;
      scratchpad.first_file = NULL;
      scratchpad.next = NULL;
      scratchpad.previous = NULL;
      total_stored = 0;
      init = MHEG5TRUE;
   }
}

static void OpenNvmStore(void)
{
   char *file_name;
   void *directory_handle;
   E_STB_DIR_ENTRY_TYPE file_type;
   if (!init)
   {
      return;
   }

   if (!store_open)
   {
      directory_handle = STB_NVMOpenDirectory((U8BIT *)NVM_STORAGE_DIRECTORY);
      if (directory_handle)
      {
         file_name = MHEG5getMem(MAX_PATH_LEN);
         memcpy(file_name, NVM_STORAGE_DIRECTORY, NVM_STORAGE_DIRECTORY_LEN);
         while (STB_NVMReadDirectory(directory_handle,
                   (U8BIT *)file_name + NVM_STORAGE_DIRECTORY_LEN, MAX_PATH_LEN - NVM_STORAGE_DIRECTORY_LEN, &file_type))
         {
            if (file_type == DIR_ENTRY_FILE)
            {
               CacheFile(file_name);
            }
            memcpy(file_name, NVM_STORAGE_DIRECTORY, NVM_STORAGE_DIRECTORY_LEN);
         }
         MHEG5freeMem(file_name);
      }
      store_open = MHEG5TRUE;
   }
}

void MHEG5FSnvmStoreOpen(void)
{
   InitStore();
}

void MHEG5FSnvmStoreClose(void)
{
   S_NVM_ALLOCATION *allocation;
   S_NVM_ALLOCATION *next_allocation;
   S_NVM_FILE *file;
   S_NVM_FILE *next_file;


   init = MHEG5FALSE;
   store_open = MHEG5FALSE;
   allocation = allocation_list;
   while (allocation)
   {
      next_allocation = allocation->next;
      file = allocation->first_file;
      while (file)
      {
         next_file = file->next;

         RemoveFileFromCache(file);

         file = next_file;
      }
      MHEG5freeMem(allocation);
      allocation = next_allocation;
   }
   file = scratchpad.first_file;
   while (file)
   {
      next_file = file->next;

      RemoveFileFromCache(file);

      file = next_file;
   }
   scratchpad.first_file = NULL;
   allocation_list = NULL;
   total_stored = 0;
}

static S_NVM_FILE* FindFile(MHEG5String filename, U16BIT allocation_id)
{
   S_NVM_ALLOCATION *allocation;
   S_NVM_FILE *file_cursor = NULL;


   /*try to find the storage allocation*/
   allocation = GetAllocationFromId(allocation_id);

   /*if it was found search for the file in it*/
   if (allocation)
   {
      file_cursor = allocation->first_file;
      while (file_cursor && !MHEG5stringEqual(&file_cursor->fn, &filename))
      {
         file_cursor = file_cursor->next;
      }
   }
   /*if the file hasn't been found yet, it could be in scratch*/
   if (!file_cursor)
   {
      allocation = &scratchpad;
      file_cursor = scratchpad.first_file;
      while (file_cursor && !MHEG5stringEqual(&file_cursor->fn, &filename))
      {
         file_cursor = file_cursor->next;
      }
   }
   return file_cursor;
}

static MHEG5Bool RemoveFileFromCache(S_NVM_FILE *file_entry)
{
   file_entry->allocation->used -= file_entry->data_len;
   total_stored -= file_entry->data_len;
   if (file_entry->data)
   {
      MHEG5freeMem(file_entry->data);
   }
   MHEG5freeMem(file_entry->fn.data);

   if (!file_entry->previous)
   {
      file_entry->allocation->first_file = file_entry->next;
   }
   else
   {
      file_entry->previous->next = file_entry->next;
   }
   if (file_entry->next)
   {
      file_entry->next->previous = file_entry->previous;
   }
   MHEG5freeMem(file_entry);
   return MHEG5TRUE;
}

static MHEG5Bool DeleteFile(S_NVM_FILE *file_entry)
{
   MHEG5Bool success = MHEG5FALSE;

   assert(file_entry);

   if (STB_NVMDeleteFile(file_entry->fn.data))
   {
      success = RemoveFileFromCache(file_entry);
   }

   return success;
}

static MHEG5Bool MoveFileToScratch(S_NVM_FILE *file)
{
   S_NVM_ALLOCATION *allocation;
   S_NVM_FILE *file_cursor;
   S_NVM_FILE *lowest_file;
   MHEG5Int lowest_score = 0x7fffffff;
   void *temp_file = NULL;
   U32BIT bytes_read = 0;

   assert(file);

   allocation = file->allocation; /*shorthand*/
   file->priority = 0;

   /*if the file isn't allocated to the scratchpad yet, move it in*/
   /*(it is possible that it is already on scratchpad, but needs reallocating)*/
   if (allocation != &scratchpad)
   {
      /*if the file being moved is already stored in NVM
         it needs to be updated*/
      if (file->stored)
      {
         /*if only the metadata is cached, re-read the file data*/
         if (!file->data)
         {
            file->data = MHEG5getMem(file->data_len + HEADER_SIZE);
            if (file->data)
            {
               temp_file = STB_NVMOpenFile(file->fn.data, FILE_MODE_READ );
            }
            if (temp_file)
            {
               bytes_read = STB_NVMReadFile( temp_file, file->data, file->data_len + HEADER_SIZE);
               STB_NVMCloseFile(temp_file);
            }
            if (file->data && bytes_read != file->data_len + HEADER_SIZE)
            {
               MHEG5freeMem(file->data);
               file->data = NULL;
            }
         }
         /*if the file data is cached, rewrite the file with the new metadata*/
         if (file->data)
         {
            WriteToFile(file);
         }
      }


      if (file->previous)
      {
         file->previous->next = file->next;
      }
      else
      {
         allocation->first_file = file->next;
      }
      if (file->next)
      {
         file->next->previous = file->previous;
      }
      allocation->used -= file->data_len;
      total_stored -= file->data_len;
      file->allocation = &scratchpad;
      file->previous = NULL;
      file->next = scratchpad.first_file;
      if (scratchpad.first_file)
      {
         scratchpad.first_file->previous = file;
      }
      scratchpad.first_file = file;
      scratchpad.used += file->data_len;
      total_stored += file->data_len;
   }

   /*if there is a scratchpad overflow*/
   while (scratchpad.size < scratchpad.used)
   {
      /*find the lowest scored file*/
      file_cursor = scratchpad.first_file;
      lowest_score = -1;
      lowest_file = NULL;
      while (file_cursor)
      {
         if (file_cursor->stored && file_cursor->score < lowest_score)
         {
            lowest_score = file_cursor->score;
            lowest_file = file_cursor;
         }
         file_cursor = file_cursor->next;
      }
      if (lowest_file)
      {
         DeleteFile(lowest_file);
      }
      else
      {
         RemoveFileFromCache(file);
         return MHEG5FALSE;
      }
   }

   return MHEG5TRUE;
}

static S_NVM_FILE* CreateFile(void *data, MHEG5Int len, MHEG5String *filename,
   U16BIT allocation_id, U32BIT priority)
{
   S_NVM_FILE *file_entry = NULL;
   S_NVM_ALLOCATION *allocation;
   S_NVM_ALLOCATION *old_allocation;

   allocation = GetAllocationFromId(allocation_id);
   if (!allocation || allocation->size < len + HEADER_SIZE)
   {
      return NULL;
   }

   file_entry = FindFile(*filename, allocation_id);
   if (!file_entry)
   {   /* new file */
      if (!priority)
      {
         allocation = &scratchpad;
      }

      if (allocation)
      {
         file_entry = MHEG5getMem(sizeof(S_NVM_FILE));
         if (file_entry)
         {
            file_entry->data = MHEG5getMem(len + HEADER_SIZE);
            if (file_entry->data)
            {
               memcpy((U8BIT *)file_entry->data + HEADER_SIZE, data, len);
            }
            file_entry->fn.data = filename->data;
            file_entry->fn.len = filename->len;
            file_entry->allocation = allocation;
            file_entry->data_len = len;
            file_entry->priority = priority;
            file_entry->previous = NULL;
            file_entry->stored = MHEG5FALSE;
            if (allocation->first_file)
            {
               allocation->first_file->previous = file_entry;
            }
            file_entry->next = allocation->first_file;

            allocation->first_file = file_entry;
            allocation->used += len;
            total_stored += len;
         }
      }
   }
   else
   {
      if (!file_entry->priority)
      {
         old_allocation = &scratchpad;
      }
      else
      {
         old_allocation = allocation;
      }
      old_allocation->used -= file_entry->data_len;
      total_stored -= file_entry->data_len;
      file_entry->data_len = len;
      file_entry->priority = priority;
      file_entry->data = MHEG5getMem(len + HEADER_SIZE);

      if (!priority)
      {
         allocation = &scratchpad;
      }
      /*move the file to a different allocation*/
      if (old_allocation != allocation)
      {
         if (file_entry->next)
         {
            file_entry->next->previous = file_entry->previous;
         }

         if (file_entry->previous)
         {
            file_entry->previous->next = file_entry->next;
         }
         if (old_allocation->first_file == file_entry)
         {
            old_allocation->first_file = file_entry->next;
         }

         file_entry->previous = NULL;
         file_entry->next = allocation->first_file;
         allocation->first_file = file_entry;
         file_entry->allocation = allocation;
      }
      allocation->used += len;
      total_stored += len;

      if (file_entry->data)
      {
         memcpy((U8BIT *)file_entry->data + HEADER_SIZE, data, len);
      }
   }
   return file_entry;
}

static MHEG5Bool ReadFromFile(void **data, MHEG5Int *len, S_NVM_FILE *file)
{
   void *nvm_file;
   MHEG5Bool success = MHEG5FALSE;
   assert(file);

   if (file->data)
   {
      *len = file->data_len;
      *data = (U8BIT *)file->data + HEADER_SIZE;
      success = MHEG5TRUE;
   }
   else
   {
      file->data = MHEG5getMem(file->data_len + HEADER_SIZE);
      nvm_file = STB_NVMOpenFile(file->fn.data, FILE_MODE_READ );
      if (nvm_file)
      {
         STB_NVMReadFile(nvm_file, file->data, file->data_len + HEADER_SIZE);
         *len = file->data_len;
         *data = (U8BIT *)file->data + HEADER_SIZE;
         success = MHEG5TRUE;
         STB_NVMCloseFile(nvm_file);
      }
   }
   return success;
}

static void CalculateFileScore(S_NVM_FILE *file)
{
   S32BIT today, second;

   MHEG5getDate(&today, &second);
   if (file->expires <= today)
   {
      file->score = 0;
   }
   else
   {
      file->score = file->priority * 30;
      file->score += file->last_accessed;
   }
}

static void NotifyUpdateServiceAllocation( U16BIT identifier, BOOLEAN groupNotService,
   U8BIT blockSize, U8BIT blocks )
{
   S_NVM_ALLOCATION *allocation;
   U16BIT allocation_id;
   MHEG5Int size;
   int i;

   if (!init)
   {
      return;
   }

   /*simple 2^blockSize*/
   size = 1;
   for (i = 0; i < blockSize; i++)
   {
      size *= 2;
   }
   size *= blocks;

   allocation_id = identifier;
   if (groupNotService)
   {
      allocation_id |= 0x8000;
   }
   allocation = GetAllocationFromId(allocation_id);
   if (allocation)
   {
      allocation->size = size;
   }
   else
   {
      if (size <= NVM_STORAGE_MAX)
      {
         allocation = MHEG5getMem(sizeof(S_NVM_ALLOCATION));
      }

      if (allocation)
      {
         allocation->size = size;
         allocation->used = 0;
         allocation->id = allocation_id;
         allocation->first_file = NULL;
         allocation->next = allocation_list;
         allocation->previous = NULL;
         allocation_list = allocation;
      }
      else
      {
         return;
      }
   }

   if (store_open)
   {
      CheckUpdatedAllocation(allocation);
   }
}

static void UpdateStorageAllocation( MHEG5FsStorageParams_t *params )
{
   NotifyUpdateServiceAllocation( params->identifier, params->group,
      params->blockSize, params->blocks );
}

E_MhegErr MHEG5_NotifyStorageChanged( U16BIT identifier, BOOLEAN groupNotService,
   U8BIT blockSize, U8BIT blocks )
{
   S_MhegMessage event_msg;
   event_msg.proc_msg_func = (F_MSG_PROCESS)UpdateStorageAllocation;
   event_msg.data_type = DT_VALUE;
   event_msg.data.fsStorage.blockSize = blockSize;
   event_msg.data.fsStorage.blocks = blocks;
   event_msg.data.fsStorage.group = groupNotService;
   event_msg.data.fsStorage.identifier = identifier;
   return VQ_PutMsg(&event_msg, PRTY_NORMAL);
}

static void CheckUpdatedAllocation(S_NVM_ALLOCATION *allocation)
{
   S_NVM_FILE *file_cursor;
   S_NVM_FILE *lowest_file;


   file_cursor = allocation->first_file;
   while (file_cursor)
   {
      if (file_cursor->data_len > allocation->size)
      {
         S_NVM_FILE *temp_next = file_cursor->next;
         DeleteFile(file_cursor);
         file_cursor = temp_next;
      }
      else
      {
         file_cursor = file_cursor->next;
      }
   }

   /*while the allocation is now too small to hold the files stored*/
   while (allocation->used > allocation->size)
   {
      /*move the lowest scored file to scratch*/
      file_cursor = allocation->first_file;
      lowest_file = NULL;
      while (file_cursor)
      {
         if (!lowest_file || file_cursor->score < lowest_file->score)
         {
            lowest_file = file_cursor;
         }
         file_cursor = file_cursor->next;
      }
      if (lowest_file)
      {
         MoveFileToScratch(lowest_file);
      }
      else
      {
         /*somehow there are no files stored, but used space > total allocated*/
         assert(0);
      }
   }



   if (scratchpad.used > scratchpad.size)
   {
      /*slight hack, but this function does what is necessary.*/
      MoveFileToScratch(scratchpad.first_file);
   }
}

static S_NVM_ALLOCATION* GetAllocationFromId(U16BIT allocation_id)
{
   S_NVM_ALLOCATION *allocation;

   allocation = allocation_list;
   while (allocation && allocation->id != allocation_id)
   {
      allocation = allocation->next;
   }
   return allocation;
}

static void CacheFile(char *file_name)
{
   void *nvm_file = NULL;
   U32BIT bytes_read = 0;
   U8BIT *header_data = NULL;
   S_NVM_ALLOCATION *allocation;
   S_NVM_FILE *new_file = NULL;

   U32BIT allocation_id;

   /*open the file for reading and take a copy of the filename*/
   nvm_file = STB_NVMOpenFile( (U8BIT *)file_name, FILE_MODE_READ );
   if (nvm_file)
   {
      new_file = MHEG5getMem(sizeof(S_NVM_FILE));
      if (new_file)
      {
         new_file->fn.data = MHEG5getMem(strlen(file_name) + 1);
         if (new_file->fn.data)
         {
            new_file->fn.len = strlen(file_name);
            memcpy(new_file->fn.data, file_name, new_file->fn.len + 1);

            header_data = MHEG5getMem(HEADER_SIZE);
         }
         else
         {
            MHEG5freeMem(new_file);
         }
      }
      /*read the file*/
      if (header_data)
      {
         bytes_read = STB_NVMReadFile( nvm_file, header_data, HEADER_SIZE);
      }
      if (bytes_read == HEADER_SIZE)
      {
         /*parse the header from the file data into the cache fields*/
         ParseFileHeader(header_data, new_file);

         new_file->data = NULL;
         new_file->stored = MHEG5TRUE;
         new_file->previous = NULL;
         allocation_id = FilenameToId(new_file->fn);
         if (allocation_id)
         {
            allocation = GetAllocationFromId(allocation_id);
            if (!allocation)
            {
               allocation = &scratchpad;
               new_file->priority = 0;
            }

            new_file->next = allocation->first_file;
            allocation->first_file = new_file;
            if (new_file->next)
            {
               new_file->next->previous = new_file;
            }
            new_file->allocation = allocation;
            allocation->used += new_file->data_len;
            total_stored += new_file->data_len;
         }
         CalculateFileScore(new_file);
      }
      if (header_data)
         MHEG5freeMem(header_data);

      STB_NVMCloseFile( nvm_file );
   }
}

static void UpdateHeader( S_NVM_FILE *file)
{
   U8BIT *header_data;

   header_data = file->data;
   if (header_data)
   {
      header_data[0] = (file->expires) & 0xff;
      header_data[1] = (file->expires >> 8) & 0xff;
      header_data[2] = (file->expires >> 16) & 0x01;
      header_data[2] |= (file->last_accessed << 1) & 0xfe;
      header_data[3] = (file->last_accessed >> 7) & 0xff;
      header_data[4] = (file->last_accessed >> 15) & 0x3;
      header_data[4] |= (file->priority << 2) & 0xc;
      header_data[5] = (file->data_len) & 0xff;
      header_data[6] = (file->data_len >> 8) & 0xff;
   }
}

static void ParseFileHeader(U8BIT *header_data, S_NVM_FILE *file)
{
   U32BIT buffer;

   assert(file);
   buffer = header_data[0];
   buffer |= header_data[1] << 8;
   buffer |= (header_data[2] << 16) & 0x10000;
   file->expires = buffer;

   buffer = header_data[2] >> 1;
   buffer |= (header_data[3] << 7) & 0x7f00;
   buffer |= (header_data[4] << 15) & 0x18000;
   file->last_accessed = buffer;

   buffer = (header_data[4] >> 2) & 0x3;
   file->priority = buffer;

   buffer = header_data[5];
   buffer |= (header_data[6] << 8) & 0xff00;
   file->data_len = buffer;
}

static U32BIT FilenameToId(MHEG5String string)
{
   U32BIT rc = 0;
   int i;

   if (!string.len)
      return 0;
   else    /* HEX INT  */
   {
      for (i = 0; i < 4; i++)
         if ((string.data[i] >= '0') && (string.data[i] <= '9'))
            rc = rc * 16 + ((int) string.data[i] - (int) '0');
         else if ((string.data[i] >= 'a') && (string.data[i] <= 'z'))
            rc = rc * 16 + ((int) string.data[i] - (int) 'a') + 10;
         else if ((string.data[i] >= 'A') && (string.data[i] <= 'Z'))
            rc = rc * 16 + ((int) string.data[i] - (int) 'A') + 10;
         else
            break;
      return rc;
   }
}

static void ClearFileDataCache(void)
{
   S_NVM_ALLOCATION *allocation_cursor;
   S_NVM_FILE *file_cursor;

   allocation_cursor = allocation_list;

   while (allocation_cursor)
   {
      file_cursor = allocation_cursor->first_file;
      while (file_cursor)
      {
         if (file_cursor->data && file_cursor->stored)
         {
            MHEG5freeMem(file_cursor->data);
            file_cursor->data = NULL;
         }
         file_cursor = file_cursor->next;
      }
      allocation_cursor = allocation_cursor->next;
   }

   if (scratchpad.first_file)
   {
      file_cursor = scratchpad.first_file;
      while (file_cursor)
      {
         if (file_cursor->data && file_cursor->stored)
         {
            MHEG5freeMem(file_cursor->data);
            file_cursor->data = NULL;
         }
         file_cursor = file_cursor->next;
      }
   }
}

#endif /*INCLUDE_FREESAT*/