Fix for issue 3385135 "source code cleanup" engine part

- Removed below unused functions
    a. M4PTO3GPP_RegisterExternalVideoEncoder
    b. M4VSS3GPP_editRegisterExternalVideoDecoder
    c. M4VSS3GPP_editRegisterExternalVideoEncoder
    d. M4VSS3GPP_extractPictureRegisterExternalVideoDecoder
    e. M4VSS3GPP_editRegisterExternalCodec
    f. M4VSS3GPP_editSubscribeExternalCodecs
    g. M4VSS3GPP_intSubscribeExternalCodecs
    h. M4VSS3GPP_intClipRegisterExternalVideoDecoder
    i. M4xVSS_RegisterExternalVideoDecoder
    j. M4xVSS_RegisterExternalVideoEncoder
    k. M4MCS_registerExternalVideoDecoder
    l. M4MCS_registerExternalVideoEncoder
    m. M4MCS_registerExternalAudioDecoder
    n. M4MCS_registerExternalAudioEncoder
    o. M4DECODER_EXTERNAL_getInterface

- Also remove small code associated with these functions and Remove below unsused src + header files
    a. M4CLOCK.h
    b. M4MDP_API.h
    c. M4VD_EXTERNAL_Internal.h
    d. M4VD_HW_API.h
    e. M4VE_API.h
    f. M4_Logo.h
    g. M4VD_EXTERNAL_Interface.c
    h. LV_Types.h
    i. M4OSA_FileAccess.h
    j. M4OSA_FileCache.h
    k. M4OSA_FileExtra.h
    l. M4OSA_FileReaderRam.h
    m. M4OSA_FileWriterRam.h
    n. M4OSA_String.h
    o. M4OSA_String_priv.h
    p. M4OSA_FileCache.c
    q. M4OSA_FileExtra.c
    r. M4OSA_FileReader_RAM.c
    s. M4OSA_FileWriter_RAM.c
    t. M4OSA_String.c
    u. M4OSA_String_priv.c

Change-Id: I7271cbe92168e665a8e5b7afe7c7fe1c331eaa1e

27 files changed, 6 insertions, 5275 deletions

