From 855ec7c4be7ad642721909d5837a8d25a117c22f Mon Sep 17 00:00:00 2001 From: Dharmaray Kundargi Date: Sun, 16 Jan 2011 16:05:58 -0800 Subject: videoeditor osal files check in on honeycomb Change-Id: Id6c5f9f8819158ebffa9fd4dbbf5979a0e5f5808 --- libvideoeditor/osal/src/M4OSA_FileCommon.c | 672 +++++++++++++++++++++++++++++ 1 file changed, 672 insertions(+) create mode 100755 libvideoeditor/osal/src/M4OSA_FileCommon.c (limited to 'libvideoeditor/osal/src/M4OSA_FileCommon.c') diff --git a/libvideoeditor/osal/src/M4OSA_FileCommon.c b/libvideoeditor/osal/src/M4OSA_FileCommon.c new file mode 100755 index 0000000..25163e6 --- /dev/null +++ b/libvideoeditor/osal/src/M4OSA_FileCommon.c @@ -0,0 +1,672 @@ +/* + * Copyright (C) 2004-2011 NXP Software + * 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_FileCommon.c + * @brief File common for Android + * @note This file implements functions used by both the file writer + * and file reader. + ************************************************************************ +*/ + +#ifndef USE_STAGEFRIGHT_CODECS +#error "USE_STAGEFRIGHT_CODECS is not defined" +#endif USE_STAGEFRIGHT_CODECS + +#ifdef UTF_CONVERSION +#include +#endif /*UTF_CONVERSION*/ + +#include +#include + +#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE +#include "M4OSA_Semaphore.h" +#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */ + + +#include "M4OSA_Debug.h" +#include "M4OSA_FileCommon.h" +#include "M4OSA_FileCommon_priv.h" +#include "M4OSA_Memory.h" +#include "M4OSA_CharStar.h" + +/** + ************************************************************************ + * @brief This function opens the provided URL and returns its context. + * If an error occured, the context is set to NULL. + * @param core_id: (IN) Core ID of the caller (M4OSA_FILE_READER or M4OSA_FILE_WRITER) + * @param context: (OUT) Context of the core file reader + * @param url: (IN) URL of the input file + * @param fileModeAccess: (IN) File mode access + * @return M4NO_ERROR: there is no error + * @return M4ERR_PARAMETER: at least one parameter is NULL + * @return M4ERR_ALLOC: there is no more memory available + * @return M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported + * file + * @return M4ERR_FILE_NOT_FOUND: the file cannot be found + * @return M4ERR_FILE_LOCKED: the file is locked by an other + * application/process + * @return M4ERR_FILE_BAD_MODE_ACCESS: the file mode access is not correct + ************************************************************************ +*/ +M4OSA_ERR M4OSA_fileCommonOpen(M4OSA_UInt16 core_id, M4OSA_Context* pContext, + M4OSA_Char* pUrl, M4OSA_FileModeAccess fileModeAccess) +{ + + M4OSA_Int32 i = 0; + M4OSA_Int32 iMode = 0; + M4OSA_Int32 iSize = 0; + M4OSA_Int32 iSavePos = 0; + + M4OSA_Char mode[4] = ""; + M4OSA_Char* pReadString = (M4OSA_Char*)"r"; + M4OSA_Char* pWriteString = (M4OSA_Char*)"w"; + M4OSA_Char* pAppendString = (M4OSA_Char*)"a"; + M4OSA_Char* pBinaryString = (M4OSA_Char*)"b"; + M4OSA_Char* pPlusString = (M4OSA_Char*)"+"; + + M4OSA_ERR err = M4NO_ERROR; + + FILE* pFileHandler = M4OSA_NULL; + M4OSA_FileContext *pFileContext = M4OSA_NULL; + +#ifdef UTF_CONVERSION + /*FB: to test the UTF16->UTF8 conversion into Video Artist*/ + /*Convert the URL from UTF16 to UTF8*/ + M4OSA_Void* tempConversionBuf; + M4OSA_UInt32 tempConversionSize = 1000; + + tempConversionBuf = (M4OSA_Char*)M4OSA_malloc(tempConversionSize +1, 0, "conversion buf"); + if(tempConversionBuf == M4OSA_NULL) + { + M4OSA_TRACE1_0("Error when allocating conversion buffer\n"); + return M4ERR_PARAMETER; + } + M4OSA_ToUTF8_OSAL(pUrl, tempConversionBuf, &tempConversionSize); + ((M4OSA_Char*)tempConversionBuf)[tempConversionSize ] = '\0'; + + printf("file open %s\n", tempConversionBuf); +#endif /*UTF CONVERSION*/ + +///*tmpLSA*/M4OSA_TRACE1_2("### M4OSA_fileCommonOpen %s 0x%X", pUrl, fileModeAccess); + M4OSA_TRACE3_4("M4OSA_fileCommonOpen\t\tM4OSA_UInt16 %d\tM4OSA_Context* 0x%x\t" + "M4OSA_Char* %s\tfileModeAccess %d", core_id, pContext, pUrl, fileModeAccess); + + M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER, "M4OSA_fileCommonOpen: pContext is M4OSA_NULL"); + M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER, "M4OSA_fileCommonOpen: pUrl is M4OSA_NULL"); + M4OSA_DEBUG_IF2(0 == fileModeAccess, M4ERR_PARAMETER, "M4OSA_fileCommonOpen: fileModeAccess is 0"); + + /* Read mode not set for the reader */ + M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && !(fileModeAccess & M4OSA_kFileRead), + M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileRead"); + + /* Read mode not set for the reader */ + M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && !(fileModeAccess & M4OSA_kFileRead), + M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileRead"); + + /* M4OSAfileReadOpen cannot be used with Write file mode access */ + M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && (fileModeAccess & M4OSA_kFileWrite), + M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileWrite"); + + /* Append and Create flags cannot be used with Read */ + M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && (fileModeAccess & M4OSA_kFileAppend), + M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileAppend"); + + M4OSA_DEBUG_IF1((M4OSA_FILE_READER == core_id) && (fileModeAccess & M4OSA_kFileCreate), + M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileCreate"); + + /* Write mode not set for the writer */ + M4OSA_DEBUG_IF1((M4OSA_FILE_WRITER == core_id) && !(fileModeAccess & M4OSA_kFileWrite), + M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: M4OSA_kFileWrite"); + + /* Create flag necessary for opening file */ + if ((fileModeAccess & M4OSA_kFileRead) && + (fileModeAccess & M4OSA_kFileWrite)&&(fileModeAccess & M4OSA_kFileCreate)) + { + M4OSA_chrNCat(mode, pWriteString, 1); + M4OSA_chrNCat(mode, pPlusString, 1); + } + else + { + if(fileModeAccess & M4OSA_kFileAppend) + { + M4OSA_chrNCat(mode, pAppendString, 1); + } + else if(fileModeAccess & M4OSA_kFileRead) + { + M4OSA_chrNCat(mode, pReadString, 1); + } + else if(fileModeAccess & M4OSA_kFileWrite) + { + M4OSA_chrNCat(mode, pWriteString, 1); + } + + if((fileModeAccess & M4OSA_kFileRead)&&(fileModeAccess & M4OSA_kFileWrite)) + { + M4OSA_chrNCat(mode,pPlusString, 1); + } + } + + if(!(fileModeAccess & M4OSA_kFileIsTextMode)) + { + M4OSA_chrNCat(mode, pBinaryString, 1); + } + + /*Open the file*/ + +#ifdef UTF_CONVERSION + /*Open the converted path*/ + pFileHandler = fopen((const char *)tempConversionBuf, (const char *)mode); + /*Free the temporary decoded buffer*/ + M4OSA_free((M4OSA_MemAddr32)tempConversionBuf); +#else + pFileHandler = fopen((const char *)pUrl, (const char *)mode); +#endif /* UTF_CONVERSION */ + + if (M4OSA_NULL == pFileHandler) + { + switch(errno) + { + case ENOENT: + { + M4OSA_DEBUG(M4ERR_FILE_NOT_FOUND, "M4OSA_fileCommonOpen: No such file or directory"); + M4OSA_TRACE1_1("File not found: %s", pUrl); + return M4ERR_FILE_NOT_FOUND; + } + case EACCES: + { + M4OSA_DEBUG(M4ERR_FILE_LOCKED, "M4OSA_fileCommonOpen: Permission denied"); + return M4ERR_FILE_LOCKED; + } + case EINVAL: + { + M4OSA_DEBUG(M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileCommonOpen: Invalid Argument"); + return M4ERR_FILE_BAD_MODE_ACCESS; + } + case EMFILE: + case ENOSPC: + case ENOMEM: + { + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonOpen: Too many open files"); + return M4ERR_ALLOC; + } + default: + { + M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_fileCommonOpen"); + return M4ERR_NOT_IMPLEMENTED; + } + } + } + + /* Allocate the file context */ + pFileContext = (M4OSA_FileContext*) M4OSA_malloc(sizeof(M4OSA_FileContext), + core_id, (M4OSA_Char*)"M4OSA_fileCommonOpen: file context"); + if (M4OSA_NULL == pFileContext) + { + fclose(pFileHandler); + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonOpen"); + return M4ERR_ALLOC; + } + + pFileContext->file_desc = pFileHandler; + pFileContext->access_mode = fileModeAccess; + pFileContext->current_seek = SeekNone; + pFileContext->b_is_end_of_file = M4OSA_FALSE; + + /** + * Note: Never use this expression "i = (value1 == value2) ? x: y;" + * because that doens't compile on other platforms (ADS for example) + * Use: if(value1 == value2) + * { i= x; ..etc + */ + pFileContext->coreID_write = 0; + pFileContext->coreID_read = 0; + pFileContext->m_DescrModeAccess = M4OSA_kDescNoneAccess; + + if (M4OSA_FILE_READER == core_id) + { + pFileContext->coreID_read = core_id; + pFileContext->m_DescrModeAccess = M4OSA_kDescReadAccess; + } + else if (M4OSA_FILE_WRITER == core_id) + { + pFileContext->coreID_write = core_id; + pFileContext->m_DescrModeAccess = M4OSA_kDescWriteAccess; + } + + M4OSA_INT_TO_FILE_POSITION(0, pFileContext->read_position); + M4OSA_INT_TO_FILE_POSITION(0, pFileContext->write_position); + + /* Allocate the memory to store the URL string */ + pFileContext->url_name = (M4OSA_Char*) M4OSA_malloc(M4OSA_chrLength(pUrl)+1, + core_id, (M4OSA_Char*)"M4OSA_fileCommonOpen: URL name"); + if (M4OSA_NULL == pFileContext->url_name) + { + fclose(pFileHandler); + M4OSA_free((M4OSA_MemAddr32)pFileContext); + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonOpen"); + return M4ERR_ALLOC; + } + M4OSA_chrNCopy(pFileContext->url_name, pUrl, M4OSA_chrLength(pUrl)+1); + + /* Get the file name */ + err = M4OSA_fileCommonGetFilename(pUrl, &pFileContext->file_name); + if(M4NO_ERROR != err) + { + fclose(pFileHandler); + M4OSA_free((M4OSA_MemAddr32)pFileContext->url_name); + M4OSA_free((M4OSA_MemAddr32)pFileContext); + M4OSA_DEBUG(err, "M4OSA_fileCommonOpen"); + return err; + } + +#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE + M4OSA_semaphoreOpen(&(pFileContext->semaphore_context), 1); /* Allocate the semaphore */ +#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */ + + + +#ifdef USE_STAGEFRIGHT_CODECS + // Workaround for file system bug on Stingray/Honeycomb where a file re-created will keep + // the original file's size filled with 0s. Do not seek to the end to avoid ill effects + if(fileModeAccess & M4OSA_kFileAppend) { + /* Get the file size */ + iSavePos = ftell(pFileHandler); /* 1- Check the first position */ + fseek(pFileHandler, 0, SEEK_END); /* 2- Go to the end of the file*/ + iSize = ftell(pFileHandler); /* 3- Check the file size */ + fseek(pFileHandler, iSavePos, SEEK_SET);/* 4- go to the first position */ + } else { + iSize = 0; + } +#else /* USE_STAGEFRIGHT_CODECS */ + /* Get the file size */ + iSavePos = ftell(pFileHandler); /* 1- Check the first position */ + fseek(pFileHandler, 0, SEEK_END); /* 2- Go to the end of the file*/ + iSize = ftell(pFileHandler); /* 3- Check the file size */ + fseek(pFileHandler, iSavePos, SEEK_SET);/* 4- go to the first position */ +#endif /* USE_STAGEFRIGHT_CODECS */ + + + + /* Warning possible overflow if the file is higher than 2GBytes */ + pFileContext->file_size = iSize; + + *pContext = pFileContext; +// /*tmpLSA*/M4OSA_TRACE1_1("### M4OSA_fileCommonOpen pFileContext 0x%X", pFileContext); + + return M4NO_ERROR; +} + + +/** + ************************************************************************ + * @brief This function convert from UTF16 to UTF8 + * @param pBufferIn: (IN) UTF16 input path + * @param pBufferOut: (OUT) UTF8 output path + * @param bufferOutSize: (IN/OUT) size of the output path + * @return M4NO_ERROR: there is no error + * @return M4ERR_PARAMETER: the output path size is not enough to contain + * the decoded path + ************************************************************************ +*/ +#ifdef UTF_CONVERSION +M4OSA_ERR M4OSA_ToUTF8_OSAL (M4OSA_Void *pBufferIn, M4OSA_UInt8 *pBufferOut, + M4OSA_UInt32 *bufferOutSize) +{ + M4OSA_UInt16 i; + wchar_t *w_str = (wchar_t *) pBufferIn; + M4OSA_UInt32 len, size_needed, size_given; + if (pBufferIn == NULL) + { + *pBufferOut=NULL; + *bufferOutSize=1; + } + else + { + len = wcslen(w_str); + size_needed = len+1; + size_given = *bufferOutSize; + + *bufferOutSize=size_needed; + if (size_given < size_needed ) + { + return M4ERR_PARAMETER; + } + else + { + for (i=0; ifile_size); + + if(SeekRead == pFileContext->current_seek) + { + M4OSA_FPOS_SET(fpos_current, pFileContext->read_position); + } + else if(SeekWrite == pFileContext->current_seek) + { + M4OSA_FPOS_SET(fpos_current, pFileContext->write_position); + } + else + { + M4OSA_INT_TO_FILE_POSITION(0, fpos_current); + } + + switch(seekMode) + { + case M4OSA_kFileSeekCurrent: + { + M4OSA_FPOS_SET(fpos_seek, *pFilePos); + break; + } + case M4OSA_kFileSeekBeginning: + { + M4OSA_FPOS_SUB(fpos_seek, *pFilePos, fpos_current) + break; + } + case M4OSA_kFileSeekEnd: + { + M4OSA_FPOS_ADD(fpos_seek, fpos_file_size, *pFilePos); + M4OSA_FPOS_SUB(fpos_seek, fpos_seek, fpos_current); + break; + } + default: + { + return M4ERR_PARAMETER; + } + } + + M4OSA_FPOS_ADD(fpos_seek_from_beginning, fpos_current, fpos_seek); + + if(fseek(pFileContext->file_desc, fpos_seek, SEEK_CUR) != 0) + { + switch(errno) + { + case EINVAL: + { + /* meaning the value for origin is invalid or the position + specified by offset is before the beginning of the file */ + return M4ERR_FILE_INVALID_POSITION; + } + + case EBADF: + default: + { + return M4ERR_BAD_CONTEXT;/* file handle is invalid */ + } + } + } + + /* Set the returned position from the beginning of the file */ + M4OSA_FPOS_SET(*pFilePos, fpos_seek_from_beginning); + + /* SEEK done, reset end of file value */ + pFileContext->b_is_end_of_file = M4OSA_FALSE; + + return M4NO_ERROR; +} + + +/** + ************************************************************************ + * @brief This function asks to close the file (associated to the context) + * @note The context of the core file reader/writer is freed. + * @param context: (IN/OUT) Context of the core file reader + * @return M4NO_ERROR: there is no error + * @return M4ERR_PARAMETER: at least one parameter is NULL + * @return M4ERR_BAD_CONTEXT: provided context is not a valid one + * @return M4ERR_ALLOC: there is no more memory available + ************************************************************************ +*/ + +M4OSA_ERR M4OSA_fileCommonClose(M4OSA_UInt16 core_id, M4OSA_Context pContext) +{ + M4OSA_FileContext* pFileContext = pContext; + M4OSA_Int32 i32_err_code=0; + + M4OSA_TRACE3_2("M4OSA_fileCommonClose\tM4OSA_UInt16 %d\tM4OSA_Context 0x%x", + core_id, pContext); + M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, + M4ERR_PARAMETER, "M4OSA_fileCommonClose: pContext is M4OSA_NULL"); +#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE + M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context, M4ERR_BAD_CONTEXT, + "M4OSA_fileCommonClose: semaphore_context is M4OSA_NULL"); +#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */ + + M4OSA_free((M4OSA_MemAddr32)pFileContext->url_name); + pFileContext->url_name = M4OSA_NULL; + + M4OSA_free((M4OSA_MemAddr32)pFileContext->file_name); + pFileContext->file_name = M4OSA_NULL; + + i32_err_code = fclose(pFileContext->file_desc); + + pFileContext->file_desc = M4OSA_NULL; + +#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE + M4OSA_semaphoreClose(pFileContext->semaphore_context);/* free the semaphore */ +#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */ + + M4OSA_free((M4OSA_MemAddr32)pFileContext); + + if (i32_err_code != 0) + { + M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_fileCommonClose"); + return M4ERR_BAD_CONTEXT; + } + + return M4NO_ERROR; +} + + +/** + ************************************************************************ + * @brief This function gets the file attributes (associated to the + * context) + * @param context: (IN) Context of the core file reader + * @param attribute: (OUT) The file attribute (allocated by the caller) + * @return M4NO_ERROR: there is no error + * @return M4ERR_PARAMETER: at least one parameter is NULL + * @return M4ERR_BAD_CONTEXT: provided context is not a valid one + ************************************************************************ +*/ +M4OSA_ERR M4OSA_fileCommonGetAttribute(M4OSA_Context pContext, M4OSA_FileAttribute* pAttribute) +{ + + M4OSA_FileContext* fileContext = pContext; + + struct stat TheStat; + + M4OSA_TRACE3_2("M4OSA_fileCommonGetAttribute\tM4OSA_Context 0x%x\t" + "M4OSA_FileAttribute* 0x%x", pContext, pAttribute); + + M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER, "M4OSA_fileCommonGetAttribute"); + M4OSA_DEBUG_IF2(M4OSA_NULL == pAttribute, M4ERR_PARAMETER, "M4OSA_fileCommonGetAttribute"); + + if(stat((char*)fileContext->url_name, &TheStat) != 0) + { + M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_fileCommonGetAttribute"); + return M4ERR_BAD_CONTEXT; + } + + M4OSA_INT64_FROM_INT32(pAttribute->creationDate.time, TheStat.st_ctime); + M4OSA_INT64_FROM_INT32(pAttribute->lastAccessDate.time, TheStat.st_atime); + M4OSA_INT64_FROM_INT32(pAttribute->modifiedDate.time, TheStat.st_mtime); + + pAttribute->creationDate.timeScale = 1; + pAttribute->lastAccessDate.timeScale= 1; + pAttribute->modifiedDate.timeScale = 1; + + pAttribute->creationDate.referenceYear = 1970; + pAttribute->lastAccessDate.referenceYear= 1970; + pAttribute->modifiedDate.referenceYear = 1970; + + pAttribute->modeAccess = fileContext->access_mode; + + return M4NO_ERROR; +} + +/** + ************************************************************************ + * @brief This function gets the file URL (associated to the context). + * @note + * @param context: (IN) Context of the core file reader + * @param url: (OUT) The buffer containing the URL (allocated by + * M4OSA_fileCommonGetURL) + * @return M4NO_ERROR: there is no error + * @return M4ERR_PARAMETER: at least one parameter is NULL + * @return M4ERR_BAD_CONTEXT: provided context is not a valid one + * @return M4ERR_ALLOC: there is no more memory available + ************************************************************************ +*/ +M4OSA_ERR M4OSA_fileCommonGetURL(M4OSA_Context pContext, M4OSA_Char** pUrl) +{ + M4OSA_FileContext* pFileContext = pContext; + M4OSA_UInt32 uiLength; + + M4OSA_TRACE3_2("M4OSA_fileCommonGetURL\tM4OSA_Context 0x%x\tM4OSA_Char** 0x%x", + pContext, pUrl); + + M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER, + "M4OSA_fileCommonGetURL: pContext is M4OSA_NULL"); + M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER, + "M4OSA_fileCommonGetURL: pUrl is M4OSA_NULL"); + + uiLength = M4OSA_chrLength(pFileContext->url_name)+1; + + /* Allocate the memory to store the url_name */ + *pUrl = (M4OSA_Char*)M4OSA_malloc(uiLength, M4OSA_FILE_COMMON, + (M4OSA_Char*)"M4OSA_fileCommonGetURL: url"); + if(M4OSA_NULL == *pUrl) + { + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonGetURL"); + return M4ERR_ALLOC; + } + + M4OSA_chrNCopy(*pUrl, pFileContext->url_name, uiLength); + + return M4NO_ERROR; +} + + +/** + ************************************************************************ + * @brief This function gets a string containing the file name associated + * to the input URL. + * @note The user should not forget to delete the output string using + * M4OSA_strDestroy + * @param pUrl: (IN) The buffer containing the URL + * @param pFileName: (OUT) The string containing the URL. It is + * allocated inside this function + * @return M4NO_ERROR: there is no error + * @return M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported + * file + * @return M4ERR_ALLOC: there is no more memory available + ************************************************************************ +*/ +M4OSA_ERR M4OSA_fileCommonGetFilename(M4OSA_Char* pUrl, M4OSA_Char** pFileName) +{ + M4OSA_Int32 i = 0; + M4OSA_Int32 iUrlLen = 0; + M4OSA_Int32 FileNameLen = 0; + + M4OSA_Char* ptrUrl = M4OSA_NULL; + M4OSA_Char* ptrFilename = M4OSA_NULL; + + M4OSA_TRACE3_2("M4OSA_fileCommonGetURL\tM4OSA_Char* %s\tM4OSA_Char** 0x%x", + pUrl, pFileName); + + M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER, + "M4OSA_fileCommonGetFilename: pUrl is M4OSA_NULL"); + M4OSA_DEBUG_IF2(M4OSA_NULL == pFileName, M4ERR_PARAMETER, + "M4OSA_fileCommonGetFilename: pFileName is M4OSA_NULL"); + + *pFileName = M4OSA_NULL; + + /*Parse URL*/ + iUrlLen = M4OSA_chrLength(pUrl); + for(i=iUrlLen-1; i>=0; i--) + { + if (pUrl[i] != '\\' && pUrl[i] != '/') + { + FileNameLen++; + } + else + { + break; /* find the beginning of the file name */ + } + } + + ptrFilename = (M4OSA_Char*) M4OSA_malloc(FileNameLen+1, M4OSA_FILE_COMMON, + (M4OSA_Char*)"M4OSA_fileCommonGetFilename: Filename string"); + if (ptrFilename == M4OSA_NULL) + { + M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileCommonGetFilename"); + return M4ERR_ALLOC; + } + + ptrUrl = pUrl + (iUrlLen - FileNameLen); + M4OSA_chrNCopy(ptrFilename, ptrUrl, FileNameLen+1); + + *pFileName = ptrFilename; + + return M4NO_ERROR; +} + -- cgit v1.1