rfs.c

Go to the documentation of this file.

/***************************************************************************/
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>

#include "thunderboard/rfs/rfs.h"

#define debug_printf(x, ...)

/***************************************************************************/
/***************************************************************************/
extern const uint32_t RFS_fileCount;      
extern const uint8_t *RFS_fileNames[];    
extern const uint32_t RFS_fileLength[];   
extern const uint8_t *RFS_fileData[];     
/***************************************************************************/
/***************************************************************************/
uint32_t RFS_getFileCount( void )
{

   return RFS_fileCount;

}

/***************************************************************************/
int32_t RFS_getFileLengthByIndex( uint32_t index )
{

   if( index >= RFS_fileCount ) {
      return -1;
   }
   else {
      /*debug_printf(" fl = %d \n", RFS_fileLength[index] ); */
      return RFS_fileLength[index];
   }

}

/***************************************************************************/
int32_t RFS_getFileLength( RFS_FileHandle *fileHandle )
{

   return RFS_getFileLengthByIndex( fileHandle->fileIndex );

}

/***************************************************************************/
uint8_t *RFS_getFileNameByIndex( uint32_t index )
{

   if( index >= RFS_fileCount ) {
      return NULL ;
   }
   else {
      return (uint8_t *) RFS_fileNames[index];
   }

}

/***************************************************************************/
uint8_t *RFS_getFileName( RFS_FileHandle *fileHandle )
{

   return RFS_getFileNameByIndex( fileHandle->fileIndex );

}

/***************************************************************************/
int16_t RFS_getFileIndex( uint8_t name[] )
{

   int i;
   int ret;

   ret = -1;
   for( i = 0; i < RFS_getFileCount(); i++ ) {

      /*debug_printf("[%d]:  %s %s\n", i, name, RFS_getFileNameByIndex(i) );*/
      if( strncmp( (char const*) name, (char const *) RFS_getFileNameByIndex( i ), RFS_MAX_FILE_NAME_SIZE ) == 0 ) {
         ret = i;
         /*debug_printf("[%d]:  MATCH \n", ret );*/
         break;
      }

   }

   return ret;

}

/***************************************************************************/
int32_t RFS_fileOpen( RFS_FileHandle *fileHandle, uint8_t name[] )
{

   int index;

   index = RFS_getFileIndex( name );
   if( index < 0 )
      return index;

   fileHandle->fileIndex = index;
   fileHandle->currentIndex = 0;

   return 1;

}

/***************************************************************************/
int32_t RFS_fileSeek( RFS_FileHandle *fileHandle, int32_t offset, uint32_t whence )
{

   /* Check file handle state */

   /*printf("fI = %d    offset = %d   whence = %08Xh\n", fileHandle->currentIndex, offset, whence );*/

   if( whence == RFS_SEEK_SET ) {
      fileHandle->currentIndex = offset;
      /*printf( "fH->cI = %d\n",fileHandle->currentIndex );*/
   }
   else if( whence == RFS_SEEK_CUR ) {
      fileHandle->currentIndex += offset;
      /*printf( "fH->cI = %d\n",fileHandle->currentIndex );*/
   }
   else if( whence == RFS_SEEK_END ) {
      fileHandle->currentIndex = ( RFS_getFileLengthByIndex( fileHandle->fileIndex ) + offset );
      /*printf( "fH->cI = %d\n",fileHandle->currentIndex );*/
   }
   else {
      return -1;
   }

   /* Check for out of bounds error on index before returning */

   return fileHandle->currentIndex;

}

/***************************************************************************/
int32_t RFS_fileRead( uint8_t *buf, uint32_t size, uint32_t nmemb, RFS_FileHandle *fileHandle )
{

   int32_t i;
   int32_t fileIndex = -1;
   uint32_t byteIndex;
   uint32_t totalByteCount;
   uint8_t *src = (uint8_t *) -1, *dst = (uint8_t *) -1, *end = (uint8_t *) -1;

   /* Get file index */
   fileIndex = fileHandle->fileIndex;
   debug_printf("RFS_fileRead(): fileIndex = %d \n", fileIndex );

   if( fileIndex < 0 ) {
      return fileIndex;
   }

   if( fileIndex >= RFS_getFileCount() ) {
      return -1;
   }

   /* Find data index */
   byteIndex = fileHandle->currentIndex;

   src = (unsigned char *) RFS_fileData[fileIndex];
   src += byteIndex;

   debug_printf(" endindex = %d\n", RFS_getFileLengthByIndex(fileIndex) );

   end = (unsigned char *) RFS_fileData[fileIndex];
   end += RFS_getFileLengthByIndex( fileIndex ) - 1;

   dst = (uint8_t *) buf;
   debug_printf("RFS_fileRead():  byteIndex = %d    src = %08Xh    end = %08Xh    dst = %08Xh   \n",
         byteIndex, src, end, dst );

   totalByteCount = size * nmemb;

   for( i = 0; ( i < totalByteCount ) && ( src <= end ); i++ )
      *dst++ = *src++;

   debug_printf("RFS_fileRead(): Bytes copied: %d [%d]\n", i, totalByteCount );

   fileHandle->currentIndex += i;

   return 1;

}

/***************************************************************************/
uint8_t *RFS_fileGetRawData( RFS_FileHandle *fileHandle )
{

   int32_t fileIndex = -1;

   /* Get file index */
   fileIndex = fileHandle->fileIndex;
   if( fileIndex < 0 )
      return 0;
   if( fileIndex >= RFS_getFileCount() )
      return 0;

   return (unsigned char *) RFS_fileData[fileIndex];

}