diff --git a/libvideoeditor/vss/common/inc/M4CLOCK.h b/libvideoeditor/vss/common/inc/M4CLOCK.h
deleted file mode 100755
index 963b135..0000000
--- a/libvideoeditor/vss/common/inc/M4CLOCK.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * 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   M4CLOCK.h
- * @brief  Clock and sleep functions types
- *
-*************************************************************************
-*/
-#ifndef __M4CLOCK_H__
-#define __M4CLOCK_H__
-
-#include "M4OSA_Types.h"
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/**
- * Type of a function that returns time.
- */
-typedef M4OSA_Double    (*M4CLOCK_getTime_fct) ( M4OSA_Void* pContext ) ;
-
-/**
- * Type of a function that suspends a task for a certain amount of time.
- */
-typedef M4OSA_Void        (*M4CLOCK_sleep_fct)    ( M4OSA_Void* pContext,\
-                                                     M4OSA_UInt32 durationInMs ) ;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __M4CLOCK_H__ */
-
diff --git a/libvideoeditor/vss/common/inc/M4ENCODER_AudioCommon.h b/libvideoeditor/vss/common/inc/M4ENCODER_AudioCommon.h
index 1386c8c..f63bcfe 100755
--- a/libvideoeditor/vss/common/inc/M4ENCODER_AudioCommon.h
+++ b/libvideoeditor/vss/common/inc/M4ENCODER_AudioCommon.h
@@ -29,6 +29,7 @@ extern "C" {
 #endif /* __cplusplus */
 
 #include "M4OSA_OptionID.h"     /* for M4OSA_OPTION_ID_CREATE() */
+#include "M4OSA_CoreID.h"
 
 #define M4ENCODER_AUDIO_NB_CHANNELS_MAX 2
 /* WARNING: this value must be equal to the number of samples grabbed */
@@ -45,7 +46,7 @@ extern "C" {
 typedef enum
 {
  /* Maximum generated AU size */
-    M4ENCODER_Audio_maxAUsize     = M4OSA_OPTION_ID_CREATE(M4_READ,      M4ENCODER_AUDIO, 0x01)
+    M4ENCODER_Audio_maxAUsize     = M4OSA_OPTION_ID_CREATE(M4_READ,M4ENCODER_AUDIO, 0x01)
 
 } M4ENCODER_Audio_OptionID;
 
diff --git a/libvideoeditor/vss/common/inc/M4MDP_API.h b/libvideoeditor/vss/common/inc/M4MDP_API.h
deleted file mode 100755
index 1000cd8..0000000
--- a/libvideoeditor/vss/common/inc/M4MDP_API.h
+++ /dev/null
@@ -1,430 +0,0 @@
-/*
- * 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   M4MDP_API.h
- * @brief  Parser of metadata
- *
-*************************************************************************
-*/
-
-#ifndef __M4MDP_API_H__
-#define __M4MDP_API_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define MD4MDP_close M4MDP_close
-
-#include "M4READER_Common.h"
-#include "M4TOOL_VersionInfo.h"
-#include "M4OSA_FileReader.h"
-#include "M4OSA_FileWriter.h"
-
-/*define the buffer size for content detection*/
-#define M4MDP_INPUT_BUFFER_SIZE    8192
-
-/**
- ************************************************************************
- * Public type of the M4MDP_osaFilePtrSt
- ************************************************************************
-*/
-typedef struct
-{
-    M4OSA_FileReadPointer*     m_pFileReaderFcts;
-    M4OSA_FileWriterPointer* m_pFileWriterFcts;
-} M4MDP_osaFilePtrSt;
-
-/**
- ************************************************************************
- * Public type of the MDP execution context
- ************************************************************************
-*/
-typedef M4OSA_Void* M4MDP_Context;
-
-/**
- ************************************************************************
- * Metadata Parser Errors & Warnings definition
- ************************************************************************
-*/
-#define M4WAR_MDP_MEDIATYPE_NOT_DETECTED        M4OSA_ERR_CREATE(M4_WAR, M4MDP, 0x000001)
-
-#define    M4ERR_MDP_FATAL                            M4OSA_ERR_CREATE(M4_ERR, M4MDP, 0x000000)
-#define    M4ERR_MDP_UNSUPPORTED_TAG_VERSION        M4OSA_ERR_CREATE(M4_ERR, M4MDP, 0x000001)
-#define    M4ERR_MDP_UNSUPPORTED_ENCODING_TYPE        M4OSA_ERR_CREATE(M4_ERR, M4MDP, 0x000002)
-#define    M4ERR_MDP_INIT_FAILED                    M4OSA_ERR_CREATE(M4_ERR, M4MDP, 0x000003)
-#define    M4ERR_MDP_ASSET_PARSING_ERROR            M4OSA_ERR_CREATE(M4_ERR, M4MDP, 0x000004)
-#define M4ERR_MDP_FILE_NOT_FOUND                M4OSA_ERR_CREATE(M4_ERR, M4MDP, 0x000005)
-#define M4ERR_MDP_INVALID_PATH                    M4OSA_ERR_CREATE(M4_ERR, M4MDP, 0x000006)
-
-/**
- ************************************************************************
- * Metadata parser FUNCTIONS
- ************************************************************************
-*/
-
-/**
- ************************************************************************
- * @brief    Getting the version of the metadata parser
- *            This function allows getting the version of the MDP library.
- *
- * @param    pVersionInfo    (OUT) Pointer on an allocated version info structure
- *                            After M4MDP_getVersion() successfully returns, this
- *                            structure is filled with the version numbers.
- *                            The structure must be allocated and further de-allocated
- *                            by the application.
- *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        pVersionInfo is null (in DEBUG only)
- ************************************************************************
-*/
-M4OSA_ERR  M4MDP_getVersion(M4_VersionInfo* pVersionInfo);
-
-
-/**
- ************************************************************************
- * @brief    Initializing the MDP
- *            This function initializes the MDP and allocates the MDP execution
- *            context and parses the metadata
- * @note    This function allocates the memory needed to store metadata in
- *            TAG ID3 V1&V2, ASF or 3gpp asset structure with the OSAL allocation
- *            function.
- *            This memory will be freed in M4MDP_cleanUp function
- *
- * @note    This function is synchronous.
- *
- * @param    pContext        (OUT)    Execution Context
- * @param    pFilePath        (IN)    Pointer to the multimedia file path
- * @param    pFileReaderFcts    (IN)    Pointer to a structure containing OSAL file reader
- *                                       functions pointers
- *
- * @return    M4NO_ERROR                        No error
- * @return    M4ERR_PARAMETER                    At least, one parameter is null (in DEBUG only)
- * @return    M4ERR_ALLOC                        There is no more memory available
- * @return    M4WAR_READER_NO_METADATA        The input file doesn't contain metadata
- * @return    M4ERR_UNSUPPORTED_MEDIA_TYPE    The input file is not recognized
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_init(M4MDP_Context* pContext, M4OSA_Char* pFilePath,
-                      M4OSA_FileReadPointer*    pFileReaderFcts);
-
-/**
- ************************************************************************
- * @brief    This function frees the MDP execution context and all metadata
- *            structures already allocated by M4MDP_init
- *
- * @note    This function is synchronous.
- *
- * @param    pContext                (IN) Execution Context
- *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        pContext is NULL. (in DEBUG only)
-************************************************************************
-*/
-M4OSA_ERR M4MDP_cleanUp(M4MDP_Context pContext);
-
-/**
- ************************************************************************
- * @brief    This function Initializes the meta data parser only once to check several files one
- *            after another.
- *
- * @note    This function is synchronous.
- *
- * @param    pContext                (IN) Execution Context
-  * @param    pFileReaderFcts    (IN)    Pointer to a structure containing OSAL file reader
-  *                                          functions pointers
-*
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        pContext is NULL. (in DEBUG only)
-************************************************************************
-*/
-M4OSA_ERR M4MDP_globalInit(M4MDP_Context* pContext, M4OSA_FileReadPointer*    pFileReaderFcts);
-
-/**
- ************************************************************************
- * @brief    This function opens a file in the meta data parser
- *
- * @note    This function is synchronous.
- *
- * @param    pContext                (IN) Execution Context
- * @param    pFilePath        (IN)    Pointer to the multimedia file path
-  *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        pContext is NULL. (in DEBUG only)
-************************************************************************
-*/
-M4OSA_ERR M4MDP_open(M4MDP_Context* pContext, M4OSA_Char* pFilePath);
-
-/**
- ************************************************************************
- * @brief    This function closes a file in the meta data parser
- *
- * @note    This function is synchronous.
- *
- * @param    pContext                (IN) Execution Context
-  *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        pContext is NULL. (in DEBUG only)
-************************************************************************
-*/
-M4OSA_ERR M4MDP_close(M4MDP_Context* pContext);
-
-
-/**
- ************************************************************************
- * @brief    The function allows the retrieval of all fields of the
- *            M4_MetaDataFields structure
- *            It basically sets M4_MetaDataFields structure fields pointers to
- *            the corresponding already retrieved metadata
- *
- * @note    If metadata are retrieved from an MP3 or an AAC files, and both
- *            TAG ID3 V1 and V2 are present, then, priority is for metadata of TAG ID3 V2
- *
- * @note    This function is synchronous.
- * @note    This function is used specially by the music manager project
- *
- * @param    pContext        (IN) Execution Context
- * @param    pMetadata        (OUT) Pointer to M4_MetaDataFields structure
- *
- * @return    M4NO_ERROR                        No error
- * @return    M4ERR_PARAMETER                    pContext or pMetadata is NULL. (in DEBUG only)
- * @return    M4WAR_READER_NO_METADATA        The input file doesn't contain metadata
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_getMetadata(M4MDP_Context pContext, M4_MetaDataFields* pMetadata);
-
-/**
- ************************************************************************
- * @brief    This function returns the audio and video media type
- *
- * @note    This function is synchronous.
- * @note    This function is used specially by the music manager project
- *
- * @param    pContext        (IN)    Execution Context
- * @param    pAudio            (OUT)    Audio media type pointer
- * @param    pVideo            (OUT)    Video media type pointer
- *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        At least one parameter is NULL. (in DEBUG only)
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_getStreamsType(M4MDP_Context pContext,M4_StreamType* pAudio,M4_StreamType* pVideo);
-
-
-/**
- ************************************************************************
- * @brief    This function returns the mediaType
- *
- * @note    This function is synchronous.
- * @note    This function is used specially by the music manager project
- *
- * @param    pContext        (IN)    Execution Context
- * @param    pMediaType        (OUT)    MediaType pointer
- *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        At least one parameter is NULL. (in DEBUG only)
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_getMediaType(M4MDP_Context pContext,M4READER_MediaType* pMediaType);
-
-/******************************************************************************
-* @brief        returns mediaType found in a file
-* @note
-* @param        pFileDescriptor (IN) : pointer to file descriptor
-* @param        pFileFunction (IN)   : pointer to file function
-* @param        pMediaType (OUT)     : mediaType if found
-* @return       M4NO_ERROR / M4ERR_ALLOC
-******************************************************************************/
-M4OSA_ERR M4MDP_getMediaTypeFromFile(M4OSA_Void *pFileDescriptor,
-                                       M4OSA_FileReadPointer *pFileFunction,
-                                       M4READER_MediaType *pMediaType);
-
-/******************************************************************************
-* @brief        return media type by extension and content detections
-* @note
-* @param        pFileDescriptor (IN) : pointer to file descriptor
-* @param        dataBuffer (IN)  : memory buffer
-* @param        bufferSize (IN)  : buffer size
-* @param        pMediaType (OUT) : mediaType if found
-* @return       M4NO_ERROR / M4ERR_ALLOC
-******************************************************************************/
-M4OSA_ERR    M4MDP_getMediaTypeFromExtensionAndContent(M4OSA_Void *pFileDescriptor,
-                                                        M4OSA_UInt8 *dataBuffer,
-                                                        M4OSA_UInt32 bufferSize,
-                                                        M4READER_MediaType *pMediaType);
-
-/******************************************************************************
-* @brief        return media type by content detection
-* @note
-* @param        dataBuffer (IN)  : memory buffer
-* @param        bufferSize (IN)  : buffer size
-* @param        pMediaType (OUT) : mediaType if found
-* @return       M4NO_ERROR / M4ERR_ALLOC
-******************************************************************************/
-M4OSA_ERR    M4MDP_getMediaTypeFromContent(M4OSA_UInt8 *dataBuffer, M4OSA_UInt32 bufferSize,
-                                             M4READER_MediaType *pMediaType);
-
-/**
- ************************************************************************
- * @brief    The function parses the buffer pAsfBuffer, extracts metadata,
- *            allocates memory for pMetaData and fills in.
- *
- * @note    pAsfBuffer owns the application (caller).
- *            The application free pAsfBuffer and pMetaData
- *
- * @note    This function is synchronous.
- *
- * @param    pAsfBuffer            (IN)    input buffer
- * @param    pMetaData            (OUT)    Pointer to the metadata structure
- *
- * @return    M4NO_ERROR                        No error
- * @return    M4ERR_PARAMETER                    pContext or pAsfBuffer is NULL. (in DEBUG only)
- * @return    M4ERR_ALLOC                        There is no more memory available
- * @return    M4WAR_READER_NO_METADATA        The M4READER_Buffer doesn't contain metadata
- * @return    M4ERR_UNSUPPORTED_MEDIA_TYPE    The input file is not recognized
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_parseASFContentDesc(M4READER_Buffer* pAsfBuffer, M4_MetaDataFields *pMetaData);
-
-
-/**
- ************************************************************************
- * @brief    The function allocates memory for pMetaData and copies its
- *            pAssetFields fields
- *
- * @note    The application which calls M4MDP_parse3GppAssetField MUST free pMetaData.
- *
- * @note    This function is synchronous.
- *
- * @param    pAssetFields    (IN)    Asset fields structure filled by the 3gpp reader
- * @param    pMetaData        (OUT)    Metadata structure to be filled in
- *
- * @return    M4NO_ERROR                        No error
- * @return    M4ERR_PARAMETER                    pContext or pAssetFields is NULL. (in DEBUG only)
- * @return    M4ERR_ALLOC                        There is no more memory available
- * @return    M4ERR_UNSUPPORTED_MEDIA_TYPE    The input file is not recognized
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_parse3GppAssetField(M4_MetaDataFields* pAssetFields, M4_MetaDataFields *pMetaData);
-
-
-/**
- ************************************************************************
- * @brief    The function allocates memory for pMetaData and copies its
- *            pExifFields fields
- *
- * @note    The application which calls M4MDP_parseExifField MUST free pMetaData.
- *
- * @note    This function is synchronous.
- *
- * @param    pExifFields    (IN)    Exif fields structure filled by the exif reader
- * @param    pMetaData    (OUT)    Metadata structure to be filled in
- *
- * @return    M4NO_ERROR                        No error
- * @return    M4ERR_PARAMETER                    pContext or pAssetFields is NULL. (in DEBUG only)
- * @return    M4ERR_ALLOC                        There is no more memory available
- * @return    M4ERR_UNSUPPORTED_MEDIA_TYPE    The input file is not recognized
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_parseExifField(M4_MetaDataFields *pExifFields, M4_MetaDataFields *pMetaData);
-
-
-/**
- ************************************************************************
- * @brief    The function allocates and fills the pMetaDataStruct by parsing
- *            a buffer
- *
- * @note    pMetaDataStruct owns the application (caller).
- *            It is the responsibility of the application (caller) to free it
- *
- * @note    This function is synchronous.
- *
- * @param        pBuffer            (IN)    input buffer
- * @param        mediaType        (IN)    media type of the buffer
- * @param        pMetaDataStruct    (OUT)    Pointer to an array of metadata
- * @param        pSize            (OUT)    pMetaDataStruct size
- *
- * @return    M4NO_ERROR                    No error
- * @return    M4ERR_PARAMETER                pContext or pBuffer or pMetaDataStruct is NULL.
- *                                          (in DEBUG only)
- * @return    M4ERR_ALLOC                    There is no more memory available
- * @return    M4ERR_UNSUPPORTED_MEDIA_TYPE The media type is not supported
- * @return    M4WAR_READER_NO_METADATA    No metadata detected
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_getMetaDataFromBuffer(M4_MetadataBuffer*    pBuffer,
-                                      M4READER_MediaType    mediaType,
-                                      M4_MetaDataFields**    pMetaDataStruct,
-                                      M4OSA_UInt32*            pSize);
-
-/**
- ************************************************************************
- * @brief    The function initializes the metadata  structure
- *
- * @param    pMetadata        (OUT) Pointer to M4_MetaDataFields structure
- *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        pContext or pMetadata is NULL. (in DEBUG only)
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_InitMetaDataFields(M4_MetaDataFields *pMetaDataTab);
-
-/**
- ************************************************************************
- * @brief    The function frees the metadata  structure
- *
- * @param    pMetadata        (IN) Pointer to M4_MetaDataFields structure
- *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        pContext or pMetadata is NULL. (in DEBUG only)
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_FreeMetaDataFields(M4_MetaDataFields *pMetaDataTab);
-
-/******************************************************************************
-* @brief        returns mediaType found in a file
-* @note
-* @param        pContext (IN) : pointer to file descriptor
-* @param        pFileDescriptor (IN) : pointer to file descriptor
-* @param        pFileFunction (IN)   : pointer to file function
-* @param        pMediaType (OUT)     : mediaType if found
-* @return       M4NO_ERROR / M4ERR_ALLOC
-******************************************************************************/
-M4OSA_ERR M4MDP_getMediaTypeFromFileExtended(    M4MDP_Context pContext,
-                                                M4OSA_Void *pFileDescriptor,
-                                                M4OSA_FileReadPointer *pFileFunction,
-                                                M4READER_MediaType *pMediaType);
-
-/**
- ************************************************************************
- * @brief    The function to get file size
- *
- * @param    pContext        (IN) Pointer to M4MDP Context structure
- * @param    pSize            (OUT)Pointer to file size
- *
- * @return    M4NO_ERROR            No error
- * @return    M4ERR_PARAMETER        pContext or pMetadata is NULL. (in DEBUG only)
- ************************************************************************
-*/
-M4OSA_ERR M4MDP_getMetaDataFileSize(M4MDP_Context pContext, M4OSA_UInt32 *pSize);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __M4MDP_API_H__ */
diff --git a/libvideoeditor/vss/common/inc/M4VD_EXTERNAL_Interface.h b/libvideoeditor/vss/common/inc/M4VD_EXTERNAL_Interface.h
index 170620c..90df82b 100755
--- a/libvideoeditor/vss/common/inc/M4VD_EXTERNAL_Interface.h
+++ b/libvideoeditor/vss/common/inc/M4VD_EXTERNAL_Interface.h
@@ -20,22 +20,10 @@
 
 #include "M4DECODER_Common.h"
 
-#include "M4VD_HW_API.h"/* M4VD_Interface */
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef struct
-{
-    M4VD_Interface*    externalFuncs;
-    M4OSA_Void*        externalUserData;
-}* M4DECODER_EXTERNAL_UserDataType;
-
-/* ----- Interface retrieval ----- */
-
-M4OSA_ERR M4DECODER_EXTERNAL_getInterface(M4DECODER_VideoInterface** pDecoderInterface);
-
 /* ----- DSI bitstream parser ----- */
 
 /* This function is available to clients of the shell to allow them to analyse clips
diff --git a/libvideoeditor/vss/common/inc/M4VD_EXTERNAL_Internal.h b/libvideoeditor/vss/common/inc/M4VD_EXTERNAL_Internal.h
deleted file mode 100755
index f2dacb2..0000000
--- a/libvideoeditor/vss/common/inc/M4VD_EXTERNAL_Internal.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * 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 __M4VD_EXTERNAL_INTERNAL_H__
-#define __M4VD_EXTERNAL_INTERNAL_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "NXPSW_CompilerSwitches.h"
-
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-#include "M4OSA_Semaphore.h"
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-
-/*typedef enum
-{
-    M4VS_THREAD_IS_IDLE = 0,
-    M4VS_THREAD_IS_RUNNING = 1,
-    M4VS_THREAD_IS_STOPPING = 2
-
-} M4VS_ThreadState_t;*/
-
-
-/* ----- internal VS context ----- */
-
-typedef struct
-{
-    /* READER */
-    /**< Reference to the reader data interface used to read access units */
-    M4READER_DataInterface*           m_pReader;
-    /**< Reference to the access unit used read and decode one frame (the AU could be passed by
-    the user instead of reading it from inside the decoder) */
-    M4_AccessUnit*                    m_pNextAccessUnitToDecode;
-    /**< Flag to know if we decode just after a (read) jump */
-    M4OSA_Bool                        m_bJump;
-    M4_MediaTime                      m_nextAUCts;                /**< CTS of the AU above */
-
-    /* DECODER */
-
-    M4_MediaTime             m_DecodeUpToCts;        /**< Target Cts for the decode up to loop */
-    M4_MediaTime             m_CurrentDecodeCts;     /**< Cts of the latest frame decoded */
-    M4_MediaTime             m_PreviousDecodeCts;    /**< Cts of the previous frame decoded */
-    M4OSA_UInt32             m_NbDecodedFrames;      /**< Number of frames decoded in the decode
-                                                          up to loop (can be 0) */
-    M4OSA_ERR                m_uiDecodeError;        /**< Error or warning code (from the VD
-                                                          reader or decoder) returned to the
-                                                          shell */
-    M4OSA_Bool               m_bDataDecodePending;   /**< There is some data to decode */
-    M4OSA_Bool               m_bIsWaitNextDecode;    /**< Do we need to wait for the anticipated
-                                                          decoding to finish ? */
-
-    /* RENDER */
-
-    M4_MediaTime                 m_TargetRenderCts;        /**< Cts for the rendering step */
-    M4_MediaTime                 m_CurrentRenderCts;       /**< Cts of the latest frame decoded */
-    M4OSA_ERR                    m_uiRenderError;          /**< Error or warning code (from the
-                                                                VD render) returned to the shell */
-    M4OSA_Bool                   m_bForceRender;           /**< Force rendering even if 0 frames
-                                                                are decoded (i.e. already
-                                                                previously decoded) */
-    M4OSA_Bool                   m_bDataRenderPending;     /**< There is some data to render */
-
-    /* STREAM PARAMS */
-
-    M4_VideoStreamHandler*            m_pVideoStreamhandler;    /**< reference to the video
-                                                                     stream description passed by
-                                                                     the user */
-    M4VD_StreamInfo*                  m_pStreamInfo;
-    M4DECODER_VideoSize                  m_VideoSize;
-    M4DECODER_MPEG4_DecoderConfigInfo m_Dci;                  /**< Information collected from
-                                                                   DSI parsing */
-    M4VIFI_ImagePlane*                m_pOutputPlane;         /**< Pointer to YUV output planes */
-
-    /* VD API */
-
-    M4VD_Interface*                   m_VD_Interface;           /**< pointers to HW functions */
-    M4VD_SignalingInterface           m_VD_SignalingInterface;  /**< pointers to Shell signaling
-                                                                     functions */
-    M4VD_Context                      m_VD_Context;             /**< pointer to the real hardware
-                                                                     context */
-
-    /* THREAD STUFF  */
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-    M4OSA_Context                      m_SemSync;
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-} M4VS_VideoDecoder_Context;
-
-
-/* ----- bitstream parser ----- */
-/*
-typedef struct
-{
-    M4OSA_UInt32 stream_byte;
-    M4OSA_UInt32 stream_index;
-    M4OSA_MemAddr8 in;
-
-} M4VS_Bitstream_ctxt;
-*/
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __M4VD_EXTERNAL_INTERNAL_H__ */
diff --git a/libvideoeditor/vss/common/inc/M4VD_HW_API.h b/libvideoeditor/vss/common/inc/M4VD_HW_API.h
deleted file mode 100755
index ba33d14..0000000
--- a/libvideoeditor/vss/common/inc/M4VD_HW_API.h
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * 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 __M4VD_HW_API_H__
-#define __M4VD_HW_API_H__
-
-#include "M4OSA_Types.h"
-#include "M4OSA_OptionID.h"
-#include "M4OSA_CoreID.h"
-#include "M4OSA_Error.h"
-#include "M4OSA_Memory.h" /* M4OSA_MemAddrN */
-
-#include "M4VIFI_FiltersAPI.h"
-
-/**
- ************************************************************************
- * @file   M4VD_HW_API.H
- * @brief
- * @note
- ************************************************************************
-*/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/* ----- Hardware decoder errors and warnings ----- */
-
-#define M4ERR_VD_FATAL        M4OSA_ERR_CREATE(M4_ERR, M4VD_EXTERNAL, 0x0001)
-
-
-/* ----- enum definitions ----- */
-
-typedef enum
-{
-    M4VD_kOptionId_Dummy = 0
-
-} M4VD_OptionID;
-
-typedef enum
-{
-    M4VD_kMpeg4VideoDec,
-    M4VD_kH263VideoDec,
-    M4VD_kH264VideoDec,
-    M4VD_kVideoType_NB /* must remain last */
-} M4VD_VideoType;
-
-typedef enum
-{
-    M4VD_kNone,
-    M4VD_kYUV420,
-    M4VD_kYUV422,
-    M4VD_kYUYV422,
-    M4VD_kRGB565,
-    M4VD_kBGR565
-
-} M4VD_OutputFormat;
-
-
-/* ----- structure definitions ----- */
-
-typedef struct
-{
-    M4OSA_MemAddr32 pBuffer;              /**< pointer to video buffer - 32 bits aligned    */
-    M4OSA_UInt32  bufferSize;             /**< the size in bytes of the buffer            */
-
-} M4VD_VideoBuffer;
-
-typedef struct
-{
-    M4OSA_UInt32 aWidth;                        /**< Width of the Image        */
-    M4OSA_UInt32 aHeight;                        /**< Height of the Image    */
-
-} M4VD_ImageSize;
-
-typedef struct
-{
-    M4OSA_MemAddr8 pBuffer;                        /**< Pointer to the decoder configuration */
-    M4OSA_UInt32 aSize;                            /**< Size of the buffer */
-
-} M4VD_DecoderConfig;
-
-typedef struct
-{
-    M4VD_ImageSize        anImageSize;            /**<Size of the image*/
-    M4VD_DecoderConfig    decoderConfiguration;    /**<configuration of the decoder*/
-
-} M4VD_StreamInfo;
-
-
-/* ----- callbacks prototypes ----- */
-
-typedef M4OSA_ERR (M4VD_CB_signalDecoderOver_fct)( M4OSA_Void* signalTarget,
-                                                    M4OSA_Double frameTime, M4OSA_ERR err);
-typedef M4OSA_ERR (M4VD_CB_signalRenderOver_fct) ( M4OSA_Void* signalTarget,
-                                                    M4OSA_Double frameTime, M4OSA_ERR err);
-
-typedef struct
-{
-    M4OSA_Void*                        m_pSignalTarget;
-
-    /* decoder callbacks that need to be raised by HW decoder functions */
-    M4VD_CB_signalDecoderOver_fct*    m_pFctSignalDecoderOver;
-    M4VD_CB_signalRenderOver_fct*     m_pFctSignalRenderOver;
-
-} M4VD_SignalingInterface;
-
-
-/* ----- Hardware decoder functions set ----- */
-
-typedef void* M4VD_Context; /* Video Decoder context (for M4VD_HW_xxxx functions) */
-
-
-/* common */
-typedef M4OSA_ERR (M4VD_init_fct)          ( M4VD_Context*, M4VD_SignalingInterface* );
-typedef M4OSA_ERR (M4VD_setOption_fct)     ( M4VD_Context, M4VD_OptionID, M4OSA_DataOption );
-typedef M4OSA_ERR (M4VD_getOption_fct)     ( M4VD_Context, M4VD_OptionID, M4OSA_DataOption* );
-typedef M4OSA_ERR (M4VD_openDecoder_fct) ( M4VD_Context, M4VD_VideoType, M4VD_StreamInfo*,
-                                            M4VD_OutputFormat*, M4OSA_Void* );
-typedef M4OSA_ERR (M4VD_stepDecode_fct)    ( M4VD_Context, M4VD_VideoBuffer*, M4OSA_Double );
-typedef M4OSA_ERR (M4VD_stepRender_fct)    ( M4VD_Context, M4VIFI_ImagePlane*, M4OSA_Double );
-typedef M4OSA_ERR (M4VD_closeDecoder_fct)( M4VD_Context );
-typedef M4OSA_ERR (M4VD_cleanUp_fct)       ( M4VD_Context );
-typedef M4OSA_ERR (M4VD_setOutputFilter_fct)( M4VD_Context, M4VIFI_PlanConverterFunctionType*,
-                                                M4OSA_Void*);
-
-typedef struct
-{
-    M4VD_init_fct*                m_pFctInitVideoDecoder;
-    M4VD_setOption_fct*            m_pFctSetOption;
-    M4VD_getOption_fct*            m_pFctGetOption;
-    M4VD_openDecoder_fct*        m_pFctOpenDecoder;
-    M4VD_stepDecode_fct*        m_pFctStepDecode;
-    M4VD_stepRender_fct*        m_pFctStepRender;
-    M4VD_closeDecoder_fct*        m_pFctClose;
-    M4VD_cleanUp_fct*            m_pFctCleanUp;
-    M4VD_setOutputFilter_fct*    m_pFctSetOutputFilter;
-} M4VD_Interface;
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* __M4VD_HW_API_H__ */
diff --git a/libvideoeditor/vss/common/inc/M4VE_API.h b/libvideoeditor/vss/common/inc/M4VE_API.h
deleted file mode 100755
index 5c27003..0000000
--- a/libvideoeditor/vss/common/inc/M4VE_API.h
+++ /dev/null
@@ -1,824 +0,0 @@
-/*
- * 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   M4VE_API.h
- * @note   This file declares the generic shell interface retrieving function
- *         of any external encoder.
-******************************************************************************
-*/
-
-#ifndef __M4VE_API_H__
-#define __M4VE_API_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-/**
- *    OSAL types definition */
-#include "M4OSA_Types.h"
-#include "M4OSA_Time.h"
-#include "M4OSA_Memory.h"
-#include "M4OSA_CoreID.h"
-#include "M4OSA_OptionID.h"
-
-/**
- *    Include Video filters interface definition (for the M4VIFI_ImagePlane type) */
-#include "M4VIFI_FiltersAPI.h"
-
-
-/**
- ************************************************************************
- * VE Errors & Warnings definition
- ************************************************************************
-*/
-#define    M4ERR_VE_FATAL        ((M4OSA_ERR)M4OSA_ERR_CREATE(M4_ERR, M4VE_EXTERNAL, 0x000000))
-
-
-/**
- *********************************************************************************************
- * enum        M4VE_EncoderMode
- * @brief    This enum defines in which mode the external encoder will be used
- *            ("Standalone encoder" or "Encoder + Grabber").
- *********************************************************************************************
- */
-typedef enum
-{
-    M4VE_kSEMode,        /**< "Standalone Encoder" mode */
-    M4VE_kEGMode        /**< "Encoder + Grabber" mode */
-} M4VE_EncoderMode;
-
-
-/**
- *********************************************************************************************
- * enum        M4VE_EncoderType
- * @brief    This enum defines the supported encoder types.
- *********************************************************************************************
- */
-typedef enum
-{
-    M4VE_kMpeg4VideoEnc,     /**< MPEG-4 */
-    M4VE_kH263VideoEnc,      /**< H263 */
-    M4VE_kH264VideoEnc,      /**< H264 */
-    M4VE_kMJPEGEnc,            /**< MJPEG */
-    M4VE_kEncoderType_NB
-} M4VE_EncoderType;
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_ImageSize
- * @brief    This structure defines video frame size (for both grabbing and encoding).
- *********************************************************************************************
- */
-typedef struct
-{
-    M4OSA_UInt32     width;     /**< Width of the Image */
-    M4OSA_UInt32     height;    /**< Height of the Image */
-} M4VE_ImageSize;
-
-
-/**
- *********************************************************************************************
- * enum        M4VE_FormatConfig
- * @brief    This enum defines the frame format we have in input for the grabbing
- *            part of the external encoder.
- *********************************************************************************************
-*/
-typedef enum
-{
-    M4VE_kYUV420=0,    /**< YUV 4:2:0 planar (standard input for mpeg-4 video) */
-    M4VE_kYUV422,    /**< YUV422 planar */
-    M4VE_kYUYV,        /**< YUV422 interlaced, luma first */
-    M4VE_kUYVY,        /**< YUV422 interlaced, chroma first */
-    M4VE_kJPEG,        /**< JPEG compressed frames */
-    M4VE_kRGB444,    /**< RGB 12 bits 4:4:4 */
-    M4VE_kRGB555,    /**< RGB 15 bits 5:5:5 */
-    M4VE_kRGB565,    /**< RGB 16 bits 5:6:5 */
-    M4VE_kRGB24,    /**< RGB 24 bits 8:8:8 */
-    M4VE_kRGB32,    /**< RGB 32 bits  */
-    M4VE_kBGR444,    /**< BGR 12 bits 4:4:4 */
-    M4VE_kBGR555,    /**< BGR 15 bits 5:5:5 */
-    M4VE_kBGR565,    /**< BGR 16 bits 5:6:5 */
-    M4VE_kBGR24,    /**< BGR 24 bits 8:8:8 */
-    M4VE_kBGR32        /**< BGR 32 bits  */
-} M4VE_FormatConfig;
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_Framerate
- * @brief    This structure defines the maximum framerate the encoder will have
- *            at input and will generate at output (in frames per second).
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4OSA_UInt32     framerateNum;    /**< Framerate numerator */
-    M4OSA_UInt32     framerateDen;    /**< Framrate denominator */
-} M4VE_Framerate;
-/**<     For example, a framerate of 29.97 fps for H263 encoding will be expressed as:
-    FramerateNum = 30000
-    FramerateDen = 1001 */
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_GrabbingParameters
- * @brief    This structure defines the grabbing parameters set at open step.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4VE_ImageSize        size;        /**< Size of grabbed frames */
-    M4VE_FormatConfig    format;        /**< Format of the grabbed frames (YUV420, RGB565,etc.) */
-} M4VE_GrabbingParameters;
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_EncodingParameters
- * @brief    This structure defines the encoding parameters set at open step.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4VE_EncoderType  type;             /**< coding type (H263/H264/MPEG-4)*/
-    M4VE_ImageSize    size;             /**< Size of frames to encode */
-    M4OSA_Bool          bRateControlEnable; /**< Flag to enable/disable rate control */
-    M4OSA_Bool          bLowDelay;        /**< force encoder in "low delay" mode */
-    M4OSA_UInt32      bitrate;             /**< Average targeted bitrate in bit per sec */
-    M4VE_Framerate    framerate;        /**< Maximum input framerate */
-    M4OSA_UInt32      timescale;       /**< timescale of the video bitstream */
-    M4OSA_Context     pUserSettings;   /**< Additionnal user settings passed by the
-                                            application to the service at Codec registration */
-} M4VE_EncodingParameters;
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_VideoBuffer
- * @brief    This structure defines the output buffer where the encoded data
- *            are stored by the encoder.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4OSA_MemAddr32 pBuffer;    /**< pointer to video buffer 32 bits aligned */
-    M4OSA_UInt32    bufferSize; /**< the size in bytes of the buffer */
-} M4VE_VideoBuffer;
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_ParameterSet
- * @brief    Parameter set structure used for H264 headers.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4OSA_UInt16    length;                /**< Number of items*/
-    M4OSA_UInt8*    pParameterSetUnit;  /**< Array of items*/
-} M4VE_ParameterSet;
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_H264HeaderBuffer
- * @brief    This structure defines the buffer where the stream header is stored
- *            by the encoder, in case of H264
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4OSA_UInt8            NALUnitLength;             /**< length in bytes of a NAL access Unit */
-    M4OSA_UInt8            nOfSequenceParametersSets; /**< Number of sequence parameter sets*/
-    M4OSA_UInt8            nOfPictureParametersSets;  /**< Number of picture parameter sets*/
-    M4VE_ParameterSet    *pSequenceParameterSets;    /**< Sequence parameter set array */
-    M4VE_ParameterSet    *pPictureParameterSets;        /**< Picture parameter set array */
-} M4VE_H264HeaderBuffer;
-
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_HeaderBuffer
- * @brief    This structure defines the buffer where the stream header is stored
- *            by the encoder.
- *********************************************************************************************
-*/
-typedef struct
-{
-    union
-    {
-        M4VE_VideoBuffer         header;     /**< MPEG-4, H263, MJPEG */
-        M4VE_H264HeaderBuffer     H264Header; /**< H264 */
-    }M4VE_SpecificHeader;
-} M4VE_HeaderBuffer;
-
-
-/**
- *********************************************************************************************
- * enum        M4VE_OptionID
- * @brief    This defines the supported options handled by the video encoder interface.
- *********************************************************************************************
-*/
-typedef enum
-{
-    dummy=0
-} M4VE_OptionID;
-
-/**
- *********************************************************************************************
- * M4OSA_Int32 (*M4VE_SignalOpenEncoderDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
- * @brief    This function signals to the service that the external encoder is opened.
- * @note    The external encoder returns one of the following codes in the errCode parameter:
- *            M4NO_ERROR    There is no error
- *            M4ERR_VE_FATAL    a fatal error occurred
- * @param    pUserData:                (IN) User data provided by the service at init step.
- * @param    errCode :                (IN) Error code returned to the service internal layers.
- * @return    M4NO_ERROR:                there is no error.
- * @return    M4ERR_VE_FATAL:        a fatal error occurred.
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SignalOpenEncoderDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
-
-
-/**
- *********************************************************************************************
- * M4OSA_Int32 (*M4VE_SignalHeaderDone)(M4OSA_Context pUserData, M4OSA_ERR errCode,
- *                                       M4VE_HeaderBuffer *pBuffer);
- * @brief    This function signals to the service that the stream header is ready.
- * @note    The external encoder returns one of the following codes in the errCode parameter:
- *            M4NO_ERROR    There is no error
- *            M4ERR_VE_FATAL    a fatal error occurred
- * @param    pUserData:                (IN) User data provided by the service at init step.
- * @param    errCode :                (IN) Error code returned to the service internal layers.
- * @param    pBuffer :                (IN) Stream header.
- * @return    M4NO_ERROR:                there is no error.
- * @return    M4ERR_PARAMETER            pBuffer field is null or invalid.
- * @return    M4ERR_VE_FATAL:        a fatal error occurred.
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SignalHeaderDone)(M4OSA_Context pUserData, M4OSA_ERR errCode,
-                     M4VE_HeaderBuffer *pBuffer);
-
-
-/**
- *********************************************************************************************
- * M4OSA_Int32 (*M4VE_SignalStartGrabberDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
- * @brief    This function signals to the service that the grabbing part is started.
- *            This callback is unused in the "standalone encoder" mode.
- * @note    The external encoder returns one of the following codes in the errCode parameter:
- *            M4NO_ERROR    There is no error
- *            M4ERR_VE_FATAL    a fatal error occurred
- * @param    pUserData:                (IN) User data provided by the service at init step.
- * @param    errCode :                (IN) Error code returned to the service internal layers.
- * @return    M4NO_ERROR:                there is no error.
- * @return    M4ERR_VE_FATAL:        a fatal error occurred.
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SignalStartGrabberDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
-
-
-/**
- *********************************************************************************************
- * M4OSA_Int32 (*M4VE_SignalStartEncoderDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
- * @brief    This function signals to the service that the external encoder is started.
- *            This callback is unused in the "standalone encoder" mode.
- * @note    The external encoder returns one of the following codes in the errCode parameter:
- *            M4NO_ERROR    There is no error
- *            M4ERR_VE_FATAL    a fatal error occurred
- * @param    pUserData:                (IN) User data provided by the service at init step.
- * @param    errCode :                (IN) Error code returned to the service internal layers.
- * @return    M4NO_ERROR:                there is no error.
- * @return    M4ERR_VE_FATAL:        a fatal error occurred.
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SignalStartEncoderDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
-
-
-/**
- *********************************************************************************************
- * M4OSA_Int32 (*M4VE_SignalEncodeDone)(M4OSA_Context pUserData, M4OSA_ERR    errCode,
-                M4OSA_UInt32 cts, M4VE_VideoBuffer* pBuffer);
- * @brief    This function signals to the service that the encoding of a frame is done.
- *            The integrator must call this function when the encoding of the video
- *            frame is completed (for example in an interrupt callback).
- * @note    The external encoder returns one of the following codes in the errCode parameter:
- *            M4NO_ERROR    There is no error
- *            M4ERR_VE_FATAL    a fatal error occurred
- * @param    pUserData:                (IN) User data provided by the service at init step.
- * @param    errCode :                (IN) Error code returned to the service internal layers.
- * @param    cts :                    (IN) Time of the encoded frame (from stepEncode).
- * @param    pBuffer :                (IN) Encoded data Buffer.
- * @return    M4NO_ERROR:                there is no error.
- * @return    M4ERR_PARAMETER            At least one parameter is null or invalid.
- * @return    M4ERR_VE_FATAL:        a fatal error occurred.
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SignalEncodeDone)(M4OSA_Context pUserData, M4OSA_ERR    errCode,
-                         M4OSA_Time cts, M4VE_VideoBuffer* pBuffer);
-
-
-/**
- *********************************************************************************************
- * M4OSA_Int32 (*M4VE_SignalStopGrabberDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
- * @brief    This function signals to the service that the grabbing part is stopped.
- *            This callback is unused in the "standalone encoder" mode.
- * @note    The external encoder returns one of the following codes in the errCode parameter:
- *            M4NO_ERROR    There is no error
- *            M4ERR_VE_FATAL    a fatal error occurred
- * @param    pUserData:                (IN) User data provided by the service at init step.
- * @param    errCode :                (IN) Error code returned to the service internal layers.
- * @return    M4NO_ERROR:                there is no error.
- * @return    M4ERR_VE_FATAL:        a fatal error occurred.
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SignalStopGrabberDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
-
-
-/**
- *********************************************************************************************
- * M4OSA_Int32 (*M4VE_SignalStopEncoderDone)(M4OSA_Context    pUserData, M4OSA_ERR errCode);
- * @brief    This function signals to the service that the external encoder is stopped.
- *            This callback is unused in the "standalone encoder" mode.
- * @note    The external encoder returns one of the following codes in the errCode parameter:
- *            M4NO_ERROR    There is no error
- *            M4ERR_VE_FATAL    a fatal error occurred
- * @param    pUserData:                (IN) User data provided by the service at init step.
- * @param    errCode :                (IN) Error code returned to the service internal layers.
- * @return    M4NO_ERROR:                there is no error.
- * @return    M4ERR_VE_FATAL:        a fatal error occurred.
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SignalStopEncoderDone)(M4OSA_Context    pUserData, M4OSA_ERR errCode);
-
-
-/**
- *********************************************************************************************
- * M4OSA_Int32 (*M4VE_SignalCloseEncoderDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
- * @brief    This function signals to the service that the external encoder is closed.
- * @note    The external encoder returns one of the following codes in the errCode parameter:
- *            M4NO_ERROR    There is no error
- *            M4ERR_VE_FATAL    a fatal error occurred
- * @param    pUserData:                (IN) User data provided by the service at init step.
- * @param    errCode :                (IN) Error code returned to the service internal layers.
- * @return    M4NO_ERROR:                there is no error.
- * @return    M4ERR_VE_FATAL:        a fatal error occurred.
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SignalCloseEncoderDone)(M4OSA_Context pUserData, M4OSA_ERR errCode);
-
-
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_GenericCallback
- * @brief    This structure is used to pass the generic callbacks, i.e. the ones that are used
- *            in both "Standalone Encoder" and "Encoder + Grabber" modes.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4VE_SignalOpenEncoderDone        pOpenEncoderDone; /**< Callback to use at open completion */
-    M4VE_SignalHeaderDone             pHeaderDone;         /**< Callback to use when the stream
-                                                                 header is ready */
-    M4VE_SignalEncodeDone             pEncodeDone;         /**< Callback to use for any frame
-                                                                    encoding completion */
-    M4VE_SignalCloseEncoderDone       pCloseEncoderDone;/**< Callback to use at close completion */
-} M4VE_GenericCallback;    /**< Callbacks used in all encoder modes */
-
-/**
- *********************************************************************************************
- * struct    M4VE_EGModeCallback
- * @brief    This structure is used to pass the callbacks used in the "Encoder + Grabber" mode
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4VE_SignalStartGrabberDone     pStartGrabberDone;/**< Callback to use at start
-                                                            completion of the grabber part*/
-    M4VE_SignalStartEncoderDone     pStartEncoderDone;/**< Callback to use at start
-                                                            completion of the encoder part*/
-    M4VE_SignalStopGrabberDone      pStopGrabberDone; /**< Callback to use at stop
-                                                            completion of the grabber part*/
-    M4VE_SignalStopEncoderDone      pStopEncoderDone; /**< Callback to use at stop
-                                                            completion of the encoder part*/
-} M4VE_EGModeCallback; /**< Callbacks used in "Encoder + Grabber" mode */
-
-/**
- *********************************************************************************************
- * struct    M4VE_SEModeCallback
- * @brief    This structure is used to pass the callbacks used in the "Standalone Encoder" mode
- * @note    There's no specific callback for the standalone encoder mode,
- *               but we have to declare one
- * @note        for some compilers
- *********************************************************************************************
-*/
-typedef M4OSA_Int32 (*M4VE_SEDummyCB)  (M4OSA_Context pUserData, M4OSA_ERR errCode);
-
-typedef struct
-{
-    M4VE_SEDummyCB                  pDummySECB; /**< No specific callback for
-                                                        Standalone encoder mode */
-} M4VE_SEModeCallback; /**< Callbacks used in "Standalone Encoder" mode */
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_CallbackInterface
- * @brief    This structure is the container for the whole set of callback used by external encoder
-  *********************************************************************************************
-*/
-
-typedef struct
-{
-    M4VE_GenericCallback    genericCallback;/**< Callbacks used in all modes */
-    union
-    {
-        M4VE_EGModeCallback    EGModeCallback; /**< Callbacks used in "Encoder + Grabber" mode */
-        M4VE_SEModeCallback    SEModeCallback; /**< Callbacks used in "Standalone Encoder" mode */
-    } M4VE_SpecificModeCallBack;
-    M4OSA_Context            pUserData;      /**< Internal user data to be retrieved in each
-                                                    callbach above */
-} M4VE_CallbackInterface;
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_initEncoder_fct)(M4OSA_Context* pContext,
- *                                       M4VE_CallbackInterface* pCallbackInterface);
- * @brief    This function initializes the external video encoder API.
- * @note    This function typically allocates the user context that will be provided
- *            to the other functions as their first argument. The second argument is
- *            the callback interface given by the service. Encoder implementation is supposed
- *            to use these callbacks in response to each asynchronous API function.
- *            All these callbacks must be called with the pUserData field specified
- *            by the service inside the M4VE_CallbackInterface structure.
- * @param    pContext:            (OUT) Execution context of the encoder.
- * @param    pCallbackInterface:    (IN) Callback interface.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    At least one parameter is not correct (NULL or invalid).
- * @return    M4ERR_ALLOC:        there is no more available memory.
- *********************************************************************************************
-*/
-typedef    M4OSA_ERR (*M4VE_initEncoder_fct)(M4OSA_Context* pContext,
-                     M4VE_CallbackInterface*    pCallbackInterface);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_setOption_fct)(M4OSA_Context, M4VE_OptionID, M4OSA_DataOption);
- * @brief    This function is used to set an option in the video encoder interface.
- * @note    none
- * @param    pContext:        (IN) Execution context of the encoder.
- * @param    optionId:        (IN) Id of the option to set.
- * @param    pValue:            (IN) Pointer of the option data to set.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    At least one parameter is not correct (NULL or invalid).
- * @return    M4ERR_BAD_OPTION_ID:The requested option Id is invalid.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_setOption_fct)(M4OSA_Context pContext,    M4VE_OptionID optionId,
-                                        M4OSA_DataOption pValue);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_getOption_fct)(M4OSA_Context, M4VE_OptionID, M4OSA_DataOption*);
- * @brief    This function is used to retrieve an option in the video interface.
- * @note    none
- * @param    pContext:        (IN) Execution context of the encoder.
- * @param    optionId:        (IN) Id of the option to set.
- * @param    pValue:            (OUT) Pointer to the location where the requested option will
- *                                      be stored.
- * @return    M4NO_ERROR:        there is no error.
- * @return    M4ERR_PARAMETER:    At least one parameter is not correct (NULL or invalid).
- * @return    M4ERR_BAD_OPTION_ID:The requested option Id is invalid.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_getOption_fct)(M4OSA_Context pContext, M4VE_OptionID optionId,
-                             M4OSA_DataOption* pValue);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_openEncoder_fct)(M4OSA_Context pContext,
- *                                     M4VE_GrabbingParameters *pGrabbingParams,
- *                                     M4VE_EncodingParameters *pEncodingParams);
- * @brief    This function opens an instance of the video encoder.
- *            Both encoding and grabbing parameters are specified here.
- * @note    This function is asynchronous, thus the external encoder must call the corresponding
- *            M4VE_SignalOpenEncoderDone callback function when the opening step is internally
- *            completed.
- *            Please note that both grabber and encoder components are opened at this step in
- *            the "encoder + grabber" mode. In response to this open, the encoder must also return
- *            the stream header (including VOS, VO & VOL) using the M4VE_SignalHeaderDone callback
- *            function. Usually the service waits for this callback between the
- *            M4VE_SignalOpenEncoderDone
- *            callback and the M4VE_SignalCloseEncoderDone callback in order to handle it.
- * @param    pContext:            (IN) Execution context of the encoder.
- * @param    pGrabbingParams:    (IN) Grabbing parameters (can be optional, in this case is
- *                                    must be NULL).
- * @param    pEncodingParams:    (IN) Encoding parameters.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    At least one parameter is not correct (NULL or invalid).
- * @return    M4ERR_ALLOC:        there is no more available memory.
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    The encoder could not be opened
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_openEncoder_fct)(M4OSA_Context pContext,
-                         M4VE_GrabbingParameters *pGrabbingParams,
-                          M4VE_EncodingParameters *pEncodingParams);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_forceIFrame_fct)(M4OSA_Context pContext);
- * @brief    This function is used by the service to signal the external encoder that an Intra
- *           refresh frame must be encoded. This function is used in both "Standalone Encoder" and
- *            "Encoder + grabber" modes and can be called at any time during the encoding session.
- * @note    For the "Encoder + Grabber" mode, this function can be called between the reception
- *            of the M4VE_SignalStartEncoderDone callback and the call to M4VE_stopEncoder_fct.
- *            For the "Standalone Encoder" mode, this function can be called between the reception
- *            of the M4VE_SignalOpenEncoderDone callback and the call to M4VE_closeEncoder_fct.
- *            The expected behavior is that the external encoder encodes an intra refresh frame
- *            for one of the frames coming next to the call of M4VE_forceIFrame_fct.
- * @param    pContext:            (IN) Execution context of the encoder.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    pContext field is not valid
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    The encoder could not handle this call
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_forceIFrame_fct)(M4OSA_Context pContext);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_releaseOutputBuffer_fct)(M4OSA_Context pContext, M4VE_VideoBuffer *pBuffer);
- * @brief    This function is called by the service to signal that a particular output buffer,
- *           provided in the M4VE_SignalEncodeDone callback by the external encoder, is no more
- *           needed by the service and can be considered as free for any remaining data processing.
- * @note    none.
- * @param    pContext:            (IN) Execution context of the encoder.
- * @param    pBuffer:            (IN) Encoded data Buffer.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    At least one parameter is not correct (NULL or invalid).
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    The encoder could not acknowledge the buffer release for any
- *                                other reason.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_releaseOutputBuffer_fct)(M4OSA_Context pContext,
-                                                    M4VE_VideoBuffer *pBuffer);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_closeEncoder_fct)(M4OSA_Context pContext);
- * @brief    This function closes the encoding session.
- * @note    This function is asynchronous, thus the external encoder must call the corresponding
- *            M4VE_SignalCloseEncoderDone callback function when the closing step is internally
- *            completed.
- * @param    pContext:            (IN) Execution context of the encoder.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    pContext pointer is null or invalid.
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    The encoder could not be closed for any other reason.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_closeEncoder_fct)(M4OSA_Context pContext);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_cleanUpEncoder_fct)(M4OSA_Context pContext);
- * @brief    The function cleans up the encoder context.
- * @note    none
- * @param    pContext:            (IN) Execution context of the encoder.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    pContext pointer is null or invalid.
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    The encoder could not be closed for any other reason.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_cleanUpEncoder_fct)(M4OSA_Context pContext);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_stepEncode_fct)(M4OSA_Context pContext,M4VIFI_ImagePlane *pInputPlane,
- *                                  M4OSA_Time cts);
- * @brief    The function gives a video frame to the external encoder in the "Standalone encoder"
- *            mode. The input buffer consists of a raw YUV420 planar frame,
- *            allocated by the service.
- *            The time (cts) is the composition time stamp of the frame to encode and is unique
- *            for each frame. This time is expressed in milliseconds.
- * @note    This function is asynchronous and its completion is signaled by the
- *            M4VE_SignalEncodeDone callback. It applies that the input buffer is maintained valid
- *            by the service till the call of this callback. The encoded data are retrieved in
- *            this callback function in a dedicated structure, allocated by the external encoder.
- *            The input buffer (YUV raw frame) is considered by the service as free for any
- *             remaining data processing after receiving the M4VE_SignalEncodeDone callback.
- * @param    pContext:            (IN) Execution context of the encoder.
- * @param    pInputPlane:        (IN) Input buffer where video frame is stored.
- * @param    cts:                (IN) Composition time stamp in milliseconds.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    pContext field is not valid
- * @return    M4ERR_ALLOC:        there is no more available memory.
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    The encoder could not encode the frame for any other reason.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_stepEncode_fct)(M4OSA_Context pContext,M4VIFI_ImagePlane *pInputPlane,
-                                            M4OSA_Time cts);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_startGrabber_fct)(M4OSA_Context pContext);
- * @brief    This function starts the grabber sub-component of the external encoder, in the
- *            "encoder + grabber" mode. This function is asynchronous, thus the external
- *            encoder must call the corresponding M4VE_SignalStartGrabberDone callback function
- *            when this start is internally effective.
- * @note    During this step, the service waits for the grabber to launch any video preview if
- *            needed.
- * @param    pContext:            (IN) Execution context of the encoder.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    pContext field is not valid
- * @return    M4ERR_ALLOC:        there is no more available memory.
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    the encoder could not be started for any other reason.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_startGrabber_fct)(M4OSA_Context pContext);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_startEncoder_fct)(M4OSA_Context pContext);
- * @brief    This function starts the video encoder in the "encoder + grabber" mode.
- * @note    This function is asynchronous, thus the external encoder must call the corresponding
- *            M4VE_SignalStartEncoderDone callback function when this start is internally
- *            effective.
- *            After the completion of this asynchronous function, the service waits for the
- *            external encoder to periodically call the M4VE_SignalEncodeDone callback each time
- *            a new frame has been encoded. The external encoder must expect to have several
- *            M4VE_startEncoder_fct calls before being closed. See the description of
- *            M4VE_stopEncoder_fct function for the expected behaviour.
- * @param    pContext:            (IN) Execution context of the encoder.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    pContext field is not valid
- * @return    M4ERR_ALLOC:        there is no more available memory.
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    the encoder could not be started for any other reason.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_startEncoder_fct)(M4OSA_Context pContext);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR M4OSA_ERR (*M4VE_stopGrabber_fct)(M4OSA_Context pContext);
- * @brief    This function stops the video grabber in the "encoder + grabber" mode.
- * @note    This function is asynchronous, thus the external encoder must call the corresponding
- *          M4VE_SignalStopGrabberDone callback function when this stop is internally effective.
- *          During this step, the service waits for the grabber to stop the video preview
- *          if needed.
- * @param    pContext:            (IN) Execution context of the encoder.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    pContext field is not valid
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_FATAL:    the encoder could not be stopped for any other reason.
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_stopGrabber_fct)(M4OSA_Context pContext);
-
-
-/**
- *********************************************************************************************
- * M4OSA_ERR (*M4VE_stopEncoder_fct)(M4OSA_Context pContext);
- * @brief    This function stops the video encoder in the "encoder + grabber" mode.
- * @note    This function is asynchronous, thus the external encoder must call the corresponding
- *            M4VE_SignalStopEncoderDone callback function when this stop is internally effective.
- *            After the reception of this callback, the service considers that no new frame will be
- *            retrieved via the M4VE_SignalEncodeDone callback.
- *            The external encoder must expect to have a possible call to M4VE_startEncoder_fct
- *            after M4VE_stopEncoder_fct. In this case, the external encoder must consider that it
- *             has been paused/resumed. The expected behaviour is the following one:
- *            - The result from this two encoding sessions is a Standalone stream, no header is
- *            generated for this new session. The external encoder is free to encode a refresh
- *            frame (like I VOP) for this new session.
- *            - The time stamps of this new session must directly follow the time stamps of the
- *            previous one (ie: no time hole coming from the delay between the stop of the first
- *            session and the start of the new one).
- * @param    pContext:            (IN) Execution context of the encoder.
- * @return    M4NO_ERROR:            there is no error.
- * @return    M4ERR_PARAMETER:    pContext field is not valid
- * @return    M4ERR_STATE:        This call is not allowed in the current encoder state.
- * @return    M4ERR_VE_ERR_FATAL:    the encoder could not be stopped for any other reason
- *********************************************************************************************
-*/
-typedef M4OSA_ERR (*M4VE_stopEncoder_fct)(M4OSA_Context pContext);
-
-
-
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_GenericInterface
- * @brief    The M4VE_GenericInterface structure defines the set of functions used in
- *               both encoder modes.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4VE_initEncoder_fct            m_pFctInitEncoder;
-    M4VE_setOption_fct                m_pFctSetOption;
-    M4VE_getOption_fct                m_pFctGetOption;
-    M4VE_openEncoder_fct            m_pFctOpenEncoder;
-    M4VE_forceIFrame_fct            m_pFctForceIFrame;
-    M4VE_releaseOutputBuffer_fct    m_pFctReleaseOutputBuffer;
-    M4VE_closeEncoder_fct            m_pFctCloseEncoder;
-    M4VE_cleanUpEncoder_fct            m_pFctCleanUpEncoder;
-} M4VE_GenericInterface;            /**< Functions used in both "Standalone Encoder" and
-                                        "Encoder + Grabber" modes */
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_SEModeInterface
- * @brief    The M4VE_SEModeInterface structure defines the set of functions used in
- *              "Standalone Encoder" mode.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4VE_stepEncode_fct            m_pFctStepEncode;
-} M4VE_SEModeInterface;            /**< Functions used only in "Standalone Encoder" mode */
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_EGModeInterface
- * @brief    The M4VE_EGModeInterface structure defines the set of functions used in
- *              "Encoder + Grabber" mode.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4VE_startGrabber_fct        m_pFctStartGrabber;
-    M4VE_startEncoder_fct        m_pFctStartEncoder;
-    M4VE_stopGrabber_fct        m_pFctStopGrabber;
-    M4VE_stopEncoder_fct        m_pFctStopEncoder;
-} M4VE_EGModeInterface;            /**< Functions used only in "Encoder + Grabber" mode */
-
-
-
-/**
- *********************************************************************************************
- * struct    M4VE_Interface
- * @brief    The M4VE_Interface structure stores pointers to the video encoder functions.
- *********************************************************************************************
-*/
-typedef struct
-{
-    M4VE_GenericInterface        genericInterface;    /**< Functions used everytime */
-    M4VE_EncoderMode            encoderMode;        /**< "Standalone Encoder"
-                                                    or "Encoder + Grabber" */
-    union
-    {
-        M4VE_SEModeInterface    SEModeInterface;    /**< Functions used only in
-                                                    "Standalone Encoder" mode */
-        M4VE_EGModeInterface    EGModeInterface;    /**< Functions used only in
-                                                    "Encoder + Grabber" mode */
-    }M4VE_SpecificInterface;
-} M4VE_Interface;
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-
-#endif /*__M4VE_API_H__*/
diff --git a/libvideoeditor/vss/common/inc/M4_Logo.h b/libvideoeditor/vss/common/inc/M4_Logo.h
deleted file mode 100755
index 79a2e1c..0000000
--- a/libvideoeditor/vss/common/inc/M4_Logo.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * 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 M4_Logo_h
-#define M4_Logo_h
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-extern const unsigned char logo[];
-extern const int logo_width;
-extern const int logo_height;
-#ifdef __cplusplus
-}
-#endif
-#endif
-
diff --git a/libvideoeditor/vss/inc/M4PTO3GPP_API.h b/libvideoeditor/vss/inc/M4PTO3GPP_API.h
index 86c6b93..693f249 100755
--- a/libvideoeditor/vss/inc/M4PTO3GPP_API.h
+++ b/libvideoeditor/vss/inc/M4PTO3GPP_API.h
@@ -44,8 +44,6 @@
  * Definitions of M4VIFI_ImagePlane */
 #include "M4VIFI_FiltersAPI.h"
 
