videoeditor osal files check in on honeycomb

Change-Id: Id6c5f9f8819158ebffa9fd4dbbf5979a0e5f5808

51 files changed, 18151 insertions, 0 deletions

diff --git a/libvideoeditor/osal/Android.mk b/libvideoeditor/osal/Android.mk
new file mode 100755
index 0000000..7ae3545
--- /dev/null
+++ b/libvideoeditor/osal/Android.mk
@@ -0,0 +1 @@
+include $(call all-subdir-makefiles)

diff --git a/libvideoeditor/osal/inc/LVOSA_FileReader_optim.h b/libvideoeditor/osal/inc/LVOSA_FileReader_optim.h
new file mode 100755
index 0000000..df0375b
--- /dev/null
+++ b/libvideoeditor/osal/inc/LVOSA_FileReader_optim.h
@@ -0,0 +1,86 @@
+/*
+ * 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_FileReader_optim.h
+ * @brief        File reader for Symbian
+ * @note         This file declares functions and types to read a file.
+ ******************************************************************************
+*/
+
+
+
+#ifndef M4OSA_FILEREADER_OPTIM_H
+#define M4OSA_FILEREADER_OPTIM_H
+
+#define M4OSA_READER_OPTIM_USE_OSAL_IF
+
+/**/
+#ifndef M4OSA_READER_OPTIM_USE_OSAL_IF
+    typedef struct
+    {
+        M4OSA_Void*        (*pFctPtr_Open)( M4OSA_Void* fd,
+                                            M4OSA_UInt32 FileModeAccess,
+                                            M4OSA_UInt16* errno );
+        M4OSA_FilePosition (*pFctPtr_Read)( M4OSA_Void* fd,
+                                            M4OSA_UInt8* data,
+                                            M4OSA_FilePosition size,
+                                            M4OSA_UInt16* errno );
+        M4OSA_FilePosition (*pFctPtr_Seek)( M4OSA_Void* fd,
+                                            M4OSA_FilePosition pos,
+                                            M4OSA_FileSeekAccessMode mode,
+                                            M4OSA_UInt16* errno );
+        M4OSA_FilePosition (*pFctPtr_Tell)( M4OSA_Void* fd,
+                                            M4OSA_UInt16* errno );
+        M4OSA_Int32        (*pFctPtr_Close)( M4OSA_Void* fd,
+                                             M4OSA_UInt16* errno );
+        M4OSA_Void         (*pFctPtr_AccessType)( M4OSA_UInt32 FileModeAccess_In,
+                                                  M4OSA_Void* FileModeAccess_Out );
+
+    } M4OSA_FileSystem_FctPtr;
+#endif
+/**/
+
+
+/* Reader API : bufferized functions */
+#ifdef M4OSA_READER_OPTIM_USE_OSAL_IF
+    M4OSA_ERR M4OSA_fileReadOpen_optim( M4OSA_Context* context,
+                                        M4OSA_Void* fileDescriptor,
+                                        M4OSA_UInt32 fileModeAccess);
+#else
+    M4OSA_ERR M4OSA_fileReadOpen_optim( M4OSA_Context* context,
+                                        M4OSA_Void* fileDescriptor,
+                                        M4OSA_UInt32 fileModeAccess,
+                                        M4OSA_FileSystem_FctPtr *FS);
+#endif
+
+M4OSA_ERR M4OSA_fileReadData_optim( M4OSA_Context context,
+                                    M4OSA_MemAddr8 buffer,
+                                    M4OSA_UInt32* size );
+M4OSA_ERR M4OSA_fileReadSeek_optim( M4OSA_Context context,
+                                    M4OSA_FileSeekAccessMode seekMode,
+                                    M4OSA_FilePosition* position );
+M4OSA_ERR M4OSA_fileReadClose_optim( M4OSA_Context context );
+M4OSA_ERR M4OSA_fileReadGetOption_optim( M4OSA_Context context,
+                                         M4OSA_FileReadOptionID optionID,
+                                         M4OSA_DataOption *optionValue );
+M4OSA_ERR M4OSA_fileReadSetOption_optim( M4OSA_Context context,
+                                         M4OSA_FileReadOptionID optionID,
+                                         M4OSA_DataOption optionValue );
+
+#endif /* M4OSA_FILEREADER_OPTIM_H */
diff --git a/libvideoeditor/osal/inc/LV_Macros.h b/libvideoeditor/osal/inc/LV_Macros.h
new file mode 100755
index 0000000..d6312cc
--- /dev/null
+++ b/libvideoeditor/osal/inc/LV_Macros.h
@@ -0,0 +1,108 @@
+/*
+ * 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        LV_Macros.h
+* @par        NXP Software
+* @brief    Macros definition for Smartphone team
+*******************************************************************************/
+
+#ifndef LV_MACROS_H
+#define LV_MACROS_H
+
+/*------------*/
+/*    INCLUDES  */
+/*------------*/
+#include "M4OSA_Memory.h"
+#include "M4OSA_Debug.h"
+
+/******************************************************************************
+*
+* CHECK_PTR(fct, p, err, errValue)
+* @note    This macro checks the value p. If it is NULL, it sets the variable err
+*           to errValue and jumps to the label <fct>_cleanUp. A trace is displayed
+*           signalling the error, the function name and the line number.
+*
+******************************************************************************/
+#define CHECK_PTR(fct, p, err, errValue) \
+{ \
+    if(M4OSA_NULL == (p)) \
+    { \
+        (err) = (errValue) ; \
+        M4OSA_TRACE1_1((M4OSA_Char*)"" #fct "(L%d): " #p " is NULL, returning " #errValue "",__LINE__) ; \
+        goto fct##_cleanUp; \
+    } \
+}
+
+/******************************************************************************
+*
+* CHECK_ERR(fct, err)
+* @note    This macro checks the value err. If it is not NULL, a trace is displayed
+*           signalling the error, the function name and the line number. The macro
+*           jumps to the label <fct>_cleanUp.
+*
+******************************************************************************/
+#define CHECK_ERR(fct, err) \
+{ \
+    if(M4NO_ERROR != (err)) \
+    { \
+        M4OSA_TRACE1_2((M4OSA_Char*)"!!! " #fct "(L%d): ERROR 0x%.8x returned",\
+                                                               __LINE__,err) ; \
+        goto fct##_cleanUp; \
+    } \
+}
+
+
+/******************************************************************************
+*
+* CHECK_ERR(fct, err)
+* @note    This macro compares a current state with a state value. If they are different,
+*           err is set to M4ERR_STATE.
+*           A trace is displayed signalling the error, the function name and the line number.
+*           The macro jumps to the label <fct>_cleanUp.
+*
+******************************************************************************/
+#define    CHECK_STATE(fct, stateValue, state) \
+{ \
+    if((stateValue) != (state)) \
+    { \
+        M4OSA_TRACE1_1("" #fct " called in bad state %d", state) ; \
+        (err) = M4ERR_STATE ; \
+        goto fct##_cleanUp; \
+    } \
+}
+
+/******************************************************************************
+*
+* SAFE_FREE(p)
+* @note    This macro checks the value of p is not NULL. If it is NULL, it does
+*           nothing. Else, p is de allocated and set to NULL.
+*
+******************************************************************************/
+#define SAFE_FREE(p) \
+{ \
+    if(M4OSA_NULL != (p)) \
+    { \
+        M4OSA_free((M4OSA_MemAddr32)(p)) ; \
+        (p) = M4OSA_NULL ; \
+    } \
+}
+
+
+
+#endif /*---  LV_MACROS_H ---*/
+
diff --git a/libvideoeditor/osal/inc/LV_Types.h b/libvideoeditor/osal/inc/LV_Types.h
new file mode 100755
index 0000000..534ea3a
--- /dev/null
+++ b/libvideoeditor/osal/inc/LV_Types.h
@@ -0,0 +1,78 @@
+/*
+ * 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        LV_Types.h
+* @brief    Types definition for Smartphone team
+*******************************************************************************/
+
+#ifndef LV_TYPES_H
+#define LV_TYPES_H
+
+/*------------*/
+/*    INCLUDES  */
+/*------------*/
+#include "M4OSA_Error.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/*--------------------------------------*/
+/*    CHARACTER ENCODING CONVERSION FCTS    */
+/*--------------------------------------*/
+/******************************************************************************
+*
+* M4OSA_UInt32 (*LV_fromUTF8ToNative_Fct)(const M4OSA_Char* pStart,
+*                                          M4OSA_Void** pOut);
+* @note        This function converts a string from UTF8 format which is the default
+*            encoding in the engines and application logics to the character encoding
+*            supported by the OS or platform. The memory will be allocated within this
+*            function and then, caller will have to free *targetStart thanks to M4OSA_free.
+*            Both strings must be NULL-terminateed.
+* @param    pStart        (IN):    String to convert.
+* @param    pOut        (OUT):    This pointer will be filled by this function. It contains the
+*                                string converted to the native format.
+* @return    Success: Size in bytes allocated including the NULL character. Failure: 0
+*
+******************************************************************************/
+typedef M4OSA_UInt32 (*LV_fromUTF8ToNative_Fct)(const M4OSA_Char* pStart,
+                                                M4OSA_Void** pOut);
+
+/******************************************************************************
+*
+* M4OSA_UInt32 (*LV_fromNativeToUTF8_Fct)(const M4OSA_Char* pStart,
+*                                          M4OSA_Void** targetStart);
+* @note        This function converts a string in the character encoding supported by the
+*            OS or platform to from UTF8 format which is the default encoding in the
+*            engines and application logics. The memory will be allocated within this
+*            function and then, caller will have to free *targetStart thanks to M4OSA_free.
+*            Both strings must be NULL-terminateed.
+* @param    pStart        (IN):    String to convert.
+* @param    pOut        (OUT):    This pointer will be filled by this function. It contains the
+*                                string converted to UTF8 format.
+* @return    Success: Size in bytes allocated including the NULL character. Failure: 0
+*
+******************************************************************************/
+typedef M4OSA_UInt32 (*LV_fromNativeToUTF8_Fct)(const M4OSA_Void** pStart,
+                                                M4OSA_Char** pOut);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*---  LV_TYPES_H ---*/
diff --git a/libvideoeditor/osal/inc/M4OSA_CharStar.h b/libvideoeditor/osal/inc/M4OSA_CharStar.h
new file mode 100755
index 0000000..b51af23
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_CharStar.h
@@ -0,0 +1,147 @@
+/*
+ * 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_CharStar.h
+ * @ingroup
+ * @brief        external API of the Char Star set of functions.
+ ************************************************************************
+*/
+
+#ifndef M4OSA_CHARSTAR_H
+#define M4OSA_CHARSTAR_H
+
+/* general OSAL types and prototypes inclusion                      */
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_Time.h"
+#include "M4OSA_FileCommon.h"
+
+/* types definition                                                          */
+typedef enum
+{
+   M4OSA_kchrDec  = 0x01,
+   M4OSA_kchrHexa = 0x02,
+   M4OSA_kchrOct  = 0x03
+} M4OSA_chrNumBase;
+
+/* error and warning codes                                                   */
+#define M4ERR_CHR_STR_OVERFLOW M4OSA_ERR_CREATE(M4_ERR,M4OSA_CHARSTAR,0x000001)
+#define M4ERR_CHR_CONV_FAILED  M4OSA_ERR_CREATE(M4_ERR,M4OSA_CHARSTAR,0x000002)
+#define M4WAR_CHR_NOT_FOUND    M4OSA_ERR_CREATE(M4_WAR,M4OSA_CHARSTAR,0x000001)
+#define M4WAR_CHR_NUM_RANGE    M4OSA_ERR_CREATE(M4_WAR,M4OSA_CHARSTAR,0x000002)
+#define M4WAR_CHR_NEGATIVE     M4OSA_ERR_CREATE(M4_WAR,M4OSA_CHARSTAR,0x000003)
+
+/* prototypes of the Char Star functions                                     */
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrNCopy          (M4OSA_Char   *strOut,
+                                   M4OSA_Char   *strIn,
+                                   M4OSA_UInt32 len2Copy);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrNCat           (M4OSA_Char   *strOut,
+                                   M4OSA_Char   *strIn,
+                                   M4OSA_UInt32 len2Append);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrCompare        (M4OSA_Char   *strIn1,
+                                   M4OSA_Char   *strIn2,
+                                   M4OSA_Int32  *cmpResult);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrNCompare       (M4OSA_Char   *strIn1,
+                                   M4OSA_Char   *strIn2,
+                                   M4OSA_UInt32 len2Comp,
+                                   M4OSA_Int32  *cmpResult);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrAreIdentical   (M4OSA_Char   *strIn1,
+                                   M4OSA_Char   *strIn2,
+                                   M4OSA_Bool  *result);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrFindChar       (M4OSA_Char   *strIn,
+                                   M4OSA_Char   c,
+                                   M4OSA_Char   **pointerInStr);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrReverseFindChar(M4OSA_Char   *strIn,
+                                   M4OSA_Char   c,
+                                   M4OSA_Char   **pointerInStr);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrSpan           (M4OSA_Char   *strIn,
+                                   M4OSA_Char   *delimiters,
+                                   M4OSA_UInt32 *posInStr);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrSpanComplement (M4OSA_Char   *strIn,
+                                   M4OSA_Char   *delimiters,
+                                   M4OSA_UInt32 *posInStr);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrPbrk           (M4OSA_Char   *strIn,
+                                   M4OSA_Char   *delimiters,
+                                   M4OSA_Char   **pointerInStr);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrFindPattern    (M4OSA_Char   *strIn1,
+                                   M4OSA_Char   *strIn2,
+                                   M4OSA_Char   **pointerInStr1);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_UInt32 M4OSA_chrLength      (M4OSA_Char   *strIn);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_Char   M4OSA_chrToLower     (M4OSA_Char   cIn);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_Char   M4OSA_chrToUpper     (M4OSA_Char   cIn);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR    M4OSA_chrGetWord     (M4OSA_Char   *strIn,
+                                   M4OSA_Char   *beginDelimiters,
+                                   M4OSA_Char   *endDelimiters,
+                                   M4OSA_Char   *strOut,
+                                   M4OSA_UInt32 *strOutMaxLen,
+                                   M4OSA_Char   **outputPointer);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetUInt32      (M4OSA_Char   *strIn,
+                                   M4OSA_UInt32 *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetUInt16      (M4OSA_Char   *strIn,
+                                   M4OSA_UInt16 *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetUInt8       (M4OSA_Char   *strIn,
+                                   M4OSA_UInt8  *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetInt64       (M4OSA_Char   *strIn,
+                                   M4OSA_Int64  *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetInt32       (M4OSA_Char   *strIn,
+                                   M4OSA_Int32  *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetInt16       (M4OSA_Char   *strIn,
+                                   M4OSA_Int16  *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetInt8        (M4OSA_Char   *strIn,
+                                   M4OSA_Int8   *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetDouble      (M4OSA_Char   *strIn,
+                                   M4OSA_Double *val,
+                                   M4OSA_Char   **strOut);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetTime        (M4OSA_Char   *strIn,
+                                   M4OSA_Time   *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrGetFilePosition(M4OSA_Char   *strIn,
+                                   M4OSA_FilePosition *val,
+                                   M4OSA_Char   **strOut,
+                                   M4OSA_chrNumBase base);
+M4OSAL_CHARSTAR_EXPORT_TYPE M4OSA_ERR M4OSA_chrSPrintf         (M4OSA_Char  *strOut,
+                                   M4OSA_UInt32 strOutMaxLen,
+                                   M4OSA_Char   *format,
+                                   ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Clock.h b/libvideoeditor/osal/inc/M4OSA_Clock.h
new file mode 100755
index 0000000..ca3c39e
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Clock.h
@@ -0,0 +1,49 @@
+/*
+ * 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_Clock.h
+ * @ingroup      OSAL
+ * @brief        clock API
+ ************************************************************************
+*/
+
+#ifndef M4OSA_CLOCH_H
+#define M4OSA_CLOCK_H
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_Time.h"
+
+
+#define M4WAR_TIMESCALE_TOO_BIG    M4OSA_ERR_CREATE(M4_WAR,M4OSA_CLOCK,0x000001) /**< Time precision too high for the system*/
+#define M4ERR_CLOCK_BAD_REF_YEAR   M4OSA_ERR_CREATE(M4_ERR,M4OSA_CLOCK,0x000001) /**< Input year of reference is neither 1900, nor 1970 nor 2000*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSAL_CLOCK_EXPORT_TYPE M4OSA_ERR M4OSA_clockGetTime(M4OSA_Time* pTime,
+                                                M4OSA_UInt32 timescale);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*M4OSA_CLOCK_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_CoreID.h b/libvideoeditor/osal/inc/M4OSA_CoreID.h
new file mode 100755
index 0000000..e8ca1a2
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_CoreID.h
@@ -0,0 +1,200 @@
+/*
+ * 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_CoreID.h
+ * @brief  defines the uniques component identifiers used for memory management
+ *         and optionID mechanism
+ * @note
+ ************************************************************************
+*/
+#ifndef __M4OSA_COREID_H__
+#define __M4OSA_COREID_H__
+
+/* CoreId are defined on 14 bits */
+/* we start from 0x0100, lower values are reserved for osal core components */
+
+/* reader shells*/
+#define M4READER_COMMON     0x0100
+#define M4READER_AVI        0x0101
+#define M4READER_AMR        0x0102
+#define M4READER_3GP        0x0103
+#define M4READER_NET        0x0104
+#define M4READER_3GP_HTTP   0x0105
+#define M4READER_MP3        0x0106
+#define M4READER_WAV        0x0107
+#define M4READER_MIDI       0x0108
+#define M4READER_ASF        0x0109
+#define M4READER_REAL        0x010A
+#define M4READER_AAC        0x010B
+#define M4READER_FLEX        0x010C
+#define M4READER_BBA        0x010D
+#define M4READER_SYNTHESIS_AUDIO    0x010E
+#define M4READER_JPEG        0x010F
+
+
+/* writer shells*/
+#define M4WRITER_COMMON     0x0110
+#define M4WRITER_AVI        0x0111
+#define M4WRITER_AMR        0x0112
+#define M4WRITER_3GP        0x0113
+#define M4WRITER_JPEG        0x0116
+#define M4WRITER_MP3        0x0117
+
+/* decoder shells */
+#define M4DECODER_COMMON    0x0120
+#define M4DECODER_JPEG      0x0121
+#define M4DECODER_MPEG4     0x0122
+#define M4DECODER_AUDIO     0x0123
+#define M4DECODER_AVC       0x0124
+#define M4DECODER_MIDI      0x0125
+#define M4DECODER_WMA        0x0126
+#define M4DECODER_WMV        0x0127
+#define M4DECODER_RMV        0x0128
+#define M4DECODER_RMA        0x0129
+#define M4DECODER_AAC       0x012A
+#define M4DECODER_BEATBREW  0x012B
+#define M4DECODER_EXTERNAL  0x012C
+
+/* encoder shells */
+#define M4ENCODER_COMMON    0x0130
+#define M4ENCODER_JPEG      0x0131
+#define M4ENCODER_MPEG4     0x0132
+#define M4ENCODER_AUDIO     0x0133
+#define M4ENCODER_VID_NULL  0x0134
+#define M4ENCODER_MJPEG        0x0135
+#define M4ENCODER_MP3        0x0136
+#define M4ENCODER_H264        0x0137
+#define M4ENCODER_AAC        0x0138
+#define M4ENCODER_AMRNB        0x0139
+#define M4ENCODER_AUD_NULL  0x013A
+#define M4ENCODER_EXTERNAL  0x013B
+
+/* cores */
+#define M4JPG_DECODER       0x0140
+#define M4JPG_ENCODER       0x0141
+
+#define M4MP4_DECODER       0x0142
+#define M4MP4_ENCODER       0x0143
+
+#define M4AVI_COMMON        0x0144
+#define M4AVI_READER        0x0145
+#define M4AVI_WRITER        0x0146
+
+#define M4HTTP_ENGINE       0x0147
+
+#define M4OSA_TMPFILE       0x0148
+#define M4TOOL_TIMER        0x0149
+
+#define M4AMR_READER        0x014A
+
+#define M4MP3_READER        0x014B
+
+#define M4WAV_READER        0x014C
+#define M4WAV_WRITER        0x014D
+#define M4WAV_COMMON        0x014E
+
+#define M4ADTS_READER        0x014F
+#define M4ADIF_READER        0x016A
+
+#define M4SPS               0x0150
+#define M4EXIF_DECODER      0x0151
+#define M4EXIF_ENCODER      0x0152
+#define M4GIF_DECODER       0x0153
+#define M4GIF_ENCODER       0x0154
+#define M4PNG_DECODER       0x0155
+#define M4PNG_ENCODER       0x0156
+#define M4WBMP_DECODER      0x0157
+#define M4WBMP_ENCODER      0x0158
+
+#define M4AMR_WRITER        0x0159    /**< no room to put it along M4AMR_READER */
+
+
+#define M4AVC_DECODER       0x015A
+#define M4AVC_ENCODER       0x015B
+
+#define M4ASF_READER        0x015C
+#define M4WMDRM_AGENT        0x015D
+#define M4MIDI_READER        0x0162    /**< no room before the presenters */
+#define M4RM_READER         0x163
+#define M4RMV_DECODER        0x164
+#define M4RMA_DECODER        0x165
+
+#define M4TOOL_XML            0x0166
+#define M4TOOL_EFR            0x0167    /**< Decryption module for Video Artist */
+#define M4IAL_FTN            0x0168    /* FTN implementation of the IAL */
+#define M4FTN                0x0169    /* FTN library */
+
+/* presenter */
+#define M4PRESENTER_AUDIO   0x0160
+#define M4PRESENTER_VIDEO   0x0161
+
+/* high level interfaces (vps, etc..)*/
+#define M4VPS               0x0170
+#define M4VTS               0x0171
+#define M4VXS               0x0172
+#define M4CALLBACK          0x0173
+#define M4VES               0x0174
+#define M4PREPROCESS_VIDEO  0x0175
+#define M4GRAB_AUDIO        0x0176
+#define M4GRAB_VIDEO        0x0177
+#define M4VSSAVI            0x0178
+#define M4VSS3GPP           0x0179
+#define M4PTO3GPP           0x017A
+#define M4PVX_PARSER        0x017B
+#define M4VCS                0x017C
+#define M4MCS                0x017D
+#define M4MNMC                0x0180    /**< mnm controller */
+#define M4TTEXT_PARSER      0x0181    /**< timed text */
+#define M4MM                0x0182    /**< Music manager */
+#define M4MDP                0x0183    /**< Metadata parser */
+#define M4MMSQLCORE            0x0184
+#define M4VPSIL                0x0185
+#define M4FILEIL            0x0186 /* IL file Interface */
+#define M4MU                0x0187
+#define M4VEE                0x0188  /**< Video effect engine */
+#define M4VA                0x0189 /* VideoArtist */
+#define M4JTS                0x018A
+#define M4JTSIL                0x018B
+#define M4AIR                0x018C  /**< AIR */
+#define M4SPE                0x018D  /**< Still picture editor */
+#define M4VS                0x018E    /**< Video Studio (xVSS) */
+#define M4VESIL                0x018F    /**< VES il */
+#define M4ID3                0x0190    /**< ID3 Tag Module */
+#define M4SC                0x0191    /**< Media Scanner */
+#define M4TG                0x0192  /**< Thumbnail Generator*/
+#define M4TS                0x0193    /**< Thumbnail storage */
+#define M4MB                0x0194    /**< Media browser */
+
+/* high level application (test or client app) */
+#define M4APPLI             0x0200
+#define M4VA_APPLI            0x0201    /**< Video Artist test application */
+
+/* external components (HW video codecs, etc.) */
+#define M4VD_EXTERNAL        0x0300
+#define M4VE_EXTERNAL        0x0301
+
+
+/* priority to combine with module ids */
+#define M4HIGH_PRIORITY     0xC000
+#define M4MEDIUM_PRIORITY   0x8000
+#define M4LOW_PRIORITY      0x4000
+#define M4DEFAULT_PRIORITY  0x0000
+
+
+#endif /*__M4OSA_COREID_H__*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Debug.h b/libvideoeditor/osal/inc/M4OSA_Debug.h
new file mode 100755
index 0000000..6d93c9c
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Debug.h
@@ -0,0 +1,267 @@
+/*
+ * 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_Debug.h
+ * @brief        Debug and Trace Macro
+ ************************************************************************
+*/
+
+
+#ifndef _M4OSA_DEBUG_H_
+#define _M4OSA_DEBUG_H_
+
+#include "M4OSA_Error.h"
+#include "M4OSA_Types.h"
+
+
+/* defaut value, defined only if not defined already. */
+#ifndef M4TRACE_ID
+#define M4TRACE_ID M4UNKNOWN_COREID
+#endif /* M4TRACE_ID undefined */
+
+
+#define M4OSA_SUPER_DEBUG_LEVEL 0
+
+#ifndef M4OSA_DEBUG_LEVEL
+#define M4OSA_DEBUG_LEVEL       0
+#endif
+
+
+#define M4OSA_SUPER_TRACE_LEVEL 0
+
+#ifndef M4OSA_TRACE_LEVEL
+#define M4OSA_TRACE_LEVEL       0
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+#if (M4OSA_DEBUG_LEVEL >= 1) || (M4OSA_SUPER_DEBUG_LEVEL >= 1)
+
+/* Debug macros */
+extern M4OSA_Void M4OSA_DEBUG_traceFunction(M4OSA_UInt32 line,
+                                            M4OSA_Char* fileName,
+                                            M4OSA_UInt32 level,
+                                            M4OSA_Char* stringCondition,
+                                            M4OSA_Char* message,
+                                            M4OSA_ERR returnedError);
+
+
+#define M4OSA_DEBUG_IFx(cond, errorCode, msg, level)\
+      if(cond)\
+      {\
+         M4OSA_DEBUG_traceFunction(__LINE__, (M4OSA_Char*)__FILE__, level,\
+                                   (M4OSA_Char*)#cond, (M4OSA_Char*)msg,
+                                   (errorCode));\
+         return(errorCode);\
+      }
+
+#define M4OSA_DEBUG(errorCode, msg)\
+         M4OSA_DEBUG_traceFunction(__LINE__, (M4OSA_Char*)__FILE__, 1,\
+                                   (M4OSA_Char*)#errorCode, (M4OSA_Char*)msg,
+                                   (errorCode));
+
+#else /*(M4OSA_DEBUG_LEVEL >= 1) || (M4OSA_SUPER_DEBUG_LEVEL >= 1)*/
+
+
+#define M4OSA_DEBUG(errorCode, msg)
+
+#endif /*(M4OSA_DEBUG_LEVEL >= 1) || (M4OSA_SUPER_DEBUG_LEVEL >= 1)*/
+
+
+
+#if (M4OSA_DEBUG_LEVEL >= 1) || (M4OSA_SUPER_DEBUG_LEVEL >= 1)
+ #define M4OSA_DEBUG_IF1(cond, errorCode, msg)\
+         M4OSA_DEBUG_IFx(cond, errorCode, msg, 1)
+#else
+ #define M4OSA_DEBUG_IF1(cond, errorCode, msg)
+#endif /*(M4OSA_DEBUG_LEVEL >= 1) || (M4OSA_SUPER_DEBUG_LEVEL >= 1)*/
+
+
+#if (M4OSA_DEBUG_LEVEL >= 2) || (M4OSA_SUPER_DEBUG_LEVEL >= 2)
+ #define M4OSA_DEBUG_IF2(cond, errorCode, msg)\
+         M4OSA_DEBUG_IFx(cond, errorCode, msg, 2)
+#else
+ #define M4OSA_DEBUG_IF2(cond, errorCode, msg)
+#endif /*(M4OSA_DEBUG_LEVEL >= 2) || (M4OSA_SUPER_DEBUG_LEVEL >= 2)*/
+
+
+#if (M4OSA_DEBUG_LEVEL >= 3) || (M4OSA_SUPER_DEBUG_LEVEL >= 3)
+ #define M4OSA_DEBUG_IF3(cond, errorCode, msg)\
+         M4OSA_DEBUG_IFx(cond, errorCode, msg, 3)
+#else
+ #define M4OSA_DEBUG_IF3(cond, errorCode, msg)
+#endif /*(M4OSA_DEBUG_LEVEL >= 3) || (M4OSA_SUPER_DEBUG_LEVEL >= 3)*/
+
+
+
+/* Trace macros */
+
+#if (M4OSA_TRACE_LEVEL >= 1) || (M4OSA_SUPER_TRACE_LEVEL >= 1)
+
+extern M4OSA_Void M4OSA_TRACE_traceFunction(M4OSA_UInt32 line,
+                                            M4OSA_Char* fileName,
+                                            M4OSA_CoreID coreID,
+                                            M4OSA_UInt32 level,
+                                            M4OSA_Char* stringMsg,
+                                            ... );
+
+
+
+#define M4OSA_TRACEx_0(msg, level)\
+      M4OSA_TRACE_traceFunction(__LINE__, (M4OSA_Char*)__FILE__,\
+                             (M4OSA_CoreID)M4TRACE_ID, level, (M4OSA_Char*)msg);
+
+
+#define M4OSA_TRACEx_1(msg, param1, level)\
+      M4OSA_TRACE_traceFunction(__LINE__, (M4OSA_Char*)__FILE__,\
+                     (M4OSA_CoreID)M4TRACE_ID, level, (M4OSA_Char*)msg, param1);
+
+
+#define M4OSA_TRACEx_2(msg, param1, param2, level)\
+      M4OSA_TRACE_traceFunction(__LINE__, (M4OSA_Char*)__FILE__,\
+                                (M4OSA_CoreID)M4TRACE_ID, level,\
+                                (M4OSA_Char*)msg, param1,\
+                                param2);
+
+
+#define M4OSA_TRACEx_3(msg, param1, param2, param3, level)\
+      M4OSA_TRACE_traceFunction(__LINE__, (M4OSA_Char*)__FILE__,\
+                                (M4OSA_CoreID)M4TRACE_ID, level, (M4OSA_Char*)msg,\
+                                param1,param2, param3);
+
+
+#define M4OSA_TRACEx_4(msg, param1, param2, param3, param4, level)\
+      M4OSA_TRACE_traceFunction(__LINE__, (M4OSA_Char*)__FILE__,\
+                                (M4OSA_CoreID)M4TRACE_ID, level,\
+                                (M4OSA_Char*)msg, param1,\
+                                param2, param3, param4);
+
+
+#define M4OSA_TRACEx_5(msg, param1, param2, param3, param4, param5, level)\
+      M4OSA_TRACE_traceFunction(__LINE__, (M4OSA_Char*)__FILE__,\
+                                (M4OSA_CoreID)M4TRACE_ID, level,\
+                                (M4OSA_Char*)msg, param1,\
+                                param2, param3, param4, param5);
+
+#endif /*(M4OSA_TRACE_LEVEL >= 1) || (M4OSA_SUPER_TRACE_LEVEL >= 1)*/
+
+
+
+#if (M4OSA_TRACE_LEVEL >= 1) || (M4OSA_SUPER_TRACE_LEVEL >= 1)
+#define M4OSA_TRACE1_0(msg)\
+        M4OSA_TRACEx_0(msg, 1)
+
+#define M4OSA_TRACE1_1(msg, param1)\
+        M4OSA_TRACEx_1(msg, param1, 1)
+
+#define M4OSA_TRACE1_2(msg, param1, param2)\
+        M4OSA_TRACEx_2(msg, param1, param2, 1)
+
+#define M4OSA_TRACE1_3(msg, param1, param2, param3)\
+        M4OSA_TRACEx_3(msg, param1, param2, param3, 1)
+
+#define M4OSA_TRACE1_4(msg, param1, param2, param3, param4)\
+        M4OSA_TRACEx_4(msg, param1, param2, param3, param4, 1)
+
+#define M4OSA_TRACE1_5(msg, param1, param2, param3, param4, param5)\
+        M4OSA_TRACEx_5(msg, param1, param2, param3, param4, param5, 1)
+
+#else /*(M4OSA_TRACE_LEVEL >= 1) || (M4OSA_SUPER_TRACE_LEVEL >= 1)*/
+
+#define M4OSA_TRACE1_0(msg)
+#define M4OSA_TRACE1_1(msg, param1)
+#define M4OSA_TRACE1_2(msg, param1, param2)
+#define M4OSA_TRACE1_3(msg, param1, param2, param3)
+#define M4OSA_TRACE1_4(msg, param1, param2, param3, param4)
+#define M4OSA_TRACE1_5(msg, param1, param2, param3, param4, param5)
+
+#endif /*(M4OSA_TRACE_LEVEL >= 1) || (M4OSA_SUPER_TRACE_LEVEL >= 1)*/
+
+
+#if (M4OSA_TRACE_LEVEL >= 2) || (M4OSA_SUPER_TRACE_LEVEL >= 2)
+#define M4OSA_TRACE2_0(msg)\
+        M4OSA_TRACEx_0(msg, 2)
+
+#define M4OSA_TRACE2_1(msg, param1)\
+        M4OSA_TRACEx_1(msg, param1, 2)
+
+#define M4OSA_TRACE2_2(msg, param1, param2)\
+        M4OSA_TRACEx_2(msg, param1, param2, 2)
+
+#define M4OSA_TRACE2_3(msg, param1, param2, param3)\
+        M4OSA_TRACEx_3(msg, param1, param2, param3, 2)
+
+#define M4OSA_TRACE2_4(msg, param1, param2, param3, param4)\
+        M4OSA_TRACEx_4(msg, param1, param2, param3, param4, 2)
+
+#define M4OSA_TRACE2_5(msg, param1, param2, param3, param4, param5)\
+        M4OSA_TRACEx_5(msg, param1, param2, param3, param4, param5, 2)
+
+#else /*(M4OSA_TRACE_LEVEL >= 2) || (M4OSA_SUPER_TRACE_LEVEL >= 2)*/
+
+#define M4OSA_TRACE2_0(msg)
+#define M4OSA_TRACE2_1(msg, param1)
+#define M4OSA_TRACE2_2(msg, param1, param2)
+#define M4OSA_TRACE2_3(msg, param1, param2, param3)
+#define M4OSA_TRACE2_4(msg, param1, param2, param3, param4)
+#define M4OSA_TRACE2_5(msg, param1, param2, param3, param4, param5)
+#endif /*(M4OSA_TRACE_LEVEL >= 2) || (M4OSA_SUPER_TRACE_LEVEL >= 2)*/
+
+
+#if (M4OSA_TRACE_LEVEL >= 3) || (M4OSA_SUPER_TRACE_LEVEL >= 3)
+#define M4OSA_TRACE3_0(msg)\
+        M4OSA_TRACEx_0(msg, 3)
+
+#define M4OSA_TRACE3_1(msg, param1)\
+        M4OSA_TRACEx_1(msg, param1, 3)
+
+#define M4OSA_TRACE3_2(msg, param1, param2)\
+        M4OSA_TRACEx_2(msg, param1, param2, 3)
+
+#define M4OSA_TRACE3_3(msg, param1, param2, param3)\
+        M4OSA_TRACEx_3(msg, param1, param2, param3, 3)
+
+#define M4OSA_TRACE3_4(msg, param1, param2, param3, param4)\
+        M4OSA_TRACEx_4(msg, param1, param2, param3, param4, 3)
+
+#define M4OSA_TRACE3_5(msg, param1, param2, param3, param4, param5)\
+        M4OSA_TRACEx_5(msg, param1, param2, param3, param4, param5, 3)
+
+#else /*(M4OSA_TRACE_LEVEL >= 3) || (M4OSA_SUPER_TRACE_LEVEL >= 3)*/
+
+#define M4OSA_TRACE3_0(msg)
+#define M4OSA_TRACE3_1(msg, param1)
+#define M4OSA_TRACE3_2(msg, param1, param2)
+#define M4OSA_TRACE3_3(msg, param1, param2, param3)
+#define M4OSA_TRACE3_4(msg, param1, param2, param3, param4)
+#define M4OSA_TRACE3_5(msg, param1, param2, param3, param4, param5)
+
+#endif /*(M4OSA_TRACE_LEVEL >= 3) || (M4OSA_SUPER_TRACE_LEVEL >= 3)*/
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _M4OSA_DEBUG_H_ */
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Error.h b/libvideoeditor/osal/inc/M4OSA_Error.h
new file mode 100755
index 0000000..963bb63
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Error.h
@@ -0,0 +1,173 @@
+/*
+ * 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_Error.h
+ * @ingroup      OSAL
+ * @brief        Definition of common error types
+ * @note         This file contains macros to generate and analyze error codes.
+ ************************************************************************
+*/
+
+
+#ifndef M4OSA_ERROR_H
+#define M4OSA_ERROR_H
+
+#include "M4OSA_Types.h"
+
+/** M4OSA_ERR is a 32 bits unsigned integer.
+ * To sort returned code, a specific naming convention must be followed:
+ * - Severity (2 bits): It may br either 0b00 (no error), 0b01 (warning) or
+ *                      0b01 (fatal error)
+ * - Core ID (14 bits): It is a unique ID for each core component
+ * - ErrorID (16 bits): It is the specific error code
+
+ * EACH CORE COMPONENT FUNCTION SHOULD RETURN AN M4OSA_ERR
+*/
+typedef M4OSA_UInt32   M4OSA_ERR;
+
+#define M4_OK     0
+#define M4_WAR    1
+#define M4_ERR    2
+
+
+/* Macro to process M4OSA_ERR */
+
+/** This macro tests if the provided M4OSA_ERR is a warning or not*/
+#define M4OSA_ERR_IS_WARNING(error)   ((((error)>>30) == M4_WAR) ? 1:0)
+
+/** This macro tests if the provided M4OSA_ERR is a fatal error or not*/
+#define M4OSA_ERR_IS_ERROR(error)   ((((error)>>30) == M4_ERR) ? 1:0)
+
+/** This macro returns an error code accroding to the 3 provided fields:
+  * @arg severity: (IN) [M4OSA_UInt32] Severity to put in the error code
+  * @arg coreID: (IN) [M4OSA_UInt32] CoreID to put in the error code
+  * @arg errorID: (IN) [M4OSA_UInt32] ErrorID to put in the error code*/
+#define M4OSA_ERR_CREATE(severity, coreID, errorID)\
+   (M4OSA_Int32)((((M4OSA_UInt32)severity)<<30)+((((M4OSA_UInt32)coreID)&0x003FFF)<<16)+(((M4OSA_UInt32)errorID)&0x00FFFF))
+
+/** This macro extracts the 3 fields from the error:
+  * @arg error: (IN) [M4OSA_ERR] Error code
+  * @arg severity: (OUT) [M4OSA_UInt32] Severity to put in the error code
+  * @arg coreID: (OUT) [M4OSA_UInt32] CoreID to put in the error code
+  * @arg errorID: (OUT) [M4OSA_UInt32] ErrorID to put in the error code*/
+#define M4OSA_ERR_SPLIT(error, severity, coreID, errorID)\
+   { severity=(M4OSA_UInt32)((error)>>30);\
+     coreID=(M4OSA_UInt32)(((error)>>16)&0x003FFF);\
+     (M4OSA_UInt32)(errorID=(error)&0x00FFFF); }
+
+
+/* "fake" CoreID, is used to report an unknown CoreID. Used by the trace system
+when the core ID macro isn't defined. Defined here instead of CoreID.h to avoid
+introducing dependencies to common/inc. */
+
+#define M4UNKNOWN_COREID    0x3FFF /* max possible CoreID */
+
+#define M4_COMMON           0x00  /**<Common*/
+#define M4MP4_COMMON        0x01  /**<Core MP4 (common)*/
+#define M4MP4_WRITER        0x02  /**<Core MP4 writer*/
+#define M4MP4_READER        0x03  /**<Core MP4 reader*/
+#define M4RTSP_COMMON       0x11  /**<Core RTSP common*/
+#define M4RTSP_WRITER       0x12  /**<Core RTSP transmitter*/
+#define M4RTSP_READER       0x13  /**<Core RTSP receiver*/
+#define M4RTP_WRITER        0x14  /**<Core RTP/RTCP receiver*/
+#define M4RTP_READER        0x15  /**<Core RTP/RTCP transmitter*/
+#define M4SAP_WRITER        0x16  /**<Core SAP transmitter*/
+#define M4SAP_READER        0x17  /**<Core SAP receiver*/
+#define M4DVBH_READER        0x18  /**<Core DVBH receiver*/
+#define M4SDP_WRITER        0x22  /**<Core SDP writer*/
+#define M4SDP_READER        0x31  /**<Core SDP reader*/
+#define M4PAK_AMR           0x32  /**<Core packetizer AMR (RFC3267)*/
+#define M4DEPAK_AMR         0x33  /**<Core de-packetizer AMR (RFC3267)*/
+#define M4PAK_H263          0x34  /**<Core packetizer H263 (RFC2429)*/
+#define M4DEPAK_H263        0x35  /**<Core de-packetizer H263(RFC2429)*/
+#define M4PAK_SIMPLE        0x36  /**<Core packetizer SimpleDraft (RFC xxxx)*/
+#define M4DEPAK_SIMPLE      0x37  /**<Core de-packetizer SimpleDraft (RFC xxxx)*/
+#define M4PAK_3016_VIDEO    0x38  /**<Core packetizer RFC3016 video*/
+#define M4DEPAK_3016_VIDEO  0x39  /**<Core de-packetizer RFC3016 video*/
+#define M4PAK_3016_AUDIO    0x3A  /**<Core packetizer RFC3016 audio (LATM)*/
+#define M4DEPAK_3016_AUDIO  0x3B  /**<Core de-packetizer RFC3016 audio (LATM)*/
+#define M4DEPAK_H264        0x3C  /**<Core de-packetizer H264*/
+#define M4DEPAK_REALV        0x3D  /**<Core de-packetizer Real Video */
+#define M4DEPAK_REALA        0x3E  /**<Core de-packetizer Real Audio */
+#define M4RDT_READER        0x3F  /**<Core RDT receiver*/
+#define M4TCP_DMUX          0x50  /**<Core TCP demux*/
+#define M4IOD_PARSER        0x51  /**<Core IOD parser*/
+#define M4OSA_FILE_COMMON   0x61  /**<OSAL file common*/
+#define M4OSA_FILE_WRITER   0x62  /**<OSAL file writer*/
+#define M4OSA_FILE_READER   0x63  /**<OSAL file reader*/
+#define M4OSA_FILE_EXTRA    0x64  /**<OSAL file extra*/
+#define M4OSA_DIRECTORY     0x65  /**<OSAL directory*/
+#define M4OSA_SOCKET        0x71  /**<OSAL socket (both reader and writer)*/
+#define M4OSA_THREAD        0x81  /**<OSAL thread*/
+#define M4OSA_MUTEX         0x82  /**<OSAL mutex*/
+#define M4OSA_SEMAPHORE     0x83  /**<OSAL semaphore*/
+#define M4OSA_CLOCK         0x84  /**<OSAL clock*/
+#define M4OSA_MEMORY        0x91  /**<OSAL memory*/
+#define M4CALL_BACK         0xA1  /**<Call Back error*/
+#define M4OSA_URI           0xB1  /**<OSAL URI handler*/
+#define M4OSA_STRING        0xB2  /**<OSAL string*/
+#define M4SYS_CMAPI         0xB3  /**<SYSTEM Common Medi API*/
+#define M4OSA_CHARSTAR      0xB4  /**<OSAL CharStar*/
+#define M4REACTOR           0xC1  /**<Core reactor*/
+#define M4TEST              0xD1  /**<Test component*/
+#define M4STACK                0xE1  /**< Core ID of the integrated stack*/
+#define M4STACK_REAL        0xE2  /**<Core ID of the Real integrated stack */
+#define M4TOOL_LBVT_PARAM   0xF1  /**<LB_VT config file manager*/
+#define M4TOOL_LINK_LIST    0xF2  /**<Tool linked list*/
+#define M4TOOL_BASE64       0xF3  /**<Core base64 encoder/decoder*/
+
+
+
+/* Definition of common error codes */
+/** there is no error*/
+#define M4NO_ERROR            0x00000000
+
+/** At least one parameter is NULL*/
+#define M4ERR_PARAMETER            M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000001)
+/** This function cannot be called now*/
+#define M4ERR_STATE                M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000002)
+/** There is no more memory available*/
+#define M4ERR_ALLOC                M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000003)
+/** Provided context is not a valid one*/
+#define M4ERR_BAD_CONTEXT          M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000004)
+#define M4ERR_CONTEXT_FAILED       M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000005)
+#define M4ERR_BAD_STREAM_ID        M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000006)
+/** The optionID is not a valid one*/
+#define M4ERR_BAD_OPTION_ID        M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000007)
+/** This option is a write only one*/
+#define M4ERR_WRITE_ONLY           M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000008)
+/** This option is a read only one*/
+#define M4ERR_READ_ONLY            M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x000009)
+/** This function is not supported yet*/
+#define M4ERR_NOT_IMPLEMENTED      M4OSA_ERR_CREATE(M4_ERR,M4_COMMON,0x00000A)
+
+#define    M4ERR_UNSUPPORTED_MEDIA_TYPE  M4OSA_ERR_CREATE(M4_ERR, M4_COMMON, 0x00000B)
+
+#define M4WAR_NO_DATA_YET          M4OSA_ERR_CREATE(M4_WAR,M4_COMMON,0x000001)
+#define M4WAR_NO_MORE_STREAM       M4OSA_ERR_CREATE(M4_WAR,M4_COMMON,0x000002)
+#define M4WAR_INVALID_TIME         M4OSA_ERR_CREATE(M4_WAR,M4_COMMON,0x000003)
+#define M4WAR_NO_MORE_AU           M4OSA_ERR_CREATE(M4_WAR,M4_COMMON,0x000004)
+#define M4WAR_TIME_OUT             M4OSA_ERR_CREATE(M4_WAR,M4_COMMON,0x000005)
+/** The buffer is full*/
+#define M4WAR_BUFFER_FULL          M4OSA_ERR_CREATE(M4_WAR,M4_COMMON,0x000006)
+/* The server asks for a redirection */
+#define M4WAR_REDIRECT               M4OSA_ERR_CREATE(M4_WAR,M4_COMMON,0x000007)
+#define M4WAR_TOO_MUCH_STREAMS     M4OSA_ERR_CREATE(M4_WAR,M4_COMMON,0x000008)
+
+#endif /*M4OSA_ERROR_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Export.h b/libvideoeditor/osal/inc/M4OSA_Export.h
new file mode 100755
index 0000000..4d38346
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Export.h
@@ -0,0 +1,62 @@
+/*
+ * 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_Export.h
+ * @brief    Data access export types for Android
+ * @note    This file defines types which must be
+ *          used to import or export any function.
+ ************************************************************************
+*/
+
+#ifndef M4OSA_EXPORT_H
+#define M4OSA_EXPORT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /*__cplusplus*/
+
+/************************************/
+/*  OSAL EXPORTS                    */
+/************************************/
+
+#define M4OSAL_CHARSTAR_EXPORT_TYPE            /**< OSAL CHAR_STAR        */
+#define M4OSAL_CLOCK_EXPORT_TYPE            /**< OSAL CLOCK            */
+#define M4OSAL_DATE_EXPORT_TYPE                /**< OSAL DATE            */
+#define M4OSAL_FILE_EXPORT_TYPE                /**< OSAL FILE            */
+#define M4OSAL_REALTIME_EXPORT_TYPE            /**< OSAL REAL TIME        */
+#define M4OSAL_SOCKET_EXPORT_TYPE            /**< SOCKET                */
+#define M4OSAL_STRING_EXPORT_TYPE            /**< OSAL STRING        */
+#define M4OSAL_URI_EXPORT_TYPE                /**< OSAL URI            */
+#define M4OSAL_MEMORY_EXPORT_TYPE            /**< OSAL MEMORY        */
+#define M4OSAL_TRACE_EXPORT_TYPE            /**< OSAL TRACE            */
+#define M4OSAL_TOOL_TIMER_EXPORT_TYPE        /**< OSAL TOOL TIMER    */
+#define M4OSAL_SYSTEM_CM_EXPORT_TYPE        /**< SYSTEM COMMON API    */
+#define M4OSAL_LINKED_LIST_EXPORT_TYPE        /**< TOOL LINKED LIST    */
+#define M4OSAL_MEMORY_MANAGER_EXPORT_TYPE    /**< MEMORY MANAGER        */
+#define M4OSAL_TRACE_MANAGER_EXPORT_TYPE    /**< TOOL TRACE MANAGER */
+#define M4VPS_EXPORT_TYPE                    /**< VPS API            */
+#define M4AP_EXPORT_TYPE                    /**< AUDIO PRESENTERS    */
+#define M4VP_EXPORT_TYPE                    /**< VIDEO PRESENTERS    */
+#define M4CB_EXPORT_TYPE                    /**< Call back            */
+
+#ifdef __cplusplus
+}
+#endif /*__cplusplus*/
+
+#endif /*M4OSA_EXPORT_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileAccess.h b/libvideoeditor/osal/inc/M4OSA_FileAccess.h
new file mode 100755
index 0000000..489a981
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileAccess.h
@@ -0,0 +1,71 @@
+/*
+ * 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.
+ */
+
+#ifndef __M4OSA_FILEACESS_H__
+#define __M4OSA_FILEACESS_H__
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Semaphore.h"
+#include "M4OSA_Debug.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ ******************************************************************************
+ * struct        M4OSA_FilePtrFct
+ * @brief        Defines the available functions for File read/write.
+ ******************************************************************************
+*/
+typedef enum
+{
+    M4OSA_FILEINTERFACE_RAM,
+    M4OSA_FILEINTERFACE_FFS,
+    M4OSA_FILEINTERFACE_OPTIM_FFS
+
+} M4OSA_FileInterface_t;
+
+
+typedef struct
+{
+    M4OSA_FileWriterPointer *pFileWriter;    /**< Pointer to file writer functions */
+    M4OSA_FileReadPointer   *pFileReader;    /**< Pointer to file reader functions */
+} M4OSA_FilePtrFct;
+
+/*Semaphore for handling of R/W access*/
+extern M4OSA_Context    M4OSA_FileInterface_RWsemaphore; /*defined in M4OSA_FileInterface.c*/
+
+/**
+ ******************************************************************************
+ * func         M4_FileInterface_xxx
+ * @brief        Manage the interface pointers for filesystem access
+ ******************************************************************************
+*/
+M4OSA_FilePtrFct* M4_FileInterface_InitPointer(void);
+M4OSA_ERR M4_FileInterface_SelectPointer(M4OSA_FilePtrFct *pFileFctPtr,
+                                         M4OSA_FileInterface_t mode);
+M4OSA_Void M4_FileInterface_FreePointer(M4OSA_FilePtrFct *pFileFctPtr);
+M4OSA_ERR M4OSA_fileReadOpen_optim_SetInterfaceFFS(M4OSA_Context* pContext,
+                                                   M4OSA_Void* pFileDescriptor,
+                                                   M4OSA_UInt32 FileModeAccess);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus*/
+
+#endif /* __M4OSA_FILEACESS_H__*/
diff --git a/libvideoeditor/osal/inc/M4OSA_FileCache.h b/libvideoeditor/osal/inc/M4OSA_FileCache.h
new file mode 100755
index 0000000..cb4c2ba
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileCache.h
@@ -0,0 +1,69 @@
+/*
+ * 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_FileCache.h
+ * @ingroup      OSAL
+ * @brief         Osal File Reader and Writer with cache
+ * @note          This file implements functions to manipulate
+ *                 filesystem access with intermediate buffers used to
+ *                  read and to write.
+ ******************************************************************************
+*/
+
+#ifndef M4OSA_FILECACHE_H
+#define M4OSA_FILECACHE_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSA_ERR M4OSA_fileOpen_cache(M4OSA_Context* pContext,
+                               M4OSA_Void* pFileDescriptor,
+                               M4OSA_UInt32 FileModeAccess);
+M4OSA_ERR M4OSA_fileReadData_cache( M4OSA_Context context,
+                                    M4OSA_MemAddr8 buffer,
+                                    M4OSA_UInt32* size );
+M4OSA_ERR M4OSA_fileWriteData_cache( M4OSA_Context context,
+                                     M4OSA_MemAddr8 buffer,
+                                     M4OSA_UInt32 size );
+M4OSA_ERR M4OSA_fileReadSeek_cache( M4OSA_Context context,
+                                    M4OSA_FileSeekAccessMode seekMode,
+                                    M4OSA_FilePosition* position );
+M4OSA_ERR M4OSA_fileWriteSeek_cache( M4OSA_Context context,
+                                     M4OSA_FileSeekAccessMode seekMode,
+                                     M4OSA_FilePosition* position );
+M4OSA_ERR M4OSA_fileGetOption_cache( M4OSA_Context context,
+                                     M4OSA_OptionID optionID,
+                                     M4OSA_DataOption *optionValue );
+M4OSA_ERR M4OSA_fileSetOption_cache( M4OSA_Context context,
+                                     M4OSA_OptionID optionID,
+                                     M4OSA_DataOption optionValue );
+M4OSA_ERR M4OSA_fileFlush_cache( M4OSA_Context pContext);
+M4OSA_ERR M4OSA_fileClose_cache( M4OSA_Context context );
+
+/* Used in VA */
+M4OSA_ERR M4OSA_fileExtrafTruncate_cache(M4OSA_Context context,
+                                         M4OSA_UInt32 length);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* M4OSA_FILECACHE_H */
diff --git a/libvideoeditor/osal/inc/M4OSA_FileCommon.h b/libvideoeditor/osal/inc/M4OSA_FileCommon.h
new file mode 100755
index 0000000..663be66
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileCommon.h
@@ -0,0 +1,237 @@
+/*
+ * 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.h
+ * @ingroup      OSAL
+ * @brief        File common
+ * @note         This file declares functions and types used by both the file
+ *               writer and file reader.
+ ************************************************************************
+*/
+
+
+#ifndef M4OSA_FILECOMMON_H
+#define M4OSA_FILECOMMON_H
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Time.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_OptionID.h"
+
+
+
+/*#define M4OSA_FILE_POS_64_BITS_SUPPORTED*/ /*Means M4OSA_Int64 is used*/
+
+#ifndef M4OSA_FILE_POS_64_BITS_SUPPORTED
+#define M4OSA_FILE_POS_32_BITS_SUPPORTED     /*Means M4OSA_Int32 is used*/
+#endif /*M4OSA_FILE_POS_64_BITS_SUPPORTED*/
+
+
+
+#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED
+typedef M4OSA_Int64 M4OSA_FilePosition;
+#endif
+#ifdef M4OSA_FILE_POS_32_BITS_SUPPORTED
+typedef M4OSA_Int32 M4OSA_FilePosition;
+#endif
+
+/** This enum defines the application mode access.
+ *  ie, the application uses a file descriptor to read or to write  or
+ *  both to read and write at the same time.
+ *  This structure is used for MM project only. It enables to read and write to a file
+ *  with one descriptor.
+ */
+typedef enum
+{
+   M4OSA_kDescNoneAccess    = 0x00,
+   M4OSA_kDescReadAccess    = 0x01,    /** The Descriptor reads only from the file */
+   M4OSA_kDescWriteAccess    = 0x02,    /** The Descriptor writes only from the file*/
+   M4OSA_kDescRWAccess        = 0x03    /** The Descriptor reads and writes from/in the file*/
+} M4OSA_DescrModeAccess;
+
+
+/** This enum defines the file mode access. Both text mode as binary mode
+    cannot be set together.*/
+typedef enum
+{
+   /** The file must be accessed in read only mode*/
+   M4OSA_kFileRead             = 0x01,
+   /** The file must be accessed in write only mode*/
+   M4OSA_kFileWrite            = 0x02,
+   /** The file must be accessed in append mode (An existing file must
+       be available to append data)*/
+   M4OSA_kFileAppend           = 0x04,
+   /** If the file does not exist, it will be created*/
+   M4OSA_kFileCreate           = 0x08,
+   /** Data are processed as binary one, there is no data management*/
+   M4OSA_kFileIsTextMode       = 0x10
+} M4OSA_FileModeAccess;
+
+
+/** This type is used to store a date.*/
+typedef struct
+{
+   /** Time scale (tick number per second)*/
+   M4OSA_UInt32 timeScale;
+   /** Date expressed in the time scale*/
+   M4OSA_Time   time;
+   /** Year of the absolute time (1900, 1970 or 2000)*/
+   M4OSA_UInt32 referenceYear;
+} M4OSA_Date;
+
+
+/** This strucure defines the file attributes*/
+typedef struct
+{
+   /** The file mode access*/
+   M4OSA_FileModeAccess    modeAccess;
+   /** The creation date*/
+   M4OSA_Date              creationDate;
+   /** The last modification date*/
+   M4OSA_Date              modifiedDate;
+   /** The last access date (read)*/
+   M4OSA_Date              lastAccessDate;
+} M4OSA_FileAttribute;
+
+
+
+/** This enum defines the seek behavior*/
+typedef enum M4OSA_FileSeekAccessMode
+{
+   /** Relative to the beginning of the file*/
+   M4OSA_kFileSeekBeginning            = 0x01,
+   /** Relative to the end of the file*/
+   M4OSA_kFileSeekEnd                  = 0x02,
+   /** Relative to the current file position*/
+   M4OSA_kFileSeekCurrent              = 0x03
+} M4OSA_FileSeekAccessMode;
+
+
+/* Error codes */
+#define M4ERR_FILE_NOT_FOUND         M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_COMMON, 0x000001)
+#define M4ERR_FILE_LOCKED            M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_COMMON, 0x000002)
+#define M4ERR_FILE_BAD_MODE_ACCESS   M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_COMMON, 0x000003)
+#define M4ERR_FILE_INVALID_POSITION  M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_COMMON, 0x000004)
+
+
+#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED
+
+#define M4OSA_FPOS_SET(fpos_a, fpos_b)\
+        M4OSA_INT64_SET(fpos_a, fpos_b)
+
+#define M4OSA_FPOS_ADD(fpos_result, fpos_a, fpos_b)\
+        M4OSA_INT64_ADD(fpos_result, fpos_a, fpos_b)
+
+#define M4OSA_FPOS_SUB(fpos_result, fpos_a, fpos_b)\
+        M4OSA_INT64_SUB(fpos_result, fpos_a, fpos_b)
+
+#define M4OSA_FPOS_ADD_CONST_UINT32(fpos_out, fpos_in, i32_in)\
+      { M4OSA_Int64 i64_in;\
+        M4OSA_INT64_FROM_INT32(i64_in, i32_in);\
+        M4OSA_INT64_ADD(fpos_out, fpos_in, i64_in); }
+
+#define M4OSA_FPOS_SUB_CONST_UINT32(fpos_out, fpos_in, i32_in)\
+      { M4OSA_Int64 i64_in;\
+        M4OSA_INT64_FROM_INT32(i64_in, i32_in);\
+        M4OSA_INT64_SUB(fpos_out, fpos_in, i64_in); }
+
+#define M4OSA_FPOS_SCALAR_PRODUCT(fpos_result, fpos_a, i32_value)\
+        M4OSA_INT64_SCALAR_PRODUCT(fpos_result, fpos_a, i32_value)
+
+#define M4OSA_FPOS_SCALAR_DIVISION(fpos_result, fpos_a, i32_value)\
+        M4OSA_INT64_SCALAR_DIVISION(fpos_result, fpos_a, i32_value)
+
+#define M4OSA_FPOS_COMPARE(fpos_a, fpos_b)\
+        M4OSA_INT64_COMPARE(fpos_a, fpos_b)
+
+#define M4OSA_FILE_POSITION_TO_INT(fpos, ipos)\
+        M4OSA_INT64_SET(ipos, fpos)
+
+#define M4OSA_INT_TO_FILE_POSITION(ipos, fpos)\
+        M4OSA_FPOS_SET(fpos, ipos)
+
+#define M4OSA_FPOS_IS_POSITIVE(fpos_value)\
+        M4OSA_INT64_IS_POSITIVE(fpos_value)
+
+#define M4OSA_FPOS_NEG(fpos_result, fpos_value)\
+        M4OSA_INT64_NEG(fpos_result, fpos_value)
+
+#define M4OSA_FPOS_ABS(fpos_result, fpos_value)\
+        M4OSA_INT64_ABS(fpos_result, fpos_value)
+
+#define M4OSA_FPOS_LEFT_SHIFT(fpos_result, fpos_value, ui32_nbPositions)\
+        M4OSA_INT64_LEFT_SHIFT(fpos_result, fpos_value, ui32_nbPositions)
+
+#define M4OSA_FPOS_RIGHT_SHIFT(fpos_result, fpos_value, ui32_nbPositions)\
+        M4OSA_INT64_RIGHT_SHIFT(fpos_result, fpos_value, ui32_nbPositions)
+
+#endif
+
+#ifdef M4OSA_FILE_POS_32_BITS_SUPPORTED
+
+#define M4OSA_FPOS_SET(fpos_a, fpos_b)\
+        M4OSA_INT32_SET(fpos_a, fpos_b)
+
+#define M4OSA_FPOS_ADD(fpos_result, fpos_a, fpos_b)\
+        M4OSA_INT32_ADD(fpos_result, fpos_a, fpos_b)
+
+#define M4OSA_FPOS_SUB(fpos_result, fpos_a, fpos_b)\
+        M4OSA_INT32_SUB(fpos_result, fpos_a, fpos_b)
+
+#define M4OSA_FPOS_ADD_CONST_UINT32(fpos_out, fpos_in, i32_in)\
+        M4OSA_FPOS_ADD(fpos_out, fpos_in, i32_in)
+
+#define M4OSA_FPOS_SUB_CONST_UINT32(fpos_out, fpos_in, i32_in)\
+        M4OSA_FPOS_SUB(fpos_out, fpos_in, i32_in)
+
+#define M4OSA_FPOS_SCALAR_PRODUCT(fpos_result, fpos_a, i32_value)\
+        M4OSA_INT32_SCALAR_PRODUCT(fpos_result, fpos_a, i32_value)
+
+#define M4OSA_FPOS_SCALAR_DIVISION(fpos_result, fpos_a, i32_value)\
+        M4OSA_INT32_SCALAR_DIVISION(fpos_result, fpos_a, i32_value)
+
+#define M4OSA_FPOS_COMPARE(fpos_a, fpos_b)\
+        M4OSA_INT32_COMPARE(fpos_a, fpos_b)
+
+#define M4OSA_FILE_POSITION_TO_INT(fpos, ipos)\
+        M4OSA_INT32_SET(ipos, fpos)
+
+#define M4OSA_INT_TO_FILE_POSITION(ipos, fpos)\
+        M4OSA_FPOS_SET(fpos, ipos)
+
+#define M4OSA_FPOS_IS_POSITIVE(fpos_value)\
+        M4OSA_INT32_IS_POSITIVE(fpos_value)
+
+#define M4OSA_FPOS_NEG(fpos_result, fpos_value)\
+        M4OSA_INT32_NEG(fpos_result, fpos_value)
+
+#define M4OSA_FPOS_ABS(fpos_result, fpos_value)\
+        M4OSA_INT32_ABS(fpos_result, fpos_value)
+
+#define M4OSA_FPOS_LEFT_SHIFT(fpos_result, fpos_value, ui32_nbPositions)\
+        M4OSA_INT32_LEFT_SHIFT(fpos_result, fpos_value, ui32_nbPositions)
+
+#define M4OSA_FPOS_RIGHT_SHIFT(fpos_result, fpos_value, ui32_nbPositions)\
+        M4OSA_INT32_RIGHT_SHIFT(fpos_result, fpos_value, ui32_nbPositions)
+
+#endif
+
+
+
+#endif /*M4OSA_FILECOMMON_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileCommon_priv.h b/libvideoeditor/osal/inc/M4OSA_FileCommon_priv.h
new file mode 100755
index 0000000..f3064a7
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileCommon_priv.h
@@ -0,0 +1,112 @@
+/*
+ * 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_priv.h
+ * @ingroup      OSAL
+ * @brief        File common private for Android
+ * @note         This file declares functions and types used by both the file
+ *               writer and file reader.
+ ************************************************************************
+*/
+
+#ifndef M4OSA_FILECOMMON_PRIV_H
+#define M4OSA_FILECOMMON_PRIV_H
+
+
+#include "M4OSA_FileCommon.h"
+#include <stdio.h>
+
+#define M4OSA_isAccessModeActived(compound_mode_access,elementary_mode_access)\
+        (((compound_mode_access)&(elementary_mode_access))? 1:0)
+
+
+typedef enum M4OSA_LastSeek
+{
+   SeekNone,
+   SeekRead,
+   SeekWrite
+} M4OSA_LastSeek;
+
+/** This structure defines the file context*/
+typedef struct {
+   M4OSA_UInt32         coreID_read;
+   M4OSA_UInt32         coreID_write;
+#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED
+   /** The file handler */
+   M4OSA_Int32          file_desc;
+#else
+   FILE*                file_desc;
+#endif /* M4OSA_FILE_POS_64_BITS_SUPPORTED */
+   /** The name of the URL */
+   M4OSA_Char*          url_name;
+   /** The name of the file */
+   M4OSA_Char*          file_name;
+   /** The size in bytes of the file */
+   M4OSA_FilePosition   file_size;
+   /** The file mode access used to open the file */
+   M4OSA_FileModeAccess access_mode;
+   M4OSA_LastSeek       current_seek;
+   M4OSA_FilePosition   read_position;
+   M4OSA_FilePosition   write_position;
+   M4OSA_Bool           b_is_end_of_file;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+   M4OSA_Context        semaphore_context;
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+
+   /* These two variables were added to manage case where a file
+    * is opened in read and write mode with one descriptor */
+    M4OSA_DescrModeAccess    m_DescrModeAccess;
+    M4OSA_UInt32            m_uiLockMode;
+
+
+} M4OSA_FileContext;
+
+
+
+M4OSA_ERR M4OSA_fileCommonOpen(M4OSA_UInt16 core_id,
+                               M4OSA_Context* context,
+                               M4OSA_Char* URL,
+                               M4OSA_FileModeAccess fileModeAccess);
+
+M4OSA_ERR M4OSA_fileCommonClose(M4OSA_UInt16 core_id,
+                                M4OSA_Context context);
+
+M4OSA_ERR M4OSA_fileCommonGetAttribute(M4OSA_Context context,
+                                       M4OSA_FileAttribute* attribute);
+
+M4OSA_ERR M4OSA_fileCommonGetURL(M4OSA_Context context,
+                                 M4OSA_Char** url);
+
+M4OSA_ERR M4OSA_fileCommonGetFilename(M4OSA_Char* url,
+                                      M4OSA_Char** filename);
+
+M4OSA_ERR M4OSA_fileCommonSeek(M4OSA_Context context,
+                               M4OSA_FileSeekAccessMode seekMode,
+                               M4OSA_FilePosition* position);
+
+#ifdef UTF_CONVERSION
+M4OSA_ERR M4OSA_ToUTF8_OSAL (M4OSA_Void   *pBufferIn,
+                             M4OSA_UInt8  *pBufferOut,
+                             M4OSA_UInt32 *bufferOutSize);
+#endif /*UTF_CONVERSION*/
+
+
+#endif /*M4OSA_FILECOMMON_PRIV_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileExtra.h b/libvideoeditor/osal/inc/M4OSA_FileExtra.h
new file mode 100755
index 0000000..0c9bac2
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileExtra.h
@@ -0,0 +1,70 @@
+/*
+ * 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_FileExtra.h                                        */
+/* @ingroup     OSAL                                                    */
+/************************************************************************/
+
+
+#ifndef M4OSA_FILE_EXTRA_H
+#define M4OSA_FILE_EXTRA_H
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_FileCommon.h"
+/* size of the copy buffer (in bytes) for M4OSA_fileExtraCopy */
+#define BUFFER_COPY_SIZE 1024
+
+typedef enum
+{
+    M4OSA_TypeInvalid = 0,
+    M4OSA_TypeFile,
+    M4OSA_TypeDir
+} M4OSA_EntryType;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSA_ERR M4OSA_fileExtraDelete(const M4OSA_Char* url);
+
+M4OSA_ERR M4OSA_fileExtraCopy(M4OSA_Char* srcUrl, M4OSA_Char* dstUrl);
+
+M4OSA_ERR M4OSA_fileExtraRename(M4OSA_Char* srcUrl, M4OSA_Char* dstUrl);
+
+M4OSA_ERR M4OSA_fileExtraChangeCurrentDir(const M4OSA_Char* url);
+
+M4OSA_ERR M4OSA_fileExtraCreateDir(const M4OSA_Char* pUrl);
+
+M4OSA_ERR M4OSA_fileExtraRemoveDir(const M4OSA_Char* pUrl);
+
+M4OSA_UInt32 M4OSA_fileExtraGetFreeSpace(const M4OSA_Char* pUrl);
+
+M4OSA_UInt32 M4OSA_fileExtraGetTotalSpace(const M4OSA_Char* pUrl);
+
+M4OSA_EntryType M4OSA_fileExtraGetType(const M4OSA_Char* pUrl);
+
+M4OSA_ERR M4OSA_fileExtrafTruncate(M4OSA_Context context, M4OSA_FilePosition length);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif   /*M4OSA_FILE_EXTRA_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileReader.h b/libvideoeditor/osal/inc/M4OSA_FileReader.h
new file mode 100755
index 0000000..f0c75ff
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileReader.h
@@ -0,0 +1,132 @@
+/*
+ * 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_FileReader.h
+ * @ingroup      OSAL
+ * @brief        File reader
+ * @note         This file declares functions and types to read a file.
+ ************************************************************************
+*/
+
+
+#ifndef M4OSA_FILEREADER_H
+#define M4OSA_FILEREADER_H
+
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_FileCommon.h"
+#include "M4OSA_Memory.h"
+
+
+
+/** This enum defines the option ID to be used in M4OSA_FileReadGetOption()
+    and M4OSA_FileReadSetOption()*/
+typedef enum M4OSA_FileReadOptionID
+{
+   /** Get the file size (M4OSA_fpos*)*/
+   M4OSA_kFileReadGetFileSize
+                  = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_READER, 0x01),
+
+      /** Get the file attributes (M4OSA_FileAttribute*)*/
+   M4OSA_kFileReadGetFileAttribute
+                  = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_READER, 0x02),
+
+   /** Get the file URL, provided by the M4OSA_FileReadOpen (M4OSA_Char*)*/
+   M4OSA_kFileReadGetURL
+                  = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_READER, 0x03),
+
+   /** Get the file position (M4OSA_fpos*)*/
+   M4OSA_kFileReadGetFilePosition
+                  = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_READER, 0x04),
+
+   /** Check end of file: TRUE if the EOF has been reached, FALSE else
+       (M4OSA_Bool*)*/
+   M4OSA_kFileReadIsEOF
+                  = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_READER, 0x05),
+
+   /** Check lock of file */
+   M4OSA_kFileReadLockMode
+                  = M4OSA_OPTION_ID_CREATE(M4_READWRITE, M4OSA_FILE_READER, 0x06)
+
+} M4OSA_FileReadOptionID;
+
+
+
+
+
+/** This structure stores the set of the function pointer to access to a
+    file in read mode*/
+typedef struct
+{
+   M4OSA_ERR (*openRead)   (M4OSA_Context* context,
+                            M4OSA_Void* fileDescriptor,
+                            M4OSA_UInt32 fileModeAccess);
+
+   M4OSA_ERR (*readData)   (M4OSA_Context context,
+                            M4OSA_MemAddr8 buffer,
+                            M4OSA_UInt32* size);
+
+   M4OSA_ERR (*seek)       (M4OSA_Context context,
+                            M4OSA_FileSeekAccessMode seekMode,
+                            M4OSA_FilePosition* position);
+
+   M4OSA_ERR (*closeRead)  (M4OSA_Context context);
+
+   M4OSA_ERR (*setOption)  (M4OSA_Context context,
+                            M4OSA_FileReadOptionID optionID,
+                            M4OSA_DataOption optionValue);
+
+   M4OSA_ERR (*getOption)  (M4OSA_Context context,
+                            M4OSA_FileReadOptionID optionID,
+                            M4OSA_DataOption *optionValue);
+} M4OSA_FileReadPointer;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileReadOpen        (M4OSA_Context* context,
+                                     M4OSA_Void* fileDescriptor,
+                                     M4OSA_UInt32 fileModeAccess);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileReadData        (M4OSA_Context context,
+                                     M4OSA_MemAddr8 buffer,
+                                     M4OSA_UInt32* size);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileReadSeek        (M4OSA_Context context,
+                                     M4OSA_FileSeekAccessMode seekMode,
+                                     M4OSA_FilePosition* position);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileReadClose       (M4OSA_Context context);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileReadGetOption   (M4OSA_Context context,
+                                     M4OSA_FileReadOptionID optionID,
+                                     M4OSA_DataOption *optionValue);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileReadSetOption   (M4OSA_Context context,
+                                     M4OSA_FileReadOptionID optionID,
+                                     M4OSA_DataOption optionValue);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif   /*M4OSA_FILEREADER_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileReaderRam.h b/libvideoeditor/osal/inc/M4OSA_FileReaderRam.h
new file mode 100755
index 0000000..0480192
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileReaderRam.h
@@ -0,0 +1,75 @@
+/*
+ * 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_FileReaderRam.h
+ * @ingroup      OSAL
+ * @note         This file implements functions to read a "file" stored in RAM.
+ ******************************************************************************
+*/
+
+
+
+#ifndef M4OSA_FILEREADERRAM_H
+#define M4OSA_FILEREADERRAM_H
+
+#include "M4OSA_FileReader.h"
+
+/**
+ ******************************************************************************
+ * structure    M4FI_FileReaderRam_Descriptor
+ * @brief        This structure defines the File descriptor (public)
+ * @note        This structure is used to store the pointer to the data in memory
+ * @note        and its size
+ ******************************************************************************
+*/
+typedef struct
+{
+    M4OSA_MemAddr8    pFileDesc;    /* Pointer on file data */
+    M4OSA_Int32        dataSize;    /* Size of data */
+} M4OSA_FileReaderRam_Descriptor;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* reader API : RAM functions */
+M4OSA_ERR M4OSA_fileReadRamOpen( M4OSA_Context* context,
+                                 M4OSA_Void* fileDescriptor,
+                                 M4OSA_UInt32 fileModeAccess );
+M4OSA_ERR M4OSA_fileReadRamData( M4OSA_Context context,
+                                 M4OSA_MemAddr8 buffer,
+                                 M4OSA_UInt32* size );
+M4OSA_ERR M4OSA_fileReadRamSeek( M4OSA_Context context,
+                                 M4OSA_FileSeekAccessMode seekMode,
+                                 M4OSA_FilePosition* position );
+M4OSA_ERR M4OSA_fileReadRamClose( M4OSA_Context context );
+M4OSA_ERR M4OSA_fileReadRamGetOption( M4OSA_Context context,
+                                      M4OSA_FileReadOptionID optionID,
+                                      M4OSA_DataOption *optionValue );
+M4OSA_ERR M4OSA_fileReadRamSetOption( M4OSA_Context context,
+                                      M4OSA_FileReadOptionID optionID,
+                                      M4OSA_DataOption optionValue );
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif   /*M4OSA_FILEREADERRAM_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileReader_priv.h b/libvideoeditor/osal/inc/M4OSA_FileReader_priv.h
new file mode 100755
index 0000000..be2af9a
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileReader_priv.h
@@ -0,0 +1,39 @@
+/*
+ * 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_FileReader_priv.h
+ * @ingroup      OSAL
+ * @brief        File reader private for Android
+ * @note
+ ************************************************************************
+*/
+
+#ifndef M4OSA_FILEREADER_PRIV_H
+#define M4OSA_FILEREADER_PRIV_H
+
+
+/** Those define enable/disable option ID*/
+
+#define M4OSA_OPTIONID_FILE_READ_GET_FILE_SIZE               M4OSA_TRUE
+#define M4OSA_OPTIONID_FILE_READ_GET_FILE_ATTRIBUTE          M4OSA_TRUE
+#define M4OSA_OPTIONID_FILE_READ_GET_URL                     M4OSA_TRUE
+#define M4OSA_OPTIONID_FILE_READ_GET_FILE_POSITION           M4OSA_TRUE
+#define M4OSA_OPTIONID_FILE_READ_IS_EOF                      M4OSA_TRUE
+
+#endif /*M4OSA_FILEREADER_PRIV_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileWriter.h b/libvideoeditor/osal/inc/M4OSA_FileWriter.h
new file mode 100755
index 0000000..b8ba553
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileWriter.h
@@ -0,0 +1,136 @@
+/*
+ * 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_FileWriter.h
+ * @ingroup      OSAL
+ * @brief        File writer
+ * @note         This file declares functions and types to write in a file.
+ ************************************************************************
+*/
+
+
+#ifndef M4OSA_FILEWRITER_H
+#define M4OSA_FILEWRITER_H
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_FileCommon.h"
+#include "M4OSA_Memory.h"
+
+
+/** This enum defines the option ID to be used in M4OSA_FileWriteGetOption()
+and M4OSA_FileWriteSetOption()*/
+typedef enum
+{
+   /** Get the file URL, provided by the M4OSA_FileWriteOpen (M4OSA_Char*)*/
+   M4OSA_kFileWriteGetURL
+               = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_WRITER, 0x01),
+
+   /** Get the file attributes (M4OSA_FileAttribute*)*/
+   M4OSA_kFileWriteGetAttribute
+               = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_WRITER, 0x02),
+
+   /** Get the reader context for read & write file. (M4OSA_Context*)*/
+   M4OSA_kFileWriteGetReaderContext
+               = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_WRITER, 0x03),
+
+   M4OSA_kFileWriteGetFilePosition
+               = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_WRITER, 0x04),
+
+   M4OSA_kFileWriteGetFileSize
+               = M4OSA_OPTION_ID_CREATE(M4_READ, M4OSA_FILE_WRITER, 0x05),
+
+
+    M4OSA_kFileWriteLockMode
+               = M4OSA_OPTION_ID_CREATE(M4_READWRITE, M4OSA_FILE_WRITER, 0x06),
+
+
+   /** Check lock of file */
+   M4OSA_kFileWriteDescMode
+                = M4OSA_OPTION_ID_CREATE(M4_READWRITE, M4OSA_FILE_WRITER, 0x07)
+} M4OSA_FileWriteOptionID;
+
+
+/** This structure stores the set of the function pointer to access to a file
+    in read mode*/
+typedef struct
+{
+   M4OSA_ERR (*openWrite)   (M4OSA_Context* context,
+                             M4OSA_Void* fileDescriptor,
+                             M4OSA_UInt32 fileModeAccess);
+
+   M4OSA_ERR (*writeData)   (M4OSA_Context context,
+                             M4OSA_MemAddr8 data,
+                             M4OSA_UInt32 size);
+
+   M4OSA_ERR (*seek)        (M4OSA_Context context,
+                             M4OSA_FileSeekAccessMode seekMode,
+                             M4OSA_FilePosition* position);
+
+   M4OSA_ERR (*Flush)       (M4OSA_Context context);
+   M4OSA_ERR (*closeWrite)  (M4OSA_Context context);
+   M4OSA_ERR (*setOption)   (M4OSA_Context context,
+                             M4OSA_OptionID optionID,
+                             M4OSA_DataOption optionValue);
+
+   M4OSA_ERR (*getOption)   (M4OSA_Context context,
+                             M4OSA_OptionID optionID,
+                             M4OSA_DataOption* optionValue);
+} M4OSA_FileWriterPointer;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileWriteOpen       (M4OSA_Context* context,
+                                     M4OSA_Void* fileDescriptor,
+                                     M4OSA_UInt32 fileModeAccess);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileWriteData       (M4OSA_Context context,
+                                     M4OSA_MemAddr8 data,
+                                     M4OSA_UInt32 size);
+
+/* Pierre Lebeaupin 2008/04/29: WARNING! the feature of file*Seek which returns
+the position in the file (from the beginning) after the seek in the "position"
+pointer has been found to be unreliably (or sometimes not at all) implemented
+in some OSALs, so relying on it is strongly discouraged, unless you really want
+to have a pizza evening. */
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileWriteSeek       (M4OSA_Context context,
+                                     M4OSA_FileSeekAccessMode seekMode,
+                                     M4OSA_FilePosition* position);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileWriteClose      (M4OSA_Context context);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileWriteFlush      (M4OSA_Context context);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileWriteGetOption  (M4OSA_Context context,
+                                     M4OSA_OptionID optionID,
+                                     M4OSA_DataOption* optionValue);
+
+M4OSAL_FILE_EXPORT_TYPE M4OSA_ERR M4OSA_fileWriteSetOption  (M4OSA_Context context,
+                                     M4OSA_OptionID optionID,
+                                     M4OSA_DataOption optionValue);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /*M4OSA_FILEWRITER_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileWriterRam.h b/libvideoeditor/osal/inc/M4OSA_FileWriterRam.h
new file mode 100755
index 0000000..bc19a05
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileWriterRam.h
@@ -0,0 +1,77 @@
+/*
+ * 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_FileWriterRam.h
+ * @ingroup      OSAL
+ * @brief        File writer to RAM
+ * @note         This file implements functions to write a "file" in RAM.
+ ******************************************************************************
+*/
+
+
+#ifndef M4OSA_FILEWRITERRAM_H
+#define M4OSA_FILEWRITERRAM_H
+
+#include "M4OSA_FileWriter.h"
+
+
+/**
+ ******************************************************************************
+ * structure    M4OSA_FileWriterRam_Descriptor
+ * @brief        This structure defines the File descriptor (public)
+ * @note        This structure is used to store the pointer to the data in memory
+ * @note        and its size
+ ******************************************************************************
+*/
+typedef struct
+{
+    M4OSA_MemAddr8    pFileDesc;    /* Pointer on file data */
+    M4OSA_Int32        dataSize;    /* Size of data */
+} M4OSA_FileWriterRam_Descriptor;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* Writer API : RAM functions */
+M4OSA_ERR M4OSA_fileWriteRamOpen(M4OSA_Context* context,
+                                 M4OSA_Void* fileDescriptor,
+                                 M4OSA_UInt32 fileModeAccess);
+M4OSA_ERR M4OSA_fileWriteRamData(M4OSA_Context context,
+                                 M4OSA_MemAddr8 data,
+                                 M4OSA_UInt32 Size);
+M4OSA_ERR M4OSA_fileWriteRamSeek(M4OSA_Context context,
+                                 M4OSA_FileSeekAccessMode SeekMode,
+                                 M4OSA_FilePosition* position);
+M4OSA_ERR M4OSA_fileWriteRamClose(M4OSA_Context context);
+M4OSA_ERR M4OSA_fileWriteRamFlush(M4OSA_Context context);
+M4OSA_ERR M4OSA_fileWriteRamSetOption(M4OSA_Context context,
+                                      M4OSA_OptionID OptionID,
+                                      M4OSA_DataOption OptionValue);
+M4OSA_ERR M4OSA_fileWriteRamGetOption(M4OSA_Context context,
+                                      M4OSA_OptionID OptionID,
+                                      M4OSA_DataOption* optionValue);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif   /*M4OSA_FILEWRITERRAM_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_FileWriter_priv.h b/libvideoeditor/osal/inc/M4OSA_FileWriter_priv.h
new file mode 100755
index 0000000..157d176
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_FileWriter_priv.h
@@ -0,0 +1,38 @@
+/*
+ * 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_FileWriter_priv.h
+ * @ingroup      OSAL
+ * @brief        File writer private for Android
+************************************************************************
+*/
+
+#ifndef M4OSA_FILEWRITER_PRIV_H
+#define M4OSA_FILEWRITER_PRIV_H
+
+
+/** Those define enable/disable option ID*/
+
+#define M4OSA_OPTIONID_FILE_WRITE_GET_FILE_SIZE              M4OSA_TRUE
+#define M4OSA_OPTIONID_FILE_WRITE_GET_FILE_ATTRIBUTE         M4OSA_TRUE
+#define M4OSA_OPTIONID_FILE_WRITE_GET_READER_CONTEXT         M4OSA_TRUE
+#define M4OSA_OPTIONID_FILE_WRITE_GET_FILE_POSITION          M4OSA_TRUE
+#define M4OSA_OPTIONID_FILE_WRITE_GET_URL                    M4OSA_TRUE
+
+#endif /*M4OSA_FILEWRITER_PRIV_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Memory.h b/libvideoeditor/osal/inc/M4OSA_Memory.h
new file mode 100755
index 0000000..d0bb49c
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Memory.h
@@ -0,0 +1,74 @@
+/*
+ * 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_Memory.h
+ * @ingroup      OSAL
+ * @brief        Memory allocation
+ * @note         This file defines function prototypes to allocate
+ *               and free memory.
+ ************************************************************************
+*/
+
+#ifndef M4OSA_MEMORY_H
+#define M4OSA_MEMORY_H
+
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h" /*for M4OSA_CoreID definition*/
+
+typedef M4OSA_Int32* M4OSA_MemAddr32;
+typedef M4OSA_Int8*  M4OSA_MemAddr8;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_MemAddr32 M4OSA_malloc (M4OSA_UInt32 size,
+                                                               M4OSA_CoreID coreID,
+                                                               M4OSA_Char* string);
+
+M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_Void  M4OSA_free   (M4OSA_MemAddr32 address);
+
+M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_Void M4OSA_memset (M4OSA_MemAddr8 address,
+                                                          M4OSA_UInt32 size,
+                                                          M4OSA_UInt8 value);
+
+M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_Void M4OSA_memcpy (M4OSA_MemAddr8 outputBlock,
+                                      M4OSA_MemAddr8 inputBlock, M4OSA_UInt32 size);
+
+M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_MemAddr8 M4OSA_memmove(M4OSA_MemAddr8 outputBlock,
+                                              M4OSA_MemAddr8 inputBlock,
+                                              M4OSA_UInt32 size);
+
+M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_Int32 M4OSA_memcmp (M4OSA_MemAddr8 address1,
+                                      M4OSA_MemAddr8 address2, M4OSA_UInt32 size);
+
+M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_ERR M4OSA_randInit(void);
+
+
+M4OSAL_MEMORY_EXPORT_TYPE extern M4OSA_ERR M4OSA_rand(M4OSA_Int32* out_value,
+                                                      M4OSA_UInt32 max_value);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Mutex.h b/libvideoeditor/osal/inc/M4OSA_Mutex.h
new file mode 100755
index 0000000..92a416f
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Mutex.h
@@ -0,0 +1,57 @@
+/*
+ * 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_Mutex.h
+ * @ingroup      OSAL
+ * @brief        mutex API
+ ************************************************************************
+*/
+
+
+#ifndef M4OSA_MUTEX_H
+#define M4OSA_MUTEX_H
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+
+
+#ifdef __cplusplus
+extern "C"
+{
+
+#endif
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_mutexOpen(    M4OSA_Context* context );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_mutexLock(    M4OSA_Context  context,
+                              M4OSA_UInt32   timeout );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_mutexUnlock(  M4OSA_Context  context );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_mutexClose(   M4OSA_Context  context );
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /*M4OSA_MUTEX_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_OptionID.h b/libvideoeditor/osal/inc/M4OSA_OptionID.h
new file mode 100755
index 0000000..b937644
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_OptionID.h
@@ -0,0 +1,73 @@
+/*
+ * 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_OptionID.h
+ * @ingroup      OSAL
+ * @brief        Option ID macros
+ * @note         This file defines macros to generate and analyze option ID.
+ *               Option ID is used by M4YYY_ZZsetOption() and
+ *               M4YYY_ZZgetOption() functions.
+ ************************************************************************
+*/
+
+#ifndef M4OSA_OPTIONID_H
+#define M4OSA_OPTIONID_H
+
+
+#include "M4OSA_Types.h"
+
+/** M4OSA_OptionID is a 32 bits unsigned integer.
+- Right access (2 bits): Some options may have read only, write only or read
+  and write access
+- Core ID (14 bits): It is a unique ID for each core component
+- SubOption ID (16 bits): To select which option in a specific core component
+*/
+typedef M4OSA_UInt32 M4OSA_OptionID;
+typedef void*        M4OSA_DataOption;
+
+#define M4_READ      0x01
+#define M4_WRITE     0x02
+#define M4_READWRITE 0x03
+
+/* Macro to process M4OSA_OptionID */
+
+/** This macro creates an optionID given read/write access,
+    coreID and SubOptionID*/
+#define M4OSA_OPTION_ID_CREATE(right, coreID, errorID)\
+   (M4OSA_Int32)((((((M4OSA_UInt32)right)&0x03)<<30))+((((M4OSA_UInt32)coreID)&0x003FFF)<<16)+(((M4OSA_UInt32)errorID)&0x00FFFF))
+
+/** This macro splits an optionID into read/write access,
+    coreID and SubOptionID*/
+#define M4OSA_OPTION_ID_SPLIT(optionID, right, coreID, errorID)\
+   { right=(M4OSA_UInt8)((optionID)>>30);\
+     coreID=(M4OSA_UInt16)(((optionID)>>16)&0x00003FFF);\
+     errorID=(M4OSA_UInt32)((optionID)&0x0000FFFF); }
+
+/** This macro returns 1 if the optionID is writable, 0 otherwise*/
+#define M4OSA_OPTION_ID_IS_WRITABLE(optionID) ((((optionID)>>30)&M4_WRITE)!=0)
+
+/** This macro returns 1 if the optionID is readable, 0 otherwise*/
+#define M4OSA_OPTION_ID_IS_READABLE(optionID) ((((optionID)>>30)&M4_READ)!=0)
+
+/** This macro returns 1 if the optionID has its core ID equal to 'coreID', 0 otherwise*/
+#define M4OSA_OPTION_ID_IS_COREID(optionID, coreID)\
+   (((((optionID)>>16)&0x003FFF) == (coreID)) ? M4OSA_TRUE:M4OSA_FALSE)
+
+
+#endif   /*M4OSA_OPTIONID_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Semaphore.h b/libvideoeditor/osal/inc/M4OSA_Semaphore.h
new file mode 100755
index 0000000..fe73673
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Semaphore.h
@@ -0,0 +1,55 @@
+/*
+ * 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_Semaphore.h
+ * @ingroup      OSAL
+ * @brief        semaphore API
+ ************************************************************************
+*/
+
+#ifndef M4OSA_SEMAPHORE_H
+#define M4OSA_SEMAPHORE_H
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_semaphoreOpen(  M4OSA_Context* context,
+                                M4OSA_UInt32   initialNumber );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_semaphorePost(  M4OSA_Context  context );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_semaphoreWait(  M4OSA_Context  context,
+                                M4OSA_Int32    timeout );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_semaphoreClose( M4OSA_Context  context );
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /*M4OSA_SEMAPHORE_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_String.h b/libvideoeditor/osal/inc/M4OSA_String.h
new file mode 100755
index 0000000..3fcf4ed
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_String.h
@@ -0,0 +1,267 @@
+/*
+ * 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_String.h
+ * @ingroup      OSAL
+ * @brief        public definition for string library
+ ************************************************************************
+*/
+
+#ifndef _M4OSA_STRING_H_
+#define _M4OSA_STRING_H_
+
+#include "M4OSA_Types.h"
+#include "M4OSA_FileCommon.h"
+#include "M4OSA_Time.h"
+#include "M4OSA_CharStar.h"
+
+
+
+typedef void* M4OSA_String;
+
+typedef enum
+{
+   M4OSA_kstrAll = 0,
+   M4OSA_kstrBegin,
+   M4OSA_kstrEnd
+} M4OSA_strMode;
+
+/* types definition */
+typedef enum
+{
+   M4OSA_kstrDec   = M4OSA_kchrDec,
+   M4OSA_kstrHexa  = M4OSA_kchrHexa,
+   M4OSA_kstrOct   = M4OSA_kchrOct
+} M4OSA_strNumBase;
+
+/* Error and Warnings codes */
+#define M4ERR_STR_BAD_STRING           M4OSA_ERR_CREATE(M4_ERR,M4OSA_STRING,0x000001)
+#define M4ERR_STR_CONV_FAILED          M4OSA_ERR_CREATE(M4_ERR,M4OSA_STRING,0x000002)
+#define M4ERR_STR_OVERFLOW             M4OSA_ERR_CREATE(M4_ERR,M4OSA_STRING,0x000003)
+#define M4ERR_STR_BAD_ARGS             M4OSA_ERR_CREATE(M4_ERR,M4OSA_STRING,0x000004)
+
+#define M4WAR_STR_OVERFLOW             M4OSA_ERR_CREATE(M4_WAR,M4OSA_STRING,0x000001)
+#define M4WAR_STR_NOT_FOUND            M4OSA_ERR_CREATE(M4_WAR,M4OSA_STRING,0x000002)
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strCreate(                M4OSA_String* pstr);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strReset(                 M4OSA_String str);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strDestroy(               M4OSA_String str);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetCharContent(        M4OSA_String str,
+                                          M4OSA_Char* pchar);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetCharContent(        M4OSA_String str,
+                                          M4OSA_Char** ppchar);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetChar(               M4OSA_String str,
+                                          M4OSA_Char c);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetChar(               M4OSA_String str,
+                                          M4OSA_Char* pc);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetInt8(               M4OSA_String str,
+                                          M4OSA_Int8 i8,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetInt8(               M4OSA_String str,
+                                          M4OSA_Int8* pi8,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetUInt8(              M4OSA_String str,
+                                          M4OSA_UInt8 ui8,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetUInt8(              M4OSA_String str,
+                                          M4OSA_UInt8* pui8,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetInt16(              M4OSA_String str,
+                                          M4OSA_Int16 i16,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetInt16(              M4OSA_String str,
+                                          M4OSA_Int16* pi16,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetUInt16(             M4OSA_String str,
+                                          M4OSA_UInt16 ui16,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetUInt16(             M4OSA_String str,
+                                          M4OSA_UInt16* pui16,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetInt32(              M4OSA_String str,
+                                          M4OSA_Int32 i32,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetInt32(              M4OSA_String str,
+                                          M4OSA_Int32* pi32,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetUInt32(             M4OSA_String str,
+                                          M4OSA_UInt32 ui32,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetUInt32(             M4OSA_String str,
+                                          M4OSA_UInt32* pui32,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetDouble(             M4OSA_String str,
+                                          M4OSA_Double d);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetDouble(             M4OSA_String str,
+                                          M4OSA_Double* pd);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetInt64(              M4OSA_String str,
+                                          M4OSA_Int64 i64,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetInt64(              M4OSA_String str,
+                                          M4OSA_Int64* pi64,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetFilePosition(       M4OSA_String str,
+                                          M4OSA_FilePosition fpos,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetFilePosition(       M4OSA_String str,
+                                          M4OSA_FilePosition* pfpos,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetTime(               M4OSA_String str,
+                                          M4OSA_Time t,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetTime(               M4OSA_String str,
+                                          M4OSA_Time* pt,
+                                          M4OSA_strNumBase base);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetLength(             M4OSA_String str,
+                                          M4OSA_UInt32 *pui32);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strTruncate(              M4OSA_String str,
+                                          M4OSA_UInt32 ui32_length);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strCopy(                  M4OSA_String str_in,
+                                          M4OSA_String str_out);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strCopySubStr(            M4OSA_String str_out,
+                                          M4OSA_UInt32 ui32_pos,
+                                          M4OSA_String str_in,
+                                          M4OSA_UInt32 ui32_offset,
+                                          M4OSA_UInt32* ui32_num);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strConcat(                M4OSA_String str_first,
+                                          M4OSA_String str_second);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strInsertSubStr(          M4OSA_String str_out,
+                                          M4OSA_UInt32 ui32_pos,
+                                          M4OSA_String str_in,
+                                          M4OSA_UInt32 ui32_offset,
+                                          M4OSA_UInt32* pui32_num);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strCompare(               M4OSA_String str_in1,
+                                          M4OSA_String str_in2,
+                                          M4OSA_Int32* pi32_result);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strCompareSubStr(         M4OSA_String str_in1,
+                                          M4OSA_UInt32 ui32_offset1,
+                                          M4OSA_String str_in2,
+                                          M4OSA_UInt32 ui32_offset2,
+                                          M4OSA_UInt32* pui32_num,
+                                          M4OSA_Int32* pi32_result);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strCaseCompare(           M4OSA_String str_in1,
+                                          M4OSA_String str_in2,
+                                          M4OSA_Int32* pi32_result);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strCaseCompareSubStr(     M4OSA_String str_in1,
+                                          M4OSA_UInt32 ui32_offset1,
+                                          M4OSA_String str_in2,
+                                          M4OSA_UInt32 ui32_offset2,
+                                          M4OSA_UInt32* pui32_num,
+                                          M4OSA_Int32* pi32_result);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSpan(                  M4OSA_String str_in,
+                                          M4OSA_Char* charset,
+                                          M4OSA_UInt32* pui32_result);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSpanComplement(        M4OSA_String str_in,
+                                          M4OSA_Char* charset,
+                                          M4OSA_UInt32* pui32_pos);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strFindFirstChar(         M4OSA_String str_in,
+                                          M4OSA_Char c,
+                                          M4OSA_UInt32* pui32_pos);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strFindLastChar(          M4OSA_String str_in,
+                                          M4OSA_Char c,
+                                          M4OSA_UInt32* pui32_pos);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strFindFirstSubStr(       M4OSA_String str_in1,
+                                          M4OSA_String str_in2,
+                                          M4OSA_UInt32* pui32_pos);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strFindLastSubStr(        M4OSA_String str_in1,
+                                          M4OSA_String str_in2,
+                                          M4OSA_UInt32* pui32_pos);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetFirstToken(         M4OSA_String str_in,
+                                          M4OSA_String str_delim,
+                                          M4OSA_String pstr_token);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strGetLastToken(          M4OSA_String str_in,
+                                          M4OSA_String str_delim,
+                                          M4OSA_String pstr_token);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetUpperCase(          M4OSA_String str);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetLowerCase(          M4OSA_String str);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strDelSubStr(             M4OSA_String str_in,
+                                          M4OSA_UInt32 ui32_offset,
+                                          M4OSA_UInt32* ui32_num);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strReplaceSubStr(         M4OSA_String str_in,
+                                          M4OSA_String str_old,
+                                          M4OSA_String str_new,
+                                          M4OSA_strMode mode);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSprintf(               M4OSA_String str,
+                                          M4OSA_Char* format,
+                                          ...);
+
+M4OSAL_STRING_EXPORT_TYPE M4OSA_ERR M4OSA_strSetMinAllocationSize(  M4OSA_String str,
+                                          M4OSA_UInt32 ui32_size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
diff --git a/libvideoeditor/osal/inc/M4OSA_String_priv.h b/libvideoeditor/osal/inc/M4OSA_String_priv.h
new file mode 100755
index 0000000..3303c1d
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_String_priv.h
@@ -0,0 +1,101 @@
+/*
+ * 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_String.h
+ * @ingroup      OSAL
+ * @brief        public definition for string library
+************************************************************************
+*/
+
+
+#ifndef _M4OSA_STRING_PRIV_H
+#define _M4OSA_STRING_PRIV_H
+
+
+#include "M4OSA_Types.h"
+#include "M4OSA_String.h"
+
+#include <stdarg.h>
+
+typedef struct
+{
+   /* string identifiant */
+   M4OSA_UInt32   coreID;
+   /** data buffer */
+   M4OSA_Char* pui8_buffer;
+   /** allocated size of the data buffer */
+   M4OSA_UInt32 ui32_size;
+   /** size of valid data in the buffer */
+   M4OSA_UInt32 ui32_length;
+} M4OSA_strStruct;
+
+
+
+M4OSA_ERR M4OSA_strPrivRealloc(              M4OSA_strStruct* str,
+                                             M4OSA_UInt32 ui32_length);
+
+M4OSA_ERR M4OSA_strPrivReallocCopy(          M4OSA_strStruct* str,
+                                             M4OSA_UInt32 ui32_length);
+
+M4OSA_ERR M4OSA_strPrivSet(                  M4OSA_strStruct* str,
+                                             M4OSA_Char* pchar,
+                                             M4OSA_UInt32 ui32_length);
+
+M4OSA_ERR M4OSA_strPrivDuplicate(            M4OSA_strStruct** ostr,
+                                             M4OSA_strStruct* istr);
+
+M4OSA_Int32 M4OSA_strPrivFindLastSubStr(     M4OSA_strStruct* str1,
+                                             M4OSA_strStruct* str2,
+                                             M4OSA_UInt32 ui32_pos);
+
+M4OSA_ERR M4OSA_strPrivSetAndRepleceStr(     M4OSA_strStruct* istr,
+                                             M4OSA_UInt32 ui32_pos,
+                                             M4OSA_UInt32 olength,
+                                             M4OSA_Char* nbuff,
+                                             M4OSA_UInt32 nlength);
+
+M4OSA_ERR M4OSA_strPrivReplaceSameSizeStr(   M4OSA_strStruct* istr,
+                                             M4OSA_strStruct* ostr,
+                                             M4OSA_strStruct* nstr,
+                                             M4OSA_strMode mode);
+
+M4OSA_ERR M4OSA_strPrivReplaceSmallerStr(    M4OSA_strStruct* istr,
+                                             M4OSA_strStruct* ostr,
+                                             M4OSA_strStruct* nstr,
+                                             M4OSA_strMode mode);
+
+M4OSA_ERR M4OSA_strPrivReplaceBiggerStr(     M4OSA_strStruct* istr,
+                                             M4OSA_strStruct* ostr,
+                                             M4OSA_strStruct* nstr,
+                                             M4OSA_strMode mode);
+
+M4OSA_ERR M4OSA_strPrivSPrintf(              M4OSA_strStruct* str,
+                                             M4OSA_Char *format,
+                                             va_list marker);
+
+
+#define M4OSA_CHECK_MALLOC(buff, string)\
+   if(buff == M4OSA_NULL)\
+   {\
+      M4OSA_DEBUG(M4ERR_ALLOC, string);\
+      return M4ERR_ALLOC;\
+   }\
+
+
+#endif
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Thread.h b/libvideoeditor/osal/inc/M4OSA_Thread.h
new file mode 100755
index 0000000..183a9f3
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Thread.h
@@ -0,0 +1,128 @@
+/*
+ * 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_Thread.h
+ * @ingroup      OSAL
+ * @brief        thread API
+ ************************************************************************
+*/
+
+
+#ifndef M4OSA_THREAD_H
+#define M4OSA_THREAD_H
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_OptionID.h"
+
+
+/* Definition of common error codes */
+#define M4ERR_THREAD_NOT_STARTED M4OSA_ERR_CREATE(M4_ERR,M4OSA_THREAD,0x000001)
+
+
+typedef enum
+{
+   M4OSA_kThreadOpened   = 0x100,
+   M4OSA_kThreadStarting = 0x200,
+   M4OSA_kThreadRunning  = 0x300,
+   M4OSA_kThreadStopping = 0x400,
+   M4OSA_kThreadClosed  = 0x500
+} M4OSA_ThreadState;
+
+
+
+typedef enum
+{
+   M4OSA_kThreadHighestPriority  =  0x000,
+   M4OSA_kThreadHighPriority     =  0x100,
+   M4OSA_kThreadNormalPriority   =  0x200,
+   M4OSA_kThreadLowPriority      =  0x300,
+   M4OSA_kThreadLowestPriority   =  0x400
+} M4OSA_ThreadPriorityLevel;
+
+
+
+typedef enum
+{
+   M4OSA_ThreadStarted
+      = M4OSA_OPTION_ID_CREATE(M4_READ|M4_WRITE, M4OSA_THREAD, 0x01),
+
+   M4OSA_ThreadStopped
+      = M4OSA_OPTION_ID_CREATE(M4_READ|M4_WRITE, M4OSA_THREAD, 0x02),
+
+   M4OSA_ThreadPriority
+      = M4OSA_OPTION_ID_CREATE(M4_READ|M4_WRITE, M4OSA_THREAD, 0x03),
+
+   M4OSA_ThreadName
+      = M4OSA_OPTION_ID_CREATE(M4_READ|M4_WRITE, M4OSA_THREAD, 0x04),
+
+   M4OSA_ThreadStackSize
+      = M4OSA_OPTION_ID_CREATE(M4_READ|M4_WRITE, M4OSA_THREAD, 0x05),
+
+   M4OSA_ThreadUserData
+      = M4OSA_OPTION_ID_CREATE(M4_READ|M4_WRITE, M4OSA_THREAD, 0x06)
+
+} M4OSA_ThreadOptionID;
+
+
+
+typedef M4OSA_ERR  (*M4OSA_ThreadDoIt)(M4OSA_Void*);
+typedef M4OSA_Void (*M4OSA_ThreadCallBack)(M4OSA_Context, M4OSA_Void*);
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_threadSyncOpen(     M4OSA_Context*        context,
+                                    M4OSA_ThreadDoIt      func );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_threadSyncStart(    M4OSA_Context         context,
+                                    M4OSA_Void*           param );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_threadSyncStop(     M4OSA_Context         context );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_threadSyncClose(    M4OSA_Context         context );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_threadSyncGetState( M4OSA_Context         context,
+                                    M4OSA_ThreadState*    state );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_threadSleep(        M4OSA_UInt32          time );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_threadSyncSetOption(M4OSA_Context         context,
+                                    M4OSA_ThreadOptionID  option,
+                                    M4OSA_DataOption      value );
+
+
+M4OSAL_REALTIME_EXPORT_TYPE M4OSA_ERR M4OSA_threadSyncGetOption(M4OSA_Context         context,
+                                    M4OSA_ThreadOptionID  option,
+                                    M4OSA_DataOption*     value );
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /*M4OSA_THREAD_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Thread_priv.h b/libvideoeditor/osal/inc/M4OSA_Thread_priv.h
new file mode 100755
index 0000000..fb9a51a
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Thread_priv.h
@@ -0,0 +1,64 @@
+/*
+ * 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_Thread_priv.h
+ * @ingroup      OSAL
+ * @brief        Thread private for Android
+ * @note
+ ************************************************************************
+*/
+
+#ifndef M4OSA_THREAD_PRIV_H
+#define M4OSA_THREAD_PRIV_H
+
+
+#include "M4OSA_Types.h"
+
+
+/* Context for the thread */
+typedef struct M4OSA_ThreadContext {
+   M4OSA_UInt32 coreID;                /* thread context identifiant */
+   pthread_t threadID;                 /* thread identifier. */
+   M4OSA_Char* name;                   /* thread name */
+   M4OSA_UInt32 stackSize;             /* thread stackSize in bytes */
+   M4OSA_ThreadDoIt func;              /* thread function */
+   M4OSA_Void* param;                  /* thread parameter */
+/*
+   M4OSA_Void* userData;               / * thread user data * /
+*/
+   M4OSA_ThreadState state;            /* thread automaton state */
+   M4OSA_Context stateMutex;           /* mutex for thread state management */
+/*
+   M4OSA_ThreadCallBack startCallBack; / * starting thread call back * /
+   M4OSA_ThreadCallBack stopCallBack;  / * stopping thread call back * /
+*/
+   M4OSA_Context semStartStop;         /* semaphore for start and stop do_it */
+   M4OSA_ThreadPriorityLevel priority; /* thread priority level */
+} M4OSA_ThreadContext ;
+
+
+/** Those define enable/disable option ID*/
+#define M4OSA_OPTIONID_THREAD_STARTED           M4OSA_TRUE
+#define M4OSA_OPTIONID_THREAD_STOPPED           M4OSA_TRUE
+#define M4OSA_OPTIONID_THREAD_PRIORITY          M4OSA_TRUE
+#define M4OSA_OPTIONID_THREAD_STACK_SIZE        M4OSA_TRUE
+#define M4OSA_OPTIONID_THREAD_NAME              M4OSA_TRUE
+#define M4OSA_OPTIONID_THREAD_USER_DATA         M4OSA_TRUE
+
+#endif /*M4OSA_THREAD_PRIV_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Time.h b/libvideoeditor/osal/inc/M4OSA_Time.h
new file mode 100755
index 0000000..984c243
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Time.h
@@ -0,0 +1,164 @@
+/*
+ * 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_Time.h
+ * @ingroup      OSAL
+ * @brief        Time macros
+ * @note         This file defines time type and associated macros which must
+ *               be used to manipulate time.
+ ************************************************************************
+*/
+
+/* $Id: M4OSA_Time.h,v 1.2 2007/01/05 13:12:22 thenault Exp $ */
+
+#ifndef M4OSA_TIME_H
+#define M4OSA_TIME_H
+
+
+#include "M4OSA_Types.h"
+
+
+typedef M4OSA_Int64   M4OSA_Time;
+
+
+/** This macro sets the unknown time value */
+#ifdef M4OSA_64BITS_SUPPORTED
+   #define M4OSA_TIME_SET_UNKNOWN(time) {time = 0x8000000000000000LL ;}
+#endif /* M4OSA_64BITS_SUPPORTED */
+
+#ifdef M4OSA_64BITS_COUPLE_INT
+   #define M4OSA_TIME_SET_UNKNOWN(time) {\
+      time.major = 0x80000000 ;\
+      time.minor = 0x00000000 ;}
+#endif /* M4OSA_64BITS_COUPLE_INT */
+
+#ifdef M4OSA_64BITS_NOT_SUPPORTED
+   #define M4OSA_TIME_SET_UNKNOWN(time) {time = 0x80000000;}
+#endif   /* M4OSA_64BITS_NOT_SUPPORTED */
+
+
+/** This macro returns 1 if the provided time is set to unknown time,
+    and 0 else.*/
+#ifdef M4OSA_64BITS_SUPPORTED
+
+#define M4OSA_TIME_IS_UNKNOWN(time) (((M4OSA_UInt64)(time) == 0x8000000000000000LL) ? 1 : 0)
+
+#elif defined M4OSA_64BITS_COUPLE_INT
+
+#define M4OSA_TIME_IS_UNKNOWN(time)\
+   (( (M4OSA_INT64_GET_HIGH32(time) == M4OSA_unknownTimeMajor)\
+      &&(M4OSA_INT64_GET_LOW32(time) == M4OSA_unknownTimeMinor) ) ? 1:0)
+
+#else /* M4OSA_64BITS_NOT_SUPPORTED */
+
+#define M4OSA_TIME_IS_UNKNOWN(time) (((M4OSA_UInt32)(time) == 0x80000000) ? 1 : 0)
+
+#endif
+
+
+/** This macro affects time2 to time1.*/
+#define M4OSA_TIME_SET(time1, time2)\
+        M4OSA_INT64_SET(time1, time2)
+
+
+/** This macro sets time from i32.*/
+#define M4OSA_TIME_FROM_INT32(time, i32)\
+        M4OSA_INT64_FROM_INT32(time, i32)
+
+
+/** This macro sets time from i32 ui32.*/
+#define M4OSA_TIME_FROM_INT32_UINT32(time, i32, ui32)\
+        M4OSA_INT64_FROM_INT32_UINT32(time, i32, ui32)
+
+
+/** This macro tests if time is positive*/
+#define M4OSA_TIME_IS_POSITIVE(time)\
+        M4OSA_INT64_IS_POSITIVE(time)
+
+
+/** This macro sets time_out = -time_in*/
+#define M4OSA_TIME_NEG(time_out, time_in)\
+        M4OSA_INT64_NEG(time_out, time_in)
+
+
+/** This macro sets time_out = |time_in|*/
+#define M4OSA_TIME_ABS(time_out, time_in)\
+        M4OSA_INT64_ABS(time_out, time_in)
+
+
+/** This macro adds the 2 provided times (time1 and time2),
+    and writes the result in result. Both times must have the same timescale.*/
+#define M4OSA_TIME_ADD(result, time1, time2)\
+        M4OSA_INT64_ADD(result, time1, time2)
+
+
+/** This macro subs the 2 provided times (time1 and time2),
+    and writes the result in result.*/
+#define M4OSA_TIME_SUB(result, time1, time2)\
+        M4OSA_INT64_SUB(result, time1, time2)
+
+
+/** This macro does a scalar product (result = time*value),
+    and writes the result in result.*/
+#define M4OSA_TIME_SCALAR_PRODUCT(result, time, value)\
+        M4OSA_INT64_SCALAR_PRODUCT(result, time, value)
+
+
+/** This macro does a scalar division (result= time / value),
+    and writes the result in result.*/
+#define M4OSA_TIME_SCALAR_DIVISION(result, time, value)\
+        M4OSA_INT64_SCALAR_DIVISION(result, time, value)
+
+
+/** This macro updates the time to the oldTimeScale to the newTimeScale. The
+    result (the nearest rounded to the min value) is stored in result value. */
+#define M4OSA_TIME_CHANGE_TIMESCALE(result, time, oldTimeScale, newTimeScale)\
+      { M4OSA_Time t_tempTime1, t_tempTime2, t_tempTime3;\
+        M4OSA_Int32 i32_quotient = newTimeScale/oldTimeScale;\
+        M4OSA_Int32 i32_rest = newTimeScale%oldTimeScale;\
+        M4OSA_INT64_SCALAR_PRODUCT(t_tempTime1, time, i32_quotient);\
+        M4OSA_INT64_SCALAR_PRODUCT(t_tempTime2, time, i32_rest);\
+        M4OSA_INT64_SCALAR_DIVISION(t_tempTime3, t_tempTime2, oldTimeScale);\
+        M4OSA_INT64_ADD(result, t_tempTime1, t_tempTime3); }
+
+
+/** This macro tests the 2 provided times (time1 & time2).
+    The result is either:
+  * @arg  1: if time1 is bigger than time2
+  * @arg  0: if time2 is equal to time2
+  * @arg -1: if time1 is smaller than time2  */
+#define M4OSA_TIME_COMPARE(time1, time2)\
+        M4OSA_INT64_COMPARE(time1, time2)
+
+
+/** This macro converts a time with a time scale to millisecond.
+    The result is a M4OSA_Double*/
+#define M4OSA_TIME_TO_MS(result, time, timescale)\
+      { M4OSA_INT64_TO_DOUBLE(result, time);\
+        result = (1000*result)/((M4OSA_Double)timescale); }
+
+
+/** This macro converts a millisecond time to M4OSA_Time with the provided
+    timescale. The result (the nearest rounded to the min value) is stored
+    in time value.*/
+#define M4OSA_MS_TO_TIME(time, timescale, ms)\
+      {M4OSA_INT64_FROM_DOUBLE(time, (ms*((M4OSA_Double)(timescale))/1000.0));}
+
+
+#endif /*M4OSA_TIME_H*/
+
diff --git a/libvideoeditor/osal/inc/M4OSA_Types.h b/libvideoeditor/osal/inc/M4OSA_Types.h
new file mode 100755
index 0000000..250f131
--- /dev/null
+++ b/libvideoeditor/osal/inc/M4OSA_Types.h
@@ -0,0 +1,378 @@
+/*
+ * 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_Types.h
+ * @ingroup      OSAL
+ * @brief        Abstraction types for Android
+ * @note         This file redefines basic types which must be
+ *               used to declare any variable.
+************************************************************************
+*/
+
+
+#ifndef M4OSA_TYPES_H
+#define M4OSA_TYPES_H
+
+#include <ctype.h>
+#include "M4OSA_Export.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*#define M4OSA_64BITS_SUPPORTED     */  /* means long long is used        */
+/*#define M4OSA_64BITS_COUPLE_INT    */    /* means couple int32 is used    */
+#define M4OSA_64BITS_NOT_SUPPORTED      /* means Int32 is used            */
+
+
+typedef signed char     M4OSA_Bool;
+typedef unsigned char   M4OSA_UInt8;
+typedef signed char     M4OSA_Int8;
+typedef unsigned short  M4OSA_UInt16;
+typedef signed short    M4OSA_Int16;
+typedef unsigned long   M4OSA_UInt32;
+typedef signed long     M4OSA_Int32;
+
+typedef signed char     M4OSA_Char;
+typedef unsigned char   M4OSA_UChar;
+
+typedef double          M4OSA_Double;
+typedef float           M4OSA_Float;
+
+typedef unsigned char   M4OSA_WChar;
+
+typedef void            M4OSA_Void;
+
+typedef struct
+{
+   M4OSA_Int32   high;
+   M4OSA_Int32   low;
+} M4OSA_CoupleInt32;
+
+#ifdef M4OSA_64BITS_SUPPORTED
+typedef signed long long M4OSA_Int64;
+typedef unsigned long long M4OSA_UInt64;
+#endif
+
+#ifdef M4OSA_64BITS_COUPLE_INT
+typedef struct
+{
+   M4OSA_Int32 major;
+   M4OSA_UInt32 minor;
+} M4OSA_Int64;
+typedef struct
+{
+   M4OSA_UInt32 major;
+   M4OSA_UInt32 minor;
+} M4OSA_UInt64;
+#endif
+
+#ifdef M4OSA_64BITS_NOT_SUPPORTED
+typedef M4OSA_Int32 M4OSA_Int64;
+typedef M4OSA_UInt32 M4OSA_UInt64;
+#endif
+
+/* Min & max definitions*/
+#define M4OSA_UINT8_MIN                  0
+#define M4OSA_UINT8_MAX                255
+
+#define M4OSA_UINT16_MIN                 0
+#define M4OSA_UINT16_MAX             65535
+
+#define M4OSA_UINT32_MIN                 0
+#define M4OSA_UINT32_MAX        0xFFFFFFFF
+
+#define M4OSA_INT8_MIN                -128
+#define M4OSA_INT8_MAX                 127
+
+#define M4OSA_INT16_MIN             -32768
+#define M4OSA_INT16_MAX              32767
+
+#define M4OSA_INT32_MIN       (-0x7FFFFFFF-1)
+#define M4OSA_INT32_MAX         0x7FFFFFFF
+
+#define M4OSA_CHAR_MIN                -128
+#define M4OSA_CHAR_MAX                 127
+
+#define M4OSA_UCHAR_MIN                  0
+#define M4OSA_UCHAR_MAX                255
+
+#ifdef M4OSA_64BITS_NOT_SUPPORTED
+
+#define M4OSA_UINT64_MIN        M4OSA_UINT32_MIN
+#define M4OSA_UINT64_MAX        M4OSA_UINT32_MAX
+#define M4OSA_INT64_MIN          M4OSA_INT32_MIN
+#define M4OSA_INT64_MAX          M4OSA_INT32_MAX
+
+#else /* M4OSA_64BITS_NOT_SUPPORTED*/
+
+#define M4OSA_UINT64_MIN                       0
+#define M4OSA_UINT64_MAX      0xFFFFFFFFFFFFFFFFLL
+#define M4OSA_INT64_MIN       0x8000000000000000LL
+#define M4OSA_INT64_MAX       0x7FFFFFFFFFFFFFFFLL
+
+#endif /* M4OSA_64BITS_NOT_SUPPORTED*/
+
+#define M4OSA_NULL                     0x00
+#define M4OSA_TRUE                     0x01
+#define M4OSA_FALSE                    0x00
+#define M4OSA_WAIT_FOREVER       0xffffffff
+
+#define M4OSA_CONST                   const
+#define M4OSA_INLINE                 inline
+
+/* Rollover offset of the clock */
+/* This value must be the one of M4OSA_clockGetTime */
+#define M4OSA_CLOCK_ROLLOVER           M4OSA_INT32_MAX
+
+typedef void*                M4OSA_Context;
+
+
+/** It is a unique ID for each core component*/
+typedef  M4OSA_UInt16 M4OSA_CoreID;
+
+
+/* Macro to support big endian and little endian platform */
+
+/* to translate a 16 bits to its Big Endian value*/
+#define M4OSA_INT16_TO_BE(ui16_host) ((((ui16_host) & (M4OSA_UInt16) 0x00ff) << 8) | \
+                                      (((ui16_host) & (M4OSA_UInt16) 0xff00) >> 8) )
+
+/* to translate a 32 bits to its Big Endian value */
+#define M4OSA_INT32_TO_BE(ui32_host) ((((ui32_host) & (M4OSA_UInt32) 0x000000ff) << 24) | \
+                                      (((ui32_host) & (M4OSA_UInt32) 0x0000ff00) <<  8) | \
+                                      (((ui32_host) & (M4OSA_UInt32) 0x00ff0000) >>  8) | \
+                                      (((ui32_host) & (M4OSA_UInt32) 0xff000000) >>  24))
+
+/* to translate a 64 bits to its Big Endian value */
+#define M4OSA_INT64_TO_BE(ui64_host) ((((ui64_host) & (M4OSA_UInt64) 0x00000000000000ff) << 56) | \
+                                      (((ui64_host) & (M4OSA_UInt64) 0x000000000000ff00) << 40) | \
+                                      (((ui64_host) & (M4OSA_UInt64) 0x0000000000ff0000) << 24) | \
+                                      (((ui64_host) & (M4OSA_UInt64) 0x00000000ff000000) <<  8) | \
+                                      (((ui64_host) & (M4OSA_UInt64) 0x000000ff00000000) >>  8) | \
+                                      (((ui64_host) & (M4OSA_UInt64) 0x0000ff0000000000) >> 24) | \
+                                      (((ui64_host) & (M4OSA_UInt64) 0x00ff000000000000) >> 40) | \
+                                      (((ui64_host) & (M4OSA_UInt64) 0xff00000000000000) >> 56))
+
+/* to translate a Big Endian 16 bits to its host representation */
+#define M4OSA_BE_TO_INT16(ui16_net) ((((ui16_net) & (M4OSA_UInt16) 0x00ff) << 8) | \
+                                     (((ui16_net) & (M4OSA_UInt16) 0xff00) >> 8) )
+
+/* to translate a Big Endian 32 bits to its host representation*/
+#define M4OSA_BE_TO_INT32(ui32_net) ((((ui32_net) & (M4OSA_UInt32) 0x000000ff) << 24) | \
+                                     (((ui32_net) & (M4OSA_UInt32) 0x0000ff00) <<  8) | \
+                                     (((ui32_net) & (M4OSA_UInt32) 0x00ff0000) >>  8) | \
+                                     (((ui32_net) & (M4OSA_UInt32) 0xff000000) >>  24))
+
+/* to translate a Big Endian 64 bits to its host representation */
+#define M4OSA_BE_TO_INT64(ui64_net) ((((ui64_net) & (M4OSA_UInt64) 0x00000000000000ff) << 56) | \
+                                     (((ui64_net) & (M4OSA_UInt64) 0x000000000000ff00) << 40) | \
+                                     (((ui64_net) & (M4OSA_UInt64) 0x0000000000ff0000) << 24) | \
+                                     (((ui64_net) & (M4OSA_UInt64) 0x00000000ff000000) <<  8) | \
+                                     (((ui64_net) & (M4OSA_UInt64) 0x000000ff00000000) >>  8) | \
+                                     (((ui64_net) & (M4OSA_UInt64) 0x0000ff0000000000) >> 24) | \
+                                     (((ui64_net) & (M4OSA_UInt64) 0x00ff000000000000) >> 40) | \
+                                     (((ui64_net) & (M4OSA_UInt64) 0xff00000000000000) >> 56))
+
+/* to translate a 16 bits to its Little Endian value*/
+#define M4OSA_INT16_TO_LE(ui16_host) (ui16_host)
+
+/* to translate a 32 bits to its Little Endian value */
+#define M4OSA_INT32_TO_LE(ui32_host) (ui32_host)
+
+/* to translate a 64 bits to its Little Endian value */
+#define M4OSA_INT64_TO_LE(ui64_host) (ui64_host)
+
+/* to translate a Little Endian 16 bits to its host representation */
+#define M4OSA_LE_TO_INT16(ui16_net) (ui16_net)
+
+/* to translate a Little Endian 32 bits to its host representation*/
+#define M4OSA_LE_TO_INT32(ui32_net) (ui32_net)
+
+/* to translate a Little Endian 64 bits to its host representation */
+#define M4OSA_LE_TO_INT64(ui64_net) (ui64_net)
+
+
+/* Macro to manipulate M4OSA_Int32*/
+#define M4OSA_INT32_SET(i32_out, i32_in)\
+   { i32_out = i32_in; }
+
+#define M4OSA_INT32_ADD(i32_result, i32_a, i32_b)\
+   { i32_result = (i32_a) + (i32_b); }
+
+#define M4OSA_INT32_SUB(i32_result, i32_a, i32_b)\
+   { i32_result = (i32_a) - (i32_b); }
+
+#define M4OSA_INT32_SCALAR_PRODUCT(i32_result, i32_a, i32_value)\
+   { i32_result = (i32_a) * (i32_value); }
+
+#define M4OSA_INT32_SCALAR_DIVISION(i32_result, i32_a, i32_value)\
+   { i32_result = (i32_a) / (i32_value); }
+
+#define M4OSA_INT32_COMPARE(i32_a, i32_b)\
+   ( ((i32_a) == (i32_b)) ? 0 : ( ((i32_a) > (i32_b)) ? 1 : -1) )
+
+#define M4OSA_INT32_FROM_INT32(i32_result, i32_value)\
+   { i32_result = (M4OSA_Int32)(i32_value); }
+
+#define M4OSA_INT32_FROM_INT32_UINT32(i32_result, i32_high, ui32_low)\
+   { i32_result = (M4OSA_Int32)(ui32_low); }
+
+#define M4OSA_INT32_GET_LOW32(i32_value) ((M4OSA_Int32)(i32_value))
+
+#define M4OSA_INT32_GET_HIGH32(i32_value) (0)
+
+#define M4OSA_INT32_IS_POSITIVE(i32_value) ((i32_value) >= 0)
+
+#define M4OSA_INT32_NEG(i32_result, i32_value)\
+   { i32_result = -(i32_value); }
+
+#define M4OSA_INT32_ABS(i32_result, i32_value)\
+   { if ((i32_value) > 0) { i32_result = i32_value; }\
+     else                 { i32_result = -(i32_value); } }
+
+#define M4OSA_INT32_LEFT_SHIFT(i32_result, i32_value, ui32_nbPos)\
+   { i64_result = (((ui32_nbPos)>0x1F)?0:((i64_value)<<(ui32_nbPos))); }
+
+#define M4OSA_INT32_RIGHT_SHIFT(i32_result, i32_value, ui32_nbPos)\
+   { i64_result = (((ui32_nbPos)>0x1F)?0:((i64_value)>>(ui32_nbPos))); }
+
+#define M4OSA_INT32_TO_DOUBLE(f_result, i32_value)\
+   { f_result = (M4OSA_Double)(i32_value); }
+
+#define M4OSA_INT32_FROM_DOUBLE(i32_result, f_value)\
+   { i32_result = (M4OSA_Int32)(f_value); }
+
+
+#ifdef M4OSA_64BITS_SUPPORTED
+
+/* Macro to manipulate M4OSA_Int64*/
+#define M4OSA_INT64_SET(i64_out, i64_in) { i64_out = i64_in; }
+
+#define M4OSA_INT64_ADD(i64_result, i64_a, i64_b)\
+   { i64_result = (i64_a) + (i64_b); }
+
+#define M4OSA_INT64_SUB(i64_result, i64_a, i64_b)\
+   { i64_result = (i64_a) - (i64_b); }
+
+#define M4OSA_INT64_SCALAR_PRODUCT(i64_result, i64_a, i32_value)\
+   { i64_result = (i64_a) * (i32_value); }
+
+#define M4OSA_INT64_SCALAR_DIVISION(i64_result, i64_a, i32_value)\
+   { i64_result = (i64_a) / (i32_value); }
+
+#define M4OSA_INT64_COMPARE(i64_a, i64_b)\
+   ( ((i64_a) == (i64_b)) ? 0 : ( ((i64_a) > (i64_b)) ? 1 : -1) )\
+
+#define M4OSA_INT64_FROM_INT32(i64_result, i32_value)\
+   { i64_result = (M4OSA_Int64)(i32_value); }
+
+#define M4OSA_INT64_FROM_INT32_UINT32(i64_result, i32_high, ui32_low)\
+   { i64_result = (i32_high); i64_result = (i64_result<<32)+(ui32_low); }
+
+#define M4OSA_INT64_GET_LOW32(i64_value)\
+   ((M4OSA_Int32)((i64_value) & 0xFFFFFFFF))
+
+#define M4OSA_INT64_GET_HIGH32(i64_value)\
+   ((M4OSA_Int32)(((i64_value) >> 32) & 0xFFFFFFFF))
+
+#define M4OSA_INT64_IS_POSITIVE(i64_value) (((i64_value)>=0)?1:0)
+
+#define M4OSA_INT64_NEG(i64_result, i64_value)\
+   { i64_result = -(i64_value); }
+
+#define M4OSA_INT64_ABS(i64_result, i64_value)\
+   { if (M4OSA_INT64_IS_POSITIVE(i64_value)) { i64_result = i64_value; }\
+     else { M4OSA_INT64_NEG(i64_result, i64_value); } }
+
+#define M4OSA_INT64_LEFT_SHIFT(i64_result, i64_value, ui32_nbPos)\
+   { i64_result = (((ui32_nbPos)>0x3F)?0:((i64_value)<<(ui32_nbPos))); }
+
+#define M4OSA_INT64_RIGHT_SHIFT(i64_result, i64_value, ui32_nbPos)\
+   { i64_result = (((ui32_nbPos)>0x3F)?0:((i64_value)>>(ui32_nbPos))); }
+
+#define M4OSA_INT64_TO_DOUBLE(f_result, i64_value)\
+   { f_result = (M4OSA_Double)(i64_value); }
+
+#define M4OSA_INT64_FROM_DOUBLE(i64_result, f_value)\
+   { i64_result = (M4OSA_Int64)(f_value); }
+
+#endif   /*M4OSA_64BITS_SUPPORTED*/
+
+
+#ifdef M4OSA_64BITS_NOT_SUPPORTED
+
+#define M4OSA_INT64_SET(i64_out, i64_in)\
+        M4OSA_INT32_SET(i64_out, i64_in)
+
+#define M4OSA_INT64_ADD(i64_result, i64_a, i64_b)\
+        M4OSA_INT32_ADD(i64_result, i64_a, i64_b)
+
+#define M4OSA_INT64_SUB(i64_result, i64_a, i64_b)\
+        M4OSA_INT32_SUB(i64_result, i64_a, i64_b)
+
+#define M4OSA_INT64_SCALAR_PRODUCT(i64_result, i64_a, i32_value)\
+        M4OSA_INT32_SCALAR_PRODUCT(i64_result, i64_a, i32_value)
+
+#define M4OSA_INT64_SCALAR_DIVISION(i64_result, i64_a, i32_value)\
+        M4OSA_INT32_SCALAR_DIVISION(i64_result, i64_a, i32_value)
+
+#define M4OSA_INT64_COMPARE(i64_a, i64_b)\
+        M4OSA_INT32_COMPARE(i64_a, i64_b)
+
+#define M4OSA_INT64_FROM_INT32(i64_result, i32_value)\
+        M4OSA_INT32_FROM_INT32(i64_result, i32_value)
+
+#define M4OSA_INT64_FROM_INT32_UINT32(i64_result, i32_high, ui32_low)\
+        M4OSA_INT32_FROM_INT32_UINT32(i64_result, i32_high, ui32_low)
+
+#define M4OSA_INT64_GET_LOW32(i64_value)\
+        M4OSA_INT32_GET_LOW32(i64_value)
+
+#define M4OSA_INT64_GET_HIGH32(i64_value)\
+        M4OSA_INT32_GET_HIGH32(i64_value)
+
+#define M4OSA_INT64_IS_POSITIVE(i64_value)\
+        M4OSA_INT32_IS_POSITIVE(i64_value)
+
+#define M4OSA_INT64_NEG(i64_result, i64_value)\
+        M4OSA_INT32_NEG(i64_result, i64_value)
+
+#define M4OSA_INT64_ABS(i64_result, i64_value)\
+        M4OSA_INT32_ABS(i64_result, i64_value)
+
+#define M4OSA_INT64_LEFT_SHIFT(i64_result, i64_value, ui32_nbPositions)\
+        M4OSA_INT32_LEFT_SHIFT(i64_result, i64_value, ui32_nbPositions)
+
+#define M4OSA_INT64_RIGHT_SHIFT(i64_result, i64_value, ui32_nbPositions)\
+        M4OSA_INT32_RIGHT_SHIFT(i64_result, i64_value, ui32_nbPositions)
+
+#define M4OSA_INT64_TO_DOUBLE(f_result, i64_value)\
+        M4OSA_INT32_TO_DOUBLE(f_result, i64_value)
+
+#define M4OSA_INT64_FROM_DOUBLE(i64_result, f_value)\
+        M4OSA_INT32_FROM_DOUBLE(i64_result, f_value)
+
+#endif /*M4OSA_64BITS_NOT_SUPPORTED*/
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*M4OSA_TYPES_H*/
+
diff --git a/libvideoeditor/osal/src/Android.mk b/libvideoeditor/osal/src/Android.mk
new file mode 100755
index 0000000..bfb440b
--- /dev/null
+++ b/libvideoeditor/osal/src/Android.mk
@@ -0,0 +1,81 @@
+#

+# Copyright (C) 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.

+#

+

+LOCAL_PATH:= $(call my-dir)

+

+#

+# libvideoeditor_osal

+#

+

+include $(CLEAR_VARS)

+

+LOCAL_MODULE:= libvideoeditor_osal

+

+LOCAL_SRC_FILES:=          \

+    M4OSA_CharStar.c \

+    M4OSA_Clock.c \

+    M4OSA_FileCache.c \

+    M4OSA_FileCommon.c \

+    M4OSA_FileExtra.c \

+    M4OSA_FileReader.c \

+    M4OSA_FileReader_RAM.c \

+    M4OSA_FileWriter.c \

+    M4OSA_FileWriter_RAM.c \

+    M4OSA_Mutex.c \

+    M4OSA_Random.c \

+    M4OSA_Semaphore.c \

+    M4OSA_String.c \

+    M4OSA_String_priv.c \

+    M4OSA_Thread.c \

+    M4PSW_DebugTrace.c \

+    M4PSW_MemoryInterface.c \

+    M4PSW_Trace.c \

+    LVOSA_FileReader_optim.c

+

+LOCAL_MODULE_TAGS := development

+

+LOCAL_SHARED_LIBRARIES := libcutils libutils

+

+LOCAL_C_INCLUDES += \

+    $(TOP)/frameworks/media/libvideoeditor/osal/inc \

+

+ifeq ($(TARGET_SIMULATOR),true)

+else

+    LOCAL_SHARED_LIBRARIES += libdl

+endif

+

+# All of the shared libraries we link against.

+LOCAL_LDLIBS := \

+    -lpthread -ldl

+

+LOCAL_CFLAGS += -Wno-multichar \

+    -D__ANDROID__ \

+    -DM4OSA_FILE_BLOCK_WITH_SEMAPHORE \

+    -DUSE_STAGEFRIGHT_CODECS \

+    -DUSE_STAGEFRIGHT_AUDIODEC \

+    -DUSE_STAGEFRIGHT_VIDEODEC \

+    -DUSE_STAGEFRIGHT_AUDIOENC \

+    -DUSE_STAGEFRIGHT_VIDEOENC \

+    -DUSE_STAGEFRIGHT_READERS \

+    -DUSE_STAGEFRIGHT_3GPP_READER

+

+# Don't prelink this library.  For more efficient code, you may want

+# to add this library to the prelink map and set this to true.

+LOCAL_PRELINK_MODULE := false

+

+include $(BUILD_STATIC_LIBRARY)

+

diff --git a/libvideoeditor/osal/src/LVOSA_FileReader_optim.c b/libvideoeditor/osal/src/LVOSA_FileReader_optim.c
new file mode 100755
index 0000000..36541f0
--- /dev/null
+++ b/libvideoeditor/osal/src/LVOSA_FileReader_optim.c
@@ -0,0 +1,1076 @@
+/*
+ * 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_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_malloc(M4OSA_READBUFFER_SIZE, M4OSA_FILE_READER, "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)
+            M4OSA_free((M4OSA_MemAddr32)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;
+
+    M4OSA_memcpy(pData, 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);
+    }
+#if 0
+    fileSeekPosition = 0;
+    errno = apContext->FS->seek(apContext->aFileDesc, M4OSA_kFileSeekEnd, &fileSeekPosition);
+
+    if (M4NO_ERROR != errno)
+    {
+        apContext->readFilePos = M4OSA_EOF;
+        err = errno;
+        M4OSA_TRACE1_1("M4OSA_FileReader_CalculateSize ERR1 = 0x%x", err);
+    }
+    else
+    {
+        /* Retrieve size of the file */
+        errno = apContext->FS->getOption(apContext->aFileDesc,
+                                         M4OSA_kFileReadGetFilePosition,
+                                         (M4OSA_DataOption*) &apContext->fileSize);
+        if (M4NO_ERROR != errno)
+        {
+            err = errno;
+            M4OSA_TRACE1_1("M4OSA_FileReader_CalculateSize ERR2 = 0x%x", err);
+        }
+        apContext->readFilePos = apContext->fileSize;
+    }
+#endif
+#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_malloc(sizeof(M4OSA_FileReader_Context_optim),
+                                      M4OSA_FILE_READER, "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_malloc(sizeof(M4OSA_FileReadPointer),
+                                       M4OSA_FILE_READER, "NXPSW_FileReaderOptim_init");
+    if (M4OSA_NULL==apContext->FS)
+    {
+        M4OSA_TRACE1_0("NXPSW_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);
+        }
+
+        M4OSA_free((M4OSA_MemAddr32) 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)
+    {
+        M4OSA_free((M4OSA_MemAddr32) apContext->FS);
+    }
+    //<<<< GLM20090212 : set the low level function statically
+
+    /* Free the context */
+    M4OSA_free((M4OSA_MemAddr32)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;
+}
diff --git a/libvideoeditor/osal/src/M4OSA_CharStar.c b/libvideoeditor/osal/src/M4OSA_CharStar.c
new file mode 100755
index 0000000..4a865c1
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_CharStar.c
@@ -0,0 +1,1602 @@
+/*
+ * 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         M4DPAK_CharStar.c
+ * @ingroup
+  * @brief        definition of the Char Star set of functions.
+ * @note         This file defines the Char Star set of functions.
+ *
+ ************************************************************************
+*/
+
+
+#include "M4OSA_CharStar.h"
+#include "M4OSA_Memory.h"
+#include "M4OSA_Debug.h"
+
+/* WARNING: Specific Android */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strncpy().
+ * @note       It copies exactly len2Copy characters from pStrIn to pStrOut,
+ *             truncating  pStrIn or adding null characters to pStrOut if
+ *             necessary.
+ *             - If len2Copy is less than or equal to the length of pStrIn,
+ *               a null character is appended automatically to the copied
+ *               string.
+ *             - If len2Copy is greater than the length of pStrIn, pStrOut is
+ *               padded with null characters up to length len2Copy.
+ *             - pStrOut and pStrIn MUST NOT OVERLAP (this is NOT CHECKED).
+ * @param      pStrOut: (OUT) Destination character string.
+ * @param      pStrIn: (IN) Source character string.
+ * @param      len2Copy: (IN) Maximum number of characters from pStrIn to copy.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pStrOut is M4OSA_NULL.
+  ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrNCopy(M4OSA_Char* pStrOut, M4OSA_Char   *pStrIn, M4OSA_UInt32 len2Copy)
+{
+    M4OSA_TRACE1_3("M4OSA_chrNCopy\t(M4OSA_Char* %x,M4OSA_Char* %x,M4OSA_UInt32 %ld)",
+        pStrOut,pStrIn,len2Copy);
+    M4OSA_DEBUG_IF2((M4OSA_NULL == pStrOut),M4ERR_PARAMETER,
+                            "M4OSA_chrNCopy:\tpStrOut is M4OSA_NULL");
+    M4OSA_DEBUG_IF2((M4OSA_NULL == pStrIn),M4ERR_PARAMETER,
+                            "M4OSA_chrNCopy:\tpStrIn is M4OSA_NULL");
+
+    strncpy((char *)pStrOut, (const char *)pStrIn, (size_t)len2Copy);
+    if(len2Copy <= (M4OSA_UInt32)strlen((const char *)pStrIn))
+    {
+        pStrOut[len2Copy] = '\0';
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strncat().
+ * @note       It appends at most len2Append characters from pStrIn to the end
+ *             of pStrOut. The initial character of pStrIn overrides the null
+ *             character at the end of pStrOut. THIS LAST NULL CHARACTER IN
+ *             pStrOut MUST BE PRESENT.
+ *             - If a null character appears in pStrIn before len2Append
+ *               characters are appended, the function appends all characters
+ *               from pStrIn, up to this M4OSA_NULL character.
+ *             - If len2Append is greater than the length of pStrIn, the length
+ *               of pStrIn is used in place of len2Append. The resulting string
+ *               is terminated with a null character.
+ *             - pStrOut and pStrIn MUST NOT OVERLAP (this is NOT CHECKED).
+ * @param      pStrOut: (OUT) Destination character string.
+ * @param      pStrIn: (IN) character string to append.
+ * @param      len2Append: (IN) Max number of characters from pStrIn to append.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pStrOut is M4OSA_NULL.
+  ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrNCat(M4OSA_Char* pStrOut, M4OSA_Char* pStrIn,
+                                                        M4OSA_UInt32 len2Append)
+{
+    M4OSA_TRACE1_3("M4OSA_chrNCat\t(M4OSA_Char* %x,M4OSA_Char* %x,M4OSA_UInt32 %ld)",
+                            pStrOut,pStrIn,len2Append);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrOut, M4ERR_PARAMETER,
+                                       "M4OSA_chrNCat:\tpStrOut is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn,M4ERR_PARAMETER,
+                                        "M4OSA_chrNCat:\tpStrIn is M4OSA_NULL");
+
+    strncat((char *)pStrOut, (const char*)pStrIn, (size_t)len2Append);
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strcmp().
+ * @note       It compares pStrIn1 and pStrIn2 lexicographically.
+ *             The value returned in cmpResult is greater than, equal to, or
+ *             less than 0, if the string pointed to by pStrIn1 is greater than,
+ *             equal to, or less than the string pointed to by pStrIn2
+ *             respectively. The sign of a non-zero return value is determined
+ *             by the sign of the difference between the values of the first
+ *             pair of bytes that differ in the strings being compared.
+ * @param      pStrIn1: (IN) First character string.
+ * @param      pStrIn2: (IN) Second character string.
+ * @param      cmpResult: (OUT) Comparison result.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn1 pStrIn2 or cmpResult is M4OSA_NULL.
+  ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrCompare(M4OSA_Char* pStrIn1, M4OSA_Char* pStrIn2,
+                                                        M4OSA_Int32* pCmpResult)
+{
+    M4OSA_TRACE1_3("M4OSA_chrCompare\t(M4OSA_Char* %x,M4OSA_Char* %x,M4OSA_Int32* %x)",
+                    pStrIn1,pStrIn2,pCmpResult);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn1, M4ERR_PARAMETER,
+                                     "M4OSA_chrCompare:\tstrIn1 is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn2, M4ERR_PARAMETER,
+                                     "M4OSA_chrCompare:\tstrIn2 is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pCmpResult, M4ERR_PARAMETER,
+                                  "M4OSA_chrCompare:\tcmpResult is M4OSA_NULL");
+
+    *pCmpResult = (M4OSA_Int32)strcmp((const char *)pStrIn1, (const char *)pStrIn2);
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+  * @brief      This function mimics the functionality of the libc's strncmp().
+ * @note       It lexicographically compares at most the first len2Comp
+ *             characters in pStrIn1 and pStrIn2.
+ *             The value returned in cmpResult is greater than, equal to, or
+ *             less than 0, if the first len2Comp characters of the string
+ *             pointed to by pStrIn1 is greater than, equal to, or less than the
+ *             first len2Comp characters of the string pointed to by pStrIn2
+ *             respectively. The sign of a non-zero return value is determined
+ *             by the sign of the difference between the values of the first
+ *             pair of bytes that differ in the strings being compared.
+ * @param      pStrIn1: (IN) First character string.
+ * @param      pStrIn2: (IN) Second character string.
+ * @param      len2Comp: (IN) Length used for the comparison.
+ * @param      cmpResult: (OUT) Comparison result.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn1 pStrIn2 or cmpResult is M4OSA_NULL.
+  ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrNCompare(M4OSA_Char* pStrIn1,M4OSA_Char* pStrIn2,
+                            M4OSA_UInt32 len2Comp, M4OSA_Int32* pCmpResult)
+{
+    M4OSA_TRACE1_4("M4OSA_chrNCompare\t(M4OSA_Char* %x,M4OSA_Char* %x,"
+        "M4OSA_Int32 %ld, M4OSA_Int32* %x)",pStrIn1,pStrIn2,len2Comp,pCmpResult);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn1,M4ERR_PARAMETER,
+                                   "M4OSA_chrNCompare:\tpStrIn1 is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn2,M4ERR_PARAMETER,
+                                   "M4OSA_chrNCompare:\tpStrIn2 is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pCmpResult,M4ERR_PARAMETER,
+                                "M4OSA_chrNCompare:\tpCmpResult is M4OSA_NULL");
+
+    *pCmpResult = (M4OSA_Int32)strncmp((const char*)pStrIn1, (const char*)pStrIn2,
+                                                              (size_t)len2Comp);
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+  * @brief      This function returns the boolean comparison of pStrIn1 and pStrIn2.
+ * @note       The value returned in result is M4OSA_TRUE if the string
+ *             pointed to by pStrIn1 is strictly identical to the string pointed
+ *             to by pStrIn2, and M4OSA_FALSE otherwise.
+ * @param      pStrIn1: (IN) First character string.
+ * @param      pStrIn2: (IN) Second character string.
+ * @param      cmpResult: (OUT) Comparison result.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn1 pStrIn2 or cmpResult is M4OSA_NULL.
+  ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrAreIdentical(M4OSA_Char* pStrIn1, M4OSA_Char* pStrIn2,
+                                                            M4OSA_Bool* pResult)
+{
+    M4OSA_UInt32 i32,len32;
+    M4OSA_TRACE1_3("M4OSA_chrAreIdentical\t(M4OSA_Char* %x,M4OSA_Char* %x,"
+        "M4OSA_Int32* %x)",pStrIn1,pStrIn2,pResult);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn1, M4ERR_PARAMETER,
+                               "M4OSA_chrAreIdentical:\tpStrIn1 is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn2, M4ERR_PARAMETER,
+                               "M4OSA_chrAreIdentical:\tpStrIn2 is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pResult, M4ERR_PARAMETER,
+                               "M4OSA_chrAreIdentical:\tpResult is M4OSA_NULL");
+
+    len32 = (M4OSA_UInt32)strlen((const char *)pStrIn1);
+    if(len32 != (M4OSA_UInt32)strlen((const char *)pStrIn2))
+    {
+        *pResult = M4OSA_FALSE;
+        return M4NO_ERROR;
+    }
+
+    for(i32=0;i32<len32;i32++)
+    {
+        if(pStrIn1[i32] != pStrIn2[i32])
+        {
+            *pResult = M4OSA_FALSE;
+            return M4NO_ERROR;
+        }
+    }
+
+    *pResult = M4OSA_TRUE;
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strchr().
+ * @note       It finds the first occurrence (i.e. starting from the beginning
+ *             of the string) of c in pStrIn and set *pPointerInStr to this
+ *             position.
+ *             If no occurrence is found, *pPointerInStr is set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string where to search.
+ * @param      c: (IN) Character to search.
+ * @param      pPointerInStr: (OUT) pointer on the first occurrence of c.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pPointerInStr is M4OSA_NULL.
+ * @return     M4WAR_CHR_NOT_FOUND: no occurrence of c found.
+  ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrFindChar (M4OSA_Char* pStrIn, M4OSA_Char c,
+                                                            M4OSA_Char** pInStr)
+{
+    M4OSA_TRACE1_3("M4OSA_chrFindChar\t(M4OSA_Char* %x, M4OSA_Char %c"
+        "M4OSA_Char** %x)",pStrIn,c,pInStr);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn,M4ERR_PARAMETER,
+                                    "M4OSA_chrFindChar:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pInStr,M4ERR_PARAMETER,
+                                    "M4OSA_chrFindChar:\tpInStr is M4OSA_NULL");
+
+    *pInStr = (M4OSA_Char*)strchr((const char *)pStrIn,(int)c);
+    if(M4OSA_NULL == *pInStr)
+    {
+        return M4WAR_CHR_NOT_FOUND;
+    }
+    else
+    {
+        return M4NO_ERROR;
+    }
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strrchr().
+ * @note       It finds the last occurrence (i.e. starting from the end of the
+ *             string, backward) of c in pStrIn and set *pPointerInStr to this
+ *             position.
+ *             If no occurrence is found, *pPointerInStr is set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string where to search.
+ * @param      c: (IN) Character to search.
+ * @param      pPointerInStr: (OUT) pointer on the first occurrence of c.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pPointerInStr is M4OSA_NULL.
+ * @return     M4WAR_CHR_NOT_FOUND: no occurrence of c found.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrReverseFindChar(M4OSA_Char* pStrIn, M4OSA_Char c,M4OSA_Char** pInStr)
+{
+    M4OSA_TRACE1_3("M4OSA_chrReverseFindChar\t(M4OSA_Char* %x, M4OSA_Char %c"
+                        "M4OSA_Char** %x)",pStrIn,c,pInStr);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                             "M4OSA_chrReverseFindChar:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pInStr, M4ERR_PARAMETER,
+                             "M4OSA_chrReverseFindChar:\tpInStr is M4OSA_NULL");
+
+    *pInStr = (M4OSA_Char*)strrchr((const char *)pStrIn,(int)c);
+    if(M4OSA_NULL == *pInStr)
+    {
+        return M4WAR_CHR_NOT_FOUND;
+    }
+    else
+    {
+        return M4NO_ERROR;
+    }
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strspn().
+ * @note       It returns the length of the initial segment of string pStrIn
+ *             that consists entirely of characters from string pDelimiters
+ *             (it "spans" this set of characters).
+ *             If no occurrence of any character present in pDelimiters is found
+ *             at the beginning of pStrIn, *pPosInStr is M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string where to search.
+ * @param      pDelimiters: (IN) Character string containing the set of
+ *             characters to search.
+ * @param      pPosInStr: (OUT) Length of the initial segment.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn, pDelimiters or pPosInStr is M4OSA_NULL.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrSpan(M4OSA_Char* pStrIn,M4OSA_Char* pDelimiters,
+                                                        M4OSA_UInt32* pPosInStr)
+{
+    M4OSA_TRACE1_3("M4OSA_chrSpan\t(M4OSA_Char* %x,M4OSA_Char* %x"
+        "M4OSA_UInt32* %x)",pStrIn,pDelimiters,pPosInStr);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                        "M4OSA_chrSpan:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pDelimiters, M4ERR_PARAMETER,
+                                   "M4OSA_chrSpan:\tpDelimiters is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pPosInStr, M4ERR_PARAMETER,
+                                     "M4OSA_chrSpan:\tpPosInStr is M4OSA_NULL");
+
+    *pPosInStr = (M4OSA_UInt32)strspn((const char *)pStrIn,
+                                                     (const char *)pDelimiters);
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strcspn().
+ * @note       It returns the length of the initial segment of string pStrIn
+ *             that consists entirely of characters NOT from string delimiters
+ *             (it spans the complement of this set of characters).
+ *             If no occurrence of any character present in delimiters is found
+ *             in pStrIn, *pPosInStr is set to the length of pStrIn.
+ * @param      pStrIn: (IN) Character string where to search.
+ * @param      delimiters: (IN) Character string containing the set of
+ *             characters to search.
+ * @param      pPosInStr: (OUT) Length of the initial segment.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn, delimiters or pPosInStr is M4OSA_NULL.
+ * @return     M4WAR_CHR_NOT_FOUND: no occurrence of any character present in
+ *             delimiters has been found in pStrIn.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrSpanComplement (M4OSA_Char* pStrIn, M4OSA_Char* pDelimiters,
+                                                        M4OSA_UInt32* pPosInStr)
+{
+    M4OSA_TRACE1_3("M4OSA_chrSpanComplement\t(M4OSA_Char* %x,M4OSA_Char* %x"
+        "M4OSA_UInt32* %x)",pStrIn,pDelimiters,pPosInStr);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn,M4ERR_PARAMETER,
+                              "M4OSA_chrSpanComplement:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pDelimiters,M4ERR_PARAMETER,
+                         "M4OSA_chrSpanComplement:\tpDelimiters is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pPosInStr,M4ERR_PARAMETER,
+                           "M4OSA_chrSpanComplement:\tpPosInStr is M4OSA_NULL");
+
+    *pPosInStr = (M4OSA_UInt32)strcspn((const char *)pStrIn,
+                                                     (const char *)pDelimiters);
+    if(*pPosInStr < (M4OSA_UInt32)strlen((const char *)pStrIn))
+    {
+        return M4NO_ERROR;
+    }
+    else
+    {
+        return M4WAR_CHR_NOT_FOUND;
+    }
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strpbrk().
+ * @note       It returns a pointer to the first occurrence in string pStrIn
+ *             of any character from string pDelimiters, or a null pointer if
+ *             no character from pDelimiters exists in pStrIn. In the latter
+ *             case, WAR_NO_FOUND is returned.
+ * @param      pStrIn: (IN) Character string where to search.
+ * @param      pDelimiters: (IN) Character string containing the set of
+ *             characters to search.
+ * @param      pPointerInStr: (OUT) Pointer on the first character belonging to
+ *             pDelimiters.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn, pDelimiters or pPosInStr is M4OSA_NULL.
+ * @return     M4WAR_CHR_NOT_FOUND: no occurrence of any character present in
+ *             pDelimiters has been found in pStrIn.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrPbrk(M4OSA_Char* pStrIn, M4OSA_Char* pDelimiters,
+                                                     M4OSA_Char **pPointerInStr)
+{
+    M4OSA_TRACE1_3("M4OSA_chrPbrk\t(M4OSA_Char* %x,M4OSA_Char* %x"
+        "M4OSA_Char** %x)",pStrIn,pDelimiters,pPointerInStr);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn,M4ERR_PARAMETER,
+                              "M4OSA_chrSpanComplement:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pDelimiters,M4ERR_PARAMETER,
+                         "M4OSA_chrSpanComplement:\tpDelimiters is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pPointerInStr,M4ERR_PARAMETER,
+                       "M4OSA_chrSpanComplement:\tpPointerInStr is M4OSA_NULL");
+
+    *pPointerInStr = (M4OSA_Char*)strpbrk((const char *)pStrIn,
+                                                     (const char *)pDelimiters);
+    if(M4OSA_NULL == *pPointerInStr)
+    {
+        return M4WAR_CHR_NOT_FOUND;
+    }
+    else
+    {
+        return M4NO_ERROR;
+    }
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strstr().
+ * @note       It locates the first occurrence of the string pStrIn2 (excluding
+ *             the terminating null character) in string pStrIn1 and set
+ *             pPointerInStr1 to the located string, or to a null pointer if the
+ *             string is not found, in which case M4WAR_CHR_NOT_FOUND is
+ *             returned. If pStrIn2 points to a string with zero length (that
+ *             is, the string ""), the function returns pStrIn1.
+ * @param      pStrIn1: (IN) Character string where to search.
+ * @param      pStrIn2: (IN) Character string to search.
+ * @param      pPointerInStr1: (OUT) Pointer on the first character of pStrIn2
+ *             in pStrIn1.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn1, pStrIn2 or pPointerInStr1 is M4OSA_NULL.
+ * @return     M4WAR_CHR_NOT_FOUND: no occurrence of pStrIn2 has been found in
+ *             pStrIn1.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrFindPattern(M4OSA_Char* pStrIn1, M4OSA_Char* pStrIn2,
+                                                    M4OSA_Char** pPointerInStr1)
+{
+    M4OSA_TRACE1_3("M4OSA_chrFindPattern\t(M4OSA_Char* %x,M4OSA_Char* %x"
+        "M4OSA_Char** %x)",pStrIn1,pStrIn2,pPointerInStr1);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn1,M4ERR_PARAMETER,
+                                "M4OSA_chrFindPattern:\tpStrIn1 is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn2,M4ERR_PARAMETER,
+                                "M4OSA_chrFindPattern:\tpStrIn2 is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pPointerInStr1,M4ERR_PARAMETER,
+                         "M4OSA_chrFindPattern:\tpPointerInStr1 is M4OSA_NULL");
+
+    *pPointerInStr1 = (M4OSA_Char*)strstr((const char *)pStrIn1,
+                                                         (const char *)pStrIn2);
+    if(M4OSA_NULL == *pPointerInStr1)
+    {
+        return M4WAR_CHR_NOT_FOUND;
+    }
+    else
+    {
+        return M4NO_ERROR;
+    }
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's strlen().
+ * @note       It returns the number of characters in pStrIn, not including
+ *             the terminating null character.
+ *             This function have no return code. It does not check that pStrIn
+ *             does not point to null, nor is a valid character string (i.e.
+ *             null-terminated).
+ * @param      pStrIn: (IN) Character string.
+ * @return     number of characters in pStrIn.
+ ************************************************************************
+*/
+M4OSA_UInt32 M4OSA_chrLength(M4OSA_Char* pStrIn)
+{
+    M4OSA_TRACE1_1("M4OSA_chrLength\t(M4OSA_Char* %x)",pStrIn);
+    return (M4OSA_UInt32)strlen((const char *)pStrIn);
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's tolower().
+ * @note       It converts the character to lower case, if possible and
+ *             appropriate, and returns it.
+ * @param      cIn: (IN) Input character to convert.
+ * @return     converted character.
+ ************************************************************************
+*/
+M4OSA_Char M4OSA_chrToLower (M4OSA_Char cIn)
+{
+    M4OSA_TRACE1_1("M4OSA_chrToLower\t(M4OSA_Char %c)",cIn);
+    return (M4OSA_Char)tolower((int)cIn);
+}
+
+/**
+ ************************************************************************
+ * @brief      This function mimics the functionality of the libc's toupper().
+ * @note       It converts the character to upper case, if possible and
+ *             appropriate, and returns it.
+ * @param      cIn: (IN) Input character to convert.
+ * @return     converted character.
+ ************************************************************************
+*/
+M4OSA_Char M4OSA_chrToUpper(M4OSA_Char cIn)
+{
+    M4OSA_TRACE1_1("M4OSA_chrToUpper\t(M4OSA_Char %c)",cIn);
+    return (M4OSA_Char)toupper((int)cIn);
+}
+
+
+M4OSA_ERR M4OSA_chrGetWord(M4OSA_Char*    pStrIn,
+                           M4OSA_Char*    pBeginDelimiters,
+                           M4OSA_Char*    pEndDelimiters,
+                           M4OSA_Char*    pStrOut,
+                           M4OSA_UInt32*pStrOutMaxLen,
+                           M4OSA_Char** pOutputPointer)
+{
+    M4OSA_Char   *pTemp;
+    M4OSA_UInt32  pos;
+    M4OSA_ERR     errorCode;
+
+    M4OSA_TRACE1_4("M4OSA_chrGetWord\t(M4OSA_Char* %x,...,...,M4OSA_Char* %x,"
+        "M4OSA_UInt32* %x,M4OSA_Char** %x)",
+                                   pStrIn,pStrOut,pStrOutMaxLen,pOutputPointer);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                     "M4OSA_chrGetWord:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pBeginDelimiters, M4ERR_PARAMETER,
+                            "M4OSA_chrGetWord:\tbeginDelimiters is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pEndDelimiters, M4ERR_PARAMETER,
+                              "M4OSA_chrGetWord:\tendDelimiters is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrOut, M4ERR_PARAMETER,
+                                    "M4OSA_chrGetWord:\tpStrOut is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrOutMaxLen, M4ERR_PARAMETER,
+                               "M4OSA_chrGetWord:\tstrOutMaxLen is M4OSA_NULL");
+
+    errorCode = M4OSA_chrSpan(pStrIn, pBeginDelimiters, &pos);
+    pTemp     = pStrIn + pos;
+    errorCode = M4OSA_chrSpanComplement(pTemp, pEndDelimiters, &pos);
+    if(pos > *pStrOutMaxLen)
+    {
+        *pStrOutMaxLen = pos;
+        return M4ERR_CHR_STR_OVERFLOW;
+    }
+    if(pos)
+    {
+        M4OSA_memcpy((M4OSA_MemAddr8)pStrOut,(M4OSA_MemAddr8)pTemp, pos);
+    }
+    pStrOut[pos]   = '\0';
+    if(M4OSA_NULL != pOutputPointer)
+    {
+        *pOutputPointer = pTemp + pos;
+    }
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_UInt32 from string.
+ * @note       This function converts the first set of non-whitespace
+ *             characters of pStrIn to a M4OSA_UInt32 value pVal, assuming a
+ *             representation in base provided by the parameter base. pStrOut is
+ *             set to the first character of the string following the last
+ *             character of the number that has been converted.
+ *             - in case of a failure during the conversion, pStrOut is not
+ *               updated, and pVal is set to null.
+ *             - in case of negative number, pStrOut is not updated, and pVal is
+ *               set to null.
+ *             - in case of numerical overflow, pVal is set to M4OSA_UINT32_MAX.
+ *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             greater than M4OSA_UINT32_MAX.
+ * @return     M4WAR_CHR_NEGATIVE: the character string represents a negative
+ *             number.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetUInt32(M4OSA_Char*    pStrIn,
+                             M4OSA_UInt32*    pVal,
+                             M4OSA_Char**    pStrOut,
+                             M4OSA_chrNumBase base)
+{
+    M4OSA_UInt32 ul;
+    char*        pTemp;
+
+    M4OSA_TRACE1_4("M4OSA_chrGetUInt32\t(M4OSA_Char* %x, M4OSA_UInt32* %x"
+        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                   "M4OSA_chrGetUInt32:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                                     "M4OSA_chrGetUInt32:\tpVal is M4OSA_NULL");
+
+    errno = 0;
+    switch(base)
+    {
+    case M4OSA_kchrDec:
+        ul = strtoul((const char *)pStrIn, &pTemp, 10);
+        break;
+    case M4OSA_kchrHexa:
+        ul = strtoul((const char *)pStrIn, &pTemp,16);
+        break;
+    case M4OSA_kchrOct:
+        ul = strtoul((const char *)pStrIn, &pTemp,8);
+        break;
+    default:
+        return M4ERR_PARAMETER;
+    }
+
+    /* has conversion failed ? */
+    if((M4OSA_Char*)pTemp == pStrIn)
+    {
+        *pVal = 0;
+        return M4ERR_CHR_CONV_FAILED;
+    }
+
+    /* was the number negative ? */
+    if(*(pStrIn+strspn((const char *)pStrIn," \t")) == '-')
+    {
+        *pVal = 0;
+        return M4WAR_CHR_NEGATIVE;
+    }
+
+    /* has an overflow occured ? */
+    if(errno == ERANGE)
+    {
+        *pVal = M4OSA_UINT32_MAX;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* nominal case */
+    *pVal = (M4OSA_UInt32)ul;
+    if(M4OSA_NULL != pStrOut)
+    {
+        *pStrOut = (M4OSA_Char*)pTemp;
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_UInt16 from string.
+ * @note       This function converts the first set of non-whitespace
+ *             characters of pStrIn to a M4OSA_UInt16 value pVal, assuming a
+ *             representation in base provided by the parameter base. pStrOut is
+ *             set to the first character of the string following the last
+ *             character of the number that has been converted.
+ *             - in case of a failure during the conversion, pStrOut is not
+ *               updated, and pVal is set to null.
+ *             - in case of negative number, pStrOut is not updated, and pVal is
+ *               set to null.
+ *             - in case of numerical overflow, pVal is set to M4OSA_UINT16_MAX.
+ *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             greater than M4OSA_UINT16_MAX.
+ * @return     M4WAR_CHR_NEGATIVE: the character string represents a negative
+ *             number.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetUInt16 (M4OSA_Char* pStrIn, M4OSA_UInt16 *pVal,
+                              M4OSA_Char** pStrOut, M4OSA_chrNumBase base)
+{
+    M4OSA_UInt32 ul;
+    char*        pTemp;
+
+    M4OSA_TRACE1_4("M4OSA_chrGetUInt16\t(M4OSA_Char* %x, M4OSA_UInt16* %x"
+        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn,M4ERR_PARAMETER,
+                                   "M4OSA_chrGetUInt16:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                                     "M4OSA_chrGetUInt16:\tpVal is M4OSA_NULL");
+
+    switch(base)
+    {
+    case M4OSA_kchrDec:
+        ul = strtoul((const char *)pStrIn, &pTemp,10);
+        break;
+    case M4OSA_kchrHexa:
+        ul = strtoul((const char *)pStrIn, &pTemp,16);
+        break;
+    case M4OSA_kchrOct:
+        ul = strtoul((const char *)pStrIn, &pTemp,8);
+        break;
+    default:
+        return M4ERR_PARAMETER;
+    }
+
+    /* has conversion failed ? */
+    if((M4OSA_Char*)pTemp == pStrIn)
+    {
+        *pVal = 0;
+        return M4ERR_CHR_CONV_FAILED;
+    }
+
+    /* was the number negative ? */
+    if(*(pStrIn+strspn((const char *)pStrIn," \t")) == '-')
+    {
+        *pVal = 0;
+        return M4WAR_CHR_NEGATIVE;
+    }
+
+    /* has an overflow occured ? */
+    if(ul>M4OSA_UINT16_MAX)
+    {
+        *pVal = M4OSA_UINT16_MAX;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* nominal case */
+    *pVal = (M4OSA_UInt16)ul;
+    if(M4OSA_NULL != pStrOut)
+    {
+        *pStrOut = (M4OSA_Char*)pTemp;
+    }
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_UInt8 from string.
+ * @note       This function converts the first set of non-whitespace
+ *             characters of pStrIn to a M4OSA_UInt8 value pVal, assuming a
+ *             representation in base provided by the parameter base. pStrOut is
+ *             set to the first character of the string following the last
+ *             character of the number that has been converted.
+ *             - in case of a failure during the conversion, pStrOut is not
+ *               updated, and pVal is set to null.
+ *             - in case of negative number, pStrOut is not updated, and pVal is
+ *               set to null.
+ *             - in case of numerical overflow, pVal is set to M4OSA_UINT8_MAX.
+ *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             greater than M4OSA_UINT8_MAX.
+ * @return     M4WAR_CHR_NEGATIVE: the character string represents a negative
+ *             number.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetUInt8(M4OSA_Char*        pStrIn,
+                            M4OSA_UInt8*    pVal,
+                            M4OSA_Char**    pStrOut,
+                            M4OSA_chrNumBase base)
+{
+    M4OSA_UInt32 ul;
+    char*        pTemp;
+
+    M4OSA_TRACE1_4("M4OSA_chrGetUInt8\t(M4OSA_Char* %x, M4OSA_UInt8* %x"
+        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                    "M4OSA_chrGetUInt8:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                                      "M4OSA_chrGetUInt8:\tpVal is M4OSA_NULL");
+
+    switch(base)
+    {
+    case M4OSA_kchrDec:
+        ul = strtoul((const char *)pStrIn, &pTemp, 10);
+        break;
+    case M4OSA_kchrHexa:
+        ul = strtoul((const char *)pStrIn, &pTemp, 16);
+        break;
+    case M4OSA_kchrOct:
+        ul = strtoul((const char *)pStrIn, &pTemp, 8);
+        break;
+    default:
+        return M4ERR_PARAMETER;
+    }
+
+    /* has conversion failed ? */
+    if((M4OSA_Char*)pTemp == pStrIn)
+    {
+        *pVal = 0;
+        return M4ERR_CHR_CONV_FAILED;
+    }
+
+    /* was the number negative ? */
+    if(*(pStrIn+strspn((const char *)pStrIn," \t")) == '-')
+    {
+        *pVal = 0;
+        return M4WAR_CHR_NEGATIVE;
+    }
+
+    /* has an overflow occured ? */
+    if(ul>M4OSA_UINT8_MAX)
+    {
+        *pVal = M4OSA_UINT8_MAX;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* nominal case */
+    *pVal = (M4OSA_UInt8)ul;
+    if(M4OSA_NULL != pStrOut)
+    {
+        *pStrOut = (M4OSA_Char*)pTemp;
+    }
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_Int64 from string.
+ * @note       This function converts the first set of non-whitespace
+ *             characters of pStrIn to a M4OSA_Int64 value pVal, assuming a
+ *             decimal representation. pStrOut is set to the first character of
+ *             the string following the last character of the number that has
+ *             been converted.
+ *             - in case of a failure during the conversion, pStrOut is not
+ *               updated, and pVal is set to null.
+ *             - in case of numerical overflow or underflow, pVal is set to
+ *               M4OSA_INT64_MAX or M4OSA_INT64_MIN respectively.
+ *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ *             FOR THE MOMENT, ONLY DECIMAL REPRESENTATION IS HANDLED.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             greater than M4OSA_INT64_MAX or less than M4OSA_INT64_MIN
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetInt64(M4OSA_Char* pStrIn, M4OSA_Int64* pVal,
+                            M4OSA_Char** pStrOut, M4OSA_chrNumBase base)
+{
+#ifdef M4OSA_64BITS_SUPPORTED
+    M4OSA_Int64     maxVal   =  M4OSA_INT64_MAX; /* this is 2^63-1 */
+    M4OSA_Int64     minVal   =  M4OSA_INT64_MIN; /* this is -2^63+1 */
+    M4OSA_Char   maxStr[] =  "9223372036854775807";
+    M4OSA_Char*  beginNum;
+    M4OSA_UInt32 maxLen   = strlen((const char *)maxStr);
+    M4OSA_UInt32 chrCount = 0;
+    M4OSA_UInt8  negative = 0;
+
+    M4OSA_TRACE1_4((M4OSA_Char *)"M4OSA_chrGetInt64\t(M4OSA_Char* %x, M4OSA_UInt64* %x"
+        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                    "M4OSA_chrGetInt64:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                                      "M4OSA_chrGetInt64:\tpVal is M4OSA_NULL");
+
+    switch(base)
+    {
+    case M4OSA_kchrDec:
+        break;
+    case M4OSA_kchrOct:
+        return M4ERR_NOT_IMPLEMENTED;
+    case M4OSA_kchrHexa:
+        return M4ERR_NOT_IMPLEMENTED;
+    default:
+        return M4ERR_PARAMETER;
+    }
+
+    /* trim blank characters */
+    while (*pStrIn == ' ' || *pStrIn == '\t') pStrIn++;
+
+    /* get the sign */
+    if (*pStrIn == '+') pStrIn++;
+    else if (*pStrIn == '-')
+    {
+        negative = 1;
+        pStrIn++;
+    }
+    beginNum = pStrIn;
+
+    /* get the length of the numerical part */
+    while((*pStrIn >= '0') && (*pStrIn <= '9'))
+    {
+        pStrIn++;
+        chrCount++;
+    }
+
+    /* has conversion failed ? */
+    if(!chrCount)
+    {
+        *pVal = 0;
+        return M4ERR_CHR_CONV_FAILED;
+    }
+
+    /* has overflow (or underflow) occured ? */
+    if((chrCount > maxLen) /* obvious overflow (or underflow) */
+        ||
+        ((chrCount == maxLen) && (strncmp((const char *)beginNum,
+                                           (const char *)maxStr, maxLen) > 0)))
+        /* less obvious overflow (or underflow) */
+    {
+        if(negative)
+        {
+            *pVal = minVal;
+        }
+        else
+        {
+            *pVal = maxVal;
+        }
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = beginNum+chrCount;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* nominal case */
+    pStrIn = beginNum;
+    *pVal  = 0;
+    while((*pStrIn >= '0') && (*pStrIn <= '9'))
+    {
+        *pVal = (*pVal)*10 + (*pStrIn++ - '0');
+    }
+    if(negative)
+    {
+        *pVal = -*pVal;
+    }
+    if(M4OSA_NULL != pStrOut)
+    {
+        *pStrOut = pStrIn;
+    }
+    return M4NO_ERROR;
+#elif defined M4OSA_64BITS_NOT_SUPPORTED
+    return(M4OSA_chrGetInt32(pStrIn, (M4OSA_Int32*) pVal, pStrOut, M4OSA_kchrDec));
+#else
+    return(M4ERR_NOT_IMPLEMENTED);
+#endif
+
+                                   }
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_Int32 from string.
+ * @note       This function converts the first set of non-whitespace
+ *             characters of pStrIn to a M4OSA_Int32 value pVal, assuming a
+ *             representation in base provided by the parameter base. pStrOut is
+ *             set to the first character of the string following the last
+ *             character of the number that has been converted.
+ *             - in case of a failure during the conversion, pStrOut is not
+ *               updated, and pVal is set to null.
+ *             - in case of numerical overflow or underflow, pVal is set to
+ *               M4OSA_INT32_MAX or M4OSA_INT32_MIN respectively.
+ *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             greater than M4OSA_INT32_MAX or less than M4OSA_INT32_MIN
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetInt32(M4OSA_Char*        pStrIn,
+                            M4OSA_Int32*    pVal,
+                            M4OSA_Char**    pStrOut,
+                            M4OSA_chrNumBase base)
+{
+    M4OSA_Int32 l;
+    char*       pTemp;
+
+    M4OSA_TRACE1_4("M4OSA_chrGetInt32\t(M4OSA_Char* %x, M4OSA_Int32* %x"
+        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn,M4ERR_PARAMETER,
+                                    "M4OSA_chrGetInt32:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal,M4ERR_PARAMETER,
+                                      "M4OSA_chrGetInt32:\tpVal is M4OSA_NULL");
+
+    errno = 0;
+    switch(base)
+    {
+    case M4OSA_kchrDec:
+        l = strtol((const char *)pStrIn, &pTemp, 10);
+        break;
+    case M4OSA_kchrHexa:
+        l = strtol((const char *)pStrIn, &pTemp, 16);
+        break;
+    case M4OSA_kchrOct:
+        l = strtol((const char *)pStrIn, &pTemp, 8);
+        break;
+    default:
+        return M4ERR_PARAMETER;
+    }
+
+    /* has conversion failed ? */
+    if((M4OSA_Char*)pTemp == pStrIn)
+    {
+        *pVal = 0;
+        return M4ERR_CHR_CONV_FAILED;
+    }
+
+    /* has an overflow occured ? */
+    if((errno == ERANGE) && (l == M4OSA_INT32_MAX))
+    {
+        *pVal = M4OSA_INT32_MAX;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* has an underflow occured ? */
+    if((errno == ERANGE) && (l ==  M4OSA_INT32_MIN))
+    {
+        *pVal = M4OSA_INT32_MIN;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* nominal case */
+    *pVal = (M4OSA_Int32)l;
+    if(M4OSA_NULL != pStrOut)
+    {
+        *pStrOut = (M4OSA_Char*)pTemp;
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_Int16 from string.
+ * @note       This function converts the first set of non-whitespace
+ *             characters of pStrIn to a M4OSA_Int16 value pVal, assuming a
+ *             representation in base provided by the parameter base. pStrOut is
+ *             set to the first character of the string following the last
+ *             character of the number that has been converted.
+ *             - in case of a failure during the conversion, pStrOut is not
+ *               updated, and pVal is set to null.
+ *             - in case of numerical overflow or underflow, pVal is set to
+ *               M4OSA_INT16_MAX or M4OSA_INT16_MIN respectively.
+ *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             greater than M4OSA_INT16_MAX or less than M4OSA_INT16_MIN
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetInt16(M4OSA_Char*        pStrIn,
+                            M4OSA_Int16*    pVal,
+                            M4OSA_Char**    pStrOut,
+                            M4OSA_chrNumBase base)
+{
+    M4OSA_Int32 l;
+    char*       pTemp;
+
+    M4OSA_TRACE1_4("M4OSA_chrGetInt16\t(M4OSA_Char* %x, M4OSA_Int16* %x"
+        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                    "M4OSA_chrGetInt16:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                                      "M4OSA_chrGetInt16:\tpVal is M4OSA_NULL");
+
+    switch(base)
+    {
+    case M4OSA_kchrDec:
+        l = strtol((const char *)pStrIn, &pTemp, 10);
+        break;
+    case M4OSA_kchrHexa:
+        l = strtol((const char *)pStrIn, &pTemp, 16);
+        break;
+    case M4OSA_kchrOct:
+        l = strtol((const char *)pStrIn, &pTemp, 8);
+        break;
+    default:
+        return M4ERR_PARAMETER;
+    }
+
+    /* has conversion failed ? */
+    if((M4OSA_Char*)pTemp == pStrIn)
+    {
+        *pVal = 0;
+        return M4ERR_CHR_CONV_FAILED;
+    }
+
+    /* has an overflow occured ? */
+    if(l>M4OSA_INT16_MAX)
+    {
+        *pVal = M4OSA_INT16_MAX;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* has an underflow occured ? */
+    if(l<M4OSA_INT16_MIN)
+    {
+        *pVal = M4OSA_INT16_MIN;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* nominal case */
+    *pVal = (M4OSA_UInt16)l;
+    if(M4OSA_NULL != pStrOut)
+    {
+        *pStrOut = (M4OSA_Char*)pTemp;
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_Int8 from string.
+ * @note       This function converts the first set of non-whitespace
+ *             characters of pStrIn to a M4OSA_Int8 value pVal, assuming a
+ *             representation in base provided by the parameter base. pStrOut is
+ *             set to the first character of the string following the last
+ *             character of the number that has been converted.
+ *             - in case of a failure during the conversion, pStrOut is not
+ *               updated, and pVal is set to null.
+ *             - in case of numerical overflow or underflow, pVal is set to
+ *               M4OSA_INT8_MAX or M4OSA_INT8_MIN respectively.
+ *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             greater than M4OSA_INT8_MAX or less than M4OSA_INT8_MIN
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetInt8(M4OSA_Char*    pStrIn,
+                           M4OSA_Int8*    pVal,
+                           M4OSA_Char**    pStrOut,
+                           M4OSA_chrNumBase base)
+{
+    M4OSA_Int32 l;
+    char*       pTemp;
+
+    M4OSA_TRACE1_4("M4OSA_chrGetInt8\t(M4OSA_Char* %x, M4OSA_Int8* %x"
+                   "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,
+                                                                          base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                     "M4OSA_chrGetInt8:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                                       "M4OSA_chrGetInt8:\tpVal is M4OSA_NULL");
+
+    switch(base)
+    {
+    case M4OSA_kchrDec:
+        l = strtol((const char *)pStrIn, &pTemp, 10);
+        break;
+    case M4OSA_kchrHexa:
+        l = strtol((const char *)pStrIn, &pTemp, 16);
+        break;
+    case M4OSA_kchrOct:
+        l = strtol((const char *)pStrIn, &pTemp, 8);
+        break;
+    default:
+        return M4ERR_PARAMETER;
+    }
+
+    /* has conversion failed ? */
+    if((M4OSA_Char*)pTemp == pStrIn)
+    {
+        *pVal = 0;
+        return M4ERR_CHR_CONV_FAILED;
+    }
+
+    /* has an overflow occured ? */
+    if(l>M4OSA_INT8_MAX)
+    {
+        *pVal = M4OSA_INT8_MAX;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* has an underflow occured ? */
+    if(l<M4OSA_INT8_MIN)
+    {
+        *pVal = M4OSA_INT8_MIN;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* nominal case */
+    *pVal = (M4OSA_UInt8)l;
+    if(M4OSA_NULL != pStrOut)
+    {
+        *pStrOut = (M4OSA_Char*)pTemp;
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_Double from string.
+ * @note       This function converts the first set of non-whitespace
+ *             characters of pStrIn to a M4OSA_Double value pVal. pStrOut is set
+ *             to the first character of the string following the last
+ *             character of the number that has been converted.
+ *             - in case of a failure during the conversion, pStrOut is not
+ *               updated, and pVal is set to null.
+ *             - in case of numerical overflow or underflow, pVal is set to null
+ *             - if pStrOut is not to be used, it can be set to M4OSA_NULL.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: an underflow or overflow occurs during the
+ *             conversion.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetDouble(M4OSA_Char*    pStrIn,
+                             M4OSA_Double*    pVal,
+                             M4OSA_Char**    pStrOut)
+{
+    M4OSA_Double d;
+    char*        pTemp;
+
+    M4OSA_TRACE1_3("M4OSA_chrGetDouble\t(M4OSA_Char* %x, M4OSA_Double* %x"
+        "M4OSA_Char** %x)",pStrIn,pVal,pStrOut);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                   "M4OSA_chrGetDouble:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                                     "M4OSA_chrGetDouble:\tpVal is M4OSA_NULL");
+
+    errno = 0;
+    d = strtod((const char *)pStrIn, &pTemp);
+
+    /* has conversion failed ? */
+    if((M4OSA_Char*)pTemp == pStrIn)
+    {
+        *pVal = 0.0;
+        return M4ERR_CHR_CONV_FAILED;
+    }
+
+    /* has an overflow or underflow occured ? */
+    if(errno == ERANGE)
+    {
+        *pVal = 0.0;
+        if(M4OSA_NULL != pStrOut)
+        {
+            *pStrOut = (M4OSA_Char*)pTemp;
+        }
+        return M4WAR_CHR_NUM_RANGE;
+    }
+
+    /* nominal case */
+    *pVal = (M4OSA_Double)d;
+    if(M4OSA_NULL != pStrOut)
+    {
+        *pStrOut = (M4OSA_Char*)pTemp;
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_Time from string.
+ * @note       Since, M4OSA_Time is defined as M4OSA_Int64, it calls
+ *             M4OSA_chrGetInt64().
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             out of range.
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetTime(M4OSA_Char*    pStrIn,
+                           M4OSA_Time*    pVal,
+                           M4OSA_Char**    pStrOut,
+                           M4OSA_chrNumBase base)
+{
+    M4OSA_TRACE1_4("M4OSA_chrGetTime\t(M4OSA_Char* %x, M4OSA_Time* %x"
+        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                                     "M4OSA_chrGetTime:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                                       "M4OSA_chrGetTime:\tpVal is M4OSA_NULL");
+
+    return M4OSA_chrGetInt64(pStrIn,(M4OSA_Int64*)pVal,pStrOut,base);
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets a M4OSA_FilePosition from string.
+ * @note       Depending on the M4OSA_FilePosition definition, this function
+ *             calls the correspoding underlying type.
+ * @param      pStrIn: (IN) Character string.
+ * @param      pVal: (OUT) read value.
+ * @param      pStrOut: (OUT) Output character string.
+ * @param      base: (IN) Base of the character string representation.
+ * @return     M4NO_ERROR: there is no error.
+ * @return     M4ERR_PARAMETER: pStrIn or pVal is M4OSA_NULL.
+ * @return     M4ERR_CHR_CONV_FAILED: conversion failure.
+ * @return     M4WAR_CHR_NUM_RANGE: the character string represents a number
+ *             out of range.
+ ******************************************************************************
+*/
+M4OSA_ERR M4OSA_chrGetFilePosition(M4OSA_Char*            pStrIn,
+                                   M4OSA_FilePosition*    pVal,
+                                   M4OSA_Char**            pStrOut,
+                                   M4OSA_chrNumBase        base)
+{
+    M4OSA_TRACE1_4("M4OSA_chrGetFilePosition\t(M4OSA_Char* %x, M4OSA_FilePosition* %x"
+        "M4OSA_Char** %x,M4OSA_chrNumBase %d)",pStrIn,pVal,pStrOut,base);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrIn, M4ERR_PARAMETER,
+                             "M4OSA_chrGetFilePosition:\tpStrIn is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pVal, M4ERR_PARAMETER,
+                               "M4OSA_chrGetFilePosition:\tpVal is M4OSA_NULL");
+
+#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED
+    return M4OSA_chrGetInt64(pStrIn,(M4OSA_Int64*)pVal,pStrOut,base);
+#else
+    return M4OSA_chrGetInt32(pStrIn,(M4OSA_Int32*)pVal,pStrOut,base);
+#endif
+
+}
+
+M4OSA_ERR M4OSA_chrSPrintf(M4OSA_Char  *pStrOut, M4OSA_UInt32 strOutMaxLen,
+                           M4OSA_Char   *format, ...)
+{
+    va_list       marker;
+    M4OSA_Char   *pTemp;
+    M4OSA_Char   *percentPointer;
+    M4OSA_Char   *newFormat;
+    M4OSA_Int32  newFormatLength=0;
+    M4OSA_UInt32  count_ll = 0;
+    M4OSA_UInt32  count_tm = 0;
+    M4OSA_UInt32  count_aa = 0;
+    M4OSA_UInt32  count;
+    M4OSA_UInt32  nbChar;
+    M4OSA_Int32     err;
+    M4OSA_Char flagChar[]             = "'-+ #0";
+    M4OSA_Char widthOrPrecisionChar[] = "*0123456789";
+    M4OSA_Char otherPrefixChar[]      = "hlL";
+    M4OSA_Char conversionChar[]       = "diouxXnfeEgGcCsSp%";
+
+    M4OSA_TRACE1_3("M4OSA_chrSPrintf\t(M4OSA_Char* %x, M4OSA_UInt32 %ld"
+        "M4OSA_Char* %x)",pStrOut,strOutMaxLen,format);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrOut, M4ERR_PARAMETER,
+                                    "M4OSA_chrSPrintf:\tpStrOut is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == format, M4ERR_PARAMETER,
+                                     "M4OSA_chrSPrintf:\tformat is M4OSA_NULL");
+
+    va_start(marker,format);
+
+    /* count the number of %[flags][width][.precision]ll[conversion] */
+    pTemp = format;
+    while(*pTemp)
+    {
+        percentPointer = (M4OSA_Char *)strchr((const char *)pTemp,'%'); /* get the next percent character */
+        if(!percentPointer)
+            break;                            /* "This is the End", (c) J. Morrisson */
+        pTemp = percentPointer+1;           /* span it */
+        if(!*pTemp)
+            break;                            /* "This is the End", (c) J. Morrisson */
+        pTemp += strspn((const char *)pTemp,(const char *)flagChar);    /* span the optional flags */
+        if(!*pTemp)
+            break;                            /* "This is the End", (c) J. Morrisson */
+        pTemp += strspn((const char *)pTemp,(const char *)widthOrPrecisionChar); /* span the optional width */
+        if(!*pTemp)
+            break;                            /* "This is the End", (c) J. Morrisson */
+        if(*pTemp=='.')
+        {
+            pTemp++;
+            pTemp += strspn((const char *)pTemp, (const char *)widthOrPrecisionChar); /* span the optional precision */
+        }
+        if(!*pTemp)
+            break;                            /* "This is the End", (c) J. Morrisson */
+        if(strlen((const char *)pTemp)>=2)
+        {
+            if(!strncmp((const char *)pTemp,"ll",2))
+            {
+                count_ll++;                 /* I got ONE */
+                pTemp +=2;                  /* span the "ll" prefix */
+            }
+            else if(!strncmp((const char *)pTemp,"tm",2))
+            {
+                count_tm++;
+                pTemp +=2;
+            }
+            else if(!strncmp((const char *)pTemp,"aa",2))
+            {
+                count_aa++;
+                pTemp +=2;
+            }
+        }
+        pTemp += strspn((const char *)pTemp, (const char *)otherPrefixChar); /* span the other optional prefix */
+        if(!*pTemp)
+            break;                        /* "This is the End", (c) J. Morrisson */
+        pTemp += strspn((const char *)pTemp, (const char *)conversionChar);
+        if(!*pTemp)
+            break;                        /* "This is the End", (c) J. Morrisson */
+    }
+
+    count = count_ll + count_tm + count_aa;
+
+    if(!count)
+    {
+        err= vsnprintf((char *)pStrOut, (size_t)strOutMaxLen + 1, (const char *)format, marker);
+        va_end(marker);
+        if ((err<0) || ((M4OSA_UInt32)err>strOutMaxLen))
+        {
+            pStrOut[strOutMaxLen] = '\0';
+            return M4ERR_CHR_STR_OVERFLOW;
+        }
+        else
+        {
+            return M4NO_ERROR;
+        }
+    }
+
+
+    newFormatLength = strlen((const char *)format) + 1;
+
+#ifdef M4OSA_64BITS_SUPPORTED
+#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED
+    newFormatLength += (count_ll+count_tm+count_aa);
+#else
+    newFormatLength += (count_ll+count_tm-count_aa);
+#endif
+#elif defined M4OSA_64BITS_NOT_SUPPORTED
+    newFormatLength -= (count_ll+count_tm+count_aa);
+#else
+    return M4ERR_NOT_IMPLEMENTED;
+#endif
+
+    newFormat =(M4OSA_Char*)M4OSA_malloc(newFormatLength,
+        M4OSA_CHARSTAR,(M4OSA_Char*)"M4OSA_chrPrintf: newFormat");
+    if(M4OSA_NULL == newFormat)
+        return M4ERR_ALLOC;
+    newFormat[newFormatLength-1] = '\0';
+    pTemp = newFormat;
+
+    /* copy format to newFormat, replacing %[flags][width][.precision]ll[conversion]
+     * by %[flags][width][.precision]I64[conversion] */
+    while(*format)
+    {
+        nbChar = strcspn((const char *)format, "%");
+        if(nbChar)
+        {
+            strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy characters before the % character */
+            format +=nbChar;
+            pTemp   +=nbChar;
+        }
+        if(!*format) break;
+        *pTemp++ = *format++;                 /* copy the % character */
+        nbChar = strspn((const char *)format, (const char *)flagChar);
+        if(nbChar)
+        {
+            strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy the flag characters */
+            format +=nbChar;
+            pTemp   +=nbChar;
+        }
+        if(!*format) break;
+        nbChar = strspn((const char *)format, (const char *)widthOrPrecisionChar);
+        if(nbChar)
+        {
+            strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy the width characters */
+            format +=nbChar;
+            pTemp   +=nbChar;
+        }
+        if(!*format) break;
+        if(*format=='.')
+        {
+            *pTemp++ = *format++;              /* copy the dot character */
+            if(!format) break;
+            nbChar = strspn((const char *)format, (const char *)widthOrPrecisionChar);
+            if(nbChar)
+            {
+                strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy the width characters */
+                format +=nbChar;
+                pTemp   +=nbChar;
+            }
+            if(!format) break;
+        }
+        if(strlen((const char *)format)>=2)
+        {
+            if(!strncmp((const char *)format, "ll", 2))
+            {
+#ifdef M4OSA_64BITS_SUPPORTED
+                *pTemp++ = 'l'; /* %ll */
+                *pTemp++ = 'l';
+#else
+                *pTemp++ = 'l'; /* %l */
+#endif
+                format +=2;                         /* span the "ll" prefix */
+            }
+            else if(!strncmp((const char *)format, "tm", 2))
+            {
+#ifdef M4OSA_64BITS_SUPPORTED
+                *pTemp++ = 'l'; /* %ll */
+                *pTemp++ = 'l';
+#else
+                *pTemp++ = 'l'; /* %l */
+#endif
+                format +=2;                         /* span the "tm" prefix */
+            }
+            else if(!strncmp((const char *)format, "aa", 2))
+            {
+#ifdef M4OSA_64BITS_SUPPORTED
+#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED
+                *pTemp++ = 'l'; /* %ll */
+                *pTemp++ = 'l';
+#else
+                *pTemp++ = 'l';
+#endif
+#else
+                *pTemp++ = 'l';
+#endif
+                format +=2;                         /* span the "aa" prefix */
+            }
+        }
+        nbChar = strspn((const char *)format, (const char *)otherPrefixChar);
+        if(nbChar)
+        {
+            strncpy((char *)pTemp, (const char *)format, nbChar);      /* copy the other Prefix */
+            format +=nbChar;
+            pTemp   +=nbChar;
+        }
+        if(!*format) break;
+        nbChar = strspn((const char *)format, (const char *)conversionChar);
+        if(nbChar)
+        {
+            strncpy((char *)pTemp, (const char *)format, nbChar);
+            format += nbChar;
+            pTemp   += nbChar;
+        }
+        if(!*format) break;
+    }
+
+    /* Zero terminate the format string. */
+    (*pTemp) = '\0';
+
+    err = vsnprintf((char *)pStrOut, (size_t)strOutMaxLen + 1, (const char *)newFormat, marker);
+    va_end(marker);
+    M4OSA_free((M4OSA_MemAddr32)newFormat);
+    if ((err<0) || ((M4OSA_UInt32)err>strOutMaxLen))
+    {
+        pStrOut[strOutMaxLen] = '\0';
+        return M4ERR_CHR_STR_OVERFLOW;
+    }
+    else
+    {
+        return M4NO_ERROR;
+    }
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_Clock.c b/libvideoeditor/osal/src/M4OSA_Clock.c
new file mode 100755
index 0000000..9148fe6
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_Clock.c
@@ -0,0 +1,126 @@
+/*
+ * 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_Clock.c
+ * @brief        Clock related functions
+ * @note         This file implements functions to manipulate clock
+ ************************************************************************
+*/
+
+#include <sys/time.h>
+#include <time.h>
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_Clock.h"
+#include "M4OSA_Memory.h"
+#include "M4OSA_Types.h"
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This function gets an absolute time to an unknown reference with
+ *             a high precision.
+ * @note       It means it can only be used to get a relative time by computing
+ *             differences between to times.
+ *             It is to the caller to allocate time. Time is expressed in
+ *             timescale unit.
+ *             M4OSA_ROLLOVER_CLOCK in M4OSA_Types.h must be configured with the rollover
+ *             offset of this function.
+ * @param      time: (IN/OUT) time
+ * @param      timescale: (IN) The timescale (time unit per second)
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4WAR_TIMESCALE_TOO_BIG: the precision of the system clock is
+ *             not
+ *             compliant with the input timescale
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_clockGetTime(M4OSA_Time* pTime, M4OSA_UInt32 timescale)
+{
+    struct timeval tv;
+    struct timezone tz;
+#ifdef M4OSA_64BITS_NOT_SUPPORTED
+    M4OSA_UInt32 u32_time = 0;
+    M4OSA_UInt32 u32_time_hi;
+    M4OSA_UInt32 u32_time_lo;
+    M4OSA_UInt32 u32_time_lh;
+#else /* M4OSA_64BITS_SUPPORTED */
+    M4OSA_Int64 i64_time = 0;
+    M4OSA_Int64 i64_time_hi;
+    M4OSA_Int64 i64_time_lo;
+    M4OSA_Int64 i64_temp;
+#endif /* M4OSA_64BITS_SUPPORTED */
+    M4OSA_UInt32 factor;
+
+    M4OSA_TRACE1_2("M4OSA_clockGetTime\t\tM4OSA_Time* 0x%x\tM4OSA_UInt32 %d",
+                                                              pTime, timescale);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pTime, M4ERR_PARAMETER,
+                                     "M4OSA_clockGetTime: pTime is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(0 == timescale, M4ERR_PARAMETER,
+                                          "M4OSA_clockGetTime: timescale is 0");
+
+    factor = 1000000 / timescale;
+
+    if(gettimeofday(&tv, &tz) == 0)
+    {
+#ifdef M4OSA_64BITS_NOT_SUPPORTED
+        u32_time_lo = (tv.tv_sec & 0xFFFF) * timescale;
+        u32_time_hi = (((tv.tv_sec >> 16) & 0xFFFF) * timescale) + ((u32_time_lo >> 16) & 0xFFFF);
+        u32_time_lo &= 0xFFFF;
+        u32_time_lo += tv.tv_usec / factor;
+        u32_time_hi += ((u32_time_lo >> 16) & 0xFFFF);
+        u32_time_lo &= 0xFFFF;
+        u32_time = ((u32_time_hi & 0x7FFF) << 16) | u32_time_lo;
+#else /* M4OSA_64BITS_SUPPORTED */
+        tv.tv_usec /= factor;
+        M4OSA_INT64_FROM_INT32_UINT32(i64_time_hi, 0, tv.tv_sec);
+        M4OSA_INT64_FROM_INT32_UINT32(i64_time_lo, 0, tv.tv_usec);
+        M4OSA_INT64_SCALAR_PRODUCT(i64_temp, i64_time_hi, timescale);
+        M4OSA_INT64_ADD(i64_time, i64_temp, i64_time_lo);
+#endif /* M4OSA_64BITS_SUPPORTED */
+    }
+
+#ifdef M4OSA_64BITS_NOT_SUPPORTED
+    /* M4OSA_Time is signed, so we need to check the max value*/
+    if (u32_time > M4OSA_INT32_MAX)
+    {
+        u32_time = u32_time - M4OSA_INT32_MAX;
+    }
+
+    *pTime = (M4OSA_Time)u32_time;
+
+    if( timescale > 10000 )
+    {
+        return M4WAR_TIMESCALE_TOO_BIG;
+    }
+#else /* M4OSA_64BITS_SUPPORTED */
+    *pTime = (M4OSA_Time)i64_time;
+
+    if( timescale > 1000000 )
+    {
+        return M4WAR_TIMESCALE_TOO_BIG;
+    }
+#endif /* M4OSA_64BITS_SUPPORTED */
+
+    return M4NO_ERROR;
+}
diff --git a/libvideoeditor/osal/src/M4OSA_FileCache.c b/libvideoeditor/osal/src/M4OSA_FileCache.c
new file mode 100755
index 0000000..a804123
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_FileCache.c
@@ -0,0 +1,2978 @@
+/*
+ * 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_FileCache.c
+ *
+ * @brief        Osal File Reader and Writer with cache
+ * @note         This file implements functions to manipulate
+ *               filesystem access with intermediate buffers used to
+ *               read and to write.
+ *************************************************************************
+*/
+
+/**
+ *************************************************************************
+ * File cache buffers parameters (size, number of buffers, etc)
+ *************************************************************************
+*/
+#define M4OSA_CACHEBUFFER_SIZE    (8*1024)
+#define M4OSA_CACHEBUFFER_NB    6
+#define M4OSA_CACHEBUFFER_NONE    -1
+#define M4OSA_CACHEBUFFER_ALL    -2
+#define M4OSA_EOF               -1
+
+/** Strategy used by Osal File Cache to flush the buffers to disk.
+Depending on the service, the strategy will have more or less success */
+//#define BUFFER_SELECT_INITIAL        /** Initial implementation of Osal File Reader optim */
+//#define BUFFER_SELECT_WITH_TIME    /** To flush in priority the buffers which have not been used for a certain time */
+//#define BUFFER_SELECT_WITH_SPACE    /** To flush in priority the buffers which have not been used a lot of times */
+#define BUFFER_SELECT_WITH_POS    /** To flush in priority the buffers which have the smallest position on the file */
+
+/* to measure success of cache operations */
+//#define FILECACHE_STATS
+
+/* For performance measure */
+//#define M4OSA_FILE_CACHE_TIME_MEAS
+
+/***  To debug */
+//#define NO_STRATEGY
+//#define BUFFER_DISPLAY
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+#include "M4OSA_clock.h"
+
+typedef enum
+{
+    fileOpentime,
+    fileClosetime,
+    fileReadDatatime,
+    fileWriteDatatime,
+    fileSeektime,
+    fileGetOptiontime,
+    fileSetOptiontime,
+    fileExternalFlushtime,
+    enum_size    /* for enum size */
+} M4OSA_filetimeType;
+
+typedef    M4OSA_Time TabFiletime[enum_size+1];
+
+void M4OSA_FileCache_initTimeMeas(M4OSA_Context pContext);
+void M4OSA_FileCache_displayTimeMeas(M4OSA_Context pContext);
+
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+/* ANSI C*/
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/stat.h>
+/* End: ANSI C includes */
+
+#include "M4OSA_FileCommon.h"
+#include "M4OSA_FileReader.h"
+#include "M4OSA_FileWriter.h"
+
+#include "M4OSA_FileCache.h"
+
+#include "M4OSA_Memory.h"
+#include "M4OSA_Debug.h"
+#include "M4OSA_CharStar.h"
+#include "M4OSA_Mutex.h"
+
+
+#define LOCK \
+    M4OSA_mutexLock(apContext->m_mutex, M4OSA_WAIT_FOREVER);
+
+#define UNLOCK \
+    M4OSA_mutexUnlock(apContext->m_mutex);
+
+typedef struct
+{
+    M4OSA_Void*                FileDesc;
+} M4OSA_FileSystem_FFS_t_cache;
+
+typedef struct
+{
+    M4OSA_Void*        (*pFctPtr_Open)( M4OSA_Void* fd,
+                                       M4OSA_UInt32 FileModeAccess,
+                                       M4OSA_UInt16* errno_ffs );
+    M4OSA_FilePosition (*pFctPtr_Read)( M4OSA_Void* fd,
+                                       M4OSA_UInt8* data,
+                                       M4OSA_FilePosition size,
+                                       M4OSA_UInt16* errno_ffs );
+    M4OSA_FilePosition (*pFctPtr_Write)( M4OSA_Void* fd,
+                                         M4OSA_UInt8* data,
+                                         M4OSA_FilePosition size,
+                                         M4OSA_UInt16* errno_ffs );
+    M4OSA_FilePosition (*pFctPtr_Seek)( M4OSA_Void* fd,
+                                        M4OSA_FilePosition pos,
+                                        M4OSA_FileSeekAccessMode mode,
+                                        M4OSA_UInt16* errno_ffs );
+    M4OSA_FilePosition (*pFctPtr_Tell)( M4OSA_Void* fd,
+                                        M4OSA_UInt16* errno_ffs );
+    M4OSA_Int32        (*pFctPtr_Close)( M4OSA_Void* fd,
+                                         M4OSA_UInt16* errno_ffs );
+    M4OSA_Void         (*pFctPtr_AccessType)( M4OSA_UInt32 FileModeAccess_In,
+                                             M4OSA_Void* FileModeAccess_Out );
+
+} M4OSA_FileSystem_FctPtr_cache;
+
+M4OSA_Void* M4OSA_FileSystem_FFS_Open_cache( M4OSA_Void* pFileDescriptor,
+                                             M4OSA_UInt32 FileModeAccess,
+                                             M4OSA_UInt16* errno_ffs );
+M4OSA_Int32 M4OSA_FileSystem_FFS_Close_cache( M4OSA_Void* pContext,
+                                              M4OSA_UInt16* errno_ffs );
+M4OSA_FilePosition M4OSA_FileSystem_FFS_Read_cache( M4OSA_Void* pContext,
+                                                    M4OSA_UInt8* data,
+                                                    M4OSA_FilePosition size,
+                                                    M4OSA_UInt16* errno_ffs );
+M4OSA_FilePosition M4OSA_FileSystem_FFS_Write_cache( M4OSA_Void* pContext,
+                                                     M4OSA_UInt8* data,
+                                                     M4OSA_FilePosition size,
+                                                     M4OSA_UInt16* errno_ );
+M4OSA_Int32 M4OSA_FileSystem_FFS_Seek_cache( M4OSA_Void* pContext,
+                                             M4OSA_FilePosition pos,
+                                             M4OSA_FileSeekAccessMode mode,
+                                             M4OSA_UInt16* errno_ffs );
+M4OSA_FilePosition M4OSA_FileSystem_FFS_Tell_cache( M4OSA_Void* pContext,
+                                                    M4OSA_UInt16* errno_ffs );
+
+M4OSA_ERR M4OSA_fileOpen_cache_internal(M4OSA_Context* pContext,
+                                        M4OSA_Void* pFileDescriptor,
+                                        M4OSA_UInt32 FileModeAccess,
+                                        M4OSA_FileSystem_FctPtr_cache *FS);
+
+/*
+------------------User--------------------
+                   ^
+                   |
+--------    --------    ----------
+|Filled|    |Copied|    |Modified|
+--------    --------    ----------
+  ^
+  |
+------------------Disk--------------------
+
+Atomic states for a buffer:
+
+0x00    initialized or flushed (When it is initialized again, it is flushed if necessary)
+0x01    Filled from disk
+0x03    Filled and Copied to user
+
+0x80    Modified and newly created (does not exist on disk) => must be flushed
+0x83    Modified after having been read from disk => must be flushed
+
+*/
+
+typedef enum
+{
+    M4OSA_kInitialized = 0,
+    M4OSA_kFilled = 0x1,
+    M4OSA_kCopied = 0x2,
+    M4OSA_kModified = 0x80
+} M4OSA_FileCacheStateAtomic;
+
+
+/**
+ ******************************************************************************
+ * structure    M4OSA_FileCache_Buffer
+ * @brief       This structure defines the File Buffers context (private)
+ ******************************************************************************
+*/
+typedef struct
+{
+    M4OSA_MemAddr8      data;        /**< buffer data */
+    M4OSA_FilePosition  size;        /**< size of the buffer */
+    M4OSA_FilePosition  filepos;    /**< position in the file of the buffer's first octet */
+    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. to detect  dead buffers */
+
+    M4OSA_UInt32        nbAccessed;            /**< nb of times the buffer has been accessed without being reinitialized */
+    M4OSA_Time            timeAccessed;         /**< last time at which the buffer has been accessed without being reinitialized */
+
+    M4OSA_UInt8            state;
+} M4OSA_FileCache_Buffer;
+
+/**
+ ******************************************************************************
+ * structure    M4OSA_FileCache_Context
+ * @brief       This structure defines the File context (private)
+ * @note        This structure is used for all File 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 file pointer */
+    M4OSA_FilePosition     absolutePos;            /**< Virtual position for next reading */
+    M4OSA_FilePosition     absoluteWritePos;        /**< Virtual position for next writing */
+    M4OSA_FilePosition     fileSize;                /**< Size of the file */
+    M4OSA_FilePosition     virtualFileSize;        /**< Size of the file */
+
+    M4OSA_FileCache_Buffer buffer[M4OSA_CACHEBUFFER_NB];  /**< buffers */
+
+    M4OSA_Void*             aFileDesc;          /**< File descriptor */
+    M4OSA_FileSystem_FctPtr_cache *FS;                /**< Filesystem interface */
+
+#ifdef FILECACHE_STATS
+    M4OSA_UInt32        cacheSuccessRead;
+    M4OSA_UInt32        cacheSuccessWrite;
+    M4OSA_UInt32        nbReadCache;
+    M4OSA_UInt32        nbWriteCache;
+
+    M4OSA_UInt32        nbReadFFS;
+    M4OSA_UInt32        nbWriteFFS;
+#endif /* FILECACHE_STATS */
+    M4OSA_Context        m_mutex;
+
+    M4OSA_Time            chrono;
+    M4OSA_Char            m_filename[256];
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    TabFiletime            gMyPerfFileTab;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+} M4OSA_FileCache_Context;
+
+
+#define M4ERR_CHECK_NULL_RETURN_VALUE(retval, pointer) if ((pointer) == M4OSA_NULL) return (retval);
+
+/* used to detect dead buffers */
+#define MAX_FILLS_SINCE_LAST_ACCESS    M4OSA_CACHEBUFFER_NB*2
+
+
+/* __________________________________________________________ */
+/*|                                                          |*/
+/*|        Quick Sort function    (private)                     |*/
+/*|__________________________________________________________|*/
+
+M4OSA_Void M4OSA_FileCache_internalQuicksort(M4OSA_Int32* const table,
+                               const M4OSA_Int32 first , const M4OSA_Int32 last)
+ {
+    M4OSA_Int32 startIndex;
+    M4OSA_Int32 endIndex;
+    M4OSA_Int32 begin;
+    M4OSA_Int32 end;
+    M4OSA_Int32 pivot;
+    M4OSA_Int32 temp;
+    M4OSA_Int32 index=0;
+    M4OSA_Int32 size=0;
+    M4OSA_Int32 capacity = M4OSA_CACHEBUFFER_NB * 5;
+    //allocation of the fifo
+    M4OSA_Int32* queue = M4OSA_NULL;
+    M4OSA_Int32* cursor;
+    M4OSA_Int32* indexc;
+
+    queue = (M4OSA_Int32*)M4OSA_malloc(capacity*sizeof(M4OSA_Int32), 0,
+                                   (M4OSA_Char*) "quicksort FIFO of FileCache");
+
+    if(queue == M4OSA_NULL)
+        return;
+    cursor = queue;
+    indexc = queue;
+    *(cursor++) = first; //remember the array first element
+    *(cursor++) = last;    //remember the array end
+    index = 0;
+    size = 2;
+    do
+    {
+        startIndex   = *(indexc++);
+        endIndex    = *(indexc++);
+        index+=2;
+        if(startIndex < endIndex)
+        {
+            begin    = startIndex;
+            end        = endIndex;
+            pivot    = table[endIndex];
+            do
+            {
+                while ( (begin < endIndex) && (table[begin]<=pivot) )
+                    begin++;
+                while ( (end > begin) && (table[end]>=pivot) )
+                    end--;
+                if (begin < end)
+                {
+                    temp            = table[end];
+                    table[end]        = table[begin];
+                    table[begin]    = temp;
+                }
+            }while(begin < end);
+
+            temp            = table[endIndex];
+            table[endIndex]        = table[begin];
+            table[begin]    = temp;
+            *(cursor++) = startIndex;
+            *(cursor++) = begin-1;
+            *(cursor++) = begin+1;
+            *(cursor++) =  endIndex;
+            size+=4;
+            if(size==capacity)
+            {
+                M4OSA_TRACE1_0("Overflow in quickSort. increase capacity size");
+                return;
+            }
+        }
+    }
+    while(index<size);
+    cursor = NULL;
+    indexc = NULL;
+    M4OSA_free(queue);
+}
+
+M4OSA_Void M4OSA_FileCache_internalQuicksort64(M4OSA_Int64* const table,
+                               const M4OSA_Int32 first , const M4OSA_Int32 last)
+ {
+    M4OSA_Int32 startIndex;
+    M4OSA_Int32 endIndex;
+    M4OSA_Int32 begin;
+    M4OSA_Int32 end;
+    M4OSA_Int64 pivot;
+    M4OSA_Int64 temp;
+    M4OSA_Int32 index=0;
+    M4OSA_Int32 size=0;
+    M4OSA_Int32 capacity = M4OSA_CACHEBUFFER_NB * 5;
+    //allocation of the fifo
+    M4OSA_Int32* queue = M4OSA_NULL;
+    M4OSA_Int32* cursor;
+    M4OSA_Int32* indexc;
+
+    queue = (M4OSA_Int32*)M4OSA_malloc(capacity*sizeof(M4OSA_Int32), 0,
+                                   (M4OSA_Char*) "quicksort FIFO of FileCache");
+
+    if(queue == M4OSA_NULL)
+        return;
+    cursor = queue;
+    indexc = queue;
+    *(cursor++) = first; //remember the array first element
+    *(cursor++) = last;    //remember the array end
+    index = 0;
+    size = 2;
+    do
+    {
+        startIndex   = *(indexc++);
+        endIndex    = *(indexc++);
+        index+=2;
+        if(startIndex < endIndex)
+        {
+            begin    = startIndex;
+            end        = endIndex;
+            pivot    = table[endIndex];
+            do
+            {
+                while ( (begin < endIndex) && (table[begin]<=pivot) )
+                    begin++;
+                while ( (end > begin) && (table[end]>=pivot) )
+                    end--;
+                if (begin < end)
+                {
+                    temp            = table[end];
+                    table[end]        = table[begin];
+                    table[begin]    = temp;
+                }
+            }while(begin < end);
+
+            temp            = table[endIndex];
+            table[endIndex]        = table[begin];
+            table[begin]    = temp;
+            *(cursor++) = startIndex;
+            *(cursor++) = begin-1;
+            *(cursor++) = begin+1;
+            *(cursor++) =  endIndex;
+            size+=4;
+            if(size==capacity)
+            {
+                M4OSA_TRACE1_0("Overflow in quickSort. increase capacity size");
+                return;
+            }
+        }
+    }
+    while(index<size);
+    cursor = NULL;
+    indexc = NULL;
+    M4OSA_free(queue);
+}
+
+/* Sorts an array of size size */
+M4OSA_Void M4OSA_FileCache_QS_quickSort (M4OSA_FilePosition array[],
+                                                              M4OSA_UInt32 size)
+{
+    if (size==1 || size==0)
+    {
+        M4OSA_TRACE3_0("Sort not necessary");
+        return;
+    }
+
+    M4OSA_FileCache_internalQuicksort(array,0,size-1);
+}
+
+M4OSA_Void M4OSA_FileCache_QS_quickSort64 (M4OSA_Time array[], M4OSA_UInt32 size)
+{
+    if (size==1 || size==0)
+    {
+        M4OSA_TRACE3_0("Sort not necessary");
+        return;
+    }
+
+    M4OSA_FileCache_internalQuicksort64(array,0,size-1);
+}
+
+/* __________________________________________________________ */
+/*|                                                          |*/
+/*|   Buffer handling functions for RW access  (private)     |*/
+/*|__________________________________________________________|*/
+
+/**************************************************************/
+M4OSA_ERR M4OSA_FileCache_BuffersInit(M4OSA_FileCache_Context* apContext)
+/**************************************************************/
+{
+    M4OSA_UInt8 i;
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        apContext->buffer[i].state = M4OSA_kInitialized;
+        M4OSA_memset((M4OSA_MemAddr8)&(apContext->buffer[i]),
+                                            sizeof(M4OSA_FileCache_Buffer) , 0);
+    }
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        apContext->buffer[i].data = (M4OSA_MemAddr8) M4OSA_malloc(M4OSA_CACHEBUFFER_SIZE,
+                  M4OSA_FILE_READER, (M4OSA_Char*)"M4OSA_FileCache_BufferInit");
+        M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_ALLOC, apContext->buffer[i].data);
+        apContext->buffer[i].filepos = M4OSA_EOF;
+
+    }
+
+    return M4NO_ERROR;
+}
+
+/**************************************************************/
+M4OSA_Void M4OSA_FileCache_BuffersFree(M4OSA_FileCache_Context* apContext)
+/**************************************************************/
+{
+    M4OSA_UInt8 i;
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(apContext->buffer[i].data != M4OSA_NULL)
+        {
+            M4OSA_free((M4OSA_MemAddr32)apContext->buffer[i].data);
+            apContext->buffer[i].data = M4OSA_NULL;
+        }
+    }
+}
+
+#ifdef BUFFER_DISPLAY
+M4OSA_Void M4OSA_FileCache_BufferDisplay(M4OSA_FileCache_Context* apContext)
+{
+    M4OSA_UInt32 i;
+
+    M4OSA_TRACE1_0("------ Buffers display ");
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        M4OSA_TRACE1_5("------ Buf%d : FilePos=%d state=0x%x nbAccessed=%d -- timeAccessed=%d",
+                                                i, apContext->buffer[i].filepos,
+                                                apContext->buffer[i].state,
+                                                apContext->buffer[i].nbAccessed,
+                                                apContext->buffer[i].timeAccessed);
+    }
+    M4OSA_TRACE1_0("---------------------- ");
+}
+#endif
+
+
+/* reads from an existing buffer (number i) at absolute position pos and fills pData. it reads maximum one bloc */
+/**************************************************************/
+M4OSA_FilePosition M4OSA_FileCache_BufferCopy(M4OSA_FileCache_Context* apContext,
+                                              M4OSA_Int8 i, M4OSA_FilePosition pos,
+                                              M4OSA_FilePosition size,
+                                              M4OSA_MemAddr8 pData)
+/**************************************************************/
+{
+    M4OSA_FilePosition copysize;
+    M4OSA_FilePosition offset;
+
+    M4OSA_TRACE3_2("BufferCopy of %d, pos=%d", i, pos);
+
+    if(apContext->buffer[i].size == M4OSA_EOF) return M4OSA_EOF;
+
+    /* verification pos is inside buffer i*/
+    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;    /* offset to read from in the buffer */
+
+    copysize = apContext->buffer[i].size - offset;    /* buffer size - offset, it is the maximum we can read from a buffer */
+    copysize = (size < copysize) ? size : copysize; /* adjust in case user wants to read less than the data available in the buffer (copysize)
+                                                        in that case, take the min(copysize, size)*/
+
+    M4OSA_memcpy(pData, apContext->buffer[i].data + offset, copysize);
+
+    apContext->buffer[i].remain -= copysize;
+    apContext->buffer[i].nbFillSinceLastAcess = 0;
+
+
+    /* it is a read access */
+    apContext->buffer[i].nbAccessed++;
+    apContext->buffer[i].timeAccessed = apContext->chrono;
+    apContext->chrono++;
+
+
+    apContext->buffer[i].state |= M4OSA_kCopied;
+
+    return copysize;
+}
+
+/* writes on cache. at absolute position pos and writes pData to the buffer. it writes maximum one bloc */
+/**************************************************************/
+M4OSA_FilePosition M4OSA_FileCache_BufferModifyContent(M4OSA_FileCache_Context* apContext,
+                                                       M4OSA_Int8 i, M4OSA_FilePosition pos,
+                                                       M4OSA_FilePosition size,
+                                                       M4OSA_MemAddr8 pData)
+/**************************************************************/
+{
+    M4OSA_FilePosition copysize;
+    M4OSA_FilePosition offset, gridPos;
+
+    M4OSA_TRACE3_2("BufferModify of %d, pos=%d", i, pos);
+
+    /* Relocate to absolute postion if necessary */
+    gridPos = (pos / M4OSA_CACHEBUFFER_SIZE) * M4OSA_CACHEBUFFER_SIZE;
+
+    apContext->buffer[i].filepos = gridPos;
+
+    /* in case of an existing block (not at eof) */
+    if    (apContext->buffer[i].size != 0)
+    {
+        /* test if we are already inside this buffer */
+        if (   (pos < apContext->buffer[i].filepos)
+           || (pos > (apContext->buffer[i].filepos + M4OSA_CACHEBUFFER_SIZE)) )
+        {
+            M4OSA_TRACE1_0("BufferModify ERR nothing copied, should never happen");
+            return 0; /* nothing copied */
+        }
+    }
+
+    offset = pos - apContext->buffer[i].filepos;    /* offset to write to, in the buffer */
+
+    /* buffer size - offset, it is the maximum we can write into a buffer */
+    copysize = M4OSA_CACHEBUFFER_SIZE - offset;
+    /* adjust in case user wants to write less than the data available in the buffer (copysize) in that case, take the min(copysize, size)*/
+    copysize = (copysize < size) ? copysize : size;
+
+    M4OSA_memcpy(apContext->buffer[i].data + offset, pData, copysize);
+
+    /* update buffer size if it is a new buffer or expanded one*/
+    if (apContext->buffer[i].size < copysize+offset)
+    {
+        apContext->buffer[i].size = copysize+offset;
+    }
+
+    apContext->buffer[i].remain = M4OSA_CACHEBUFFER_SIZE - apContext->buffer[i].size; /* not temporary */
+
+    /* mark this buffer as modified */
+    apContext->buffer[i].state |= M4OSA_kModified;
+
+    apContext->buffer[i].nbFillSinceLastAcess = 0;
+    apContext->buffer[i].nbAccessed++;
+    apContext->buffer[i].timeAccessed = apContext->chrono;
+    apContext->chrono++;
+
+    return copysize;
+}
+
+
+/* writes in a buffer (number i) with the data read from disk*/
+/**************************************************************/
+M4OSA_ERR M4OSA_FileCache_BufferFill(M4OSA_FileCache_Context* apContext,
+                                     M4OSA_Int8 i, M4OSA_FilePosition pos)
+/**************************************************************/
+{
+    M4OSA_FilePosition gridPos;
+    M4OSA_FilePosition diff;
+    M4OSA_FilePosition size;
+    M4OSA_ERR err = M4NO_ERROR;
+    M4OSA_Int32 ret_val;
+    M4OSA_UInt16 errReturned;
+
+    M4OSA_TRACE3_2("BufferFill  i = %d  pos = %d", i, pos);
+
+    /* Avoid cycling statement because of EOF */
+    if(pos > apContext->virtualFileSize)
+            return M4WAR_NO_MORE_AU;
+
+    /* Relocate to absolute postion if necessary */
+    gridPos = (pos / M4OSA_CACHEBUFFER_SIZE) * M4OSA_CACHEBUFFER_SIZE;
+
+    /* diff is how much shall we fs_seek from current position to reach gridPos*/
+    diff = gridPos - apContext->readFilePos;
+
+    /* on some filesystems it is necessary to do a seek between an ffs read and ffs write even if it is same pos */
+        ret_val = apContext->FS->pFctPtr_Seek(apContext->aFileDesc,
+                                    diff, M4OSA_kFileSeekCurrent, &errReturned);
+        apContext->readFilePos = gridPos;
+
+        if(ret_val != 0)
+        {
+            err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errReturned);
+            M4OSA_TRACE2_1("M4OSA_FileCache_BufferFill ERR1 = 0x%x", err);
+            return err;
+        }
+    /* end. on some */
+
+/* the buffer will be reused to be filled with another filepos so reinit counters of access */
+    if (apContext->buffer[i].filepos  != gridPos)
+    {
+        apContext->buffer[i].nbAccessed = 0;
+        apContext->buffer[i].timeAccessed = 0;
+    }
+
+    /* stores the information relative to this buffer */
+    apContext->buffer[i].filepos = gridPos;
+
+    /* Read Data */
+    size = apContext->FS->pFctPtr_Read(apContext->aFileDesc,
+                                       (M4OSA_UInt8*)apContext->buffer[i].data,
+                                        M4OSA_CACHEBUFFER_SIZE, &errReturned);
+
+#ifdef FILECACHE_STATS
+    apContext->nbReadFFS++;
+#endif /* FILECACHE_STATS */
+
+    if(size == -1)
+    {
+        apContext->buffer[i].size = M4OSA_EOF;
+        apContext->buffer[i].remain = 0;
+
+        err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errReturned);
+        M4OSA_TRACE2_1("M4OSA_FileCache_BufferFill ERR2 = 0x%x", err);
+        return err;
+    }
+
+    apContext->buffer[i].size = size;
+    apContext->buffer[i].remain = size;
+    apContext->buffer[i].nbFillSinceLastAcess = 0;
+
+
+    /* Retrieve current position */
+    apContext->readFilePos = apContext->FS->pFctPtr_Tell(apContext->aFileDesc,
+                                                                  &errReturned);
+
+    if(   (apContext->buffer[i].size >= 0)
+       && (apContext->buffer[i].size < M4OSA_CACHEBUFFER_SIZE) )
+    {
+        err = M4WAR_NO_DATA_YET;
+        M4OSA_TRACE2_1("M4OSA_FileCache_BufferFill ERR3 = 0x%x", err);
+        return err;
+    }
+
+    /* mark this buffer as modified */
+    apContext->buffer[i].state |= M4OSA_kFilled;
+
+    /* it is a write access */
+    apContext->buffer[i].nbAccessed++;
+    apContext->buffer[i].timeAccessed = apContext->chrono;
+    apContext->chrono++;
+
+    /* Return without error */
+    return M4NO_ERROR;
+}
+
+/*  Reinitializes a buffer for filling it for data at end of file. fileposition is given */
+/**************************************************************/
+M4OSA_ERR M4OSA_FileCache_BufferReinitialize(M4OSA_FileCache_Context* apContext,
+                                           M4OSA_Int8 i, M4OSA_FilePosition pos)
+/**************************************************************/
+{
+    M4OSA_FilePosition gridPos;
+    M4OSA_ERR err = M4NO_ERROR;
+
+    M4OSA_MemAddr8 saveDataAddress;
+
+    M4OSA_TRACE3_2("BufferReinitialize i = %d  pos = %d", i, pos);
+
+    /* Relocate to absolute postion if necessary */
+    if (pos != -1)
+        gridPos = (pos / M4OSA_CACHEBUFFER_SIZE) * M4OSA_CACHEBUFFER_SIZE;
+    else
+        gridPos = -1;
+
+    /* RAZ the buffer, only "data address" stays*/
+    saveDataAddress = apContext->buffer[i].data;
+
+    M4OSA_memset((M4OSA_MemAddr8)&(apContext->buffer[i]),
+                                            sizeof(M4OSA_FileCache_Buffer) , 0);
+
+    /* put again the precious "data address" previously allocated */
+    apContext->buffer[i].data = saveDataAddress;
+
+    /* initializations already done in the memset: */
+    /* mark this buffer as initialized*/
+    apContext->buffer[i].state= M4OSA_kInitialized;
+    apContext->buffer[i].nbAccessed = 0;
+    apContext->buffer[i].timeAccessed = 0;
+
+    /* Relocate to absolute postion if necessary */
+    apContext->buffer[i].filepos = gridPos;
+
+    /* Return without error */
+    return M4NO_ERROR;
+}
+
+
+/* flushes a buffer (number i) to the disk*/
+/**************************************************************/
+M4OSA_ERR M4OSA_FileCache_BufferFlush(M4OSA_FileCache_Context* apContext,
+                                                                  M4OSA_UInt8 i)
+/**************************************************************/
+{
+    M4OSA_FilePosition gridPos, pos;
+    M4OSA_FilePosition diff;
+    M4OSA_FilePosition size;
+    M4OSA_ERR err = M4NO_ERROR;
+    M4OSA_Int32 ret_val;
+    M4OSA_UInt16 errReturned;
+
+    M4OSA_TRACE3_2("BufferFlush of buffer i=%d its pos=%d", i,
+                                                  apContext->buffer[i].filepos);
+
+    pos = apContext->buffer[i].filepos;
+
+    /* Relocate to absolute postion if necessary */
+    gridPos = (pos / M4OSA_CACHEBUFFER_SIZE) * M4OSA_CACHEBUFFER_SIZE;
+
+    /* diff is how much shall we fs_seek from current position to reach gridPos*/
+    diff = gridPos - apContext->readFilePos;
+
+    if (pos > apContext->fileSize)
+    {
+        M4OSA_TRACE1_2("M4OSA_FileCache_BufferFlush: Error! Attempt to seek at pos=%d, whilst fileSize=%d ",
+                                                      pos, apContext->fileSize);
+        return M4WAR_NO_MORE_AU;
+    }
+
+    /* on some filesystems it is necessary to do a seek between an ffs read and ffs write even if it is same pos */
+        ret_val = apContext->FS->pFctPtr_Seek(apContext->aFileDesc, diff,
+                                          M4OSA_kFileSeekCurrent, &errReturned);
+        apContext->readFilePos = gridPos;
+
+        if(ret_val != 0)
+        {
+            err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errReturned);
+            M4OSA_TRACE1_1("M4OSA_FileCache_BufferFill ERR1 = 0x%x", err);
+            return err;
+        }
+    /* end: on some filesystems*/
+
+    /* update the read file pos after the seek */
+    apContext->readFilePos = apContext->buffer[i].filepos;
+
+    /* Write Data */
+    size = apContext->FS->pFctPtr_Write(apContext->aFileDesc,
+                                        (M4OSA_UInt8*)apContext->buffer[i].data,
+                                        apContext->buffer[i].size, &errReturned);
+#ifdef FILECACHE_STATS
+    apContext->nbWriteFFS++;
+#endif /* FILECACHE_STATS */
+     /* verify if all data requested to be written, has been written */
+    if(size < apContext->buffer[i].size)
+    {
+        apContext->buffer[i].size = M4OSA_EOF;
+        apContext->buffer[i].remain = 0;
+
+        err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errReturned);
+        M4OSA_TRACE1_1("M4OSA_FileCache_BufferFlush ERR2 = 0x%x", err);
+        return err;
+    }
+
+    /* Retrieve current position */
+    apContext->readFilePos = apContext->FS->pFctPtr_Tell(apContext->aFileDesc,
+                                                                  &errReturned);
+
+    apContext->fileSize = (apContext->readFilePos > apContext->fileSize) ? apContext->readFilePos : apContext->fileSize;
+
+    /* mark this buffer as not modified */
+    apContext->buffer[i].state &= ~(M4OSA_kModified);
+
+    /* Return without error */
+    return M4NO_ERROR;
+}
+
+/* flushes all modified buffers until the position of buffer i
+if index is M4OSA_CACHEBUFFER_ALL then flush all*/
+/**************************************************************/
+M4OSA_ERR M4OSA_FileCache_BuffersFlushUntil(M4OSA_FileCache_Context* apContext,
+                                                               M4OSA_Int8 index)
+/**************************************************************/
+{
+    M4OSA_UInt8 i, j, howManyToFlush;
+    M4OSA_FilePosition bufPos[M4OSA_CACHEBUFFER_NB];
+    M4OSA_Bool flushed = M4OSA_FALSE;
+    M4OSA_ERR err = M4NO_ERROR;
+
+
+    i=0;
+    for(j=0; j<M4OSA_CACHEBUFFER_NB; j++)
+    {
+        if ( ((apContext->buffer[j].state & M4OSA_kModified) == M4OSA_kModified)                    )
+        {
+            bufPos[i] = apContext->buffer[j].filepos;
+            i++;
+        }
+    }
+    howManyToFlush = i;
+
+    if (howManyToFlush == 0)
+    {
+        M4OSA_TRACE2_0("BuffersFlush : no flush needed");
+        return M4NO_ERROR;
+    }
+    else if (howManyToFlush == 1)
+    {
+        goto flushing;
+    }
+
+    M4OSA_FileCache_QS_quickSort(bufPos, howManyToFlush);
+
+flushing:
+    if (index == M4OSA_CACHEBUFFER_ALL)
+    {/* simply flush all buffers in order of positions */
+        for(j=0; j<howManyToFlush; j++)
+        {
+            for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+            if (apContext->buffer[i].filepos == bufPos[j] )
+            {
+                M4OSA_TRACE2_2("M4OSA_FileCache_BuffersFlushUntil(1) : We Need to Flush buffer %d its pos=%d",
+                                               i, apContext->buffer[i].filepos);
+                err = M4OSA_FileCache_BufferFlush(apContext, i);
+                if (M4NO_ERROR!= err)
+                {
+                    return err;
+                }
+                break;
+            }
+        }
+    }
+    else
+    { /* there is a given index to flush until it*/
+        for(j=0; j<howManyToFlush; j++)
+        {
+            for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+            {
+                if (
+                        apContext->buffer[i].filepos == bufPos[j]
+                        && apContext->buffer[i].filepos <= apContext->buffer[index].filepos
+                        && apContext->buffer[i].filepos >= apContext->fileSize - M4OSA_CACHEBUFFER_SIZE
+                    )
+                    {
+                        M4OSA_TRACE2_2("M4OSA_FileCache_BuffersFlushUntil(2) : We Need to Flush buffer %d its pos=%d",
+                                               i, apContext->buffer[i].filepos);
+                        err = M4OSA_FileCache_BufferFlush(apContext, i);
+                        if (M4NO_ERROR!= err)
+                        {
+                            return err;
+                        }
+                        if (i==index)
+                        {    /* the buffer with the given index has been flushed */
+                            flushed = M4OSA_TRUE;
+                        }
+                        break;
+                    }
+            }
+
+        }
+
+        if (M4OSA_TRUE == flushed)
+        {
+            err = M4NO_ERROR;
+        }
+        else
+        {
+            M4OSA_TRACE1_1("M4OSA_FileCache_BuffersFlushUntil err=0x%x", err);
+            err = M4ERR_BAD_CONTEXT;
+        }
+
+    }
+
+    return err;
+
+}
+
+#ifdef BUFFER_DISPLAY
+M4OSA_Void M4OSA_FileCache_BufferDisplay(M4OSA_FileCache_Context* apContext)
+{
+    M4OSA_UInt32 i;
+
+    M4OSA_TRACE1_0("------ Buffers display ");
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        M4OSA_TRACE1_3("------ Buf%d : FilePos=%d state=0x%x ",
+                   i, apContext->buffer[i].filepos, apContext->buffer[i].state);
+#ifdef BUFFER_DATE
+        M4OSA_TRACE1_2("nbAccessed=%d - nbModified =%d",
+              apContext->buffer[i].nbAccessed, apContext->buffer[i].nbModified);
+        M4OSA_TRACE1_2("timeAccessed=%d - timeModified =%d",
+                                              apContext->buffer[i].timeAccessed,
+                                               apContext->buffer[i].timeModified);
+#endif /* BUFFER_DATE */
+    }
+    M4OSA_TRACE1_0("---------------------- ");
+}
+#endif
+
+
+/* provides the buffer corresponding to a position pos
+and with pos inside the read data into this buffer
+else returns CACHE_BUFFER_NONE*/
+/**************************************************************/
+M4OSA_Int8 M4OSA_FileCache_BufferMatchToRead(M4OSA_FileCache_Context* apContext,
+                                                         M4OSA_FilePosition pos)
+/**************************************************************/
+{
+    M4OSA_Int8 i;
+
+    /* Select the buffer which matches with given pos */
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(   (pos >= apContext->buffer[i].filepos)
+            && (pos < apContext->buffer[i].filepos + apContext->buffer[i].size)
+            && (apContext->buffer[i].filepos != M4OSA_EOF)                     )
+        {
+            M4OSA_TRACE3_1("BufferMatch returns  i = %d", i);
+            return i;
+        }
+    }
+
+    M4OSA_TRACE3_1("BufferMatch returns  N O N E !!!", i);
+    return M4OSA_CACHEBUFFER_NONE;
+}
+
+
+/* provides the buffer corresponding to a position pos
+and with pos inside its maximum capacity
+else returns CACHE_BUFFER_NONE*/
+/**************************************************************/
+M4OSA_Int8 M4OSA_FileCache_BufferMatchToWrite(M4OSA_FileCache_Context* apContext,
+                                                         M4OSA_FilePosition pos)
+/**************************************************************/
+{
+    M4OSA_Int8 i;
+
+    /* Select the buffer which matches with given pos */
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(   (pos >= apContext->buffer[i].filepos)
+           && (pos < apContext->buffer[i].filepos + M4OSA_CACHEBUFFER_SIZE)
+            && (apContext->buffer[i].filepos != M4OSA_EOF)                )
+        {
+            M4OSA_TRACE3_1("BufferMatch returns  i = %d", i);
+            return i;
+        }
+    }
+
+    M4OSA_TRACE3_1("BufferMatch returns  N O N E !!!", i);
+    return M4OSA_CACHEBUFFER_NONE;
+}
+
+/* chooses a buffer by overwriting an existing one and returns i */
+/**************************************************************/
+M4OSA_Int8 M4OSA_FileCache_BufferSelectForWrite(M4OSA_FileCache_Context* apContext)
+/**************************************************************/
+{
+    M4OSA_Int8 i;
+    M4OSA_UInt8 selected = 0;
+    M4OSA_UInt32 j, toSort;
+    M4OSA_FilePosition bufPos[M4OSA_CACHEBUFFER_NB];
+    M4OSA_ERR err;
+
+    // update nbFillSinceLastAcess field
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        apContext->buffer[i].nbFillSinceLastAcess ++;
+    }
+#ifdef NO_STRATEGY
+    goto end_selection;
+#endif
+
+    /*********************************************/
+    /* 1/ if there is still a new buffer, use it */
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(apContext->buffer[i].state == M4OSA_kInitialized)
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+    /*********************************************/
+    /* 2/ Choose a filled and copied buffer      */
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if( ((apContext->buffer[i].state & M4OSA_kFilled) == M4OSA_kFilled)
+            && ((apContext->buffer[i].state & M4OSA_kCopied) == M4OSA_kCopied)
+            && ((apContext->buffer[i].state & M4OSA_kModified) != M4OSA_kModified)   /* bug fix modified */
+           )
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+    /****************************************************************/
+    /* 3/ Choose a modified buffer with filepos>threshold and min   */
+    i=0;
+
+    /* sort the buffers by filepos and choose the min and not < threshold*/
+    for(j=0; j<M4OSA_CACHEBUFFER_NB; j++)
+    {
+        if  (
+             ((apContext->buffer[j].state & M4OSA_kModified) == M4OSA_kModified)
+             && (apContext->buffer[j].filepos > -1) /* not EOF */
+             )
+        {
+            bufPos[i] = apContext->buffer[j].filepos;
+            i++;
+        }
+    }
+
+    toSort = i;
+    if (toSort == 0 )
+    {
+        selected = 0;
+        goto end_selection;
+    }
+    else if (toSort ==1 )
+    {
+        goto skip_sort;
+    }
+    else
+    {
+        M4OSA_FileCache_QS_quickSort(bufPos, toSort);
+    }
+
+skip_sort:
+    /* take the smallest filepos */
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if (apContext->buffer[i].filepos == bufPos[0])
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+end_selection:
+    if (apContext->buffer[selected].filepos > apContext->fileSize )
+    {
+        /* in case it selects a modified buffer outside real file size,
+        in that case, flush all buffers before this one
+        unless there will be a seek outside filesize*/
+        M4OSA_FileCache_BuffersFlushUntil(apContext, selected);
+    }
+    else if ((apContext->buffer[selected].state & M4OSA_kModified) == M4OSA_kModified )
+    {
+        /* in case it selects a modified buffer inside filesize, simply flush it*/
+        err = M4OSA_FileCache_BufferFlush(apContext, selected);
+        if (M4NO_ERROR!= err)
+        {
+            return M4OSA_CACHEBUFFER_NONE;
+        }
+    }
+
+#ifdef NO_STRATEGY
+    /* selected stays 0 */
+    err = M4OSA_FileCache_BuffersFlushUntil(apContext, M4OSA_CACHEBUFFER_ALL);
+    if (M4NO_ERROR!= err)
+    {
+        return M4OSA_FILE_CACHE_BUFFER_NONE;
+    }
+#endif
+
+    M4OSA_TRACE3_1("---------- BufferSelect returns  i = %d", selected);
+     return selected;
+}
+
+
+/* chooses a buffer by overwriting an existing one and returns i */
+/**************************************************************/
+M4OSA_Int8 M4OSA_FileCache_BufferSelectWithTime(M4OSA_FileCache_Context* apContext)
+/**************************************************************/
+{
+    M4OSA_Int8 i;
+    M4OSA_UInt8 selected = 0;
+    M4OSA_UInt32 j, toSort;
+    M4OSA_Time bufTime[M4OSA_CACHEBUFFER_NB];
+    M4OSA_ERR err;
+
+    /*********************************************/
+    /* 1/ if there is still a new buffer, use it */
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(apContext->buffer[i].state == M4OSA_kInitialized)
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+    i=0;
+    /* sort all buffers with order of timeAccessed */
+    for(j=0; j<M4OSA_CACHEBUFFER_NB; j++)
+    {
+        bufTime[i] = apContext->buffer[j].timeAccessed;
+        i++;
+    }
+
+    toSort = i;
+    if (toSort == 0 )
+    {
+        selected = 0;
+        goto end_selection;
+    }
+    else if (toSort ==1 )
+    {
+        goto skip_sort;
+    }
+    else
+    {
+        M4OSA_FileCache_QS_quickSort64(bufTime, toSort);
+    }
+
+skip_sort:
+    /* take the smallest timeAccessed */
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if (apContext->buffer[i].timeAccessed == bufTime[0])
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+end_selection:
+    if (apContext->buffer[selected].filepos > apContext->fileSize )
+    {
+        /* in case it selects a modified buffer outside real file size,
+        in that case, flush all buffers before this one
+        unless there will be a seek outside filesize*/
+        M4OSA_FileCache_BuffersFlushUntil(apContext, selected);
+    }
+    else if ((apContext->buffer[selected].state & M4OSA_kModified) == M4OSA_kModified )
+    {
+        /* in case it selects a modified buffer inside filesize, simply flush it*/
+        err = M4OSA_FileCache_BufferFlush(apContext, selected);
+        if (M4NO_ERROR!= err)
+        {
+            return M4OSA_CACHEBUFFER_NONE;
+        }
+    }
+    M4OSA_TRACE3_1("---------- BufferSelect returns  i = %d", selected);
+     return selected;
+}
+
+/* chooses a buffer by overwriting an existing one and returns i */
+/**************************************************************/
+M4OSA_Int8 M4OSA_FileCache_BufferSelectWithPos(M4OSA_FileCache_Context* apContext)
+/**************************************************************/
+{
+    M4OSA_Int8 i;
+    M4OSA_UInt8 selected = 0, j;
+    M4OSA_ERR err;
+    M4OSA_FilePosition minPos;
+
+    /*********************************************/
+    /* 1/ if there is still a new buffer, use it */
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(apContext->buffer[i].state == M4OSA_kInitialized)
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+    minPos = apContext->buffer[0].filepos;
+    selected = 0;
+    for(j=1; j<M4OSA_CACHEBUFFER_NB; j++)
+    {
+        if (apContext->buffer[j].filepos < minPos)
+        {
+            minPos = apContext->buffer[j].filepos;
+            selected = j;
+        }
+    }
+
+end_selection:
+    if (apContext->buffer[selected].filepos > apContext->fileSize )
+    {
+        /* in case it selects a modified buffer outside real file size,
+        in that case, flush all buffers before this one
+        unless there will be a seek outside filesize*/
+        M4OSA_TRACE3_2("BufferSelectWithPos selected buffer is ouside file b.filepos=%d > fileSize=%d",
+                                            apContext->buffer[selected].filepos,
+                                             apContext->fileSize );
+        M4OSA_FileCache_BuffersFlushUntil(apContext, selected);
+    }
+    else if ((apContext->buffer[selected].state & M4OSA_kModified) == M4OSA_kModified )
+    {
+        /* in case it selects a modified buffer inside filesize, simply flush it*/
+        err = M4OSA_FileCache_BufferFlush(apContext, selected);
+        if (M4NO_ERROR!= err)
+        {
+            return M4OSA_CACHEBUFFER_NONE;
+        }
+    }
+    M4OSA_TRACE3_1("---------- BufferSelectWithPos returns  i = %d", selected);
+     return selected;
+}
+
+
+/* chooses a buffer by overwriting an existing one and returns i */
+/**************************************************************/
+M4OSA_Int8 M4OSA_FileCache_BufferSelectWithSpace(M4OSA_FileCache_Context* apContext)
+/**************************************************************/
+{
+    M4OSA_Int8 i;
+    M4OSA_UInt8 selected = 0;
+    M4OSA_UInt32 j, toSort;
+    M4OSA_FilePosition bufStat[M4OSA_CACHEBUFFER_NB];
+    M4OSA_ERR err;
+
+    /*********************************************/
+    /* 1/ if there is still a new buffer, use it */
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(apContext->buffer[i].state == M4OSA_kInitialized)
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+    i=0;
+    /* sort all buffers with order of nbAccessed */
+    for(j=0; j<M4OSA_CACHEBUFFER_NB; j++)
+    {
+        bufStat[i] = apContext->buffer[j].nbAccessed + apContext->buffer[j].timeAccessed*2; /* try hybrid */
+        i++;
+    }
+
+    toSort = i;
+    if (toSort == 0 )
+    {
+        selected = 0;
+        goto end_selection;
+    }
+    else if (toSort ==1 )
+    {
+        goto skip_sort;
+    }
+    else
+    {
+        M4OSA_FileCache_QS_quickSort(bufStat, toSort);
+    }
+
+skip_sort:
+    /* take the smallest nbAccessed */
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if ((M4OSA_Int64) apContext->buffer[i].nbAccessed  + apContext->buffer[i].timeAccessed*2 == bufStat[0]) /* hybrid */
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+end_selection:
+    if (apContext->buffer[selected].filepos > apContext->fileSize )
+    {
+        /* in case it selects a modified buffer outside real file size,
+        in that case, flush all buffers before this one
+        unless there will be a seek outside filesize*/
+        M4OSA_FileCache_BuffersFlushUntil(apContext, selected);
+    }
+    else if ((apContext->buffer[selected].state & M4OSA_kModified) == M4OSA_kModified )
+    {
+        /* in case it selects a modified buffer inside filesize, simply flush it*/
+        err = M4OSA_FileCache_BufferFlush(apContext, selected);
+        if (M4NO_ERROR!= err)
+        {
+            return M4OSA_CACHEBUFFER_NONE;
+        }
+    }
+    M4OSA_TRACE3_1("---------- BufferSelect returns  i = %d", selected);
+     return selected;
+}
+
+
+/**************************************************************/
+M4OSA_Int8 M4OSA_FileCache_BufferSelectForRead(M4OSA_FileCache_Context* apContext)
+/**************************************************************/
+{
+    M4OSA_Int8 i,j, selected;
+    M4OSA_FilePosition min_amount,max_amount;
+    M4OSA_Int8 min_i,max_count;
+    M4OSA_ERR err;
+
+    /* update nbFillSinceLastAcess field */
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        apContext->buffer[i].nbFillSinceLastAcess ++;
+    }
+
+    /**************************************************/
+    /* Plan A/ if there is still a new buffer, use it */
+
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(apContext->buffer[i].state == M4OSA_kInitialized)
+        {
+            selected = i;
+            goto end_selection;
+        }
+    }
+
+    max_count = M4OSA_CACHEBUFFER_NB;
+    max_amount = MAX_FILLS_SINCE_LAST_ACCESS;
+
+    /* Plan B : Scan for dead buffer */
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        if(apContext->buffer[i].nbFillSinceLastAcess >= (M4OSA_UInt32) max_amount)
+        {
+            max_amount = apContext->buffer[i].nbFillSinceLastAcess;
+            max_count = i;
+        }
+    }
+    if(max_count<M4OSA_CACHEBUFFER_NB)
+    {
+        M4OSA_TRACE3_2("DEAD BUFFER: %d, %d",max_count,apContext->buffer[max_count].nbFillSinceLastAcess);
+        selected = max_count;
+        goto end_selection;
+    }
+
+    min_i = 0;
+    min_amount = M4OSA_CACHEBUFFER_NB;
+
+    /* Select the buffer which is the most "empty" */
+    for(i=0; i<M4OSA_CACHEBUFFER_NB; i++)
+    {
+        j = i % M4OSA_CACHEBUFFER_NB;
+
+        if(apContext->buffer[j].remain < min_amount)
+        {
+            min_amount = apContext->buffer[j].remain;
+            min_i = j;
+        }
+    }
+    selected = min_i;
+
+end_selection:
+    if (apContext->buffer[selected].filepos > apContext->fileSize )
+    {
+        /* in case it selects a modified buffer outside real file size,
+        in that case, flush all buffers before this one
+        unless there will be a seek outside filesize*/
+        M4OSA_FileCache_BuffersFlushUntil(apContext, selected);
+    }
+    else if ((apContext->buffer[selected].state & M4OSA_kModified) == M4OSA_kModified )
+    {
+        /* in case it selects a modified buffer inside filesize, simply flush it*/
+        err = M4OSA_FileCache_BufferFlush(apContext, selected);
+        if (M4NO_ERROR!= err)
+        {
+            return M4OSA_CACHEBUFFER_NONE;
+        }
+    }
+
+    return selected;
+}
+
+
+/**************************************************************/
+M4OSA_ERR M4OSA_FileCache_CalculateSize(M4OSA_FileCache_Context* apContext)
+/**************************************************************/
+{
+    M4OSA_ERR    err = M4NO_ERROR;
+    M4OSA_Int32  ret_val;
+    M4OSA_UInt16 errReturned;
+
+    /* go to the end of file*/
+    ret_val = apContext->FS->pFctPtr_Seek(apContext->aFileDesc, 0,
+                                          M4OSA_kFileSeekEnd,
+                                          &errReturned);
+
+    if (ret_val != 0)
+    {
+        apContext->readFilePos = M4OSA_EOF;
+        err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errReturned);
+        M4OSA_TRACE2_1("M4OSA_FileCache_CalculateSize ERR = 0x%x", err);
+    }
+    else
+    {
+        /* Retrieve size of the file */
+        apContext->fileSize = apContext->FS->pFctPtr_Tell(apContext->aFileDesc,
+                                                                  &errReturned);
+        apContext->readFilePos = apContext->fileSize;
+    }
+
+    return err;
+}
+
+/* _____________________________________________________________  */
+/*|                                                             | */
+/*| OSAL filesystem functions dependent on Platform FileSystem  | */
+/*|_____________________________________________________________| */
+
+/**
+ ************************************************************************
+ * @brief   Opens a file
+ * @note
+ * @param   pFileDescriptor :    IN    url of the file
+ *          FileModeAccess  :    IN    access mode for opening the file
+ *          errno_ffs           :   OUT internal error returned by the filesystem
+ * @return  pC              :   internal context
+ ************************************************************************
+*/
+M4OSA_Void* M4OSA_FileSystem_FFS_Open_cache( M4OSA_Void* pFileDescriptor,
+                                             M4OSA_UInt32 FileModeAccess,
+                                             M4OSA_UInt16* errno_ffs )
+{
+
+    M4OSA_FileSystem_FFS_t_cache     *pC = M4OSA_NULL;
+    FILE* fp;
+
+    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*)"+";
+
+    fp = M4OSA_NULL;
+    *errno_ffs = 0;
+
+    M4OSA_TRACE3_0("M4OSA_FileSystem_FFS_Open_cache : Open **** \n");
+
+     /************************/
+     /*  Verify access mode  */
+     /************************/
+
+    /*
+    All possible file accesses:
+
+        r : Read only, file must exist
+
+        w : Write only. If the file exists, it is overwritten. If it does not exist, it is created.
+
+        a : write at end of file (append). If the file exists, it is extended. If the file does not exist, it is created.
+
+        r+ : update (i.e. read and write). The file must exist. It is not possible to do a read after a write (or a write after a read)
+        unless we reposition the file pointer.
+
+        w+ : creation, to update. If the file exists, it is overwritten. If the files does not exist, it is created.
+        a+ : extension and update. If the file does not exist, it is created. If the file exists, the file pointer is put at end of file.
+
+    All possible cases for fileModeAccess parameter:
+
+        Write(2)            w
+        WriteRead(3)        r+    // r+b Used by MM
+        WriteReadCreate(11)    w+    // w+b Used by MM
+        WriteReadAppend(7)    a+
+        WriteCreate(10)        w
+        WriteAppend(12)        a
+        Read                r    // rb Used by MM
+        Error
+    */
+
+
+    if ((FileModeAccess & M4OSA_kFileWrite) && (FileModeAccess & M4OSA_kFileRead) && (FileModeAccess & M4OSA_kFileCreate)) /* Used by MM */
+    {
+        /** "w+" */
+        M4OSA_chrNCat(mode, pWriteString, 1);
+        M4OSA_chrNCat(mode, pPlusString, 1);
+    }
+    else if ((FileModeAccess & M4OSA_kFileWrite) && (FileModeAccess & M4OSA_kFileRead) && (FileModeAccess & M4OSA_kFileAppend))
+    {
+        /** "a+" */
+        M4OSA_chrNCat(mode, pAppendString, 1);
+        M4OSA_chrNCat(mode, pPlusString, 1);
+    }
+    else if ((FileModeAccess & M4OSA_kFileWrite) && (FileModeAccess & M4OSA_kFileRead))    /* Used by MM */
+    {
+        /** "r+" */
+        M4OSA_chrNCat(mode, pReadString, 1);
+        M4OSA_chrNCat(mode, pPlusString, 1);
+    }
+    else if ((FileModeAccess & M4OSA_kFileWrite) && (FileModeAccess & M4OSA_kFileCreate))
+    {
+        /** "w" */
+        M4OSA_chrNCat(mode, pWriteString, 1);
+    }
+    else if ((FileModeAccess & M4OSA_kFileWrite) && (FileModeAccess & M4OSA_kFileAppend))
+    {
+        /** "a" */
+        M4OSA_chrNCat(mode, pAppendString, 1);
+    }
+    else if (FileModeAccess & M4OSA_kFileRead)
+    {
+        /** "r" */
+        M4OSA_chrNCat(mode, pReadString, 1);
+    }
+    else if (FileModeAccess & M4OSA_kFileWrite)
+    {
+        /** "w" */
+        M4OSA_chrNCat(mode, pWriteString, 1);
+    }
+    else
+    {
+        M4OSA_TRACE1_1("M4OSA_FileSystem_FFS_Open_cache : invalid FileModeAccess = %x", FileModeAccess);
+        *errno_ffs = (M4OSA_UInt16)M4ERR_FILE_BAD_MODE_ACCESS;
+    }
+
+    /* add the b */
+    M4OSA_chrNCat(mode, pBinaryString, 1);
+
+    fp = fopen((const char *) pFileDescriptor, (const char *)mode); /* Open in rb or in r+b*/
+    if( fp != NULL )
+    {
+        pC = (M4OSA_FileSystem_FFS_t_cache *) M4OSA_malloc(sizeof * pC, M4OSA_FILE_READER, (M4OSA_Char*)"M4OSA_FileSystem_FFS_Open_cache");
+
+        if (pC == M4OSA_NULL) return M4OSA_NULL; /*error occured => return NULL pointer*/
+
+        pC->FileDesc = fp;
+    }
+    else
+    {
+        switch(errno)
+        {
+            case ENOENT:
+                 M4OSA_DEBUG(M4ERR_FILE_NOT_FOUND, "M4OSA_fileReadOpen: No such file or directory");
+                 *errno_ffs=(M4OSA_UInt16)M4ERR_FILE_NOT_FOUND;
+                 break;
+
+            case EACCES:
+                M4OSA_DEBUG(M4ERR_FILE_LOCKED, "M4OSA_fileReadOpen: Permission denied");
+                *errno_ffs=(M4OSA_UInt16)M4ERR_FILE_LOCKED;
+                break;
+
+            case EINVAL:
+                M4OSA_DEBUG(M4ERR_FILE_BAD_MODE_ACCESS, "M4OSA_fileReadOpen: Invalid Argument");
+                *errno_ffs=(M4OSA_UInt16)M4ERR_FILE_BAD_MODE_ACCESS;
+                break;
+
+             case EMFILE:
+             case ENOSPC:
+             case ENOMEM:
+                M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileReadOpen: Too many open files");
+                *errno_ffs=(M4OSA_UInt16)M4ERR_ALLOC;
+                break;
+
+             default:
+                M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_fileReadOpen");
+                *errno_ffs=(M4OSA_UInt16)M4ERR_NOT_IMPLEMENTED;
+
+        } /* end switch */
+    } /* end else */
+
+    return (M4OSA_Void*)pC;
+}
+
+/**
+ ************************************************************************
+ * @brief   Reads data from file
+ * @note
+ * @param   pContext        :   IN  internal context
+ *          data            :    IN  buffer for reading data
+ *          size            :    IN    amount of bytes to read
+ *          errno_ffs           :   OUT internal error returned by the filesystem
+ * @return  ret             :   effective amount of bytes read / -1 if an error occurs
+ ************************************************************************
+*/
+M4OSA_FilePosition M4OSA_FileSystem_FFS_Read_cache( M4OSA_Void* pContext,
+                                                    M4OSA_UInt8* data,
+                                                    M4OSA_FilePosition size,
+                                                    M4OSA_UInt16* errno_ffs )
+{
+    M4OSA_FileSystem_FFS_t_cache *pC = (M4OSA_FileSystem_FFS_t_cache *)pContext;
+    M4OSA_Int32    res;
+
+    M4OSA_TRACE2_1("M4OSA_FileSystem_FFS_Read  size = %ld", size);
+
+    res = -1;
+
+    res = fread(data,sizeof(M4OSA_Char), size, pC->FileDesc);
+    if( -1 < res )
+    {
+        *errno_ffs = M4NO_ERROR;
+    }
+    else
+    {
+        *errno_ffs = errno;
+    }
+
+    return (M4OSA_FilePosition)res;
+}
+
+
+
+/**
+ ************************************************************************
+ * @brief   Writes data to file
+ * @note
+ * @param   pContext        :   IN  internal context
+ *          data            :    IN  buffer with data to write
+ *          size            :    IN    amount of bytes to read
+ *          errno_ffs           :   OUT internal error returned by the filesystem
+ * @return  ret             :   effective amount of bytes read / an error code if an error occurs
+ ************************************************************************
+*/
+M4OSA_FilePosition M4OSA_FileSystem_FFS_Write_cache( M4OSA_Void* pContext,
+                                                     M4OSA_UInt8* data,
+                                                     M4OSA_FilePosition size,
+                                                     M4OSA_UInt16* errno_ffs )
+{
+    M4OSA_FileSystem_FFS_t_cache *pC = (M4OSA_FileSystem_FFS_t_cache *)pContext;
+    M4OSA_Int32    res;
+
+    M4OSA_TRACE2_1("M4OSA_FileSystem_FFS_Write  size = %ld", size);
+
+    res = 0;
+
+    res = fwrite(data,sizeof(M4OSA_Char), size, pC->FileDesc);
+    if( -1 < res )
+    {
+        *errno_ffs = M4NO_ERROR;
+    }
+    else
+    {
+        *errno_ffs = errno;
+        M4OSA_TRACE1_1("M4OSA_FileSystem_FFS_Write  error", *errno_ffs);
+    }
+
+    fflush(pC->FileDesc);
+
+    return (M4OSA_FilePosition)res;
+}
+
+/**
+ ************************************************************************
+ * @brief   Seeks at given position in a file
+ * @note
+ * @param   pContext        :   IN  internal context
+ *          pos             :    IN  amount of bytes for the move
+ *          mode            :    IN    kind of seek to perform
+ *          errno_ffs           :   OUT internal error returned by the filesystem
+ * @return  ret             :   0 on success / any other value if an error occurs
+ ************************************************************************
+*/
+M4OSA_Int32 M4OSA_FileSystem_FFS_Seek_cache( M4OSA_Void* pContext,
+                                             M4OSA_FilePosition pos,
+                                             M4OSA_FileSeekAccessMode mode,
+                                             M4OSA_UInt16* errno_ffs )
+{
+    M4OSA_FileSystem_FFS_t_cache *pC = (M4OSA_FileSystem_FFS_t_cache *)pContext;
+
+    M4OSA_TRACE2_2("M4OSA_FileSystem_FFS_Seek  pos = %ld  mode = %d", pos, mode);
+
+    switch(mode)
+    {
+        case M4OSA_kFileSeekBeginning :
+            *errno_ffs = fseek(pC->FileDesc, pos, SEEK_SET);
+            break;
+
+        case M4OSA_kFileSeekCurrent :
+            *errno_ffs= fseek(pC->FileDesc, pos, SEEK_CUR);
+            break;
+
+        case M4OSA_kFileSeekEnd :
+            *errno_ffs = fseek(pC->FileDesc, pos, SEEK_END);
+            break;
+    }
+
+    return *errno_ffs;
+
+}
+
+/**
+ ************************************************************************
+ * @brief   Tells the position of the file pointer
+ * @note
+ * @param   pContext        :   IN  internal context
+ *          errno_ffs           :   OUT internal error returned by the filesystem
+ * @return  ret             :   position of the file pointer/ -1 if an error occurs
+ ************************************************************************
+*/
+M4OSA_FilePosition M4OSA_FileSystem_FFS_Tell_cache( M4OSA_Void* pContext,
+                                                       M4OSA_UInt16* errno_ffs )
+{
+    M4OSA_FileSystem_FFS_t_cache *pC = (M4OSA_FileSystem_FFS_t_cache *)pContext;
+    M4OSA_FilePosition pos;
+
+    pos = ftell(pC->FileDesc);
+
+    *errno_ffs = 0;
+
+    return pos;
+}
+
+/**
+ ************************************************************************
+ * @brief   Closes the file
+ * @note
+ * @param   pContext        :   IN  internal context
+ *          errno_ffs           :   OUT internal error returned by the filesystem
+ * @return  ret             :   0 on success / any other value if an error occurs
+ ************************************************************************
+*/
+M4OSA_Int32 M4OSA_FileSystem_FFS_Close_cache( M4OSA_Void* pContext,
+                                                       M4OSA_UInt16* errno_ffs )
+{
+    M4OSA_FileSystem_FFS_t_cache *pC = (M4OSA_FileSystem_FFS_t_cache *)pContext;
+
+    *errno_ffs = fclose(pC->FileDesc);
+
+    return *errno_ffs;
+}
+
+/* __________________________________________________________ */
+/*|                                                          |*/
+/*|                    OSAL fileCache                        |*/
+/*|__________________________________________________________|*/
+
+/**************************************************************/
+M4OSA_ERR M4OSA_fileOpen_cache(M4OSA_Context* pContext,
+                               M4OSA_Void* pFileDescriptor,
+                               M4OSA_UInt32 FileModeAccess)
+/**************************************************************/
+{
+    M4OSA_FileSystem_FctPtr_cache *FS;
+
+    /* Allocate memory for the File System interface */
+    FS = (M4OSA_FileSystem_FctPtr_cache *)M4OSA_malloc(sizeof * FS,
+                M4OSA_FILE_READER,(M4OSA_Char*)"M4OSA_FileSystem_FctPtr_cache");
+
+    if(M4OSA_NULL == FS)
+        return M4ERR_ALLOC;
+
+    FS->pFctPtr_Open = M4OSA_FileSystem_FFS_Open_cache;
+    FS->pFctPtr_Read = M4OSA_FileSystem_FFS_Read_cache;
+    FS->pFctPtr_Write = M4OSA_FileSystem_FFS_Write_cache;
+    FS->pFctPtr_Seek = M4OSA_FileSystem_FFS_Seek_cache;
+    FS->pFctPtr_Tell = M4OSA_FileSystem_FFS_Tell_cache;
+    FS->pFctPtr_Close = M4OSA_FileSystem_FFS_Close_cache;
+
+    return M4OSA_fileOpen_cache_internal(pContext, pFileDescriptor,
+                                                            FileModeAccess, FS);
+}
+
+/**
+******************************************************************************
+* @brief       This method opens the provided fileDescriptor and returns its context.
+* @param       pContext:       (OUT) File Cache 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
+* @return      M4ERR_FILE_NOT_FOUND The file can not be opened.
+******************************************************************************
+*/
+M4OSA_ERR M4OSA_fileOpen_cache_internal(M4OSA_Context* pContext,
+                                        M4OSA_Void* pFileDescriptor,
+                                        M4OSA_UInt32 FileModeAccess,
+                                        M4OSA_FileSystem_FctPtr_cache *FS)
+{
+    M4OSA_FileCache_Context* apContext = M4OSA_NULL;
+
+    M4OSA_ERR   err       = M4NO_ERROR;
+    M4OSA_Void* aFileDesc = M4OSA_NULL;
+    M4OSA_Bool  buffers_allocated = M4OSA_FALSE;
+    M4OSA_UInt16 errReturned = 0;
+    M4OSA_Int32 len,name_len;
+    M4OSA_Char* pCharFileDesc = (M4OSA_Char*)pFileDescriptor;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_Time time1 = 0;
+    M4OSA_Time time2 = 0;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    M4OSA_TRACE2_2("M4OSA_fileOpen_cache fd = %s mode = %d", pFileDescriptor,
+                                                                FileModeAccess);
+
+    /*      Check input parameters */
+    M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pContext);
+    M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pFileDescriptor);
+    M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, FS);
+
+    *pContext = M4OSA_NULL;
+
+    /* Allocate memory for the File reader context. */
+    apContext = (M4OSA_FileCache_Context *)M4OSA_malloc(sizeof(M4OSA_FileCache_Context),
+                     M4OSA_FILE_READER, (M4OSA_Char*)"M4OSA_FileCache_Context");
+
+    M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_ALLOC, apContext);
+
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+        M4OSA_FileCache_initTimeMeas(apContext);
+        M4OSA_clockGetTime(&time1,1000);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    /* Set filesystem interface */
+    apContext->FS = FS;
+
+    if (M4OSA_kFileWrite == FileModeAccess)
+    {
+        FileModeAccess |= M4OSA_kFileWrite | M4OSA_kFileCreate;    /* for VA in case of open with only Write flag, we add the Create */
+    }
+
+    /* For VA and VES, we need to add access in read, to write the moov for example */
+    /* Add the flag Read in all cases, because Osal File Cache uses read at the same time */
+    FileModeAccess |= M4OSA_kFileRead;
+
+    aFileDesc = apContext->FS->pFctPtr_Open(pFileDescriptor, FileModeAccess,
+                                                                  &errReturned);
+
+    if (aFileDesc != M4OSA_NULL)
+    {
+        apContext->IsOpened = M4OSA_TRUE;
+    }
+    else
+    {
+        /* converts the error to PSW format*/
+        err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errReturned);
+        M4OSA_TRACE1_2("M4OSA_fileOpen_cache error 0x%x for fd = %s", err,
+                                                               pFileDescriptor);
+        apContext->IsOpened = M4OSA_FALSE;
+
+        /*free the context and associated FS pointers*/
+        if (M4OSA_NULL != apContext) /*should never be null*/
+        {
+            if (M4OSA_NULL != apContext->FS) /*should never be null*/
+            {
+                M4OSA_free((M4OSA_MemAddr32)apContext->FS);
+            }
+
+            M4OSA_free((M4OSA_MemAddr32)apContext);
+            apContext = M4OSA_NULL;
+        }
+
+        if (M4NO_ERROR != err) goto cleanup;
+    }
+
+    /* Allocate buffers */
+    err = M4OSA_FileCache_BuffersInit(apContext);
+    buffers_allocated = M4OSA_TRUE;
+
+    if (M4NO_ERROR != err) goto cleanup;
+
+    /* Initialize parameters */
+    apContext->fileSize = 0;
+    apContext->virtualFileSize = 0;
+    apContext->absolutePos = 0;
+    apContext->absoluteWritePos = 0;
+
+
+    apContext->readFilePos = 0;
+
+    /* Retrieve the File Descriptor*/
+    apContext->aFileDesc = aFileDesc;
+
+    /* Retrieve the File mode Access */
+    apContext->FileAttribute.modeAccess = (M4OSA_FileModeAccess)FileModeAccess;
+
+    apContext->chrono = 0;
+
+#ifdef FILECACHE_STATS
+    apContext->nbReadCache = 0;
+    apContext->nbWriteCache = 0;
+
+    apContext->nbReadFFS = 0;
+    apContext->nbWriteFFS = 0;
+#endif
+
+    /*Retrieve the File reader context */
+    *pContext= (M4OSA_Context)apContext;
+
+    /* Compute file size */
+    err = M4OSA_FileCache_CalculateSize(apContext);
+
+    if (M4NO_ERROR != err) goto cleanup;
+
+    apContext->virtualFileSize = apContext->fileSize;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_clockGetTime(&time2,1000);
+    if (time2>time1)
+        apContext->gMyPerfFileTab[fileOpentime] += time2-time1;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    M4OSA_mutexOpen(&(apContext->m_mutex));
+
+    /* filename extraction, just for traces  */
+    M4OSA_memset(apContext->m_filename, 256, 0);
+    len=( M4OSA_chrLength(pCharFileDesc) )+1;
+    for( --len ; (len >= 0 && pCharFileDesc[len] != '\\' && pCharFileDesc[len] != '/') ; len-- );
+    name_len=M4OSA_chrLength( &pCharFileDesc[len+1] );
+    err=M4OSA_chrNCopy(apContext->m_filename, &pCharFileDesc[len+1], name_len);
+
+    M4OSA_TRACE2_2("M4OSA_fileOpen_cache of %s has pC = 0x%x", apContext->m_filename, apContext);
+
+    return M4NO_ERROR;
+
+cleanup:
+
+    /* free context */
+    if (M4OSA_NULL != apContext)
+    {
+        if(buffers_allocated == M4OSA_TRUE)
+        {
+            M4OSA_FileCache_BuffersFree(apContext);
+        }
+
+        if (M4OSA_NULL != apContext)
+        {
+            M4OSA_free((M4OSA_MemAddr32)apContext);
+            apContext = M4OSA_NULL;
+        }
+        *pContext = M4OSA_NULL;
+    }
+
+    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_cache(M4OSA_Context pContext,M4OSA_MemAddr8 pData,
+                                                           M4OSA_UInt32* pSize)
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+
+    M4OSA_ERR err;
+    M4OSA_FilePosition aSize;
+    M4OSA_FilePosition copiedSize;
+    M4OSA_Int8 selected_buffer, current_buffer;
+    M4OSA_Int32 castedSize;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_Time time1 = 0;
+    M4OSA_Time time2 = 0;
+
+    M4OSA_clockGetTime(&time1,1000);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    M4OSA_TRACE2_3("M4OSA_fileReadData_cache of %s size=%d at pos=%d  ",
+                         apContext->m_filename, *pSize, apContext->absolutePos);
+
+    /* 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;
+    }
+
+LOCK
+
+/* 20080125 Start : if *pSize is too high, adjust it to the size left in the file. MI-958*/
+    castedSize = * pSize;
+    if (castedSize < 0)
+    {
+        copiedSize = 0;
+        err = M4WAR_NO_MORE_AU;
+#ifdef M4OSA_FILECACHE_MM
+        err = M4WAR_NO_DATA_YET; /* no_data_yet for MM */
+#endif
+        goto cleanup;
+    }
+/* 20080125 End : if *pSize is too high, adjust it to the size left in the file. MI-958*/
+
+    /* Prevent reading beyond EOF */
+    if((*pSize > 0) && (apContext->absolutePos >= apContext->virtualFileSize)) /* virtual FSize*/
+    {
+        copiedSize = 0;
+        err = M4WAR_NO_MORE_AU; /* for VA and VPS */
+#ifdef M4OSA_FILECACHE_MM
+        err = M4WAR_NO_DATA_YET; /* no_data_yet for MM */
+#endif
+        goto cleanup;
+    }
+
+/* 20080125 Start : if *pSize is too high, adjust it to the size left in the file. MI-958*/
+    if (*pSize > (M4OSA_UInt32)(apContext->virtualFileSize - apContext->absolutePos))
+    {
+        M4OSA_TRACE1_0("M4OSA_fileReadData_cache : Attempted to read beyond file size, adjusted size");
+        *pSize = apContext->virtualFileSize - apContext->absolutePos;
+    }
+/* 20080125 End : if *pSize is too high, adjust it to the size left in the file. MI-958*/
+
+    /* 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_FileCache_BufferMatchToRead(apContext,
+                                                        apContext->absolutePos);
+
+    if(selected_buffer == M4OSA_CACHEBUFFER_NONE)
+    {
+
+#if defined(BUFFER_SELECT_INITIAL)
+        selected_buffer = M4OSA_FileCache_BufferSelectForRead(apContext);
+#elif defined(BUFFER_SELECT_WITH_TIME)
+        selected_buffer = M4OSA_FileCache_BufferSelectWithTime(apContext);
+#elif defined(BUFFER_SELECT_WITH_SPACE)
+        selected_buffer = M4OSA_FileCache_BufferSelectWithSpace(apContext);
+#elif defined(BUFFER_SELECT_WITH_POS)
+        selected_buffer = M4OSA_FileCache_BufferSelectWithPos(apContext);
+#endif
+
+        if (M4OSA_CACHEBUFFER_NONE == selected_buffer)
+        {
+            err = M4ERR_BAD_CONTEXT; /* temporary error code */
+            goto cleanup;
+        }
+
+        err = M4OSA_FileCache_BufferFill(apContext, selected_buffer,
+                                                        apContext->absolutePos);
+    }
+#ifdef FILECACHE_STATS
+    else
+    {
+        /* bufferMatch has success in read  */
+        apContext->nbReadCache++;
+    }
+#endif /* FILECACHE_STATS */
+
+    if(err != M4NO_ERROR)
+    {
+        if((err == M4WAR_NO_DATA_YET) && (*pSize <= (M4OSA_UInt32)apContext->buffer[selected_buffer].size))
+             err = M4NO_ERROR;
+        else goto cleanup;
+    }
+
+    M4OSA_TRACE3_3("readData  size = %d  buffer = %d  pos = %d",
+                               *pSize, selected_buffer, apContext->absolutePos);
+
+    /* Copy buffer into pData */
+    while(((M4OSA_UInt32)copiedSize < *pSize) && (err == M4NO_ERROR))
+    {
+        aSize = M4OSA_FileCache_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_FileCache_BufferMatchToRead(apContext,
+                                             apContext->absolutePos+copiedSize);
+
+                if(selected_buffer == M4OSA_CACHEBUFFER_NONE)
+                {
+#if defined(BUFFER_SELECT_INITIAL)
+                    selected_buffer = M4OSA_FileCache_BufferSelectForRead(apContext);
+#elif defined(BUFFER_SELECT_WITH_TIME)
+                    selected_buffer = M4OSA_FileCache_BufferSelectWithTime(apContext);
+#elif defined(BUFFER_SELECT_WITH_SPACE)
+                    selected_buffer = M4OSA_FileCache_BufferSelectWithSpace(apContext);
+#elif defined(BUFFER_SELECT_WITH_POS)
+                    selected_buffer = M4OSA_FileCache_BufferSelectWithPos(apContext);
+#endif
+
+                    if (M4OSA_CACHEBUFFER_NONE == selected_buffer)
+                    {
+                        err = M4ERR_BAD_CONTEXT; /* temporary error code */
+                        goto cleanup;
+                    }
+
+                    err = M4OSA_FileCache_BufferFill(apContext, selected_buffer,
+                                             apContext->absolutePos+copiedSize);
+
+                    if(err != M4NO_ERROR)
+                    {
+                        if((err == M4WAR_NO_DATA_YET) && ((*pSize-copiedSize) <= (M4OSA_UInt32)apContext->buffer[selected_buffer].size))
+                             err = M4NO_ERROR;
+                        else goto cleanup;
+                    }
+                }
+#ifdef FILECACHE_STATS
+                else
+                {
+                    /* bufferMatch has success in read  */
+                    apContext->nbReadCache++;
+                }
+#endif /* FILECACHE_STATS */
+
+            }
+        }
+    }
+
+cleanup :
+
+    /* Update the new position of the pointer */
+    apContext->absolutePos = apContext->absolutePos + copiedSize;
+
+#ifdef M4OSA_FILECACHE_MM
+    apContext->absoluteWritePos = apContext->absolutePos;
+#endif /* M4OSA_FILECACHE_MM */
+
+    if(err != M4NO_ERROR)
+    {
+        M4OSA_TRACE1_3("M4OSA_fileReadData_cache size = %d  copied = %d  err = 0x%x",
+                                                       *pSize, copiedSize, err);
+    }
+
+    /* Effective copied size must be returned */
+    *pSize = copiedSize;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_clockGetTime(&time2,1000);
+    if (time2>time1)
+        apContext->gMyPerfFileTab[fileReadDatatime] += time2-time1;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+UNLOCK
+
+    /* Read is done */
+    return err;
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function writes the 'size' bytes stored at 'data' memory
+ *             in the file selected by its context.
+ * @note       The caller is responsible for allocating/de-allocating the
+ *             memory for 'data' parameter.
+ * @note       Moreover the data pointer must be allocated to store at least
+ *             'size' bytes.
+ * @param      pContext: (IN/OUT) Context of the core file reader
+ * @param      pData: (IN) Data pointer of the write data
+ * @param      size: (IN) Size of the data to write (in bytes)
+ * @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_fileWriteData_cache(M4OSA_Context pContext,M4OSA_MemAddr8 pData,
+                                                              M4OSA_UInt32 size)
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+
+    M4OSA_ERR err;
+    M4OSA_FilePosition aSize;
+    M4OSA_FilePosition copiedSize;
+    M4OSA_Int8 selected_buffer, current_buffer;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_Time time1 = 0;
+    M4OSA_Time time2 = 0;
+
+    M4OSA_clockGetTime(&time1,1000);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    M4OSA_TRACE2_3("M4OSA_fileWriteData_cache of %s size=%d at pos=%d   ",
+                      apContext->m_filename, size, apContext->absoluteWritePos);
+
+    /* Check input parameters */
+    M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_BAD_CONTEXT, apContext);
+    M4ERR_CHECK_NULL_RETURN_VALUE(M4ERR_PARAMETER, pData);
+
+
+    if (apContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;
+    }
+
+    /*protection*/
+    if (apContext->absoluteWritePos > apContext->virtualFileSize)
+    {
+        M4OSA_TRACE1_0("M4OSA_fileWriteData_cache ERROR : attempting to write beyond EOF");
+        return M4WAR_NO_DATA_YET;
+    }
+
+LOCK
+
+    /* Check if data has been read into a buffer */
+    /* If not, we should read that buffer first and then fill it */
+    copiedSize = 0;
+    err = M4NO_ERROR;
+
+    selected_buffer = M4OSA_FileCache_BufferMatchToWrite(apContext,
+                                                   apContext->absoluteWritePos);
+
+    if(selected_buffer == M4OSA_CACHEBUFFER_NONE)
+    {
+#if defined(BUFFER_SELECT_INITIAL)
+        selected_buffer = M4OSA_FileCache_BufferSelectForWrite(apContext);
+#elif defined(BUFFER_SELECT_WITH_TIME)
+        selected_buffer = M4OSA_FileCache_BufferSelectWithTime(apContext);
+#elif defined(BUFFER_SELECT_WITH_SPACE)
+        selected_buffer = M4OSA_FileCache_BufferSelectWithSpace(apContext);
+#elif defined(BUFFER_SELECT_WITH_POS)
+        selected_buffer = M4OSA_FileCache_BufferSelectWithPos(apContext);
+#endif
+
+        if (M4OSA_CACHEBUFFER_NONE == selected_buffer)
+        {
+            M4OSA_TRACE1_1("M4OSA_fileWriteData_cache ERR1 err=0x%x", err);
+            err = M4ERR_BAD_CONTEXT; /* temporary error code */
+            goto cleanup;
+        }
+
+        if (apContext->absoluteWritePos - M4OSA_CACHEBUFFER_SIZE < apContext->fileSize) /* absolutePos not readfilepo strictly < */
+        {
+            err = M4OSA_FileCache_BufferFill(apContext, selected_buffer,
+                                                   apContext->absoluteWritePos);
+        }
+        else
+        {
+            err = M4OSA_FileCache_BufferReinitialize(apContext, selected_buffer,
+                                                   apContext->absoluteWritePos);
+        }
+
+    }
+#ifdef FILECACHE_STATS
+    else
+    {
+        /* bufferMatch has success in write */
+        apContext->nbWriteCache++;
+    }
+#endif /* FILECACHE_STATS */
+
+    if(err != M4NO_ERROR)
+    {
+        if(err == M4WAR_NO_DATA_YET) /* means the buffer is small, it is at EOF, bufferFill didn't fully fill it*/
+             err = M4NO_ERROR;
+        else goto cleanup;
+    }
+
+    M4OSA_TRACE3_3("writeData  size = %d  buffer = %d  pos = %d", size,
+                                  selected_buffer, apContext->absoluteWritePos);
+
+    /* Copy buffer into pData */
+    while(((M4OSA_UInt32)copiedSize < size) && (err == M4NO_ERROR))
+    {
+        aSize = M4OSA_FileCache_BufferModifyContent(apContext, selected_buffer,
+                                                    apContext->absoluteWritePos+copiedSize,
+                                                    size-copiedSize, pData+copiedSize);
+        copiedSize += aSize;
+
+        /* update virtualFileSize in case we write at the end  */
+        if (apContext->absoluteWritePos+copiedSize>apContext->virtualFileSize)
+        {
+            apContext->virtualFileSize = apContext->absoluteWritePos+copiedSize;
+            M4OSA_TRACE3_1("virtualFileSize incremented to %d", apContext->virtualFileSize);
+        }
+
+        if((M4OSA_UInt32)copiedSize < size)
+        {
+            current_buffer = selected_buffer;
+            selected_buffer = M4OSA_FileCache_BufferMatchToWrite(apContext,
+                                        apContext->absoluteWritePos+copiedSize);
+
+            if(selected_buffer == M4OSA_CACHEBUFFER_NONE)
+            {
+#if defined(BUFFER_SELECT_INITIAL)
+                selected_buffer = M4OSA_FileCache_BufferSelectForWrite(apContext);
+#elif defined(BUFFER_SELECT_WITH_TIME)
+                selected_buffer = M4OSA_FileCache_BufferSelectWithTime(apContext);
+#elif defined(BUFFER_SELECT_WITH_SPACE)
+                selected_buffer = M4OSA_FileCache_BufferSelectWithSpace(apContext);
+#elif defined(BUFFER_SELECT_WITH_POS)
+                selected_buffer = M4OSA_FileCache_BufferSelectWithPos(apContext);
+#endif
+
+                if (M4OSA_CACHEBUFFER_NONE == selected_buffer)
+                {
+                    M4OSA_TRACE1_1("M4OSA_fileWriteData_cache ERR2 err=0x%x", err);
+                    err = M4ERR_BAD_CONTEXT; /* temporary error code */
+                    goto cleanup;
+                }
+
+                if (apContext->absoluteWritePos+copiedSize < apContext->fileSize) /* absolutePos not readfilepo strictly < */
+                {
+                    err = M4OSA_FileCache_BufferFill(apContext, selected_buffer,
+                                        apContext->absoluteWritePos+copiedSize);
+                }
+                else
+                {
+                    err = M4OSA_FileCache_BufferReinitialize(apContext,
+                                                             selected_buffer,
+                                                             apContext->absoluteWritePos+copiedSize);
+                }
+
+
+                if(err != M4NO_ERROR)
+                {
+                    if((err == M4WAR_NO_DATA_YET))
+                         err = M4NO_ERROR;
+                    else goto cleanup;
+                }
+            }
+#ifdef FILECACHE_STATS
+    else  /* (selected_buffer == M4OSA_CACHEBUFFER_NONE) */
+    {
+        /* bufferMatch has success in write */
+        apContext->nbWriteCache++;
+    }
+#endif /* FILECACHE_STATS */
+
+        }
+
+    }
+
+cleanup :
+
+    /* Update the new position of the pointer */
+    apContext->absoluteWritePos = apContext->absoluteWritePos + copiedSize;
+#ifdef M4OSA_FILECACHE_MM
+    apContext->absolutePos = apContext->absoluteWritePos;
+#endif /* M4OSA_FILECACHE_MM */
+
+    if(err != M4NO_ERROR)
+    {
+        M4OSA_TRACE3_3("M4OSA_fileWriteData_cache size = %d  copied = %d  err = 0x%x",
+                                                         size, copiedSize, err);
+    }
+
+    /* Effective copied size must be returned */
+    size = copiedSize;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_clockGetTime(&time2,1000);
+    if (time2>time1)
+        apContext->gMyPerfFileTab[fileWriteDatatime] += time2-time1;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+UNLOCK
+
+    /* 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_cache( M4OSA_Context pContext,
+                                    M4OSA_FileSeekAccessMode SeekMode,
+                                    M4OSA_FilePosition* pPosition)
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+    M4OSA_ERR err = M4NO_ERROR;
+    M4OSA_FilePosition finalPos;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_Time time1 = 0;
+    M4OSA_Time time2 = 0;
+
+    M4OSA_clockGetTime(&time1,1000);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    M4OSA_TRACE3_2("M4OSA_fileReadSeek_cache mode = %d pos = %d", 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 */
+    }
+
+LOCK
+
+    /* Go to the desired position */
+    switch(SeekMode)
+    {
+        case M4OSA_kFileSeekBeginning :
+            finalPos = *pPosition;
+            break;
+
+        case M4OSA_kFileSeekEnd :
+            finalPos = apContext->virtualFileSize + *pPosition;
+            break;
+
+        case M4OSA_kFileSeekCurrent :
+            finalPos = apContext->absolutePos + *pPosition;
+            break;
+
+        default :
+            UNLOCK
+            return M4ERR_PARAMETER; /**< Bad SeekAcess mode */
+            break;
+    }
+
+    M4OSA_TRACE2_1("M4OSA_fileReadSeek_cache to absolutePos = %d ", finalPos);
+
+/* 20080125 Start : Protect against seek outside file. MI-958*/
+    if (finalPos <= apContext->virtualFileSize && finalPos>=0)
+    {
+        apContext->absolutePos = finalPos;
+        *pPosition = finalPos;
+    }
+    else
+    {
+        M4OSA_TRACE1_2("M4OSA_fileReadSeek_cache: attempted to seek at %d whilst filesize=%d",
+                                          finalPos, apContext->virtualFileSize);
+        *pPosition = apContext->absolutePos;    /* keep the previous position */
+        //err = M4ERR_FILE_INVALID_POSITION;
+        err = M4NO_ERROR;  /* for VA */
+    }
+/* 20080125 End : Protect against seek outside file. MI-958*/
+
+#ifdef M4OSA_FILECACHE_MM
+        apContext->absoluteWritePos = apContext->absolutePos;
+#endif /* M4OSA_FILECACHE_MM */
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_clockGetTime(&time2,1000);
+    if (time2>time1)
+        apContext->gMyPerfFileTab[fileSeektime] += time2-time1;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+UNLOCK
+
+    /* Return without error */
+    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_fileWriteSeek_cache( M4OSA_Context pContext,
+                                     M4OSA_FileSeekAccessMode SeekMode,
+                                     M4OSA_FilePosition* pPosition)
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+    M4OSA_ERR err = M4NO_ERROR;
+    M4OSA_FilePosition finalPos;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_Time time1 = 0;
+    M4OSA_Time time2 = 0;
+
+    M4OSA_clockGetTime(&time1,1000);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    M4OSA_TRACE3_2("M4OSA_fileWriteSeek_cache mode = %d pos = %d", 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 */
+    }
+
+LOCK
+
+    /* Go to the desired position */
+    switch(SeekMode)
+    {
+        case M4OSA_kFileSeekBeginning :
+            finalPos = *pPosition;
+            break;
+
+        case M4OSA_kFileSeekEnd :
+            finalPos = apContext->virtualFileSize + *pPosition;
+            break;
+
+        case M4OSA_kFileSeekCurrent :
+            finalPos = apContext->absoluteWritePos + *pPosition;
+            break;
+
+        default :
+            UNLOCK
+            return M4ERR_PARAMETER; /**< Bad SeekAcess mode */
+            break;
+    }
+
+    M4OSA_TRACE2_1("M4OSA_fileWriteSeek_cache to absoluteWritePos = %d ", finalPos);
+
+/* 20080125 Start : Protect against seek outside file. MI-958*/
+    if (finalPos <= apContext->virtualFileSize && finalPos>=0)
+    {
+        apContext->absoluteWritePos = finalPos;
+        *pPosition = finalPos;
+    }
+    else
+    {
+        M4OSA_TRACE1_2("M4OSA_fileWriteSeek_cache: attempted to seek at %d whilst filesize=%d     ",
+                                          finalPos, apContext->virtualFileSize);
+        *pPosition = apContext->absoluteWritePos;    /* keep the previous position */
+        //err = M4ERR_FILE_INVALID_POSITION;
+        err = M4NO_ERROR;  /* for VA */
+    }
+/* 20080125 End : Protect against seek outside file. MI-958*/
+
+#ifdef M4OSA_FILECACHE_MM
+    apContext->absolutePos = apContext->absoluteWritePos;
+#endif /* M4OSA_FILECACHE_MM */
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_clockGetTime(&time2,1000);
+    if (time2>time1)
+        apContext->gMyPerfFileTab[fileSeektime] += time2-time1;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+UNLOCK
+
+    /* Return without error */
+    return err;
+}
+
+M4OSA_ERR M4OSA_fileFlush_cache( M4OSA_Context pContext)
+{
+    /* Do nothing, M4OSA_fileCache module manages its caches by itself */
+
+    return M4NO_ERROR;
+}
+/**
+******************************************************************************
+* @brief       This method asks the core file reader to close the file (associated to 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_fileClose_cache(M4OSA_Context pContext)
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+
+    M4OSA_ERR err = M4NO_ERROR;
+    M4OSA_Int32 aRet_Val = 0;
+    M4OSA_UInt16 errReturned = 0;
+
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_Time time1 = 0;
+    M4OSA_Time time2 = 0;
+
+    M4OSA_clockGetTime(&time1,1000);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    M4OSA_TRACE2_1("M4OSA_fileClose_cache pC = 0x%x", 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 */
+    }
+
+LOCK
+
+#ifdef BUFFER_DISPLAY
+    M4OSA_FileCache_BufferDisplay(apContext);
+#endif
+
+    M4OSA_FileCache_BuffersFlushUntil(apContext, M4OSA_CACHEBUFFER_ALL);
+
+    /* buffer */
+    M4OSA_FileCache_BuffersFree(apContext);
+
+    /* Close the file */
+    aRet_Val = apContext->FS->pFctPtr_Close(apContext->aFileDesc, &errReturned);
+
+    if (aRet_Val != 0)
+    {
+        /* converts the error to PSW format*/
+        err = M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_READER, errReturned);
+        M4OSA_TRACE1_1("M4OSA_fileClose_cache ERR1 = 0x%x", err);
+    }
+    apContext->IsOpened = M4OSA_FALSE;
+
+    /* Free the context */
+    M4OSA_free((M4OSA_MemAddr32)apContext->FS);
+    M4OSA_free((M4OSA_MemAddr32)apContext->aFileDesc);
+
+#ifdef FILECACHE_STATS
+{
+    M4OSA_Int32 successRateRead, successRateWrite;
+
+    successRateRead= (apContext->nbReadFFS + apContext->nbReadCache ==0)? (-1) : (apContext->nbReadCache)*100 / (apContext->nbReadCache + apContext->nbReadFFS);
+
+    successRateWrite = (apContext->nbWriteFFS + apContext->nbWriteCache == 0)? (-1) : (apContext->nbWriteCache)*100 / (apContext->nbWriteCache + apContext->nbWriteFFS);
+
+#if defined(BUFFER_SELECT_INITIAL)
+    M4OSA_TRACE1_0("BUFFER_SELECT_INITIAL");
+#elif defined(BUFFER_SELECT_WITH_TIME)
+    M4OSA_TRACE1_0("BUFFER_SELECT_WITH_TIME");
+#elif defined(BUFFER_SELECT_WITH_SPACE)
+    M4OSA_TRACE1_0("BUFFER_SELECT_WITH_SPACE");
+#elif defined(BUFFER_SELECT_WITH_POS)
+    M4OSA_TRACE1_0("BUFFER_SELECT_WITH_POS");
+#endif
+
+    M4OSA_TRACE1_1("Osal File Cache Stats for %s", apContext->m_filename);
+    M4OSA_TRACE1_2("FILECACHE_STATS: nbReadCache=%d / nbReadFFS=%d",
+                                  apContext->nbReadCache, apContext->nbReadFFS);
+    M4OSA_TRACE1_2("FILECACHE_STATS: nbWriteCache=%d / nbWriteFFS=%d",
+                                apContext->nbWriteCache, apContext->nbWriteFFS);
+    M4OSA_TRACE1_2("FILECACHE_STATS: Success in reading : %d percent - Success in writing %d percent",
+                                             successRateRead, successRateWrite);
+    M4OSA_TRACE1_0("---------------------------------------------------------");
+}
+#endif /* FILECACHE_STATS */
+
+    UNLOCK
+
+    if (apContext->m_mutex != M4OSA_NULL)
+    {
+        M4OSA_mutexClose(apContext->m_mutex);
+        apContext->m_mutex = M4OSA_NULL;
+    }
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+        M4OSA_clockGetTime(&time2,1000);
+        if (time2>time1)
+            apContext->gMyPerfFileTab[fileClosetime] += time2-time1;
+
+        M4OSA_FileCache_displayTimeMeas(apContext);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    M4OSA_memset((M4OSA_MemAddr8)apContext, sizeof(M4OSA_FileCache_Context), 0);
+
+    M4OSA_free((M4OSA_MemAddr32)apContext);
+
+    M4OSA_TRACE2_1("M4OSA_fileClose_cache leaving with err = 0x%x", err);
+
+    /* Return without error */
+    return err;
+}
+
+/**
+******************************************************************************
+* @brief       This method asks the core file reader to set 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       OptionValue :   (IN) 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_fileSetOption_cache(M4OSA_Context pContext,
+                                    M4OSA_OptionID OptionID,
+                                    M4OSA_DataOption OptionValue)
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_Time time1 = 0;
+    M4OSA_Time time2 = 0;
+
+    M4OSA_clockGetTime(&time1,1000);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    /* 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 */
+    }
+
+    /* Set the desired option if it is avalaible */
+    switch(OptionID)
+    {
+        case M4OSA_kFileReadGetFileSize :       /**< Get size of the file, limited to 32 bit size */
+        case M4OSA_kFileReadGetFileAttribute :  /**< Get the file attribute*/
+        case M4OSA_kFileReadGetURL :            /**< Get the directory + name of the file */
+        case M4OSA_kFileReadIsEOF :             /**< See if we are at the end of the file */
+        case M4OSA_kFileReadGetFilePosition :   /**< Get file position */
+            return M4ERR_READ_ONLY;
+            break;
+
+        case M4OSA_kFileWriteDescMode:
+            return M4NO_ERROR;                    /* for MM */
+
+        default :                               /**< Bad option ID */
+            return M4ERR_BAD_OPTION_ID;
+            break;
+    }
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_clockGetTime(&time2,1000);
+    if (time2>time1)
+        apContext->gMyPerfFileTab[fileSetOptiontime] += time2-time1;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    /* Return without error */
+    return M4NO_ERROR;
+}
+
+/**
+******************************************************************************
+* @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_fileGetOption_cache(M4OSA_Context pContext,
+                                    M4OSA_OptionID OptionID,
+                                    M4OSA_DataOption* pOptionValue)
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+    M4OSA_ERR err = M4NO_ERROR;
+    M4OSA_Bool isEof;
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_Time time1 = 0;
+    M4OSA_Time time2 = 0;
+
+    M4OSA_clockGetTime(&time1,1000);
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+
+    /*  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 */
+    }
+
+LOCK
+
+    /* 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_TRACE2_1("M4OSA_fileGetOption_cache ReadGetFileSize return filesize = %d ",
+                                                    apContext->virtualFileSize);
+            (*(M4OSA_UInt32 *)pOptionValue) = apContext->virtualFileSize; /* return virtual */
+            break;
+
+
+        case M4OSA_kFileWriteGetFileSize:/**< Get size of the file, limited to 32 bit size */
+            M4OSA_TRACE2_1("M4OSA_fileGetOption_cache WriteGetFileSize return filesize = %d ",
+                                                    apContext->virtualFileSize);
+            (*(M4OSA_UInt32 *)pOptionValue) = apContext->virtualFileSize; /* return virtual */
+            break;
+
+        /* Check End of file Occurs */
+        case M4OSA_kFileReadIsEOF :     /**< See if we are at the end of the file */
+            isEof = (apContext->absolutePos >= apContext->virtualFileSize) ? M4OSA_TRUE : M4OSA_FALSE; /* virtual */
+            (*(M4OSA_Bool *)pOptionValue) = isEof;
+            M4OSA_TRACE2_1("M4OSA_fileGetOption_cache ReadIsEOF return isEof=%d ",
+                                                                         isEof);
+            break;
+
+        /* Get File Position */
+        case M4OSA_kFileReadGetFilePosition :   /**< Get file position */
+            M4OSA_TRACE2_1("M4OSA_fileGetOption_cache ReadGetFilePosition return rpos=%d ",
+                                                        apContext->absolutePos);
+            *(M4OSA_FilePosition *)pOptionValue = apContext->absolutePos;
+            break;
+
+        /* Get File Position */
+        case M4OSA_kFileWriteGetFilePosition :    /**< Get file position */
+            M4OSA_TRACE2_1("M4OSA_fileGetOption_cache WriteGetFilePosition return wpos=%d ",
+                                                   apContext->absoluteWritePos);
+            *(M4OSA_FilePosition *)pOptionValue = apContext->absoluteWritePos;
+            break;
+
+        /* Get Attribute */
+        case M4OSA_kFileReadGetFileAttribute :  /**< Get the file attribute = access mode */
+            M4OSA_TRACE2_1("M4OSA_fileGetOption_cache ReadGetFileAttribute return mode=%d ",
+                                           apContext->FileAttribute.modeAccess);
+            (*(M4OSA_FileAttribute *)pOptionValue).modeAccess = apContext->FileAttribute.modeAccess;
+            break;
+   /** Get the reader context for read & write file. (M4OSA_Context*)*/
+        case M4OSA_kFileWriteGetReaderContext:
+            M4OSA_TRACE2_1("M4OSA_fileGetOption_cache WriteGetReaderContext return c=0x%x ",
+                                                                     apContext);
+            (*(M4OSA_Context *)pOptionValue) = apContext;
+            break;
+        default:
+            /**< Bad option ID */
+            UNLOCK
+            return  M4ERR_BAD_OPTION_ID;
+            break;
+    }
+
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+    M4OSA_clockGetTime(&time2,1000);
+    if (time2>time1)
+        apContext->gMyPerfFileTab[fileGetOptiontime] += time2-time1;
+#endif /* M4OSA_FILE_CACHE_TIME_MEAS */
+
+    UNLOCK
+
+
+    /*Return without error */
+    return err;
+}
+
+/* For VA */
+M4OSA_ERR M4OSA_fileExtrafTruncate_cache(M4OSA_Context context, M4OSA_UInt32 length)
+{
+    M4OSA_ERR err = M4NO_ERROR;
+    M4OSA_UInt16 result = M4OSA_FALSE;
+    M4OSA_FileCache_Context* apContext = context;
+
+
+    FILE* filedesc1 = ((M4OSA_FileSystem_FFS_t_cache*) ( apContext->aFileDesc))->FileDesc;
+
+    result = ftruncate(filedesc1->_file, length);
+
+    if(result != 0)
+    {
+        err = errno;
+        M4OSA_TRACE1_1("SetEndOfFile returns err: 0x%x\n", err);
+        return M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_EXTRA, err);
+    }
+    return M4NO_ERROR;
+}
+#ifdef M4OSA_FILE_CACHE_TIME_MEAS
+
+/**************************************************************/
+void M4OSA_FileCache_initTimeMeas(M4OSA_Context pContext)
+/**************************************************************/
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+    M4OSA_Time time1 = 0;
+
+    memset(apContext->gMyPerfFileTab, 0, sizeof(apContext->gMyPerfFileTab)); //Reset perf measurement array
+
+    M4OSA_clockGetTime(&time1,1000);
+    apContext->gMyPerfFileTab[enum_size] = time1;         //to compute total application time
+
+}
+
+/**************************************************************/
+void M4OSA_FileCache_displayTimeMeas(M4OSA_Context pContext)
+/**************************************************************/
+{
+    M4OSA_FileCache_Context* apContext = (M4OSA_FileCache_Context*) pContext;
+
+    M4OSA_Time globalfileperfmeas = 0;
+    M4OSA_Time time2 = 0;
+    M4OSA_UInt32 i=0;
+
+    M4OSA_clockGetTime(&time2,1000);
+
+    /* Time spent in application */
+    time2 = time2-apContext->gMyPerfFileTab[enum_size];
+
+    /* Time spent in File System procedures */
+    for (i=0; i<enum_size; i++)
+        globalfileperfmeas += apContext->gMyPerfFileTab[i];
+
+    M4OSA_TRACE1_1("Osal File Cache Time measurement for %s ",
+                                                         apContext->m_filename);
+    M4OSA_TRACE1_2("Application time =%d, fileCache total time =%d",
+                                               (M4OSA_Int32)time2,
+                                               (M4OSA_Int32)globalfileperfmeas);
+    M4OSA_TRACE1_4("Opentime:%d, ReadDatatime:%d, WriteDatatime: %d, Seektime:%d",
+                  (M4OSA_Int32)apContext->gMyPerfFileTab[fileOpentime] ,
+                  (M4OSA_Int32)apContext->gMyPerfFileTab[fileReadDatatime] ,
+                  (M4OSA_Int32)apContext->gMyPerfFileTab[fileWriteDatatime] ,
+                  (M4OSA_Int32)apContext->gMyPerfFileTab[fileSeektime] );
+    M4OSA_TRACE1_4("GetOptiontime:%d, SetOptiontime:%d, ExternalFlush: %d, Closetime: %d",
+                  (M4OSA_Int32)apContext->gMyPerfFileTab[fileGetOptiontime] ,
+                  (M4OSA_Int32)apContext->gMyPerfFileTab[fileSetOptiontime],
+                  (M4OSA_Int32)apContext->gMyPerfFileTab[fileExternalFlushtime],
+                  (M4OSA_Int32)apContext->gMyPerfFileTab[fileClosetime]);
+    M4OSA_TRACE1_0("--------------------------------------------------------------------");
+}
+
+#endif /* M4OSA_FILE_INTERFACE_MM_TIME_MEAS */
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;
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_FileExtra.c b/libvideoeditor/osal/src/M4OSA_FileExtra.c
new file mode 100755
index 0000000..4a7b532
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_FileExtra.c
@@ -0,0 +1,527 @@
+/*
+ * 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_FileExtra.c
+* @brief        File extra for Android
+* @note         This file implements a set of basic functions to handle file
+*               itself.
+************************************************************************
+*/
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_FileCommon.h"
+#include "M4OSA_FileCommon_priv.h"
+#include "M4OSA_FileExtra.h"
+#include "M4OSA_FileReader.h"
+#include "M4OSA_FileWriter.h"
+
+#include <errno.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/statfs.h>
+
+
+
+/**
+ ************************************************************************
+ * @brief      This function deletes the provided URL.
+ * @note
+ * @param      pUrl: (IN) URL of the file to delete
+ * @param      fileModeAccess: (IN) File mode access
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileExtraDelete(const M4OSA_Char* pUrl)
+{
+
+    M4OSA_Int32  err;
+#ifdef UTF_CONVERSION
+    M4OSA_Void* tempConversionBuf;
+    M4OSA_UInt32 tempConversionSize = 1000;    /*size of the decoded buffer,
+                                                 can be increase if necessary*/
+#endif /* UTF_CONVERSION */
+
+    M4OSA_TRACE1_1("M4OSA_fileExtraDelete\t\tM4OSA_Char* %s", pUrl);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER,
+                                   "M4OSA_fileExtraDelete: pUrl is M4OSA_NULL");
+
+#ifdef UTF_CONVERSION
+    /*FB: to test the UTF16->UTF8 conversion into Video Artist*/
+    /*Convert the URL from UTF16 to UTF8*/
+    tempConversionBuf = (M4OSA_Char*)M4OSA_malloc(tempConversionSize +1, 0,
+                                                 (M4OSA_Char*)"conversion buf");
+    if(tempConversionBuf == M4OSA_NULL)
+    {
+        M4OSA_TRACE1_0("Error when allocating conversion buffer\n");
+        return M4ERR_PARAMETER;
+    }
+    M4OSA_ToUTF8_OSAL((M4OSA_Void*)pUrl, tempConversionBuf, &tempConversionSize);
+    ((M4OSA_Char*)tempConversionBuf)[tempConversionSize ] = '\0';
+
+    printf("remove file %s\n", tempConversionBuf);
+
+    /*Open the converted path*/
+    err = remove (tempConversionBuf);
+    /*Free the temporary decoded buffer*/
+    M4OSA_free((M4OSA_MemAddr32)tempConversionBuf);
+#else
+    err = remove((const char *)pUrl);
+#endif /* UTF_CONVERSION */
+
+    if(-1 == err)
+    {
+        M4OSA_DEBUG(M4ERR_PARAMETER,
+                          "M4OSA_fileExtraDelete: Cannot remove the input url");
+        return M4ERR_PARAMETER;
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function copies the file located by 'pSrcUrl' to 'pDstUrl'.
+ * @note
+ * @param      pSrcUrl: (IN) source URL
+ * @param      pDstUrl: (IN) Destination URL
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileExtraCopy(M4OSA_Char* pSrcUrl, M4OSA_Char* pDstUrl)
+{
+    M4OSA_Context pInputFileContext    = M4OSA_NULL;
+    M4OSA_Context pOutputFileContext= M4OSA_NULL;
+
+    M4OSA_ERR       err;
+    M4OSA_UInt32    uiSizeRead = BUFFER_COPY_SIZE;
+    M4OSA_MemAddr32 copy_buffer;
+
+    M4OSA_TRACE1_2("M4OSA_fileExtraDelete\t\tM4OSA_Char* %s\tM4OSA_Char* %s",
+                                                              pSrcUrl, pDstUrl);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pDstUrl, M4ERR_PARAMETER,
+                                  "M4OSA_fileExtraCopy: pDstUrl is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pSrcUrl, M4ERR_PARAMETER,
+                                  "M4OSA_fileExtraCopy: pSrcUrl is M4OSA_NULL");
+
+    /* Open input file */
+    err = M4OSA_fileReadOpen(&pInputFileContext, pSrcUrl, M4OSA_kFileRead);
+    if(M4NO_ERROR != err)
+    {
+        M4OSA_DEBUG(err, "M4OSA_fileExtraCopy: M4OSA_fileReadOpen");
+        return err;
+    }
+
+    /* Open output file */
+    err = M4OSA_fileWriteOpen(&pOutputFileContext, pDstUrl,
+                        M4OSA_kFileWrite|M4OSA_kFileCreate);
+    if(M4NO_ERROR != err)
+    {
+        M4OSA_DEBUG(err, "M4OSA_fileExtraCopy: M4OSA_fileWriteOpen");
+        return err;
+    }
+
+    /* Allocate buffer */
+    copy_buffer = M4OSA_malloc(BUFFER_COPY_SIZE, M4OSA_FILE_EXTRA,
+                               (M4OSA_Char*)"M4OSA_fileExtraCopy: copy buffer");
+    if(M4OSA_NULL == copy_buffer)
+    {
+        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileExtraCopy");
+        return M4ERR_ALLOC;
+    }
+
+    /* Copy input file to output file using copy buffer */
+    while (1)
+    {
+        /* Load data into copy buffer */
+        err = M4OSA_fileReadData(pInputFileContext,
+                                      (M4OSA_MemAddr8)copy_buffer, &uiSizeRead);
+        if(M4NO_ERROR == err)
+        {
+            /* Write data to output file */
+            err = M4OSA_fileWriteData(pOutputFileContext,
+                                       (M4OSA_MemAddr8)copy_buffer, uiSizeRead);
+            if(M4NO_ERROR != err)
+            {
+                break;
+            }
+        }
+        else if (M4WAR_NO_DATA_YET == err)
+        {
+            /* no more data to copy, end of file reached */
+            err = M4OSA_fileWriteData(pOutputFileContext,
+                                       (M4OSA_MemAddr8)copy_buffer, uiSizeRead);
+            break;
+        }
+        else
+        {
+            break; /* an error occur */
+        }
+    }
+
+    /* Free copy buffer */
+    M4OSA_free(copy_buffer);
+
+    err = M4OSA_fileWriteClose(pOutputFileContext);
+    if(M4NO_ERROR != err)
+    {
+        M4OSA_DEBUG(err, "M4OSA_fileExtraCopy: M4OSA_fileWriteClose");
+    }
+
+    err = M4OSA_fileReadClose(pInputFileContext);
+    if(M4NO_ERROR != err)
+    {
+        M4OSA_DEBUG(err, "M4OSA_fileExtraCopy: M4OSA_fileReadClose");
+    }
+
+    return err;
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function renames the 'pSrcUrl' to 'pDstUrl'.
+ * @note
+ * @param      pSrcUrl: (IN) source URL
+ * @param      pDstUrl: (IN) Destination URL
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileExtraRename(M4OSA_Char* pSrcUrl, M4OSA_Char* pDstUrl)
+{
+    M4OSA_ERR    err;
+    M4OSA_Int32 iValue;
+    M4OSA_Char*    pSrcFilename = M4OSA_NULL;
+    M4OSA_Char*    pDstFilename = M4OSA_NULL;
+
+    M4OSA_TRACE1_2("M4OSA_fileExtraRename\t\tM4OSA_Char* %s\tM4OSA_Char* %s",
+                                                              pSrcUrl, pDstUrl);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pDstUrl, M4ERR_PARAMETER,
+                                "M4OSA_fileExtraRename: pSrcUrl is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pSrcUrl, M4ERR_PARAMETER,
+                                "M4OSA_fileExtraRename: pDstUrl is M4OSA_NULL");
+
+    err = M4OSA_fileCommonGetFilename(pSrcUrl, &pSrcFilename);
+    if(M4NO_ERROR != err)
+    {
+        M4OSA_DEBUG(err, "M4OSA_fileExtraRename: M4OSA_fileCommonGetFilename");
+        return err;
+    }
+
+    err = M4OSA_fileCommonGetFilename(pDstUrl, &pDstFilename);
+    if(M4NO_ERROR != err)
+    {
+        M4OSA_free((M4OSA_MemAddr32)pSrcFilename);
+        M4OSA_DEBUG(err, "M4OSA_fileExtraRename: M4OSA_fileCommonGetFilename");
+        return err;
+    }
+
+    /* Rename file */
+    iValue = rename((const char *)pSrcFilename, (const char *)pDstFilename);
+    if (0 != iValue)
+    {
+    /*
+        What error code shall be returned ? From MSDN:
+        Each of these functions returns 0 if it is successful. On an error, the
+        function  returns a nonzero value and sets errno to one of the following
+        values:
+        - EACCES: File or directory specified by newname already exists or could
+        not be created (invalid path); or oldname is a directory and newname
+        specifies a different path.
+        - ENOENT: File or path specified by oldname not found.
+        - EINVAL: Name contains invalid characters.
+        For other possible return values, see _doserrno, _errno, syserrlist, and
+            _sys_nerr. */
+        M4OSA_DEBUG(M4ERR_PARAMETER, "M4OSA_fileExtraRename: rename failed");
+        return M4ERR_PARAMETER;
+    }
+
+    M4OSA_free((M4OSA_MemAddr32)pDstFilename);
+    M4OSA_free((M4OSA_MemAddr32)pSrcFilename);
+
+    return M4NO_ERROR;
+}
+
+
+
+/**
+ ************************************************************************
+ * @brief      This function changes the current directory to the specified new
+ *             directory 'url'.
+ * @note
+ * @param      pUrl: (IN) Directory to which current directory to be changed
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+
+M4OSA_ERR M4OSA_fileExtraChangeCurrentDir(const M4OSA_Char* pUrl)
+{
+    M4OSA_ERR    err;
+    M4OSA_Char* pFileName = M4OSA_NULL;
+    M4OSA_Int32 iValue = 0;
+
+    M4OSA_TRACE1_1("M4OSA_fileExtraChangeCurrentDir\t\tM4OSA_Char* %s", pUrl);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER,
+                         "M4OSA_fileExtraChangeCurrentDir: pUrl is M4OSA_NULL");
+
+    err = M4OSA_fileCommonGetFilename((M4OSA_Char*)pUrl, &pFileName);
+    if(M4NO_ERROR != err)
+    {
+        M4OSA_DEBUG(err,
+                "M4OSA_fileExtraChangeCurrentDir: M4OSA_fileCommonGetFilename");
+        return err;
+    }
+
+    iValue = chdir((char*)pFileName);
+
+    if (iValue != 0)
+    {
+    /*
+    What error code shall be returned ? From MSDN:
+    Each of these functions returns a value of 0 if successful. A return
+    value of -1 indicates that the specified path could not be found, in
+    which case errno is set to ENOENT.*/
+        M4OSA_DEBUG(M4ERR_PARAMETER,
+                               "M4OSA_fileExtraChangeCurrentDir: chdir failed");
+        return(M4ERR_PARAMETER);
+    }
+
+    M4OSA_free((M4OSA_MemAddr32)pFileName);
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function creates a new directory to the specified 'url'.
+ * @note
+ * @param      pUrl: (IN) Path to create new directory with name
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileExtraCreateDir(const M4OSA_Char* pUrl)
+{
+    M4OSA_Int32        err;
+
+    M4OSA_TRACE2_1("M4OSA_fileExtraCreateDir %s", pUrl);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER,
+                                "M4OSA_fileExtraCreateDir: pUrl is M4OSA_NULL");
+
+    err = mkdir((char*)pUrl, S_IRWXU | S_IRWXG | S_IRWXO);
+
+    if( err < 0 )
+    {
+           return M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_EXTRA, errno);
+    }
+
+    return M4NO_ERROR;
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function removes the current directory.
+ * @note
+ * @param      pUrl: (IN) Path of directory with name
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileExtraRemoveDir(const M4OSA_Char* pUrl)
+{
+    M4OSA_Int32    err;
+
+    M4OSA_TRACE2_1("M4OSA_fileExtraRemoveDir %s", pUrl);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pUrl, M4ERR_PARAMETER,
+                                "M4OSA_fileExtraRemoveDir: pUrl is M4OSA_NULL");
+
+    err = rmdir((char*)pUrl);
+    if(err < 0 )
+    {
+        M4OSA_DEBUG(M4ERR_PARAMETER, "M4OSA_fileExtraRemoveDir failed");
+        return M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_EXTRA, errno);
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      retrieves the free space.
+ * @note
+ * @param      pUrl: (IN) root directory
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+M4OSA_UInt32 M4OSA_fileExtraGetFreeSpace(const M4OSA_Char* pUrl)
+{
+    M4OSA_UInt32 size = 0;
+    struct statfs stat;
+
+    if ( M4OSA_NULL != pUrl )
+    {
+        if (0 == statfs( (const char *)pUrl, &stat ))
+        {
+            if ((stat.f_bfree * stat.f_bsize) > M4OSA_UINT32_MAX)
+            {
+                size = M4OSA_UINT32_MAX;
+            }
+            else
+            {
+                size = (M4OSA_UInt32)(stat.f_bfree * stat.f_bsize);
+            }
+        }
+    }
+
+    return (size);
+}
+
+/**
+ ************************************************************************
+ * @brief      This function gets the total space
+ * @note
+ * @param      pUrl: (IN) Path of directory with name
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+M4OSA_UInt32 M4OSA_fileExtraGetTotalSpace(const M4OSA_Char* pUrl)
+{
+    M4OSA_UInt32 size = 0;
+    struct statfs stat;
+
+    if ( M4OSA_NULL != pUrl )
+    {
+        if (0 == statfs( (const char *)pUrl, &stat ))
+        {
+             if ((stat.f_blocks * stat.f_bsize) > M4OSA_UINT32_MAX)
+            {
+                size = M4OSA_UINT32_MAX;
+            }
+            else
+            {
+                size = (M4OSA_UInt32)(stat.f_blocks * stat.f_bsize);
+            }
+        }
+    }
+
+    return (size);
+}
+
+/**
+ ************************************************************************
+ * @brief      This function retrieve the file type (Directory or file).
+ * @note
+ * @param      pUrl: (IN) Path of directory with name
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_NOT_IMPLEMENTED: the URL does not match with the supported
+ *             file
+ ************************************************************************
+*/
+M4OSA_EntryType M4OSA_fileExtraGetType(const M4OSA_Char* pUrl)
+{
+    M4OSA_EntryType type = M4OSA_TypeInvalid;
+    struct stat fileStat;
+
+    if ( M4OSA_NULL != pUrl )
+    {
+        if (0 == stat( (const char *)pUrl, &fileStat))
+        {
+            if ( S_ISDIR( fileStat.st_mode ) )
+            {
+                type = M4OSA_TypeDir;
+            }
+            else
+            {
+                type = M4OSA_TypeFile;
+            }
+        }
+    }
+
+    return (type);
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function truncate a file.
+ *               the file must be previously opened in write mode
+ * @note       the position pointer in the file is set to the beginning
+ *               of the file after the truncate
+ * @param      context: (IN) media context
+ * @param      length: (IN) length of the file after truncation
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more memory available
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileExtrafTruncate(M4OSA_Context context, M4OSA_FilePosition length)
+{
+    M4OSA_ERR err = M4NO_ERROR;
+    M4OSA_UInt16 result = M4OSA_FALSE;
+    M4OSA_FileContext* pFileContext = context;
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == context, M4ERR_PARAMETER,
+                             "M4OSA_fileExtrafTruncate: context is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == length, M4ERR_PARAMETER,
+                              "M4OSA_fileExtrafTruncate: length is M4OSA_NULL");
+
+    result = ftruncate(pFileContext->file_desc->_file, length);
+
+    if(result != 0)
+    {
+        err = errno;
+        M4OSA_TRACE1_1("SetEndOfFile returns err: 0x%x\n", err);
+        return M4OSA_ERR_CREATE(M4_ERR, M4OSA_FILE_EXTRA, err);
+    }
+    return M4NO_ERROR;
+}
+
+
diff --git a/libvideoeditor/osal/src/M4OSA_FileReader.c b/libvideoeditor/osal/src/M4OSA_FileReader.c
new file mode 100755
index 0000000..be3bb37
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_FileReader.c
@@ -0,0 +1,552 @@
+/*
+ * 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_FileReader.c
+ * @author       Cedric Lecoutre (cedric.lecoutre@philips.com)
+ *               Laurent Fay (laurent.fay@philips.com)
+ * @par Org:     Philips Digital Systems Laboratories - Paris (PDSL-P)
+ * @brief        File reader for Android
+ * @note         This file implements functions to read a file.
+ ************************************************************************
+*/
+
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_FileCommon_priv.h"
+#include "M4OSA_FileReader.h"
+#include "M4OSA_FileReader_priv.h"
+#include "M4OSA_Memory.h"
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+#include "M4OSA_Semaphore.h"
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+
+/**
+************************************************************************
+* @brief      This function opens the provided URL and returns its context.
+*             If an error occured, the context is set to NULL.
+* @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_fileReadOpen(M4OSA_Context* pContext, M4OSA_Void* pFileDescriptor,
+                             M4OSA_UInt32 fileModeAccess)
+{
+    M4OSA_TRACE1_3("M4OSA_fileReadOpen : pC = 0x%p  fd = 0x%p  mode = %lu",
+                                     pContext, pFileDescriptor, fileModeAccess);
+
+    return M4OSA_fileCommonOpen(M4OSA_FILE_READER, pContext,
+                                               pFileDescriptor, fileModeAccess);
+}
+
+/**
+************************************************************************
+* @brief      This function reads the 'size' bytes in the core file reader
+*             (selected by its 'context') and writes the data to the 'data'
+*             pointer.
+* @note       If 'size' byte cannot be read in the core file reader, 'size'
+*             parameter is updated to match the correct
+* @note       number of read bytes.
+* @param      context: (IN/OUT) Context of the core file reader
+* @param      buffer: (OUT) Data pointer of the read data
+* @param      size: (IN/OUT) Size of the data to read (in bytes)
+* @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     M4WAR_NO_DATA_YET: there is no enough data to fill the 'data'
+*             buffer, so the size parameter has been updated.
+************************************************************************
+*/
+M4OSA_ERR M4OSA_fileReadData(M4OSA_Context pContext, M4OSA_MemAddr8 data,
+                                                            M4OSA_UInt32* pSize)
+{
+    M4OSA_FileContext* pFileContext = pContext;
+    M4OSA_ERR    err = M4NO_ERROR;
+    M4OSA_Int32    uiSizeRead;
+
+    M4OSA_TRACE2_2("M4OSA_fileReadData : data = 0x%p  size = %lu",
+                                    data, (M4OSA_NULL != pSize) ? (*pSize) : 0);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                  "M4OSA_fileReadData: pContext is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == data, M4ERR_PARAMETER,
+                                      "M4OSA_fileReadData: data is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pSize, M4ERR_PARAMETER,
+                                     "M4OSA_fileReadData: pSize is M4OSA_NULL");
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context,
+      M4ERR_BAD_CONTEXT, "M4OSA_fileReadData: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    if(M4OSA_kDescRWAccess == pFileContext->m_DescrModeAccess) /* read write */
+    {
+        uiSizeRead = fread(data, sizeof(M4OSA_Char), *pSize,
+                                                       pFileContext->file_desc);
+        if(-1 == uiSizeRead)
+        {
+            /* handle is invalid, or the file is not open for reading, or the file is locked */
+            *pSize = 0;
+            err = M4ERR_BAD_CONTEXT;
+        }
+        else
+        {
+            M4OSA_FPOS_ADD_CONST_UINT32(pFileContext->read_position,
+                                       pFileContext->read_position, uiSizeRead);
+            if ((M4OSA_UInt32)uiSizeRead < *pSize)
+            {
+                *pSize = uiSizeRead;
+                /* This is the end of file */
+                pFileContext->b_is_end_of_file = M4OSA_TRUE;
+                err = M4WAR_NO_DATA_YET;
+            }
+            else
+            {
+                *pSize = uiSizeRead;
+            }
+        }
+
+        return err;
+    }
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    if(pFileContext->current_seek != SeekRead)
+    {
+        /* fseek to the last read position */
+        err = M4OSA_fileCommonSeek(pContext, M4OSA_kFileSeekBeginning,
+                                                &(pFileContext->read_position));
+        if(M4OSA_ERR_IS_ERROR(err))
+        {
+            M4OSA_DEBUG(err, "M4OSA_fileReadData: M4OSA_fileCommonSeek");
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            return err;
+        }
+
+        pFileContext->current_seek = SeekRead;
+    }
+
+    /* Read data */
+    uiSizeRead = fread(data, sizeof(M4OSA_Char), *pSize,
+                                                       pFileContext->file_desc);
+    if(-1 == uiSizeRead)
+    {
+        /* handle is invalid, or the file is not open for reading,
+         or the file is locked */
+        *pSize = 0;
+        err = M4ERR_BAD_CONTEXT;
+    }
+    else
+    {
+        M4OSA_FPOS_ADD_CONST_UINT32(pFileContext->read_position,
+                    pFileContext->read_position, uiSizeRead);
+        if ((M4OSA_UInt32)uiSizeRead < *pSize)
+        {
+            *pSize = uiSizeRead;
+
+            /* This is the end of file */
+            pFileContext->b_is_end_of_file = M4OSA_TRUE;
+
+            err = M4WAR_NO_DATA_YET;
+        }
+        else
+        {
+            *pSize = uiSizeRead;
+        }
+    }
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+
+    return err;
+}
+
+
+/**
+************************************************************************
+ * @brief      This function 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, from
+ *             the end or from the current postion. To support large file
+ *             access (more than 2GBytes), the position is provided on a 64
+ *             bits.
+ * @note       If this function returns an error the current position pointer
+ *             in the file must not change. Else the current
+ *             position pointer must be updated.
+ * @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_fileReadSeek(M4OSA_Context pContext, M4OSA_FileSeekAccessMode seekMode,
+                             M4OSA_FilePosition* pPosition)
+{
+    M4OSA_FileContext* pFileContext = (M4OSA_FileContext*)pContext;
+    M4OSA_ERR err;
+
+    M4OSA_TRACE2_2("M4OSA_fileReadSeek : mode = %d  pos = %lu", seekMode,
+                                  (pPosition != M4OSA_NULL) ? (*pPosition) : 0);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                  "M4OSA_fileReadSeek: pContext is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(0 == seekMode, M4ERR_PARAMETER,
+                                           "M4OSA_fileReadSeek: seekMode is 0");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pPosition, M4ERR_PARAMETER,
+                                 "M4OSA_fileReadSeek: pPosition is M4OSA_NULL");
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context,
+      M4ERR_BAD_CONTEXT, "M4OSA_fileReadSeek: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    if (M4OSA_kDescRWAccess == pFileContext->m_DescrModeAccess)
+    {
+         M4OSA_UInt32    SeekModeOption;
+         /* Go to the desired position */
+        if (M4OSA_kFileSeekBeginning == seekMode)
+        {
+            SeekModeOption = SEEK_SET;
+        }
+        else if (M4OSA_kFileSeekEnd == seekMode)
+        {
+            SeekModeOption = SEEK_END;
+        }
+        else if (M4OSA_kFileSeekCurrent == seekMode)
+        {
+            SeekModeOption = SEEK_CUR;
+        }
+        else
+        {
+            M4OSA_TRACE1_0("M4OSA_fileReadSeek: END WITH ERROR !!! (CONVERION ERROR FOR THE SEEK MODE)");
+            return M4ERR_PARAMETER;
+        }
+
+        /**
+         * Go to the desired position */
+        err = fseek(pFileContext->file_desc, *pPosition, SeekModeOption);
+        if(err != 0)
+        {
+            /* converts the error to PSW format*/
+            err=((M4OSA_UInt32)(M4_ERR)<<30)+(((M4OSA_FILE_WRITER)&0x003FFF)<<16)+(M4OSA_Int16)(err);
+            M4OSA_TRACE1_1("M4OSA_FileReadSeek error:%x",err);
+        }
+        else
+        {
+            return M4NO_ERROR;
+        }
+
+        /* Return without error */
+        return err;
+    }
+
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    if(pFileContext->current_seek != SeekRead)
+    {
+
+        /* fseek to the last read position */
+        err = M4OSA_fileCommonSeek(pContext, M4OSA_kFileSeekBeginning,
+                                                &(pFileContext->read_position));
+        if(M4OSA_ERR_IS_ERROR(err))
+        {
+            M4OSA_DEBUG(err, "M4OSA_fileReadData: M4OSA_fileCommonSeek");
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            return err;
+        }
+
+        pFileContext->current_seek = SeekRead;
+    }
+
+    err = M4OSA_fileCommonSeek(pContext, seekMode, pPosition);
+    if(M4OSA_ERR_IS_ERROR(err))
+    {
+        M4OSA_DEBUG(err, "M4OSA_fileReadData: M4OSA_fileCommonSeek");
+    }
+    else
+    {
+        M4OSA_FPOS_SET(pFileContext->read_position, *pPosition);
+    }
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    return err;
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function asks the core file reader to close the file
+ *             (associated to the context).
+ * @note       The context of the core file reader is freed.
+ * @param      pContext: (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_fileReadClose(M4OSA_Context pContext)
+{
+    M4OSA_FileContext* pFileContext = (M4OSA_FileContext*)pContext;
+
+    M4OSA_TRACE1_1("M4OSA_fileReadClose : pC = 0x%p", pContext);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                 "M4OSA_fileReadClose: pContext is M4OSA_NULL");
+
+    if(M4OSA_FILE_WRITER == pFileContext->coreID_write)
+    {
+        return M4NO_ERROR;
+    }
+
+    return M4OSA_fileCommonClose(M4OSA_FILE_READER, pContext);
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This function 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       'value' must be cast according to the type related to the
+ *             optionID As the caller is responsible for
+ *             allocating/de-allocating the 'value' field, the callee must copy
+ *             this field to its internal variable.
+ * @param      pContext: (IN/OUT) Context of the core file reader
+ * @param      pOptionID: (IN) ID of the option
+ * @param      pOptionValue: (OUT) Value of the option
+ * @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_BAD_OPTION_ID: the optionID is not a valid one
+ * @return     M4ERR_WRITE_ONLY: this option is a write only one
+ * @return     M4ERR_NOT_IMPLEMENTED: this option is not implemented
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileReadGetOption(M4OSA_Context pContext, M4OSA_FileReadOptionID optionID,
+                                  M4OSA_DataOption* pOptionValue)
+{
+    M4OSA_FileContext* pFileContext = pContext;
+
+    M4OSA_TRACE2_1("M4OSA_fileReadGetOption : option = 0x%x", optionID);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                             "M4OSA_fileReadGetOption: pContext is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(optionID == 0, M4ERR_PARAMETER,
+                                      "M4OSA_fileReadGetOption: optionID is 0");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pOptionValue, M4ERR_PARAMETER,
+                         "M4OSA_fileReadGetOption: pOptionValue is M4OSA_NULL");
+
+    M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_COREID(optionID, M4OSA_FILE_READER),
+                                M4ERR_BAD_OPTION_ID, "M4OSA_fileReadGetOption");
+    M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_READABLE(optionID),
+                                   M4ERR_WRITE_ONLY, "M4OSA_fileReadGetOption");
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context,
+                                  M4ERR_BAD_CONTEXT,
+                                  "M4OSA_fileReadGetOption: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    switch(optionID)
+    {
+#if(M4OSA_OPTIONID_FILE_READ_GET_FILE_POSITION == M4OSA_TRUE)
+    case M4OSA_kFileReadGetFilePosition:
+        {
+            M4OSA_FilePosition* pPosition = (M4OSA_FilePosition*)pOptionValue;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            *pPosition = pFileContext->read_position;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            return M4NO_ERROR;
+        }
+#endif /*M4OSA_OPTIONID_FILE_READ_GET_FILE_POSITION*/
+
+#if(M4OSA_OPTIONID_FILE_READ_IS_EOF == M4OSA_TRUE)
+    case M4OSA_kFileReadIsEOF:
+        {
+            M4OSA_Bool* bIsEndOfFile = (M4OSA_Bool*)pOptionValue;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            *bIsEndOfFile = pFileContext->b_is_end_of_file;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            return M4NO_ERROR;
+        }
+#endif /*M4OSA_OPTIONID_FILE_READ_IS_EOF*/
+
+
+#if(M4OSA_OPTIONID_FILE_READ_GET_FILE_SIZE == M4OSA_TRUE)
+    case M4OSA_kFileReadGetFileSize:
+        {
+            M4OSA_FilePosition* pPosition = (M4OSA_FilePosition*)pOptionValue;
+            M4OSA_Int32 iSavePos    = 0;
+            M4OSA_Int32 iSize        = 0;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+            /**
+            * Bugfix: update the file size.
+            * When a file is in read mode, may be another application is writing in.
+            * So, we have to update the file size */
+            iSavePos = ftell(pFileContext->file_desc);            /*1- Check the first position */
+            fseek(pFileContext->file_desc, 0, SEEK_END);        /*2- Go to the end of the file */
+            iSize = ftell(pFileContext->file_desc);                /*3- Check the file size*/
+            fseek(pFileContext->file_desc, iSavePos, SEEK_SET);    /*4- go to the first position*/
+            pFileContext->file_size = iSize;
+
+            *pPosition = pFileContext->file_size;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            return M4NO_ERROR;
+        }
+#endif /*M4OSA_OPTIONID_FILE_READ_GET_FILE_SIZE*/
+
+#if(M4OSA_OPTIONID_FILE_READ_GET_FILE_ATTRIBUTE == M4OSA_TRUE)
+    case M4OSA_kFileReadGetFileAttribute:
+        {
+            return M4OSA_fileCommonGetAttribute(pContext,
+                                            (M4OSA_FileAttribute*)pOptionValue);
+        }
+#endif /*M4OSA_OPTIONID_FILE_READ_GET_FILE_ATTRIBUTE*/
+
+#if(M4OSA_OPTIONID_FILE_READ_GET_URL == M4OSA_TRUE)
+    case M4OSA_kFileReadGetURL:
+        {
+            return M4OSA_fileCommonGetURL(pContext, (M4OSA_Char**)pOptionValue);
+        }
+#endif /*M4OSA_OPTIONID_FILE_READ_GET_URL*/
+
+        case M4OSA_kFileReadLockMode:
+        {
+            *(M4OSA_UInt32*)pOptionValue = pFileContext->m_uiLockMode;
+            return M4NO_ERROR;
+        }
+    }
+
+    M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_fileReadGetOption");
+
+    return M4ERR_NOT_IMPLEMENTED;
+}
+
+/**
+ ************************************************************************
+ * @fn         M4OSA_ERR M4OSA_fileReadSetOption (M4OSA_Context context,
+ *                       M4OSA_OptionID optionID, M4OSA_DataOption optionValue))
+ * @brief      This function asks the core file reader to set the value associated with the optionID.
+ *             The caller is responsible for allocating/de-allocating the memory of the value field.
+ * @note       As the caller is responsible for allocating/de-allocating the 'value' field, the callee must copy this field
+ *             to its internal variable.
+ * @param      pContext: (IN/OUT) Context of the core file reader
+ * @param      optionID: (IN) ID of the option
+ * @param      value: (IN) Value of the option
+ * @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_BAD_OPTION_ID: the optionID is not a valid one
+ * @return     M4ERR_READ_ONLY: this option is a read only one
+ * @return     M4ERR_NOT_IMPLEMENTED: this option is not implemented
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_fileReadSetOption(M4OSA_Context pContext,
+                                  M4OSA_FileReadOptionID optionID,
+                                  M4OSA_DataOption optionValue)
+{
+    M4OSA_FileContext* pFileContext = pContext;
+
+    M4OSA_TRACE2_1("M4OSA_fileReadSetOption : option = 0x%x", optionID);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                             "M4OSA_fileReadSetOption: pContext is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(0 == optionID, M4ERR_PARAMETER,
+                                                     "M4OSA_fileReadSetOption");
+    M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_COREID(optionID, M4OSA_FILE_READER),
+                                M4ERR_BAD_OPTION_ID, "M4OSA_fileReadSetOption");
+
+    M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_WRITABLE(optionID),
+                                    M4ERR_READ_ONLY, "M4OSA_fileReadSetOption");
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context,
+                                  M4ERR_BAD_CONTEXT,
+                                  "M4OSA_fileReadSetOption: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    switch(optionID)
+    {
+        case M4OSA_kFileReadLockMode:
+        {
+            pFileContext->m_uiLockMode= (M4OSA_UInt32)*(M4OSA_UInt32*)optionValue;
+            return M4NO_ERROR;
+        }
+        default:
+            M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_fileReadSetOption");
+            return M4ERR_NOT_IMPLEMENTED;
+    }
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_FileReader_RAM.c b/libvideoeditor/osal/src/M4OSA_FileReader_RAM.c
new file mode 100755
index 0000000..24acfaa
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_FileReader_RAM.c
@@ -0,0 +1,419 @@
+/*
+ * 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_FileReaderRam.c
+ * @ingroup      OSAL
+ * @brief        File reader from RAM
+ * @note         This file implements functions to read a "file" stored in RAM.
+ * @date         - 2004-05-11: creation
+ ******************************************************************************
+*/
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_FileReaderRam.h"
+#include "M4OSA_Memory.h"
+
+/**
+ ******************************************************************************
+ * structure    M4OSA_FileReaderRam_Context
+ * @brief       This structure defines the File reader in Ram context (private)
+ * @note        This structure is used for all File Reader calls to store the context
+ ******************************************************************************
+*/
+typedef struct
+{
+    M4OSA_MemAddr8  pFileDesc;  /* Pointer on file data */
+    M4OSA_UInt32    dataSize;   /* Size of data to read */
+    M4OSA_UInt32    dataOffset; /* Actual offset */
+    M4OSA_Bool      IsOpened;   /* Micro state machine */
+} M4OSA_FileReaderRam_Context;
+
+/**
+ ******************************************************************************
+ * @brief      This function sets the read pointer at the provided adress and
+ *             returns a context.
+ *             If an error occured, the context is set to NULL.
+ * @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_fileReadRamOpen( M4OSA_Context* context,
+                                 M4OSA_Void* fileDescriptor,
+                                 M4OSA_UInt32 fileModeAccess )
+{
+    M4OSA_FileReaderRam_Context* pContext=M4OSA_NULL;
+    M4OSA_FileReaderRam_Descriptor* pDescriptor=fileDescriptor;
+    M4OSA_ERR err = M4NO_ERROR;
+
+    M4OSA_TRACE3_3("M4OSA_fileReadRamOpen\t\tM4OSA_Context* 0x%x\tM4OSA_Void* 0x%x"
+                  "\tM4OSA_UInt32 %d", context, fileDescriptor,
+                  fileModeAccess);
+
+    /* Check input parameters */
+    if(M4OSA_NULL == context)
+    {
+        return M4ERR_PARAMETER;
+    }
+    *context = M4OSA_NULL;
+    if(M4OSA_NULL == fileDescriptor)
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    /* Allocates memory for the context */
+    pContext = (M4OSA_FileReaderRam_Context*)M4OSA_malloc(sizeof(M4OSA_FileReaderRam_Context),
+                          M4OSA_FILE_READER, (M4OSA_Char*)"Context allocation");
+    if(pContext == M4OSA_NULL)
+    {
+        return M4ERR_ALLOC;
+    }
+
+    /* Verify access mode */
+    if (((fileModeAccess & M4OSA_kFileAppend) != 0)
+       ||(0 == (fileModeAccess & M4OSA_kFileRead)))
+    {
+        err=M4ERR_FILE_BAD_MODE_ACCESS;
+        goto cleanup;
+    }
+
+    /* Open file in read mode and in binary/text mode  with/without creation right */
+    if((fileModeAccess & M4OSA_kFileCreate) != 0)
+    {
+        err=M4ERR_FILE_BAD_MODE_ACCESS;
+    }
+    else
+    {
+        if ((fileModeAccess & M4OSA_kFileRead))
+        {
+            pContext->pFileDesc = (M4OSA_MemAddr8)(pDescriptor->pFileDesc);
+            pContext->dataSize = (M4OSA_Int32)(pDescriptor->dataSize);
+            pContext->dataOffset = 0;
+            pContext->IsOpened = M4OSA_TRUE;
+        }
+        else
+        {
+            err=M4ERR_FILE_BAD_MODE_ACCESS;
+        }
+    }
+
+cleanup:
+    if(err != M4NO_ERROR)
+    {
+        if(pContext != M4OSA_NULL)
+        {
+            M4OSA_free((M4OSA_MemAddr32)pContext);
+            *context = M4OSA_NULL;
+        }
+    }
+    else
+    {
+        *context = pContext;
+    }
+    return err;
+}
+
+/**
+ ******************************************************************************
+  * @brief      This function reads the 'size' bytes in memory
+ *             (selected by its 'context') and writes the data to the 'data'
+ *             pointer.
+ * @note       If 'size' byte cannot be read in the core file reader, 'size'
+ *             parameter is updated to match the correct
+ *             number of read bytes.
+ * @param      context: (IN/OUT) Context of the core file reader
+ * @param      data: (OUT) Data pointer of the read data
+ * @param      size: (IN/OUT) Size of the data to read (in bytes)
+ * @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     M4WAR_NO_DATA_YET: there is no enough data to fill the 'data'
+ *             buffer, so the size parameter has been updated.
+ ******************************************************************************
+*/
+M4OSA_ERR M4OSA_fileReadRamData( M4OSA_Context context, M4OSA_MemAddr8 data,
+                                                           M4OSA_UInt32* pSize )
+{
+    M4OSA_FileReaderRam_Context* pContext=(M4OSA_FileReaderRam_Context*)context;
+    M4OSA_UInt32 aSize = *pSize;
+    M4OSA_ERR err = M4NO_ERROR;
+
+    /* Check input parameters */
+    if(context == M4OSA_NULL || data == M4OSA_NULL || pSize == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;
+    }
+
+    /* Check if there is enough data to read or not */
+    if((pContext->dataOffset + aSize) > pContext->dataSize)
+    {
+        aSize = pContext->dataSize - pContext->dataOffset;
+        M4OSA_memcpy(data, (pContext->pFileDesc + pContext->dataOffset), aSize);
+        *pSize = aSize;
+        err = M4WAR_NO_DATA_YET;
+    }
+    else
+    {
+        M4OSA_memcpy(data, (pContext->pFileDesc + pContext->dataOffset), aSize);
+        err = M4NO_ERROR;
+    }
+
+    pContext->dataOffset += aSize;
+    return err;
+}
+
+/**
+ ******************************************************************************
+ * @brief      This function 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, from
+ *             the end or from the current postion.
+ * @note       If this function returns an error the current position pointer
+ *             in the file must not change. Else the current
+ *             position pointer must be updated.
+ * @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_fileReadRamSeek( M4OSA_Context context,
+                                 M4OSA_FileSeekAccessMode seekMode,
+                                 M4OSA_FilePosition* position )
+{
+    M4OSA_FileReaderRam_Context* pContext=(M4OSA_FileReaderRam_Context*)context;
+    M4OSA_ERR err = M4NO_ERROR;
+
+    /* Check input parameters */
+    if(context == M4OSA_NULL || seekMode == M4OSA_NULL || position == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;
+    }
+
+    /* */
+    switch(seekMode)
+    {
+        case M4OSA_kFileSeekBeginning:
+            /* Check if position is reachable and update dataOffset */
+            if(((M4OSA_UInt32)(*position) <= pContext->dataSize) && (*position >= 0))
+            {
+                pContext->dataOffset = *position;
+                *position = pContext->dataOffset;
+                err = M4NO_ERROR;
+            }
+            else
+            {
+                err = M4ERR_FILE_INVALID_POSITION;
+            }
+            break;
+
+        case M4OSA_kFileSeekEnd:
+            /* Check if position is reachable and update dataOffset */
+            if(((M4OSA_Int32)(pContext->dataSize) + *position >= 0) && (*position <= 0))
+            {
+                pContext->dataOffset = pContext->dataSize + *position;
+                *position = pContext->dataOffset;
+                err = M4NO_ERROR;
+            }
+            else
+            {
+                err = M4ERR_FILE_INVALID_POSITION;
+            }
+            break;
+
+        case M4OSA_kFileSeekCurrent:
+            /* Check if position is reachable and update dataOffset */
+            if((*position + (M4OSA_Int32)(pContext->dataOffset) >= 0) &&
+               (*position + (M4OSA_Int32)(pContext->dataOffset) <=
+               (M4OSA_Int32)pContext->dataSize))
+            {
+                pContext->dataOffset += *position;
+                *position = pContext->dataOffset;
+                err = M4NO_ERROR;
+            }
+            else
+            {
+                err = M4ERR_FILE_INVALID_POSITION;
+            }
+            break;
+
+        default:
+            err = M4ERR_PARAMETER;
+            break;
+    }
+
+    return err;
+}
+
+/**
+ ******************************************************************************
+ * @brief      This function asks the core file reader to close the file
+ *             (associated to the context).
+ * @note       The context of the core file reader 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_fileReadRamClose(M4OSA_Context context)
+{
+    M4OSA_FileReaderRam_Context* pContext=(M4OSA_FileReaderRam_Context*)context;
+
+    /* Check input parameters */
+    if(context == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;
+    }
+
+    pContext->IsOpened = M4OSA_FALSE;
+
+    M4OSA_free((M4OSA_MemAddr32)pContext);
+
+    return M4NO_ERROR;
+}
+
+/**
+ ******************************************************************************
+ * @brief      This function 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       'value' must be cast according to the type related to the
+ *             optionID As the caller is responsible for
+ *             allocating/de-allocating the 'value' field, the callee must copy
+ *             this field to its internal variable.
+ * @param      context: (IN/OUT) Context of the core file reader
+ * @param      optionID: (IN) ID of the option
+ * @param      value: (OUT) Value of the option
+ * @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_BAD_OPTION_ID: the optionID is not a valid one
+ * @return     M4ERR_NOT_IMPLEMENTED: this option is not implemented
+ ******************************************************************************
+*/
+M4OSA_ERR M4OSA_fileReadRamGetOption( M4OSA_Context context,
+                                      M4OSA_FileReadOptionID optionID,
+                                      M4OSA_DataOption* optionValue )
+{
+    M4OSA_FileReaderRam_Context* pContext=(M4OSA_FileReaderRam_Context*)context;
+    M4OSA_ERR err=M4NO_ERROR;
+
+    /* Check input parameters */
+    if(context == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;
+    }
+
+    switch(optionID)
+    {
+        case M4OSA_kFileReadGetFileSize:
+            (*(M4OSA_UInt32 *)optionValue) = (pContext->dataSize);
+            break;
+
+        case M4OSA_kFileReadIsEOF:
+            if(pContext->dataOffset == pContext->dataSize)
+            {
+                (*(M4OSA_UInt8 *)optionValue) = M4OSA_TRUE;
+            }
+            else
+            {
+                (*(M4OSA_UInt8 *)optionValue) = M4OSA_FALSE;
+            }
+            break;
+
+        case M4OSA_kFileReadGetFileAttribute:
+            err = M4ERR_NOT_IMPLEMENTED;
+            break;
+
+        case M4OSA_kFileReadGetURL:
+            err = M4ERR_NOT_IMPLEMENTED;
+            break;
+
+        case M4OSA_kFileReadGetFilePosition :
+            (*(M4OSA_UInt32 *)optionValue) = pContext->dataOffset;
+            break;
+
+        default:
+            err = M4ERR_BAD_OPTION_ID;
+            M4OSA_TRACE1_1("M4OSA_fileReadRamGetOption invalid option ID 0x%x",
+                                                                      optionID);
+            break;
+    }
+
+    return err;
+}
+
+/**
+ ***************************************************************************
+ * @fn         M4OSA_ERR M4OSA_fileReadSetOption (M4OSA_Context context,
+ *                                                M4OSA_OptionID optionID,
+ *                                                M4OSA_DataOption optionValue))
+ * @brief      This function asks the core file reader to set the value associated with the optionID.
+ *             The caller is responsible for allocating/de-allocating the memory of the value field.
+ * @note       As the caller is responsible for allocating/de-allocating the 'value' field, the callee must copy this field
+ *             to its internal variable.
+ * @param      context: (IN/OUT) Context of the core file reader
+ * @param      optionID: (IN) ID of the option
+ * @param      value: (IN) Value of the option
+ * @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_BAD_OPTION_ID: the optionID is not a valid one
+ * @return     M4ERR_READ_ONLY: this option is a read only one
+ * @return     M4ERR_NOT_IMPLEMENTED: this option is not implemented
+ ***************************************************************************
+*/
+M4OSA_ERR M4OSA_fileReadRamSetOption( M4OSA_Context context,
+                                      M4OSA_FileReadOptionID optionID,
+                                      M4OSA_DataOption optionValue )
+{
+   return M4ERR_NOT_IMPLEMENTED;
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_FileWriter.c b/libvideoeditor/osal/src/M4OSA_FileWriter.c
new file mode 100755
index 0000000..1fc73dc
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_FileWriter.c
@@ -0,0 +1,577 @@
+/*
+ * 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_FileWriter.c
+ * @brief        File writer for Android
+ * @note         This file implements functions to write in a file.
+ ************************************************************************
+*/
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_FileCommon_priv.h"
+#include "M4OSA_FileWriter.h"
+#include "M4OSA_FileWriter_priv.h"
+#include "M4OSA_Memory.h"
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+#include "M4OSA_Semaphore.h"
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+/**
+ ************************************************************************
+ * @brief      This function opens the provided URL and returns its context.
+ *             If an error occured, the context is set to NULL.
+ * @param      pContext: (OUT) Context of the core file writer
+ * @param      pUrl: (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_fileWriteOpen(M4OSA_Context* pContext, M4OSA_Void* pUrl,
+                              M4OSA_UInt32 fileModeAccess)
+{
+    M4OSA_TRACE1_3("M4OSA_fileWriteOpen : pC = 0x%p  fd = 0x%p  mode = %d",
+                                                pContext, pUrl, fileModeAccess);
+
+    return M4OSA_fileCommonOpen(M4OSA_FILE_WRITER, pContext, pUrl,
+                                fileModeAccess);
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function writes the 'size' bytes stored at 'data' memory
+ *             in the file selected by its context.
+ * @note       The caller is responsible for allocating/de-allocating the
+ *             memory for 'data' parameter.
+ * @note       Moreover the data pointer must be allocated to store at least
+ *             'size' bytes.
+ * @param      pContext: (IN/OUT) Context of the core file reader
+ * @param      buffer: (IN) Data pointer of the write data
+ * @param      size: (IN) Size of the data to write (in bytes)
+ * @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_fileWriteData(M4OSA_Context pContext, M4OSA_MemAddr8 data,
+                              M4OSA_UInt32 uiSize)
+{
+    M4OSA_FileContext* pFileContext = pContext;
+    M4OSA_ERR err;
+    M4OSA_UInt32 uiSizeWrite;
+
+    M4OSA_TRACE2_2("M4OSA_fileWriteData : data = 0x%p  size = %lu", data,
+                                                                        uiSize);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                 "M4OSA_fileWriteData: pContext is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == data, M4ERR_PARAMETER,
+                                     "M4OSA_fileWriteData: data is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(0 == uiSize, M4ERR_PARAMETER,
+                                            "M4OSA_fileWriteData: uiSize is 0");
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context,
+                                  M4ERR_BAD_CONTEXT,
+                                  "M4OSA_fileWriteData: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    if (M4OSA_kDescRWAccess == pFileContext->m_DescrModeAccess)
+    {
+        M4OSA_UInt32    WriteSize;
+        err = M4NO_ERROR;
+        WriteSize = fwrite((void *)data,1, uiSize, pFileContext->file_desc);
+        if(WriteSize != uiSize)
+        {
+            /* converts the error to PSW format*/
+            err = ((M4OSA_UInt32)(M4_ERR)<<30)+(((M4OSA_FILE_WRITER)&0x003FFF)<<16)+(M4OSA_Int16)(WriteSize);
+            M4OSA_TRACE1_1("M4OSA_FileWriteData error:%x",err);
+        }
+        fflush(pFileContext->file_desc);
+
+        M4OSA_FPOS_ADD_CONST_UINT32(pFileContext->write_position, pFileContext->write_position, WriteSize);
+
+        /* Update the file size */
+        if(M4OSA_FPOS_COMPARE(pFileContext->write_position, pFileContext->file_size) > 0)
+        {
+            M4OSA_FPOS_SET(pFileContext->file_size, pFileContext->write_position);
+        }
+        return err;
+    }
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    if(pFileContext->current_seek != SeekWrite)
+    {
+        /* fseek to the last read position */
+        err = M4OSA_fileCommonSeek(pContext, M4OSA_kFileSeekBeginning,
+            &(pFileContext->write_position));
+
+        if(M4OSA_ERR_IS_ERROR(err))
+        {
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+            M4OSA_DEBUG(err, "M4OSA_fileWriteData: M4OSA_fileCommonSeek");
+            return err;
+        }
+
+        pFileContext->current_seek = SeekWrite;
+    }
+
+    /* Write data */
+    uiSizeWrite = fwrite(data, sizeof(M4OSA_Char), uiSize, pFileContext->file_desc);
+
+    if(uiSizeWrite == (M4OSA_UInt32)-1)
+    {
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+        M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+        /* An error occured */
+
+        M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_fileWriteData: fwrite failed");
+        return M4ERR_BAD_CONTEXT;
+    }
+
+    M4OSA_FPOS_ADD_CONST_UINT32(pFileContext->write_position,
+                                pFileContext->write_position,
+                                uiSizeWrite);
+
+    /* Update the file size */
+    if(M4OSA_FPOS_COMPARE(pFileContext->write_position, pFileContext->file_size) > 0)
+    {
+        M4OSA_FPOS_SET(pFileContext->file_size, pFileContext->write_position);
+    }
+
+    if((M4OSA_UInt32)uiSizeWrite < uiSize)
+    {
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+        M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_fileWriteData");
+        return M4ERR_ALLOC;
+    }
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    return M4NO_ERROR;
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function seeks at the provided position in the core file
+ *             writer (selected by its 'context'). The position is related to
+ *             the seekMode parameter it can be either from the beginning,
+ *             from the end or from the current postion. To support large file
+ *             access (more than 2GBytes), the position is provided on a 64
+ *             bits.
+ * @note       If this function returns an error the current position pointer
+ *             in the file must not change. Else the current position pointer
+ *             must be updated.
+ * @param      pContext: (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_fileWriteSeek(M4OSA_Context pContext, M4OSA_FileSeekAccessMode seekMode,
+                              M4OSA_FilePosition* pPosition)
+{
+    M4OSA_FileContext* pFileContext = (M4OSA_FileContext*)pContext;
+    M4OSA_ERR err;
+
+    M4OSA_TRACE2_2("M4OSA_fileWriteSeek : mode = %d  pos = %lu",
+                        seekMode, (M4OSA_NULL != pPosition) ? (*pPosition) : 0);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                 "M4OSA_fileWriteSeek: pContext is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(0 == seekMode, M4ERR_PARAMETER,
+                                          "M4OSA_fileWriteSeek: seemMode is 0");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pPosition, M4ERR_PARAMETER,
+                                "M4OSA_fileWriteSeek: pPosition is M4OSA_NULL");
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context, M4ERR_BAD_CONTEXT,
+                        "M4OSA_fileWriteSeek: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    if (M4OSA_kDescRWAccess == pFileContext->m_DescrModeAccess) /* read write */
+    {
+         M4OSA_UInt32    SeekModeOption;
+        /*The position for the seek mode between the SHP and the OSAl part are different */
+        if (M4OSA_kFileSeekBeginning == seekMode)
+        {
+            SeekModeOption = SEEK_SET;
+        }
+        else if (M4OSA_kFileSeekEnd == seekMode)
+        {
+            SeekModeOption = SEEK_END;
+        }
+        else if (M4OSA_kFileSeekCurrent == seekMode)
+        {
+            SeekModeOption = SEEK_CUR;
+        }
+        else
+        {
+            M4OSA_TRACE1_0("M4OSA_fileWriteSeek: END WITH ERROR !!! (CONVERION ERROR FOR THE SEEK MODE) ");
+            return M4ERR_PARAMETER;
+        }
+
+        /**
+         * Go to the desired position */
+        err = fseek(pFileContext->file_desc,*pPosition,SeekModeOption);
+        if(err != 0)
+        {
+            /* converts the error to PSW format*/
+            err=((M4OSA_UInt32)(M4_ERR)<<30)+(((M4OSA_FILE_WRITER)&0x003FFF)<<16)+(M4OSA_Int16)(err);
+            M4OSA_TRACE1_1("M4OSA_FileWriteSeek error:%x",err);
+        }
+        else
+        {
+            return M4NO_ERROR;
+        }
+
+        return err;
+    }
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    err = M4OSA_fileCommonSeek(pContext, seekMode, pPosition);
+
+    if(M4OSA_ERR_IS_ERROR(err))
+    {
+        M4OSA_DEBUG(err, "M4OSA_fileWriteSeek: M4OSA_fileCommonSeek");
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+        M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+        return err;
+    }
+
+    M4OSA_FPOS_SET(pFileContext->write_position, *pPosition);
+
+    pFileContext->current_seek = SeekWrite;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    return M4NO_ERROR;
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function asks the core file writer to close the file
+ *             (associated to the context).
+ * @note       The context of the core file writer is freed.
+ * @param      pContext: (IN/OUT) Context of the core file writer
+ * @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_fileWriteClose(M4OSA_Context pContext)
+{
+    M4OSA_FileContext* pFileContext = (M4OSA_FileContext*)pContext;
+
+    M4OSA_TRACE1_1("M4OSA_fileWriteClose : pC = 0x%p", pContext);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                "M4OSA_fileWriteClose: pContext is M4OSA_NULL");
+
+    return M4OSA_fileCommonClose(M4OSA_FILE_WRITER, pContext);
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function flushes the stream associated to the context.
+ * @param      pContext: (IN/OUT) Context of the core file writer
+ * @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_fileWriteFlush(M4OSA_Context pContext)
+{
+    M4OSA_FileContext* pFileContext = pContext;
+    M4OSA_ERR    err = M4NO_ERROR;
+
+    M4OSA_TRACE2_1("M4OSA_fileWriteFlush : pC = 0x%p", pContext);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                "M4OSA_fileWriteFlush: pcontext is M4OSA_NULL");
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context, M4ERR_BAD_CONTEXT,
+                       "M4OSA_fileWriteFlush: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    if (fflush(pFileContext->file_desc) != 0)
+    {
+        err = M4ERR_BAD_CONTEXT;
+    }
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    return err;
+}
+
+
+/**
+ ************************************************************************
+ * @brief      This function asks the core file writer to return the value
+ *             associated with the optionID.
+ *             The caller is responsible for allocating/de-allocating the
+ *             memory of the value field.
+ * @note       'value' must be cast according to the type related to the
+ *             optionID
+ *             As the caller is responsible for allocating/de-allocating the
+ *             'value' field, the callee must copy this field
+ *             to its internal variable.
+ * @param      pContext: (IN/OUT) Context of the core file writer
+ * @param      optionID: (IN) ID of the option
+ * @param      value: (OUT) Value of the option
+ * @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_BAD_OPTION_ID: the optionID is not a valid one
+ * @return     M4ERR_WRITE_ONLY: this option is a write only one
+ * @return     M4ERR_NOT_IMPLEMENTED: this option is not implemented
+************************************************************************
+*/
+
+M4OSA_ERR M4OSA_fileWriteGetOption(M4OSA_Context pContext, M4OSA_OptionID optionID,
+                                   M4OSA_DataOption* pOptionValue)
+{
+    M4OSA_FileContext* pFileContext = pContext;
+
+    M4OSA_TRACE2_1("M4OSA_fileWriteGetOption : option = 0x%x", optionID);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                            "M4OSA_fileWriteGetOption: pContext is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(optionID == 0, M4ERR_PARAMETER, "M4OSA_fileWriteGetOption");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pOptionValue, M4ERR_PARAMETER,
+                         "M4OSA_fileWriteGetOption: pOtionValue is M4OSA_NULL");
+
+    M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_COREID(optionID, M4OSA_FILE_WRITER),
+                               M4ERR_BAD_OPTION_ID, "M4OSA_fileWriteGetOption");
+    M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_READABLE(optionID), M4ERR_WRITE_ONLY,
+                                                    "M4OSA_fileWriteGetOption");
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context, M4ERR_BAD_CONTEXT,
+                   "M4OSA_fileWriteGetOption: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    switch(optionID)
+    {
+#if(M4OSA_OPTIONID_FILE_WRITE_GET_FILE_POSITION == M4OSA_TRUE)
+    case M4OSA_kFileWriteGetFilePosition:
+        {
+            M4OSA_FilePosition* position = (M4OSA_FilePosition*)pOptionValue;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            *position = pFileContext->write_position;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            return M4NO_ERROR;
+        }
+#endif /*M4OSA_OPTIONID_FILE_WRITE_GET_FILE_POSITION*/
+
+#if(M4OSA_OPTIONID_FILE_WRITE_GET_FILE_SIZE == M4OSA_TRUE)
+    case M4OSA_kFileWriteGetFileSize:
+        {
+            M4OSA_FilePosition* position = (M4OSA_FilePosition*)pOptionValue;
+
+            if(M4OSA_kDescRWAccess == pFileContext->m_DescrModeAccess)
+            {
+                M4OSA_Int32 iSavePos    = 0;
+                M4OSA_Int32 iSize        = 0;
+
+                iSavePos = ftell(pFileContext->file_desc);            /*1- Check the first position */
+                fseek(pFileContext->file_desc, 0, SEEK_END);        /*2- Go to the end of the file */
+                *position = ftell(pFileContext->file_desc);            /*3- Check the file size*/
+                fseek(pFileContext->file_desc, iSavePos, SEEK_SET);    /*4- go to the first position*/
+                return M4NO_ERROR;
+            }
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphoreWait(pFileContext->semaphore_context, M4OSA_WAIT_FOREVER);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            *position = pFileContext->file_size;
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+            M4OSA_semaphorePost(pFileContext->semaphore_context);
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+            return M4NO_ERROR;
+        }
+#endif /*M4OSA_OPTIONID_FILE_WRITE_GET_FILE_SIZE*/
+
+#if(M4OSA_OPTIONID_FILE_WRITE_GET_URL == M4OSA_TRUE)
+    case M4OSA_kFileWriteGetURL:
+        {
+            return M4OSA_fileCommonGetURL (pContext, (M4OSA_Char**)pOptionValue);
+        }
+#endif /*M4OSA_OPTIONID_FILE_WRITE_GET_URL*/
+
+#if(M4OSA_OPTIONID_FILE_WRITE_GET_FILE_ATTRIBUTE == M4OSA_TRUE)
+    case M4OSA_kFileWriteGetAttribute:
+        {
+            return M4OSA_fileCommonGetAttribute(pContext,
+                (M4OSA_FileAttribute*)pOptionValue);
+        }
+#endif /*M4OSA_OPTIONID_FILE_WRITE_GET_FILE_ATTRIBUTE*/
+
+#if(M4OSA_OPTIONID_FILE_WRITE_GET_READER_CONTEXT == M4OSA_TRUE)
+    case M4OSA_kFileWriteGetReaderContext:
+        {
+            M4OSA_FileModeAccess access = pFileContext->access_mode;
+
+            M4OSA_DEBUG_IF1(!(access & M4OSA_kFileRead), M4ERR_BAD_CONTEXT,
+                "M4OSA_fileWriteGetOption: M4OSA_kFileRead");
+
+            M4OSA_DEBUG_IF1(!(access & M4OSA_kFileWrite), M4ERR_BAD_CONTEXT,
+                "M4OSA_fileWriteGetOption: M4OSA_kFileWrite");
+
+            pFileContext->coreID_read = M4OSA_FILE_READER;
+
+            *pOptionValue = pContext;
+
+            return M4NO_ERROR;
+        }
+#endif /*M4OSA_OPTIONID_FILE_WRITE_GET_READER_CONTEXT*/
+
+    case M4OSA_kFileWriteLockMode:
+        {
+            *(M4OSA_UInt32*)pOptionValue = pFileContext->m_uiLockMode;
+            return M4NO_ERROR;
+        }
+
+    }
+
+    M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_fileWriteGetOption");
+
+    return M4ERR_NOT_IMPLEMENTED;
+}
+
+
+/**
+************************************************************************
+* @brief      This function asks the core file writer to set the value
+*             associated with the optionID.
+*             The caller is responsible for allocating/de-allocating the
+*             memory of the value field.
+* @note       As the caller is responsible for allocating/de-allocating the
+*             'value' field, the callee must copy this field to its internal
+*             variable.
+* @param      pContext: (IN/OUT) Context of the core file writer
+* @param      optionID: (IN) ID of the option
+* @param      value: (IN) Value of the option
+* @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_BAD_OPTION_ID: the optionID is not a valid one
+* @return     M4ERR_READ_ONLY: this option is a read only one
+* @return     M4ERR_NOT_IMPLEMENTED: this option is not implemented
+************************************************************************
+*/
+
+M4OSA_ERR M4OSA_fileWriteSetOption(M4OSA_Context pContext,
+                                   M4OSA_OptionID optionID,
+                                   M4OSA_DataOption optionValue)
+{
+    M4OSA_FileContext* pFileContext = pContext;
+
+    M4OSA_TRACE2_1("M4OSA_fileWriteSetOption : option = 0x%x", optionID);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                                    "M4OSA_fileWriteSetOption");
+
+    M4OSA_DEBUG_IF2(0 == optionID, M4ERR_PARAMETER, "M4OSA_fileWriteSetOption");
+
+    M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_COREID(optionID, M4OSA_FILE_WRITER),
+        M4ERR_BAD_OPTION_ID, "M4OSA_fileWriteSetOption");
+
+    M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_WRITABLE(optionID), M4ERR_READ_ONLY,
+                                                     "M4OSA_fileReadSetOption");
+
+#ifdef M4OSA_FILE_BLOCK_WITH_SEMAPHORE
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFileContext->semaphore_context, M4ERR_BAD_CONTEXT,
+                   "M4OSA_fileWriteSetOption: semaphore_context is M4OSA_NULL");
+#endif /* M4OSA_FILE_BLOCK_WITH_SEMAPHORE */
+
+    switch(optionID)
+    {
+        case M4OSA_kFileWriteLockMode:
+        {
+            pFileContext->m_uiLockMode = (M4OSA_UInt32)*(M4OSA_UInt32*)optionValue;
+            return M4NO_ERROR;
+        }
+
+        case M4OSA_kFileWriteDescMode:
+        {
+            pFileContext->m_DescrModeAccess = (M4OSA_Int32)*(M4OSA_Int32*)optionValue;
+            return M4NO_ERROR;
+        }
+
+        default:
+            return M4ERR_NOT_IMPLEMENTED;
+    }
+
+    return M4ERR_NOT_IMPLEMENTED;
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_FileWriter_RAM.c b/libvideoeditor/osal/src/M4OSA_FileWriter_RAM.c
new file mode 100755
index 0000000..9341ca9
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_FileWriter_RAM.c
@@ -0,0 +1,448 @@
+/*
+ * 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_FileReaderRam.c
+
+ * @brief        File reader from RAM
+ * @note         This file implements functions to read a "file" stored in RAM.
+******************************************************************************
+*/
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_FileWriterRam.h"
+#include "M4OSA_FileReaderRam.h"
+#include "M4OSA_Memory.h"
+
+
+/**
+ ******************************************************************************
+ * structure    M4OSA_FileWriteRam_Context
+ * @brief        This structure defines the File writer context (private)
+ * @note        This structure is used for all File writer calls to store the context
+ ******************************************************************************
+*/
+typedef struct
+{
+    M4OSA_MemAddr8    pFileDesc;    /* Pointer on file data */
+    M4OSA_UInt32    dataSize;    /* Size of data to write */
+    M4OSA_UInt32    dataOffset;    /* Actual offset */
+    M4OSA_Bool        IsOpened;    /* Micro state machine */
+    M4OSA_UInt32    bufferSize;    /* Actual used size inside the buffer */
+} M4OSA_FileWriterRam_Context;
+
+
+/**
+ ******************************************************************************
+ * @brief    This method "opens" the provided fileDescriptor (in fact address)
+ *            and returns its context.
+ * @param    pContext:    (OUT) File writer 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
+ * @return    M4ERR_FILE_NOT_FOUND The file can not be opened.
+ ******************************************************************************
+*/
+M4OSA_ERR M4OSA_fileWriteRamOpen(M4OSA_Context* context, M4OSA_Void* fileDescriptor,
+                                                    M4OSA_UInt32 fileModeAccess)
+{
+    M4OSA_FileWriterRam_Context* pContext=M4OSA_NULL;
+    M4OSA_FileWriterRam_Descriptor* pDescriptor = fileDescriptor;
+    M4OSA_Int32 aFileDesc=-1;
+    M4OSA_ERR   err=M4NO_ERROR;
+
+    /*    Check input parameters */
+    if(context == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+    *context = M4OSA_NULL;
+    if(fileDescriptor == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    /*    Allocate memory for the File writer context. */
+    pContext = (M4OSA_FileWriterRam_Context *)M4OSA_malloc(sizeof(M4OSA_FileWriterRam_Context),
+                          M4OSA_FILE_WRITER, (M4OSA_Char*)"Context allocation");
+    if(pContext == M4OSA_NULL)
+    {
+        return M4ERR_ALLOC;
+    }
+
+    if ((fileModeAccess & M4OSA_kFileWrite))
+    {
+        pContext->pFileDesc = (M4OSA_MemAddr8)(pDescriptor->pFileDesc);
+        pContext->dataSize = (M4OSA_Int32)(pDescriptor->dataSize);
+        pContext->dataOffset = 0;
+        pContext->bufferSize = 0;
+        pContext->IsOpened = M4OSA_TRUE;
+    }
+    else
+    {
+        err = M4ERR_FILE_BAD_MODE_ACCESS;
+    }
+    if (M4NO_ERROR != err)
+    {
+          if (M4OSA_NULL != pContext)
+        {
+            M4OSA_free((M4OSA_MemAddr32)pContext);
+        }
+        *context=M4OSA_NULL;
+    }
+    else
+    {
+        *context = pContext;
+    }
+
+    return err;
+}
+
+/**
+ ******************************************************************************
+ * @brief    This method writes the 'size' bytes stored at 'data' memory at the end
+ *            of the file selected by its context.
+ *            The caller is responsible for allocating/de-allocating the memory for 'data' parameter.
+ *            Moreover, the data pointer must be allocated to store at least 'size' bytes.
+ * @param    pContext:    (IN) File writer context.
+ * @param    pData :    (IN) Data pointer of the written data.
+ * @param    Size :    (IN) Size of the data to write (in bytes).
+ * @return    M4NO_ERROR: there is no error
+ * @return    M4ERR_PARAMETER     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_fileWriteRamData(M4OSA_Context context,M4OSA_MemAddr8 data, M4OSA_UInt32 Size)
+{
+    M4OSA_FileWriterRam_Context* pContext=(M4OSA_FileWriterRam_Context*)context;
+    M4OSA_ERR err=M4NO_ERROR;
+
+    /*    Check input parameters */
+    if(context == M4OSA_NULL || data == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;    /* The context can not be correct */
+    }
+
+    /* Check if there is enough room to write or not */
+    if (pContext->dataOffset + Size < pContext->dataSize )
+    {
+        M4OSA_memcpy((pContext->pFileDesc + pContext->dataOffset), data, Size);
+        pContext->dataOffset += Size;
+        if(pContext->dataOffset> pContext->bufferSize) pContext->bufferSize = pContext->dataOffset;
+        err = M4NO_ERROR;
+    }
+    else
+    {
+        err = M4ERR_FILE_INVALID_POSITION;
+    }
+
+    return err;
+}
+
+/**
+ ******************************************************************************
+ * @brief    This method seeks at the provided position in the core file writer (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_fileWriteRamSeek(M4OSA_Context context, M4OSA_FileSeekAccessMode SeekMode,
+                                                   M4OSA_FilePosition* position)
+{
+    M4OSA_FileWriterRam_Context* pContext=(M4OSA_FileWriterRam_Context*)context;
+    M4OSA_ERR err=M4NO_ERROR;
+
+    /*    Check input parameters */
+    if(context == M4OSA_NULL || SeekMode == M4OSA_NULL || position == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;    /* The context can not be correct */
+    }
+
+    /* Go to the desired position */
+    switch(SeekMode)
+    {
+        case M4OSA_kFileSeekBeginning:
+            /* Check if position is reachable and update dataOffset */
+            if (((*position) >= 0) && ((M4OSA_UInt32)(*position) <= pContext->dataSize))
+            {
+                pContext->dataOffset = *position;
+                err = M4NO_ERROR;
+            }
+            else
+            {
+                err = M4ERR_FILE_INVALID_POSITION;
+            }
+            break;
+
+        case M4OSA_kFileSeekEnd:
+            /* Check if position is reachable and update dataOffset */
+            if ((*position) < 0)
+            {
+                if (pContext->dataSize >= (M4OSA_UInt32)(-(*position)))
+                {
+                    pContext->dataOffset = (M4OSA_UInt32) (pContext->pFileDesc + pContext->dataSize + (*position));
+                    err = M4NO_ERROR;
+                }
+                else
+                {
+                    err = M4ERR_FILE_INVALID_POSITION;
+                }
+            }
+            else if ((*position) == 0)
+            {
+                 pContext->dataOffset = (M4OSA_UInt32)(pContext->pFileDesc + pContext->dataSize);
+                 err = M4NO_ERROR;
+            }
+            else
+            {
+                err = M4ERR_FILE_INVALID_POSITION;
+            }
+            break;
+
+        case M4OSA_kFileSeekCurrent:
+            /* Check if position is reachable and update dataOffset */
+            if ((*position) < 0)
+            {
+                if (pContext->dataOffset >= (M4OSA_UInt32)(-(*position)))
+                {
+                    pContext->dataOffset = (M4OSA_UInt32) (pContext->dataOffset + (*position));
+                    err = M4NO_ERROR;
+                }
+                else
+                {
+                    err = M4ERR_FILE_INVALID_POSITION;
+                }
+            }
+            else
+            {
+                if (pContext->dataSize >= (M4OSA_UInt32)(pContext->dataOffset + (*position)))
+                {
+                    pContext->dataOffset = (M4OSA_UInt32) (pContext->dataOffset + (*position));
+                    err = M4NO_ERROR;
+                }
+                else
+                {
+                    err = M4ERR_FILE_INVALID_POSITION;
+                }
+            }
+            break;
+
+        default:
+            err = M4ERR_PARAMETER;
+            break;
+    }
+
+    return err;
+}
+
+/**
+ ******************************************************************************
+ * @brief    This method asks the core file writer to close the file (associated to the context).
+ *            The context of the core file reader must be freed.
+ * @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_fileWriteRamClose(M4OSA_Context context)
+{
+    M4OSA_FileWriterRam_Context* pContext=(M4OSA_FileWriterRam_Context*)context;
+    M4OSA_ERR err=M4NO_ERROR;
+
+    /*    Check input parameters */
+    if(pContext == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;    /* The context can not be correct */
+    }
+
+    pContext->IsOpened = M4OSA_FALSE;
+
+    /* Free the context */
+    M4OSA_free((M4OSA_MemAddr32)pContext);
+
+    /*    Return error */
+    return err;
+}
+
+/**
+ ******************************************************************************
+ * @brief    This method asks the core file writer to flush the pending data
+ *            to the file (associated to the context).
+ *            All pending written data are written in the file.
+ * @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_fileWriteRamFlush(M4OSA_Context context)
+{
+    M4OSA_FileWriterRam_Context* pContext=(M4OSA_FileWriterRam_Context*)context;
+
+    /*    Check input parameters */
+    if(context == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;    /* The context can not be correct */
+    }
+
+    /*
+     * DO NOTHING */
+
+    /**
+     *    Return without error */
+    return M4NO_ERROR;
+}
+
+/**
+ ******************************************************************************
+ * @brief    This method asks the core file writer to set 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    OptionValue :    (IN) Value of the option.
+ * @return    M4NO_ERROR: there is no error
+ * @return    M4ERR_BAD_CONTEXT    pContext is NULL
+ * @return    M4ERR_READ_ONLY The option is not implemented yet.
+ * @return    M4ERR_BAD_OPTION_ID the option id is not valid.
+ * @return    M4ERR_NOT_IMPLEMENTED The option is not implemented yet.
+ ******************************************************************************
+*/
+M4OSA_ERR M4OSA_fileWriteRamSetOption(M4OSA_Context context,
+                                      M4OSA_OptionID OptionID,
+                                      M4OSA_DataOption OptionValue)
+{
+    M4OSA_FileWriterRam_Context* pContext=(M4OSA_FileWriterRam_Context*)context;
+
+    /*    Check input parameters */
+    if(context == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;    /**< The context can not be correct */
+    }
+
+    /*    Set the desired option if it is avalaible */
+    switch(OptionID)
+    {
+        case M4OSA_kFileWriteGetReaderContext :    /* Get the file attribute*/
+        case M4OSA_kFileWriteGetURL :            /* Get the directory + name of the file */
+        case M4OSA_kFileWriteGetFilePosition :    /* Get file position */
+            return M4ERR_READ_ONLY;
+            break;
+
+        case M4OSA_kFileWriteGetAttribute :
+            /**
+             * Get the reader context for read & write file. It is NULL if the file is opened
+             * with write attribute only */
+            return M4ERR_NOT_IMPLEMENTED;
+
+        default :                                /* Bad option ID */
+            return    M4ERR_BAD_OPTION_ID;
+    }
+
+    /*    Return without error */
+    return M4NO_ERROR;
+}
+
+/**
+ ******************************************************************************
+ * @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_ALLOC    there is no more memory available
+ * @return    M4ERR_NOT_IMPLEMENTED The option is not implemented yet.
+ ******************************************************************************
+*/
+M4OSA_ERR M4OSA_fileWriteRamGetOption(M4OSA_Context context,
+                                      M4OSA_OptionID OptionID,
+                                      M4OSA_DataOption* optionValue)
+{
+    M4OSA_FileWriterRam_Context* pContext=(M4OSA_FileWriterRam_Context*)context;
+    M4OSA_ERR   err=M4NO_ERROR;
+
+    /*    Check input parameters */
+    if(context == M4OSA_NULL)
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    if (pContext->IsOpened != M4OSA_TRUE)
+    {
+        return M4ERR_BAD_CONTEXT;    /**< The context can not be correct */
+    }
+
+    /*    Get the desired option if it is avalaible */
+    switch(OptionID)
+    {
+        case M4OSA_kFileWriteGetFileSize:/* Get size of the file, limited to 32 bit size */
+            (*(M4OSA_UInt32 *)optionValue) = (pContext->bufferSize);
+            break;
+
+        case M4OSA_kFileWriteGetURL :    /* Get the directory + name of the file */
+            return M4ERR_NOT_IMPLEMENTED;
+
+        default :                                /**< Bad option ID */
+            return M4ERR_BAD_OPTION_ID;
+            break;
+    }
+
+    /*    Return without error */
+    return err;
+}
diff --git a/libvideoeditor/osal/src/M4OSA_Mutex.c b/libvideoeditor/osal/src/M4OSA_Mutex.c
new file mode 100755
index 0000000..0d857f6
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_Mutex.c
@@ -0,0 +1,276 @@
+/*
+ * 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.
+ */
+/**
+ ************************************************************************
+ * @brief        Mutex for Android
+ * @note         This file implements functions to manipulate mutex
+ ************************************************************************
+*/
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_Memory.h"
+#include "M4OSA_Mutex.h"
+
+#include <pthread.h>
+#include <errno.h>
+
+
+/* Context for the mutex */
+typedef struct
+{
+   M4OSA_UInt32     coreID;               /* mutex context identifiant */
+   pthread_mutex_t  mutex;                /* mutex */
+   pthread_t        threadOwnerID;        /* thread owner identifiant */
+} M4OSA_MutexContext;
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method creates a new mutex.
+ * @note       This function creates and allocates a unique context. It's the
+ *             OSAL real time responsibility for managing its context. It must
+ *             be freed by the M4OSA_mutexClose function. The context parameter
+ *             will be sent back to any OSAL core mutex functions to allow
+ *             retrieving data associated to the opened mutex.
+ * @param      pContext:(OUT) Context of the created mutex
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_ALLOC: there is no more available memory
+ * @return     M4ERR_CONTEXT_FAILED: the context creation failed
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_mutexOpen(M4OSA_Context* pContext)
+{
+    M4OSA_MutexContext* pMutexContext = (M4OSA_MutexContext*)M4OSA_NULL;
+    pthread_mutexattr_t attribute = { 0 };
+    M4OSA_Bool opened = M4OSA_FALSE;
+
+    M4OSA_TRACE1_1("M4OSA_mutexOpen\t\tM4OSA_Context* 0x%x", pContext);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pContext, M4ERR_PARAMETER,
+                                     "M4OSA_mutexOpen: pContext is M4OSA_NULL");
+
+    *pContext = M4OSA_NULL;
+
+    pMutexContext = (M4OSA_MutexContext*)M4OSA_malloc(sizeof(M4OSA_MutexContext),
+                    M4OSA_MUTEX, (M4OSA_Char*)"M4OSA_mutexOpen: mutex context");
+
+    if(M4OSA_NULL == pMutexContext)
+    {
+        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_mutexOpen");
+        return M4ERR_ALLOC;
+    }
+
+    /* Initialize the mutex attribute. */
+    if ( 0 == pthread_mutexattr_init( &attribute ) )
+    {
+        /* Initialize the mutex type. */
+        if ( 0 == pthread_mutexattr_settype( &attribute, PTHREAD_MUTEX_RECURSIVE ) )
+        {
+            /* Initialize the mutex. */
+            if (0 == pthread_mutex_init( &pMutexContext->mutex, &attribute ) )
+            {
+                opened = M4OSA_TRUE;
+            }
+        }
+
+        /* Destroy the mutex attribute. */
+        pthread_mutexattr_destroy( &attribute );
+    }
+
+    if(!opened)
+    {
+        M4OSA_DEBUG(M4ERR_CONTEXT_FAILED, "M4OSA_mutexOpen: OS mutex creation failed");
+        M4OSA_free((M4OSA_MemAddr32)pMutexContext);
+        return M4ERR_CONTEXT_FAILED ;
+    }
+
+    pMutexContext->coreID = M4OSA_MUTEX;
+
+    pMutexContext->threadOwnerID = 0;
+
+    *pContext = (M4OSA_Context) pMutexContext;
+
+    return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method locks the mutex. "Context" identifies the mutex.
+ * @note       If the mutex is already locked, the calling thread blocks until
+ *             the mutex becomes available (by calling M4OSA_mutexUnlock) or
+ *             "timeout" is reached. This is a blocking call.
+ * @param      context:(IN/OUT) Context of the mutex
+ * @param      timeout:(IN) Time out in milliseconds
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4WAR_TIME_OUT: time out is elapsed before mutex has been
+ *             available
+ * @return     M4ERR_BAD_CONTEXT: provided context is not a valid one
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_mutexLock(M4OSA_Context context, M4OSA_UInt32 timeout)
+{
+    M4OSA_MutexContext* pMutexContext = (M4OSA_MutexContext*)context;
+    pthread_t           currentThread;
+    int                 result;
+    struct timespec     ts;
+    struct timespec     left;
+
+    M4OSA_TRACE1_2("M4OSA_mutexLock\t\tM4OSA_Context 0x%x\tM4OSA_UInt32 %d",
+        context, timeout);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == context, M4ERR_PARAMETER,
+                                      "M4OSA_mutexLock: context is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(pMutexContext->coreID != M4OSA_MUTEX,
+                                          M4ERR_BAD_CONTEXT, "M4OSA_mutexLock");
+
+    currentThread = pthread_self();
+
+    if(pMutexContext ->threadOwnerID == currentThread)
+    {
+        M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_mutexLock: Thread tried to lock a mutex it already owns");
+        return M4ERR_BAD_CONTEXT ;
+    }
+
+    /* Lock the mutex. */
+    if ( M4OSA_WAIT_FOREVER == timeout)
+    {
+        if ( 0 != pthread_mutex_lock(&pMutexContext->mutex) )
+        {
+            M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_mutexLock: OS mutex wait failed");
+            return M4ERR_BAD_CONTEXT;
+        }
+    }
+    else
+    {
+        result = pthread_mutex_trylock(&pMutexContext->mutex);
+        while ( ( EBUSY == result ) && ( 0 < timeout ) )
+        {
+            ts.tv_sec  = 0;
+            if (1 <= timeout)
+            {
+                ts.tv_nsec = 1000000;
+                timeout -= 1;
+            }
+            else
+            {
+                ts.tv_nsec = timeout * 1000000;
+                timeout = 0;
+            }
+            nanosleep(&ts, &left);
+            result = pthread_mutex_trylock(&pMutexContext->mutex);
+        }
+        if (0 != result)
+        {
+            if (EBUSY == result)
+            {
+                return M4WAR_TIME_OUT;
+            }
+            else
+            {
+                M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_mutexLock: OS mutex wait failed");
+                return M4ERR_BAD_CONTEXT;
+            }
+        }
+    }
+
+    pMutexContext->threadOwnerID = currentThread;
+
+    return M4NO_ERROR;
+}
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method unlocks the mutex. The mutex is identified by
+ *             its context
+ * @note       The M4OSA_mutexLock unblocks the thread with the highest
+ *             priority and made it ready to run.
+ * @note       No hypotheses can be made on which thread will be un-blocked
+ *             between threads with the same priority.
+ * @param      context:(IN/OUT) Context of the mutex
+ * @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_mutexUnlock(M4OSA_Context context)
+{
+    M4OSA_MutexContext* pMutexContext = (M4OSA_MutexContext*)context;
+    pthread_t currentThread;
+
+    M4OSA_TRACE1_1("M4OSA_mutexUnlock\t\tM4OSA_Context 0x%x", context);
+    M4OSA_DEBUG_IF2(M4OSA_NULL == context, M4ERR_PARAMETER,
+                                    "M4OSA_mutexUnlock: context is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(M4OSA_MUTEX != pMutexContext->coreID,
+                                        M4ERR_BAD_CONTEXT, "M4OSA_mutexUnlock");
+
+    currentThread = pthread_self();
+
+    if(pMutexContext->threadOwnerID != currentThread)
+    {
+        M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_mutexUnlock: Thread tried to unlock a mutex it doesn't own");
+        return M4ERR_BAD_CONTEXT;
+    }
+
+    pMutexContext->threadOwnerID = 0 ;
+
+    pthread_mutex_unlock(&pMutexContext->mutex);
+
+    return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method deletes a mutex (identify by its context). After
+ *             this call, the mutex and its context is no more useable. This
+ *             function frees all the memory related to this mutex.
+ * @note       It is an application issue to warrant no more threads are locked
+ *             on the deleted mutex.
+ * @param      context:(IN/OUT) Context of the mutex
+ * @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_mutexClose(M4OSA_Context context)
+{
+    M4OSA_MutexContext* pMutexContext = (M4OSA_MutexContext*)context;
+
+    M4OSA_TRACE1_1("M4OSA_mutexClose\t\tM4OSA_Context 0x%x", context);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == context, M4ERR_PARAMETER,
+                                     "M4OSA_mutexClose: context is M4OSA_NULL");
+    M4OSA_DEBUG_IF2(pMutexContext->coreID != M4OSA_MUTEX,
+                                        M4ERR_BAD_CONTEXT, "M4OSA_mutexUnlock");
+
+    pthread_mutex_destroy(&pMutexContext->mutex);
+
+    M4OSA_free((M4OSA_MemAddr32) pMutexContext);
+
+    return M4NO_ERROR;
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_Random.c b/libvideoeditor/osal/src/M4OSA_Random.c
new file mode 100755
index 0000000..63fdf5e
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_Random.c
@@ -0,0 +1,91 @@
+/*
+ * 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        M4PSW_Trace.c
+ * @brief        Trace function for trace macros
+ * @note        This file gives the implementation of the trace function used
+ *                in the trace instrumentation macros
+ ************************************************************************
+*/
+
+#include <stdio.h>  /*for printf */
+#include <stdarg.h> /* ANSI C macros and defs for variable args */
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_Memory.h"
+#include "M4OSA_Mutex.h"
+/**
+ ************************************************************************
+ * @fn         M4OSA_ERR M4OSA_randInit()
+ * @brief      this function initialize the number generator
+ *               this function must be called once before any call to M4OSA_rand()
+ *               need the stdlib and time libraries
+ * @note
+ * @param
+ * @return     M4NO_ERROR
+ ************************************************************************
+*/
+
+M4OSA_ERR M4OSA_randInit()
+{
+    int i;
+
+    srand(time(NULL));
+
+    /* Windows' rand is rotten, the first generated value after the init
+    above is not random enough, so let's shake things a little... */
+
+    for (i=0; i<100; i++) rand();
+
+    return M4NO_ERROR;
+}
+/**
+ ************************************************************************
+ * @fn           M4OSA_ERR M4OSA_rand(M4OSA_Int32* out_value, M4OSA_UInt32 max_value)
+ * @brief       This function gives a random number between 1 and max_value
+ *               (inclusive) with approximately equal probability, and
+ *               returns this number in out_value. For instance, a max_value
+ *             of 6 will simulate a fair 6-sided dice roll.
+ * @note
+ * @param      out_value (OUT): on return, points to random result
+ * @param       max_value (IN): max expected value
+ * @return     M4NO_ERROR
+ ************************************************************************
+*/
+
+M4OSA_ERR M4OSA_rand(M4OSA_Int32* out_value, M4OSA_UInt32 max_value)
+{
+    if( (out_value == M4OSA_NULL) || (max_value < 1) )
+    {
+        return M4ERR_PARAMETER;
+    }
+
+    (*out_value) = rand();
+    /* notice this algorithm will only work for max_values such that the multiplication
+    won't overflow, which means that max_value typically shouldn't go over the range of
+    an Int16. */
+    (*out_value) = (((*out_value) * max_value) / ((M4OSA_UInt32)RAND_MAX + 1)) + 1;
+
+    return M4NO_ERROR;
+}
+
+
diff --git a/libvideoeditor/osal/src/M4OSA_Semaphore.c b/libvideoeditor/osal/src/M4OSA_Semaphore.c
new file mode 100755
index 0000000..a99b136
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_Semaphore.c
@@ -0,0 +1,264 @@
+/*
+ * 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_Semaphore.c
+ * @brief        Semaphore for Windows
+ * @note         This file implements functions to manipulate semaphore
+ ************************************************************************
+*/
+
+
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_Memory.h"
+#include "M4OSA_Semaphore.h"
+
+#include <semaphore.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <time.h>
+
+
+/* Context for the semaphore */
+typedef struct {
+   M4OSA_UInt32   coreID;     /* semaphore context identifiant */
+   sem_t          semaphore;  /* semaphore */
+} M4OSA_SemaphoreContext;
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method creates a new semaphore with the "initialCounter"
+ *             value.
+ * @note       This function creates and allocates a unique context. It's the
+ *             OSAL real time responsibility for managing its context. It must
+ *             be freed by the M4OSA_semaphoreClose function. The context
+ *             parameter will be sent back to any OSAL core semaphore functions
+ *             to allow retrieving data associated to the opened semaphore.
+ * @param      context:(OUT) Context of the created semaphore
+ * @param      initial_count:(IN) Initial counter of the semaphore
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_PARAMETER: provided context is NULL
+ * @return     M4ERR_ALLOC: there is no more available memory
+ * @return     M4ERR_CONTEXT_FAILED: the context creation failed
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_semaphoreOpen(M4OSA_Context* context,
+                              M4OSA_UInt32 initial_count)
+{
+   M4OSA_SemaphoreContext* semaphoreContext = M4OSA_NULL;
+
+   M4OSA_TRACE1_2("M4OSA_semaphoreOpen\t\tM4OSA_Context* 0x%x\tM4OSA_UInt32 "
+                  "%d", context, initial_count);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_semaphoreOpen");
+
+   *context = M4OSA_NULL;
+
+   semaphoreContext = (M4OSA_SemaphoreContext*) M4OSA_malloc(
+                      sizeof(M4OSA_SemaphoreContext), M4OSA_SEMAPHORE,
+                      (M4OSA_Char*)"M4OSA_semaphoreOpen: semaphore context");
+
+   if(semaphoreContext == M4OSA_NULL)
+   {
+      M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_semaphoreOpen");
+
+      return M4ERR_ALLOC;
+   }
+
+   if (0 != sem_init(&semaphoreContext->semaphore, 0, initial_count))
+   {
+      M4OSA_free((M4OSA_MemAddr32)semaphoreContext);
+
+      M4OSA_DEBUG(M4ERR_CONTEXT_FAILED,
+         "M4OSA_semaphoreOpen: OS semaphore creation failed");
+
+      return M4ERR_CONTEXT_FAILED;
+   }
+
+   semaphoreContext->coreID = M4OSA_SEMAPHORE ;
+   *context = (M4OSA_Context)semaphoreContext;
+
+   return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method decrements (one by one) the semaphore counter. The
+ *             semaphore is identified by its context This call is not blocking
+ *             if the semaphore counter is positive or zero (after
+ *             decrementation). This call is blocking if the semaphore counter
+ *             is less than zero (after decrementation), until the semaphore is
+ *             upper than zero (see M4OSA_semaphorePost) or time_out is
+ *             reached.
+ * @note       If "timeout" value is M4OSA_WAIT_FOREVER, the calling thread
+ *             will block indefinitely until the semaphore  is unlocked.
+ * @param      context:(IN/OUT) Context of the semaphore
+ * @param      timeout:(IN) Time out in milliseconds
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4WAR_TIME_OUT: time out is elapsed before semaphore has been
+ *             available.
+ * @return     M4ERR_BAD_CONTEXT: provided context is not a valid one
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_semaphoreWait(M4OSA_Context context, M4OSA_Int32 timeout)
+{
+   M4OSA_SemaphoreContext* semaphoreContext = (M4OSA_SemaphoreContext*)context;
+   struct timespec         ts;
+   struct timespec         left;
+   int                     result;
+
+   M4OSA_TRACE1_2("M4OSA_semaphoreWait\t\tM4OSA_Context 0x%x\tM4OSA_UInt32 %d",
+                  context, timeout);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_semaphoreWait");
+
+   M4OSA_DEBUG_IF2(semaphoreContext->coreID != M4OSA_SEMAPHORE,
+                   M4ERR_BAD_CONTEXT, "M4OSA_semaphoreWait");
+
+   if ( (M4OSA_Int32)M4OSA_WAIT_FOREVER == timeout)
+   {
+       if ( 0 != sem_wait(&semaphoreContext->semaphore) )
+       {
+           M4OSA_DEBUG(M4ERR_BAD_CONTEXT,
+                  "M4OSA_semaphoreWait: OS semaphore wait failed");
+
+           return M4ERR_BAD_CONTEXT ;
+       }
+   }
+   else
+   {
+       result = sem_trywait(&semaphoreContext->semaphore);
+       while ( ((EBUSY == result) || (EAGAIN == result)) && ( 0 < timeout ) )
+       {
+           ts.tv_sec  = 0;
+           if (1 <= timeout)
+           {
+               ts.tv_nsec = 1000000;
+               timeout -= 1;
+           }
+           else
+           {
+               ts.tv_nsec = timeout * 1000000;
+               timeout = 0;
+           }
+           nanosleep(&ts, &left);
+           result = sem_trywait(&semaphoreContext->semaphore);
+       }
+       if (0 != result)
+       {
+           if ((EBUSY == result) || (EAGAIN == result))
+           {
+               return M4WAR_TIME_OUT;
+           }
+           else
+           {
+               M4OSA_DEBUG(M4ERR_BAD_CONTEXT, "M4OSA_semaphoreWait: OS semaphore wait failed");
+               return M4ERR_BAD_CONTEXT;
+           }
+       }
+   }
+
+   return M4NO_ERROR;
+}
+
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method increments the semaphore counter. The semaphore is
+ *             identified by its context
+ * @note       If the semaphore counter is upper than zero (after addition),
+ *             the M4OSA_semaphoreWait call of the thread with the highest
+ *             priority is unblocked and made ready to run.
+ * @note       No hypotheses can be made on which thread will be unblocked
+ *             between threads with the same priority.
+ * @param      context:(IN/OUT) Context of the semaphore
+ * @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_semaphorePost(M4OSA_Context context)
+{
+   M4OSA_SemaphoreContext* semaphoreContext = (M4OSA_SemaphoreContext*)context;
+
+   M4OSA_TRACE1_1("M4OSA_semaphorePost\t\tM4OSA_Context 0x%x", context);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_semaphorePost");
+
+   M4OSA_DEBUG_IF2(semaphoreContext->coreID != M4OSA_SEMAPHORE,
+                   M4ERR_BAD_CONTEXT, "M4OSA_semaphorePost");
+
+   sem_post(&semaphoreContext->semaphore);
+
+   return M4NO_ERROR;
+}
+
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method deletes a semaphore (identify by its context).
+ *             After this call the semaphore and its context is no more
+ *             useable. This function frees all the memory related to this
+ *             semaphore.
+ * @note       It is an application issue to warrant no more threads are locked
+ *             on the deleted semaphore.
+ * @param      context:(IN/OUT) Context of the semaphore
+ * @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_semaphoreClose(M4OSA_Context context)
+{
+   M4OSA_SemaphoreContext* semaphoreContext = (M4OSA_SemaphoreContext*)context;
+
+   M4OSA_TRACE1_1("M4OSA_semaphoreClose\t\tM4OSA_Context 0x%x", context);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_semaphoreClose");
+
+   M4OSA_DEBUG_IF2(semaphoreContext->coreID != M4OSA_SEMAPHORE,
+                   M4ERR_BAD_CONTEXT, "M4OSA_semaphoreClose");
+
+   sem_destroy(&semaphoreContext->semaphore);
+
+   M4OSA_free((M4OSA_MemAddr32)semaphoreContext);
+
+   return M4NO_ERROR;
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_String.c b/libvideoeditor/osal/src/M4OSA_String.c
new file mode 100755
index 0000000..af98b4b
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_String.c
@@ -0,0 +1,2417 @@
+/*
+ * 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_String.c
+ ************************************************************************
+*/
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_Memory.h"
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_CharStar.h"
+#include "M4OSA_FileCommon.h"
+#include "M4OSA_String_priv.h"
+#include "M4OSA_String.h"
+
+
+/**
+ ************************************************************************
+ * @brief      This function creates an empty M4OSA_String
+ * @note
+ * @param      pStrOut
+ * @return     M4OSA_ERROR
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_strCreate(M4OSA_String* pStrOut)
+{
+    M4OSA_strStruct* pStr = M4OSA_NULL;
+
+    M4OSA_TRACE1_1("M4OSA_strCreate\t\tM4OSA_String* 0x%x", pStrOut);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStrOut, M4ERR_PARAMETER, "M4OSA_strCreate");
+    M4OSA_DEBUG_IF2(M4OSA_NULL != *pStrOut, M4ERR_STR_BAD_STRING,
+                                                             "M4OSA_strCreate");
+
+    /* Allocate the output M4OSA_String */
+    pStr = (M4OSA_strStruct*)M4OSA_malloc(sizeof(M4OSA_strStruct), M4OSA_STRING,
+        (M4OSA_Char*)"M4OSA_strPrivCreate: output string");
+
+    /* Check memory allocation error */
+    if(M4OSA_NULL == pStr)
+    {
+        *pStrOut = M4OSA_NULL ;
+
+        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivCreate");
+
+        return M4ERR_ALLOC;
+    }
+
+    pStr->coreID = M4OSA_STRING;
+    pStr->pui8_buffer = M4OSA_NULL;
+    pStr->ui32_length = 0;
+    pStr->ui32_size = 0;
+
+    *pStrOut = pStr;
+
+    return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This function reset the M4OSA_String
+ * @note
+ * @param      str_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strReset(M4OSA_String str_in)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_Char* pBuffer;
+
+    M4OSA_TRACE1_1("M4OSA_strReset\t\tM4OSA_String* 0x%x", str_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strReset");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                              "M4OSA_strReset");
+
+    pBuffer = pStr->pui8_buffer;
+
+    if(M4OSA_NULL != pBuffer)
+    {
+        M4OSA_free((M4OSA_MemAddr32)pBuffer);
+
+        pStr->pui8_buffer = M4OSA_NULL;
+    }
+
+    pStr->ui32_length = 0;
+    pStr->ui32_size = 0;
+
+
+    return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This function free the memory of the input M4OSA_String
+ * @note
+ * @param      str_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strDestroy(M4OSA_String str_in)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+
+    M4OSA_TRACE1_1("M4OSA_strDestroy\t\tM4OSA_String 0x%x", str_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strDestroy");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                            "M4OSA_strDestroy");
+
+
+    /* Free M4OSA_String buffer */
+    M4OSA_free((M4OSA_MemAddr32)(pStr->pui8_buffer));
+
+    /* Free M4OSA_String structure memory */
+    M4OSA_free((M4OSA_MemAddr32)pStr);
+
+
+    return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief     str_in content
+ * @note
+ * @param      str_in
+ * @param      pChar
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strSetCharContent(M4OSA_String str_in, M4OSA_Char *pChar)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+
+    M4OSA_TRACE1_2("M4OSA_strSetContent\t\tM4OSA_String 0x%x\tM4OSA_Char*"
+        " 0x%x", str_in, pChar);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetContent");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pChar, M4ERR_PARAMETER,
+                                                         "M4OSA_strSetContent");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                         "M4OSA_strSetContent");
+
+    return M4OSA_strPrivSet(pStr, pChar, M4OSA_chrLength(pChar));
+}
+
+
+
+
+/**
+ ************************************************************************
+* @brief      This function returns, in pac_content, the "C-String" of str_in
+ * @note
+ * @param      str_in
+ * @param      pac_content
+ * @return     M4OSA_ERROR
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_strGetCharContent(M4OSA_String str_in, M4OSA_Char** ppchar)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+
+    M4OSA_TRACE1_2("M4OSA_strGetContent\t\tM4OSA_String 0x%x\tM4OSA_Char**"
+        " 0x%x", str_in, ppchar);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetContent");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == ppchar, M4ERR_PARAMETER,
+                                                         "M4OSA_strGetContent");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                         "M4OSA_strGetContent");
+
+    *ppchar = pStr->pui8_buffer;
+
+
+    return M4NO_ERROR;
+}
+
+M4OSA_ERR M4OSA_strSetChar(M4OSA_String str_in, M4OSA_Char c_in)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err;
+
+    M4OSA_TRACE1_2("M4OSA_strSetChar\t\tM4OSA_String 0x%x\tM4OSA_Char %c",
+        str_in, c_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetChar");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                            "M4OSA_strSetChar");
+
+
+    err = M4OSA_strPrivRealloc(pStr, 1);
+
+    if(M4OSA_ERR_IS_ERROR(err))
+    {
+        return err;
+    }
+
+    pStr->pui8_buffer[0] = c_in;
+    pStr->pui8_buffer[1] = '\0';
+    pStr->ui32_length    = 1;
+
+
+    return M4NO_ERROR;
+}
+
+
+
+
+M4OSA_ERR M4OSA_strGetChar(M4OSA_String str_in, M4OSA_Char* pc_out)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+
+    M4OSA_TRACE1_2("M4OSA_strGetChar\t\tM4OSA_String 0x%x\tM4OSA_Char* 0x%x",
+        str_in, pc_out);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pc_out, M4ERR_PARAMETER, "M4OSA_strGetChar");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetChar");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                            "M4OSA_strGetChar");
+
+    if(pStr->ui32_length == 0)
+    {
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    *pc_out = pStr->pui8_buffer[0];
+
+
+    return M4NO_ERROR;
+}
+
+M4OSA_ERR M4OSA_strSetInt8(M4OSA_String str_in, M4OSA_Int8 i8_in,
+                           M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[8];
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_2("M4OSA_strSetInt8\t\tM4OSA_String 0x%x\tM4OSA_Int8 %d",
+        str_in, i8_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetInt8");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                            "M4OSA_strSetInt8");
+
+
+    /* Convert input number into "C-String" */
+    switch(base)
+    {
+    case M4OSA_kstrDec:
+        {
+            err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"%d", i8_in);
+            break;
+        }
+
+    case M4OSA_kstrHexa:
+        {
+            if(i8_in < 0)
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"-%X",
+                                                                        -i8_in);
+            }
+            else
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"%X",
+                                                                         i8_in);
+            }
+            break;
+        }
+
+    case M4OSA_kstrOct:
+        {
+            if(i8_in < 0)
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"-%o",
+                                                                        -i8_in);
+            }
+            else
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"%o",
+                                                                         i8_in);
+            }
+            break;
+        }
+
+    default:
+        {
+            return M4ERR_PARAMETER;
+        }
+    }
+
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+M4OSA_ERR M4OSA_strGetInt8(M4OSA_String str_in, M4OSA_Int8* pi8_out,
+                           M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetInt8\t\tM4OSA_String 0x%x\tM4OSA_Int8* 0x%x\t"
+        "M4OSA_strNumBase %d", str_in, pi8_out, base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetInt8");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pi8_out, M4ERR_PARAMETER, "M4OSA_strGetInt8");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa) &&
+        (base != M4OSA_kstrOct), M4ERR_PARAMETER, "M4OSA_strGetInt8");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID,M4ERR_STR_BAD_STRING,
+                                                            "M4OSA_strGetInt8");
+
+
+    err_code = M4OSA_chrGetInt8(pStr->pui8_buffer, pi8_out, M4OSA_NULL, base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetInt8");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+
+    return M4NO_ERROR;
+}
+
+
+
+M4OSA_ERR M4OSA_strSetUInt8(M4OSA_String str_in, M4OSA_UInt8 ui8_in,
+                            M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[4];
+    M4OSA_ERR err_code;
+    M4OSA_Char* pFormat;
+
+    M4OSA_TRACE1_2("M4OSA_strSetUInt8\t\tM4OSA_String* 0x%x\tM4OSA_UInt8 %d",
+        str_in, ui8_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER,  "M4OSA_strSetUInt8");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strSetUInt8");
+
+    if (base == M4OSA_kchrDec)
+    {
+        pFormat = (M4OSA_Char*)"%u";
+    }
+    else if (base == M4OSA_kchrHexa)
+    {
+        pFormat = (M4OSA_Char*)"%X";
+    }
+    else if (base == M4OSA_kchrOct)
+    {
+        pFormat = (M4OSA_Char*)"%o";
+    }
+    else
+    {
+        pFormat = M4OSA_NULL;
+    }
+
+    /* Convert input number into "C-String" */
+    err_code = M4OSA_chrSPrintf(aui8_buffer, 4, pFormat, ui8_in);
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+
+
+M4OSA_ERR M4OSA_strGetUInt8(M4OSA_String str_in,
+                            M4OSA_UInt8* pui8_out,
+                            M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetUInt8\t\tM4OSA_String 0x%x\tM4OSA_UInt8* 0x%x\t"
+        "M4OSA_strNumBase %d", str_in, pui8_out,  base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetUInt8");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui8_out, M4ERR_PARAMETER,
+                                                           "M4OSA_strGetUInt8");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa)
+        && (base != M4OSA_kstrOct), M4ERR_PARAMETER, "M4OSA_strGetUInt8");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strGetUInt8");
+
+
+    err_code = M4OSA_chrGetUInt8(pStr->pui8_buffer, pui8_out, M4OSA_NULL, base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetUInt8");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+
+M4OSA_ERR M4OSA_strSetInt16(M4OSA_String str_in, M4OSA_Int16 i16_in,
+                            M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[8];
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_2("M4OSA_strSetInt16\t\tM4OSA_String* 0x%x\tM4OSA_Int16 %d",
+        str_in, i16_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetInt16");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strSetInt16");
+
+    /* Convert input number into "C-String" */
+    switch(base)
+    {
+    case M4OSA_kstrDec:
+        {
+            err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"%d",
+                                                                        i16_in);
+            break;
+        }
+
+    case M4OSA_kstrHexa:
+        {
+            if(i16_in < 0)
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"-%X",
+                                                                       -i16_in);
+            }
+            else
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"%X",
+                                                                        i16_in);
+            }
+            break;
+        }
+
+    case M4OSA_kstrOct:
+        {
+            if(i16_in < 0)
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"-%o",
+                                                                       -i16_in);
+            }
+            else
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 8, (M4OSA_Char*)"%o",
+                                                                        i16_in);
+            }
+            break;
+        }
+
+    default:
+        {
+            return M4ERR_PARAMETER;
+        }
+    }
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+
+
+M4OSA_ERR M4OSA_strGetInt16(M4OSA_String str_in, M4OSA_Int16* pi16_out,
+                            M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetInt16\t\tM4OSA_String 0x%x\tM4OSA_Int16* 0x%x"
+        "\tM4OSA_strNumBase %d", str_in, pi16_out, base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetInt16");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pi16_out, M4ERR_PARAMETER,
+                                                           "M4OSA_strGetInt16");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa)
+            && (base != M4OSA_kstrOct),M4ERR_PARAMETER, "M4OSA_strGetInt16");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strGetInt16");
+
+    err_code = M4OSA_chrGetInt16(pStr->pui8_buffer, pi16_out, M4OSA_NULL, base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetInt16");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetUInt16(M4OSA_String str_in, M4OSA_UInt16 ui16_in,
+                             M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[8];
+    M4OSA_ERR err_code;
+    M4OSA_Char* pFormat;
+
+    M4OSA_TRACE1_2("M4OSA_strSetUInt16\t\tM4OSA_String* 0x%x\tM4OSA_UInt16 %d",
+        str_in, ui16_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetUInt16");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                         "M4OSA_strSetUInt16");
+
+    if (M4OSA_kchrDec == base)
+    {
+        pFormat = (M4OSA_Char*)"%u";
+    }
+    else if (M4OSA_kchrHexa == base)
+    {
+        pFormat = (M4OSA_Char*)"%X";
+    }
+    else if (M4OSA_kchrOct == base)
+    {
+        pFormat = (M4OSA_Char*)"%o";
+    }
+    else
+    {
+        pFormat = M4OSA_NULL;
+    }
+
+    /* Convert input number into "C-String" */
+    err_code = M4OSA_chrSPrintf(aui8_buffer, 8, pFormat, ui16_in);
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+
+M4OSA_ERR M4OSA_strGetUInt16(M4OSA_String str_in, M4OSA_UInt16* pui16_out,
+                             M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetUInt16\t\tM4OSA_String 0x%x\tM4OSA_UInt16* "
+        "0x%x\tM4OSA_strNumBase %d", str_in, pui16_out, base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetUInt16");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui16_out, M4ERR_PARAMETER,
+                                                          "M4OSA_strGetUInt16");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa)
+            && (base != M4OSA_kstrOct), M4ERR_PARAMETER, "M4OSA_strGetUInt16");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                          "M4OSA_strGetUInt16");
+
+    err_code = M4OSA_chrGetUInt16(pStr->pui8_buffer, pui16_out, M4OSA_NULL,
+                                                                          base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetUInt16");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetInt32(M4OSA_String str_in, M4OSA_Int32 i32_in,
+                            M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[16];
+    M4OSA_ERR err_code;
+    M4OSA_Char* pFormat;
+
+    M4OSA_TRACE1_2("M4OSA_strSetInt32\t\tM4OSA_String* 0x%x\tM4OSA_Int32 %d",
+        str_in, i32_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetInt32");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strSetInt32");
+
+    if (M4OSA_kchrDec == base)
+    {
+        pFormat = (M4OSA_Char*)"%d";
+    }
+    else if (M4OSA_kchrHexa == base)
+    {
+        pFormat = (M4OSA_Char*)"%X";
+    }
+    else if (M4OSA_kchrOct == base)
+    {
+        pFormat = (M4OSA_Char*)"%o";
+    }
+    else
+    {
+        pFormat = M4OSA_NULL;
+    }
+
+    /* Convert input number into "C-String" */
+    switch(base)
+    {
+    case M4OSA_kstrDec:
+        {
+            err_code = M4OSA_chrSPrintf(aui8_buffer, 16, (M4OSA_Char*)"%d",
+                                                                        i32_in);
+            break;
+        }
+
+    case M4OSA_kstrHexa:
+        {
+            if(i32_in < 0)
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 16, (M4OSA_Char*)"-%X",
+                                                                       -i32_in);
+            }
+            else
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 16, (M4OSA_Char*)"%X",
+                                                                        i32_in);
+            }
+            break;
+        }
+
+    case M4OSA_kstrOct:
+        {
+            if(i32_in < 0)
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 16, (M4OSA_Char*)"-%o",
+                                                                       -i32_in);
+            }
+            else
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 16, (M4OSA_Char*)"%o",
+                                                                        i32_in);
+            }
+            break;
+        }
+
+    default:
+        {
+            return M4ERR_PARAMETER;
+        }
+    }
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+M4OSA_ERR M4OSA_strGetInt32(M4OSA_String str_in,
+                            M4OSA_Int32* pi32_out,
+                            M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetInt32\t\tM4OSA_String 0x%x\tM4OSA_Int32* 0x%x"
+        "\tM4OSA_strNumBase %d", str_in, pi32_out, base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetInt32");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pi32_out, M4ERR_PARAMETER,
+                                                           "M4OSA_strGetInt32");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa)
+        && (base != M4OSA_kstrOct), M4ERR_PARAMETER, "M4OSA_strGetInt32");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strGetInt32");
+
+    err_code = M4OSA_chrGetInt32(pStr->pui8_buffer, pi32_out, M4OSA_NULL, base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetInt32");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+M4OSA_ERR M4OSA_strSetUInt32(M4OSA_String str_in, M4OSA_UInt32 ui32_in,
+                             M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[12];
+    M4OSA_ERR err_code;
+    M4OSA_Char* pFormat;
+
+    M4OSA_TRACE1_2("M4OSA_strSetUInt32\t\tM4OSA_String* 0x%x\tM4OSA_UInt32 %d",
+        str_in, ui32_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetUInt32");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                          "M4OSA_strSetUInt32");
+
+    if (M4OSA_kchrDec == base)
+    {
+        pFormat = (M4OSA_Char*)"%u";
+    }
+    else if (M4OSA_kchrHexa == base)
+    {
+        pFormat = (M4OSA_Char*)"%X";
+    }
+    else if (M4OSA_kchrOct == base)
+    {
+        pFormat = (M4OSA_Char*)"%o";
+    }
+    else
+    {
+        pFormat = M4OSA_NULL;
+    }
+
+    /* Convert input number into "C-String" */
+    err_code = M4OSA_chrSPrintf(aui8_buffer, 12, pFormat, ui32_in);
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+
+M4OSA_ERR M4OSA_strGetUInt32(M4OSA_String str_in, M4OSA_UInt32* pui32_out,
+                             M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetUInt32\t\tM4OSA_String 0x%x\tM4OSA_UInt32* "
+        "0x%x\tM4OSA_strNumBase %d", str_in, pui32_out, base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetUInt32");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_out, M4ERR_PARAMETER,
+                                                          "M4OSA_strGetUInt32");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa)
+        && (base != M4OSA_kstrOct), M4ERR_PARAMETER, "M4OSA_strGetUInt32");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                          "M4OSA_strGetUInt32");
+
+    err_code = M4OSA_chrGetUInt32(pStr->pui8_buffer, pui32_out,
+                    M4OSA_NULL, base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetUInt32");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetInt64(M4OSA_String str_in, M4OSA_Int64 i64_in,
+                            M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[24];
+    M4OSA_ERR err_code;
+
+
+    M4OSA_TRACE1_2("M4OSA_strSetInt64\t\tM4OSA_String* 0x%x\tM4OSA_Int64 0x%x",
+        str_in, &i64_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetInt64");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strSetInt64");
+
+    /* Convert input number into "C-String" */
+    switch(base)
+    {
+    case M4OSA_kstrDec:
+        {
+            err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%lld",
+                                                                        i64_in);
+            break;
+        }
+
+    case M4OSA_kstrHexa:
+        {
+            if(M4OSA_INT64_IS_POSITIVE(i64_in))
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%llX",
+                                                                        i64_in);
+            }
+            else
+            {
+                M4OSA_INT64_NEG(i64_in, i64_in);
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"-%llX",
+                                                                        i64_in);
+            }
+            break;
+        }
+
+    case M4OSA_kstrOct:
+        {
+            if(M4OSA_INT64_IS_POSITIVE(i64_in))
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%llo",
+                                                                        i64_in);
+            }
+            else
+            {
+                M4OSA_INT64_NEG(i64_in, i64_in);
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"-%llo",
+                                                                        i64_in);
+            }
+            break;
+        }
+
+    default:
+        {
+            return M4ERR_PARAMETER;
+        }
+    }
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+M4OSA_ERR M4OSA_strGetInt64(M4OSA_String str_in, M4OSA_Int64* pi64_out,
+                            M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetInt64\t\tM4OSA_String 0x%x\tM4OSA_Int64* 0x%x"
+        "\tM4OSA_strNumBase %d", str_in, pi64_out, base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetInt64");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pi64_out, M4ERR_PARAMETER,
+                                                           "M4OSA_strGetInt64");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa)
+        && (base != M4OSA_kstrOct), M4ERR_PARAMETER, "M4OSA_strGetInt64");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strGetInt64");
+
+    err_code = M4OSA_chrGetInt64(pStr->pui8_buffer, pi64_out, M4OSA_NULL, base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetInt64");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetDouble(M4OSA_String str_in, M4OSA_Double d_in)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[24];
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_2("M4OSA_strSetDouble\t\tM4OSA_String* 0x%x\tM4OSA_Double* "
+        "0x%x", str_in, &d_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetDouble");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                          "M4OSA_strSetDouble");
+
+    /* Convert input number into "C-String" */
+    err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%e", d_in);
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+
+M4OSA_ERR M4OSA_strGetDouble(M4OSA_String str_in, M4OSA_Double* pd_out)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_2("M4OSA_strGetDouble\t\tM4OSA_String 0x%x\tM4OSA_Double* "
+        "0x%x", str_in, pd_out);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetDouble");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pd_out, M4ERR_PARAMETER, "M4OSA_strGetDouble");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                          "M4OSA_strGetDouble");
+
+    err_code = M4OSA_chrGetDouble(pStr->pui8_buffer, pd_out, M4OSA_NULL);
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetDouble");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetFilePosition(M4OSA_String str_in, M4OSA_FilePosition fpos_in,
+                                   M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[24];
+    M4OSA_ERR err_code;
+
+
+    M4OSA_TRACE1_2("M4OSA_strSetFilePosition\t\tM4OSA_String* 0x%x\t"
+        "M4OSA_FilePosition* 0x%x", str_in, &fpos_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER,
+                                                    "M4OSA_strSetFilePosition");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                    "M4OSA_strSetFilePosition");
+
+
+    /* Convert input number into "C-String" */
+    switch(base)
+    {
+    case M4OSA_kstrDec:
+        {
+            err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%aad",
+                                                                       fpos_in);
+            break;
+        }
+
+    case M4OSA_kstrHexa:
+        {
+            if(M4OSA_FPOS_IS_POSITIVE(fpos_in))
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%aaX",
+                                                                       fpos_in);
+            }
+            else
+            {
+                M4OSA_FPOS_NEG(fpos_in, fpos_in);
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"-%aaX",
+                                                                       fpos_in);
+            }
+            break;
+        }
+
+    case M4OSA_kstrOct:
+        {
+            if(M4OSA_FPOS_IS_POSITIVE(fpos_in))
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%aao",
+                                                                       fpos_in);
+            }
+            else
+            {
+                M4OSA_FPOS_NEG(fpos_in, fpos_in);
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"-%aao",
+                                                                       fpos_in);
+            }
+            break;
+        }
+
+    default:
+        {
+            return M4ERR_PARAMETER;
+        }
+    }
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+M4OSA_ERR M4OSA_strGetFilePosition(M4OSA_String str_in, M4OSA_FilePosition* pfpos_out,
+                                   M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetFilePosition\t\tM4OSA_String 0x%x\t"
+        "M4OSA_FilePosition* 0x%x\t\tM4OSA_strNumBase %d",
+        str_in, pfpos_out, base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER,
+                                                    "M4OSA_strGetFilePosition");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pfpos_out, M4ERR_PARAMETER,
+                                                    "M4OSA_strGetFilePosition");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa)
+        && (base != M4OSA_kstrOct), M4ERR_PARAMETER, "M4OSA_strGetFilePosition");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                    "M4OSA_strGetFilePosition");
+
+    err_code = M4OSA_chrGetFilePosition(pStr->pui8_buffer, pfpos_out,
+                        M4OSA_NULL, base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetFilePosition");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetTime(M4OSA_String str_in, M4OSA_Time t_in,
+                           M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char aui8_buffer[24];
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_2("M4OSA_strSetDouble\t\tM4OSA_String* 0x%x\tM4OSA_Time* 0x%x",
+        str_in, &t_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetTime");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                            "M4OSA_strSetTime");
+
+    /* Convert input number into "C-String" */
+    switch(base)
+    {
+    case M4OSA_kstrDec:
+        {
+            err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%tmd",
+                                                                          t_in);
+            break;
+        }
+
+    case M4OSA_kstrHexa:
+        {
+            if(M4OSA_TIME_IS_POSITIVE(t_in))
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%tmX",
+                                                                          t_in);
+            }
+            else
+            {
+                M4OSA_TIME_NEG(t_in, t_in);
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"-%tmX",
+                                                                          t_in);
+            }
+            break;
+        }
+
+    case M4OSA_kstrOct:
+        {
+            if(M4OSA_TIME_IS_POSITIVE(t_in))
+            {
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"%tmo",
+                                                                          t_in);
+            }
+            else
+            {
+                M4OSA_TIME_NEG(t_in, t_in);
+                err_code = M4OSA_chrSPrintf(aui8_buffer, 24, (M4OSA_Char*)"-%tmo",
+                                                                          t_in);
+            }
+            break;
+        }
+
+    default:
+        {
+            return M4ERR_PARAMETER;
+        }
+    }
+
+    if(M4OSA_ERR_IS_ERROR(err_code))
+    {
+        return err_code;
+    }
+
+    /* Calculate M4OSA_String content length */
+    ui32_length = M4OSA_chrLength(aui8_buffer) ;
+
+    return M4OSA_strPrivSet(pStr, aui8_buffer, ui32_length);
+}
+
+
+M4OSA_ERR M4OSA_strGetTime(M4OSA_String str_in, M4OSA_Time* pt_out,
+                           M4OSA_strNumBase base)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetTime\t\tM4OSA_String 0x%x\tM4OSA_Time* 0x%x"
+        "\tM4OSA_strNumBase %d", str_in, pt_out, base);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetTime");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pt_out, M4ERR_PARAMETER, "M4OSA_strGetTime");
+    M4OSA_DEBUG_IF2((base != M4OSA_kstrDec) && (base != M4OSA_kstrHexa)
+        && (base != M4OSA_kstrOct), M4ERR_PARAMETER, "M4OSA_strGetTime");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID,M4ERR_STR_BAD_STRING,
+                                                            "M4OSA_strGetTime");
+
+    err_code = M4OSA_chrGetTime(pStr->pui8_buffer, pt_out, M4OSA_NULL, base);
+
+    if(M4NO_ERROR != err_code)
+    {
+        M4OSA_DEBUG(M4ERR_STR_CONV_FAILED, "M4OSA_strGetTime");
+
+        return M4ERR_STR_CONV_FAILED;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strGetLength(M4OSA_String str_in, M4OSA_UInt32* pui32_len)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+
+    M4OSA_TRACE1_2("M4OSA_strGetLength\t\tM4OSA_String 0x%x\tM4OSA_UInt32* "
+        "0x%x", str_in, pui32_len);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strGetLength");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_len, M4ERR_PARAMETER, "M4OSA_strGetLength");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING, "M4OSA_strGetLength");
+
+    /* Get the M4OSA_StringStuct length field */
+    *pui32_len = pStr->ui32_length ;
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strCompare(M4OSA_String str_in1, M4OSA_String str_in2,
+                           M4OSA_Int32* pi32_result)
+{
+    M4OSA_strStruct* pStr1 = (M4OSA_strStruct*)str_in1;
+    M4OSA_strStruct* pStr2 = (M4OSA_strStruct*)str_in2;
+    M4OSA_UInt32 length, length1, length2;
+    M4OSA_Int32 result;
+    M4OSA_UInt32 i;
+    M4OSA_Char* buffer1;
+    M4OSA_Char* buffer2;
+    M4OSA_Char* pTmp1;
+    M4OSA_Char* pTmp2;
+
+    M4OSA_TRACE1_3("M4OSA_strCompare\t\tM4OSA_String 0x%x\tM4OSA_String 0x%x\t"
+        "M4OSA_UInt32* 0x%x", str_in1, str_in2, pi32_result);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr1, M4ERR_PARAMETER, "M4OSA_strCompare");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr2, M4ERR_PARAMETER, "M4OSA_strCompare");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pi32_result, M4ERR_PARAMETER, "M4OSA_strCompare");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr1->coreID, M4ERR_STR_BAD_STRING, "M4OSA_strCompare");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr2->coreID, M4ERR_STR_BAD_STRING, "M4OSA_strCompare");
+
+    buffer1 = pStr1->pui8_buffer;
+    buffer2 = pStr2->pui8_buffer;
+
+    length1 = pStr1->ui32_length;
+    length2 = pStr2->ui32_length;
+
+    length = (length1 < length2) ? length1 : length2;
+
+    pTmp1 = (M4OSA_Char*)M4OSA_malloc(2 * length * sizeof(M4OSA_Char),
+                M4OSA_STRING, (M4OSA_Char*)"M4OSA_strCompare");
+
+    M4OSA_CHECK_MALLOC(pTmp1, "M4OSA_strCompare");
+
+    pTmp2 = pTmp1 + length;
+
+    M4OSA_memcpy(pTmp1, buffer1, length);
+
+    M4OSA_memcpy(pTmp2, buffer2, length);
+
+    for(i=0; i<length; i++)
+    {
+        pTmp1[i] = M4OSA_chrToLower(buffer1[i]);
+        pTmp2[i] = M4OSA_chrToLower(buffer2[i]);
+    }
+
+    M4OSA_chrNCompare(pTmp1, pTmp2, length, &result);
+
+    M4OSA_free((M4OSA_MemAddr32)pTmp1);
+
+    if(result != 0)
+    {
+        *pi32_result = result;
+    }
+    else
+    {
+        if (length1 == length2)
+        {
+            *pi32_result = 0;
+        }
+        else if (length1  > length2)
+        {
+            *pi32_result = 1;
+        }
+        else
+        {
+            *pi32_result = -1;
+        }
+    }
+
+    return M4NO_ERROR;
+}
+
+M4OSA_ERR M4OSA_strCompareSubStr(M4OSA_String str_in1,
+                                 M4OSA_UInt32 ui32_offset1,
+                                 M4OSA_String str_in2,
+                                 M4OSA_UInt32 ui32_offset2,
+                                 M4OSA_UInt32* pui32_num,
+                                 M4OSA_Int32* pi32_result)
+{
+    M4OSA_strStruct* pStr1 = (M4OSA_strStruct*)str_in1;
+    M4OSA_strStruct* pStr2 = (M4OSA_strStruct*)str_in2;
+    M4OSA_Char* pBuffer1;
+    M4OSA_Char* pBuffer2;
+    M4OSA_Char* pTmp1;
+    M4OSA_Char* pTmp2;
+    M4OSA_UInt32 length1, length2, i;
+    M4OSA_ERR err_code, return_code = M4NO_ERROR;
+
+    M4OSA_TRACE1_5("M4OSA_strCompareSubStr\t\tM4OSA_String 0x%x\tM4OSA_UInt32 "
+        "%d\tM4OSA_String 0x%x\tM4OSA_UInt32 %d\tM4OSA_UInt32* 0x%x"
+        "\tM4OSA_Int32* 0x%x", str_in1, ui32_offset1, str_in2,
+        ui32_offset2, *pui32_num);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr1, M4ERR_PARAMETER,
+                                                      "M4OSA_strCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr2, M4ERR_PARAMETER,
+                                                      "M4OSA_strCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pi32_result, M4ERR_PARAMETER,
+                                                      "M4OSA_strCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_num, M4ERR_PARAMETER,
+                                                      "M4OSA_strCompareSubStr");
+    M4OSA_DEBUG_IF2(*pui32_num == 0, M4ERR_PARAMETER, "M4OSA_strCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr1->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr2->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strCompareSubStr");
+    M4OSA_DEBUG_IF2(ui32_offset1 >= pStr1->ui32_length, M4ERR_STR_OVERFLOW,
+                                                      "M4OSA_strCompareSubStr");
+    M4OSA_DEBUG_IF2(ui32_offset2 >= pStr2->ui32_length, M4ERR_STR_OVERFLOW,
+                                                      "M4OSA_strCompareSubStr");
+
+    length1 = pStr1->ui32_length - ui32_offset1;
+    length2 = pStr2->ui32_length - ui32_offset2;
+
+    pBuffer1 = pStr1->pui8_buffer + ui32_offset1;
+    pBuffer2 = pStr2->pui8_buffer + ui32_offset2;
+
+    if(length1 < *pui32_num)
+    {
+        *pui32_num = length1;
+
+        return_code = M4WAR_STR_OVERFLOW;
+    }
+
+    if(length2 < *pui32_num)
+    {
+        *pui32_num = length2;
+
+        return_code = M4WAR_STR_OVERFLOW;
+    }
+
+    pTmp1 = (M4OSA_Char*)M4OSA_malloc(2 * (*pui32_num) * sizeof(M4OSA_Char),
+            M4OSA_STRING, (M4OSA_Char*)"M4OSA_strCompareSubStr");
+
+    M4OSA_CHECK_MALLOC(pTmp1, "M4OSA_strCompareSubStr");
+
+    pTmp2 = pTmp1 + (*pui32_num);
+
+    M4OSA_memcpy(pTmp1, pBuffer1, *pui32_num);
+
+    M4OSA_memcpy(pTmp2, pBuffer2, *pui32_num);
+
+    for(i=0; i<(*pui32_num); i++)
+    {
+        pTmp1[i] = M4OSA_chrToLower(pBuffer1[i]);
+        pTmp2[i] = M4OSA_chrToLower(pBuffer2[i]);
+    }
+
+    err_code = M4OSA_chrNCompare(pTmp1, pTmp2, *pui32_num, pi32_result);
+
+    M4OSA_DEBUG_IF2((M4OSA_ERR)M4ERR_PARAMETER == err_code, M4ERR_PARAMETER,
+                                   "M4OSA_strCompareSubStr: M4OSA_chrNCompare");
+
+    M4OSA_free((M4OSA_MemAddr32)pTmp1);
+
+    return return_code;
+}
+
+
+M4OSA_ERR M4OSA_strCaseCompare(M4OSA_String str_in1, M4OSA_String str_in2,
+                               M4OSA_Int32* pi32_result)
+{
+    M4OSA_strStruct* pStr1 = (M4OSA_strStruct*)str_in1;
+    M4OSA_strStruct* pStr2 = (M4OSA_strStruct*)str_in2;
+    M4OSA_UInt32 length, length1, length2;
+    M4OSA_Char *pBuffer1, *pBuffer2;
+    M4OSA_Int32 result;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strCaseCompare\t\tM4OSA_String 0x%x\tM4OSA_String "
+        "0x%x\tM4OSA_UInt32* 0x%x", str_in1, str_in2, pi32_result);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr1, M4ERR_PARAMETER, "M4OSA_strCaseCompare");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr2, M4ERR_PARAMETER, "M4OSA_strCaseCompare");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pi32_result,M4ERR_PARAMETER,
+                                                        "M4OSA_strCaseCompare");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr1->coreID, M4ERR_STR_BAD_STRING,
+                                                        "M4OSA_strCaseCompare");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr2->coreID, M4ERR_STR_BAD_STRING,
+                                                        "M4OSA_strCaseCompare");
+
+    length1 = pStr1->ui32_length;
+    length2 = pStr2->ui32_length;
+
+    /** NB:  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
+     */
+    if (M4OSA_NULL == pStr1->pui8_buffer)
+    {
+        pBuffer1 = (M4OSA_Char*)"";
+    }
+    else
+    {
+        pBuffer1 = pStr1->pui8_buffer;
+    }
+
+    if (M4OSA_NULL == pStr2->pui8_buffer)
+    {
+        pBuffer2 = (M4OSA_Char*)"";
+    }
+    else
+    {
+        pBuffer2 = pStr2->pui8_buffer;
+    }
+
+    if ((length1 < length2))
+    {
+        length = length1;
+    }
+    else
+    {
+        length =  length2;
+    }
+
+    err_code = M4OSA_chrNCompare(pBuffer1, pBuffer2, length, &result);
+
+    M4OSA_DEBUG_IF2((M4OSA_ERR)M4ERR_PARAMETER == err_code, M4ERR_PARAMETER,
+                                     "M4OSA_strCaseCompare: M4OSA_chrNCompare");
+
+    if (result != 0)
+    {
+        *pi32_result = result;
+    }
+    else if (length1 > length2)
+    {
+        *pi32_result = 1 ;
+    }
+    else
+    {
+        *pi32_result = -1;
+    }
+
+    return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @author     Nicolas Santini (PDSL-P)
+ * @author     Hilaire Verschuere (PDSL-P)
+ * @brief
+ * @note
+ * @param      str_in
+ * @param
+ * @return     M4OSA_ERROR
+ * @date       - 2002-12-32: creation
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strCaseCompareSubStr(M4OSA_String str_in1,
+                                     M4OSA_UInt32 ui32_offset1,
+                                     M4OSA_String str_in2,
+                                     M4OSA_UInt32 ui32_offset2,
+                                     M4OSA_UInt32* pui32_num,
+                                     M4OSA_Int32* pi32_result)
+{
+    M4OSA_strStruct* pStr1 = (M4OSA_strStruct*)str_in1;
+    M4OSA_strStruct* pStr2 = (M4OSA_strStruct*)str_in2;
+    M4OSA_Char* pBuffer1;
+    M4OSA_Char* pBuffer2;
+    M4OSA_UInt32 length1, length2;
+    M4OSA_ERR err_code = M4NO_ERROR;
+
+    M4OSA_TRACE1_5("M4OSA_strCaseCompareSubStr\t\tM4OSA_String 0x%x\t"
+        "M4OSA_UInt32 %d\tM4OSA_String 0x%x\tM4OSA_UInt32 %d\t"
+        "M4OSA_UInt32* 0x%x\tM4OSA_Int32* 0x%x", str_in1,
+        ui32_offset1, str_in2, ui32_offset2, *pui32_num);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr1, M4ERR_PARAMETER,
+                                                  "M4OSA_strCaseCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr2, M4ERR_PARAMETER,
+                                                  "M4OSA_strCaseCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pi32_result, M4ERR_PARAMETER,
+                                                  "M4OSA_strCaseCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_num, M4ERR_PARAMETER,
+                                                  "M4OSA_strCaseCompareSubStr");
+    M4OSA_DEBUG_IF2(*pui32_num == 0, M4ERR_PARAMETER,
+                                                  "M4OSA_strCaseCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr1->coreID, M4ERR_STR_BAD_STRING,
+                                                  "M4OSA_strCaseCompareSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr2->coreID, M4ERR_STR_BAD_STRING,
+                                                  "M4OSA_strCaseCompareSubStr");
+    M4OSA_DEBUG_IF2(ui32_offset1 >= pStr1->ui32_length, M4ERR_STR_OVERFLOW,
+                                                  "M4OSA_strCaseCompareSubStr");
+    M4OSA_DEBUG_IF2(ui32_offset2 >= pStr2->ui32_length, M4ERR_STR_OVERFLOW,
+                                                  "M4OSA_strCaseCompareSubStr");
+
+
+    length1 = pStr1->ui32_length - ui32_offset1;
+    length2 = pStr2->ui32_length - ui32_offset2;
+
+    pBuffer1 = pStr1->pui8_buffer + ui32_offset1;
+    pBuffer2 = pStr2->pui8_buffer + ui32_offset2;
+
+    if(length1 < *pui32_num)
+    {
+        *pui32_num = length1;
+
+        err_code = M4WAR_STR_OVERFLOW;
+    }
+
+    if(length2 < *pui32_num)
+    {
+        *pui32_num = length2;
+
+        err_code = M4WAR_STR_OVERFLOW;
+    }
+
+    M4OSA_chrNCompare(pBuffer1, pBuffer2, *pui32_num, pi32_result);
+
+    return err_code;
+}
+
+
+M4OSA_ERR M4OSA_strSpan(M4OSA_String str_in, M4OSA_Char* charset,
+                        M4OSA_UInt32* pui32_pos)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char* pBuffer;
+    M4OSA_ERR err_code;
+
+
+    M4OSA_TRACE1_3("M4OSA_strSpan\t\tM4OSA_String 0x%x\tM4OSA_Char* 0x%x\t"
+        "M4OSA_UInt32* 0x%x", str_in, charset, pui32_pos);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSpan");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == charset, M4ERR_PARAMETER, "M4OSA_strSpan");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_pos, M4ERR_PARAMETER, "M4OSA_strSpan");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                               "M4OSA_strSpan");
+
+    pStr = (M4OSA_strStruct*)str_in ;
+
+    if(*pui32_pos >= pStr->ui32_length)
+    {
+        return M4ERR_STR_OVERFLOW;
+    }
+
+    pBuffer = pStr->pui8_buffer + *pui32_pos;
+
+    err_code = M4OSA_chrSpan(pBuffer, charset, &ui32_length);
+
+    M4OSA_DEBUG_IF2((M4OSA_ERR)M4ERR_PARAMETER == err_code, M4ERR_PARAMETER,
+                                                "M4OSA_strSpan: M4OSA_chrSpan");
+
+    *pui32_pos += ui32_length;
+
+    return M4NO_ERROR;
+}
+
+
+
+
+
+M4OSA_ERR M4OSA_strSpanComplement(M4OSA_String str_in, M4OSA_Char* charset,
+                                  M4OSA_UInt32* pui32_pos)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code;
+    M4OSA_UInt32 ui32_length;
+
+    M4OSA_TRACE1_3("M4OSA_strSpanComplement\t\tM4OSA_String 0x%x\tM4OSA_Char* "
+        "0x%x\tM4OSA_UInt32* 0x%x", str_in, charset, pui32_pos);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER,
+                                                     "M4OSA_strSpanComplement");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == charset, M4ERR_PARAMETER,
+                                                     "M4OSA_strSpanComplement");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_pos, M4ERR_PARAMETER,
+                                                     "M4OSA_strSpanComplement");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                     "M4OSA_strSpanComplement");
+
+    if(*pui32_pos >= pStr->ui32_length)
+    {
+        return M4ERR_STR_OVERFLOW;
+    }
+
+    err_code = M4OSA_chrSpanComplement(pStr->pui8_buffer + *pui32_pos,
+                    charset, &ui32_length);
+
+    M4OSA_DEBUG_IF2((M4OSA_ERR)M4ERR_PARAMETER == err_code, M4ERR_PARAMETER,
+                "M4OSA_strSpanComplement: M4OSA_chrSpanComplement");
+
+    if(M4WAR_CHR_NOT_FOUND == err_code)
+    {
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    *pui32_pos += ui32_length;
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strFindFirstChar(M4OSA_String str_in, M4OSA_Char c,
+                                 M4OSA_UInt32* pui32_pos)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_Char* pBuffer;
+    M4OSA_Char* pchar;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strFindFirstChar\t\tM4OSA_String 0x%x\tM4OSA_Char"
+        " 0x%x\tM4OSA_UInt32* 0x%x", str_in, c, pui32_pos);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER,
+                                                      "M4OSA_strFindFirstChar");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_pos, M4ERR_PARAMETER,
+                                                      "M4OSA_strFindFirstChar");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strFindFirstChar");
+
+    if(*pui32_pos >= pStr->ui32_length)
+    {
+        return M4ERR_STR_OVERFLOW;
+    }
+
+    pBuffer = pStr->pui8_buffer + *pui32_pos;
+
+    err_code = M4OSA_chrFindChar(pBuffer, c, &pchar);
+
+    M4OSA_DEBUG_IF2(err_code == (M4OSA_ERR)M4ERR_PARAMETER,
+        M4ERR_PARAMETER, "M4OSA_strFindFirstChar");
+
+    if(M4WAR_CHR_NOT_FOUND == err_code)
+    {
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    *pui32_pos = pchar - pStr->pui8_buffer;
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strFindLastChar(M4OSA_String str_in, M4OSA_Char c,
+                                M4OSA_UInt32* pui32_pos)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_Char* pBuffer;
+    M4OSA_UInt32 i;
+
+    M4OSA_TRACE1_3("M4OSA_strFindLastChar\t\tM4OSA_String 0x%x\tM4OSA_Char"
+        " 0x%x\tM4OSA_UInt32* 0x%x", str_in, c, pui32_pos);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER,"M4OSA_strFindLastChar");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_pos, M4ERR_PARAMETER,
+                                                       "M4OSA_strFindLastChar");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strFindLastChar");
+
+    if(*pui32_pos > pStr->ui32_length)
+    {
+        return M4ERR_STR_OVERFLOW;
+    }
+
+    pBuffer = pStr->pui8_buffer;
+
+    for(i=(*pui32_pos); i!=0; i--)
+    {
+        if(pBuffer[i] == c)
+        {
+            *pui32_pos = i;
+
+            return M4NO_ERROR;
+        }
+    }
+
+    return M4WAR_STR_NOT_FOUND;
+}
+
+
+M4OSA_ERR M4OSA_strFindFirstSubStr(M4OSA_String str_in1, M4OSA_String str_in2,
+                                   M4OSA_UInt32* pui32_pos)
+{
+    M4OSA_strStruct* pStr1 = (M4OSA_strStruct*)str_in1;
+    M4OSA_strStruct* pStr2 = (M4OSA_strStruct*)str_in2;
+    M4OSA_Char* pResult;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strFindFirstSubStr\t\tM4OSA_String 0x%x\tM4OSA_String"
+        " 0x%x\tM4OSA_UInt32* 0x%x", str_in1, str_in2, pui32_pos);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr1, M4ERR_PARAMETER,
+                                                    "M4OSA_strFindFirstSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr2, M4ERR_PARAMETER,
+                                                    "M4OSA_strFindFirstSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_pos, M4ERR_PARAMETER,
+                                                    "M4OSA_strFindFirstSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr1->coreID, M4ERR_STR_BAD_STRING,
+                                                    "M4OSA_strFindFirstSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr2->coreID, M4ERR_STR_BAD_STRING,
+                                                    "M4OSA_strFindFirstSubStr");
+
+    if(*pui32_pos >= pStr1->ui32_length)
+    {
+        return M4ERR_STR_OVERFLOW;
+    }
+
+    if(pStr2->ui32_length == 0)
+    {
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    err_code = M4OSA_chrFindPattern(pStr1->pui8_buffer + (*pui32_pos),
+                pStr2->pui8_buffer, &pResult);
+
+    M4OSA_DEBUG_IF2((M4OSA_ERR)M4ERR_PARAMETER == err_code, M4ERR_PARAMETER,
+                              "M4OSA_strFindFirstSubStr: M4OSA_chrFindPattern");
+
+    if(M4WAR_CHR_NOT_FOUND == err_code)
+    {
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    *pui32_pos = pResult - pStr1->pui8_buffer;
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strFindLastSubStr(M4OSA_String str_in1, M4OSA_String str_in2,
+                                  M4OSA_UInt32* pui32_pos)
+{
+    M4OSA_strStruct* pStr1 = (M4OSA_strStruct*)str_in1;
+    M4OSA_strStruct* pStr2 = (M4OSA_strStruct*)str_in2;
+    M4OSA_Int32 i32_result;
+
+
+    M4OSA_TRACE1_3("M4OSA_strFindLastSubStr\t\tM4OSA_String 0x%x\tM4OSA_String"
+        " 0x%x\tM4OSA_UInt32* 0x%x", str_in1, str_in2, pui32_pos);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr1, M4ERR_PARAMETER,
+                                                     "M4OSA_strFindLastSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr2, M4ERR_PARAMETER,
+                                                     "M4OSA_strFindLastSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pui32_pos, M4ERR_PARAMETER,
+                                                     "M4OSA_strFindLastSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr1->coreID, M4ERR_STR_BAD_STRING,
+                                                     "M4OSA_strFindLastSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr2->coreID, M4ERR_STR_BAD_STRING,
+                                                     "M4OSA_strFindLastSubStr");
+
+    if(*pui32_pos > pStr1->ui32_length)
+    {
+        return M4ERR_STR_OVERFLOW;
+    }
+
+    if((pStr2->ui32_length == 0) || (pStr1->ui32_length == 0))
+    {
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    i32_result = M4OSA_strPrivFindLastSubStr(pStr1, pStr2, *pui32_pos);
+
+    if(i32_result < 0)
+    {
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    *pui32_pos = i32_result;
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strTruncate(M4OSA_String str_in, M4OSA_UInt32 ui32_length)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+
+    M4OSA_TRACE1_2("M4OSA_strTroncate\t\tM4OSA_String 0x%x\tM4OSA_UInt32 %d",
+        str_in, ui32_length);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strTroncate");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strTroncate");
+
+    if(ui32_length >= pStr->ui32_length)
+    {
+        return M4WAR_STR_OVERFLOW;
+    }
+
+    pStr->ui32_length = ui32_length;
+
+    if(pStr->pui8_buffer != M4OSA_NULL)
+    {
+        pStr->pui8_buffer[ui32_length] = '\0';
+    }
+
+    return M4NO_ERROR;
+}
+
+M4OSA_ERR M4OSA_strCopy(M4OSA_String str_out, M4OSA_String str_in)
+{
+    M4OSA_strStruct* pIstr = (M4OSA_strStruct*)str_in;
+    M4OSA_strStruct* pOstr = (M4OSA_strStruct*)str_out;
+
+    M4OSA_TRACE1_2("M4OSA_strCopy\t\tM4OSA_String 0x%x\tM4OSA_String 0x%x",
+        str_in, str_out);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pIstr, M4ERR_PARAMETER, "M4OSA_strCopy");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pOstr, M4ERR_PARAMETER, "M4OSA_strCopy");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pIstr->coreID, M4ERR_STR_BAD_STRING,
+                                                               "M4OSA_strCopy");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pOstr->coreID, M4ERR_STR_BAD_STRING,
+                                                               "M4OSA_strCopy");
+
+    return M4OSA_strPrivSet(pOstr, pIstr->pui8_buffer, pIstr->ui32_length);
+}
+
+
+M4OSA_ERR M4OSA_strCopySubStr(M4OSA_String str_out,
+                              M4OSA_UInt32 ui32_pos,
+                              M4OSA_String str_in,
+                              M4OSA_UInt32 ui32_offset,
+                              M4OSA_UInt32* ui32_num)
+{
+    M4OSA_strStruct *pIstr = (M4OSA_strStruct*)str_in;
+    M4OSA_strStruct *pOstr = (M4OSA_strStruct*)str_out;
+    M4OSA_ERR err_code = M4NO_ERROR;
+    M4OSA_UInt32 ui32_length, olength;
+    M4OSA_Char* pSrc;
+    M4OSA_Char* pDest;
+
+
+    M4OSA_TRACE1_5("M4OSA_strCopySubStr\t\tM4OSA_String 0x%x\tM4OSA_UInt32 %d"
+        "\tM4OSA_String 0x%x\tM4OSA_UInt32 %d\tM4OSA_UInt32* %0x%x",
+        str_out, str_in, str_out, ui32_pos, ui32_num);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pIstr, M4ERR_PARAMETER, "M4OSA_strCopySubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pOstr, M4ERR_PARAMETER, "M4OSA_strCopySubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == ui32_num, M4ERR_PARAMETER,
+                                                         "M4OSA_strCopySubStr");
+    M4OSA_DEBUG_IF2(*ui32_num == 0, M4ERR_PARAMETER, "M4OSA_strCopySubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pOstr->coreID, M4ERR_STR_BAD_STRING,
+                                                         "M4OSA_strCopySubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pIstr->coreID, M4ERR_STR_BAD_STRING,
+                                                         "M4OSA_strCopySubStr");
+    M4OSA_DEBUG_IF2(ui32_pos > pOstr->ui32_length, M4ERR_STR_OVERFLOW,
+                                                         "M4OSA_strCopySubStr");
+    M4OSA_DEBUG_IF2(ui32_offset > pIstr->ui32_length, M4ERR_STR_OVERFLOW,
+                                                         "M4OSA_strCopySubStr");
+
+    /* Calculate there is enough char in str_in after ui32_offset */
+    ui32_length = pIstr->ui32_length - ui32_offset;
+
+    if(*ui32_num > ui32_length)
+    {
+        *ui32_num = ui32_length;
+
+        err_code = M4WAR_STR_OVERFLOW;
+    }
+
+    /* Calculate the future length of str2 */
+    ui32_length = ui32_pos + *ui32_num;
+
+    olength = pOstr->ui32_length;
+
+    if(ui32_length >= olength)
+    {
+        olength = ui32_length;
+    }
+
+    /* Reallocation if needed */
+    if(M4OSA_strPrivReallocCopy(pOstr, olength) != M4NO_ERROR)
+    {
+        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strCopySubStr");
+
+        return M4ERR_ALLOC;
+    }
+
+    pSrc  = pIstr->pui8_buffer + ui32_offset;
+    pDest = pOstr->pui8_buffer + ui32_pos;
+
+    M4OSA_memcpy(pDest, pSrc, *ui32_num);
+
+    pOstr->ui32_length = olength;
+    pOstr->pui8_buffer[pOstr->ui32_length] = '\0';
+
+    return err_code;
+}
+
+
+M4OSA_ERR M4OSA_strConcat(M4OSA_String str_first, M4OSA_String str_second)
+{
+    M4OSA_strStruct* pStr1 = (M4OSA_strStruct*)str_first;
+    M4OSA_strStruct* pStr2 = (M4OSA_strStruct*)str_second;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char* pBuffer;
+
+    M4OSA_TRACE1_2("M4OSA_strConcat\t\tM4OSA_String 0x%x\tM4OSA_String 0x%x",
+        str_first, str_second);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr1, M4ERR_PARAMETER, "M4OSA_strConcat");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr2, M4ERR_PARAMETER, "M4OSA_strConcat");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr1->coreID, M4ERR_STR_BAD_STRING,
+                                                             "M4OSA_strConcat");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr2->coreID, M4ERR_STR_BAD_STRING,
+                                                             "M4OSA_strConcat");
+
+    if(pStr2->ui32_length == 0)
+    {
+        return M4NO_ERROR;
+    }
+
+    ui32_length = pStr1->ui32_length + pStr2->ui32_length;
+
+    if(M4OSA_strPrivReallocCopy(pStr1, ui32_length) != M4NO_ERROR)
+    {
+        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strConcat");
+
+        return M4ERR_ALLOC;
+    }
+
+    pBuffer = pStr1->pui8_buffer + pStr1->ui32_length;
+
+    /* Fill the actual M4OSA_String content */
+    M4OSA_memcpy(pBuffer, pStr2->pui8_buffer, pStr2->ui32_length+1);
+
+    pStr1->ui32_length = ui32_length;
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strInsertSubStr(M4OSA_String str_out,
+                                M4OSA_UInt32 ui32_pos,
+                                M4OSA_String str_in,
+                                M4OSA_UInt32 ui32_offset,
+                                M4OSA_UInt32* ui32_num)
+{
+    M4OSA_strStruct *pIstr = (M4OSA_strStruct*)str_in;
+    M4OSA_strStruct *pOstr = (M4OSA_strStruct*)str_out;
+    M4OSA_ERR err_code, return_code = M4NO_ERROR;
+    M4OSA_UInt32 ui32_length;
+
+    M4OSA_TRACE1_5("M4OSA_strInsertSubStr\t\tM4OSA_String 0x%x\tM4OSA_UInt32 %d"
+        "\tM4OSA_String 0x%x\tM4OSA_UInt32 %d\tM4OSA_UInt32* %0x%x",
+        str_out, str_in, str_out, ui32_pos, ui32_num);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pIstr, M4ERR_PARAMETER,
+                                                       "M4OSA_strInsertSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pOstr, M4ERR_PARAMETER,
+                                                       "M4OSA_strInsertSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == ui32_num, M4ERR_PARAMETER,
+                                                       "M4OSA_strInsertSubStr");
+    M4OSA_DEBUG_IF2(*ui32_num == 0, M4ERR_PARAMETER,
+                                                       "M4OSA_strInsertSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pIstr->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strInsertSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pOstr->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strInsertSubStr");
+    M4OSA_DEBUG_IF2(ui32_pos > pOstr->ui32_length, M4ERR_STR_OVERFLOW,
+                                                       "M4OSA_strInsertSubStr");
+    M4OSA_DEBUG_IF2(ui32_offset > pIstr->ui32_length, M4ERR_STR_OVERFLOW,
+                                                       "M4OSA_strInsertSubStr");
+
+    /* Calculate there is enough char in str_in after ui32_offset */
+    ui32_length = pIstr->ui32_length - ui32_offset;
+
+    if(*ui32_num > ui32_length)
+    {
+        *ui32_num = ui32_length;
+
+        return_code = M4WAR_STR_OVERFLOW;
+    }
+
+    err_code = M4OSA_strPrivSetAndRepleceStr(pOstr, ui32_pos, 0,
+        pIstr->pui8_buffer + ui32_offset, *ui32_num);
+
+    if(err_code == (M4OSA_ERR)M4ERR_ALLOC)
+    {
+        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strInsertSubStr");
+
+        return M4ERR_ALLOC;
+    }
+
+    return return_code;
+}
+
+
+M4OSA_ERR M4OSA_strDelSubStr(M4OSA_String str_in, M4OSA_UInt32 ui32_offset,
+                             M4OSA_UInt32* ui32_num)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_length;
+    M4OSA_Char* pBuffer;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strDelSubStr\t\tM4OSA_String 0x%x\tM4OSA_UInt32 %d\t"
+        "M4OSA_UInt32* 0x%x", str_in, ui32_offset, ui32_num);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strDelSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == ui32_num, M4ERR_PARAMETER,
+                                                          "M4OSA_strDelSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                          "M4OSA_strDelSubStr");
+
+    pBuffer = pStr->pui8_buffer;
+
+    ui32_length = pStr->ui32_length ;
+
+    if(ui32_offset >= ui32_length)
+    {
+        return M4ERR_STR_OVERFLOW;
+    }
+
+    ui32_length -= ui32_offset;
+
+    if(*ui32_num >= ui32_length)
+    {
+        *ui32_num = ui32_length;
+
+        pStr->ui32_length -= ui32_length;
+
+        pBuffer[pStr->ui32_length] = '\0';
+
+        err_code = M4WAR_STR_OVERFLOW;
+    }
+    else
+    {
+        err_code = M4OSA_strPrivSetAndRepleceStr(pStr, ui32_offset, *ui32_num,
+            M4OSA_NULL, 0);
+    }
+
+    return err_code;
+}
+
+
+M4OSA_ERR M4OSA_strReplaceSubStr(M4OSA_String str_in, M4OSA_String str_old,
+                                 M4OSA_String str_new, M4OSA_strMode mode)
+{
+    M4OSA_strStruct* pIstr = (M4OSA_strStruct*)str_in;
+    M4OSA_strStruct* pOstr = (M4OSA_strStruct*)str_old;
+    M4OSA_strStruct* pNstr = (M4OSA_strStruct*)str_new;
+    M4OSA_UInt32 olength, nlength, ilength;
+    M4OSA_Bool ostr2free = M4OSA_FALSE;
+    M4OSA_Bool nstr2free = M4OSA_FALSE;
+    M4OSA_ERR err_code;
+
+
+    M4OSA_TRACE1_4("M4OSA_strReplaceSubStr\t\tM4OSA_String 0x%x\tM4OSA_String "
+        "0x%x\tM4OSA_String 0x%x\tM4OSA_strSupprMode %d",
+        str_in, str_old, str_new, mode);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pIstr, M4ERR_PARAMETER,
+                                                      "M4OSA_strReplaceSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pOstr, M4ERR_PARAMETER,
+                                                      "M4OSA_strReplaceSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pNstr, M4ERR_PARAMETER,
+                                                      "M4OSA_strReplaceSubStr");
+    M4OSA_DEBUG_IF2((mode != M4OSA_kstrAll) && (mode != M4OSA_kstrEnd)
+        && (mode != M4OSA_kstrBegin), M4ERR_PARAMETER,
+                                                      "M4OSA_strReplaceSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pIstr->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strReplaceSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pOstr->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strReplaceSubStr");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pNstr->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strReplaceSubStr");
+
+    olength = pOstr->ui32_length;
+    nlength = pNstr->ui32_length;
+    ilength = pIstr->ui32_length;
+
+    if((olength == 0) || (ilength == 0) || (olength > ilength))
+    {
+        M4OSA_DEBUG(M4WAR_STR_NOT_FOUND, "M4OSA_strReplaceSubStr");
+
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    if(pIstr == pOstr)
+    {
+        M4OSA_strPrivDuplicate(&pOstr, pIstr);
+
+        ostr2free = M4OSA_TRUE;
+    }
+
+    if(pIstr == pNstr)
+    {
+        M4OSA_strPrivDuplicate(&pNstr, pIstr);
+
+        nstr2free = M4OSA_TRUE;
+    }
+
+    if(nlength == olength)
+    {
+        err_code = M4OSA_strPrivReplaceSameSizeStr(pIstr, pOstr, pNstr, mode);
+    }
+    else if(nlength < olength)
+    {
+        err_code = M4OSA_strPrivReplaceSmallerStr(pIstr, pOstr, pNstr, mode);
+    }
+    else
+    {
+        err_code = M4OSA_strPrivReplaceBiggerStr(pIstr, pOstr, pNstr, mode);
+    }
+
+    if(ostr2free == M4OSA_TRUE)
+    {
+        M4OSA_free((M4OSA_MemAddr32)pOstr->pui8_buffer);
+        M4OSA_free((M4OSA_MemAddr32)pOstr);
+    }
+
+    if(nstr2free == M4OSA_TRUE)
+    {
+        M4OSA_free((M4OSA_MemAddr32)pNstr->pui8_buffer);
+        M4OSA_free((M4OSA_MemAddr32)pNstr);
+    }
+
+    return err_code;
+}
+
+
+M4OSA_ERR M4OSA_strGetFirstToken(M4OSA_String str_in, M4OSA_String str_token,
+                                 M4OSA_String str_delim)
+{
+    M4OSA_strStruct* pIn =    (M4OSA_strStruct*)str_in;
+    M4OSA_strStruct* pToken = (M4OSA_strStruct*)str_token;
+    M4OSA_strStruct* pDelim = (M4OSA_strStruct*)str_delim;
+    M4OSA_UInt32 length_token, length_delim;
+    M4OSA_Char* pBuffer;
+    M4OSA_Char* pchar;
+    M4OSA_ERR err_code;
+
+
+    M4OSA_TRACE1_3("M4OSA_strGetFirstToken\t\tM4OSA_String 0x%x\tM4OSA_String"
+        " 0x%x\tM4OSA_String 0x%x", str_in, str_token, str_delim);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pIn, M4ERR_PARAMETER,"M4OSA_strGetFirstToken");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pToken, M4ERR_PARAMETER,
+                                                      "M4OSA_strGetFirstToken");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pDelim, M4ERR_PARAMETER,
+                                                      "M4OSA_strGetFirstToken");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pIn->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strGetFirstToken");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pToken->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strGetFirstToken");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pDelim->coreID, M4ERR_STR_BAD_STRING,
+                                                      "M4OSA_strGetFirstToken");
+
+    length_delim = pDelim->ui32_length;
+
+    if(pDelim->ui32_length == 0)
+    {
+        M4OSA_DEBUG(M4WAR_STR_NOT_FOUND, "M4OSA_strGetFirstToken");
+
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    pBuffer = pIn->pui8_buffer;
+
+    err_code = M4OSA_chrFindPattern(pBuffer,pDelim->pui8_buffer, &pchar);
+
+    if(err_code != M4NO_ERROR)
+    {
+        M4OSA_DEBUG(M4WAR_STR_NOT_FOUND, "M4OSA_strGetFirstToken");
+
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    length_token = pchar - pBuffer;
+
+    err_code = M4OSA_strPrivSet(pToken, pBuffer, length_token);
+
+    if(err_code == (M4OSA_ERR)M4ERR_ALLOC)
+    {
+        M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strGetFirstToken: M4OSA_strPrivSet");
+
+        return M4ERR_ALLOC;
+    }
+
+    err_code = M4OSA_strPrivSetAndRepleceStr(pIn, 0, length_token + length_delim,
+        M4OSA_NULL, 0);
+
+    if(err_code == (M4OSA_ERR)M4ERR_ALLOC)
+    {
+        M4OSA_DEBUG(M4ERR_ALLOC,
+            "M4OSA_strGetFirstToken: M4OSA_strPrivSetAndRepleceStr");
+
+        return M4ERR_ALLOC;
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strGetLastToken(M4OSA_String str_in, M4OSA_String str_token,
+                                M4OSA_String str_delim)
+{
+    M4OSA_strStruct* pIn =    (M4OSA_strStruct*)str_in;
+    M4OSA_strStruct* pToken = (M4OSA_strStruct*)str_token;
+    M4OSA_strStruct* pDelim = (M4OSA_strStruct*)str_delim;
+    M4OSA_UInt32 in_length, token_length, delim_length;
+    M4OSA_Char* pIn_buffer;
+    M4OSA_Char* pToken_buffer;
+    M4OSA_Int32 delim_pos;
+    M4OSA_ERR err_code;
+
+    M4OSA_TRACE1_3("M4OSA_strGetLastToken\t\tM4OSA_String 0x%x\tM4OSA_String"
+        " 0x%x\tM4OSA_String 0x%x", str_in, str_token, str_delim);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pIn, M4ERR_PARAMETER,
+                                                       "M4OSA_strGetLastToken");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pToken, M4ERR_PARAMETER,
+                                                       "M4OSA_strGetLastToken");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pDelim, M4ERR_PARAMETER,
+                                                       "M4OSA_strGetLastToken");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pIn->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strGetLastToken");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pToken->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strGetLastToken");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pDelim->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strGetLastToken");
+
+    in_length = pIn->ui32_length;
+    delim_length = pDelim->ui32_length;
+    pIn_buffer = pIn->pui8_buffer;
+
+    if(pDelim->ui32_length > pIn->ui32_length)
+    {
+        M4OSA_DEBUG(M4WAR_STR_NOT_FOUND, "M4OSA_strGetLastToken");
+
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    delim_pos = M4OSA_strPrivFindLastSubStr(pIn, pDelim, in_length-delim_length);
+
+    if(delim_pos < 0)
+    {
+        M4OSA_DEBUG(M4WAR_STR_NOT_FOUND, "M4OSA_strGetLastToken");
+
+        return M4WAR_STR_NOT_FOUND;
+    }
+
+    pToken_buffer = pIn_buffer + delim_pos + delim_length;
+    token_length = in_length - delim_pos + delim_length;
+
+    err_code = M4OSA_strPrivSet(str_token, pToken_buffer, token_length);
+
+    if(err_code == (M4OSA_ERR)M4ERR_ALLOC)
+    {
+        M4OSA_DEBUG(M4ERR_ALLOC,
+            "M4OSA_strGetLastToken: M4OSA_strPrivSet");
+
+        return err_code;
+    }
+
+    pIn_buffer[delim_pos] = '\0';
+
+    pIn->ui32_length = delim_pos;
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetUpperCase(M4OSA_String str_in)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_Char* pBuffer;
+    M4OSA_Char* pchar;
+
+
+    M4OSA_TRACE1_1("M4OSA_strSetUpperCase\t\tM4OSA_String 0x%x", str_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetUpperCase");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strSetUpperCase");
+
+    pBuffer = pStr->pui8_buffer;
+
+    for(pchar=pBuffer; pchar!=(pBuffer+pStr->ui32_length); pchar++)
+    {
+        *pchar = M4OSA_chrToUpper(*pchar);
+    }
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetLowerCase(M4OSA_String str_in)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_Char* pBuffer;
+    M4OSA_Char* pchar;
+
+    M4OSA_TRACE1_1("M4OSA_strSetLowerCase\t\tM4OSA_String 0x%x", str_in);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetLowerCase");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strSetLowerCase");
+
+    pBuffer = pStr->pui8_buffer;
+
+    for(pchar=pBuffer; pchar!=(pBuffer+pStr->ui32_length); pchar++)
+    {
+        *pchar = M4OSA_chrToLower(*pchar);
+    }
+
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSprintf(M4OSA_String str_in, M4OSA_Char* pFormat, ...)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_ERR err_code = M4ERR_STR_OVERFLOW;
+    M4OSA_UInt32 ui32_size;
+    va_list args;
+
+    M4OSA_TRACE1_2("M4OSA_strSprintf\t\tM4OSA_String 0x%x\tM4OSA_Char* 0x%x",
+        str_in, pFormat);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pFormat, M4ERR_PARAMETER, "M4OSA_strSprintf");
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSprintf");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                       "M4OSA_strSetLowerCase");
+
+    ui32_size = pStr->ui32_length + (M4OSA_UInt32)(1.5 * M4OSA_chrLength(pFormat));
+
+    va_start(args, pFormat);
+
+    while(err_code == (M4OSA_ERR)M4ERR_STR_OVERFLOW)
+    {
+        err_code = M4OSA_strPrivReallocCopy(pStr, ui32_size);
+
+        if(err_code == (M4OSA_ERR)M4ERR_ALLOC)
+        {
+            M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strSprintf");
+
+            va_end(args);
+
+            return M4ERR_ALLOC;
+        }
+
+        ui32_size *= 2;
+
+        err_code = M4OSA_strPrivSPrintf(pStr, pFormat, args);
+    }
+
+    va_end(args);
+
+    pStr->ui32_length = M4OSA_chrLength(pStr->pui8_buffer);
+
+    return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strSetMinAllocationSize(M4OSA_String str_in, M4OSA_UInt32 ui32_newsize)
+{
+    M4OSA_strStruct* pStr = (M4OSA_strStruct*)str_in;
+    M4OSA_UInt32 ui32_size;
+    M4OSA_Char* pBuffer;
+    M4OSA_Char* pIbuffer;
+
+    M4OSA_TRACE1_2("M4OSA_strSetMinAllocationSize\t\tM4OSA_String 0x%x\t"
+        "M4OSA_Int32 %d", str_in, ui32_newsize);
+
+    M4OSA_DEBUG_IF2(M4OSA_NULL == pStr, M4ERR_PARAMETER, "M4OSA_strSetInt32");
+    M4OSA_DEBUG_IF2(M4OSA_STRING != pStr->coreID, M4ERR_STR_BAD_STRING,
+                                                           "M4OSA_strSetInt32");
+
+    ui32_size = pStr->ui32_size;
+    pIbuffer = pStr->pui8_buffer;
+
+    if(ui32_newsize > ui32_size)
+    {
+        ui32_size = ui32_newsize + ((4 - (ui32_newsize % 4)) % 4);
+    }
+
+    /* Allocate the actual M4OSA_String content */
+    pBuffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char),
+        M4OSA_STRING, (M4OSA_Char*)"M4OSA_strSetMinAllocationSize");
+
+    M4OSA_CHECK_MALLOC(pBuffer, "M4OSA_strSetMinAllocationSize");
+
+    if(pIbuffer != M4OSA_NULL)
+    {
+        M4OSA_memcpy(pBuffer, pIbuffer, pStr->ui32_length+1);
+
+        M4OSA_free((M4OSA_MemAddr32)pIbuffer);
+    }
+
+    pStr->pui8_buffer = pBuffer;
+
+    pStr->ui32_size = ui32_size;
+
+    return M4NO_ERROR;
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_String_priv.c b/libvideoeditor/osal/src/M4OSA_String_priv.c
new file mode 100755
index 0000000..07cef33
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_String_priv.c
@@ -0,0 +1,1136 @@
+/*
+ * 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_String_priv.c
+ ************************************************************************
+*/
+
+#include "M4OSA_Debug.h"
+#include "M4OSA_Types.h"
+#include "M4OSA_Memory.h"
+#include "M4OSA_Error.h"
+#include "M4OSA_String_priv.h"
+#include "M4OSA_String.h"
+
+/**
+ ************************************************************************
+ * @brief      This function replaces a string buffer by a new "C-String"
+ *             and manage memory if needed
+ * @note
+ * @param      pstr_src
+ * @param      pac_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strPrivRealloc(M4OSA_strStruct* str,
+                               M4OSA_UInt32 ui32_length)
+{
+   M4OSA_UInt32 ui32_size;
+   M4OSA_Char* buffer;
+
+   M4OSA_TRACE2_2("M4OSA_strPrivRealloc\t\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_UInt32* %d", str, ui32_length);
+
+   ui32_size = str->ui32_size;
+
+   /* Realloc if size is not sufficient to contain it entirely */
+   if(ui32_length >= ui32_size)
+   {
+      if(ui32_size == 0)
+      {
+         ui32_size = 16;
+      }
+
+      while(ui32_length >= ui32_size)
+      {
+         ui32_size <<= 1;
+      }
+
+      buffer = str->pui8_buffer;
+
+      if(buffer != M4OSA_NULL)
+      {
+         M4OSA_free((M4OSA_MemAddr32)buffer);
+      }
+
+      /* Allocate the actual M4OSA_String content */
+      buffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char),
+                            M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivRealloc");
+
+      /* Check memory allocation error */
+      if(buffer == M4OSA_NULL)
+      {
+         M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivRealloc");
+
+         str->pui8_buffer = M4OSA_NULL;
+         str->ui32_size = 0;
+         str->ui32_length = 0;
+
+         return M4ERR_ALLOC;
+      }
+
+      str->pui8_buffer = buffer;
+      str->ui32_size = ui32_size;
+   }
+
+   return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function replaces a string buffer by a new "C-String"
+ *             and manage memory if needed
+ * @note
+ * @param      pstr_src
+ * @param      pac_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strPrivReallocCopy(M4OSA_strStruct* str,
+                                   M4OSA_UInt32 ui32_length)
+{
+   M4OSA_UInt32 ui32_size;
+   M4OSA_Char* buffer;
+   M4OSA_Char* pui8_buffer;
+
+   M4OSA_TRACE2_2("M4OSA_strPrivReallocCopy\t\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_UInt32* %d", str, ui32_length);
+
+
+   ui32_size = str->ui32_size;
+
+   /* Realloc if size is not sufficient to contain it entirely */
+   if(ui32_length >= ui32_size)
+   {
+      if(ui32_size == 0)
+      {
+         ui32_size = 16;
+      }
+
+      while(ui32_length >= ui32_size)
+      {
+         ui32_size <<= 1;
+      }
+
+      /* Allocate the actual M4OSA_String content */
+      buffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char),
+                            M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivReallocCopy");
+
+      /* Check memory allocation error */
+      if(buffer == M4OSA_NULL)
+      {
+         M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivReallocCopy");
+
+         str->pui8_buffer = M4OSA_NULL;
+         str->ui32_size = 0;
+         str->ui32_length = 0;
+
+         return M4ERR_ALLOC;
+      }
+
+      pui8_buffer = str->pui8_buffer;
+
+      if(pui8_buffer != M4OSA_NULL)
+      {
+         M4OSA_memcpy(buffer, pui8_buffer, str->ui32_length + 1);
+
+         M4OSA_free((M4OSA_MemAddr32)pui8_buffer);
+      }
+
+      str->pui8_buffer = buffer;
+      str->ui32_size = ui32_size;
+   }
+
+   return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strPrivDuplicate(M4OSA_strStruct** ostr,
+                                 M4OSA_strStruct* istr)
+{
+   M4OSA_strStruct* str;
+   M4OSA_ERR err_code;
+
+   M4OSA_TRACE2_2("M4OSA_strPrivDuplicate\t\tM4OSA_strStruct** 0x%x\t"
+                  "M4OSA_strStruct** 0x%x", ostr, istr);
+
+   /* Allocate the output M4OSA_String */
+   str = (M4OSA_strStruct*)M4OSA_malloc(sizeof(M4OSA_strStruct), M4OSA_STRING,
+                           (M4OSA_Char*)"M4OSA_strPrivDuplicate: output string");
+
+   /* Check memory allocation error */
+   if(str == M4OSA_NULL)
+   {
+      *ostr = M4OSA_NULL ;
+
+      M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivDuplicate");
+
+      return M4ERR_ALLOC;
+   }
+
+   str->coreID = M4OSA_STRING;
+   str->pui8_buffer = M4OSA_NULL;
+   str->ui32_length = 0;
+   str->ui32_size = 0;
+
+   err_code =  M4OSA_strPrivSet(str, istr->pui8_buffer, istr->ui32_length);
+
+   if(err_code != M4NO_ERROR)
+   {
+      return err_code;
+   }
+
+   *ostr = str;
+
+   return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function replaces a string buffer by a new "C-String"
+ *             and manage memory if needed
+ * @note
+ * @param      pstr_src
+ * @param      pac_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_strPrivSet(M4OSA_strStruct* str,
+                           M4OSA_Char* pchar,
+                           M4OSA_UInt32 ui32_length)
+{
+   M4OSA_UInt32 length;
+   M4OSA_Char* buffer;
+
+   M4OSA_TRACE2_3("M4OSA_strPrivSet\t\tM4OSA_strStruct* 0x%x\tM4OSA_Char* "
+                  "0x%x\tM4OSA_UInt32 %d", str, pchar, ui32_length);
+
+   if(ui32_length != 0)
+   {
+      length = M4OSA_chrLength(pchar);
+
+      if(length < ui32_length)
+      {
+         ui32_length = length;
+      }
+
+      if(M4OSA_strPrivRealloc(str, ui32_length) != M4NO_ERROR)
+      {
+         M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_strPrivSet");
+
+         return M4ERR_ALLOC;
+      }
+
+      buffer = str->pui8_buffer;
+
+      /* Fill the actual M4OSA_String content */
+      M4OSA_memcpy(buffer, pchar, ui32_length);
+
+      buffer[ui32_length] = '\0';
+   }
+   else if(str->pui8_buffer != M4OSA_NULL)
+   {
+      str->pui8_buffer[0] = '\0';
+   }
+
+   str->ui32_length = ui32_length;
+
+   return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function replaces a string buffer by a new "C-String"
+ *             and manage memory if needed
+ * @note
+ * @param      pstr_src
+ * @param      pac_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+*/
+M4OSA_Int32 M4OSA_strPrivFindLastSubStr(M4OSA_strStruct* str1,
+                                        M4OSA_strStruct* str2,
+                                        M4OSA_UInt32 ui32_pos)
+{
+   M4OSA_Char *pchar;
+   M4OSA_Char *buffer1;
+   M4OSA_Char *buffer2;
+   M4OSA_Int32 i32_result;
+   M4OSA_UInt32 length1, length2;
+   M4OSA_Int32 dist;
+
+   M4OSA_TRACE2_3("M4OSA_strPrivFindLastSubStr\t\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_strStruct* 0x%x\tM4OSA_UInt32 %d",
+                  str1, str2, ui32_pos);
+
+   length1 = str1->ui32_length;
+   length2 = str2->ui32_length;
+
+   if((length1 == 0) || (length2 == 0))
+   {
+      return -1;
+   }
+
+   buffer1 = str1->pui8_buffer;
+   buffer2 = str2->pui8_buffer;
+
+   dist = length1 - length2;
+
+   if(dist < 0)
+   {
+      return -1;
+   }
+
+   if((M4OSA_Int32)ui32_pos > dist)
+   {
+      ui32_pos = dist;
+   }
+
+   for(pchar = buffer1 + ui32_pos; pchar != buffer1; pchar--)
+   {
+      M4OSA_chrNCompare(pchar, buffer2, length2, &i32_result);
+
+      if(i32_result == 0)
+      {
+         return pchar - buffer1;
+      }
+   }
+
+   return -1;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function replaces a string buffer by a new "C-String"
+ *             and manage memory if needed
+ * @note
+ * @param      pstr_src
+ * @param      pac_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strPrivSetAndRepleceStr(M4OSA_strStruct* istr,
+                                        M4OSA_UInt32 ui32_pos,
+                                        M4OSA_UInt32 olength,
+                                        M4OSA_Char* nbuff,
+                                        M4OSA_UInt32 nlength)
+{
+   M4OSA_Char* buffer;
+   M4OSA_Char* ibuffer;
+   M4OSA_UInt32 ui32_length, ui32_size, ui32_lend, ui32_poso, ui32_posn;
+
+   M4OSA_TRACE2_5("M4OSA_strPrivSetAndRepleceStr\t\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_UInt32 %d\tM4OSA_UInt32 %d\tM4OSA_Char* 0x%x\t"
+                  "M4OSA_UInt32 %d", istr, ui32_pos, olength, nbuff, nlength);
+
+   ui32_length = istr->ui32_length - olength + nlength;
+
+   ibuffer = istr->pui8_buffer;
+
+   /* string to replace has the same this that new string */
+   if(nlength == olength)
+   {
+      if(nlength == 0)
+      {
+         return M4NO_ERROR;
+      }
+
+      M4OSA_memcpy(ibuffer + ui32_pos, nbuff, nlength);
+   }
+   else
+   {
+      ui32_lend = istr->ui32_length - ui32_pos - olength;
+      ui32_poso = ui32_pos + olength;
+      ui32_posn = ui32_pos + nlength;
+
+      /* string to replace is bigger that new string */
+      if(nlength < olength)
+      {
+         if(nlength > 0)
+         {
+            M4OSA_memcpy(ibuffer + ui32_pos, nbuff, nlength);
+         }
+
+         if((olength - nlength) >= ui32_lend)
+         {
+            M4OSA_memcpy(ibuffer + ui32_posn, ibuffer + ui32_poso, ui32_lend);
+         }
+         else
+         {
+            buffer = (M4OSA_Char*)M4OSA_malloc(ui32_lend * sizeof(M4OSA_Char),
+                                M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivSetAndRepleceStr");
+
+            M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivSetAndRepleceStr");
+            M4OSA_memcpy(buffer, ibuffer + ui32_poso, ui32_lend);
+            M4OSA_memcpy(ibuffer + ui32_posn, buffer, ui32_lend);
+            M4OSA_free((M4OSA_MemAddr32)buffer);
+         }
+      }
+      /* string to replace is smaller that new string */
+      else
+      {
+         ui32_size = istr->ui32_size;
+
+         /* check if there is enough memory allocated in istr */
+         if(ui32_length >= ui32_size)
+         {
+            if(ui32_size == 0)
+            {
+               ui32_size = 16;
+            }
+
+            while(ui32_length >= ui32_size)
+            {
+               ui32_size <<= 1;
+            }
+
+            buffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char),
+                                M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivSetAndRepleceStr");
+
+            M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivSetAndRepleceStr");
+
+            M4OSA_memcpy(buffer, ibuffer, ui32_pos);
+
+            M4OSA_memcpy(buffer + ui32_pos, nbuff, nlength);
+
+            M4OSA_memcpy(buffer + ui32_posn, ibuffer + ui32_poso, ui32_lend);
+
+            M4OSA_free((M4OSA_MemAddr32)ibuffer);
+
+            istr->pui8_buffer = buffer;
+
+            istr->ui32_size = ui32_size;
+         }
+         else
+         {
+            buffer = (M4OSA_Char*)M4OSA_malloc(ui32_lend * sizeof(M4OSA_Char),
+                                M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivSetAndRepleceStr");
+
+            M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivSetAndRepleceStr");
+
+            M4OSA_memcpy(buffer, ibuffer + ui32_poso, ui32_lend);
+
+            M4OSA_memcpy(ibuffer + ui32_pos, nbuff, nlength);
+
+            M4OSA_memcpy(ibuffer + ui32_posn, buffer, ui32_lend);
+
+            M4OSA_free((M4OSA_MemAddr32)buffer);
+         }
+      }
+   }
+
+
+   istr->pui8_buffer[ui32_length] = '\0';
+
+   istr->ui32_length = ui32_length;
+
+   return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function replaces a string buffer by a new "C-String"
+ *             and manage memory if needed
+ * @note
+ * @param      pstr_src
+ * @param      pac_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strPrivReplaceSameSizeStr(M4OSA_strStruct* istr,
+                                          M4OSA_strStruct* ostr,
+                                          M4OSA_strStruct* nstr,
+                                          M4OSA_strMode mode)
+{
+   M4OSA_Char* ibuffer;
+   M4OSA_Char* obuffer;
+   M4OSA_Char* nbuffer;
+   M4OSA_Char* ptr;
+   M4OSA_UInt32 ilength, nlength;
+   M4OSA_Int32 i32_pos;
+   M4OSA_ERR err_code;
+
+   M4OSA_TRACE2_4("M4OSA_strPrivReplaceSameSizeStr\t\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_strStruct* 0x%x\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_strMode %d", istr, ostr, nstr, mode);
+
+   ibuffer = istr->pui8_buffer;
+   obuffer = ostr->pui8_buffer;
+   nbuffer = nstr->pui8_buffer;
+
+   ilength = istr->ui32_length;
+   nlength = nstr->ui32_length;
+
+   if(mode != M4OSA_kstrEnd)
+   {
+      err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr);
+
+      M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code,
+                      "M4OSA_strPrivReplaceSameSizeStr");
+
+      if(err_code == M4WAR_CHR_NOT_FOUND)
+      {
+         return M4WAR_STR_NOT_FOUND;
+      }
+
+      if(mode == M4OSA_kstrAll)
+      {
+         do
+         {
+            M4OSA_memcpy(ptr, nbuffer, nlength);
+
+            err_code = M4OSA_chrFindPattern(ptr+nlength, obuffer, &ptr);
+
+            M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code,
+                            "M4OSA_strPrivReplaceSameSizeStr");
+
+         } while(err_code != M4WAR_CHR_NOT_FOUND);
+      }
+      else
+      {
+         M4OSA_memcpy(ptr, nbuffer, nlength);
+      }
+   }
+   else
+   {
+      i32_pos = M4OSA_strPrivFindLastSubStr(istr, ostr, ilength-1);
+
+      if(i32_pos < 0)
+      {
+         return M4WAR_STR_NOT_FOUND;
+      }
+
+      M4OSA_memcpy(ibuffer + i32_pos, nbuffer, nlength);
+   }
+
+
+   return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function replaces a string buffer by a new "C-String"
+ *             and manage memory if needed
+ * @note
+ * @param      pstr_src
+ * @param      pac_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strPrivReplaceSmallerStr(M4OSA_strStruct* istr,
+                                         M4OSA_strStruct* ostr,
+                                         M4OSA_strStruct* nstr,
+                                         M4OSA_strMode mode)
+{
+   M4OSA_Char* ibuffer;
+   M4OSA_Char* obuffer;
+   M4OSA_Char* nbuffer;
+   M4OSA_Char* buffer;
+   M4OSA_Char* ptr_src;
+   M4OSA_Char* ptr_dest;
+   M4OSA_UInt32 ilength, nlength, olength, size, length;
+   M4OSA_Int32 i32_pos;
+   M4OSA_ERR err_code;
+
+   M4OSA_TRACE2_4("M4OSA_strPrivReplaceSmallerStr\t\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_strStruct* 0x%x\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_strMode %d", istr, ostr, nstr, mode);
+
+   ibuffer = istr->pui8_buffer;
+   obuffer = ostr->pui8_buffer;
+   nbuffer = nstr->pui8_buffer;
+
+   ilength = istr->ui32_length;
+   olength = ostr->ui32_length;
+   nlength = nstr->ui32_length;
+
+   length = ilength;
+
+   if(mode == M4OSA_kstrAll)
+   {
+      err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr_src);
+
+      M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code,
+                      "M4OSA_strPrivReplaceSameSizeStr");
+
+      if(err_code == M4WAR_CHR_NOT_FOUND)
+      {
+         return M4WAR_STR_NOT_FOUND;
+      }
+
+      /* Allocate the actual M4OSA_String content */
+      buffer = (M4OSA_Char*)M4OSA_malloc(istr->ui32_size * sizeof(M4OSA_Char),
+                            M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivReplaceSmallerStr");
+
+      M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivReplaceSmallerStr");
+
+      ptr_dest = buffer;
+
+      do
+      {
+         size = (M4OSA_UInt32)ptr_src - (M4OSA_UInt32)ibuffer;
+
+         length += (nlength - olength);
+
+         M4OSA_memcpy(ptr_dest, ibuffer, size);
+
+         ptr_dest += size;
+
+         M4OSA_memcpy(ptr_dest, nbuffer, nlength);
+
+         ptr_dest += nlength;
+
+         ibuffer += (size + olength);
+
+         err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr_src);
+
+         M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code,
+                         "M4OSA_strPrivReplaceSameSizeStr");
+
+      } while(err_code != M4WAR_CHR_NOT_FOUND);
+
+      size = ilength - (M4OSA_UInt32)(ibuffer - istr->pui8_buffer);
+
+      M4OSA_memcpy(ptr_dest, ibuffer, size);
+
+      M4OSA_free((M4OSA_MemAddr32)istr->pui8_buffer);
+
+      istr->ui32_length = length ;
+
+      buffer[length] = '\0';
+
+      istr->pui8_buffer = buffer;
+   }
+   else
+   {
+      if(mode == M4OSA_kstrBegin)
+      {
+         err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr_src);
+
+         M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code,
+                      "M4OSA_strPrivReplaceSameSizeStr");
+
+         if(err_code == M4WAR_CHR_NOT_FOUND)
+         {
+            return M4WAR_STR_NOT_FOUND;
+         }
+
+         i32_pos = (M4OSA_UInt32)ptr_src - (M4OSA_UInt32)ibuffer;
+      }
+      else
+      {
+         i32_pos = M4OSA_strPrivFindLastSubStr(istr, ostr, ilength-1);
+
+         if(i32_pos == -1)
+         {
+            return M4WAR_STR_NOT_FOUND;
+         }
+      }
+
+      err_code = M4OSA_strPrivSetAndRepleceStr(istr, i32_pos, olength,
+                                               nbuffer, nlength);
+
+      if(M4OSA_ERR_IS_ERROR(err_code))
+      {
+         M4OSA_DEBUG(err_code, "M4OSA_strPrivReplaceSmallerStr");
+
+         return err_code;
+      }
+   }
+
+   return M4NO_ERROR;
+}
+
+/**
+ ************************************************************************
+ * @brief      This function replaces a string buffer by a new "C-String"
+ *             and manage memory if needed
+ * @note
+ * @param      pstr_src
+ * @param      pac_in
+ * @return     M4OSA_ERROR
+ ************************************************************************
+ */
+M4OSA_ERR M4OSA_strPrivReplaceBiggerStr(M4OSA_strStruct* istr,
+                                        M4OSA_strStruct* ostr,
+                                        M4OSA_strStruct* nstr,
+                                        M4OSA_strMode mode)
+{
+   M4OSA_Char* ibuffer;
+   M4OSA_Char* obuffer;
+   M4OSA_Char* nbuffer;
+   M4OSA_Char* buffer;
+   M4OSA_Char* ptr;
+   M4OSA_UInt32 ilength, nlength, olength, length;
+   M4OSA_Int32 i32_pos;
+   M4OSA_ERR err_code;
+
+   M4OSA_TRACE2_4("M4OSA_strPrivReplaceBiggerStr\t\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_strStruct* 0x%x\tM4OSA_strStruct* 0x%x\t"
+                  "M4OSA_strMode %d", istr, ostr, nstr, mode);
+
+   ibuffer = istr->pui8_buffer;
+   obuffer = ostr->pui8_buffer;
+   nbuffer = nstr->pui8_buffer;
+
+   ilength = istr->ui32_length;
+   olength = ostr->ui32_length;
+   nlength = nstr->ui32_length;
+
+
+   if(mode == M4OSA_kstrAll)
+   {
+      M4OSA_UInt32 n=0, i;
+      M4OSA_Int32* patterns;
+      M4OSA_UInt32 pos=0, size;
+      M4OSA_UInt32 max_pattern = ilength / olength;
+      M4OSA_UInt32 ui32_size = istr->ui32_size;
+      M4OSA_Char* src;
+      M4OSA_Char* dest;
+
+      /* Allocate the actual M4OSA_String content */
+      patterns = (M4OSA_Int32*)M4OSA_malloc(max_pattern * sizeof(M4OSA_UInt32),
+                              M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivReplaceBiggerStr");
+
+      M4OSA_CHECK_MALLOC(patterns, (M4OSA_Char*)"M4OSA_strPrivReplaceBiggerStr");
+
+
+      err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr);
+
+      M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code,
+                      "M4OSA_strPrivReplaceBiggerStr");
+
+      if(err_code == M4WAR_CHR_NOT_FOUND)
+      {
+         return M4WAR_STR_NOT_FOUND;
+      }
+
+      do
+      {
+         patterns[n] = (M4OSA_UInt32)ptr - (M4OSA_UInt32)ibuffer;
+
+         n++;
+
+         err_code = M4OSA_chrFindPattern(ptr + olength, obuffer, &ptr);
+
+         M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code,
+                         "M4OSA_strPrivReplaceBiggerStr");
+
+      } while(err_code != M4WAR_CHR_NOT_FOUND);
+
+      length = ilength - (n * olength) + (n * nlength);
+
+
+      if(length >= ui32_size)
+      {
+         do
+         {
+            ui32_size <<= 1;
+
+         } while(length >= ui32_size);
+      }
+
+      /* Allocate the actual M4OSA_String content */
+      buffer = (M4OSA_Char*)M4OSA_malloc(ui32_size * sizeof(M4OSA_Char),
+                            M4OSA_STRING, (M4OSA_Char*)"M4OSA_strPrivReplaceBiggerStr");
+
+      M4OSA_CHECK_MALLOC(buffer, "M4OSA_strPrivReplaceBiggerStr");
+
+      src = ibuffer;
+      dest = buffer;
+
+      for(i=0; i<n; i++)
+      {
+         size = patterns[i] - pos;
+
+         M4OSA_memcpy(dest, src, size);
+
+         pos = patterns[i] + olength;
+
+         src = ibuffer + pos;
+
+         dest += size;
+
+         M4OSA_memcpy(dest, nbuffer, nlength);
+
+         dest += nlength;
+      }
+
+      size = ilength - (M4OSA_UInt32)(src - ibuffer);
+
+      M4OSA_memcpy(dest, src, size);
+
+      M4OSA_free((M4OSA_MemAddr32)patterns);
+
+      M4OSA_free((M4OSA_MemAddr32)ibuffer);
+
+      istr->ui32_length = length;
+
+      istr->pui8_buffer = buffer;
+
+      istr->pui8_buffer[length] = '\0';
+   }
+   else
+   {
+      if(mode == M4OSA_kstrBegin)
+      {
+         err_code = M4OSA_chrFindPattern(ibuffer, obuffer, &ptr);
+
+         M4OSA_DEBUG_IF2(M4OSA_ERR_IS_ERROR(err_code), err_code,
+                      "M4OSA_strPrivReplaceSameSizeStr");
+
+         if(err_code == M4WAR_CHR_NOT_FOUND)
+         {
+            return M4WAR_STR_NOT_FOUND;
+         }
+
+         i32_pos = (M4OSA_UInt32)ptr - (M4OSA_UInt32)ibuffer;
+      }
+      else
+      {
+         i32_pos = M4OSA_strPrivFindLastSubStr(istr, ostr, ilength-1);
+
+         if(i32_pos == -1)
+         {
+            return M4WAR_STR_NOT_FOUND;
+         }
+      }
+
+      err_code = M4OSA_strPrivSetAndRepleceStr(istr, i32_pos, olength,
+                                               nbuffer, nlength);
+
+      if(M4OSA_ERR_IS_ERROR(err_code))
+      {
+         M4OSA_DEBUG(err_code, "M4OSA_strPrivReplaceSmallerStr");
+
+         return err_code;
+      }
+   }
+
+   return M4NO_ERROR;
+}
+
+
+M4OSA_ERR M4OSA_strPrivSPrintf(M4OSA_strStruct* str,
+                               M4OSA_Char *format,
+                               va_list marker)
+{
+    M4OSA_Char *temp;
+    M4OSA_Char *percentPointer;
+    M4OSA_Char *newFormat;
+    M4OSA_Char* strOut = str->pui8_buffer + str->ui32_length;
+    M4OSA_UInt32 strOutMaxLen = str->ui32_size-1;
+    M4OSA_Int32 newFormatLength = 0;
+    M4OSA_UInt32 count_ll = 0;
+    M4OSA_UInt32 count_tm = 0;
+    M4OSA_UInt32 count_aa = 0;
+    M4OSA_UInt32 count;
+    M4OSA_UInt32 nbChar;
+    M4OSA_Int32  iResult;
+
+    M4OSA_Int32 err;
+    M4OSA_Char flagChar[]             = "'-+ #0";
+    M4OSA_Char widthOrPrecisionChar[] = "*0123456789";
+    M4OSA_Char otherPrefixChar[]      = "hlL";
+    M4OSA_Char conversionChar[]       = "diouxXnfeEgGcCsSp%";
+
+    M4OSA_TRACE2_2("M4OSA_strSPrintf\t\tM4OSA_String 0x%x\tM4OSA_Char* 0x%x",
+        str, format);
+
+
+    /* count the number of %[flags][width][.precision]ll[conversion] */
+    temp = format;
+
+    while(*temp)
+    {
+        /* get the next percent character */
+        err = M4OSA_chrFindChar (temp, '%', &percentPointer);
+
+        if((!percentPointer) || (M4WAR_CHR_NOT_FOUND == err))
+        {
+            break;         /* "This is the End", (c) J. Morrisson */
+        }
+
+        temp = percentPointer+1;           /* span it */
+        if(!*temp) /* "This is the End", (c) J. Morrisson */
+        {
+            break;
+        }
+
+        /* span the optional flags */
+        M4OSA_chrSpan(format, conversionChar, &nbChar);
+        temp += nbChar;
+
+        if(!*temp) /* "This is the End", (c) J. Morrisson */
+        {
+            break;
+        }
+
+        /* span the optional width */
+        M4OSA_chrSpan(temp, widthOrPrecisionChar, &nbChar);
+        temp += nbChar;
+        if(!*temp) /* "This is the End", (c) J. Morrisson */
+        {
+            break;
+        }
+
+        if(*temp=='.')
+        {
+            /* span the optional precision */
+            M4OSA_chrSpan(++temp, widthOrPrecisionChar, &nbChar);
+            temp += nbChar;
+        }
+        if(!*temp) /* "This is the End", (c) J. Morrisson */
+        {
+            break;
+        }
+
+        if(M4OSA_chrLength(temp)>=2)
+        {
+
+            M4OSA_chrNCompare(temp, (M4OSA_Char*)"ll",2, &iResult);
+            if (iResult != 0)
+            {
+                count_ll++;                        /* I got ONE */
+                temp +=2;                          /* span the "ll" prefix */
+            }
+            else
+            {
+                M4OSA_chrNCompare(temp, (M4OSA_Char*)"tm",2, &iResult);
+                if (iResult != 0) /* à voir si ce n'est pas == 0 */
+                {
+                    count_tm++;
+                    temp +=2;
+                }
+                else
+                {
+                    M4OSA_chrNCompare(temp, (M4OSA_Char*)"aa",2, &iResult);
+                    if (iResult != 0) /* à voir si ce n'est pas == 0 */
+                    {
+                        count_aa++;
+                        temp +=2;
+                    }
+                }
+            }
+        }
+
+        /* span the other optional prefix */
+        M4OSA_chrSpan(temp, otherPrefixChar, &nbChar);
+        temp += nbChar;
+        if(!*temp) /* "This is the End", (c) J. Morrisson */
+        {
+            break;
+        }
+
+        M4OSA_chrSpan(temp, conversionChar, &nbChar);
+        temp += nbChar;
+        if(!*temp) /* "This is the End", (c) J. Morrisson */
+        {
+            break;
+        }
+
+    }
+
+    count = count_ll + count_tm + count_aa;
+
+    if(!count)
+    {
+        err = M4OSA_chrSPrintf(strOut,strOutMaxLen,format,marker);
+
+        if(M4ERR_CHR_STR_OVERFLOW == err)
+        {
+            return M4ERR_STR_OVERFLOW;
+        }
+
+        return M4NO_ERROR;
+    }
+
+
+    newFormatLength = M4OSA_chrLength(format) + 1;
+
+#ifdef M4OSA_64BITS_SUPPORTED
+#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED
+    newFormatLength += (count_ll+count_tm+count_aa);
+#else
+    newFormatLength += (count_ll+count_tm-count_aa);
+#endif
+#elif defined M4OSA_64BITS_NOT_SUPPORTED
+    newFormatLength -= (count_ll+count_tm+count_aa);
+#else
+    return M4ERR_NOT_IMPLEMENTED;
+#endif
+
+    newFormat =(M4OSA_Char*)M4OSA_malloc(newFormatLength,
+        M4OSA_CHARSTAR, (M4OSA_Char*)"M4OSA_chrPrintf: newFormat");
+    if(newFormat == M4OSA_NULL) return M4ERR_ALLOC;
+    newFormat[newFormatLength-1] = '\0';
+    temp = newFormat;
+    /* copy format to newFormat, replacing
+    %[flags][width][.precision]ll[conversion]
+    by %[flags][width][.precision]I64[conversion] */
+    while(*format)
+    {
+        M4OSA_chrSpanComplement(format, (M4OSA_Char*)"%", &nbChar);
+        if(nbChar)
+        {
+            M4OSA_chrNCopy(temp,format,nbChar);      /* copy characters before the % character */
+            format +=nbChar;
+            temp   +=nbChar;
+        }
+        if(!*format)
+        {
+            break;
+        }
+        *temp++ = *format++;                 /* copy the % character */
+
+        M4OSA_chrSpan(format, flagChar, &nbChar);
+        if(nbChar)
+        {
+            M4OSA_chrNCopy(temp,format,nbChar);      /* copy the flag characters */
+            format +=nbChar;
+            temp   +=nbChar;
+        }
+        if(!*format)
+        {
+            break;
+        }
+
+        M4OSA_chrSpan(format, widthOrPrecisionChar, &nbChar);
+        if(nbChar)
+        {
+            M4OSA_chrNCopy(temp,format,nbChar);      /* copy the width characters */
+            format +=nbChar;
+            temp   +=nbChar;
+        }
+        if(!*format)
+        {
+            break;
+        }
+        if(*format=='.')
+        {
+            *temp++ = *format++;              /* copy the dot character */
+            if(!*format)
+            {
+                break;
+            }
+
+            M4OSA_chrSpan(format, widthOrPrecisionChar, &nbChar);
+            if(nbChar)
+            {
+                M4OSA_chrNCopy(temp,format,nbChar);      /* copy the width characters */
+                format +=nbChar;
+                temp   +=nbChar;
+            }
+            if(!*format)
+            {
+                break;
+            }
+        }
+        if(M4OSA_chrLength(format)>=2)
+        {
+
+            M4OSA_chrNCompare(format, (M4OSA_Char*)"ll",2, &iResult);
+            if (iResult != 0)
+            {
+#ifdef M4OSA_64BITS_SUPPORTED
+                *temp++ = 'I'; /* %I64 */
+                *temp++ = '6';
+                *temp++ = '4';
+#else
+                *temp++ = 'l'; /* %l */
+#endif
+                format +=2;                         /* span the "ll" prefix */
+            }
+            else
+            {
+                M4OSA_chrNCompare(format, (M4OSA_Char*)"tm",2, &iResult);
+                if (iResult != 0)
+                {
+#ifdef M4OSA_64BITS_SUPPORTED
+                *temp++ = 'I'; /* %I64 */
+                *temp++ = '6';
+                *temp++ = '4';
+#else
+                *temp++ = 'l'; /* %l */
+#endif
+                format +=2;                         /* span the "tm" prefix */
+                }
+                else
+                {
+                    M4OSA_chrNCompare(format, (M4OSA_Char*)"aa",2, &iResult);
+                    if (iResult != 0) /* à voir si ce n'est pas != 0 */
+                    {
+#ifdef M4OSA_64BITS_SUPPORTED
+#ifdef M4OSA_FILE_POS_64_BITS_SUPPORTED
+                        *temp++ = 'I'; /* %I64 */
+                        *temp++ = '6';
+                        *temp++ = '4';
+#else
+                        *temp++ = 'l';
+#endif
+#else
+                        *temp++ = 'l';
+#endif
+                        format +=2;                         /* span the "aa" prefix */
+                    }
+                }
+            }
+        }
+
+        M4OSA_chrSpan(format, otherPrefixChar, &nbChar);
+
+        if(nbChar)
+        {
+            M4OSA_chrNCopy(temp,format,nbChar);      /* copy the other Prefix */
+            format +=nbChar;
+            temp   +=nbChar;
+        }
+
+        if(!*format)
+        {
+            break;
+        }
+
+        M4OSA_chrSpan(format, conversionChar, &nbChar);
+        if(nbChar)
+        {
+            M4OSA_chrNCopy(temp,format,nbChar);
+            format += nbChar;
+            temp   += nbChar;
+        }
+
+        if(!*format)
+        {
+            break;
+        }
+   }
+
+    err = M4OSA_chrSPrintf(strOut,strOutMaxLen,newFormat,marker);
+
+   M4OSA_free((M4OSA_MemAddr32)newFormat);
+
+   if (M4ERR_CHR_STR_OVERFLOW == err)
+   {
+       return M4ERR_STR_OVERFLOW;
+   }
+   else
+   {
+       return M4NO_ERROR;
+   }
+}
+
diff --git a/libvideoeditor/osal/src/M4OSA_Thread.c b/libvideoeditor/osal/src/M4OSA_Thread.c
new file mode 100755
index 0000000..c09b82c
--- /dev/null
+++ b/libvideoeditor/osal/src/M4OSA_Thread.c
@@ -0,0 +1,954 @@
+/*
+ * 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_Thread.c
+ * @ingroup      OSAL
+ * @brief        Implements and manipulate threads
+ * @note         This file implements functions to manipulate threads
+ ************************************************************************
+*/
+
+#include <sched.h>
+#include <time.h>
+#include <pthread.h>
+#include <errno.h>
+
+#include <utils/threads.h>
+#include "M4OSA_Debug.h"
+#include "M4OSA_Memory.h"
+#include "M4OSA_Thread.h"
+#include "M4OSA_Thread_priv.h"
+#include "M4OSA_Mutex.h"
+#include "M4OSA_Semaphore.h"
+#include "M4OSA_CharStar.h"
+
+
+void* M4OSA_threadSyncForEverDo(void *context)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+   M4OSA_Bool auto_kill = M4OSA_FALSE;
+
+    /*
+       M4OSA_Void* userData;
+    */
+
+   M4OSA_TRACE2_1("M4OSA_threadSyncForEverDo\t\tLPVOID 0x%x", context);
+
+    /*
+       userData = threadContext->userData;
+    */
+
+   M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+
+   /*if(threadContext->startCallBack != M4OSA_NULL)
+   {
+      threadContext->startCallBack(threadContext, userData);
+   }*/
+
+   threadContext->state = M4OSA_kThreadRunning;
+
+   M4OSA_semaphorePost(threadContext->semStartStop);
+
+   while(threadContext->state == M4OSA_kThreadRunning)
+   {
+      M4OSA_mutexUnlock(threadContext->stateMutex);
+
+      if((threadContext->func(threadContext->param)) != M4NO_ERROR)
+      {
+         M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+
+         if(threadContext->state == M4OSA_kThreadRunning)
+         {
+
+            //PR 2354 - ACO : Suppress stopping state and don't
+            //         unlock mutex before closing the thread
+            threadContext->state = M4OSA_kThreadOpened;
+            M4OSA_mutexUnlock(threadContext->stateMutex);
+            return 0;
+         }
+
+         M4OSA_mutexUnlock(threadContext->stateMutex);
+      }
+
+      M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+   }
+
+
+   M4OSA_semaphorePost(threadContext->semStartStop);
+
+
+   M4OSA_mutexUnlock(threadContext->stateMutex);
+
+
+   return 0;
+}
+
+
+
+
+
+/**
+ ************************************************************************
+  * @brief      This method creates a new thread. After this call the thread is
+ *             identified by its "context". The thread function is provided by
+ *             the "func" parameter. This function creates & allocates a unique
+ *             context. It's the OSAL real time responsibility for managing its
+ *             context. It must be freed by the M4OSA_threadSyncClose function.
+ *             The context parameter will be sent back to any OSAL core thread
+ *             functions to allow retrieving data associated to the opened
+ *             thread.
+ * @note       This function creates the thread, but the thread is not running.
+ * @note       Once the thread is created, the state is M4OSA_kThreadOpened.
+ * @param      context:(OUT) Context of the created thread
+ * @param      func:(IN) "doIt" function pointer to run
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_ALLOC: there is no more available memory
+ * @return     M4ERR_CONTEXT_FAILED: the context creation failed
+  ************************************************************************
+*/
+M4OSA_ERR M4OSA_threadSyncOpen(M4OSA_Context* context,
+                               M4OSA_ThreadDoIt func)
+{
+   M4OSA_ThreadContext* threadContext = M4OSA_NULL;
+   M4OSA_ERR err_code;
+
+   M4OSA_TRACE1_2("M4OSA_threadSyncOpen\t\tM4OSA_Context* 0x%x\t"
+                  "M4OSA_ThreadDoIt 0x%x", context, func);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncOpen");
+
+   M4OSA_DEBUG_IF2(func == M4OSA_NULL,
+                    M4ERR_PARAMETER, "M4OSA_threadSyncOpen");
+
+   *context = M4OSA_NULL;
+
+   threadContext =
+      (M4OSA_ThreadContext*)M4OSA_malloc(sizeof(M4OSA_ThreadContext),
+      M4OSA_THREAD, (M4OSA_Char*)"M4OSA_threadSyncOpen: thread context");
+
+   if(threadContext == M4OSA_NULL)
+   {
+      M4OSA_DEBUG(M4ERR_ALLOC, "M4OSA_threadSyncOpen");
+
+      return M4ERR_ALLOC;
+   }
+
+   threadContext->func = func;
+   threadContext->stackSize = 64 * 1024;
+   threadContext->name = M4OSA_NULL;
+   threadContext->threadID = 0;
+   threadContext->coreID = M4OSA_THREAD;
+/*
+   threadContext->userData = M4OSA_NULL;
+   threadContext->stopCallBack = M4OSA_NULL;
+   threadContext->startCallBack = M4OSA_NULL;
+*/
+   threadContext->state = M4OSA_kThreadOpened;
+   threadContext->priority = M4OSA_kThreadNormalPriority ;
+
+   err_code = M4OSA_mutexOpen(&(threadContext->stateMutex));
+
+   if(M4OSA_ERR_IS_ERROR(err_code))
+   {
+      M4OSA_DEBUG(err_code, "M4OSA_threadSyncOpen: M4OSA_mutexOpen");
+
+      return err_code;
+   }
+
+   err_code = M4OSA_semaphoreOpen(&(threadContext->semStartStop), 0);
+
+   if(M4OSA_ERR_IS_ERROR(err_code))
+   {
+      M4OSA_DEBUG(err_code, "M4OSA_threadSyncOpen: M4OSA_semaphoreOpen");
+
+      return err_code;
+   }
+
+   *context = threadContext;
+
+   return M4NO_ERROR;
+}
+
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method runs a specified thread. The "param" parameter
+ *             allows the application to set a specific parameter to the
+ *             created thread. This parameter will be used as the second one of
+ *             the "M4OSA_ThreadDoIt" function.
+ * @note       This method is a blocking up to the thread is running.
+ *             Before calling this method, the state is M4OSA_kThreadOpened.
+ *             Once the method is called, the state is M4OSA_kThreadStarting.
+ *             Once the thread is running, the state is M4OSA_kThreadRunning.
+ * @note       This method returns immediately. If the "threadStarted" optionID
+ *             is not NULL, the thread will call it before running the doIt
+ *             function.
+ * @param      context:(IN/OUT) Context of the thread
+ * @param      param:(IN) Application data thread parameter
+ * @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_STATE: this function cannot be called now
+ * @return     M4ERR_THREAD_NOT_STARTED: the thread did not start
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_threadSyncStart(M4OSA_Context context,
+                                M4OSA_Void* param)
+{
+   M4OSA_ThreadContext* threadContext =  (M4OSA_ThreadContext*)context;
+   pthread_attr_t     attribute = { 0, 0, 0, 0, 0, 0 };
+   int                min       = 0;
+   int                max       = 0;
+   int                priority  = 0;
+   struct sched_param sched     = { 0 };
+
+   M4OSA_TRACE1_2("M4OSA_threadSyncStart\t\tM4OSA_Context 0x%x\tM4OSA_Void* "
+                  "0x%x", context, param);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncStart");
+
+   M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD,
+                   M4ERR_BAD_CONTEXT, "M4OSA_threadSyncStart");
+
+   M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+
+   if(threadContext->state != M4OSA_kThreadOpened)
+   {
+      M4OSA_mutexUnlock(threadContext->stateMutex);
+
+      M4OSA_DEBUG(M4ERR_STATE, "M4OSA_threadSyncStart");
+
+      return M4ERR_STATE;
+   }
+
+   threadContext->state = M4OSA_kThreadStarting;
+
+   M4OSA_mutexUnlock(threadContext->stateMutex);
+   threadContext->param = param;
+
+   if ( 0 == pthread_attr_init( &attribute ) )
+   {
+      if ( 0 == pthread_attr_setdetachstate( &attribute, PTHREAD_CREATE_DETACHED ) )
+      {
+         if ( 0 == pthread_attr_setstacksize( &attribute, (size_t)threadContext->stackSize ) )
+         {
+            if ( 0 == pthread_attr_setschedpolicy( &attribute, SCHED_OTHER ) )
+            {
+#if 0
+                min = sched_get_priority_min( SCHED_OTHER );
+                max = sched_get_priority_max( SCHED_OTHER );
+
+                switch(threadContext->priority)
+                {
+                case M4OSA_kThreadLowestPriority:
+                    priority = min;
+                    break;
+                case M4OSA_kThreadLowPriority:
+                    priority = min + ( max - min ) / 4;
+                    break;
+                case M4OSA_kThreadNormalPriority:
+                    priority = min + ( max - min ) / 2;
+                    break;
+                case M4OSA_kThreadHighPriority:
+                    priority = max - ( max - min ) / 4;
+                    break;
+                case M4OSA_kThreadHighestPriority:
+                    priority = max;
+                    break;
+                }
+#else
+                /* Tentative patches to handle priorities in a better way : */
+                /* Use Android's predefined priorities (range +19..-20)
+                 *rather than Linux ones (0..99)*/
+
+                /* Get min and max priorities */
+                min = sched_get_priority_min( SCHED_FIFO );
+                max = sched_get_priority_max( SCHED_FIFO );
+
+                M4OSA_TRACE1_2("M4OSA_threadSyncStart MAX=%d MIN=%d", max, min);
+
+                /* tentative modification of the priorities */
+                /* Set the priority based on default android priorities */
+                /* This probably requires some more tuning,
+                 * outcome of this priority settings are not yet satisfactory */
+                /* Implementing thread handling based on Android's thread creation
+                 * helpers might bring some improvement (see threads.h) */
+                switch(threadContext->priority)
+                {
+                case M4OSA_kThreadLowestPriority:
+                    priority = ANDROID_PRIORITY_NORMAL;
+                    break;
+                case M4OSA_kThreadLowPriority:
+                    priority = ANDROID_PRIORITY_DISPLAY;
+                    break;
+                case M4OSA_kThreadNormalPriority:
+                    priority = ANDROID_PRIORITY_URGENT_DISPLAY;
+                    break;
+                case M4OSA_kThreadHighPriority:
+                    priority = ANDROID_PRIORITY_AUDIO;
+                    break;
+                case M4OSA_kThreadHighestPriority:
+                    priority = ANDROID_PRIORITY_URGENT_AUDIO;
+                    break;
+                }
+#endif
+                sched.sched_priority = priority;
+
+                if ( 0 == pthread_attr_setschedparam( &attribute, &sched ) )
+                {
+                    if ( 0 == pthread_create( &threadContext->threadID,
+                                              &attribute,
+                                              &M4OSA_threadSyncForEverDo,
+                                              (void *)threadContext ) )
+                    {
+                        if ( M4OSA_FALSE == M4OSA_ERR_IS_ERROR( M4OSA_semaphoreWait(
+                                                                    threadContext->semStartStop,
+                                                                    M4OSA_WAIT_FOREVER ) ) )
+                        {
+                            return M4NO_ERROR;
+                        }
+                    }
+                }
+            }
+         }
+      }
+      pthread_attr_destroy( &attribute );
+   }
+
+   M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+
+   threadContext->state = M4OSA_kThreadOpened;
+
+   M4OSA_mutexUnlock(threadContext->stateMutex);
+
+   M4OSA_DEBUG(M4ERR_THREAD_NOT_STARTED, "M4OSA_threadSyncStart");
+
+   return M4ERR_THREAD_NOT_STARTED;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method stops a specified thread.
+ * @note       This call is a blocking one up to the "M4OSA_ThreadDoIt"
+ *             function has returned.
+ *             Before the method is called, the state is M4OSA_kThreadRunning.
+ *             Once the method is called, the state is M4OSA_kThreadStopping.
+ *             Once the thread is stopped, the state is M4OSA_kThreadOpened.
+ * @note       This method returns once the thread has been stopped. If the
+ *             "threadStopped" optionID is not NULL, the thread will call it
+ *             before dying.
+ * @param      context:(IN/OUT) Context of the thread
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_STATE: this function cannot be called now
+ * @return     M4ERR_BAD_CONTEXT: provided context is not a valid one
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_threadSyncStop(M4OSA_Context context)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+
+   M4OSA_TRACE1_1("M4OSA_threadSyncStop\t\tM4OSA_Context 0x%x", context);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncStop");
+
+   M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD,
+                   M4ERR_BAD_CONTEXT, "M4OSA_threadSyncStop");
+
+   M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+
+   if(threadContext->state != M4OSA_kThreadRunning)
+   {
+      M4OSA_mutexUnlock(threadContext->stateMutex);
+
+      M4OSA_DEBUG(M4ERR_STATE, "M4OSA_threadSyncStop");
+
+      return M4ERR_STATE;
+   }
+
+   threadContext->state = M4OSA_kThreadStopping;
+
+   M4OSA_mutexUnlock(threadContext->stateMutex);
+
+   M4OSA_semaphoreWait(threadContext->semStartStop, M4OSA_WAIT_FOREVER);
+
+   M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+
+   threadContext->state = M4OSA_kThreadOpened;
+
+   M4OSA_mutexUnlock(threadContext->stateMutex);
+
+   return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method deletes a thread (identified by its context). After
+ *             this call the thread and its context are no more useable. This
+ *             function frees all the memory related to this thread.
+ * @note       Before the method is called, the state is M4OSA_kThreadOpened.
+ *             Once the method is called, the state is M4OSA_kThreadClosed.
+ * @param      context:(IN/OUT) Context of the thread
+ * @return     M4NO_ERROR: there is no error
+ * @return     M4ERR_PARAMETER: at least one parameter is NULL
+ * @return     M4ERR_STATE: this function cannot be called now
+ * @return     M4ERR_BAD_CONTEXT: provided context is not a valid one
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_threadSyncClose(M4OSA_Context context)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+   M4OSA_ERR err_code;
+
+   M4OSA_TRACE1_1("M4OSA_threadSyncClose\t\tM4OSA_Context 0x%x", context);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncClose");
+
+   M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD,
+                   M4ERR_BAD_CONTEXT, "M4OSA_threadSyncClose");
+
+   M4OSA_DEBUG_IF2(threadContext->state == M4OSA_kThreadClosed,
+                   M4ERR_BAD_CONTEXT, "M4OSA_threadSyncClose");
+
+   M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+
+   if(threadContext->state != M4OSA_kThreadOpened)
+   {
+      M4OSA_mutexUnlock(threadContext->stateMutex);
+
+      M4OSA_DEBUG(M4ERR_STATE, "M4OSA_threadSyncClose");
+
+      return M4ERR_STATE;
+   }
+
+   threadContext->state = M4OSA_kThreadClosed;
+
+   M4OSA_mutexUnlock(threadContext->stateMutex);
+
+   err_code = M4OSA_mutexClose(threadContext->stateMutex);
+
+   if(M4OSA_ERR_IS_ERROR(err_code))
+   {
+      M4OSA_DEBUG(err_code, "M4OSA_threadSyncClose: M4OSA_mutexClose");
+
+      return err_code;
+   }
+
+   err_code = M4OSA_semaphoreClose(threadContext->semStartStop);
+
+   if(M4OSA_ERR_IS_ERROR(err_code))
+   {
+      M4OSA_DEBUG(err_code, "M4OSA_threadSyncClose: M4OSA_semaphoreClose");
+
+      return err_code;
+   }
+
+   if(threadContext->name != M4OSA_NULL)
+   {
+      M4OSA_free((M4OSA_MemAddr32)threadContext->name);
+   }
+
+   M4OSA_free((M4OSA_MemAddr32)threadContext);
+
+   return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method asks the thread to return its state.
+ * @note       The caller is responsible for allocating/deallocating the state
+ *             field.
+ * @param      context:(IN) Context of the thread
+ * @param      state:(OUT) Thread state
+ * @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_threadSyncGetState(M4OSA_Context context,
+                                   M4OSA_ThreadState* state)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+
+   M4OSA_TRACE1_2("M4OSA_threadSyncGetState\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_ThreadState* 0x%x", context, state);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncGetState");
+
+   M4OSA_DEBUG_IF2(state == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncGetState");
+
+   M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD,
+                   M4ERR_BAD_CONTEXT, "M4OSA_threadSyncGetState");
+
+   *state = threadContext->state;
+
+   return M4NO_ERROR;
+}
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method asks the calling thread to sleep during "timeSleep"
+ *             milliseconds.
+ * @note       This function does not have any context.
+ * @param      time:(IN) Time to sleep in milliseconds
+ * @return     M4NO_ERROR: there is no error
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_threadSleep(M4OSA_UInt32 time)
+{
+   struct timespec rqtp = { 0, 0 };
+   struct timespec rmtp = { 0, 0 };
+
+   M4OSA_TRACE1_1("M4OSA_threadSleep\t\tM4OSA_UInt32 %d", time);
+
+   rqtp.tv_sec = (time_t)time/1000;
+   rqtp.tv_nsec = (time%1000) * 1000000;
+   nanosleep(&rqtp, &rmtp);
+
+   return M4NO_ERROR;
+}
+
+
+
+
+#if(M4OSA_OPTIONID_THREAD_STARTED == M4OSA_TRUE)
+
+/*M4OSA_ERR M4OSA_SetThreadSyncStarted(M4OSA_Context context,
+                                 M4OSA_DataOption optionValue)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context ;
+
+   M4OSA_TRACE2_2("M4OSA_SetThreadSyncStarted\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_DataOption 0x%x", context, optionValue);
+
+   threadContext->startCallBack = (M4OSA_ThreadCallBack)optionValue;
+
+   return M4NO_ERROR;
+}*/
+
+#endif /*M4OSA_OPTIONID_THREAD_STARTED*/
+
+
+
+
+#if(M4OSA_OPTIONID_THREAD_STOPPED == M4OSA_TRUE)
+
+/*M4OSA_ERR M4OSA_SetThreadSyncStopped(M4OSA_Context context,
+                                 M4OSA_DataOption optionValue)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+
+   M4OSA_TRACE2_2("M4OSA_SetThreadSyncStopped\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_DataOption 0x%x", context, optionValue);
+
+   threadContext->stopCallBack = (M4OSA_ThreadCallBack)optionValue;
+
+   return M4NO_ERROR;
+}*/
+
+#endif /*M4OSA_OPTIONID_THREAD_STOPPED*/
+
+
+
+#if(M4OSA_OPTIONID_THREAD_PRIORITY == M4OSA_TRUE)
+
+M4OSA_ERR M4OSA_SetThreadSyncPriority(M4OSA_Context context,
+                                  M4OSA_DataOption optionValue)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+   M4OSA_ThreadPriorityLevel priority
+                                 = (M4OSA_ThreadPriorityLevel)(optionValue);
+
+   M4OSA_TRACE2_2("M4OSA_SetThreadSyncPriority\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_DataOption 0x%x", context, optionValue);
+
+   if((M4OSA_UInt32)optionValue>M4OSA_kThreadLowestPriority)
+   {
+      return M4ERR_PARAMETER;
+   }
+
+   threadContext->priority = priority;
+
+   return M4NO_ERROR;
+}
+
+#endif /*M4OSA_OPTIONID_THREAD_PRIORITY*/
+
+
+
+
+#if(M4OSA_OPTIONID_THREAD_NAME == M4OSA_TRUE)
+
+M4OSA_ERR M4OSA_SetThreadSyncName(M4OSA_Context context,
+                              M4OSA_DataOption optionValue)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+   M4OSA_Char* name = (M4OSA_Char*)optionValue;
+   M4OSA_UInt32 nameSize ;
+
+   M4OSA_TRACE2_2("M4OSA_SetThreadSyncName\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_DataOption 0x%x", context, optionValue);
+
+   if(threadContext->name != NULL)
+   {
+      M4OSA_free((M4OSA_MemAddr32)threadContext->name);
+      threadContext->name = M4OSA_NULL;
+   }
+
+   if(optionValue != M4OSA_NULL)
+   {
+      nameSize = M4OSA_chrLength(name)+1;
+
+      threadContext->name =
+         (M4OSA_Char*)M4OSA_malloc(nameSize, M4OSA_THREAD,
+         (M4OSA_Char*)"M4OSA_SetThreadSyncName: thread name");
+
+      if(threadContext == M4OSA_NULL)
+      {
+         return M4ERR_ALLOC;
+      }
+
+      M4OSA_memcpy((M4OSA_MemAddr8)threadContext->name, (M4OSA_MemAddr8)name,
+                   nameSize);
+   }
+
+   return M4NO_ERROR;
+}
+
+#endif /*M4OSA_OPTIONID_THREAD_NAME*/
+
+
+#if(M4OSA_OPTIONID_THREAD_STACK_SIZE == M4OSA_TRUE)
+
+M4OSA_ERR M4OSA_SetThreadSyncStackSize(M4OSA_Context context,
+                                   M4OSA_DataOption optionValue)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+
+   M4OSA_TRACE2_2("M4OSA_SetThreadSyncStackSize\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_DataOption 0x%x", context, optionValue);
+
+   threadContext->stackSize = (M4OSA_UInt32)optionValue;
+
+   return M4NO_ERROR;
+}
+
+#endif /*M4OSA_OPTIONID_THREAD_STACK_SIZE*/
+
+
+
+#if(M4OSA_OPTIONID_THREAD_USER_DATA == M4OSA_TRUE)
+
+/*M4OSA_ERR M4OSA_SetThreadSyncUserData(M4OSA_Context context,
+                                  M4OSA_DataOption optionValue)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+
+   M4OSA_TRACE2_2("M4OSA_SetThreadSyncUserData\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_DataOption 0x%x", context, optionValue);
+
+   threadContext->userData = (M4OSA_Void*)optionValue;
+
+   return M4NO_ERROR;
+}*/
+
+#endif /*M4OSA_OPTIONID_THREAD_USER_DATA*/
+
+
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method asks the core OSAL-Thread component to set the value
+ *             associated with the optionID. The caller is responsible for
+ *             allocating/deallocating the memory of the value field.
+ * @note       As the caller is responsible of allocating/de-allocating the
+ *             "value" field, the callee must copy this field to its internal
+ *             variable.
+ * @param      context:(IN/OUT) Context of the thread
+ * @param      optionID:(IN) ID of the option
+ * @param      optionValue:(IN) Value of the option
+ * @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_BAD_OPTION_ID: the optionID is not a valid one
+ * @return     M4ERR_STATE: this option is not available now
+ * @return     M4ERR_READ_ONLY: this option is a read only one
+ * @return     M4ERR_NOT_IMPLEMENTED: this option is not implemented
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_threadSyncSetOption(M4OSA_Context context,
+                                    M4OSA_ThreadOptionID optionID,
+                                    M4OSA_DataOption optionValue)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+   M4OSA_ERR err_code;
+
+   M4OSA_TRACE1_3("M4OSA_threadSyncSetOption\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_OptionID %d\tM4OSA_DataOption 0x%x",
+                  context, optionID, optionValue);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncSetOption");
+
+   M4OSA_DEBUG_IF2(optionID == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncSetOption");
+
+   M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD,
+                   M4ERR_BAD_CONTEXT, "M4OSA_threadSyncSetOption");
+
+   M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_COREID(optionID, M4OSA_THREAD),
+                   M4ERR_BAD_OPTION_ID, "M4OSA_threadSyncSetOption");
+
+   M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_WRITABLE(optionID),
+                   M4ERR_READ_ONLY, "M4OSA_threadSyncSetOption");
+
+
+   M4OSA_mutexLock(threadContext->stateMutex, M4OSA_WAIT_FOREVER);
+
+   if(threadContext->state != M4OSA_kThreadOpened)
+   {
+      M4OSA_mutexUnlock(threadContext->stateMutex);
+
+      M4OSA_DEBUG(M4ERR_STATE, "M4OSA_threadSyncSetOption");
+
+      return M4ERR_STATE;
+   }
+
+   switch(optionID)
+   {
+#if(M4OSA_OPTIONID_THREAD_STARTED == M4OSA_TRUE)
+      /*case M4OSA_ThreadStarted:
+      {
+         err_code = M4OSA_SetThreadSyncStarted(context, optionValue);
+
+         break;
+      }*/
+#endif /*M4OSA_OPTIONID_THREAD_STARTED*/
+
+#if(M4OSA_OPTIONID_THREAD_STOPPED == M4OSA_TRUE)
+      /*case M4OSA_ThreadStopped:
+      {
+         err_code = M4OSA_SetThreadSyncStopped(context, optionValue);
+
+         break;
+      }*/
+#endif /*M4OSA_OPTIONID_THREAD_STOPPED*/
+
+#if(M4OSA_OPTIONID_THREAD_USER_DATA == M4OSA_TRUE)
+      /*case M4OSA_ThreadUserData:
+      {
+         err_code = M4OSA_SetThreadSyncUserData(context, optionValue);
+
+         break;
+      }*/
+#endif /*M4OSA_OPTIONID_THREAD_USER_DATA*/
+
+#if(M4OSA_OPTIONID_THREAD_PRIORITY == M4OSA_TRUE)
+      case M4OSA_ThreadPriority:
+      {
+         err_code = M4OSA_SetThreadSyncPriority(context, optionValue);
+
+         break;
+      }
+#endif /*M4OSA_OPTIONID_THREAD_PRIORITY*/
+
+#if(M4OSA_OPTIONID_THREAD_NAME == M4OSA_TRUE)
+      case M4OSA_ThreadName:
+      {
+         err_code = M4OSA_SetThreadSyncName(context, optionValue);
+
+         break;
+      }
+#endif /*M4OSA_OPTIONID_THREAD_NAME*/
+
+#if(M4OSA_OPTIONID_THREAD_STACK_SIZE == M4OSA_TRUE)
+      case M4OSA_ThreadStackSize:
+      {
+         err_code = M4OSA_SetThreadSyncStackSize(context, optionValue);
+
+         break;
+      }
+#endif /*M4OSA_OPTIONID_THREAD_STACK_SIZE*/
+
+      default:
+      {
+         M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_threadSyncSetOption");
+
+         err_code = M4ERR_NOT_IMPLEMENTED;
+      }
+   }
+
+   M4OSA_mutexUnlock(threadContext->stateMutex);
+
+   return err_code;
+}
+
+
+
+/**
+ ************************************************************************
+ * @brief      This method asks the OSAL-Thread to return the value associated
+ *             with the optionID. The caller is responsible for
+ *             allocating/deallocating the memory of the value field.
+ * @note       "optionValue" must be cast according to the type related to the
+ *             optionID.
+ * @note       As the caller is responsible for de-allocating the "value"
+ *             field, the core OSAL-Thread component must perform a copy of its
+ *             internal value to the value field.
+ * @param      context:(IN) Context of the thread
+ * @param      optionID:(IN) ID of the option
+ * @param      optionValue:(OUT) Value of the option
+ * @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_BAD_OPTION_ID: the optionID is not a valid one
+ * @return     M4ERR_WRITE_ONLY: this option is a write only one
+ * @return     M4ERR_NOT_IMPLEMENTED: this option is not implemented
+ ************************************************************************
+*/
+M4OSA_ERR M4OSA_threadSyncGetOption(M4OSA_Context context,
+                                    M4OSA_ThreadOptionID optionID,
+                                    M4OSA_DataOption* optionValue)
+{
+   M4OSA_ThreadContext* threadContext = (M4OSA_ThreadContext*)context;
+
+   M4OSA_TRACE1_3("M4OSA_threadSyncGetOption\t\tM4OSA_Context 0x%x\t"
+                  "M4OSA_OptionID %d\tM4OSA_DataOption* 0x%x",
+                  context, optionID, optionValue);
+
+   M4OSA_DEBUG_IF2(context == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncGetOption");
+
+   M4OSA_DEBUG_IF2(optionID == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncGetOption");
+
+   M4OSA_DEBUG_IF2(optionValue == M4OSA_NULL,
+                   M4ERR_PARAMETER, "M4OSA_threadSyncGetOption");
+
+   M4OSA_DEBUG_IF2(threadContext->coreID != M4OSA_THREAD,
+                   M4ERR_BAD_CONTEXT, "M4OSA_threadSyncGetOption");
+
+   M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_COREID(optionID, M4OSA_THREAD),
+                   M4ERR_BAD_OPTION_ID, "M4OSA_threadSyncGetOption");
+
+   M4OSA_DEBUG_IF2(!M4OSA_OPTION_ID_IS_READABLE(optionID),
+                   M4ERR_WRITE_ONLY, "M4OSA_threadSyncGetOption");
+
+   switch(optionID)
+   {
+#if(M4OSA_OPTIONID_THREAD_STARTED == M4OSA_TRUE)
+      /*case M4OSA_ThreadStarted:
+      {
+         M4OSA_ThreadCallBack* startCallBack = (M4OSA_ThreadCallBack*)optionValue;
+
+         *startCallBack = threadContext->startCallBack;
+
+         return M4NO_ERROR;
+      }*/
+#endif /*M4OSA_OPTIONID_THREAD_STARTED*/
+
+#if(M4OSA_OPTIONID_THREAD_STOPPED == M4OSA_TRUE)
+      /*case M4OSA_ThreadStopped:
+      {
+         M4OSA_ThreadCallBack* stopCallBack = (M4OSA_ThreadCallBack*)optionValue;
+
+         *stopCallBack = threadContext->stopCallBack;
+
+         return M4NO_ERROR;
+      }*/
+#endif /*M4OSA_OPTIONID_THREAD_STOPPED*/
+
+#if(M4OSA_OPTIONID_THREAD_USER_DATA == M4OSA_TRUE)
+      /*case M4OSA_ThreadUserData:
+      {
+         M4OSA_Void** userData = (M4OSA_Void**)optionValue;
+
+         *userData = threadContext->userData;
+
+         return M4NO_ERROR;
+      }*/
+#endif /*M4OSA_OPTIONID_THREAD_USER_DATA*/
+
+#if(M4OSA_OPTIONID_THREAD_PRIORITY == M4OSA_TRUE)
+      case M4OSA_ThreadPriority:
+      {
+         M4OSA_ThreadPriorityLevel* priority =
+                                    (M4OSA_ThreadPriorityLevel*)optionValue;
+
+         *priority = threadContext->priority;
+
+         return M4NO_ERROR;
+      }
+#endif /*M4OSA_OPTIONID_THREAD_PRIORITY*/
+
+#if(M4OSA_OPTIONID_THREAD_NAME == M4OSA_TRUE)
+      case M4OSA_ThreadName:
+      {
+         M4OSA_Char** name = (M4OSA_Char**)optionValue;
+
+         *name = threadContext->name;
+
+         return M4NO_ERROR;
+      }
+#endif /*M4OSA_OPTIONID_THREAD_NAME*/
+
+#if(M4OSA_OPTIONID_THREAD_STACK_SIZE == M4OSA_TRUE)
+      case M4OSA_ThreadStackSize:
+      {
+         M4OSA_UInt32* stackSize = (M4OSA_UInt32*)optionValue;
+
+         *stackSize = threadContext->stackSize;
+
+         return M4NO_ERROR;
+      }
+#endif /*M4OSA_OPTIONID_THREAD_STACK_SIZE*/
+
+      default:
+        break;
+   }
+
+   M4OSA_DEBUG(M4ERR_NOT_IMPLEMENTED, "M4OSA_threadSyncGetOption");
+
+   return M4ERR_NOT_IMPLEMENTED;
+}
+
diff --git a/libvideoeditor/osal/src/M4PSW_DebugTrace.c b/libvideoeditor/osal/src/M4PSW_DebugTrace.c
new file mode 100755
index 0000000..71a6a06
--- /dev/null
+++ b/libvideoeditor/osal/src/M4PSW_DebugTrace.c
@@ -0,0 +1,85 @@
+/*
+ * 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       M4PSW_DebugTrace.c
+ * @brief      Default trace function for debugging macros
+ * @note       This file gives the default implementation of the trace function
+ *             used in the debug instrumentation macros, based on printf.
+ *             Application writers are strongly encouraged to implement their
+ *             own "M4OSA_DebugTrace".
+ ************************************************************************
+*/
+
+
+#include <stdio.h> /*for printf */
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Error.h"
+
+/*#define NO_FILE */ /* suppresses the file name print out */
+
+
+/**
+ ************************************************************************
+ * void M4OSA_DebugTrace(M4OSA_Int32 line, char* file, M4OSA_Int32 level,
+ *                       M4OSA_Char* cond, char* msg, M4OSA_ERR err)
+ * @brief    This function implements the trace for debug tests
+ * @note    This function is to be called in the debug macros only.
+ *            This implementation uses printf.
+ * @param    line (IN): the line number in the source file
+ * @param    file (IN): the source file name
+ * @param    level (IN): the debug level
+ * @param    msg (IN): the error message
+ * @param    err (IN): the return value (error code)
+ * @return    none
+ ************************************************************************
+*/
+
+M4OSAL_TRACE_EXPORT_TYPE void M4OSA_DebugTrace(M4OSA_Int32 line,
+                                               M4OSA_Char* file,
+                                               M4OSA_Int32 level,
+                                               M4OSA_Char* cond,
+                                               M4OSA_Char* msg,
+                                               M4OSA_ERR err)
+{
+    M4OSA_Int32 i;
+
+    /* try to "indent" the resulting traces depending on the level */
+    for (i =0 ; i < level; i ++)
+    {
+        printf(" ");
+    }
+
+#ifdef NO_FILE
+    printf("Error: %li, on %s: %s\n",err,cond,msg);
+#else /* NO_FILE     */
+    printf("Error: %li, on %s: %s Line %lu in: %s\n",err,cond,msg,line,file);
+#endif /* NO_FILE     */
+
+}
+
+M4OSAL_TRACE_EXPORT_TYPE M4OSA_Void M4OSA_DEBUG_traceFunction(M4OSA_UInt32 line,
+                                                              M4OSA_Char* fileName,
+                                                              M4OSA_UInt32 level,
+                                                              M4OSA_Char* stringCondition,
+                                                              M4OSA_Char* message,
+                                                              M4OSA_ERR returnedError)
+{
+    M4OSA_DebugTrace(line, fileName, level, stringCondition, message, returnedError);
+}
+
diff --git a/libvideoeditor/osal/src/M4PSW_MemoryInterface.c b/libvideoeditor/osal/src/M4PSW_MemoryInterface.c
new file mode 100755
index 0000000..1dd4d3a
--- /dev/null
+++ b/libvideoeditor/osal/src/M4PSW_MemoryInterface.c
@@ -0,0 +1,183 @@
+/*
+ * 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   M4PSW_MemoryInterface.c
+ * @brief  Memory Interface
+ * @note   Implementation of the osal memory functions
+ *************************************************************************
+*/
+
+#include <stdlib.h>
+#include <memory.h>
+
+#include <time.h>
+#include "M4OSA_Memory.h"
+#ifndef M4VPS_ADVANCED_MEMORY_MANAGER
+/**
+ ************************************************************************
+ * @fn         M4OSA_MemAddr32 M4OSA_malloc(M4OSA_UInt32 size,
+ *                                          M4OSA_CoreID coreID,
+ *                                          M4OSA_Char* string)
+ * @brief      this function allocates a memory block (at least 32 bits aligned)
+ * @note
+ * @param      size (IN): size of allocated block in bytes
+ * @param      coreID (IN): identification of the caller component
+ * @param      string (IN): description of the allocated block (null terminated)
+ * @return     address of the allocated block, M4OSA_NULL if no memory available
+ ************************************************************************
+*/
+
+M4OSA_MemAddr32 M4OSA_malloc(M4OSA_UInt32 size,
+                             M4OSA_CoreID coreID,
+                             M4OSA_Char* string)
+{
+    M4OSA_MemAddr32 Address = M4OSA_NULL;
+
+    /**
+     * If size is 0, malloc on WIN OS allocates a zero-length item in
+     * the heap and returns a valid pointer to that item.
+     * On other platforms, malloc could returns an invalid pointer
+     * So, DON'T allocate memory of 0 byte */
+    if (size == 0)
+    {
+        return Address;
+    }
+
+    if (size%4 != 0)
+    {
+        size = size + 4 - (size%4);
+    }
+
+    Address = (M4OSA_MemAddr32) malloc(size);
+
+    return Address;
+}
+
+
+/**
+ ************************************************************************
+ * @fn         M4OSA_Void M4OSA_free(M4OSA_MemAddr32 address)
+ * @brief      this function free the provided memory block
+ * @note       As in stlib.h, this function does nothing if address is NULL.
+ * @param      address (IN): address of the block to free
+ * @return     none
+ ************************************************************************
+*/
+
+M4OSA_Void M4OSA_free (M4OSA_MemAddr32 address)
+{
+    free(address);
+}
+
+
+/**
+ ************************************************************************
+ * @fn         M4OSA_Void M4OSA_memset(M4OSA_MemAddr8 block,
+ *                                     M4OSA_UInt32 size,
+ *                                     M4OSA_UInt8 value)
+ * @brief      this function initializes the provided memory block with value
+ * @note
+ * @param      block (IN): address of block to fill
+ * @param      size  (IN): size of the provided block
+ * @param      value (IN): value used for initialization
+ * @return     none
+ ************************************************************************
+*/
+
+M4OSA_Void M4OSA_memset(M4OSA_MemAddr8 block,
+                        M4OSA_UInt32 size,
+                        M4OSA_UInt8 value)
+{
+    memset((void*)block, value, size);
+}
+
+
+/**
+ ************************************************************************
+ * @fn         M4OSA_Void M4OSA_memcpy(M4OSA_MemAddr8 outputBlock,
+ *                                     M4OSA_MemAddr8 inputBlock,
+ *                                     M4OSA_UInt32 size)
+ * @brief      this function copies 'size' bytes from inputBlock to outputBlock
+ * @note
+ * @param      outputBlock (IN): address of block to fill
+ * @param      inputBlock  (IN): address of the input block
+ * @param      size (IN): size of the block to copy (in bytes)
+ * @return     none
+ ************************************************************************
+*/
+
+M4OSA_Void M4OSA_memcpy(M4OSA_MemAddr8 outputBlock,
+                        M4OSA_MemAddr8 inputBlock,
+                        M4OSA_UInt32 size)
+{
+    memcpy((void*)outputBlock, (void*)inputBlock,  size);
+}
+
+/**
+ ************************************************************************
+ * @fn         M4OSA_MemAddr8 M4OSA_memmove(M4OSA_MemAddr8 outputBlock, M4OSA_MemAddr8 inputBlock, M4OSA_UInt32 size)
+ * @brief      this function moves 'size' bytes from inputBlock to outputBlock
+ *               unlike M4OSA_memcpy, the two buffers can have an overlap.
+ * @note       increment memcpy byte number (François VALETTE)
+ * @param      outputBlock (IN): address of block to fill
+ * @param      inputBlock  (IN): address of the input block
+ * @param      size (IN): size of the block to copy (in bytes)
+ * @return     address of the output block, i.e. the first parameter
+ ************************************************************************
+*/
+M4OSA_MemAddr8 M4OSA_memmove(M4OSA_MemAddr8 outputBlock,
+                         M4OSA_MemAddr8 inputBlock,
+                         M4OSA_UInt32 size)
+{
+   return memmove((void*)outputBlock, (void*)inputBlock,  size);
+}
+
+/**
+ ************************************************************************
+ * @fn         M4OSA_Int32 M4OSA_memcmp(M4OSA_MemAddr8 address1, M4OSA_MemAddr8 address2, M4OSA_UInt32 size)
+ * @brief      this function compares the first 'size' bytes of address1 and
+               'address2' and return a value indicating their relationship.
+ * @note
+ * @param      address1 (IN): memory address 1
+ * @param      address2 (IN): memory address 2
+ * @param      size (IN): size of the block to compare (in bytes)
+ * @return     +1, if first bytes of adress1 are smaller than those of address2
+ * @return      0, if both blocks are identical
+ * @return    -1, if first bytes of address1 are bigger than those of address2
+ ************************************************************************
+*/
+
+M4OSA_Int32 M4OSA_memcmp(M4OSA_MemAddr8 address1,
+                         M4OSA_MemAddr8 address2,
+                         M4OSA_UInt32 size)
+{
+    M4OSA_Int32 i32_result = memcmp(address1, address2, size);
+    if (i32_result > 0) {
+        return 1;
+    }
+    else if (i32_result < 0) {
+        return((M4OSA_Int32)-1);
+    }
+    return 0;
+}
+
+
+
+
+#endif
+
diff --git a/libvideoeditor/osal/src/M4PSW_Trace.c b/libvideoeditor/osal/src/M4PSW_Trace.c
new file mode 100755
index 0000000..ef39d82
--- /dev/null
+++ b/libvideoeditor/osal/src/M4PSW_Trace.c
@@ -0,0 +1,99 @@
+/*
+ * 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        M4PSW_Trace.c
+ * @brief        Trace function for trace macros
+ * @note        This file gives the implementation of the trace function used
+ *                in the trace instrumentation macros
+ ************************************************************************
+*/
+
+
+#include <stdio.h> /*for printf */
+#include <stdarg.h> /* ANSI C macros and defs for variable args */
+#include "utils/Log.h"
+
+#include "M4OSA_Types.h"
+#include "M4OSA_Debug.h"
+
+#define NO_FILE /* suppresses the file name print out */
+
+#define MAX_STRING_SIZE 1024
+
+/**
+ ************************************************************************
+ * void M4OSA_Trace(M4OSA_Int32 line, M4OSA_Char* file ,M4OSA_Int32 level,
+ *                                                      M4OSA_Char* format, ...)
+ * @brief    This function implements the trace for debug tests
+ * @note    This implementation uses printf. First the variables are retrieved using
+ *            ANSI C defs and macros which enable to access a variable number of arguments.
+ *            Then the printf is done (with some ornemental adds).
+ * @param    level (IN): the debug level
+ * @param    format (IN): the "printf" formated string
+ * @param    ... (IN): as many parameters as required ...
+ * @return    none
+ ************************************************************************
+*/
+
+M4OSAL_TRACE_EXPORT_TYPE void M4OSA_Trace(M4OSA_Int32 line, M4OSA_Char* file ,
+                                     M4OSA_Int32 level, M4OSA_Char* format, ...)
+{
+    M4OSA_Char message[MAX_STRING_SIZE];
+    M4OSA_Int32 i;
+    va_list marker; /* pointer to list of arguments */
+
+    /* get the var arguments into the string message to be able to print */
+    va_start(marker,format); /* set ptr to first argument in the list of arguments passed to the function */
+    vsprintf((char *)message, (const char *)format,marker );  /* formats and writes the data into message */
+    va_end(marker); /* reset pointer to NULL */
+
+    /* do the actual print */
+#ifdef NO_FILE
+    __android_log_print(ANDROID_LOG_INFO, "LifeVibesTrace", "%s", (char*)message);
+#else /* NO_FILE     */
+    __android_log_print(ANDROID_LOG_INFO, "LifeVibesTrace", "%s", "%s at %lu in %s",
+                                                   (char *)message, line, file);
+#endif /* NO_FILE     */
+
+}
+
+M4OSAL_TRACE_EXPORT_TYPE M4OSA_Void M4OSA_TRACE_traceFunction(M4OSA_UInt32 line,
+                                                              M4OSA_Char* fileName,
+                                                              M4OSA_CoreID coreID,
+                                                              M4OSA_UInt32 level,
+                                                              M4OSA_Char* stringMsg, ...)
+{
+    M4OSA_Char message[MAX_STRING_SIZE];
+    M4OSA_Int32 i;
+    va_list marker; /* pointer to list of arguments */
+
+    /* get the var arguments into the string message to be able to print */
+    va_start(marker,stringMsg); /* set ptr to first argument in the list of arguments passed to the function */
+    vsprintf((char *)message, (const char *)stringMsg,marker );  /* formats and writes the data into message */
+    va_end(marker); /* reset pointer to NULL */
+
+    /* do the actual print */
+#ifdef NO_FILE
+    __android_log_print(ANDROID_LOG_INFO, "LifeVibesTrace", "%s", (char*)message);
+#else /* NO_FILE     */
+    __android_log_print(ANDROID_LOG_INFO, "LifeVibesTrace", "%s", "%s at %lu in %s",
+                                            (char *)message, line, (char*)file);
+#endif /* NO_FILE     */
+
+}
+