videoeditor osal files check in on honeycomb

Change-Id: Id6c5f9f8819158ebffa9fd4dbbf5979a0e5f5808

1 files changed, 672 insertions, 0 deletions

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 <string.h>
+#endif /*UTF_CONVERSION*/
+
+#include <sys/stat.h>
+#include <errno.h>
+
+#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; i<len; i++)
+            {
+                pBufferOut[i]=(M4OSA_UInt8)w_str[i];
+            }
+            pBufferOut[len]=0;
+        }
+    }
+    return M4NO_ERROR;
+}
+#endif /*UTF CONVERSION*/
+
+/**
+ ************************************************************************
+ * @brief      This function seeks at the provided position.
+ * @param      context: (IN/OUT) Context of the core file reader
+ * @param      seekMode: (IN) Seek access mode
+ * @param      position: (IN/OUT) Position in the file
+ * @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
+ * @return     M4ERR_FILE_INVALID_POSITION: the position cannot be reached
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileCommonSeek(M4OSA_Context pContext,
+                               M4OSA_FileSeekAccessMode seekMode,
+                               M4OSA_FilePosition* pFilePos)
+{
+    M4OSA_FileContext* pFileContext = pContext;
+    M4OSA_FilePosition fpos_current;
+    M4OSA_FilePosition fpos_seek;
+    M4OSA_FilePosition fpos_null;
+    M4OSA_FilePosition fpos_neg_un;
+    M4OSA_FilePosition fpos_file_size;
+    M4OSA_FilePosition fpos_seek_from_beginning;
+
+    M4OSA_TRACE3_3("M4OSA_fileCommonSeek\t\tM4OSA_Context 0x%x\t M4OSA_FileSeekAccessMode %d\tM4OSA_FilePosition* 0x%x",
+        pContext, seekMode, pFilePos);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER, "M4OSA_fileCommonSeek");
+    M4OSA_DEBUG_IF2(0 == seekMode, M4ERR_PARAMETER, "M4OSA_fileCommonSeek");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFilePos, M4ERR_PARAMETER, "M4OSA_fileCommonSeek");
+
+    M4OSA_INT_TO_FILE_POSITION(0, fpos_null);
+    M4OSA_INT_TO_FILE_POSITION(-1, fpos_neg_un);
+    M4OSA_FPOS_SET(fpos_file_size, pFileContext->file_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;
+}
+