-#include "M4VE_API.h"
-
 /**
  * Common definitions of video editing components */
 #include "M4_VideoEditingCommon.h"
@@ -249,12 +247,6 @@ M4OSA_ERR M4PTO3GPP_Close(M4PTO3GPP_Context pContext);
 M4OSA_ERR M4PTO3GPP_CleanUp(M4PTO3GPP_Context pContext);
 
 
-M4OSA_ERR M4PTO3GPP_RegisterExternalVideoEncoder(M4PTO3GPP_Context pContext,
-                                                 M4VE_EncoderType encoderType,
-                                                 M4VE_Interface*    pEncoderInterface,
-                                                 M4OSA_Void* pUserData);
-
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/libvideoeditor/vss/inc/M4PTO3GPP_InternalTypes.h b/libvideoeditor/vss/inc/M4PTO3GPP_InternalTypes.h
index a858cb2..e6e830d 100755
--- a/libvideoeditor/vss/inc/M4PTO3GPP_InternalTypes.h
+++ b/libvideoeditor/vss/inc/M4PTO3GPP_InternalTypes.h
@@ -193,13 +193,6 @@ typedef struct
      *    Audio padding mode */
     M4OSA_Bool                    m_bAudioPaddingSilence;  /**< A boolean that signals that audio
                                                                 AU will be padded by silence */
-
-    struct
-    {
-        M4VE_Interface*    pEncoderInterface;
-        M4OSA_Void*        pUserData;
-        M4OSA_Bool        registered;
-    } registeredExternalEncs[M4VE_kEncoderType_NB];
 } M4PTO3GPP_InternalContext;
 
 
diff --git a/libvideoeditor/vss/inc/M4VSS3GPP_API.h b/libvideoeditor/vss/inc/M4VSS3GPP_API.h
index f6f8daa..a1cf225 100755
--- a/libvideoeditor/vss/inc/M4VSS3GPP_API.h
+++ b/libvideoeditor/vss/inc/M4VSS3GPP_API.h
@@ -48,11 +48,6 @@
 /**
  * Common definitions of video editing components */
 #include "M4_VideoEditingCommon.h"
-
-
-#include "M4VD_HW_API.h"
-#include "M4VE_API.h"
-
 #include "M4ENCODER_AudioCommon.h"
 #include "M4AD_Common.h"
 #include "M4DA_Types.h"
@@ -591,54 +586,6 @@ M4OSA_ERR M4VSS3GPP_editCleanUp(M4VSS3GPP_EditContext pContext);
 
 /**
  ******************************************************************************
- * M4OSA_ERR M4VSS3GPP_editRegisterExternalVideoDecoder(M4VSS3GPP_EditContext pContext,
- *                                     M4VD_VideoType decoderType,
- *                                     M4VD_Interface*    pDecoderInterface,
- *                                     M4OSA_Void* pUserData)
- * @brief    Registers an external Video decoder
- * @note
- * @param   pContext           (IN) VSS3GPP context
- * @param   decoderType        (IN) Type of decoder (MPEG4 ...)
- * @param   pDecoderInterface  (IN) Decoder interface
- * @param   pUserData          (IN) Pointer on a user data to give to external decoder
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:        VSS3GPP is not in an appropriate state for this function
- *                              to be called
- ******************************************************************************
- */
-M4OSA_ERR M4VSS3GPP_editRegisterExternalVideoDecoder(M4VSS3GPP_EditContext pContext,
-                                     M4VD_VideoType decoderType,
-                                     M4VD_Interface*    pDecoderInterface,
-                                     M4OSA_Void* pUserData);
-
-/**
- ******************************************************************************
- *M4OSA_ERR M4VSS3GPP_editRegisterExternalVideoEncoder(M4VSS3GPP_EditContext pContext,
- *                                     M4VE_EncoderType encoderType,
- *                                     M4VE_Interface*    pEncoderInterface,
- *                                     M4OSA_Void* pUserData)
- * @brief    Registers an external Video encoder
- * @note
- * @param   pContext           (IN) VSS3GPP context
- * @param   encoderType        (IN) Type of encoder (MPEG4 ...)
- * @param   pEncoderInterface  (IN) Encoder interface
- * @param   pUserData          (IN) Pointer on a user data to give to external encoder
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:        VSS3GPP is not in an appropriate state for this function
- *                              to be called
- ******************************************************************************
- */
-M4OSA_ERR M4VSS3GPP_editRegisterExternalVideoEncoder(M4VSS3GPP_EditContext pContext,
-                                     M4VE_EncoderType encoderType,
-                                     M4VE_Interface*    pEncoderInterface,
-                                     M4OSA_Void* pUserData);
-
-
-
-/**
- ******************************************************************************
  ******************************************************************************
  ******************************************************************************
  *
@@ -828,33 +775,6 @@ M4OSA_ERR M4VSS3GPP_extractPictureCleanUp(M4VSS3GPP_ExtractPictureContext pConte
 
 /**
  ******************************************************************************
- * M4OSA_ERR M4VSS3GPP_extractPictureRegisterExternalVideoDecoder(
- *                   M4VSS3GPP_ExtractPictureContext pContext,
- *                                     M4VD_VideoType decoderType,
- *                                     M4VD_Interface*    pDecoderInterface,
- *                                     M4OSA_Void* pUserData)
- * @brief    Registers an external Video decoder
- * @note
- * @param   pContext           (IN) Extract picture context
- * @param   decoderType        (IN) Type of decoder (MPEG4 ...)
- * @param   pDecoderInterface  (IN) Decoder interface
- * @param   pUserData          (IN) Pointer on a user data to give to external decoder
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:        Extract picture is not in an appropriate state for this
- *                              function to be called
- ******************************************************************************
- */
-M4OSA_ERR M4VSS3GPP_extractPictureRegisterExternalVideoDecoder(\
-                   M4VSS3GPP_ExtractPictureContext pContext,
-                                     M4VD_VideoType decoderType,
-                                     M4VD_Interface*    pDecoderInterface,
-                                     M4OSA_Void* pUserData);
-
-
-
-/**
- ******************************************************************************
  ******************************************************************************
  ******************************************************************************
  *
@@ -893,66 +813,6 @@ M4OSA_ERR M4VSS3GPP_GetErrorMessage(M4OSA_ERR err, M4OSA_Char* sMessage);
 #endif /**< WIN32 */
 
 
-
-
-/**
- ******************************************************************************
- * M4OSA_ERR M4VSS3GPP_editRegisterExternalCodec(
- *                                                             M4VSS3GPP_EditContext    pContext,
- *                                     M4VSS3GPP_codecType        codecType,
- *                                     M4OSA_Context    pCodecInterface,
- *                                     M4OSA_Void* pUserData)
- * @brief    Registers an external Video/Audio codec with VSS3GPP
- * @note This is much different from the other external codec registration API to
- *       cope up with specific requirement of OMX codec implementation.
- *
- * @param  pContext           (IN) VSS3GPP context
- * @param  codecType        (IN) Type of codec (MPEG4 ...)
- * @param  pCodecInterface  (IN) Codec interface
- * @param  pUserData          (IN) Pointer on a user data to give to external codec
- * @return  M4NO_ERROR:       No error
- * @return  M4ERR_PARAMETER:  At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:     VSS3GPP is not in an appropriate state for this function to be called
- ******************************************************************************
- */
- M4OSA_ERR M4VSS3GPP_editRegisterExternalCodec(M4VSS3GPP_EditContext pContext,
-                                     M4VSS3GPP_codecType codecType,
-                                     M4OSA_Context    pCodecInterface,
-                                     M4OSA_Void* pUserData);
-
-/**
- ******************************************************************************
- * M4OSA_ERR M4VSS3GPP_editSubscribeExternalCodecs(M4VSS3GPP_EditContext    pContext)
- * @brief    Subscribes to previously registered external Video/Audio codec
- * @note This is much different from the other external codec registration API to
- *       cope up with specific requirement of OMX codec implementation.
- *
- * @param  pContext           (IN) VSS3GPP context
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:     VSS3GPP is not in an appropriate state for this function to be called
- ******************************************************************************
- */
- M4OSA_ERR M4VSS3GPP_editSubscribeExternalCodecs(M4VSS3GPP_EditContext pContext);
-
-/**
- ******************************************************************************
- * M4OSA_ERR M4VSS3GPP_intSubscribeExternalCodecs(M4VSS3GPP_EditContext    pContext,
- *                                                M4OSA_Context pShellCtxt)
- * @brief    Subscribes to previously registered external Video/Audio codec
- * @note This is much different from the other external codec registration API to
- *       cope up with specific requirement of OMX codec implementation.
- *
- * @param  pContext           (IN) VSS3GPP context
- * @param pShellContext    (IN) Media Codec shell context
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:     VSS3GPP is not in an appropriate state for this function to be called
- ******************************************************************************
- */
- M4OSA_ERR M4VSS3GPP_intSubscribeExternalCodecs(M4VSS3GPP_EditContext pContext,
-                                                M4OSA_Context pShellCtxt);
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/libvideoeditor/vss/inc/M4VSS3GPP_InternalFunctions.h b/libvideoeditor/vss/inc/M4VSS3GPP_InternalFunctions.h
index aeddd97..ea09caa 100755
--- a/libvideoeditor/vss/inc/M4VSS3GPP_InternalFunctions.h
+++ b/libvideoeditor/vss/inc/M4VSS3GPP_InternalFunctions.h
@@ -39,10 +39,6 @@
 
 #include "M4READER_Common.h" /**< for M4_AccessUnit definition */
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-#include "M4VD_HW_API.h"
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -607,13 +603,6 @@ M4OSA_ERR M4VSS3GPP_intAudioMixingCompatibility(M4VSS3GPP_InternalAudioMixingCon
 */
 M4OSA_Void M4VSS3GPP_intClipDeleteAudioTrack(M4VSS3GPP_ClipContext *pClipCtxt);
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-M4OSA_ERR M4VSS3GPP_intClipRegisterExternalVideoDecoder(M4VSS3GPP_ClipContext *pClipCtxt,
-                                     M4VD_VideoType decoderType,
-                                     M4VD_Interface*    pDecoderInterface,
-                                     M4OSA_Void* pUserData);
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
 /******************************************************************************
  * M4OSA_ERR M4VSS3GPP_intStartAU()
  * @brief    StartAU writer-like interface used for the VSS 3GPP only
diff --git a/libvideoeditor/vss/inc/M4VSS3GPP_InternalTypes.h b/libvideoeditor/vss/inc/M4VSS3GPP_InternalTypes.h
index bf627c7..f01e371 100755
--- a/libvideoeditor/vss/inc/M4VSS3GPP_InternalTypes.h
+++ b/libvideoeditor/vss/inc/M4VSS3GPP_InternalTypes.h
@@ -53,10 +53,6 @@
 #include "From2iToMono_16.h"        /**< Stereo to Mono     */
 #include "MonoTo2I_16.h"            /**< Mono to Stereo     */
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-#include "M4VD_HW_API.h"
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -599,19 +595,6 @@ typedef struct
      * Interfaces of the used modules */
     M4VSS3GPP_MediaAndCodecCtxt         ShellAPI;           /**< Filesystem and shell reader,
                                                                  decoder functions */
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-    struct
-    {
-        M4VD_Interface*    pDecoderInterface;
-        M4OSA_Void*        pUserData;
-        M4OSA_Bool        registered;
-    } registeredExternalDecs[M4VD_kVideoType_NB];
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-#ifdef M4VSS_SUPPORT_OMX_CODECS
-    M4OSA_Context        m_codecInterface[M4VSS3GPP_kCodecType_NB];
-    M4OSA_Context        pOMXUserData;
-#endif
     M4OSA_Bool               bIssecondClip;
     M4OSA_UInt8              *pActiveEffectsList1;  /**< List of the active effects settings. Array of nbEffects RC */
     M4OSA_UInt8              nbActiveEffects1;  /**< Numbers of active effects RC */
diff --git a/libvideoeditor/vss/inc/M4xVSS_API.h b/libvideoeditor/vss/inc/M4xVSS_API.h
index d69a17c..a66211b 100755
--- a/libvideoeditor/vss/inc/M4xVSS_API.h
+++ b/libvideoeditor/vss/inc/M4xVSS_API.h
@@ -374,50 +374,6 @@ M4OSA_ERR M4xVSS_CloseCommand(M4OSA_Context pContext);
 M4OSA_ERR M4xVSS_CleanUp(M4OSA_Context pContext);
 
 /**
-******************************************************************************
- * M4OSA_ERR M4xVSS_RegisterExternalVideoDecoder(M4OSA_Context pContext,
- *                                     M4VD_VideoType decoderType,
- *                                     M4VD_Interface*    pDecoderInterface,
- *                                     M4OSA_Void* pUserData)
- * @brief    Registers an external Video decoder
- * @note
- * @param   pContext           (IN) xVSS context
- * @param   decoderType        (IN) Type of decoder (MPEG4 ...)
- * @param   pDecoderInterface  (IN) Decoder interface
- * @param   pUserData          (IN) Pointer on a user data to give to external decoder
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:        xVSS is not in an appropriate state for this function to be called
-******************************************************************************
-*/
-M4OSA_ERR M4xVSS_RegisterExternalVideoDecoder(M4OSA_Context pContext,
-                                     M4VD_VideoType decoderType,
-                                     M4VD_Interface*    pDecoderInterface,
-                                     M4OSA_Void* pUserData);
-
-/**
-******************************************************************************
- * M4OSA_ERR M4xVSS_RegisterExternalVideoEncoder(M4OSA_Context pContext,
- *                                     M4VE_EncoderType encoderType,
- *                                     M4VE_Interface*    pEncoderInterface,
- *                                     M4OSA_Void* pUserData)
- * @brief    Registers an external Video decoder
- * @note
- * @param   pContext           (IN) xVSS context
- * @param   encoderType        (IN) Type of encoder (MPEG4 ...)
- * @param   pEncoderInterface  (IN) Encoder interface
- * @param   pUserData          (IN) Pointer on a user data to give to external encoder
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:        xVSS is not in an appropriate state for this function to be called
-******************************************************************************
-*/
-M4OSA_ERR M4xVSS_RegisterExternalVideoEncoder(M4OSA_Context pContext,
-                                     M4VE_EncoderType encoderType,
-                                     M4VE_Interface*    pEncoderInterface,
-                                     M4OSA_Void* pUserData);
-
-/**
  ******************************************************************************
  * prototype    M4xVSS_GetVersion(M4_VersionInfo *pVersion)
  * @brief        This function get the version of the Video Studio 2.1
diff --git a/libvideoeditor/vss/inc/M4xVSS_Internal.h b/libvideoeditor/vss/inc/M4xVSS_Internal.h
index 0f99632..e999867 100755
--- a/libvideoeditor/vss/inc/M4xVSS_Internal.h
+++ b/libvideoeditor/vss/inc/M4xVSS_Internal.h
@@ -479,20 +479,6 @@ typedef struct {
     /*UTF Conversion support*/
     M4xVSS_UTFConversionContext    UTFConversionContext;    /*UTF conversion context structure*/
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-    struct
-    {
-        M4VD_Interface*    pDecoderInterface;
-        M4OSA_Void*        pUserData;
-        M4OSA_Bool        registered;
-    } registeredExternalDecs[M4VD_kVideoType_NB];
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-    struct
-    {
-        M4VE_Interface*    pEncoderInterface;
-        M4OSA_Void*        pUserData;
-        M4OSA_Bool        registered;
-    } registeredExternalEncs[M4VE_kEncoderType_NB];
 } M4xVSS_Context;
 
 /**
diff --git a/libvideoeditor/vss/mcs/inc/M4MCS_API.h b/libvideoeditor/vss/mcs/inc/M4MCS_API.h
index 2592fb4..7fb64e8 100755
--- a/libvideoeditor/vss/mcs/inc/M4MCS_API.h
+++ b/libvideoeditor/vss/mcs/inc/M4MCS_API.h
@@ -46,9 +46,6 @@
  * Common definitions of video editing components */
 #include "M4_VideoEditingCommon.h"
 
-#include "M4VD_HW_API.h"
-#include "M4VE_API.h"
-
 /**
  * To enable external audio codecs registering*/
 #include "M4AD_Common.h"
@@ -259,27 +256,6 @@ typedef enum
     M4MCS_kCropBeforeResize      = 0x01  /*Input image is cropped (before changing resolution)*/
 } M4MCS_SPCrop ;
 
-/**
- ******************************************************************************
- * enum      M4MCS_ExifInfos
- * @brief    Still picture specific : The following structure contains all available exif field
- ******************************************************************************
- */
-typedef struct {
-    M4OSA_Char* ImageTitle;              /* Image title */
-    M4OSA_Char* EquipmentManufacturer;   /* Image input equipment manufacturer */
-    M4OSA_Char* EquipmentModel;          /* Image input equipment model */
-    M4OSA_Char* Software;                /* Software used */
-    M4OSA_Char* Artist;                  /* Artist */
-    M4OSA_Char* Copyright;               /* Copyright */
-    M4OSA_Char* CreationDateTime;        /* Creation date and time */
-    M4OSA_UInt32 Orientation;            /* Orientation of the picture */
-    M4OSA_Char* LastChangeDateTime;      /* Last Change date and time*/
-    M4OSA_UInt32 PixelXDimension;        /* Image width*/
-    M4OSA_UInt32 PixelYDimension;        /* Image Height*/
-} M4MCS_ExifInfos;
-
-/*--- STILL PICTURE ---*/
 
 /**
  ******************************************************************************
@@ -590,74 +566,6 @@ M4OSA_ERR M4MCS_getExtendedEncodingParams(M4MCS_Context pContext, M4MCS_Encoding
  */
 M4OSA_ERR M4MCS_checkParamsAndStart(M4MCS_Context pContext);
 
