/* * 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; ibuffer[i].data = M4OSA_NULL; apContext->buffer[i].size = 0; apContext->buffer[i].filepos = 0; apContext->buffer[i].remain = 0; } for(i=0; ibuffer[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; ibuffer[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= 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; ibuffer[i].nbFillSinceLastAcess ++; } /* Plan A : Scan for empty buffer */ for(i=0; ibuffer[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; ibuffer[i].nbFillSinceLastAcess >= (M4OSA_UInt32) max_amount) { max_amount = apContext->buffer[i].nbFillSinceLastAcess; max_count = i; } } if(max_countbuffer[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; ibuffer[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; }