/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
******************************************************************************
* @file M4OSA_FileReader_optim.c
* @brief
* @note This file implements functions to manipulate filesystem access
******************************************************************************
*/
/** Addition of Trace ID **/
#include "M4OSA_CoreID.h"
#include "M4OSA_Error.h"
#ifdef M4TRACE_ID
#undef M4TRACE_ID
#endif
#define M4TRACE_ID M4OSA_FILE_READER
#include "M4OSA_FileCommon.h"
#include "M4OSA_FileReader.h"
#include "M4OSA_FileWriter.h"
#include "M4OSA_Memory.h"
#include "M4OSA_Debug.h"
#include "LVOSA_FileReader_optim.h"
#define M4OSA_READER_OPTIM_USE_OSAL_IF
#ifndef M4OSA_READER_OPTIM_USE_OSAL_IF
#include "M4OSA_FileAccess.h"
#endif
#define M4ERR_CHECK_NULL_RETURN_VALUE(retval, pointer) if ((pointer) == M4OSA_NULL) return (retval);
/**
******************************************************************************
* File reader cache buffers parameters (size, number of buffers, etc)
******************************************************************************
*/
#define M4OSA_READBUFFER_SIZE 1024*16
#define M4OSA_READBUFFER_NB 2
#define M4OSA_READBUFFER_NONE -1
#define M4OSA_EOF -1
#define MAX_FILLS_SINCE_LAST_ACCESS M4OSA_READBUFFER_NB*2
/**
******************************************************************************
* structure M4OSA_FileReader_Buffer
* @brief This structure defines the File reader Buffers context (private)
******************************************************************************
*/
typedef struct
{
M4OSA_MemAddr8 data; /**< buffer data */
M4OSA_FilePosition size; /**< size of the buffer */
M4OSA_FilePosition filepos; /**< position in the file where the buffer starts */
M4OSA_FilePosition remain; /**< data amount not already copied from buffer */
M4OSA_UInt32 nbFillSinceLastAcess; /**< To know since how many time we didn't use this buffer */
} M4OSA_FileReader_Buffer_optim;
/**
******************************************************************************
* structure M4OSA_FileReader_Context
* @brief This structure defines the File reader context (private)
* @note This structure is used for all File Reader calls to store the context
******************************************************************************
*/
typedef struct
{
M4OSA_Bool IsOpened; /**< Micro state machine */
M4OSA_FileAttribute FileAttribute; /**< Opening mode */
M4OSA_FilePosition readFilePos; /**< Effective position of the GFL read pointer */
M4OSA_FilePosition absolutePos; /**< Virtual position for next reading */
M4OSA_FilePosition fileSize; /**< Size of the file */
M4OSA_FileReader_Buffer_optim buffer[M4OSA_READBUFFER_NB]; /**< Read buffers */
M4OSA_Void* aFileDesc; /**< File descriptor */
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
M4OSA_FileReadPointer* FS; /**< Filesystem interface */
#else
M4OSA_FileSystem_FctPtr *FS; /**< Filesystem interface */
#endif
} M4OSA_FileReader_Context_optim;
/* __________________________________________________________ */
/*| |*/
/*| Global function for handling low level read access |*/
/*|__________________________________________________________|*/
static M4OSA_FileReadPointer* gv_NXPSW_READOPT_lowLevelFunctions;
M4OSA_ERR NXPSW_FileReaderOptim_init(M4OSA_Void *lowLevel_functionPointers, M4OSA_Void *optimized_functionPointers)
{
M4OSA_FileReadPointer* lowLevel_fp = (M4OSA_FileReadPointer*) lowLevel_functionPointers;
M4OSA_FileReadPointer* optimized_fp = (M4OSA_FileReadPointer*) optimized_functionPointers;
//Set the optimized functions, to be called by the user
optimized_fp->openRead = M4OSA_fileReadOpen_optim;
optimized_fp->readData = M4OSA_fileReadData_optim;
optimized_fp->seek = M4OSA_fileReadSeek_optim;
optimized_fp->closeRead = M4OSA_fileReadClose_optim;
optimized_fp->setOption = M4OSA_fileReadSetOption_optim;
optimized_fp->getOption = M4OSA_fileReadGetOption_optim;
return M4NO_ERROR;
}
M4OSA_ERR NXPSW_FileReaderOptim_cleanUp()
{
gv_NXPSW_READOPT_lowLevelFunctions = M4OSA_NULL;
return M4NO_ERROR;
}
M4OSA_ERR NXPSW_FileReaderOptim_getLowLevelFunctions(M4OSA_Void **FS)
{
M4OSA_FileReadPointer** pFunctionsPointer = (M4OSA_FileReadPointer**) FS;
*pFunctionsPointer = gv_NXPSW_READOPT_lowLevelFunctions;
return M4NO_ERROR;
}
/* __________________________________________________________ */
/*| |*/
/*| Buffer handling functions for Read access |*/
/*|__________________________________________________________|*/
/**************************************************************/
M4OSA_ERR M4OSA_FileReader_BufferInit(M4OSA_FileReader_Context_optim* apContext)
/**************************************************************/
{
M4OSA_UInt8 i;
for(i=0; i<M4OSA_READBUFFER_NB; i++)
{
apContext->buffer[i].data = M4OSA_NULL;
apContext->buffer[i].size = 0;
apContext->buffer[i].filepos = 0;
apContext->buffer[i].remain = 0;
}
for(i=0; i<M4OSA_READBUFFER_NB; i++)
{
apContext->buffer[i].data = (M4OSA_MemAddr8) M4OSA_32bitAlignedMalloc(M4OSA_READBUFFER_SIZE,
M4OSA_FILE_READER, (M4OSA_Char *)"M4OSA_FileReader_BufferInit");
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_ALLOC, apContext->buffer[i].data);
}
return M4NO_ERROR;
}
/**************************************************************/
M4OSA_Void M4OSA_FileReader_BufferFree(M4OSA_FileReader_Context_optim* apContext)
/**************************************************************/
{
M4OSA_Int8 i;
for(i=0; i<M4OSA_READBUFFER_NB; i++)
if(apContext->buffer[i].data != M4OSA_NULL)
free(apContext->buffer[i].data);
}
/**************************************************************/
M4OSA_FilePosition M4OSA_FileReader_BufferCopy(M4OSA_FileReader_Context_optim* apContext,
M4OSA_Int8 i, M4OSA_FilePosition pos,
M4OSA_FilePosition size, M4OSA_MemAddr8 pData)
/**************************************************************/
{
M4OSA_FilePosition copysize;
M4OSA_FilePosition offset;
if(apContext->buffer[i].size == M4OSA_EOF) return M4OSA_EOF;
if( (pos < apContext->buffer[i].filepos)
|| (pos > (apContext->buffer[i].filepos + apContext->buffer[i].size - 1)) )
{
return 0; /* nothing copied */
}
offset = pos - apContext->buffer[i].filepos;
copysize = apContext->buffer[i].size - offset;
copysize = (size < copysize) ? size : copysize;
memcpy((void *)pData, (void *)(apContext->buffer[i].data + offset), copysize);
apContext->buffer[i].remain -= copysize;
apContext->buffer[i].nbFillSinceLastAcess = 0;
return copysize;
}
/**************************************************************/
M4OSA_ERR M4OSA_FileReader_BufferFill(M4OSA_FileReader_Context_optim* apContext,
M4OSA_Int8 i, M4OSA_FilePosition pos)
/**************************************************************/
{
M4OSA_FilePosition gridPos;
M4OSA_FilePosition tempPos;
M4OSA_UInt32 bufferSize;
M4OSA_FilePosition diff;
M4OSA_FilePosition size;
M4OSA_ERR err = M4NO_ERROR;
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
M4OSA_ERR errno = M4NO_ERROR;
M4OSA_UInt32 fileReadSize = 0;
M4OSA_FilePosition fileSeekPosition = 0;
#else
M4OSA_Int32 ret_val;
M4OSA_UInt16 errno;
#endif
M4OSA_TRACE3_4("BufferFill i = %d pos = %ld read = %ld old = %ld", i, pos,
apContext->readFilePos, apContext->buffer[i].filepos);
/* Avoid cycling statement because of EOF */
if(pos >= apContext->fileSize)
return M4WAR_NO_MORE_AU;
/* Relocate to absolute postion if necessary */
bufferSize = M4OSA_READBUFFER_SIZE;
tempPos = (M4OSA_FilePosition) (pos / bufferSize);
gridPos = tempPos * M4OSA_READBUFFER_SIZE;
diff = gridPos - apContext->readFilePos;
if(diff != 0)
{
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
fileSeekPosition = diff;
errno = apContext->FS->seek(apContext->aFileDesc, M4OSA_kFileSeekCurrent,
&fileSeekPosition);
apContext->readFilePos = gridPos;
if(M4NO_ERROR != errno)
{
err = errno;
M4OSA_TRACE1_1("M4OSA_FileReader_BufferFill ERR1 = 0x%x", err);
return err;
}
#else
ret_val = apContext->FS->pFctPtr_Seek(apContext->aFileDesc, diff,
M4OSA_kFileSeekCurrent, &errno);
apContext->readFilePos = gridPos;
if(ret_val != 0)
{
err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errno);
M4OSA_TRACE1_1("M4OSA_FileReader_BufferFill ERR1 = 0x%x", err);
return err;
}
#endif /*M4OSA_READER_OPTIM_USE_OSAL_IF*/
}
apContext->buffer[i].filepos = apContext->readFilePos;
/* Read Data */
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
fileReadSize = M4OSA_READBUFFER_SIZE;
errno = apContext->FS->readData(apContext->aFileDesc,
(M4OSA_MemAddr8)apContext->buffer[i].data, &fileReadSize);
size = (M4OSA_FilePosition)fileReadSize;
if ((M4NO_ERROR != errno)&&(M4WAR_NO_DATA_YET != errno))
{
apContext->buffer[i].size = M4OSA_EOF;
apContext->buffer[i].remain = 0;
err = errno;
M4OSA_TRACE1_1("M4OSA_FileReader_BufferFill ERR2 = 0x%x", err);
return err;
}
#else
size = apContext->FS->pFctPtr_Read(apContext->aFileDesc,
(M4OSA_UInt8 *)apContext->buffer[i].data, M4OSA_READBUFFER_SIZE, &errno);
if(size == -1)
{
apContext->buffer[i].size = M4OSA_EOF;
apContext->buffer[i].remain = 0;
err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errno);
M4OSA_TRACE1_1("M4OSA_FileReader_BufferFill ERR2 = 0x%x", err);
return err;
}
#endif
apContext->buffer[i].size = size;
apContext->buffer[i].remain = size;
apContext->buffer[i].nbFillSinceLastAcess = 0;
/* Retrieve current position */
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
errno = apContext->FS->getOption(apContext->aFileDesc,
M4OSA_kFileReadGetFilePosition,
(M4OSA_DataOption*) &apContext->readFilePos);
if (M4NO_ERROR != errno)
{
err = errno;
M4OSA_TRACE1_1("M4OSA_FileReader_BufferFill ERR3 = 0x%x", err);
}
else if( (apContext->buffer[i].size >= 0)
&& (apContext->buffer[i].size < M4OSA_READBUFFER_SIZE) )
{
err = M4WAR_NO_DATA_YET;
M4OSA_TRACE2_0("M4OSA_FileReader_BufferFill returns NO DATA YET");
return err;
}
#else
apContext->readFilePos = apContext->FS->pFctPtr_Tell(apContext->aFileDesc, &errno);
if( (apContext->buffer[i].size >= 0)
&& (apContext->buffer[i].size < M4OSA_READBUFFER_SIZE) )
{
err = M4WAR_NO_DATA_YET;
M4OSA_TRACE1_1("M4OSA_FileReader_BufferFill ERR3 = 0x%x", err);
return err;
}
#endif /*M4OSA_READER_OPTIM_USE_OSAL_IF*/
/* Return without error */
return M4NO_ERROR;
}
/**************************************************************/
M4OSA_Int8 M4OSA_FileReader_BufferMatch(M4OSA_FileReader_Context_optim* apContext,
M4OSA_FilePosition pos)
/**************************************************************/
{
M4OSA_Int8 i;
/* Select the buffer which matches with given pos */
for(i=0; i<M4OSA_READBUFFER_NB; i++)
{
if( (pos >= apContext->buffer[i].filepos)
&& (pos < (apContext->buffer[i].filepos + apContext->buffer[i].size)) )
{
return i;
}
}
return M4OSA_READBUFFER_NONE;
}
/**************************************************************/
M4OSA_Int8 M4OSA_FileReader_BufferSelect(M4OSA_FileReader_Context_optim* apContext,
M4OSA_Int8 current_i)
/**************************************************************/
{
M4OSA_Int8 i,j;
M4OSA_FilePosition min_amount,max_amount;
M4OSA_Int8 min_i,max_count;
/* update nbFillSinceLastAcess field */
for(i=0; i<M4OSA_READBUFFER_NB; i++)
{
apContext->buffer[i].nbFillSinceLastAcess ++;
}
/* Plan A : Scan for empty buffer */
for(i=0; i<M4OSA_READBUFFER_NB; i++)
{
if(apContext->buffer[i].remain == 0)
{
return i;
}
}
max_count = M4OSA_READBUFFER_NB;
max_amount = MAX_FILLS_SINCE_LAST_ACCESS;
/* Plan B : Scan for dead buffer */
for(i=0; i<M4OSA_READBUFFER_NB; i++)
{
if(apContext->buffer[i].nbFillSinceLastAcess >= (M4OSA_UInt32) max_amount)
{
max_amount = apContext->buffer[i].nbFillSinceLastAcess;
max_count = i;
}
}
if(max_count<M4OSA_READBUFFER_NB)
{
M4OSA_TRACE2_2("DEAD BUFFER: %d, %d",max_count,apContext->buffer[max_count].nbFillSinceLastAcess);
return max_count;
}
min_i = current_i;
min_amount = M4OSA_READBUFFER_SIZE;
/* Select the buffer which is the most "empty" */
for(i=0; i<M4OSA_READBUFFER_NB; i++)
{
j = (i+current_i)%M4OSA_READBUFFER_NB;
if(apContext->buffer[j].remain < min_amount)
{
min_amount = apContext->buffer[j].remain;
min_i = j;
}
}
return min_i;
}
/**************************************************************/
M4OSA_ERR M4OSA_FileReader_CalculateSize(M4OSA_FileReader_Context_optim* apContext)
/**************************************************************/
{
M4OSA_ERR err = M4NO_ERROR;
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
M4OSA_ERR errno = M4NO_ERROR;
#else
M4OSA_Int32 ret_val;
M4OSA_UInt16 errno;
#endif
/* go to the end of file*/
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
errno = apContext->FS->getOption(apContext->aFileDesc, M4OSA_kFileReadGetFileSize,
(M4OSA_DataOption*) &apContext->fileSize);
if (M4NO_ERROR != errno)
{
err = errno;
M4OSA_TRACE1_1("M4OSA_FileReader_CalculateSize ERR = 0x%x", err);
}
#else
ret_val = apContext->FS->pFctPtr_Seek(apContext->aFileDesc, 0, M4OSA_kFileSeekEnd, &errno);
if (ret_val != 0)
{
apContext->readFilePos = M4OSA_EOF;
err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errno);
M4OSA_TRACE1_1("M4OSA_FileReader_CalculateSize ERR = 0x%x", err);
}
else
{
/* Retrieve size of the file */
apContext->fileSize = apContext->FS->pFctPtr_Tell(apContext->aFileDesc, &errno);
apContext->readFilePos = apContext->fileSize;
}
#endif /*M4OSA_READER_OPTIM_USE_OSAL_IF*/
return err;
}
/* __________________________________________________________ */
/*| |*/
/*| OSAL filesystem API |*/
/*|__________________________________________________________|*/
/**
******************************************************************************
* @brief This method opens the provided fileDescriptor and returns its context.
* @param pContext: (OUT) File reader context.
* @param pFileDescriptor : (IN) File Descriptor of the input file.
* @param FileModeAccess : (IN) File mode access.
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER pContext or fileDescriptor is NULL
* @return M4ERR_ALLOC there is no more memory available
* @return M4ERR_FILE_BAD_MODE_ACCESS the file mode access is not correct (it must be either isTextMode or read)
* @return M4ERR_FILE_NOT_FOUND The file can not be opened.
******************************************************************************
*/
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
M4OSA_ERR M4OSA_fileReadOpen_optim(M4OSA_Context* pContext,
M4OSA_Void* pFileDescriptor,
M4OSA_UInt32 FileModeAccess)
#else
M4OSA_ERR M4OSA_fileReadOpen_optim(M4OSA_Context* pContext,
M4OSA_Void* pFileDescriptor,
M4OSA_UInt32 FileModeAccess,
M4OSA_FileSystem_FctPtr *FS)
#endif
{
M4OSA_FileReader_Context_optim* apContext = M4OSA_NULL;
M4OSA_ERR err = M4NO_ERROR;
M4OSA_Void* aFileDesc = M4OSA_NULL;
M4OSA_Bool buffers_allocated = M4OSA_FALSE;
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
M4OSA_ERR errno = M4NO_ERROR;
#else
M4OSA_UInt16 errno;
#endif /*M4OSA_READER_OPTIM_USE_OSAL_IF*/
M4OSA_TRACE2_3("M4OSA_fileReadOpen_optim p = 0x%p fd = %s mode = %lu", pContext,
pFileDescriptor, FileModeAccess);
/* Check input parameters */
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext);
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pFileDescriptor);
*pContext = M4OSA_NULL;
/* Allocate memory for the File reader context. */
apContext = (M4OSA_FileReader_Context_optim *)M4OSA_32bitAlignedMalloc(sizeof(M4OSA_FileReader_Context_optim),
M4OSA_FILE_READER, (M4OSA_Char *)"M4OSA_FileReader_Context_optim");
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_ALLOC, apContext);
/* Set filesystem interface */
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
/*Set the optimized functions, to be called by the user*/
apContext->FS = (M4OSA_FileReadPointer*) M4OSA_32bitAlignedMalloc(sizeof(M4OSA_FileReadPointer),
M4OSA_FILE_READER, (M4OSA_Char *)"M4OSA_FileReaderOptim_init");
if (M4OSA_NULL==apContext->FS)
{
M4OSA_TRACE1_0("M4OSA_FileReaderOptim_init - ERROR : allocation failed");
return M4ERR_ALLOC;
}
apContext->FS->openRead = M4OSA_fileReadOpen;
apContext->FS->readData = M4OSA_fileReadData;
apContext->FS->seek = M4OSA_fileReadSeek;
apContext->FS->closeRead = M4OSA_fileReadClose;
apContext->FS->setOption = M4OSA_fileReadSetOption;
apContext->FS->getOption = M4OSA_fileReadGetOption;
#else
apContext->FS = FS;
#endif
/* Verify access mode */
if ( ((FileModeAccess & M4OSA_kFileAppend) != 0)
|| ((FileModeAccess & M4OSA_kFileRead) == 0))
{
err = M4ERR_FILE_BAD_MODE_ACCESS;
goto cleanup;
}
/* Open file in read mode */
if((FileModeAccess & M4OSA_kFileCreate) != 0)
{
err = M4ERR_FILE_BAD_MODE_ACCESS;
}
else
{
if ((FileModeAccess & M4OSA_kFileRead))
{
/* File is opened in read only*/
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
errno = apContext->FS->openRead(&aFileDesc, pFileDescriptor, FileModeAccess);
if ((aFileDesc == M4OSA_NULL)||(M4NO_ERROR != errno))
{
/* converts the error to PSW format*/
err = errno;
M4OSA_TRACE2_1("M4OSA_fileReadOpen_optim ERR1 = 0x%x", err);
apContext->IsOpened = M4OSA_FALSE;
}
#else
aFileDesc = apContext->FS->pFctPtr_Open(pFileDescriptor, FileModeAccess, &errno);
if (aFileDesc == M4OSA_NULL)
{
/* converts the error to PSW format*/
err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errno);
M4OSA_TRACE2_1("M4OSA_fileReadOpen_optim ERR1 = 0x%x", err);
apContext->IsOpened = M4OSA_FALSE;
}
#endif
else
{
apContext->IsOpened = M4OSA_TRUE;
}
}
else
{
err = M4ERR_FILE_BAD_MODE_ACCESS;
}
}
if (M4NO_ERROR != err) goto cleanup;
/* Allocate buffers */
err = M4OSA_FileReader_BufferInit(apContext);
buffers_allocated = M4OSA_TRUE;
if (M4NO_ERROR != err) goto cleanup;
/* Initialize parameters */
apContext->fileSize = 0;
apContext->absolutePos = 0;
apContext->readFilePos = 0;
/* Retrieve the File Descriptor*/
apContext->aFileDesc = aFileDesc;
/* Retrieve the File mode Access */
apContext->FileAttribute.modeAccess = (M4OSA_FileModeAccess) FileModeAccess;
/*Retrieve the File reader context */
*pContext= (M4OSA_Context)apContext;
/* Compute file size */
err = M4OSA_FileReader_CalculateSize(apContext);
if (M4NO_ERROR != err) goto cleanup;
return M4NO_ERROR;
cleanup:
/* free context */
if (M4OSA_NULL != apContext)
{
if(buffers_allocated == M4OSA_TRUE)
{
M4OSA_FileReader_BufferFree(apContext);
}
free( apContext);
*pContext = M4OSA_NULL;
}
M4OSA_TRACE2_1 ("M4OSA_fileReadOpen_optim: returns error 0x%0x", err)
return err;
}
/**
******************************************************************************
* @brief This method reads the 'size' bytes in the core file reader (selected by its 'context')
* and writes the data to the 'data' pointer. If 'size' byte can not be read in the core file reader,
* 'size' parameter is updated to match the correct number of read bytes.
* @param pContext: (IN) File reader context.
* @param pData : (OUT) Data pointer of the read data.
* @param pSize : (INOUT) Size of the data to read (in byte).
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER pSize, fileDescriptor or pData is NULL
* @return M4ERR_ALLOC there is no more memory available
* @return M4ERR_BAD_CONTEXT provided context is not a valid one.
******************************************************************************
*/
M4OSA_ERR M4OSA_fileReadData_optim(M4OSA_Context pContext,M4OSA_MemAddr8 pData,
M4OSA_UInt32* pSize)
{
M4OSA_FileReader_Context_optim* apContext =
(M4OSA_FileReader_Context_optim*) pContext;
M4OSA_ERR err;
M4OSA_FilePosition aSize;
M4OSA_FilePosition copiedSize;
M4OSA_Int8 selected_buffer, current_buffer;
M4OSA_TRACE3_3("M4OSA_fileReadData_optim p = 0x%p d = 0x%p s = %lu",
pContext, pData, *pSize);
/* Check input parameters */
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_BAD_CONTEXT, apContext);
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pData);
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pSize);
if (apContext->IsOpened != M4OSA_TRUE)
{
return M4ERR_BAD_CONTEXT;
}
/* Prevent reading beyond EOF */
if((*pSize > 0) && (apContext->absolutePos >= apContext->fileSize))
{
copiedSize = 0;
err = M4WAR_NO_MORE_AU;
goto cleanup;
}
/* Check if data can be read from a buffer */
/* If not, fill one according to quantized positions */
copiedSize = 0;
err = M4NO_ERROR;
selected_buffer = M4OSA_FileReader_BufferMatch(apContext, apContext->absolutePos);
if(selected_buffer == M4OSA_READBUFFER_NONE)
{
selected_buffer = M4OSA_FileReader_BufferSelect(apContext, 0);
err = M4OSA_FileReader_BufferFill(apContext, selected_buffer,
apContext->absolutePos);
}
if(err != M4NO_ERROR)
{
if(err == M4WAR_NO_DATA_YET)
{
if (*pSize <= (M4OSA_UInt32)apContext->buffer[selected_buffer].size)
{
err = M4NO_ERROR;
}
else
{
copiedSize = (M4OSA_UInt32)apContext->buffer[selected_buffer].size;
/*copy the content into pData*/
M4OSA_FileReader_BufferCopy(apContext, selected_buffer,
apContext->absolutePos, copiedSize, pData);
goto cleanup;
}
}
else
{
goto cleanup;
}
}
M4OSA_TRACE3_3("read size = %lu buffer = %d pos = %ld", *pSize,
selected_buffer, apContext->absolutePos);
/* Copy buffer into pData */
while(((M4OSA_UInt32)copiedSize < *pSize) && (err == M4NO_ERROR))
{
aSize = M4OSA_FileReader_BufferCopy(apContext, selected_buffer,
apContext->absolutePos+copiedSize,
*pSize-copiedSize, pData+copiedSize);
copiedSize += aSize;
if(aSize == 0)
{
err = M4WAR_NO_DATA_YET;
}
else
{
if((M4OSA_UInt32)copiedSize < *pSize)
{
current_buffer = selected_buffer;
selected_buffer = M4OSA_FileReader_BufferMatch(apContext,
apContext->absolutePos+copiedSize);
if(selected_buffer == M4OSA_READBUFFER_NONE)
{
selected_buffer = M4OSA_FileReader_BufferSelect(apContext,
current_buffer);
err = M4OSA_FileReader_BufferFill(apContext, selected_buffer,
apContext->absolutePos+copiedSize);
if(err != M4NO_ERROR)
{
if(err == M4WAR_NO_DATA_YET)
{
/*If we got all the data that we wanted, we should return no error*/
if ((*pSize-copiedSize) <= (M4OSA_UInt32)apContext->buffer[selected_buffer].size)
{
err = M4NO_ERROR;
}
/*If we did not get enough data, we will return NO_DATA_YET*/
/*copy the data read*/
aSize = M4OSA_FileReader_BufferCopy(apContext, selected_buffer,
apContext->absolutePos+copiedSize,
*pSize-copiedSize, pData+copiedSize);
copiedSize += aSize;
/*we reached end of file, so stop trying to read*/
goto cleanup;
}
if (err == M4WAR_NO_MORE_AU)
{
err = M4WAR_NO_DATA_YET;
/*copy the data read*/
aSize = M4OSA_FileReader_BufferCopy(apContext, selected_buffer,
apContext->absolutePos+copiedSize,
*pSize-copiedSize, pData+copiedSize);
copiedSize += aSize;
/*we reached end of file, so stop trying to read*/
goto cleanup;
}
else
{
goto cleanup;
}
}
}
}
}
}
cleanup :
/* Update the new position of the pointer */
apContext->absolutePos = apContext->absolutePos + copiedSize;
if((err != M4NO_ERROR)&&(err!=M4WAR_NO_DATA_YET))
{
M4OSA_TRACE2_3("M4OSA_fileReadData_optim size = %ld copied = %ld err = 0x%x",
*pSize, copiedSize, err);
}
/* Effective copied size must be returned */
*pSize = copiedSize;
/* Read is done */
return err;
}
/**
******************************************************************************
* @brief This method seeks at the provided position in the core file reader (selected by its 'context').
* The position is related to the seekMode parameter it can be either :
* From the beginning (position MUST be positive) : end position = position
* From the end (position MUST be negative) : end position = file size + position
* From the current position (signed offset) : end position = current position + position.
* @param pContext: (IN) File reader context.
* @param SeekMode : (IN) Seek access mode.
* @param pPosition : (IN) Position in the file.
* @return M4NO_ERROR: there is no error
* @return M4ERR_PARAMETER Seekmode or fileDescriptor is NULL
* @return M4ERR_ALLOC there is no more memory available
* @return M4ERR_BAD_CONTEXT provided context is not a valid one.
* @return M4ERR_FILE_INVALID_POSITION the position cannot be reached.
******************************************************************************
*/
M4OSA_ERR M4OSA_fileReadSeek_optim( M4OSA_Context pContext, M4OSA_FileSeekAccessMode SeekMode,
M4OSA_FilePosition* pPosition)
{
M4OSA_FileReader_Context_optim* apContext = (M4OSA_FileReader_Context_optim*) pContext;
M4OSA_ERR err = M4NO_ERROR;
M4OSA_TRACE3_3("M4OSA_fileReadSeek_optim p = 0x%p mode = %d pos = %d", pContext,
SeekMode, *pPosition);
/* Check input parameters */
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_BAD_CONTEXT, apContext);
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pPosition);
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, SeekMode);
if (apContext->IsOpened != M4OSA_TRUE)
{
return M4ERR_BAD_CONTEXT; /*< The context can not be correct */
}
/* Go to the desired position */
switch(SeekMode)
{
case M4OSA_kFileSeekBeginning :
if(*pPosition < 0) {
return M4ERR_PARAMETER; /**< Bad SeekAcess mode */
}
apContext->absolutePos = *pPosition;
*pPosition = apContext->absolutePos;
break;
case M4OSA_kFileSeekEnd :
if(*pPosition > 0) {
return M4ERR_PARAMETER; /**< Bad SeekAcess mode */
}
apContext->absolutePos = apContext->fileSize + *pPosition;
*pPosition = apContext->absolutePos;
break;
case M4OSA_kFileSeekCurrent :
if(((apContext->absolutePos + *pPosition) > apContext->fileSize) ||
((apContext->absolutePos + *pPosition) < 0)){
return M4ERR_PARAMETER; /**< Bad SeekAcess mode */
}
apContext->absolutePos = apContext->absolutePos + *pPosition;
*pPosition = apContext->absolutePos;
break;
default :
err = M4ERR_PARAMETER; /**< Bad SeekAcess mode */
break;
}
/* Return without error */
return err;
}
/**
******************************************************************************
* @brief This method asks the core file reader to close the file
* (associated to the context) and also frees the context.
* @param pContext: (IN) File reader context.
* @return M4NO_ERROR: there is no error
* @return M4ERR_BAD_CONTEXT provided context is not a valid one.
******************************************************************************
*/
M4OSA_ERR M4OSA_fileReadClose_optim(M4OSA_Context pContext)
{
M4OSA_FileReader_Context_optim* apContext = (M4OSA_FileReader_Context_optim*) pContext;
M4OSA_ERR err = M4NO_ERROR;
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
M4OSA_ERR errno = M4NO_ERROR;
#else
M4OSA_UInt16 errno;
#endif
M4OSA_TRACE2_1("M4OSA_fileReadClose_optim p = 0x%p", pContext );
/* Check input parameters */
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_BAD_CONTEXT, apContext);
if (apContext->IsOpened != M4OSA_TRUE)
{
return M4ERR_BAD_CONTEXT; /**< The context can not be correct */
}
/* buffer */
M4OSA_FileReader_BufferFree(apContext);
/* Close the file */
#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
errno = apContext->FS->closeRead(apContext->aFileDesc);
if (M4NO_ERROR != errno)
{
/* converts the error to PSW format*/
err = errno;
M4OSA_TRACE2_1("M4OSA_fileReadClose_optim ERR1 = 0x%x", err);
}
#else
aRet_Val = apContext->FS->pFctPtr_Close(apContext->aFileDesc, &errno);
if (aRet_Val != 0)
{
/* converts the error to PSW format*/
err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errno);
M4OSA_TRACE2_1("M4OSA_fileReadClose_optim ERR1 = 0x%x", err);
}
#endif /*M4OSA_READER_OPTIM_USE_OSAL_IF*/
apContext->IsOpened = M4OSA_FALSE;
//>>>> GLM20090212 : set the low level function statically
if (apContext->FS != M4OSA_NULL)
{
free( apContext->FS);
}
//<<<< GLM20090212 : set the low level function statically
/* Free the context */
free(apContext);
/* Return without error */
return err;
}
/**
******************************************************************************
* @brief This is a dummy function required to maintain function pointer
* structure.
* @note This is a dummy function required to maintain function pointer
* structure.
* @param pContext: (IN) Execution context.
* @param OptionId : (IN) Id of the option to set.
* @param OptionValue : (IN) Value of the option.
* @return M4NO_ERROR: there is no error
******************************************************************************
*/
M4OSA_ERR M4OSA_fileReadSetOption_optim(M4OSA_Context pContext,
M4OSA_FileReadOptionID OptionID,
M4OSA_DataOption OptionValue)
{
M4OSA_ERR err = M4NO_ERROR;
return err;
}
/**
******************************************************************************
* @brief This method asks the core file reader to return the value associated
* with the optionID.The caller is responsible for allocating/de-allocating
* the memory of the value field.
* @note The options handled by the component depend on the implementation
* of the component.
* @param pContext: (IN) Execution context.
* @param OptionId : (IN) Id of the option to set.
* @param pOptionValue : (OUT) Value of the option.
* @return M4NO_ERROR: there is no error
* @return M4ERR_BAD_CONTEXT pContext is NULL
* @return M4ERR_BAD_OPTION_ID the option id is not valid.
* @return M4ERR_NOT_IMPLEMENTED The option is not implemented yet.
******************************************************************************
*/
M4OSA_ERR M4OSA_fileReadGetOption_optim(M4OSA_Context pContext,
M4OSA_FileReadOptionID OptionID,
M4OSA_DataOption* pOptionValue)
{
M4OSA_FileReader_Context_optim* apContext = (M4OSA_FileReader_Context_optim*) pContext;
M4OSA_ERR err = M4NO_ERROR;
/* Check input parameters */
M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_BAD_CONTEXT, apContext);
if (apContext->IsOpened != M4OSA_TRUE)
{
return M4ERR_BAD_CONTEXT; /**< The context can not be correct */
}
/* Get the desired option if it is avalaible */
switch(OptionID)
{
/* Get File Size */
case M4OSA_kFileReadGetFileSize:/**< Get size of the file, limited to 32 bit size */
(*(M4OSA_UInt32 *)pOptionValue) = apContext->fileSize;
break;
/* Check End of file Occurs */
case M4OSA_kFileReadIsEOF : /**< See if we are at the end of the file */
(*(M4OSA_Bool *)pOptionValue) = (apContext->absolutePos >= apContext->fileSize) ? M4OSA_TRUE : M4OSA_FALSE;
break;
/* Get File Position */
case M4OSA_kFileReadGetFilePosition : /**< Get file position */
*(M4OSA_FilePosition *)pOptionValue = apContext->absolutePos;
break;
/* Get Attribute */
case M4OSA_kFileReadGetFileAttribute : /**< Get the file attribute = access mode */
(*(M4OSA_FileAttribute *)pOptionValue).modeAccess = apContext->FileAttribute.modeAccess;
break;
default:
/**< Bad option ID */
err = M4ERR_BAD_OPTION_ID;
break;
}
/*Return without error */
return err;
}