-/**
- ******************************************************************************
- * M4OSA_ERR M4MCS_registerExternalVideoDecoder(M4MCS_Context pContext,
- *                                     M4VD_VideoType decoderType,
- *                                     M4VD_Interface*    pDecoderInterface,
- *                                     M4OSA_Void* pUserData)
- * @brief    Registers an external Video decoder
- * @note
- * @param   pContext           (IN) MCS context
- * @param   decoderType        (IN) Type of decoder (MPEG4 ...)
- * @param   pDecoderInterface  (IN) Decoder interface
- * @param   pUserData          (IN) Pointer on a user data to give to external decoder
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
- ******************************************************************************
- */
-M4OSA_ERR M4MCS_registerExternalVideoDecoder(M4MCS_Context pContext,
-                                     M4VD_VideoType decoderType,
-                                     M4VD_Interface*    pDecoderInterface,
-                                     M4OSA_Void* pUserData);
-
-M4OSA_ERR M4MCS_registerExternalVideoEncoder(M4MCS_Context pContext,
-                                     M4VE_EncoderType encoderType,
-                                     M4VE_Interface*    pEncoderInterface,
-                                     M4OSA_Void* pUserData);
-
-
-/**
- ************************************************************************
- * M4OSA_ERR M4MCS_registerExternalAudioDecoder(M4MCS_Context pContext,
- *                                    M4AD_Type decoderType,
- *                                    M4AD_Interface *pDecoderInterface);
- * @brief    This function will register a specific external audio decoder.
- * @note    According to the decoderType, this function will store in the internal context
- *          the decoder interface.
- * @param    context            (IN/OUT) MCS context.
- * @param    decoderType        (IN) Audio decoder type
- * @param    pDecoderInterface  (IN) Audio decoder interface.
- * @return   M4NO_ERROR:        No error
- * @return   M4ERR_PARAMETER:   A parameter is null, or the decoder type is invalid(in DEBUG only)
- ************************************************************************
- */
-M4OSA_ERR M4MCS_registerExternalAudioDecoder(M4MCS_Context pContext,
-                                    M4AD_Type decoderType,
-                                    M4AD_Interface *pDecoderInterface);
-
-
-/**
- ******************************************************************************
- * M4OSA_ERR   M4MCS_registerExternalAudioEncoder(M4MCS_Context pContext,
- *                                    M4ENCODER_AudioFormat mediaType,
- *                                    M4ENCODER_AudioGlobalInterface *pEncGlobalInterface)
- * @brief    This function will register a specific external audio encoder.
- * @note    According to the Mediatype, this function will store in the internal context
- *          the encoder interface.
- * @param    pContext:                (IN) Execution context.
- * @param    mediaType:                (IN) The media type.
- * @param    pEncGlobalInterface:    (OUT) the encoder interface functions.
- * @return    M4NO_ERROR: there is no error
- * @return    M4ERR_PARAMETER: pContext or pEncGlobalInterface is M4OSA_NULL (debug only)
- ******************************************************************************
- */
-M4OSA_ERR M4MCS_registerExternalAudioEncoder(M4MCS_Context pContext,
-                                    M4ENCODER_AudioFormat MediaType,
-                                    M4ENCODER_AudioGlobalInterface *pEncGlobalInterface);
-
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/libvideoeditor/vss/mcs/src/M4MCS_API.c b/libvideoeditor/vss/mcs/src/M4MCS_API.c
index 91e3b96..db6d92f 100755
--- a/libvideoeditor/vss/mcs/src/M4MCS_API.c
+++ b/libvideoeditor/vss/mcs/src/M4MCS_API.c
@@ -10799,299 +10799,3 @@ M4OSA_ERR M4MCS_open_normalMode(M4MCS_Context pContext, M4OSA_Void* pFileIn,
     return M4NO_ERROR;
 }
 
-
-M4OSA_ERR M4MCS_registerExternalVideoDecoder( M4MCS_Context pContext,
-                                             M4VD_VideoType decoderType,
-                                             M4VD_Interface *pDecoderInterface,
-                                             M4OSA_Void *pUserData )
-{
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-
-    M4OSA_ERR err = M4NO_ERROR;
-    M4DECODER_VideoInterface *shellInterface;
-    M4DECODER_VideoType nativeType;
-    M4DECODER_EXTERNAL_UserDataType shellUserData;
-
-    switch( decoderType )
-    {
-        case M4VD_kMpeg4VideoDec:
-        case M4VD_kH263VideoDec:
-            nativeType = M4DECODER_kVideoTypeMPEG4;
-            break;
-
-        case M4VD_kH264VideoDec:
-            nativeType = M4DECODER_kVideoTypeAVC;
-            break;
-
-        default:
-            M4OSA_TRACE1_1(
-                "M4MCS_registerExternalVideoDecoder: unknown decoderType %d",
-                decoderType);
-            return M4ERR_PARAMETER;
-            break;
-    }
-
-    shellUserData =
-        (M4DECODER_EXTERNAL_UserDataType)M4OSA_32bitAlignedMalloc(sizeof(*shellUserData),
-        M4MCS,
-        (M4OSA_Char *)"userData structure for the external shell decoder");
-
-    if( M4OSA_NULL == shellUserData )
-    {
-        M4OSA_TRACE1_0(
-            "M4MCS_registerExternalVideoDecoder:\
-                 failed to allocate userData structure for the external shell decoder");
-        return M4ERR_ALLOC;
-    }
-
-    shellUserData->externalFuncs = pDecoderInterface;
-    shellUserData->externalUserData = pUserData;
-
-    err = M4DECODER_EXTERNAL_getInterface(&shellInterface);
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4MCS_registerExternalVideoDecoder:\
-                 M4DECODER_EXTERNAL_getInterface failed with error 0x%08X",
-            err);
-        free(shellUserData);
-        return err;
-    }
-
-    err = M4MCS_registerVideoDecoder(pContext, nativeType, shellInterface);
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4MCS_registerExternalVideoDecoder:\
-                 M4MCS_registerVideoDecoder failed with error 0x%08X",
-            err);
-        free(shellInterface);
-        free(shellUserData);
-        return err;
-    }
-
-    ( (M4MCS_InternalContext
-        *)pContext)->m_pVideoDecoderUserDataTable[nativeType] = shellUserData;
-
-    return M4NO_ERROR;
-#else
-
-    return M4ERR_NOT_IMPLEMENTED;
-
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-}
-
-M4OSA_ERR M4MCS_registerExternalVideoEncoder( M4MCS_Context pContext,
-                                             M4VE_EncoderType encoderType,
-                                             M4VE_Interface *pEncoderInterface,
-                                             M4OSA_Void *pUserData )
-{
-#ifdef M4VSS_ENABLE_EXTERNAL_ENCODERS
-
-    M4OSA_ERR err = M4NO_ERROR;
-    M4ENCODER_GlobalInterface *shellInterface;
-    M4ENCODER_Format nativeType;
-
-    switch( encoderType )
-    {
-        case M4VE_kH263VideoEnc:
-            err = M4EGE_H263_getInterfaces(&nativeType, &shellInterface,
-                M4ENCODER_OPEN_ADVANCED);
-
-            break;
-
-        case M4VE_kMpeg4VideoEnc:
-            err = M4EGE_MPEG4_getInterfaces(&nativeType, &shellInterface,
-                M4ENCODER_OPEN_ADVANCED);
-            break;
-
-        case M4VE_kH264VideoEnc:
-            M4OSA_TRACE1_0(
-                "M4MCS_registerExternalVideoEncoder: H264 encoder type not implemented yet");
-            return M4ERR_NOT_IMPLEMENTED;
-            break;
-
-        default:
-            M4OSA_TRACE1_1(
-                "M4MCS_registerExternalVideoEncoder: unknown encoderType %d",
-                encoderType);
-            return M4ERR_PARAMETER;
-            break;
-    }
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4MCS_registerExternalVideoDecoder: M4EGE_getInterface failed with error 0x%08X",
-            err);
-        return err;
-    }
-
-    err = M4MCS_registerVideoEncoder(pContext, nativeType, shellInterface);
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4MCS_registerExternalVideoEncoder:\
-                 M4MCS_registerVideoEncoder failed with error 0x%08X",
-            err);
-        free(shellInterface);
-        return err;
-    }
-
-    ( (M4MCS_InternalContext
-        *)pContext)->pVideoEncoderExternalAPITable[nativeType]
-    = pEncoderInterface;
-    ( (M4MCS_InternalContext
-        *)pContext)->pVideoEncoderUserDataTable[nativeType] = pUserData;
-
-    return M4NO_ERROR;
-
-#else
-
-    return M4ERR_NOT_IMPLEMENTED;
-
-#endif
-
-}
-
-/**
- ************************************************************************
- * M4OSA_ERR M4MCS_registerExternalAudioDecoder(M4MCS_Context pContext,
- *                                    M4AD_Type decoderType,
- *                                    M4AD_Interface *pDecoderInterface);
- * @brief    This function will register a specific external audio decoder.
- * @note    According to the decoderType, this function will store in the internal context the
- *                decoder interface.
- * @param    context                (IN/OUT) MCS context.
- * @param    decoderType            (IN) Audio decoder type
- * @param    pDecoderInterface    (IN) Audio decoder interface.
- * @return    M4NO_ERROR:            No error
- * @return    M4ERR_PARAMETER:    A parameter is null, or the decoder type is invalid
- *                                (in DEBUG only)
- ************************************************************************
- */
-M4OSA_ERR M4MCS_registerExternalAudioDecoder( M4MCS_Context pContext,
-                                             M4AD_Type decoderType,
-                                             M4AD_Interface *pDecoderInterface )
-{
-    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)pContext;
-
-    M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
-        "M4MCS_registerExternalAudioDecoder: invalid context pointer");
-    M4OSA_DEBUG_IF1((M4OSA_NULL == pDecoderInterface), M4ERR_PARAMETER,
-        "M4MCS_registerExternalAudioDecoder: invalid pointer on decoder interface");
-
-    if( M4MCS_kState_CREATED != pC->State )
-    {
-        M4OSA_TRACE1_1(
-            "M4MCS_registerExternalAudioDecoder(): Wrong State (%d), returning M4ERR_STATE",
-            pC->State);
-        return M4ERR_STATE;
-    }
-
-    if( decoderType >= M4AD_kType_NB )
-    {
-        M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
-            "M4MCS_registerExternalAudioDecoder: Invalid audio decoder type");
-        return M4ERR_PARAMETER;
-    }
-
-    if( pC->m_pAudioDecoderFlagTable[decoderType] == M4OSA_TRUE
-        && pC->m_pAudioDecoderItTable[decoderType] != M4OSA_NULL )
-    {
-        M4OSA_TRACE1_1(
-            "M4MCS_registerExternalAudioDecoder: error parameter: an external decoder of type\
-                 %i is already registered",
-            decoderType);
-        return M4ERR_PARAMETER;
-    }
-
-    if( pC->m_pAudioDecoderItTable[decoderType] != M4OSA_NULL )
-    {
-        free(pC->m_pAudioDecoderItTable[decoderType]);
-        pC->m_pAudioDecoderItTable[decoderType] = M4OSA_NULL;
-    }
-
-    pC->m_pAudioDecoderItTable[decoderType] = pDecoderInterface;
-    pC->m_pAudioDecoderFlagTable[decoderType] =
-        M4OSA_TRUE; /* external decoder */
-
-    return M4NO_ERROR;
-}
-
-/**
- ******************************************************************************
- * M4OSA_ERR   M4MCS_registerExternalAudioEncoder(M4MCS_Context pContext,
- *                                             M4ENCODER_AudioFormat mediaType,
- *                                             M4ENCODER_AudioGlobalInterface *pEncGlobalInterface)
- * @brief    This function will register a specific external audio encoder.
- * @note    According to the Mediatype, this function will store in the internal context the
- *             encoder context.
- * @param    pContext:                (IN) Execution context.
- * @param    mediaType:                (IN) The media type.
- * @param    pEncGlobalInterface:    (OUT) the encoder interface functions.
- * @return    M4NO_ERROR: there is no error
- * @return    M4ERR_PARAMETER: pContext or pEncGlobalInterface is M4OSA_NULL (debug only)
- ******************************************************************************
- */
-M4OSA_ERR M4MCS_registerExternalAudioEncoder( M4MCS_Context pContext,
-                                             M4ENCODER_AudioFormat MediaType,
-                                             M4ENCODER_AudioGlobalInterface *pEncGlobalInterface )
-{
-    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)pContext;
-
-    /**
-    *    Check input parameters */
-    M4OSA_DEBUG_IF2((pC == M4OSA_NULL), M4ERR_PARAMETER,
-        "MCS: context is M4OSA_NULL in M4MCS_registerExternalAudioEncoder");
-    M4OSA_DEBUG_IF2((pEncGlobalInterface == M4OSA_NULL), M4ERR_PARAMETER,
-        "pEncGlobalInterface is M4OSA_NULL in M4MCS_registerExternalAudioEncoder");
-
-    M4OSA_TRACE3_2(
-        "MCS: M4MCS_registerExternalAudioEncoder called with pContext=0x%x, \
-        pEncGlobalInterface=0x%x",
-        pC, pEncGlobalInterface);
-
-    if( M4MCS_kState_CREATED != pC->State )
-    {
-        M4OSA_TRACE1_1(
-            "M4MCS_registerExternalAudioEncoder(): Wrong State (%d), returning M4ERR_STATE",
-            pC->State);
-        return M4ERR_STATE;
-    }
-
-    if( MediaType >= M4ENCODER_kAudio_NB )
-    {
-        M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
-            "M4MCS_registerExternalAudioEncoder(): Invalid audio encoder type");
-        return M4ERR_PARAMETER;
-    }
-
-    if( pC->pAudioEncoderFlag[MediaType] == M4OSA_TRUE
-        && pC->pAudioEncoderInterface[MediaType] != M4OSA_NULL )
-    {
-        M4OSA_TRACE1_1(
-            "M4MCS_registerExternalAudioEncoder: error parameter:\
-             an external encoder of type %i is already registered",
-            MediaType);
-        return M4ERR_PARAMETER;
-    }
-
-    if( pC->pAudioEncoderInterface[MediaType] != M4OSA_NULL )
-    {
-        free(pC->pAudioEncoderInterface[MediaType]);
-        pC->pAudioEncoderInterface[MediaType] = M4OSA_NULL;
-    }
-
-    /*
-    * Save encoder interface in context */
-    pC->pAudioEncoderInterface[MediaType] = pEncGlobalInterface;
-    pC->pAudioEncoderFlag[MediaType] = M4OSA_TRUE; /* external encoder */
-
-    return M4NO_ERROR;
-}
-
diff --git a/libvideoeditor/vss/mcs/src/M4MCS_BitstreamParser.c b/libvideoeditor/vss/mcs/src/M4MCS_BitstreamParser.c
deleted file mode 100755
index 8c05191..0000000
--- a/libvideoeditor/vss/mcs/src/M4MCS_BitstreamParser.c
+++ /dev/null
@@ -1,944 +0,0 @@
-/*
- * 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   M4MCS_Parsing.c
- * @brief  MCS implementation (Video Compressor Service)
- * @note   This file implements the VOL parsing and timescale 'on the fly' modification
- *************************************************************************
- **/
-
-/**
- ********************************************************************
- * Includes
- ********************************************************************
- */
-
-/* Core headers */
-#include "M4MCS_API.h"
-#include "M4MCS_InternalTypes.h"
-#include "M4VD_Tools.h"
-
-
-#ifdef TIMESCALE_BUG
-
-/*typedef struct
-{
-    M4OSA_UInt32 stream_byte;
-    M4OSA_UInt32 stream_index;
-    M4OSA_MemAddr8 in;
-
-} M4MCS_Bitstream_ctxt;*/
-typedef M4VS_Bitstream_ctxt M4MCS_Bitstream_ctxt;
-
-/*
- ************************************************************************
- * M4OSA_UInt32 M4MCS_GetBitsFromMemory( )
- * @brief
- * @return
- ************************************************************************
- */
-static M4OSA_UInt32 M4MCS_GetBitsFromMemory(
-                                    M4MCS_Bitstream_ctxt* parsingCtxt,
-                                    M4OSA_UInt32 nb_bits)
-{
-    return(M4VD_Tools_GetBitsFromMemory((M4VS_Bitstream_ctxt*) parsingCtxt, nb_bits));
-}
-
-/**
- ***********************************************************************
- * M4OSA_ERR M4MCS_WriteBitsToMemory( )
- * @brief
- * @return
- ***********************************************************************
- */
-static M4OSA_ERR M4MCS_WriteBitsToMemory(   M4OSA_UInt32 bitsToWrite,
-                                            M4OSA_MemAddr32 dest_bits,
-                                            M4OSA_UInt8 offset,
-                                            M4OSA_UInt8 nb_bits)
-{
-    return (M4VD_Tools_WriteBitsToMemory(bitsToWrite,
-                                         dest_bits,
-                                         offset, nb_bits));
-}
-
-/**
- ************************************************************************
- * M4OSA_ERR M4MCS_WriteByteToMemory( )
- * @brief
- * @return
- ************************************************************************
- */
-static M4OSA_ERR M4MCS_WriteByteToMemory(   M4OSA_UInt8 BytesToWrite,
-                                            M4OSA_MemAddr8 dest_bytes)
-{
-    M4OSA_MemAddr8 addr = dest_bytes;
-
-    *addr = BytesToWrite;
-
-    return M4NO_ERROR;
-}
-
-/**
- ************************************************************************
- * M4OSA_Void M4MCS_intCheckIndex( )
- * @brief :
- * @note :    This function can be used to write until 15 bits ...
- *            Depending on the bits offset, it increases or not the 8 bits pointer.
- *            It must be called if more than 8 bits have to be written not consequently.
- * @return
- ************************************************************************
- */
-static M4OSA_Void M4MCS_intCheckIndex(  M4OSA_UInt8 *index,
-                                        M4OSA_UInt32 a,
-                                        M4OSA_MemAddr8* in)
-{
-    M4OSA_UInt32 offset = a;
-
-    if(offset > 8 && offset <=16)
-    {
-        offset-=8;
-        (*in)++;
-    }
-    if((*index+offset) >= 8)
-    {
-        *index = (*index+offset)-8;
-        (*in)++;
-    }
-    else
-    {
-        *index += offset;
-    }
-}
-
-/**
- ************************************************************************
- * M4OSA_ERR M4MCS_intParseVideoDSI( )
- * @brief :  This function parses video DSI and changes writer vop time increment resolution
- * @note  :  It also calculates the number of bits on which the vop_time_increment is coded in
- *           the input stream
- * @return
- ************************************************************************
- */
-M4OSA_ERR M4MCS_intParseVideoDSI(M4MCS_InternalContext* pC)
-{
-    M4MCS_Bitstream_ctxt parsingCtxt;
-    M4OSA_UInt32 code,j;
-    M4OSA_MemAddr8 start, in;
-    M4OSA_UInt8 i;
-    M4OSA_UInt32 time_incr_length, new_time_incr_length;
-    M4OSA_UInt8 vol_verid=0, b_hierarchy_type;
-
-    /* Fill default values */
-    pC->volParsing.video_object_layer_shape = 0;
-    pC->volParsing.sprite_enable = 0;
-    pC->volParsing.reduced_resolution_vop_enable = 0;
-    pC->volParsing.scalability = 0;
-    pC->volParsing.enhancement_type = 0;
-    pC->volParsing.complexity_estimation_disable = 0;
-    pC->volParsing.interlaced = 0;
-    pC->volParsing.sprite_warping_points = 0;
-    pC->volParsing.sprite_brightness_change = 0;
-    pC->volParsing.quant_precision = 5;
-
-    parsingCtxt.stream_byte = 0;
-    parsingCtxt.stream_index = 8;
-    parsingCtxt.in = pC->WriterVideoStreamInfo.Header.pBuf;
-
-    start = pC->WriterVideoStreamInfo.Header.pBuf;
-
-    while (parsingCtxt.in - start\
-         < pC->pReaderVideoStream->m_basicProperties.m_decoderSpecificInfoSize)
-    {
-        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-        if (code == 0)
-        {
-            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-            if (code == 0)
-            {
-                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-                if (code == 1)
-                {
-                    /* start code found */
-                    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-                    if(code == 0xB5) /* Visual object start code */
-                    {
-                        /* is object layer identifier */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                        if (code == 1)
-                        {
-                            /* visual object verid */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 4);
-                            vol_verid = code;
-                            /* visual object layer priority */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 3);
-                        }
-                        else
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 7); /* Realign on byte */
-                            vol_verid = 1;
-                        }
-                    }
-                    else if ((code > 0x1F) && (code < 0x30))
-                    { /* find vol start code */
-                        /* random accessible vol */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-
-                        /* video object type indication */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-
-                        /* is object layer identifier */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                        if (code == 1)
-                        {
-                            /* video object layer verid */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 4);
-                            vol_verid = code;
-                            /* video object layer priority */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 3);
-                        }
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 4);/* aspect ratio */
-                        if (code == 15)
-                            /* par_width and par_height (8+8) */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 16);
-                        /* vol control parameters */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                        if (code == 1)
-                        {
-                            /* chroma format + low delay (3+1) */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 3);
-                            /* vbv parameters */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                            if (code == 1)
-                            {
-                                /* first and latter half bitrate + 2 marker bits
-                                  (15 + 1 + 15 + 1)*/
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 32);
-
-                                /* first and latter half vbv buffer size + first half
-                                   vbv occupancy
-                                + marker bits (15+1+3+11+1)*/
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 31);
-
-                                /* first half vbv occupancy + marker bits (15+1)*/
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 16);
-                            }
-                        }
-                        /* video object layer shape */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 2);
-
-                        /* Need to save it for vop parsing */
-                        pC->volParsing.video_object_layer_shape = code;
-
-                        if (code != 0) return 0; /* only rectangular case supported */
-                        /* Marker bit */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                        /* VOP time increment resolution */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 16);
-
-                        /* Computes time increment length */
-                        j    = code - 1;
-                        for (i = 0; (i < 32) && (j != 0); j >>=1)
-                        {
-                            i++;
-                        }
-                        time_incr_length = (i == 0) ? 1 : i;
-                        /* Save time increment length and original timescale */
-                        pC->uiOrigTimescaleLength = time_incr_length;
-                        pC->uiOrigVideoTimescale = code;
-
-                        /* Compute new time increment length */
-                        j    = pC->uiVideoTimescale - 1;
-                        for (i = 0; (i < 32) && (j != 0); j >>=1)
-                        {
-                            i++;
-                        }
-                        time_incr_length = (i == 0) ? 1 : i;
-                        /* Save new time increment length */
-                        pC->uiTimescaleLength = time_incr_length;
-
-                        /* Write new VOP time increment resolution */
-                        if(parsingCtxt.stream_index == 0)
-                        {
-                            in = parsingCtxt.in - 2;
-                        }
-                        else
-                        {
-                            in = parsingCtxt.in - 3;
-                        }
-                        M4MCS_WriteByteToMemory(pC->uiVideoTimescale, in,
-                            parsingCtxt.stream_index, 16 );
-
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* Marker bit */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* Fixed VOP rate */
-                        if (code == 1)
-                        {
-                            /* Fixed VOP time increment resolution */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt,
-                                    time_incr_length);
-                        }
-
-                        if(pC->volParsing.video_object_layer_shape != 1) /* 1 = Binary */
-                        {
-                            if(pC->volParsing.video_object_layer_shape == 0) /* 0 = rectangular */
-                            {
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* Marker bit */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 13);/* Width */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* Marker bit */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 13);/* Height */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* Marker bit */
-                            }
-                        }
-
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* interlaced */
-                        pC->volParsing.interlaced = code;
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* OBMC disable */
-
-                        if(vol_verid == 1)
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* sprite enable */
-                            pC->volParsing.sprite_enable = code;
-                        }
-                        else
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 2);/* sprite enable */
-                            pC->volParsing.sprite_enable = code;
-                        }
-                        if ((pC->volParsing.sprite_enable == 1) ||
-                            (pC->volParsing.sprite_enable == 2))
-                            /* Sprite static = 1 and Sprite GMC = 2 */
-                        {
-                            if (pC->volParsing.sprite_enable != 2)
-                            {
-                                /* sprite width */
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 13);
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 1);/* Marker bit */
-                                /* sprite height */
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 13);
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 1);/* Marker bit */
-                                /* sprite l coordinate */
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 13);
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 1);/* Marker bit */
-                                /* sprite top coordinate */
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 13);
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 1);/* Marker bit */
-                            }
-                            /* sprite warping points */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 6);
-                            pC->volParsing.sprite_warping_points = code;
-                            /* sprite warping accuracy */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 2);
-
-                            /* sprite brightness change */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                            pC->volParsing.sprite_brightness_change = code;
-                            if (pC->volParsing.sprite_enable != 2)
-                            {
-                                /* low latency sprite enable */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                            }
-                        }
-                        if ((vol_verid != 1) && (pC->volParsing.video_object_layer_shape != 0))
-                        {
-                            code = M4MCS_GetBitsFromMemory(
-                                    &parsingCtxt, 1);/* sadct disable */
-                        }
-
-                        code = M4MCS_GetBitsFromMemory(
-                                &parsingCtxt, 1); /* not 8 bits */
-                        if (code)
-                        {   /* quant precision */
-                            code = M4MCS_GetBitsFromMemory(
-                                    &parsingCtxt, 4);
-                            pC->volParsing.quant_precision = code;
-                            /* bits per pixel */
-                            code = M4MCS_GetBitsFromMemory(
-                                    &parsingCtxt, 4);
-                        }
-
-                        /* greyscale not supported */
-                        if(pC->volParsing.video_object_layer_shape == 3)
-                        {
-                            /* nogray quant update + composition method + linear composition */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 3);
-                        }
-
-                        code = M4MCS_GetBitsFromMemory(
-                                &parsingCtxt, 1);/* quant type */
-                        if (code)
-                        {
-                            /* load intra quant mat */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                            if (code)
-                            {
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 8);
-                                i    = 1;
-                                while (i < 64)
-                                {
-                                    code = M4MCS_GetBitsFromMemory(
-                                            &parsingCtxt, 8);
-                                    if (code == 0)
-                                        break;
-                                    i++;
-                                }
-                            }
-                            /* load non intra quant mat */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                            if (code)
-                            {
-                                code = M4MCS_GetBitsFromMemory(
-                                        &parsingCtxt, 8);
-                                i    = 1;
-                                while (i < 64)
-                                {
-                                    code = M4MCS_GetBitsFromMemory(
-                                            &parsingCtxt, 8);
-                                    if (code == 0)
-                                        break;
-                                    i++;
-                                }
-                            }
-                        }
-
-                        if (vol_verid != 1)
-                        {
-                            code = M4MCS_GetBitsFromMemory(
-                                    &parsingCtxt, 1);/* quarter sample */
-                        }
-                        /* complexity estimation disable */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                        pC->volParsing.complexity_estimation_disable = code;
-                        if (!code)
-                        {
-                            return M4ERR_NOT_IMPLEMENTED;
-                        }
-
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* resync marker disable*/
-
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* data partitionned */
-                        if (code)
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);/* reversible VLC */
-                        }
-
-                        if (vol_verid != 1)
-                        {
-                            code = M4MCS_GetBitsFromMemory(
-                                    &parsingCtxt, 1);/* newpred */
-                            if (code)
-                            {
-                                return M4ERR_PARAMETER;
-                            }
-                            /* reduced resolution vop enable */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                            pC->volParsing.reduced_resolution_vop_enable = code;
-                        }
-
-                        code = M4MCS_GetBitsFromMemory(
-                                &parsingCtxt, 1);/* scalability */
-                        pC->volParsing.scalability = code;
-                        if (code)
-                        {
-                            code = M4MCS_GetBitsFromMemory(
-                                    &parsingCtxt, 1);/* hierarchy type */
-                            b_hierarchy_type = code;
-                            code = M4MCS_GetBitsFromMemory(
-                                    &parsingCtxt, 4);/* ref layer id */
-
-                            /* ref sampling direct */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-
-                            /* hor sampling factor N */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 5);
-
-                            /* hor sampling factor M */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 5);
-
-                            /* vert sampling factor N */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 5);
-
-                            /* vert sampling factor M */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 5);
-
-                            /* enhancement type */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                            pC->volParsing.enhancement_type = code;
-                            if ((!b_hierarchy_type) &&
-                                (pC->volParsing.video_object_layer_shape == 1))
-                            {
-                                /* use ref shape */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                                /* use ref texture */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                                /* shape hor sampling factor N */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 5);
-                                /* shape hor sampling factor M */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 5);
-                                /* shape vert sampling factor N */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 5);
-                                /* shape vert sampling factor M */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 5);
-                            }
-                        }
-                        break;
-                    }
-                }
-                else
-                {
-                    if ((code >> 2) == 0x20)
-                    {
-                        /* H263 ...-> wrong*/
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    return M4NO_ERROR;
-}
-
-/**
- ************************************************************************
- * M4OSA_ERR M4MCS_intChangeAUVideoTimescale( )
- * @brief
- * @return
- ************************************************************************
- */
-M4OSA_ERR M4MCS_intChangeAUVideoTimescale(M4MCS_InternalContext* pC)
-{
-    M4MCS_Bitstream_ctxt parsingCtxt;
-    M4OSA_UInt32 code;
-    M4OSA_MemAddr8 start, in;
-    M4OSA_MemAddr32 in_temp;
-    M4OSA_UInt8 i, in_index=0; /* in_index is the bit index in the input buffer */
-    M4OSA_UInt32 new_time_incr;
-    M4OSA_Int32 diff_timescale= 0 ;
-    M4OSA_UInt32 stuffing_byte=0;
-    M4OSA_UInt8 vopCodingType, vop_fcode_forward, vop_fcode_backward, nb_zeros;
-
-    parsingCtxt.stream_byte = 0;
-    parsingCtxt.stream_index = 8;
-    parsingCtxt.in = pC->ReaderVideoAU.m_dataAddress;
-
-    start = pC->ReaderVideoAU.m_dataAddress;
-    in = pC->WriterVideoAU.dataAddress;
-
-    memset((void *)in, 0, pC->ReaderVideoAU.m_size);
-    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-    M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, 0, 8);
-    in++;
-    if (code == 0)
-    {
-        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, 0, 8);
-        in++;
-        if (code == 0)
-        {
-            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, 0, 8);
-            in++;
-            if (code == 1)
-            {
-                /* start code found */
-                code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-                M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, 0, 8);
-                in++;
-                if (code == 0xB6)
-                { /* find vop start code */
-                    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 2); /* VOP coding type */
-                    M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                            in_index, 2);
-                    M4MCS_intCheckIndex(&in_index,2,&in);
-                    vopCodingType = code; /* Save it before needed further in parsing */
-                    do
-                    {
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* Modulo time base */
-                        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                                in_index, 1);
-                        M4MCS_intCheckIndex(&in_index,1,&in);
-                    } while(code != 0);
-                    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* Marker bit */
-                    M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                            in_index, 1);
-                    M4MCS_intCheckIndex(&in_index,1,&in);
-                    code = M4MCS_GetBitsFromMemory(&parsingCtxt,
-                                            pC->uiOrigTimescaleLength);
-                    /* VOP time increment */
-
-                    /* Calculates new time increment and write it to AU */
-                    new_time_incr = (pC->uiVideoTimescale * code) /
-                                    pC->uiOrigVideoTimescale;
-                    M4MCS_WriteByteToMemory(new_time_incr, in,
-                                    in_index, pC->uiTimescaleLength );
-                    M4MCS_intCheckIndex(&in_index,pC->uiTimescaleLength,
-                                    &in);
-
-                    /* VOP not coded */
-                    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* Marker bit */
-                    M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                    in_index, 1);
-                    M4MCS_intCheckIndex(&in_index,1,&in);
-                    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* VOP not coded bit */
-                    M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                    in_index, 1);
-                    M4MCS_intCheckIndex(&in_index,1,&in);
-                    if(code == 1)
-                    {
-                        //break; /* TODO !!! -> Goto stuffing */
-                    }
-                    /* newpred ignored */
-
-                    if((pC->volParsing.video_object_layer_shape != 2) &&
-                        (vopCodingType == 1 || vopCodingType == 3 &&
-                        pC->volParsing.sprite_enable == 2))
-                    {
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* VOP rounding type */
-                        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                    in_index, 1);
-                        M4MCS_intCheckIndex(&in_index,1,&in);
-                    }
-
-                    if(pC->volParsing.reduced_resolution_vop_enable &&
-                        pC->volParsing.video_object_layer_shape == 0 &&
-                        (vopCodingType == 0 || vopCodingType == 1))
-                    {
-                        /* VOP reduced resolution */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                    in_index, 1);
-                        M4MCS_intCheckIndex(&in_index,1,&in);
-                    }
-
-                    if(pC->volParsing.video_object_layer_shape != 0)
-                    {
-                        if(pC->volParsing.sprite_enable == 1 &&
-                            vopCodingType == 0)
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 13); /* VOP width */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 13);
-                            M4MCS_intCheckIndex(&in_index,13,&in);
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* Marker bit */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                            M4MCS_intCheckIndex(&in_index,1,&in);
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 13); /* VOP height */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 13);
-                            M4MCS_intCheckIndex(&in_index,13,&in);
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* Marker bit */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                            M4MCS_intCheckIndex(&in_index,1,&in);
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 13); /* VOP horizontal
-                                                                              mc spatial ref */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 13);
-                            M4MCS_intCheckIndex(&in_index,13,&in);
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* Marker bit */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                            M4MCS_intCheckIndex(&in_index,1,&in);
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 13); /* VOP vertical
-                                                                              mc spatial ref */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 13);
-                            M4MCS_intCheckIndex(&in_index,13,&in);
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* Marker bit */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                            M4MCS_intCheckIndex(&in_index,1,&in);
-                        }
-                        if(pC->volParsing.video_object_layer_shape != 1 &&
-                            pC->volParsing.scalability &&
-                            pC->volParsing.enhancement_type)
-                        {
-                            /* Background composition */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                            M4MCS_intCheckIndex(&in_index,1,&in);
-                        }
-                        /* Change conv ratio disable */
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-
-                        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                        M4MCS_intCheckIndex(&in_index,1,&in);
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* VOP constant alpha */
-                        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                        M4MCS_intCheckIndex(&in_index,1,&in);
-                        if(code)
-                        {
-                            /* VOP constant alpha value */
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 8);
-                            M4MCS_intCheckIndex(&in_index,8,&in);
-                        }
-                    }
-
-                    if(pC->volParsing.video_object_layer_shape != 2)
-                    {
-                        if(!pC->volParsing.complexity_estimation_disable)
-                        {
-                            return M4ERR_NOT_IMPLEMENTED;
-                        }
-                    }
-
-                    if(pC->volParsing.video_object_layer_shape != 2)
-                    {
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 3); /* intra dc vlc thr */
-                        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 3);
-                        M4MCS_intCheckIndex(&in_index,3,&in);
-                        if(pC->volParsing.interlaced)
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* top field first */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                            M4MCS_intCheckIndex(&in_index,1,&in);
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1); /* alternate vertical
-                                                                             scan flag */
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 1);
-                            M4MCS_intCheckIndex(&in_index,1,&in);
-                        }
-                    }
-
-                    if((pC->volParsing.sprite_enable == 1 || pC->volParsing.sprite_enable == 2) &&
-                        vopCodingType == 3)
-                    {
-                        if(pC->volParsing.sprite_warping_points > 0 ||
-                            (pC->volParsing.sprite_brightness_change))
-                        {
-                            return M4ERR_NOT_IMPLEMENTED;
-                        }
-                        if(pC->volParsing.sprite_enable == 1)
-                        {
-                            return M4ERR_NOT_IMPLEMENTED;
-                        }
-                    }
-
-                    if(pC->volParsing.video_object_layer_shape != 2)
-                    {
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt,
-                            pC->volParsing.quant_precision); /* vop_quant */
-                        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index,
-                            pC->volParsing.quant_precision);
-                        M4MCS_intCheckIndex(&in_index,pC->volParsing.quant_precision,&in);
-                        if(pC->volParsing.video_object_layer_shape == 3)
-                        {
-                            return M4ERR_NOT_IMPLEMENTED;
-                        }
-                        if(vopCodingType != 0) /* P-VOP or S-VOP or B-VOP case */
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 3); /* vop fcode forward*/
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 3);
-                            M4MCS_intCheckIndex(&in_index,3,&in);
-                            vop_fcode_forward = code;
-                        }
-                        if(vopCodingType == 2) /* B-VOP */
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 3); /* vop fcode forward*/
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 3);
-                            M4MCS_intCheckIndex(&in_index,3,&in);
-                            vop_fcode_backward = code;
-                        }
-
-                    }
-
-#if 1
-                    /* Align on read */
-                    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8-(parsingCtxt.stream_index));
-                    M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                        in_index, 8-(parsingCtxt.stream_index));
-                    M4MCS_intCheckIndex(&in_index,8-(parsingCtxt.stream_index),&in);
-
-                    do
-                    {
-                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-                        if(code == 0)
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-                            if(code == 0)
-                            {
-                                nb_zeros = 0;
-                                if((vopCodingType == 1 || vopCodingType == 3)
-                                    && vop_fcode_forward > 1) /* P-VOP or S-VOP case */
-                                {
-                                    code = M4MCS_GetBitsFromMemory(&parsingCtxt,
-                                        vop_fcode_forward-1);
-                                    nb_zeros = vop_fcode_forward-1;
-                                }
-                                else if(vopCodingType == 2 && (vop_fcode_forward > 1 ||
-                                    vop_fcode_backward > 1)) /* B-VOP case */
-                                {
-                                    if(vop_fcode_forward > vop_fcode_backward)
-                                    {
-                                        if(15+vop_fcode_forward > 17)
-                                        {
-                                            code = M4MCS_GetBitsFromMemory(&parsingCtxt,
-                                                vop_fcode_forward-1);
-                                        }
-                                        else
-                                        {
-                                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                                        }
-                                        nb_zeros = vop_fcode_forward-1;
-                                    }
-                                    else
-                                    {
-                                        if(15+vop_fcode_backward > 17)
-                                        {
-                                            code = M4MCS_GetBitsFromMemory(&parsingCtxt,
-                                                vop_fcode_backward-1);
-                                        }
-                                        else
-                                        {
-                                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                                        }
-                                        nb_zeros = vop_fcode_backward-1;
-                                    }
-                                    if(code == 0)
-                                    {
-                                        code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                                        if(code != 1)
-                                        {
-                                            M4MCS_WriteByteToMemory(0, (M4OSA_MemAddr32)in,
-                                                in_index, 8);
-                                            M4MCS_intCheckIndex(&in_index,8,&in);
-                                            M4MCS_WriteByteToMemory(0, (M4OSA_MemAddr32)in,
-                                                in_index, 8);
-                                            M4MCS_intCheckIndex(&in_index,8,&in);
-                                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                                in_index, 1);
-                                            M4MCS_intCheckIndex(&in_index,1,&in);
-                                            goto realign;
-                                        }
-                                        else
-                                        {
-                                            M4MCS_intChangeVideoPacketVideoTimescale(pC );
-                                        }
-                                    }
-                                    else
-                                    {
-
-                                        goto realign;
-                                    }
-                                }
-                                else /* I-VOP case or P-VOP or S-VOP case with
-                                     vop_fcode_forward = 1 */
-                                {
-                                    /* Read next bit that must be one */
-                                    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 1);
-                                    if(code != 1)
-                                    {
-                                        goto realign;
-                                    }
-                                    else
-                                    {
-                                        /* Realign on byte */
-
-                                        /* Write resync marker */
-                                        M4MCS_WriteByteToMemory(0, (M4OSA_MemAddr32)in,
-                                            in_index, 8);
-                                        M4MCS_intCheckIndex(&in_index,8,&in);
-                                        M4MCS_WriteByteToMemory(0, (M4OSA_MemAddr32)in,
-                                            in_index, 8);
-                                        M4MCS_intCheckIndex(&in_index,8,&in);
-                                        M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in,
-                                            in_index, 1);
-                                        M4MCS_intCheckIndex(&in_index,1,&in);
-
-                                        /* Change timescale into video packet header */
-                                        M4MCS_intChangeVideoPacketVideoTimescale(pC );
-                                    }
-
-                                }
-                            }
-                            else
-                            {
-                                M4MCS_WriteByteToMemory(0, (M4OSA_MemAddr32)in, in_index, 8);
-                                M4MCS_intCheckIndex(&in_index,8,&in);
-                                M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 8);
-                                M4MCS_intCheckIndex(&in_index,8,&in);
-realign:
-                                /* Realign on read */
-                                code = M4MCS_GetBitsFromMemory(&parsingCtxt,
-                                    8-(parsingCtxt.stream_index));
-                                M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index,
-                                    8-(parsingCtxt.stream_index));
-                                M4MCS_intCheckIndex(&in_index,8-(parsingCtxt.stream_index),&in);
-                            }
-                        }
-                        else
-                        {
-                            M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 8);
-                            M4MCS_intCheckIndex(&in_index,8,&in);
-                        }
-                    } while(parsingCtxt.in - pC->ReaderVideoAU.m_dataAddress\
-                        < pC->ReaderVideoAU.m_size);
-#else
-                    /* Align on write */
-                    code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8-in_index);
-                    M4MCS_WriteByteToMemory(code, (M4OSA_MemAddr32)in, in_index, 8-in_index);
-                    M4MCS_intCheckIndex(&in_index,8-in_index,&in);
-
-                    /* Read 8 bits words, and write them to the output AU
-                    (write is 8 bits aligned) */
-                    diff_timescale = pC->uiOrigTimescaleLength - pC->uiTimescaleLength;
-                    if(diff_timescale > 0)
-                    {
-                        while (parsingCtxt.in - start <= pC->ReaderVideoAU.m_size)
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-                            //WritebyteToMemory(code, in);
-                            *in = code;
-                            in++;
-                        }
-                    }
-                    else
-                    {
-                        while (parsingCtxt.in - start < pC->ReaderVideoAU.m_size)
-                        {
-                            code = M4MCS_GetBitsFromMemory(&parsingCtxt, 8);
-                            //WritebyteToMemory(code, in);
-                            *in = code;
-                            in++;
-                        }
-                    }
-#endif
-                    in--;
-
-                    for(i=0;i<parsingCtxt.stream_index;i++)
-                    {
-                        stuffing_byte = stuffing_byte << 1;
-                        stuffing_byte += 1;
-                    }
-                    M4MCS_WriteByteToMemory(stuffing_byte, (M4OSA_MemAddr32)in,
-                        8-parsingCtxt.stream_index, parsingCtxt.stream_index);
-                    pC->WriterVideoAU.size = in + 1 - pC->WriterVideoAU.dataAddress;
-                    //*in ;
-                }
-            }
-        }
-    }
-
-    return M4NO_ERROR;
-}
-
-#endif /* TIMESCALE_BUG */
-
diff --git a/libvideoeditor/vss/src/Android.mk b/libvideoeditor/vss/src/Android.mk
index 55a000d..c6fc64a 100755
--- a/libvideoeditor/vss/src/Android.mk
+++ b/libvideoeditor/vss/src/Android.mk
@@ -40,7 +40,6 @@ LOCAL_SRC_FILES:=          \
       M4VSS3GPP_MediaAndCodecSubscription.c \
       M4ChannelCoverter.c \
       M4VD_EXTERNAL_BitstreamParser.c \
-      M4VD_EXTERNAL_Interface.c \
       M4AIR_API.c \
       M4READER_Pcm.c \
       M4PCMR_CoreReader.c \
diff --git a/libvideoeditor/vss/src/M4ChannelCoverter.c b/libvideoeditor/vss/src/M4ChannelCoverter.c
index eee62d8..5d89820 100755
--- a/libvideoeditor/vss/src/M4ChannelCoverter.c
+++ b/libvideoeditor/vss/src/M4ChannelCoverter.c
@@ -44,7 +44,7 @@ void From2iToMono_16( const short *src,
 {
     short ii;
     long Temp;
-    for (ii = n; ii != 0; ii--) {
+    for (ii = n; ii != 0; ii--){
         Temp = (long)*(src++);
         Temp += (long)*(src++);
         *(dst++) = (short)(Temp >>1);
diff --git a/libvideoeditor/vss/src/M4PTO3GPP_API.c b/libvideoeditor/vss/src/M4PTO3GPP_API.c
index e3fe84f..2ce22f6 100755
--- a/libvideoeditor/vss/src/M4PTO3GPP_API.c
+++ b/libvideoeditor/vss/src/M4PTO3GPP_API.c
@@ -242,13 +242,6 @@ M4OSA_ERR M4PTO3GPP_Init(   M4PTO3GPP_Context* pContext,
     pC->pSavedPlane = M4OSA_NULL;
     pC->uiSavedDuration = 0;
 
-    for (i=0; i<M4VE_kEncoderType_NB; i++)
-    {
-        pC->registeredExternalEncs[i].pEncoderInterface = M4OSA_NULL;
-        pC->registeredExternalEncs[i].pUserData = M4OSA_NULL;
-        pC->registeredExternalEncs[i].registered = M4OSA_FALSE;
-    }
-
     M4OSA_TRACE3_0("M4PTO3GPP_Init(): returning M4NO_ERROR");
     return M4NO_ERROR;
 }
@@ -265,7 +258,7 @@ M4OSA_ERR M4PTO3GPP_Init(   M4PTO3GPP_Context* pContext,
  * @return  M4NO_ERROR:         No error
  * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
  * @return  M4ERR_STATE:        M4PTO3GPP is not in an appropriate state for this function to be
-                                  called
+                                 called
  * @return  M4ERR_ALLOC:        There is no more available memory
  * @return  ERR_PTO3GPP_INVALID_VIDEO_FRAME_SIZE_FOR_H263 The output video frame
  *                              size parameter is incompatible with H263 encoding
@@ -317,7 +310,7 @@ M4OSA_ERR M4PTO3GPP_Open(M4PTO3GPP_Context pContext, M4PTO3GPP_Params* pParams)
 
     /**
      * Video Format */
-    if ((M4VIDEOEDITING_kH263 != pParams->OutputVideoFormat) &&
+    if( (M4VIDEOEDITING_kH263 != pParams->OutputVideoFormat) &&
         (M4VIDEOEDITING_kMPEG4 != pParams->OutputVideoFormat) &&
         (M4VIDEOEDITING_kMPEG4_EMP != pParams->OutputVideoFormat) &&
         (M4VIDEOEDITING_kH264 != pParams->OutputVideoFormat))
@@ -328,7 +321,7 @@ M4OSA_ERR M4PTO3GPP_Open(M4PTO3GPP_Context pContext, M4PTO3GPP_Params* pParams)
 
      /**
      * Video Bitrate */
-    if (!((M4VIDEOEDITING_k16_KBPS       == pParams->OutputVideoBitrate) ||
+    if(!((M4VIDEOEDITING_k16_KBPS       == pParams->OutputVideoBitrate) ||
          (M4VIDEOEDITING_k24_KBPS       == pParams->OutputVideoBitrate) ||
          (M4VIDEOEDITING_k32_KBPS       == pParams->OutputVideoBitrate) ||
          (M4VIDEOEDITING_k48_KBPS       == pParams->OutputVideoBitrate) ||
@@ -1263,23 +1256,6 @@ M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC)
     {
         case M4VIDEOEDITING_kMPEG4_EMP: bActivateEmp = M4OSA_TRUE; /* no break */
         case M4VIDEOEDITING_kMPEG4:
-            if (pC->registeredExternalEncs[M4VE_kMpeg4VideoEnc].registered)
-            {
-#ifdef M4VSS_ENABLE_EXTERNAL_ENCODERS
-                pC->m_pEncoderExternalAPI = pC->registeredExternalEncs[M4VE_kMpeg4VideoEnc]
-                .pEncoderInterface;
-                pC->m_pEncoderUserData = pC->registeredExternalEncs[M4VE_kMpeg4VideoEnc].pUserData;
-
-                err = M4EGE_MPEG4_getInterfaces(&encFormat, &pC->m_pEncoderInt,
-                    M4ENCODER_OPEN_ADVANCED);
-#else
-                M4OSA_TRACE1_0("No external MPEG4 encoder available!\
-                               Did you forget to register one?");
-                err = M4ERR_STATE;
-#endif
-            }
-            else
-            {
 #ifdef M4VSS_SUPPORT_ENCODER_MPEG4
                 err = VideoEditorVideoEncoder_getInterface_MPEG4(&encFormat, &pC->m_pEncoderInt,
                     M4ENCODER_OPEN_ADVANCED);
@@ -1287,26 +1263,8 @@ M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC)
                 M4OSA_TRACE1_0("No MPEG4 encoder available! Did you forget to register one?");
                 err = M4ERR_STATE;
 #endif /* software MPEG4 encoder available? */
-            }
             break;
         case M4VIDEOEDITING_kH263:
-            if (pC->registeredExternalEncs[M4VE_kH263VideoEnc].registered)
-            {
-#ifdef M4VSS_ENABLE_EXTERNAL_ENCODERS
-                pC->m_pEncoderExternalAPI = pC->registeredExternalEncs[M4VE_kH263VideoEnc]
-                .pEncoderInterface;
-                pC->m_pEncoderUserData = pC->registeredExternalEncs[M4VE_kH263VideoEnc].pUserData;
-
-                err = M4EGE_H263_getInterfaces(&encFormat, &pC->m_pEncoderInt,
-                    M4ENCODER_OPEN_ADVANCED);
-#else
-                M4OSA_TRACE1_0("No external H263 encoder available! Did you forget to register\
-                               one?");
-                err = M4ERR_STATE;
-#endif
-            }
-            else
-            {
 #ifdef M4VSS_SUPPORT_ENCODER_MPEG4
                 err = VideoEditorVideoEncoder_getInterface_H263(&encFormat, &pC->m_pEncoderInt,
                     M4ENCODER_OPEN_ADVANCED);
@@ -1314,17 +1272,8 @@ M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC)
                 M4OSA_TRACE1_0("No H263 encoder available! Did you forget to register one?");
                 err = M4ERR_STATE;
 #endif /* software H263 encoder available? */
-            }
             break;
         case M4VIDEOEDITING_kH264:
-            if (pC->registeredExternalEncs[M4VE_kH264VideoEnc].registered)
-            {
-                M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing: No external H264 encoder available! \
-                               Did you forget to register one?");
-                err = M4ERR_STATE;
-            }
-            else
-            {
 #ifdef M4VSS_SUPPORT_ENCODER_AVC
                 err = VideoEditorVideoEncoder_getInterface_H264(&encFormat, &pC->m_pEncoderInt,
                     M4ENCODER_OPEN_ADVANCED);
@@ -1333,7 +1282,6 @@ M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC)
                                Did you forget to register one?");
                 err = M4ERR_STATE;
 #endif /* software H264 encoder available? */
-            }
             break;
         default:
             M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning \
@@ -2020,41 +1968,3 @@ static M4OSA_ERR M4PTO3GPP_writeAmrSilence048Frame(M4WRITER_DataInterface* pWrit
 }
 
 
-M4OSA_ERR M4PTO3GPP_RegisterExternalVideoEncoder(M4PTO3GPP_Context pContext,
-                                     M4VE_EncoderType encoderType,
-                                     M4VE_Interface*    pEncoderInterface,
-                                     M4OSA_Void* pUserData)
-{
-    M4OSA_ERR err = M4NO_ERROR;
-    M4PTO3GPP_InternalContext *pC = (M4PTO3GPP_InternalContext*)(pContext);
-
-    switch (encoderType)
-    {
-        case M4VE_kMpeg4VideoEnc:
-        case M4VE_kH263VideoEnc:
-            /* OK */
-        break;
-
-        case M4VE_kH264VideoEnc:
-            M4OSA_TRACE1_0("M4PTO3GPP_RegisterExternalVideoEncoder: \
-                           H264 encoder type not implemented yet");
-            return M4ERR_NOT_IMPLEMENTED;
-        break;
-
-        default:
-            M4OSA_TRACE1_1("M4PTO3GPP_RegisterExternalVideoEncoder:\
-                           unknown encoderType %d", encoderType);
-            return M4ERR_PARAMETER;
-        break;
-    }
-
-    pC->registeredExternalEncs[encoderType].pEncoderInterface = pEncoderInterface;
-    pC->registeredExternalEncs[encoderType].pUserData = pUserData;
-    pC->registeredExternalEncs[encoderType].registered = M4OSA_TRUE;
-
-    /* Notice it overwrites any HW encoder that may already have been registered for this type;
-    this is normal. */
-
-    return M4NO_ERROR;
-}
-
diff --git a/libvideoeditor/vss/src/M4VD_EXTERNAL_BitstreamParser.c b/libvideoeditor/vss/src/M4VD_EXTERNAL_BitstreamParser.c
index b2e8e6f..c8a8aca 100755
--- a/libvideoeditor/vss/src/M4VD_EXTERNAL_BitstreamParser.c
+++ b/libvideoeditor/vss/src/M4VD_EXTERNAL_BitstreamParser.c
@@ -19,7 +19,6 @@
 #include "M4OSA_Debug.h"
 
 #include "M4VD_EXTERNAL_Interface.h"
-#include "M4VD_EXTERNAL_Internal.h"
 #include "M4VD_Tools.h"
 
 /**
diff --git a/libvideoeditor/vss/src/M4VD_EXTERNAL_Interface.c b/libvideoeditor/vss/src/M4VD_EXTERNAL_Interface.c
deleted file mode 100755
index 8258eca..0000000
--- a/libvideoeditor/vss/src/M4VD_EXTERNAL_Interface.c
+++ /dev/null
@@ -1,1126 +0,0 @@
-/*
- * 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    M4VD_EXTERNAL_Interface.c
- * @brief
- * @note
- ******************************************************************************
- */
-
-#include "NXPSW_CompilerSwitches.h"
-
-#include "M4OSA_CoreID.h"
-#include "M4OSA_Types.h"
-#include "M4OSA_Debug.h"
-
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-#include "M4OSA_Semaphore.h"
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-
-#include "M4VD_EXTERNAL_Interface.h"
-#include "M4VD_EXTERNAL_Internal.h"
-
-/* Warning: the decode thread has finished decoding all the frames */
-#define M4WAR_DECODE_FINISHED                                M4OSA_ERR_CREATE(M4_WAR,\
-                                                                 M4DECODER_EXTERNAL, 0x0001)
-/* Warning: the render thread has finished rendering the frame */
-#define M4WAR_RENDER_FINISHED                                M4OSA_ERR_CREATE(M4_WAR,\
-                                                                 M4DECODER_EXTERNAL, 0x0002)
-
-#define M4ERR_CHECK(x) if(M4NO_ERROR!=x) return x;
-#define M4ERR_EXIT(x) do { err = x; goto exit_with_error; } while(0)
-
-
-/* ----- shell API ----- */
-
-static M4OSA_ERR M4DECODER_EXTERNAL_create(M4OSA_Context *pVS_Context,
-                                             M4_StreamHandler *pStreamHandler,
-                                             M4READER_DataInterface *pReaderDataInterface,
-                                             M4_AccessUnit* pAccessUnit, M4OSA_Void* pUserData);
-static M4OSA_ERR M4DECODER_EXTERNAL_destroy(M4OSA_Context pVS_Context);
-static M4OSA_ERR M4DECODER_EXTERNAL_getOption(M4OSA_Context pVS_Context, M4OSA_OptionID optionId,
-                                                M4OSA_DataOption* pValue);
-static M4OSA_ERR M4DECODER_EXTERNAL_setOption(M4OSA_Context pVS_Context, M4OSA_OptionID optionId,
-                                                 M4OSA_DataOption pValue);
-static M4OSA_ERR M4DECODER_EXTERNAL_decode(M4OSA_Context pVS_Context, M4_MediaTime* pTime,
-                                             M4OSA_Bool bJump);
-static M4OSA_ERR M4DECODER_EXTERNAL_render(M4OSA_Context pVS_Context, M4_MediaTime* pTime,
-                                             M4VIFI_ImagePlane* pOutputPlane,
-                                             M4OSA_Bool bForceRender);
-
-/* ----- Signaling functions ----- */
-
-static M4OSA_ERR M4DECODER_EXTERNAL_signalDecoderOver(M4OSA_Context pVS_Context,
-                                                        M4_MediaTime aTime, M4OSA_ERR aUserError);
-static M4OSA_ERR M4DECODER_EXTERNAL_signalRenderOver(M4OSA_Context pVS_Context,
-                                                     M4_MediaTime aTime, M4OSA_ERR aUserError);
-
-/* ----- static internal functions ----- */
-
-static M4OSA_ERR M4DECODER_EXTERNAL_Init(void** pVS_Context, M4VD_Interface* p_HWInterface,
-                                         M4_StreamHandler *pStreamHandler);
-static M4OSA_ERR M4DECODER_EXTERNAL_StreamDescriptionInit(M4VD_StreamInfo** ppStreamInfo,
-                                                             M4_StreamHandler *pStreamHandler);
-static M4OSA_ERR M4DECODER_EXTERNAL_SetUpReadInput(void* pVS_Context,
-                                                     M4READER_DataInterface* pReader,
-                                                     M4_AccessUnit* pAccessUnit);
-static M4OSA_ERR M4DECODER_EXTERNAL_GetNextAu(M4VS_VideoDecoder_Context* pStreamContext,
-                                                 M4VD_VideoBuffer *nextBuffer,
-                                                 M4_MediaTime* nextFrameTime);
-static M4OSA_ERR M4DECODER_EXTERNAL_SynchronousDecode(M4OSA_Context pVS_Context);
-static M4OSA_ERR M4DECODER_EXTERNAL_AsynchronousDecode(M4OSA_Context pVS_Context);
-static M4OSA_ERR M4DECODER_EXTERNAL_AsynchronousRender(M4OSA_Context pVS_Context);
-
-
-/* ___________________________________________________________________ */
-/*|                                                                   |*/
-/*|                                                       |*/
-/*|___________________________________________________________________|*/
-
-/**
- ************************************************************************
- * @brief   Retrieves the interface implemented by the decoder
- * @note
- *
- * @param   pDecoderInterface: (OUT) address of a pointer that will be set to the interface
- *                                   implemented by this decoder. The interface is a structure
- *                                   allocated by the function and must be unallocated by the
- *                                   caller.
- *
- * @returns : M4NO_ERROR  if OK
- *            M4ERR_ALLOC if allocation failed
- ************************************************************************
- */
-M4OSA_ERR M4DECODER_EXTERNAL_getInterface(M4DECODER_VideoInterface **pDecoderInterface)
-{
-    /* Allocates memory for the decoder shell pointer to function */
-    *pDecoderInterface =
-         (M4DECODER_VideoInterface*)M4OSA_32bitAlignedMalloc( sizeof(M4DECODER_VideoInterface),
-             M4DECODER_EXTERNAL, (M4OSA_Char *)"M4DECODER_VideoInterface" );
-    if (M4OSA_NULL == *pDecoderInterface)
-    {
-        M4OSA_TRACE1_0("M4DECODER_EXTERNAL_getInterface:\
-             unable to allocate M4DECODER_VideoInterface, returning M4ERR_ALLOC");
-        return M4ERR_ALLOC;
-    }
-
-    (*pDecoderInterface)->m_pFctCreate    = M4DECODER_EXTERNAL_create;
-    (*pDecoderInterface)->m_pFctDestroy   = M4DECODER_EXTERNAL_destroy;
-    (*pDecoderInterface)->m_pFctGetOption = (M4DECODER_getOption_fct*)M4DECODER_EXTERNAL_getOption;
-    (*pDecoderInterface)->m_pFctSetOption = M4DECODER_EXTERNAL_setOption;
-    (*pDecoderInterface)->m_pFctDecode    = M4DECODER_EXTERNAL_decode;
-    (*pDecoderInterface)->m_pFctRender    = M4DECODER_EXTERNAL_render;
-
-    return M4NO_ERROR;
-}
-
-
-/* ___________________________________________________________________ */
-/*|                                                                   |*/
-/*|                           shell API                            |*/
-/*|___________________________________________________________________|*/
-
-/**
- ************************************************************************
- * @brief   Creates the external video decoder
- * @note    This function creates internal video decoder context and
- *          initializes it.
- *
- * @param   pVS_Context     (OUT)   Context of the video hw shell
- * @param   pStreamHandler  (IN)    Pointer to a video stream description
- * @param   pReaderDataInterface: (IN)  Pointer to the M4READER_DataInterface
- *                                  structure that must be used by the
- *                                  decoder to read data from the stream
- * @param   pAccessUnit     (IN)    Pointer to an access unit (allocated
- *                                  by the caller) where the decoded data
- *                                  are stored
- * @param   pExternalAPI    (IN)    Interface of the client video decoder
- * @param   pUserData       (IN)    User data of the external video decoder
- *
- * @return  M4NO_ERROR              There is no error
- * @return  M4ERR_ALLOC             a memory allocation has failed
- * @return  M4ERR_PARAMETER         at least one parameter is not properly set (in DEBUG only)
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_create(M4OSA_Context *pVS_Context,
-                                             M4_StreamHandler *pStreamHandler,
-                                             M4READER_DataInterface *pReaderDataInterface,
-                                             M4_AccessUnit* pAccessUnit, M4OSA_Void* pUserData)
-{
-    M4VD_VideoType videoDecoderKind;
-    M4VD_StreamInfo* pStreamInfo;
-    M4VD_OutputFormat outputFormat;
-
-    M4VS_VideoDecoder_Context* pStreamContext;
-    M4OSA_ERR err = M4NO_ERROR;
-
-    M4OSA_TRACE2_0("M4DECODER_EXTERNAL_create");
-
-    /* Video Shell Creation */
-    err = M4DECODER_EXTERNAL_Init(pVS_Context,
-         ((M4DECODER_EXTERNAL_UserDataType)pUserData)->externalFuncs, pStreamHandler);
-
-    if (err != M4NO_ERROR)
-    {
-        M4OSA_TRACE1_1("M4DECODER_EXTERNAL_create :\
-             M4VD_EXTERNAL_Init RETURNS THE ERROR CODE = 0x%x", err);
-        return err;
-    }
-
-    err = M4DECODER_EXTERNAL_SetUpReadInput(*pVS_Context, pReaderDataInterface, pAccessUnit);
-
-    if (err != M4NO_ERROR)
-    {
-        M4OSA_TRACE1_1("M4DECODER_EXTERNAL_create :\
-             M4VD_EXTERNAL_SetUpReadInput RETURNS THE ERROR CODE = 0x%x", err);
-        return err;
-    }
-
-    pStreamContext = (M4VS_VideoDecoder_Context*)(*pVS_Context);
-
-    /* Stream Description init */
-    err = M4DECODER_EXTERNAL_StreamDescriptionInit(&pStreamInfo, pStreamHandler);
-
-    if (err != M4NO_ERROR)
-    {
-        M4OSA_TRACE1_1("M4DECODER_EXTERNAL_create :\
-             M4VD_EXTERNAL_StreamDescriptionInit RETURNS THE ERROR CODE = 0x%x", err);
-        return err;
-    }
-
-    pStreamContext->m_pStreamInfo = pStreamInfo;
-
-    /* HW context creation */
-    err = pStreamContext->m_VD_Interface->m_pFctInitVideoDecoder(&(pStreamContext->m_VD_Context),
-         &(pStreamContext->m_VD_SignalingInterface));
-
-    if (err != M4NO_ERROR)
-    {
-        M4OSA_TRACE1_1("M4DECODER_EXTERNAL_create : m_pFctInitVideoDecoder() error 0x%x", err);
-        return err;
-    }
-
-    /* HW decoder creation */
-    switch(pStreamHandler->m_streamType)
-    {
-        case M4DA_StreamTypeVideoH263 :
-            videoDecoderKind = M4VD_kH263VideoDec;
-            break;
-
-        default :
-        case M4DA_StreamTypeVideoMpeg4 :
-            videoDecoderKind = M4VD_kMpeg4VideoDec;
-            break;
-    }
-
-    err = pStreamContext->m_VD_Interface->m_pFctOpenDecoder(pStreamContext->m_VD_Context,
-         videoDecoderKind, pStreamContext->m_pStreamInfo, &outputFormat,
-             ((M4DECODER_EXTERNAL_UserDataType)pUserData)->externalUserData);
-
-    if (err != M4NO_ERROR)
-    {
-        M4OSA_TRACE1_1("M4DECODER_EXTERNAL_create : m_pFctOpenDecoder() error 0x%x", err);
-        return err;
-    }
-
-    /* Parse the VOL header */
-    err = M4DECODER_EXTERNAL_ParseVideoDSI((M4OSA_UInt8 *)pStreamContext->m_pStreamInfo->\
-                                           decoderConfiguration.pBuffer,
-                                           pStreamContext->m_pStreamInfo->\
-                                           decoderConfiguration.aSize,
-                                           &pStreamContext->m_Dci, &pStreamContext->m_VideoSize);
-
-    if (err != M4NO_ERROR)
-    {
-        M4OSA_TRACE1_1("M4DECODER_EXTERNAL_create :\
-             M4DECODER_EXTERNAL_ParseVideoDSI() error 0x%x", err);
-        return err;
-    }
-
-    return M4NO_ERROR;
-}
-
-/**
- ************************************************************************
- * @brief   destroy the instance of the decoder
- * @note    after this call the context is invalid
- *
- * @param   pVS_Context:   (IN) Context of the decoder
- *
- * @return  M4NO_ERROR          There is no error
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_destroy(M4OSA_Context pVS_Context)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_TRACE2_0("M4DECODER_EXTERNAL_destroy");
-
-    if(M4OSA_NULL != pStreamContext)
-    {
-        /* Call external API destroy function */
-        pStreamContext->m_VD_Interface->m_pFctClose(pStreamContext->m_VD_Context);
-
-        /* Destroy context */
-        pStreamContext->m_VD_Interface->m_pFctCleanUp(pStreamContext->m_VD_Context);
-
-        if(M4OSA_NULL != pStreamContext->m_pStreamInfo)
-        {
-            free(pStreamContext->m_pStreamInfo);
-            pStreamContext->m_pStreamInfo = M4OSA_NULL;
-        }
-
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-        if (M4OSA_NULL != pStreamContext->m_SemSync)
-        {
-            M4OSA_semaphoreClose(pStreamContext->m_SemSync);
-        }
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-
-        free(pStreamContext);
-        pStreamContext = M4OSA_NULL;
-    }
-
-    return M4NO_ERROR;
-}
-
-/**
- ************************************************************************
- * @brief   Get an option value from the decoder
- * @note    It allows the caller to retrieve a property value:
- *          - the size (width x height) of the image
- *          - the DSI properties
- *
- * @param   pVS_Context: (IN)       Context of the decoder
- * @param   optionId:    (IN)       indicates the option to set
- * @param   pValue:      (IN/OUT)   pointer to structure or value (allocated by user) where option
- *                                    is stored
- * @return  M4NO_ERROR              there is no error
- * @return  M4ERR_PARAMETER         The context is invalid (in DEBUG only)
- * @return  M4ERR_BAD_OPTION_ID     when the option ID is not a valid one
- * @return  M4ERR_STATE             State automaton is not applied
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_getOption(M4OSA_Context pVS_Context, M4OSA_OptionID optionId,
-                                             M4OSA_DataOption *pValue)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-    M4OSA_ERR err = M4NO_ERROR;
-
-    M4OSA_TRACE2_0("M4DECODER_EXTERNAL_getOption");
-
-    switch (optionId)
-    {
-        case M4DECODER_kOptionID_VideoSize:
-            *((M4DECODER_VideoSize*)pValue) = pStreamContext->m_VideoSize;
-            err = M4NO_ERROR;
-            break;
-
-        case M4DECODER_MPEG4_kOptionID_DecoderConfigInfo:
-            *((M4DECODER_MPEG4_DecoderConfigInfo*)pValue) = pStreamContext->m_Dci;
-            err = M4NO_ERROR;
-            break;
-
-        default:
-            err = pStreamContext->m_VD_Interface->m_pFctGetOption(pStreamContext->m_VD_Context,
-                     optionId, pValue);
-            break;
-    }
-
-    return err;
-}
-
-/**
- ************************************************************************
- * @brief   set en option value of the decoder
- * @note    It allows the caller to set a property value:
- *          - Nothing implemented at this time
- *
- * @param   pVS_Context: (IN)       Context of the external video decoder shell
- * @param   optionId:    (IN)       Identifier indicating the option to set
- * @param   pValue:      (IN)       Pointer to structure or value (allocated by user) where
- *                                    option is stored
- * @return  M4NO_ERROR              There is no error
- * @return  M4ERR_BAD_OPTION_ID     The option ID is not a valid one
- * @return  M4ERR_STATE             State automaton is not applied
- * @return  M4ERR_PARAMETER         The option parameter is invalid
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_setOption(M4OSA_Context pVS_Context, M4OSA_OptionID optionId,
-                                              M4OSA_DataOption pValue)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-    M4OSA_ERR err;
-    M4OSA_TRACE2_0("M4DECODER_EXTERNAL_setOption");
-
-    switch (optionId)
-    {
-        case M4DECODER_kOptionID_OutputFilter:
-        {
-            M4DECODER_OutputFilter* pOutputFilter = (M4DECODER_OutputFilter*) pValue;
-            err =
-                pStreamContext->m_VD_Interface->m_pFctSetOutputFilter(pStreamContext->m_VD_Context,
-                            (M4VIFI_PlanConverterFunctionType*)pOutputFilter->m_pFilterFunction,
-                            pOutputFilter->m_pFilterUserData);
-        }
-        break;
-
-        case M4DECODER_kOptionID_DeblockingFilter:
-            err = M4NO_ERROR;
-        break;
-
-        default:
-            err = pStreamContext->m_VD_Interface->m_pFctSetOption(pStreamContext->m_VD_Context,
-                 optionId, pValue);
-        break;
-    }
-
-    return err;
-}
-
-/**
- ************************************************************************
- * @brief   Decode video Access Units up to a target time
- * @note    Parse and decode the video until it can output a decoded image for which
- *          the composition time is equal or greater to the passed targeted time
- *          The data are read from the reader data interface passed to M4DECODER_EXTERNAL_create.
- *          If threaded mode, waits until previous decoding is over,
- *          and fill decoding parameters used by the decoding thread.
- *
- * @param   pVS_Context:(IN)        Context of the external video decoder shell
- * @param   pTime:      (IN/OUT)    IN: Time to decode up to (in milli secondes)
- *                                  OUT:Time of the last decoded frame (in ms)
- * @param   bJump:      (IN)        0 if no jump occured just before this call
- *                                  1 if a a jump has just been made
- *
- * @return  M4NO_ERROR              there is no error
- * @return  M4ERR_PARAMETER         at least one parameter is not properly set
- * @return  M4WAR_NO_MORE_AU        there is no more access unit to decode (end of stream)
- * @return  M4WAR_VIDEORENDERER_NO_NEW_FRAME    No frame to render
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_decode(M4OSA_Context pVS_Context, M4_MediaTime* pTime,
-                                             M4OSA_Bool bJump)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_ERR err = M4NO_ERROR;
-
-    M4OSA_TRACE2_2("M4DECODER_EXTERNAL_decode : up to %lf  bjump = 0x%x", *pTime, bJump);
-
-    pStreamContext->m_DecodeUpToCts = *pTime;
-    pStreamContext->m_bJump = bJump;
-    if (bJump)
-    {
-        pStreamContext->m_CurrentDecodeCts = -1.0;
-        pStreamContext->m_CurrentRenderCts = -1.0;
-    }
-
-    if(pStreamContext->m_DecodeUpToCts < pStreamContext->m_nextAUCts &&
-        pStreamContext->m_CurrentRenderCts > pStreamContext->m_DecodeUpToCts)
-    {
-        /* It means that we do not need to launch another predecode, as we will reuse
-             the previously decoded frame*/
-        /* a warning is returned to the service to warn it about that .*/
-        /* In that case, the service MUST NOT call render function, and must keep the
-             previous frame */
-        /* if necessary (i.e force render case)*/
-        M4OSA_TRACE2_0("No decode is needed, same frame reused");
-        return M4WAR_VIDEORENDERER_NO_NEW_FRAME;
-    }
-
-    /* If render has not been called for frame n, it means that n+1 frame decoding has
-         not been launched
-    -> do not wait for its decoding completion ...*/
-    if(pStreamContext->m_bIsWaitNextDecode == M4OSA_TRUE)
-    {
-        /* wait for decode n+1 to complete */
-        //M4semvalue--;
-        //printf("Semaphore wait: %d\n", M4semvalue);
-        pStreamContext->m_bIsWaitNextDecode = M4OSA_FALSE;
-        M4OSA_semaphoreWait(pStreamContext->m_SemSync, M4OSA_WAIT_FOREVER);
-    }
-    if(pStreamContext->m_CurrentDecodeCts >= *pTime)
-    {
-        /* If we are not in this condition, it means that we ask for a frame after the
-             "predecoded" frame */
-        *pTime = pStreamContext->m_CurrentDecodeCts;
-        return M4NO_ERROR;
-    }
-
-    pStreamContext->m_NbDecodedFrames = 0;
-    pStreamContext->m_uiDecodeError = M4NO_ERROR;
-    pStreamContext->m_bDataDecodePending = M4OSA_TRUE;
-    pStreamContext->m_uiDecodeError = M4NO_ERROR;
-
-    /* Launch DecodeUpTo process in synchronous mode */
-    while(pStreamContext->m_uiDecodeError == M4NO_ERROR)
-    {
-        M4DECODER_EXTERNAL_SynchronousDecode(pVS_Context);
-        /* return code is ignored, it is used only in M4OSA_Thread api */
-    }
-
-    *pTime = pStreamContext->m_CurrentDecodeCts;
-
-    if ( (M4WAR_DECODE_FINISHED == pStreamContext->m_uiDecodeError)
-        || (M4WAR_VIDEORENDERER_NO_NEW_FRAME == pStreamContext->m_uiDecodeError) )
-    {
-        pStreamContext->m_uiDecodeError = M4NO_ERROR;
-    }
-
-    return pStreamContext->m_uiDecodeError;
-}
-
-/**
- ************************************************************************
- * @brief   Renders the video at the specified time.
- * @note    If threaded mode, this function unlock the decoding thread,
- *          which also call the external rendering function.
- *          Else, just call external rendering function, and waits for its
- *          completion.
- *
- * @param   pVS_Context: (IN)       Context of the video decoder shell
- * @param   pTime:       (IN/OUT)   IN: Time to render to (in milli secondes)
- *                                  OUT:Time of the effectively rendered frame (in ms)
- * @param   pOutputPlane:(OUT)      Output plane filled with decoded data (converted)
- *                                  If NULL, the rendering is made by the external
- *                                  component.
- * @param   bForceRender:(IN)       1 if the image must be rendered even it has already been
- *                                  0 if not (in which case the function can return
- *                                    M4WAR_VIDEORENDERER_NO_NEW_FRAME)
- * @return  M4NO_ERROR              There is no error
- * @return  M4ERR_PARAMETER         At least one parameter is not properly set
- * @return  M4ERR_STATE             State automaton is not applied
- * @return  M4ERR_ALLOC             There is no more available memory
- * @return  M4WAR_VIDEORENDERER_NO_NEW_FRAME    If the frame to render has already been rendered
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_render(M4OSA_Context pVS_Context, M4_MediaTime* pTime,
-                                           M4VIFI_ImagePlane* pOutputPlane,
-                                           M4OSA_Bool bForceRender)
-{
-    M4OSA_ERR err = M4NO_ERROR;
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_TRACE2_2("M4DECODER_EXTERNAL_render : pTime = %lf, forceRender: %d ", *pTime,
-         bForceRender);
-
-    pStreamContext->m_TargetRenderCts = *pTime;
-    pStreamContext->m_pOutputPlane = pOutputPlane;
-    pStreamContext->m_bForceRender = bForceRender;
-    pStreamContext->m_uiRenderError = M4NO_ERROR;
-    pStreamContext->m_bDataRenderPending = M4OSA_TRUE;
-
-    /* Launch Render process in synchronous mode */
-    while(pStreamContext->m_uiRenderError == M4NO_ERROR)
-    {
-        M4DECODER_EXTERNAL_AsynchronousRender(pVS_Context);
-        /* return code is ignored, it is used only in M4OSA_Thread */
-    }
-
-
-    *pTime = pStreamContext->m_CurrentRenderCts;
-
-
-    if (M4WAR_RENDER_FINISHED == pStreamContext->m_uiRenderError)
-    {
-        pStreamContext->m_uiRenderError = M4NO_ERROR;
-    }
-
-    return pStreamContext->m_uiRenderError;
-}
-
-
-/* ___________________________________________________________________ */
-/*|                                                                   |*/
-/*|                        Signaling functions                        |*/
-/*|___________________________________________________________________|*/
-
-/**
- ************************************************************************
- * @brief   Called by the HW video decoder to signal that a decoding is
- *          over
- * @note    The function gets another AU in the internal AU buffer, and
- *          launches the decoding.
- *          If no more AU are available, the M4DECODER_EXTERNAL_decode
- *          (or M4DECODER_EXTERNAL_render if threaded) function is unlocked
- *
- * @param   pVS_Context:    (IN)    context of the video hw shell
- * @param   aTime:          (IN)    time of the decoded frame
- * @param   aUserError      (IN)    error code returned to the VPS
- *
- * @return  M4NO_ERROR              There is no error
- * @return  M4ERR_HW_DECODER_xxx    A fatal error occured
- * @return  M4ERR_PARAMETER         At least one parameter is NULL
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_signalDecoderOver(M4OSA_Context pVS_Context,
-                                                      M4_MediaTime aTime, M4OSA_ERR aUserError)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_TRACE2_1("M4DECODER_EXTERNAL_signalDecoderOver : aTime = %lf", aTime);
-
-    pStreamContext->m_NbDecodedFrames++;
-    pStreamContext->m_uiDecodeError = aUserError;
-    pStreamContext->m_CurrentDecodeCts = aTime;
-
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-    /* give control back to stepDecode */
-    //M4semvalue++;
-    //printf("Semaphore post: %d\n", M4semvalue);
-    M4OSA_semaphorePost(pStreamContext->m_SemSync);
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-
-    return M4NO_ERROR;
-}
-
-/**
- ************************************************************************
- * @brief   Called by the HW video renderer to signal that a rendering is
- *          over
- * @note    The function just post a semaphore to unblock
- *          M4DECODER_EXTERNAL_render function
- *
- * @param   pVS_Context:    (IN)    context of the video hw shell
- * @param   aTime:          (IN)    time of the decoded frame
- * @param   aUserError      (IN)    error code returned to the VPS
- *
- * @return  M4NO_ERROR              There is no error
- * @return  M4ERR_HW_DECODER_xxx    A fatal error occured
- * @return  M4ERR_PARAMETER         At least one parameter is NULL
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_signalRenderOver(M4OSA_Context pVS_Context,
-                                                     M4_MediaTime aTime, M4OSA_ERR aUserError)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_TRACE3_1("M4DECODER_EXTERNAL_signalRenderOver : aTime = %lf", aTime);
-
-    pStreamContext->m_uiRenderError = aUserError;
-    pStreamContext->m_CurrentRenderCts = aTime;
-
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-    /* give control back to stepRender */
-    //M4semvalue++;
-    //printf("Semaphore post: %d\n", M4semvalue);
-    M4OSA_semaphorePost(pStreamContext->m_SemSync);
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-
-    return M4NO_ERROR;
-}
-
-
-/* ___________________________________________________________________ */
-/*|                                                                   |*/
-/*|                            Internals                              |*/
-/*|___________________________________________________________________|*/
-
-/**
- ************************************************************************
- * @brief    Initializes the video decoder shell/handler
- * @note     allocates an execution context
- *
- * @param    pVS_Context:    (OUT)   Output context allocated
- * @param    p_HWInterface:  (IN)    Pointer on the set of external HW codec functions
- * @param    pStreamHandler: (IN)    Pointer to a video stream description
- *
- * @return   M4NO_ERROR     There is no error
- * @return   M4ERR_ALLOC    There is no more available memory
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_Init(M4OSA_Context* pVS_Context,
-                                         M4VD_Interface* p_HWInterface,
-                                         M4_StreamHandler *pStreamHandler)
-{
-    M4VS_VideoDecoder_Context* pStreamContext;
-
-    M4OSA_ERR err = M4NO_ERROR;
-
-    M4OSA_TRACE2_0("M4DECODER_EXTERNAL_Init");
-
-    /* Allocate the internal context */
-    *pVS_Context = M4OSA_NULL;
-
-    pStreamContext = (M4VS_VideoDecoder_Context*)M4OSA_32bitAlignedMalloc(sizeof(M4VS_VideoDecoder_Context),
-         M4DECODER_EXTERNAL,(M4OSA_Char *) "M4VS_VideoDecoder_Context");
-    if (M4OSA_NULL == pStreamContext)
-    {
-        M4OSA_TRACE1_0("M4DECODER_EXTERNAL_Init : error, cannot allocate context !");
-        return M4ERR_ALLOC;
-    }
-
-    /* Reset internal context structure */
-    *pVS_Context = pStreamContext;
-
-    /* --- READER --- */
-    pStreamContext->m_pReader = M4OSA_NULL;
-    pStreamContext->m_pNextAccessUnitToDecode = M4OSA_NULL;
-    pStreamContext->m_bJump = M4OSA_FALSE;
-    pStreamContext->m_nextAUCts = -1;
-
-    /* --- DECODER --- */
-    pStreamContext->m_DecodeUpToCts = -1;
-    pStreamContext->m_CurrentDecodeCts = -1;
-    pStreamContext->m_NbDecodedFrames = 0;
-    pStreamContext->m_uiDecodeError = M4NO_ERROR;
-    pStreamContext->m_bDataDecodePending = M4OSA_FALSE;
-    pStreamContext->m_PreviousDecodeCts = 0;
-    pStreamContext->m_bIsWaitNextDecode = M4OSA_FALSE;
-
-    /* --- RENDER --- */
-    pStreamContext->m_TargetRenderCts = -1;
-    pStreamContext->m_CurrentRenderCts = -1;
-    pStreamContext->m_uiRenderError = M4NO_ERROR;
-    pStreamContext->m_bForceRender = M4OSA_TRUE;
-    pStreamContext->m_bDataRenderPending = M4OSA_FALSE;
-
-    /* --- STREAM PARAMS --- */
-    pStreamContext->m_pVideoStreamhandler = (M4_VideoStreamHandler*)pStreamHandler;
-    pStreamContext->m_pStreamInfo = M4OSA_NULL;
-    pStreamContext->m_pOutputPlane = M4OSA_NULL;
-
-    /* --- VD API --- */
-    pStreamContext->m_VD_Interface = p_HWInterface;
-    pStreamContext->m_VD_Context = M4OSA_NULL;
-
-    pStreamContext->m_VD_SignalingInterface.m_pSignalTarget = pStreamContext;
-    pStreamContext->m_VD_SignalingInterface.m_pFctSignalDecoderOver =
-         M4DECODER_EXTERNAL_signalDecoderOver;
-    pStreamContext->m_VD_SignalingInterface.m_pFctSignalRenderOver =
-         M4DECODER_EXTERNAL_signalRenderOver;
-
-    /* --- THREAD STUFF --- */
-
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-    pStreamContext->m_SemSync = M4OSA_NULL;
-    //M4semvalue=0;
-    err = M4OSA_semaphoreOpen(&(pStreamContext->m_SemSync), 0);
-    if (M4NO_ERROR != err)
-    {
-        M4OSA_TRACE1_1("M4DECODER_EXTERNAL_Init: can't open sync semaphore (err 0x%08X)", err);
-        return err;
-    }
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-
-    return err;
-}
-
-/**
- ************************************************************************
- * @brief   Fills the stream info structure
- * @note    This function is called at decoder's creation time,
- *          allocates and fills video info structure
- *
- * @param   ppStreamInfo    (OUT)   Video info structure
- * @param   pStreamHandler  (IN)    Pointer to a video stream description
- *
- * @return  M4ERR_ALLOC     Memory allocation error
- * @return  M4NO_ERROR      There is no error
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_StreamDescriptionInit(M4VD_StreamInfo** ppStreamInfo,
-                                                          M4_StreamHandler *pStreamHandler)
-{
-    M4_VideoStreamHandler* pVideoStreamHandler  = M4OSA_NULL;
-
-    M4OSA_TRACE2_0("M4DECODER_EXTERNAL_StreamDescriptionInit");
-
-    pVideoStreamHandler = (M4_VideoStreamHandler*)pStreamHandler;
-
-    /* M4VD_StreamInfo allocation */
-    *ppStreamInfo = (M4VD_StreamInfo*)M4OSA_32bitAlignedMalloc(sizeof(M4VD_StreamInfo),
-         M4DECODER_EXTERNAL, (M4OSA_Char *)"M4VD_StreamInfo");
-    if(M4OSA_NULL == *ppStreamInfo)
-    {
-        return M4ERR_ALLOC;
-    }
-
-    /* init values */
-    (*ppStreamInfo)->anImageSize.aWidth  = pVideoStreamHandler->m_videoWidth;
-    (*ppStreamInfo)->anImageSize.aHeight = pVideoStreamHandler->m_videoHeight;
-
-    (*ppStreamInfo)->decoderConfiguration.pBuffer =
-         (M4OSA_MemAddr8)pStreamHandler->m_pDecoderSpecificInfo;
-    (*ppStreamInfo)->decoderConfiguration.aSize   = pStreamHandler->m_decoderSpecificInfoSize;
-
-    return M4NO_ERROR;
-}
-
-/**
- ************************************************************************
- * @brief   Initializes current AU parameters
- * @note    It is called at decoder's creation time to initialize
- *          current decoder's AU.
- *
- * @param   pVS_Context (IN)    Context of the video decoder shell
- * @param   pReader     (IN)    Reader interface
- * @param   pAccessUnit (IN)    Access Unit structure used bu decoder
- *
- * @return
- * @return
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_SetUpReadInput(M4OSA_Context pVS_Context,
-                                                    M4READER_DataInterface* pReader,
-                                                    M4_AccessUnit* pAccessUnit)
-{
-    M4VS_VideoDecoder_Context* pStreamContext=(M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_TRACE2_0("M4DECODER_EXTERNAL_SetUpReadInput");
-
-    M4OSA_DEBUG_IF1((M4OSA_NULL == pStreamContext), M4ERR_PARAMETER,
-         "M4DECODER_EXTERNAL_SetUpReadInput: invalid context pointer");
-    M4OSA_DEBUG_IF1((M4OSA_NULL == pReader),        M4ERR_PARAMETER,
-         "M4DECODER_EXTERNAL_SetUpReadInput: invalid pReader pointer");
-    M4OSA_DEBUG_IF1((M4OSA_NULL == pAccessUnit),    M4ERR_PARAMETER,
-         "M4DECODER_EXTERNAL_SetUpReadInput: invalid pAccessUnit pointer");
-
-    pStreamContext->m_pReader = pReader;
-    pStreamContext->m_pNextAccessUnitToDecode = pAccessUnit;
-
-    pAccessUnit->m_streamID = 0;
-    pAccessUnit->m_size = 0;
-    pAccessUnit->m_CTS = 0;
-    pAccessUnit->m_DTS = 0;
-    pAccessUnit->m_attribute = 0;
-
-    return M4NO_ERROR;
-}
-
-/**
- ************************************************************************
- * @brief   Gets the next AU from internal AU buffer
- * @note    This function is necessary to be able to have a decodeUpTo
- *          interface with the VPS.
- *          The AU are read from file by M4DECODER_EXTERNAL_decode function
- *          and stored into a buffer. This function is called internally
- *          to get these stored AU.
- *
- * @param   pStreamContext: (IN)        context of the video hw shell
- * @param   nextFrameTime:  (IN/OUT)    time of the AU
- *
- * @return  M4NO_ERROR          There is no error
- * @return  M4WAR_NO_MORE_AU    No more AU in internal buffer
- * @return  M4ERR_PARAMETER     One invalid parameter
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_GetNextAu(M4VS_VideoDecoder_Context* pStreamContext,
-                                                 M4VD_VideoBuffer *nextBuffer,
-                                                 M4_MediaTime* nextFrameTime)
-{
-    M4OSA_ERR err = M4NO_ERROR;
-    M4_AccessUnit* pAccessUnit;
-
-    M4OSA_TRACE3_0("M4DECODER_EXTERNAL_GetNextAu");
-
-    /* Check context is valid */
-    if(M4OSA_NULL == pStreamContext)
-    {
-        M4OSA_TRACE1_0("M4DECODER_EXTERNAL_GetNextAu : error pStreamContext is NULL");
-        return M4ERR_PARAMETER;
-    }
-
-    /* Read the AU */
-    pAccessUnit = pStreamContext->m_pNextAccessUnitToDecode;
-
-    err = pStreamContext->m_pReader->m_pFctGetNextAu(pStreamContext->m_pReader->m_readerContext,
-         (M4_StreamHandler*)pStreamContext->m_pVideoStreamhandler, pAccessUnit);
-
-    if((err == M4WAR_NO_DATA_YET) || (err == M4WAR_NO_MORE_AU))
-    {
-        M4OSA_TRACE2_1("M4DECODER_EXTERNAL_GetNextAu : no data avalaible 0x%x", err);
-    }
-    else if(err != M4NO_ERROR)
-    {
-        M4OSA_TRACE1_1("M4DECODER_EXTERNAL_GetNextAu : filesystem error 0x%x", err);
-
-        *nextFrameTime         = 0;
-        nextBuffer->pBuffer    = M4OSA_NULL;
-        nextBuffer->bufferSize = 0;
-
-        return err;
-    }
-
-    /* Fill buffer */
-    *nextFrameTime         = pAccessUnit->m_CTS;
-    nextBuffer->pBuffer    = (M4OSA_MemAddr32)pAccessUnit->m_dataAddress;
-    nextBuffer->bufferSize = pAccessUnit->m_size;
-
-    M4OSA_TRACE3_1("M4DECODER_EXTERNAL_GetNextAu: AU obtained, time is %f", *nextFrameTime);
-
-    return err;
-}
-
-/**
- ************************************************************************
- * @brief
- * @note
- *
- * @param    pVS_Context:    (IN)    Context of the video hw shell
- *
- * @return    M4NO_ERROR        There is no error
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_SynchronousDecode(M4OSA_Context pVS_Context)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_ERR err = M4NO_ERROR;
-    M4VD_VideoBuffer nextBuffer;
-
-
-    /* ----- decode process ----- */
-
-    if(M4OSA_TRUE == pStreamContext->m_bDataDecodePending)
-    {
-        /* Targeted time is reached */
-        if( pStreamContext->m_CurrentDecodeCts >= pStreamContext->m_DecodeUpToCts )
-        {
-            M4OSA_TRACE2_0("M4DECODER_EXTERNAL_SynchronousDecode :\
-                 skip decode because synchronisation");
-
-            if(pStreamContext->m_NbDecodedFrames > 0)
-            {
-                pStreamContext->m_uiDecodeError = M4WAR_DECODE_FINISHED;
-            }
-            else
-            {
-                pStreamContext->m_uiDecodeError = M4WAR_VIDEORENDERER_NO_NEW_FRAME;
-            }
-
-            M4ERR_EXIT(M4NO_ERROR);
-        }
-
-        pStreamContext->m_PreviousDecodeCts = pStreamContext->m_CurrentDecodeCts;
-
-        /* Get the next AU */
-        pStreamContext->m_uiDecodeError = M4DECODER_EXTERNAL_GetNextAu(pStreamContext,
-             &nextBuffer, &pStreamContext->m_CurrentDecodeCts);
-
-        if( M4NO_ERROR != pStreamContext->m_uiDecodeError )
-        {
-            if ( M4WAR_NO_MORE_AU != pStreamContext->m_uiDecodeError)
-            {
-                M4OSA_TRACE1_1("M4DECODER_EXTERNAL_SynchronousDecode :\
-                     M4DECODER_EXTERNAL_GetNextAu error 0x%x", pStreamContext->m_uiDecodeError);
-            }
-            M4ERR_EXIT(pStreamContext->m_uiDecodeError);
-        }
-
-        /* Decode the AU */
-        if(nextBuffer.bufferSize > 0)
-        {
-            pStreamContext->m_uiDecodeError =
-                 pStreamContext->m_VD_Interface->m_pFctStepDecode(pStreamContext->m_VD_Context,
-                     &nextBuffer, pStreamContext->m_CurrentDecodeCts);
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-            if ( (M4NO_ERROR == pStreamContext->m_uiDecodeError)
-                /*|| (M4WAR_IO_PENDING == pStreamContext->m_uiDecodeError)*/ )
-            {
-                /* wait for decode to complete */
-                //M4semvalue--;
-                //printf("Semaphore wait 2: %d\n", M4semvalue);
-                M4OSA_semaphoreWait(pStreamContext->m_SemSync, M4OSA_WAIT_FOREVER);
-                /* by now the actual m_uiDecodeError has been set by signalDecode */
-            }
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-            if(M4NO_ERROR != pStreamContext->m_uiDecodeError)
-            {
-                M4OSA_TRACE1_1("M4DECODER_EXTERNAL_SynchronousDecode : HW decoder error 0x%x",
-                     pStreamContext->m_uiDecodeError);
-                M4ERR_EXIT(M4NO_ERROR);
-            }
-        }
-        else
-        {
-            M4ERR_EXIT(M4NO_ERROR);
-        }
-    }
-
-    return M4NO_ERROR;
-
-
-/* ----- Release resources if an error occured */
-exit_with_error:
-
-    /* Abort decoding */
-    pStreamContext->m_bDataDecodePending = M4OSA_FALSE;
-
-    if((M4NO_ERROR == pStreamContext->m_uiDecodeError) && (M4NO_ERROR != err))
-    {
-        pStreamContext->m_uiDecodeError = err;
-    }
-
-    return err;
-}
-
-/**
- ************************************************************************
- * @brief
- * @note
- *
- * @param    pVS_Context:    (IN)    Context of the video hw shell
- *
- * @return    M4NO_ERROR        There is no error
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_AsynchronousDecode(M4OSA_Context pVS_Context)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_ERR err = M4NO_ERROR;
-    M4VD_VideoBuffer nextBuffer;
-
-
-    /* ----- decode process ----- */
-
-    if(M4OSA_TRUE == pStreamContext->m_bDataDecodePending)
-    {
-        pStreamContext->m_PreviousDecodeCts = pStreamContext->m_CurrentDecodeCts;
-
-        /* Get the next AU */
-        pStreamContext->m_uiDecodeError = M4DECODER_EXTERNAL_GetNextAu(pStreamContext,
-             &nextBuffer, &pStreamContext->m_nextAUCts);
-
-        if( M4NO_ERROR != pStreamContext->m_uiDecodeError )
-        {
-            if ( M4WAR_NO_MORE_AU != pStreamContext->m_uiDecodeError)
-            {
-                M4OSA_TRACE1_1("M4DECODER_EXTERNAL_AsynchronousDecode :\
-                     M4DECODER_EXTERNAL_GetNextAu error 0x%x", pStreamContext->m_uiDecodeError);
-            }
-            //M4semvalue++;
-            //printf("Semaphore post: %d\n", M4semvalue);
-            //M4OSA_semaphorePost(pStreamContext->m_SemSync);
-            M4ERR_EXIT(pStreamContext->m_uiDecodeError);
-        }
-
-        /* Decode the AU if needed */
-        if(nextBuffer.bufferSize > 0)
-        {
-            pStreamContext->m_uiDecodeError =
-                 pStreamContext->m_VD_Interface->m_pFctStepDecode(pStreamContext->m_VD_Context,
-                    &nextBuffer, pStreamContext->m_nextAUCts\
-                        /*pStreamContext->m_CurrentDecodeCts*/);
-            if(M4NO_ERROR != pStreamContext->m_uiDecodeError)
-            {
-                M4OSA_TRACE1_1("M4DECODER_EXTERNAL_AsynchronousDecode : HW decoder error 0x%x",
-                     pStreamContext->m_uiDecodeError);
-                M4ERR_EXIT(M4NO_ERROR);
-            }
-            pStreamContext->m_bIsWaitNextDecode = M4OSA_TRUE;
-        }
-        else
-        {
-            M4ERR_EXIT(M4NO_ERROR);
-        }
-    }
-
-    return M4NO_ERROR;
-
-
-/* ----- Release resources if an error occured */
-exit_with_error:
-
-    /* Abort decoding */
-    pStreamContext->m_bDataDecodePending = M4OSA_FALSE;
-
-    if((M4NO_ERROR == pStreamContext->m_uiDecodeError) && (M4NO_ERROR != err))
-    {
-        pStreamContext->m_uiDecodeError = err;
-    }
-
-    return err;
-}
-
-/**
- ************************************************************************
- * @brief
- * @note
- *
- * @param    pVS_Context:    (IN)    Context of the video hw shell
- *
- * @return    M4NO_ERROR        There is no error
- ************************************************************************
- */
-static M4OSA_ERR M4DECODER_EXTERNAL_AsynchronousRender(M4OSA_Context pVS_Context)
-{
-    M4VS_VideoDecoder_Context* pStreamContext = (M4VS_VideoDecoder_Context*)pVS_Context;
-
-    M4OSA_ERR err = M4NO_ERROR;
-
-
-    /* ----- Render one frame ----- */
-
-    if(M4OSA_TRUE == pStreamContext->m_bDataRenderPending)
-    {
-        /* Render the frame */
-        pStreamContext->m_CurrentRenderCts = pStreamContext->m_CurrentDecodeCts;
-
-        pStreamContext->m_uiRenderError =
-             pStreamContext->m_VD_Interface->m_pFctStepRender(pStreamContext->m_VD_Context,
-                 pStreamContext->m_pOutputPlane, pStreamContext->m_CurrentRenderCts);
-#ifndef M4DECODER_EXTERNAL_SYNC_EXT_DECODE
-        if ( (M4NO_ERROR == pStreamContext->m_uiRenderError)
-            /* || (M4WAR_IO_PENDING == pStreamContext->m_uiRenderError) */ )
-        {
-            /* wait for render to complete */
-            //M4semvalue--;
-            //printf("Semaphore wait: %d\n", M4semvalue);
-            M4OSA_semaphoreWait(pStreamContext->m_SemSync, M4OSA_WAIT_FOREVER);
-            /* by now the actual m_uiRenderError has been set by signalRender */
-        }
-#endif /* not M4DECODER_EXTERNAL_SYNC_EXT_DECODE */
-        if(M4NO_ERROR != pStreamContext->m_uiRenderError)
-        {
-            M4OSA_TRACE1_1("M4DECODER_EXTERNAL_AsynchronousRender : HW render error 0x%x", err);
-            pStreamContext->m_bDataRenderPending = M4OSA_FALSE;
-
-            return M4NO_ERROR;
-        }
-
-        /* Launch in asynchronous mode the predecoding of the next frame */
-        pStreamContext->m_NbDecodedFrames = 0;
-        pStreamContext->m_uiDecodeError = M4NO_ERROR;
-        pStreamContext->m_bDataDecodePending = M4OSA_TRUE;
-        M4DECODER_EXTERNAL_AsynchronousDecode(pVS_Context);
-
-        pStreamContext->m_uiRenderError = M4WAR_RENDER_FINISHED;
-    }
-
-    return M4NO_ERROR;
-
-
-/* ----- Release resources if an error occured */
-exit_with_error:
-
-    /* Abort the rendering */
-    pStreamContext->m_bDataRenderPending = M4OSA_FALSE;
-
-    if((M4NO_ERROR == pStreamContext->m_uiRenderError) && (M4NO_ERROR != err))
-    {
-        pStreamContext->m_uiRenderError = err;
-    }
-
-
-    return err;
-}
-
diff --git a/libvideoeditor/vss/src/M4VSS3GPP_Clip.c b/libvideoeditor/vss/src/M4VSS3GPP_Clip.c
index 6311cd6..d9b6eb5 100755
--- a/libvideoeditor/vss/src/M4VSS3GPP_Clip.c
+++ b/libvideoeditor/vss/src/M4VSS3GPP_Clip.c
@@ -1817,87 +1817,6 @@ M4OSA_ERR M4VSS3GPP_intClipCleanUp( M4VSS3GPP_ClipContext *pClipCtxt )
     return err;
 }
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-
-M4OSA_ERR
-M4VSS3GPP_intClipRegisterExternalVideoDecoder( M4VSS3GPP_ClipContext *pClipCtxt,
-                                              M4VD_VideoType decoderType,
-                                              M4VD_Interface *pDecoderInterface,
-                                              M4OSA_Void *pUserData )
-{
-    M4OSA_ERR err = M4NO_ERROR;
-    M4DECODER_VideoInterface *shellInterface;
-    M4DECODER_VideoType nativeType;
-    M4DECODER_EXTERNAL_UserDataType shellUserData;
-
-    switch( decoderType )
-    {
-        case M4VD_kMpeg4VideoDec:
-        case M4VD_kH263VideoDec:
-            nativeType = M4DECODER_kVideoTypeMPEG4;
-            break;
-
-        case M4VD_kH264VideoDec:
-            nativeType = M4DECODER_kVideoTypeAVC;
-            break;
-
-        default:
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intClipRegisterExternalVideoDecoder: unknown decoderType %d",
-                decoderType);
-            return M4ERR_PARAMETER;
-            break;
-    }
-
-    shellUserData =
-        (M4DECODER_EXTERNAL_UserDataType)M4OSA_32bitAlignedMalloc(sizeof(*shellUserData),
-        M4VSS3GPP, (M4OSA_Char *)"userData structure for the external shell decoder");
-
-    if( M4OSA_NULL == shellUserData )
-    {
-        M4OSA_TRACE1_0(
-            "M4VSS3GPP_intClipRegisterExternalVideoDecoder:\
-            failed to allocate userData structure for the external shell decoder");
-        return M4ERR_ALLOC;
-    }
-
-    shellUserData->externalFuncs = pDecoderInterface;
-    shellUserData->externalUserData = pUserData;
-
-    err = M4DECODER_EXTERNAL_getInterface(&shellInterface);
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4VSS3GPP_intClipRegisterExternalVideoDecoder:\
-            M4DECODER_EXTERNAL_getInterface failed with error 0x%08X",
-            err);
-        free(shellUserData);
-        return err;
-    }
-
-    err = M4VSS3GPP_registerVideoDecoder(&(pClipCtxt->ShellAPI), nativeType,
-        shellInterface);
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4VSS3GPP_intClipRegisterExternalVideoDecoder:\
-            M4VSS3GPP_registerVideoDecoder failed with error 0x%08X",
-            err);
-        free(shellInterface);
-        free(shellUserData);
-        return err;
-    }
-
-    pClipCtxt->ShellAPI.m_pVideoDecoderUserDataTable[nativeType] =
-        shellUserData;
-
-    return M4NO_ERROR;
-}
-
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
 /**
  ******************************************************************************
  * M4OSA_UInt32 M4VSS3GPP_intGetFrameSize_AMRNB()
diff --git a/libvideoeditor/vss/src/M4VSS3GPP_Edit.c b/libvideoeditor/vss/src/M4VSS3GPP_Edit.c
index e778b52..efdda9b 100755
--- a/libvideoeditor/vss/src/M4VSS3GPP_Edit.c
+++ b/libvideoeditor/vss/src/M4VSS3GPP_Edit.c
@@ -190,24 +190,6 @@ M4OSA_ERR M4VSS3GPP_editInit( M4VSS3GPP_EditContext *pContext,
     pC->pOsaFileReadPtr = pFileReadPtrFct;
     pC->pOsaFileWritPtr = pFileWritePtrFct;
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-
-    for ( i = 0; i < M4VD_kVideoType_NB; i++ )
-    {
-        pC->registeredExternalDecs[i].pDecoderInterface = M4OSA_NULL;
-        pC->registeredExternalDecs[i].pUserData = M4OSA_NULL;
-        pC->registeredExternalDecs[i].registered = M4OSA_FALSE;
-    }
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-#ifdef M4VSS_SUPPORT_OMX_CODECS
-
-    for ( i = 0; i < M4VSS3GPP_kCodecType_NB; i++ )
-    {
-        pC->m_codecInterface[i] = M4OSA_NULL;
-    }
-    pC->pOMXUserData = M4OSA_NULL;
-#endif /* M4VSS_SUPPORT_OMX_CODECS */
     /*
     * Reset pointers for media and codecs interfaces */
 
@@ -1659,119 +1641,6 @@ M4OSA_ERR M4VSS3GPP_editCleanUp( M4VSS3GPP_EditContext pContext )
     return M4NO_ERROR;
 }
 
-M4OSA_ERR
-M4VSS3GPP_editRegisterExternalVideoDecoder( M4VSS3GPP_EditContext pContext,
-                                           M4VD_VideoType decoderType,
-                                           M4VD_Interface *pDecoderInterface,
-                                           M4OSA_Void *pUserData )
-{
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-
-    M4VSS3GPP_InternalEditContext *pC =
-        (M4VSS3GPP_InternalEditContext *)pContext;
-    /* Here the situation is a bit special: we need to record the registrations that are made,
-    so that we can replay them for each clip we create. */
-
-    if( decoderType >= M4VD_kVideoType_NB )
-    {
-        return M4ERR_PARAMETER;
-    }
-
-    pC->registeredExternalDecs[decoderType].pDecoderInterface
-        = pDecoderInterface;
-    pC->registeredExternalDecs[decoderType].pUserData = pUserData;
-    pC->registeredExternalDecs[decoderType].registered = M4OSA_TRUE;
-
-    /* Notice it overwrites any HW decoder that may already have been registered for this type;
-    this is normal.*/
-
-    return M4NO_ERROR;
-
-#else
-
-    return M4ERR_NOT_IMPLEMENTED;
-
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-}
-
-M4OSA_ERR
-M4VSS3GPP_editRegisterExternalVideoEncoder( M4VSS3GPP_EditContext pContext,
-                                           M4VE_EncoderType encoderType,
-                                           M4VE_Interface *pEncoderInterface,
-                                           M4OSA_Void *pUserData )
-{
-#ifdef M4VSS_ENABLE_EXTERNAL_ENCODERS
-
-    M4VSS3GPP_InternalEditContext *pC =
-        (M4VSS3GPP_InternalEditContext *)pContext;
-    M4OSA_ERR err = M4NO_ERROR;
-    M4ENCODER_GlobalInterface *shellInterface;
-    M4ENCODER_Format nativeType;
-
-    switch( encoderType )
-    {
-        case M4VE_kH263VideoEnc:
-            err = M4EGE_H263_getInterfaces(&nativeType, &shellInterface,
-                M4ENCODER_OPEN_ADVANCED);
-
-            break;
-
-        case M4VE_kMpeg4VideoEnc:
-            err = M4EGE_MPEG4_getInterfaces(&nativeType, &shellInterface,
-                M4ENCODER_OPEN_ADVANCED);
-            break;
-
-        case M4VE_kH264VideoEnc:
-            M4OSA_TRACE1_0(
-                "M4VSS3GPP_editRegisterExternalVideoEncoder:\
-                H264 encoder type not implemented yet");
-            return M4ERR_NOT_IMPLEMENTED;
-            break;
-
-        default:
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_editRegisterExternalVideoEncoder: unknown encoderType %d",
-                encoderType);
-            return M4ERR_PARAMETER;
-            break;
-    }
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4VSS3GPP_editRegisterExternalVideoEncoder:\
-            M4EGE_getInterface failed with error 0x%08X",
-            err);
-        return err;
-    }
-
-    err = M4VSS3GPP_registerVideoEncoder(&(pC->ShellAPI), nativeType,
-        shellInterface);
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4VSS3GPP_editRegisterExternalVideoEncoder:\
-            M4VSS3GPP_registerVideoEncoder failed with error 0x%08X",
-            err);
-        free(shellInterface);
-        return err;
-    }
-
-    pC->ShellAPI.pVideoEncoderExternalAPITable[nativeType] = pEncoderInterface;
-    pC->ShellAPI.pVideoEncoderUserDataTable[nativeType] = pUserData;
-
-    return M4NO_ERROR;
-
-#else
-
-    return M4ERR_NOT_IMPLEMENTED;
-
-#endif
-
-}
-
 #ifdef WIN32
 /**
  ******************************************************************************
@@ -3303,49 +3172,6 @@ M4OSA_ERR M4VSS3GPP_intOpenClip( M4VSS3GPP_InternalEditContext *pC,
     * Set shortcut */
     pClip = *hClip;
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-    /* replay recorded external decoder registrations on the clip */
-
-    for ( i = 0; i < M4VD_kVideoType_NB; i++ )
-    {
-        if( pC->registeredExternalDecs[i].registered )
-        {
-            err = M4VSS3GPP_intClipRegisterExternalVideoDecoder(pClip, i,
-                pC->registeredExternalDecs[i].pDecoderInterface,
-                pC->registeredExternalDecs[i].pUserData);
-
-            if( M4NO_ERROR != err )
-            {
-                M4OSA_TRACE1_1(
-                    "M4VSS3GPP_intOpenClip:\
-                    M4VSS3GPP_intClipRegisterExternalVideoDecoder() returns 0x%x!",
-                    err);
-                M4VSS3GPP_intClipCleanUp(pClip);
-                return err;
-            }
-        }
-    }
-
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-#ifdef M4VSS_SUPPORT_OMX_CODECS
-
-    M4OSA_TRACE3_1("M4VSS3GPP_intOpenClip: pClip->ShellAPI = 0x%x",
-        &pClip->ShellAPI);
-    err = M4VSS3GPP_intSubscribeExternalCodecs((M4VSS3GPP_EditContext *)pC,
-        (M4OSA_Context) &pClip->ShellAPI);
-
-    if( M4NO_ERROR != err )
-    {
-        M4OSA_TRACE1_1(
-            "M4VSS3GPP_intOpenClip: M4VSS3GPP_intSubscribeExternalCodecs returned err 0x%x",
-            err);
-    }
-    M4OSA_TRACE3_1(
-        "M4VSS3GPP_intOpenClip: M4VSS3GPP_intSubscribeExternalCodecs returned 0x%x",
-        err);
-#endif /* M4VSS_SUPPORT_OMX_CODECS */
-
     err = M4VSS3GPP_intClipOpen(pClip, pClipSettings, M4OSA_FALSE, M4OSA_FALSE,
         M4OSA_FALSE);
 
@@ -3595,431 +3421,3 @@ static M4OSA_Void M4VSS3GPP_intComputeOutputAverageVideoBitrate(
     pC->ewc.uiVideoBitrate = ( total_bitsum / total_duration) * 1000;
 }
 
-#ifdef M4VSS_SUPPORT_OMX_CODECS
-
-/**
- ******************************************************************************
- * M4OSA_ERR M4VSS3GPP_editRegisterExternalCodec(M4VSS3GPP_EditContext pContext,
- *                                               M4VSS3GPP_codecType   codecType,
- *                                               M4OSA_Context pCodecInterface,
- *                                               M4OSA_Void* pUserData)
- * @brief    Registers an external Video/Audio codec with VSS3GPP
- * @note This is much different from the other external codec registration API to cope
- *      up with specific requirement of OMX codec implementation.
- *
- * @param  pContext           (IN) VSS3GPP context
- * @param  codecType        (IN) Type of codec (MPEG4 ...)
- * @param  pCodecInterface  (IN) Codec interface
- * @param  pUserData          (IN) Pointer on a user data to give to external codec
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:       VSS3GPP is not in an appropriate state for
- *                             this function to be called
- ******************************************************************************
- */
-
-M4OSA_ERR M4VSS3GPP_editRegisterExternalCodec( M4VSS3GPP_EditContext pContext,
-                                              M4VSS3GPP_codecType codecType,
-                                              M4OSA_Context pCodecInterface,
-                                              M4OSA_Void *pUserData )
-{
-    M4VSS3GPP_InternalEditContext *pC =
-        (M4VSS3GPP_InternalEditContext *)pContext;
-    M4OSA_ERR err = M4NO_ERROR;
-
-    if( ( M4OSA_NULL == pContext) || (M4OSA_NULL == pCodecInterface) )
-    {
-        M4OSA_TRACE1_2(
-            "M4VSS3GPP_editRegisterExternalCodec: NULL input parameter; pContext=0x%x,\
-            pCodecInterface=0x%x",
-            pContext, pCodecInterface);
-        return M4ERR_PARAMETER;
-    }
-
-    if( codecType >= M4VSS3GPP_kCodecType_NB )
-    {
-        M4OSA_TRACE1_1(
-            "M4VSS3GPP_editRegisterExternalCodec: invalid codec Type; codecType=0x%x",
-            codecType);
-        return M4ERR_PARAMETER;
-    }
-
-    pC->m_codecInterface[codecType] = pCodecInterface;
-    pC->pOMXUserData = pUserData;
-
-    M4OSA_TRACE3_2(
-        "M4VSS3GPP_editRegisterExternalCodec: pC->m_codecInterface[%d] = 0x%x",
-        codecType, pCodecInterface);
-    M4OSA_TRACE3_1(
-        "M4VSS3GPP_editRegisterExternalCodec: pC->pOMXUserDatat = 0x%x",
-        pUserData);
-
-    return M4NO_ERROR;
-}
-
-/**
- ******************************************************************************
- * M4OSA_ERR M4VSS3GPP_editSubscribeExternalCodecs(M4VSS3GPP_EditContext    pContext)
- * @brief    Subscribes to previously registered external Video/Audio codec
- * @note This is much different from the other external codec registration API to cope
- *       up with specific    requirement of OMX codec implementation.
- *
- * @param  pContext           (IN) VSS3GPP context
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:       VSS3GPP is not in an appropriate state for
- *                             this function to be called
- ******************************************************************************
- */
-M4OSA_ERR M4VSS3GPP_editSubscribeExternalCodecs(
-    M4VSS3GPP_EditContext pContext )
-{
-    M4VSS3GPP_InternalEditContext *pC =
-        (M4VSS3GPP_InternalEditContext *)pContext;
-    M4OSA_ERR err = M4NO_ERROR;
-
-    if( M4OSA_NULL == pContext )
-    {
-        M4OSA_TRACE1_1(
-            "M4VSS3GPP_editSubscribeExternalCodecs: NULL input parameter; pContext=0x%x",
-            pContext);
-        return M4ERR_PARAMETER;
-    }
-
-    M4OSA_TRACE3_1(
-        "M4VSS3GPP_editSubscribeExternalCodecs: &pC->ShellAPI = 0x%x",
-        &pC->ShellAPI);
-    err = M4VSS3GPP_intSubscribeExternalCodecs(pContext,
-        (M4OSA_Context) &pC->ShellAPI);
-    M4OSA_TRACE3_1(
-        "M4VSS3GPP_editSubscribeExternalCodecs:\
-        M4VSS3GPP_intSubscribeExternalCodecs returns 0x%x",
-        err);
-    return err;
-}
-
-/**
- ******************************************************************************
- * M4OSA_ERR M4VSS3GPP_intSubscribeExternalCodecs(M4VSS3GPP_EditContext    pContext,
- *                                                 M4OSA_Context pShellCtxt)
- * @brief    Subscribes to previously registered external Video/Audio codec
- * @note This is much different from the other external codec registration API to cope
- *       up with specific requirement of OMX codec implementation.
- *
- * @param  pContext           (IN) VSS3GPP context
- * @param pShellContext    (IN) Media Codec shell context
- * @return  M4NO_ERROR:         No error
- * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
- * @return  M4ERR_STATE:       VSS3GPP is not in an appropriate state for
- *                             this function to be called
- ******************************************************************************
- */
-M4OSA_ERR M4VSS3GPP_intSubscribeExternalCodecs( M4VSS3GPP_EditContext pContext,
-                                               M4OSA_Context pShellCtxt )
-{
-    M4VSS3GPP_InternalEditContext *pC =
-        (M4VSS3GPP_InternalEditContext *)pContext;
-    M4VSS3GPP_MediaAndCodecCtxt *pShellContext =
-        (M4VSS3GPP_MediaAndCodecCtxt *)pShellCtxt;
-    M4OSA_ERR err = M4NO_ERROR;
-
-    if( ( M4OSA_NULL == pContext) || (M4OSA_NULL == pShellContext) )
-    {
-        M4OSA_TRACE1_2(
-            "M4VSS3GPP_intSubscribeExternalCodecs: NULL input parameter; pContext=0x%x,\
-            pShellContext=0x%x",
-            pContext, pShellContext);
-        return M4ERR_PARAMETER;
-    }
-
-    M4OSA_TRACE3_1("M4VSS3GPP_intSubscribeExternalCodecs: pShellContext=0x%x",
-        pShellContext);
-
-#ifdef M4VSS_SUPPORT_VIDEC_3GP
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kVideoDecMPEG4] )
-    {
-        err = M4VSS3GPP_registerVideoDecoder(pShellContext,
-            M4DECODER_kVideoTypeMPEG4, (M4DECODER_VideoInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoDecMPEG4]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerVideoDecoder(Mpeg4) returned err 0x%x",
-                err);
-            return err;
-        }
-        /** Provide the application user data back to the interface functions. **
-        **/
-        pShellContext->m_pVideoDecoderUserDataTable[M4DECODER_kVideoTypeMPEG4] =
-            pC->pOMXUserData;
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs:\
-             M4VSS3GPP_registerVideoDecoder(Mpeg4) OK: 0x%x",
-            (M4DECODER_VideoInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoDecMPEG4]);
-    }
-
-#endif /* M4VSS_SUPPORT_VIDEC_3GP */
-
-#ifdef M4VSS_SUPPORT_VIDEO_AVC
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kVideoDecH264] )
-    {
-        err = M4VSS3GPP_registerVideoDecoder(pShellContext,
-            M4DECODER_kVideoTypeAVC, (M4DECODER_VideoInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoDecH264]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerVideoDecoder(AVC) returned err 0x%x",
-                err);
-            return err;
-        }
-        /** Provide the application user data back to the interface functions. **
-        **/
-        pShellContext->m_pVideoDecoderUserDataTable[M4DECODER_kVideoTypeAVC] =
-            pC->pOMXUserData;
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs: M4VSS3GPP_registerVideoDecoder(H264) OK: 0x%x",
-            (M4DECODER_VideoInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoDecH264]);
-    }
-
-#endif /* M4VSS_SUPPORT_VIDEO_AVC*/
-
-#ifdef M4VSS_SUPPORT_ENCODER_MPEG4
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kVideoEncMPEG4] )
-    {
-        err = M4VSS3GPP_registerVideoEncoder(pShellContext, M4ENCODER_kMPEG4,
-            (M4ENCODER_GlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoEncMPEG4]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerVideoEncoder(Mpeg4) returned err 0x%x",
-                err);
-            return err;
-        }
-        /** Provide the application user data back to the interface functions. **
-        **/
-        pShellContext->pVideoEncoderUserDataTable[M4ENCODER_kMPEG4] =
-            pC->pOMXUserData;
-        pShellContext->pVideoEncoderExternalAPITable[M4ENCODER_kMPEG4] =
-            pC->m_codecInterface[M4VSS3GPP_kVideoEncMPEG4];
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs:\
-            M4VSS3GPP_registerVideoEncoder(Mpeg4) OK: 0x%x",
-            (M4ENCODER_GlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoEncMPEG4]);
-    }
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kVideoEncH263] )
-    {
-        err = M4VSS3GPP_registerVideoEncoder(pShellContext, M4ENCODER_kH263,
-            (M4ENCODER_GlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoEncH263]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerVideoEncoder(H263) returned err 0x%x",
-                err);
-            return err;
-        }
-        /** Provide the application user data back to the interface functions. **
-        **/
-        pShellContext->pVideoEncoderUserDataTable[M4ENCODER_kH263] =
-            pC->pOMXUserData;
-        pShellContext->pVideoEncoderExternalAPITable[M4ENCODER_kH263] =
-            pC->m_codecInterface[M4VSS3GPP_kVideoEncH263];
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs: M4VSS3GPP_registerVideoEncoder(H263) OK: 0x%x",
-            (M4ENCODER_GlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoEncH263]);
-    }
-
-#endif /* M4VSS_SUPPORT_ENCODER_MPEG4 */
-
-#ifdef M4VSS_SUPPORT_ENCODER_AVC
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kVideoEncH264] )
-    {
-        err = M4VSS3GPP_registerVideoEncoder(pShellContext, M4ENCODER_kH264,
-            (M4ENCODER_GlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoEncH264]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerVideoEncoder(H264) returned err 0x%x",
-                err);
-            return err;
-        }
-        /** Provide the application user data back to the interface functions. **
-        **/
-        pShellContext->pVideoEncoderUserDataTable[M4ENCODER_kH264] =
-            pC->pOMXUserData;
-        pShellContext->pVideoEncoderExternalAPITable[M4ENCODER_kH264] =
-            pC->m_codecInterface[M4VSS3GPP_kVideoEncH264];
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs: M4VSS3GPP_registerVideoEncoder(H264) OK: 0x%x",
-            (M4ENCODER_GlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kVideoEncH264]);
-    }
-
-#endif /* M4VSS_SUPPORT_ENCODER_AVC */
-
-#ifdef M4VSS_SUPPORT_AUDEC_AAC
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kAudioDecAAC] )
-    {
-        err = M4VSS3GPP_registerAudioDecoder(pShellContext, M4AD_kTypeAAC,
-            (M4AD_Interface *)pC->m_codecInterface[M4VSS3GPP_kAudioDecAAC]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerAudioDecoder(AAC) returned err 0x%x",
-                err);
-            return err;
-        }
-        pShellContext->pAudioDecoderUserDataTable[M4AD_kTypeAAC] =
-            pC->pOMXUserData;
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs: M4VSS3GPP_registerAudioDecoder(AAC) OK: 0x%x",
-            (M4AD_Interface *)pC->m_codecInterface[M4VSS3GPP_kAudioDecAAC]);
-    }
-
-#endif /* M4VSS_SUPPORT_AUDEC_AAC*/
-
-#ifdef M4VSS_SUPPORT_AUDEC_AMRNB
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kAudioDecAMRNB] )
-    {
-        err = M4VSS3GPP_registerAudioDecoder(pShellContext, M4AD_kTypeAMRNB,
-            (M4AD_Interface
-            *)pC->m_codecInterface[M4VSS3GPP_kAudioDecAMRNB]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerAudioDecoder(AMRNB) returned err 0x%x",
-                err);
-            return err;
-        }
-        pShellContext->pAudioDecoderUserDataTable[M4AD_kTypeAMRNB] =
-            pC->pOMXUserData;
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs:\
-            M4VSS3GPP_registerAudioDecoder(AMRNB) OK: 0x%x",
-            (M4AD_Interface *)pC->m_codecInterface[M4VSS3GPP_kAudioDecAMRNB]);
-    }
-
-#endif /* M4VSS_SUPPORT_AUDEC_AMRNB*/
-
-#ifdef M4VSS_SUPPORT_AUDEC_MP3
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kAudioDecMP3] )
-    {
-        err = M4VSS3GPP_registerAudioDecoder(pShellContext, M4AD_kTypeMP3,
-            (M4AD_Interface *)pC->m_codecInterface[M4VSS3GPP_kAudioDecMP3]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerAudioDecoder(MP3) returned err 0x%x",
-                err);
-            return err;
-        }
-        pShellContext->pAudioDecoderUserDataTable[M4AD_kTypeMP3] =
-            pC->pOMXUserData;
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs: M4VSS3GPP_registerAudioDecoder(MP3) OK: 0x%x",
-            (M4AD_Interface *)pC->m_codecInterface[M4VSS3GPP_kAudioDecMP3]);
-    }
-
-#endif /* M4VSS_SUPPORT_AUDEC_MP3*/
-
-#ifdef M4VSS_SUPPORT_ENCODER_AAC
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kAudioEncAAC] )
-    {
-        err = M4VSS3GPP_registerAudioEncoder(pShellContext, M4ENCODER_kAAC,
-            (M4ENCODER_AudioGlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kAudioEncAAC]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerAudioEncoder(AAC) returned err 0x%x",
-                err);
-            return err;
-        }
-        pShellContext->pAudioEncoderUserDataTable[M4ENCODER_kAAC] =
-            pC->pOMXUserData;
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs: M4VSS3GPP_registerAudioEncoder(AAC) OK: 0x%x",
-            (M4ENCODER_AudioGlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kAudioEncAAC]);
-    }
-
-#endif /* M4VSS_SUPPORT_ENCODER_AAC*/
-
-#ifdef M4VSS_SUPPORT_ENCODER_AMR
-
-    if( M4OSA_NULL != pC->m_codecInterface[M4VSS3GPP_kAudioEncAMRNB] )
-    {
-        err = M4VSS3GPP_registerAudioEncoder(pShellContext, M4ENCODER_kAMRNB,
-            (M4ENCODER_AudioGlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kAudioEncAMRNB]);
-
-        if( M4NO_ERROR != err )
-        {
-            M4OSA_TRACE1_1(
-                "M4VSS3GPP_intSubscribeExternalCodecs:\
-                M4VSS3GPP_registerAudioEncoder(AMRNB) returned err 0x%x",
-                err);
-            return err;
-        }
-        pShellContext->pAudioEncoderUserDataTable[M4ENCODER_kAMRNB] =
-            pC->pOMXUserData;
-        M4OSA_TRACE3_1(
-            "M4VSS3GPP_intSubscribeExternalCodecs:\
-            M4VSS3GPP_registerAudioEncoder(AMRNB) OK: 0x%x",
-            (M4ENCODER_AudioGlobalInterface
-            *)pC->m_codecInterface[M4VSS3GPP_kAudioEncAMRNB]);
-    }
-
-#endif /* M4VSS_SUPPORT_ENCODER_AMR*/
-
-    if( M4OSA_NULL != pC->pOMXUserData )
-    {
-        /* If external OMX codecs are already registered with VSS3GPP internal context
-        * and are being subscribed by application, *
-        * then set boolean to prevent unregistration of external codec interfaces. *
-        * This is to prevent external codec interfaces from being reset
-          during VSS3GPP step function. *
-        * External OMX codecs are registered only once by application.
-          So pointers should remain valid*
-        * throughout life cycle of the application */
-
-        pShellContext->bAllowFreeingOMXCodecInterface = M4OSA_FALSE;
-    }
-
-    return M4NO_ERROR;
-}
-#endif /* M4VSS_SUPPORT_OMX_CODECS */
diff --git a/libvideoeditor/vss/src/M4xVSS_API.c b/libvideoeditor/vss/src/M4xVSS_API.c
index 8750fec..e99cfe5 100755
--- a/libvideoeditor/vss/src/M4xVSS_API.c
+++ b/libvideoeditor/vss/src/M4xVSS_API.c
@@ -30,7 +30,6 @@
 #include "M4OSA_Debug.h"
 #include "M4OSA_FileReader.h"
 #include "M4OSA_FileWriter.h"
-#include "M4OSA_FileExtra.h"
 #include "M4OSA_CoreID.h"
 #include "M4OSA_CharStar.h"
 // StageFright encoders require %16 resolution
@@ -218,23 +217,6 @@ M4OSA_ERR M4xVSS_Init( M4OSA_Context *pContext, M4xVSS_InitParams *pParams )
     /*FB: initialize to avoid crash when error during the editing*/
     xVSS_context->pCurrentEditSettings = M4OSA_NULL;
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-
-    for ( i = 0; i < M4VD_kVideoType_NB; i++ )
-    {
-        xVSS_context->registeredExternalDecs[i].pDecoderInterface = M4OSA_NULL;
-        xVSS_context->registeredExternalDecs[i].pUserData = M4OSA_NULL;
-        xVSS_context->registeredExternalDecs[i].registered = M4OSA_FALSE;
-    }
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-    for ( i = 0; i < M4VE_kEncoderType_NB; i++ )
-    {
-        xVSS_context->registeredExternalEncs[i].pEncoderInterface = M4OSA_NULL;
-        xVSS_context->registeredExternalEncs[i].pUserData = M4OSA_NULL;
-        xVSS_context->registeredExternalEncs[i].registered = M4OSA_FALSE;
-    }
-
     /* Initialize state if all initializations are corrects */
     xVSS_context->m_state = M4xVSS_kStateInitialized;
 
@@ -6101,65 +6083,6 @@ M4OSA_ERR M4xVSS_CleanUp( M4OSA_Context pContext )
     return M4NO_ERROR;
 }
 
-M4OSA_ERR M4xVSS_RegisterExternalVideoDecoder( M4OSA_Context pContext,
-                                              M4VD_VideoType decoderType,
-                                              M4VD_Interface *pDecoderInterface,
-                                              M4OSA_Void *pUserData )
-{
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-
-    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
-    /* Here the situation is a bit special: we need to record the registrations that are made,
-    so that we can replay them for each clip we create. */
-
-    if( decoderType >= M4VD_kVideoType_NB )
-    {
-        return M4ERR_PARAMETER;
-    }
-
-    xVSS_context->registeredExternalDecs[decoderType].pDecoderInterface =
-        pDecoderInterface;
-    xVSS_context->registeredExternalDecs[decoderType].pUserData = pUserData;
-    xVSS_context->registeredExternalDecs[decoderType].registered = M4OSA_TRUE;
-
-    /* Notice it overwrites any HW decoder that may already have been registered for this type;
-    this is normal.*/
-
-    return M4NO_ERROR;
-
-#else
-
-    return M4ERR_NOT_IMPLEMENTED;
-
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-}
-
-M4OSA_ERR M4xVSS_RegisterExternalVideoEncoder( M4OSA_Context pContext,
-                                              M4VE_EncoderType encoderType,
-                                              M4VE_Interface *pEncoderInterface,
-                                              M4OSA_Void *pUserData )
-{
-    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
-    /* Here the situation is a bit special: we need to record the registrations that are made,
-    so that we can replay them for each clip we create. */
-
-    if( encoderType >= M4VE_kEncoderType_NB )
-    {
-        return M4ERR_PARAMETER;
-    }
-
-    xVSS_context->registeredExternalEncs[encoderType].pEncoderInterface =
-        pEncoderInterface;
-    xVSS_context->registeredExternalEncs[encoderType].pUserData = pUserData;
-    xVSS_context->registeredExternalEncs[encoderType].registered = M4OSA_TRUE;
-
-    /* Notice it overwrites any HW encoder that may already have been registered for this type;
-    this is normal.*/
-
-    return M4NO_ERROR;
-}
-
 /**
  ******************************************************************************
  * prototype    M4xVSS_GetVersion(M4_VersionInfo *pVersion)
diff --git a/libvideoeditor/vss/src/M4xVSS_internal.c b/libvideoeditor/vss/src/M4xVSS_internal.c
index e7e2dfd..391c945 100755
--- a/libvideoeditor/vss/src/M4xVSS_internal.c
+++ b/libvideoeditor/vss/src/M4xVSS_internal.c
@@ -23,7 +23,6 @@
  */
 #include "M4OSA_Debug.h"
 #include "M4OSA_CharStar.h"
-#include "M4OSA_FileExtra.h"
 
 #include "NXPSW_CompilerSwitches.h"
 
@@ -94,44 +93,6 @@ M4OSA_ERR M4xVSS_internalStartTranscoding(M4OSA_Context pContext)
         return err;
     }
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-    /* replay recorded external decoder registrations on the MCS */
-    for (i=0; i<M4VD_kVideoType_NB; i++)
-    {
-        if (xVSS_context->registeredExternalDecs[i].registered)
-        {
-            err = M4MCS_registerExternalVideoDecoder(mcs_context, i,
-                    xVSS_context->registeredExternalDecs[i].pDecoderInterface,
-                    xVSS_context->registeredExternalDecs[i].pUserData);
-            if (M4NO_ERROR != err)
-            {
-                M4OSA_TRACE1_1("M4xVSS_internalStartTranscoding:\
-                     M4MCS_registerExternalVideoDecoder() returns 0x%x!", err);
-                M4MCS_abort(mcs_context);
-                return err;
-            }
-        }
-    }
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-    /* replay recorded external encoder registrations on the MCS */
-    for (i=0; i<M4VE_kEncoderType_NB; i++)
-    {
-        if (xVSS_context->registeredExternalEncs[i].registered)
-        {
-            err = M4MCS_registerExternalVideoEncoder(mcs_context, i,
-                    xVSS_context->registeredExternalEncs[i].pEncoderInterface,
-                    xVSS_context->registeredExternalEncs[i].pUserData);
-            if (M4NO_ERROR != err)
-            {
-                M4OSA_TRACE1_1("M4xVSS_internalStartTranscoding:\
-                     M4MCS_registerExternalVideoEncoder() returns 0x%x!", err);
-                M4MCS_abort(mcs_context);
-                return err;
-            }
-        }
-    }
-
     err = M4MCS_open(mcs_context, xVSS_context->pMCScurrentParams->pFileIn,
          xVSS_context->pMCScurrentParams->InputFileType,
              xVSS_context->pMCScurrentParams->pFileOut,
@@ -1550,24 +1511,6 @@ M4OSA_ERR M4xVSS_internalStartConvertPictureTo3gp(M4OSA_Context pContext)
         return err;
     }
 
-    /* replay recorded external encoder registrations on the PTO3GPP */
-    for (i=0; i<M4VE_kEncoderType_NB; i++)
-    {
-        if (xVSS_context->registeredExternalEncs[i].registered)
-        {
-            err = M4PTO3GPP_RegisterExternalVideoEncoder(pM4PTO3GPP_Ctxt, i,
-                    xVSS_context->registeredExternalEncs[i].pEncoderInterface,
-                    xVSS_context->registeredExternalEncs[i].pUserData);
-            if (M4NO_ERROR != err)
-            {
-                M4OSA_TRACE1_1("M4xVSS_internalGenerateEditedFile:\
-                     M4PTO3GPP_registerExternalVideoEncoder() returns 0x%x!", err);
-                M4PTO3GPP_CleanUp(pM4PTO3GPP_Ctxt);
-                return err;
-            }
-        }
-    }
-
     pCallBackCtxt = (M4xVSS_PictureCallbackCtxt*)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_PictureCallbackCtxt),
          M4VS,(M4OSA_Char *) "Pto3gpp callback struct");
     if(pCallBackCtxt == M4OSA_NULL)
@@ -2406,44 +2349,6 @@ M4OSA_ERR M4xVSS_internalGenerateEditedFile(M4OSA_Context pContext)
         return err;
     }
 
-#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
-    /* replay recorded external decoder registrations on the VSS3GPP */
-    for (i=0; i<M4VD_kVideoType_NB; i++)
-    {
-        if (xVSS_context->registeredExternalDecs[i].registered)
-        {
-            err = M4VSS3GPP_editRegisterExternalVideoDecoder(pVssCtxt, i,
-                    xVSS_context->registeredExternalDecs[i].pDecoderInterface,
-                    xVSS_context->registeredExternalDecs[i].pUserData);
-            if (M4NO_ERROR != err)
-            {
-                M4OSA_TRACE1_1("M4xVSS_internalGenerateEditedFile: \
-                    M4VSS3GPP_editRegisterExternalVideoDecoder() returns 0x%x!", err);
-                M4VSS3GPP_editCleanUp(pVssCtxt);
-                return err;
-            }
-        }
-    }
-#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
-
-    /* replay recorded external encoder registrations on the VSS3GPP */
-    for (i=0; i<M4VE_kEncoderType_NB; i++)
-    {
-        if (xVSS_context->registeredExternalEncs[i].registered)
-        {
-            err = M4VSS3GPP_editRegisterExternalVideoEncoder(pVssCtxt, i,
-                    xVSS_context->registeredExternalEncs[i].pEncoderInterface,
-                    xVSS_context->registeredExternalEncs[i].pUserData);
-            if (M4NO_ERROR != err)
-            {
-                M4OSA_TRACE1_1("M4xVSS_internalGenerateEditedFile:\
-                     M4VSS3GPP_editRegisterExternalVideoEncoder() returns 0x%x!", err);
-                M4VSS3GPP_editCleanUp(pVssCtxt);
-                return err;
-            }
-        }
-    }
-
     /* In case of MMS use case, we fill directly into the VSS context the targeted bitrate */
     if(xVSS_context->targetedBitrate != 0)
     {