xref: /frameworks/av/libvideoeditor/vss/src/M4xVSS_API.c

/*
 * 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    M4xVSS_API.c
 * @brief    API of eXtended Video Studio Service (Video Studio 2.1)
 * @note
 ******************************************************************************
 */

/**
 * OSAL main types and errors ***/
#include "M4OSA_Types.h"
#include "M4OSA_Error.h"
#include "M4OSA_Memory.h"
#include "M4OSA_Debug.h"
#include "M4OSA_FileReader.h"
#include "M4OSA_FileWriter.h"
#include "M4OSA_CoreID.h"
#include "M4OSA_CharStar.h"
// StageFright encoders require %16 resolution
#include "M4ENCODER_common.h"
#include "M4DECODER_Common.h"
#include "VideoEditorVideoDecoder.h"

/**
 * VSS 3GPP API definition */
#include "M4VSS3GPP_ErrorCodes.h"

/*************************
Begin of xVSS API
 **************************/

#include "M4xVSS_API.h"
#include "M4xVSS_Internal.h"

/* RC: to delete unecessary temp files on the fly */
#include "M4VSS3GPP_InternalTypes.h"
#include <utils/Log.h>

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_Init(M4OSA_Context* pContext, M4xVSS_InitParams* pParams)
 * @brief        This function initializes the xVSS
 * @note        Initializes the xVSS edit operation (allocates an execution context).
 *
 * @param    pContext            (OUT) Pointer on the xVSS edit context to allocate
 * @param    params                (IN) Parameters mandatory for xVSS
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_ALLOC:        Memory allocation has failed
 ******************************************************************************
 */

M4OSA_ERR M4xVSS_Init( M4OSA_Context *pContext, M4xVSS_InitParams *pParams )
{
    M4xVSS_Context *xVSS_context;
    M4OSA_UInt32 length = 0, i;

    if( pParams == M4OSA_NULL )
    {
        M4OSA_TRACE1_0("Parameter structure for M4xVSS_Init function is NULL");
        return M4ERR_PARAMETER;
    }

    if( pParams->pFileReadPtr == M4OSA_NULL
        || pParams->pFileWritePtr == M4OSA_NULL )
    {
        M4OSA_TRACE1_0(
            "pFileReadPtr or pFileWritePtr in M4xVSS_InitParams structure is NULL");
        return M4ERR_PARAMETER;
    }

    xVSS_context = (M4xVSS_Context *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_Context), M4VS,
        (M4OSA_Char *)"Context of the xVSS layer");

    if( xVSS_context == M4OSA_NULL )
    {
        M4OSA_TRACE1_0("Allocation error in M4xVSS_Init");
        return M4ERR_ALLOC;
    }

    /* Initialize file read/write functions pointers */
    xVSS_context->pFileReadPtr = pParams->pFileReadPtr;
    xVSS_context->pFileWritePtr = pParams->pFileWritePtr;

    /*UTF Conversion support: copy conversion functions pointers and allocate the temporary
     buffer*/
    if( pParams->pConvFromUTF8Fct != M4OSA_NULL )
    {
        if( pParams->pConvToUTF8Fct != M4OSA_NULL )
        {
            xVSS_context->UTFConversionContext.pConvFromUTF8Fct =
                pParams->pConvFromUTF8Fct;
            xVSS_context->UTFConversionContext.pConvToUTF8Fct =
                pParams->pConvToUTF8Fct;
            xVSS_context->UTFConversionContext.m_TempOutConversionSize =
                UTF_CONVERSION_BUFFER_SIZE;
            xVSS_context->UTFConversionContext.pTempOutConversionBuffer =
                (M4OSA_Void *)M4OSA_32bitAlignedMalloc(UTF_CONVERSION_BUFFER_SIZE
                * sizeof(M4OSA_UInt8),
                M4VA, (M4OSA_Char *)"M4xVSS_Init: UTF conversion buffer");

            if( M4OSA_NULL
                == xVSS_context->UTFConversionContext.pTempOutConversionBuffer )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_Init");
                free(xVSS_context->pTempPath);
                xVSS_context->pTempPath = M4OSA_NULL;
                free(xVSS_context);
                xVSS_context = M4OSA_NULL;
                return M4ERR_ALLOC;
            }
        }
        else
        {
            M4OSA_TRACE1_0("M4xVSS_Init: one UTF conversion pointer is null and the other\
                           is not null");
            free(xVSS_context->pTempPath);
            xVSS_context->pTempPath = M4OSA_NULL;
            free(xVSS_context);
            xVSS_context = M4OSA_NULL;
            return M4ERR_PARAMETER;
        }
    }
    else
    {
        xVSS_context->UTFConversionContext.pConvFromUTF8Fct = M4OSA_NULL;
        xVSS_context->UTFConversionContext.pConvToUTF8Fct = M4OSA_NULL;
        xVSS_context->UTFConversionContext.m_TempOutConversionSize = 0;
        xVSS_context->UTFConversionContext.pTempOutConversionBuffer =
            M4OSA_NULL;
    }

    if( pParams->pTempPath != M4OSA_NULL )
    {
        /*No need to convert into UTF8 as all input of xVSS are in UTF8
        (the conversion customer format into UTF8
        is done in VA/VAL)*/
        xVSS_context->pTempPath =
            (M4OSA_Void *)M4OSA_32bitAlignedMalloc(strlen(pParams->pTempPath) + 1,
            M4VS, (M4OSA_Char *)"xVSS Path for temporary files");

        if( xVSS_context->pTempPath == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_Init");
            return M4ERR_ALLOC;
        }
        memcpy((void *)xVSS_context->pTempPath, (void *)pParams->pTempPath,
            strlen(pParams->pTempPath) + 1);
        /* TODO: Check that no previous xVSS temporary files are present ? */
    }
    else
    {
        M4OSA_TRACE1_0("Path for temporary files is NULL");
        free(xVSS_context);
        xVSS_context = M4OSA_NULL;
        return M4ERR_PARAMETER;
    }

    xVSS_context->pSettings =
        (M4VSS3GPP_EditSettings *)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_EditSettings),
        M4VS, (M4OSA_Char *)"Copy of VSS structure");

    if( xVSS_context->pSettings == M4OSA_NULL )
    {
        M4OSA_TRACE1_0("Allocation error in M4xVSS_Init");
        free(xVSS_context->pTempPath);
        xVSS_context->pTempPath = M4OSA_NULL;
        free(xVSS_context);
        xVSS_context = M4OSA_NULL;
        return M4ERR_ALLOC;
    }

    /* Initialize pointers in pSettings */
    xVSS_context->pSettings->pClipList = M4OSA_NULL;
    xVSS_context->pSettings->pTransitionList = M4OSA_NULL;
    xVSS_context->pSettings->Effects = M4OSA_NULL; /* RC */
    xVSS_context->pSettings->xVSS.pBGMtrack = M4OSA_NULL;

    /* This is used to know if the user has added or removed some medias */
    xVSS_context->previousClipNumber = 0;

    /* "State machine" */
    xVSS_context->editingStep = 0;
    xVSS_context->analyseStep = 0;

    xVSS_context->pcmPreviewFile = M4OSA_NULL;

    /* Initialize Pto3GPP and MCS lists */
    xVSS_context->pMCSparamsList = M4OSA_NULL;
    xVSS_context->pPTo3GPPparamsList = M4OSA_NULL;
    xVSS_context->pPTo3GPPcurrentParams = M4OSA_NULL;
    xVSS_context->pMCScurrentParams = M4OSA_NULL;

    xVSS_context->tempFileIndex = 0;

    xVSS_context->targetedBitrate = 0;

    xVSS_context->targetedTimescale = 0;

    xVSS_context->pAudioMixContext = M4OSA_NULL;
    xVSS_context->pAudioMixSettings = M4OSA_NULL;

    /*FB: initialize to avoid crash when error during the editing*/
    xVSS_context->pCurrentEditSettings = M4OSA_NULL;

    /* Initialize state if all initializations are corrects */
    xVSS_context->m_state = M4xVSS_kStateInitialized;

    /* initialize MCS context*/
    xVSS_context->pMCS_Ctxt = M4OSA_NULL;

    *pContext = xVSS_context;

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * prototype    M4xVSS_ReduceTranscode
 * @brief        This function changes the given editing structure in order to
 *                minimize the transcoding time.
 * @note        The xVSS analyses this structure, and if needed, changes the
 *                output parameters (Video codec, video size, audio codec,
 *                audio nb of channels) to minimize the transcoding time.
 *
 * @param    pContext            (OUT) Pointer on the xVSS edit context to allocate
 * @param    pSettings            (IN) Edition settings (allocated by the user)
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_ALLOC:        Memory allocation has failed
 * @return    M4ERR_STATE:        This function cannot not be called at this time
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_ReduceTranscode( M4OSA_Context pContext,
                                 M4VSS3GPP_EditSettings *pSettings )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4OSA_ERR err = M4NO_ERROR;
    M4VIDEOEDITING_ClipProperties fileProperties;
    M4OSA_UInt8 i, j;
    M4OSA_Bool bAudioTransition = M4OSA_FALSE;
    M4OSA_Bool bIsBGMReplace = M4OSA_FALSE;
    M4OSA_Bool bFound;
    M4OSA_UInt32 videoConfig[9] =
    {
        0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    /** Index <-> Video config **/
    /* 0:        H263  SQCIF        */
    /* 1:        H263  QCIF        */
    /* 2:        H263  CIF        */
    /* 3:        MPEG4 SQCIF        */
    /* 4:        MPEG4 QQVGA        */
    /* 5:        MPEG4 QCIF        */
    /* 6:        MPEG4 QVGA        */
    /* 7:        MPEG4 CIF        */
    /* 8:        MPEG4 VGA        */
    /****************************/
    M4OSA_UInt32 audioConfig[3] =
    {
        0, 0, 0
    };
    /** Index <-> Audio config **/
    /* 0:    AMR                    */
    /* 1:    AAC    16kHz mono        */
    /* 2:    AAC 16kHz stereo    */
    /****************************/

    /* Check state */
    if( xVSS_context->m_state != M4xVSS_kStateInitialized \
        && xVSS_context->m_state != M4xVSS_kStateOpened )
    {
        M4OSA_TRACE1_1(
            "Bad state when calling M4xVSS_ReduceTranscode function! State is %d",
            xVSS_context->m_state);
        return M4ERR_STATE;
    }

    /* Check number of clips */
    if( pSettings->uiClipNumber == 0 )
    {
        M4OSA_TRACE1_0("The number of input clip must be greater than 0 !");
        return M4ERR_PARAMETER;
    }

    /* Check if there is a background music, and if its audio will replace input clip audio */
    if( pSettings->xVSS.pBGMtrack != M4OSA_NULL )
    {
        if( pSettings->xVSS.pBGMtrack->uiAddVolume == 100 )
        {
            bIsBGMReplace = M4OSA_TRUE;
        }
    }

    /* Parse all clips, and give occurences of each combination */
    for ( i = 0; i < pSettings->uiClipNumber; i++ )
    {
        /* We ignore JPG input files as they are always transcoded */
        if( pSettings->pClipList[i]->FileType == M4VIDEOEDITING_kFileType_3GPP )
        {
            /**
            * UTF conversion: convert into the customer format*/
            M4OSA_Void *pDecodedPath = pSettings->pClipList[i]->pFile;
            M4OSA_UInt32 ConvertedSize = 0;

            if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                != M4OSA_NULL && xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer
                != M4OSA_NULL )
            {
                err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                    (M4OSA_Void *)pSettings->pClipList[i]->pFile,
                    (M4OSA_Void *)xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer,
                    &ConvertedSize);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1("M4xVSS_ReduceTranscode:\
                                   M4xVSS_internalConvertFromUTF8 returns err: 0x%x", err);
                    return err;
                }
                pDecodedPath =
                    xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
            }
            /**
            * End of the utf conversion, now use the converted path*/
            err = M4xVSS_internalGetProperties(xVSS_context, pDecodedPath,
                &fileProperties);

            //err = M4xVSS_internalGetProperties(xVSS_context, pSettings->pClipList[i]->pFile,
            //     &fileProperties);
            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4xVSS_sendCommand: M4xVSS_internalGetProperties returned 0x%x",
                    err);
                /* TODO: Translate error code of MCS to an xVSS error code ? */
                return err;
            }

            /* Check best video settings */
            if( fileProperties.uiVideoWidth == 128
                && fileProperties.uiVideoHeight == 96 )
            {
                if( fileProperties.VideoStreamType == M4VIDEOEDITING_kH263 )
                {
                    videoConfig[0] += fileProperties.uiClipVideoDuration;
                }
                else if( ( fileProperties.VideoStreamType
                    == M4VIDEOEDITING_kMPEG4) \
                    || (fileProperties.VideoStreamType == M4VIDEOEDITING_kH264) )
                {
                    videoConfig[3] += fileProperties.uiClipVideoDuration;
                }
            }
            else if( fileProperties.uiVideoWidth == 160
                && fileProperties.uiVideoHeight == 120 )
            {
                if( ( fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4) \
                    || (fileProperties.VideoStreamType == M4VIDEOEDITING_kH264) )
                {
                    videoConfig[4] += fileProperties.uiClipVideoDuration;
                }
            }
            else if( fileProperties.uiVideoWidth == 176
                && fileProperties.uiVideoHeight == 144 )
            {
                if( fileProperties.VideoStreamType == M4VIDEOEDITING_kH263 )
                {
                    videoConfig[1] += fileProperties.uiClipVideoDuration;
                }
                else if( ( fileProperties.VideoStreamType
                    == M4VIDEOEDITING_kMPEG4) \
                    || (fileProperties.VideoStreamType == M4VIDEOEDITING_kH264) )
                {
                    videoConfig[5] += fileProperties.uiClipVideoDuration;
                }
            }
            else if( fileProperties.uiVideoWidth == 320
                && fileProperties.uiVideoHeight == 240 )
            {
                if( ( fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4) \
                    || (fileProperties.VideoStreamType == M4VIDEOEDITING_kH264) )
                {
                    videoConfig[6] += fileProperties.uiClipVideoDuration;
                }
            }
            else if( fileProperties.uiVideoWidth == 352
                && fileProperties.uiVideoHeight == 288 )
            {
                if( fileProperties.VideoStreamType == M4VIDEOEDITING_kH263 )
                {
                    videoConfig[2] += fileProperties.uiClipVideoDuration;
                }
                else if( ( fileProperties.VideoStreamType
                    == M4VIDEOEDITING_kMPEG4) \
                    || (fileProperties.VideoStreamType == M4VIDEOEDITING_kH264) )
                {
                    videoConfig[7] += fileProperties.uiClipVideoDuration;
                }
            }
            else if( fileProperties.uiVideoWidth == 640
                && fileProperties.uiVideoHeight == 480 )
            {
                if( ( fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4) \
                    || (fileProperties.VideoStreamType == M4VIDEOEDITING_kH264) )
                {
                    videoConfig[8] += fileProperties.uiClipVideoDuration;
                }
            }

            /* If there is a BGM that replaces existing audio track, we do not care about
            audio track as it will be replaced */
            /* If not, we try to minimize audio reencoding */
            if( bIsBGMReplace == M4OSA_FALSE )
            {
                if( fileProperties.AudioStreamType == M4VIDEOEDITING_kAAC )
                {
                    if( fileProperties.uiSamplingFrequency == 16000 && \
                        fileProperties.uiNbChannels == 1 )
                    {
                        audioConfig[1] += fileProperties.uiClipAudioDuration;
                    }
                    else if( fileProperties.uiSamplingFrequency == 16000 && \
                        fileProperties.uiNbChannels == 2 )
                    {
                        audioConfig[2] += fileProperties.uiClipAudioDuration;
                    }
                }
                else if( fileProperties.AudioStreamType
                    == M4VIDEOEDITING_kAMR_NB )
                {
                    audioConfig[0] += fileProperties.uiClipAudioDuration;
                }
            }
        }
    }

    /* Find best output video format (the most occuring combination) */
    j = 0;
    bFound = M4OSA_FALSE;

    for ( i = 0; i < 9; i++ )
    {
        if( videoConfig[i] >= videoConfig[j] )
        {
            j = i;
            bFound = M4OSA_TRUE;
        }
    }

    if( bFound )
    {
        switch( j )
        {
            case 0:
                pSettings->xVSS.outputVideoFormat = M4VIDEOEDITING_kH263;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kSQCIF;
                break;

            case 1:
                pSettings->xVSS.outputVideoFormat = M4VIDEOEDITING_kH263;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kQCIF;
                break;

            case 2:
                pSettings->xVSS.outputVideoFormat = M4VIDEOEDITING_kH263;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kCIF;
                break;

            case 3:
                pSettings->xVSS.outputVideoFormat =
                    (fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4)
                    ? M4VIDEOEDITING_kMPEG4 : M4VIDEOEDITING_kH264;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kSQCIF;
                break;

            case 4:
                pSettings->xVSS.outputVideoFormat =
                    (fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4)
                    ? M4VIDEOEDITING_kMPEG4 : M4VIDEOEDITING_kH264;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kQQVGA;
                break;

            case 5:
                pSettings->xVSS.outputVideoFormat =
                    (fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4)
                    ? M4VIDEOEDITING_kMPEG4 : M4VIDEOEDITING_kH264;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kQCIF;
                break;

            case 6:
                pSettings->xVSS.outputVideoFormat =
                    (fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4)
                    ? M4VIDEOEDITING_kMPEG4 : M4VIDEOEDITING_kH264;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kQVGA;
                break;

            case 7:
                pSettings->xVSS.outputVideoFormat =
                    (fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4)
                    ? M4VIDEOEDITING_kMPEG4 : M4VIDEOEDITING_kH264;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kCIF;
                break;

            case 8:
                pSettings->xVSS.outputVideoFormat =
                    (fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4)
                    ? M4VIDEOEDITING_kMPEG4 : M4VIDEOEDITING_kH264;
                pSettings->xVSS.outputVideoSize = M4VIDEOEDITING_kVGA;
                break;
        }
    }

    /* Find best output audio format (the most occuring combination) */
    j = 0;
    bFound = M4OSA_FALSE;

    for ( i = 0; i < 3; i++ )
    {
        if( audioConfig[i] >= audioConfig[j] )
        {
            j = i;
            bFound = M4OSA_TRUE;
        }
    }

    if( bFound )
    {
        switch( j )
        {
            case 0:
                pSettings->xVSS.outputAudioFormat = M4VIDEOEDITING_kAMR_NB;
                pSettings->xVSS.bAudioMono = M4OSA_TRUE;
                break;

            case 1:
                pSettings->xVSS.outputAudioFormat = M4VIDEOEDITING_kAAC;
                pSettings->xVSS.bAudioMono = M4OSA_TRUE;
                break;

            case 2:
                pSettings->xVSS.outputAudioFormat = M4VIDEOEDITING_kAAC;
                pSettings->xVSS.bAudioMono = M4OSA_FALSE;
                break;
        }
    }

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_SendCommand(M4OSA_Context pContext,
 *                                         M4VSS3GPP_EditSettings* pSettings)
 * @brief        This function gives to the xVSS an editing structure
 * @note        The xVSS analyses this structure, and prepare edition
 *                This function must be called after M4xVSS_Init, after
 *                M4xVSS_CloseCommand, or after M4xVSS_PreviewStop.
 *                After this function, the user must call M4xVSS_Step until
 *                it returns another error than M4NO_ERROR.
 *
 * @param    pContext            (IN) Pointer on the xVSS edit context
 * @param    pSettings            (IN) Edition settings (allocated by the user)
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_ALLOC:        Memory allocation has failed
 * @return    M4ERR_STATE:        This function cannot not be called at this time
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_SendCommand( M4OSA_Context pContext,
                             M4VSS3GPP_EditSettings *pSettings )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4OSA_UInt8 i, j;
    M4OSA_UInt8 nbOfSameClip = 0;
    M4OSA_ERR err;
    M4OSA_Bool isNewBGM = M4OSA_TRUE;
    M4xVSS_Pto3GPP_params *pPto3GPP_last = M4OSA_NULL;
    M4xVSS_MCS_params *pMCS_last = M4OSA_NULL;
    M4OSA_UInt32 width, height, samplingFreq;
    M4OSA_Bool bIsTranscoding = M4OSA_FALSE;
    M4OSA_Int32 totalDuration;
    M4OSA_UInt32 outputSamplingFrequency = 0;
    M4OSA_UInt32 length = 0;
    M4OSA_Int8 masterClip = -1;

    i = 0;
    /* Check state */
    if( xVSS_context->m_state != M4xVSS_kStateInitialized \
        && xVSS_context->m_state != M4xVSS_kStateOpened )
    {
        M4OSA_TRACE1_1(
            "Bad state when calling M4xVSS_SendCommand function! State is %d",
            xVSS_context->m_state);
        return M4ERR_STATE;
    }

    /* State is back to initialized to allow call of cleanup function in case of error */
    xVSS_context->m_state = M4xVSS_kStateInitialized;

    /* Check if a previous sendCommand has been called */
    if( xVSS_context->previousClipNumber != 0 )
    {
        M4OSA_UInt32 pCmpResult = 0;

        /* Compare BGM input */
        if( xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL \
            && pSettings->xVSS.pBGMtrack != M4OSA_NULL )
        {
            pCmpResult = strcmp((const char *)xVSS_context->pSettings->xVSS.pBGMtrack->pFile,
                (const char *)pSettings->xVSS.pBGMtrack->pFile);

            if( pCmpResult == 0 )
            {
                /* Check if audio output parameters have changed */
                if( xVSS_context->pSettings->xVSS.outputAudioFormat ==
                    pSettings->xVSS.outputAudioFormat
                    && xVSS_context->pSettings->xVSS.bAudioMono
                    == pSettings->xVSS.bAudioMono )
                {
                    /* It means that BGM is the same as before, so, no need to redecode it */
                    M4OSA_TRACE2_0(
                        "BGM is the same as before, nothing to decode");
                    isNewBGM = M4OSA_FALSE;
                }
                else
                {
                    /* We need to unallocate PCM preview file path in internal context */
                    if( xVSS_context->pcmPreviewFile != M4OSA_NULL )
                    {
                        free(xVSS_context->pcmPreviewFile);
                        xVSS_context->pcmPreviewFile = M4OSA_NULL;
                    }
                }
            }
            else
            {
                /* We need to unallocate PCM preview file path in internal context */
                if( xVSS_context->pcmPreviewFile != M4OSA_NULL )
                {
                    free(xVSS_context->pcmPreviewFile);
                    xVSS_context->pcmPreviewFile = M4OSA_NULL;
                }
            }
        }

        /* Check if output settings have changed */
        if( xVSS_context->pSettings->xVSS.outputVideoSize
            != pSettings->xVSS.outputVideoSize
            || xVSS_context->pSettings->xVSS.outputVideoFormat
            != pSettings->xVSS.outputVideoFormat
            || xVSS_context->pSettings->xVSS.outputVideoProfile
            != pSettings->xVSS.outputVideoProfile
            || xVSS_context->pSettings->xVSS.outputVideoLevel
            != pSettings->xVSS.outputVideoLevel
            || xVSS_context->pSettings->xVSS.outputAudioFormat
            != pSettings->xVSS.outputAudioFormat
            || xVSS_context->pSettings->xVSS.bAudioMono
            != pSettings->xVSS.bAudioMono
            || xVSS_context->pSettings->xVSS.outputAudioSamplFreq
            != pSettings->xVSS.outputAudioSamplFreq )
        {
            /* If it is the case, we can't reuse already transcoded/converted files */
            /* so, we delete these files and remove them from chained list */
            if( xVSS_context->pPTo3GPPparamsList != M4OSA_NULL )
            {
                M4xVSS_Pto3GPP_params *pParams =
                    xVSS_context->pPTo3GPPparamsList;
                M4xVSS_Pto3GPP_params *pParams_sauv;

                while( pParams != M4OSA_NULL )
                {
                    if( pParams->pFileIn != M4OSA_NULL )
                    {
                        free(pParams->pFileIn);
                        pParams->pFileIn = M4OSA_NULL;
                    }

                    if( pParams->pFileOut != M4OSA_NULL )
                    {
                        /* Delete temporary file */
                        remove((const char *)pParams->pFileOut);
                        free(pParams->pFileOut);
                        pParams->pFileOut = M4OSA_NULL;
                    }

                    if( pParams->pFileTemp != M4OSA_NULL )
                    {
                        /* Delete temporary file */
#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE

                        remove((const char *)pParams->pFileTemp);
                        free(pParams->pFileTemp);

#endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/

                        pParams->pFileTemp = M4OSA_NULL;
                    }
                    pParams_sauv = pParams;
                    pParams = pParams->pNext;
                    free(pParams_sauv);
                    pParams_sauv = M4OSA_NULL;
                }
                xVSS_context->pPTo3GPPparamsList = M4OSA_NULL;
            }

            if( xVSS_context->pMCSparamsList != M4OSA_NULL )
            {
                M4xVSS_MCS_params *pParams = xVSS_context->pMCSparamsList;
                M4xVSS_MCS_params *pParams_sauv;
                M4xVSS_MCS_params *pParams_bgm = M4OSA_NULL;

                while( pParams != M4OSA_NULL )
                {
                    /* Here, we do not delete BGM */
                    if( pParams->isBGM != M4OSA_TRUE )
                    {
                        if( pParams->pFileIn != M4OSA_NULL )
                        {
                            free(pParams->pFileIn);
                            pParams->pFileIn = M4OSA_NULL;
                        }

                        if( pParams->pFileOut != M4OSA_NULL )
                        {
                            /* Delete temporary file */
                            remove((const char *)pParams->pFileOut);
                            free(pParams->pFileOut);
                            pParams->pFileOut = M4OSA_NULL;
                        }

                        if( pParams->pFileTemp != M4OSA_NULL )
                        {
                            /* Delete temporary file */
#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE

                            remove((const char *)pParams->pFileTemp);
                            free(pParams->pFileTemp);

#endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/

                            pParams->pFileTemp = M4OSA_NULL;
                        }
                        pParams_sauv = pParams;
                        pParams = pParams->pNext;
                        free(pParams_sauv);
                        pParams_sauv = M4OSA_NULL;
                    }
                    else
                    {
                        pParams_bgm = pParams;
                        pParams = pParams->pNext;
                        /*PR P4ME00003182 initialize this pointer because the following params
                        element will be deallocated*/
                        if( pParams != M4OSA_NULL
                            && pParams->isBGM != M4OSA_TRUE )
                        {
                            pParams_bgm->pNext = M4OSA_NULL;
                        }
                    }
                }
                xVSS_context->pMCSparamsList = pParams_bgm;
            }
            /* Maybe need to implement framerate changing */
            //xVSS_context->pSettings->videoFrameRate;
        }

        /* Unallocate previous xVSS_context->pSettings structure */
        M4xVSS_freeSettings(xVSS_context->pSettings);

        /*Unallocate output file path*/
        if( xVSS_context->pSettings->pOutputFile != M4OSA_NULL )
        {
            free(xVSS_context->pSettings->pOutputFile);
            xVSS_context->pSettings->pOutputFile = M4OSA_NULL;
        }
        xVSS_context->pSettings->uiOutputPathSize = 0;
        xVSS_context->pOutputFile = M4OSA_NULL;
    }

    /**********************************
    Clips registering
    **********************************/

    /* Copy settings from user given structure to our "local" structure */
    xVSS_context->pSettings->xVSS.outputVideoFormat =
        pSettings->xVSS.outputVideoFormat;
    xVSS_context->pSettings->xVSS.outputVideoProfile =
        pSettings->xVSS.outputVideoProfile;
    xVSS_context->pSettings->xVSS.outputVideoLevel =
        pSettings->xVSS.outputVideoLevel;
    xVSS_context->pSettings->xVSS.outputVideoSize =
        pSettings->xVSS.outputVideoSize;
    xVSS_context->pSettings->xVSS.outputAudioFormat =
        pSettings->xVSS.outputAudioFormat;
    xVSS_context->pSettings->xVSS.bAudioMono = pSettings->xVSS.bAudioMono;
    xVSS_context->pSettings->xVSS.outputAudioSamplFreq =
        pSettings->xVSS.outputAudioSamplFreq;
    /*xVSS_context->pSettings->pOutputFile = pSettings->pOutputFile;*/
    /*FB: VAL CR P4ME00003076
    The output video and audio bitrate are given by the user in the edition settings structure*/
    xVSS_context->pSettings->xVSS.outputVideoBitrate =
        pSettings->xVSS.outputVideoBitrate;
    xVSS_context->pSettings->xVSS.outputAudioBitrate =
        pSettings->xVSS.outputAudioBitrate;
    xVSS_context->pSettings->PTVolLevel = pSettings->PTVolLevel;

    /*FB: bug fix if the output path is given in M4xVSS_sendCommand*/

    if( pSettings->pOutputFile != M4OSA_NULL
        && pSettings->uiOutputPathSize > 0 )
    {
        M4OSA_Void *pDecodedPath = pSettings->pOutputFile;
        /*As all inputs of the xVSS are in UTF8, convert the output file path into the
        customer format*/
        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
            && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
            != M4OSA_NULL )
        {
            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                (M4OSA_Void *)pSettings->pOutputFile,
                (M4OSA_Void *)xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer, &length);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1("M4xVSS_SendCommand:\
                               M4xVSS_internalConvertFromUTF8 returns err: 0x%x", err);
                return err;
            }
            pDecodedPath =
                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
            pSettings->uiOutputPathSize = length;
        }

        xVSS_context->pSettings->pOutputFile = (M4OSA_Void *)M4OSA_32bitAlignedMalloc \
            (pSettings->uiOutputPathSize + 1, M4VS,
            (M4OSA_Char *)"output file path");

        if( xVSS_context->pSettings->pOutputFile == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            /*FB: to avoid leaks when there is an error in the send command*/
            /* Free Send command */
            M4xVSS_freeCommand(xVSS_context);
            /**/
            return M4ERR_ALLOC;
        }
        memcpy((void *)xVSS_context->pSettings->pOutputFile,
            (void *)pDecodedPath, pSettings->uiOutputPathSize + 1);
        xVSS_context->pSettings->uiOutputPathSize = pSettings->uiOutputPathSize;
        xVSS_context->pOutputFile = xVSS_context->pSettings->pOutputFile;
    }
    else
    {
        xVSS_context->pSettings->pOutputFile = M4OSA_NULL;
        xVSS_context->pSettings->uiOutputPathSize = 0;
        xVSS_context->pOutputFile = M4OSA_NULL;
    }
    xVSS_context->pSettings->pTemporaryFile = pSettings->pTemporaryFile;
    xVSS_context->pSettings->uiClipNumber = pSettings->uiClipNumber;
    xVSS_context->pSettings->videoFrameRate = pSettings->videoFrameRate;
    xVSS_context->pSettings->uiMasterClip =
        0; /* With VSS 2.0, this new param is mandatory */
    xVSS_context->pSettings->xVSS.pTextRenderingFct =
        pSettings->xVSS.pTextRenderingFct; /* CR text handling */
    xVSS_context->pSettings->xVSS.outputFileSize =
        pSettings->xVSS.outputFileSize;

    if( pSettings->xVSS.outputFileSize != 0 \
        && pSettings->xVSS.outputAudioFormat != M4VIDEOEDITING_kAMR_NB )
    {
        M4OSA_TRACE1_0("M4xVSS_SendCommand: Impossible to limit file\
                       size with other audio output than AAC");
        return M4ERR_PARAMETER;
    }
    xVSS_context->nbStepTotal = 0;
    xVSS_context->currentStep = 0;

    if( xVSS_context->pSettings->xVSS.outputVideoFormat != M4VIDEOEDITING_kMPEG4
        && xVSS_context->pSettings->xVSS.outputVideoFormat
        != M4VIDEOEDITING_kH263
        && xVSS_context->pSettings->xVSS.outputVideoFormat
        != M4VIDEOEDITING_kH264 )
    {
        xVSS_context->pSettings->xVSS.outputVideoFormat =
            M4VIDEOEDITING_kNoneVideo;
    }

    /* Get output width/height */
    switch( xVSS_context->pSettings->xVSS.outputVideoSize )
    {
        case M4VIDEOEDITING_kSQCIF:
            width = 128;
            height = 96;
            break;

        case M4VIDEOEDITING_kQQVGA:
            width = 160;
            height = 120;
            break;

        case M4VIDEOEDITING_kQCIF:
            width = 176;
            height = 144;
            break;

        case M4VIDEOEDITING_kQVGA:
            width = 320;
            height = 240;
            break;

        case M4VIDEOEDITING_kCIF:
            width = 352;
            height = 288;
            break;

        case M4VIDEOEDITING_kVGA:
            width = 640;
            height = 480;
            break;
            /* +PR LV5807 */
        case M4VIDEOEDITING_kWVGA:
            width = 800;
            height = 480;
            break;

        case M4VIDEOEDITING_kNTSC:
            width = 720;
            height = 480;
            break;
            /* -PR LV5807 */
            /* +CR Google */
        case M4VIDEOEDITING_k640_360:
            width = 640;
            height = 360;
            break;

        case M4VIDEOEDITING_k854_480:

            // StageFright encoders require %16 resolution

            width = M4ENCODER_854_480_Width;

            height = 480;
            break;

        case M4VIDEOEDITING_k1280_720:
            width = 1280;
            height = 720;
            break;

        case M4VIDEOEDITING_k1080_720:
            // StageFright encoders require %16 resolution
            width = M4ENCODER_1080_720_Width;
            height = 720;
            break;

        case M4VIDEOEDITING_k960_720:
            width = 960;
            height = 720;
            break;

        case M4VIDEOEDITING_k1920_1080:
            width = 1920;
            height = M4ENCODER_1920_1080_Height;
            break;

            /* -CR Google */
        default: /* If output video size is not given, we take QCIF size */
            width = 176;
            height = 144;
            xVSS_context->pSettings->xVSS.outputVideoSize =
                M4VIDEOEDITING_kQCIF;
            break;
    }

    /* Get output Sampling frequency */
    switch( xVSS_context->pSettings->xVSS.outputAudioSamplFreq )
    {
        case M4VIDEOEDITING_k8000_ASF:
            samplingFreq = 8000;
            break;

        case M4VIDEOEDITING_k16000_ASF:
            samplingFreq = 16000;
            break;

        case M4VIDEOEDITING_k22050_ASF:
            samplingFreq = 22050;
            break;

        case M4VIDEOEDITING_k24000_ASF:
            samplingFreq = 24000;
            break;

        case M4VIDEOEDITING_k32000_ASF:
            samplingFreq = 32000;
            break;

        case M4VIDEOEDITING_k44100_ASF:
            samplingFreq = 44100;
            break;

        case M4VIDEOEDITING_k48000_ASF:
            samplingFreq = 48000;
            break;

        case M4VIDEOEDITING_kDefault_ASF:
        default:
            if( xVSS_context->pSettings->xVSS.outputAudioFormat
                == M4VIDEOEDITING_kAMR_NB )
            {
                samplingFreq = 8000;
            }
            else if( xVSS_context->pSettings->xVSS.outputAudioFormat
                == M4VIDEOEDITING_kAAC )
            {
                samplingFreq = 16000;
            }
            else
            {
                samplingFreq = 0;
            }
            break;
    }

    /* Allocate clip/transitions if clip number is not null ... */
    if( 0 < xVSS_context->pSettings->uiClipNumber )
    {
        if( xVSS_context->pSettings->pClipList != M4OSA_NULL )
        {
            free((xVSS_context->pSettings->pClipList));
            xVSS_context->pSettings->pClipList = M4OSA_NULL;
        }

        if( xVSS_context->pSettings->pTransitionList != M4OSA_NULL )
        {
            free(xVSS_context->pSettings->pTransitionList);
            xVSS_context->pSettings->pTransitionList = M4OSA_NULL;
        }

        xVSS_context->pSettings->pClipList =
            (M4VSS3GPP_ClipSettings ** )M4OSA_32bitAlignedMalloc \
            (sizeof(M4VSS3GPP_ClipSettings *)*xVSS_context->pSettings->uiClipNumber,
            M4VS, (M4OSA_Char *)"xVSS, copy of pClipList");

        if( xVSS_context->pSettings->pClipList == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            /*FB: to avoid leaks when there is an error in the send command*/
            /* Free Send command */
            M4xVSS_freeCommand(xVSS_context);
            /**/
            return M4ERR_ALLOC;
        }
        /* Set clip list to NULL */
        memset((void *)xVSS_context->pSettings->pClipList,0,
            sizeof(M4VSS3GPP_ClipSettings *)
            *xVSS_context->pSettings->uiClipNumber);

        if( xVSS_context->pSettings->uiClipNumber > 1 )
        {
            xVSS_context->pSettings->pTransitionList =
                (M4VSS3GPP_TransitionSettings ** ) \
                M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_TransitionSettings *)                \
                *(xVSS_context->pSettings->uiClipNumber - 1), M4VS, (M4OSA_Char *) \
                "xVSS, copy of pTransitionList");

            if( xVSS_context->pSettings->pTransitionList == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                /*FB: to avoid leaks when there is an error in the send command*/
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                /**/
                return M4ERR_ALLOC;
            }
            /* Set transition list to NULL */
            memset(
                (void *)xVSS_context->pSettings->pTransitionList,0,
                sizeof(M4VSS3GPP_TransitionSettings *)
                *(xVSS_context->pSettings->uiClipNumber - 1));
        }
        else
        {
            xVSS_context->pSettings->pTransitionList = M4OSA_NULL;
        }
    }
    /* else, there is a pb in the input settings structure */
    else
    {
        M4OSA_TRACE1_0("No clip in this settings list !!");
        /*FB: to avoid leaks when there is an error in the send command*/
        /* Free Send command */
        M4xVSS_freeCommand(xVSS_context);
        /**/
        return M4ERR_PARAMETER;
    }

    /* RC Allocate effects settings */
    xVSS_context->pSettings->nbEffects = pSettings->nbEffects;

    if( 0 < xVSS_context->pSettings->nbEffects )
    {
        xVSS_context->pSettings->Effects =
            (M4VSS3GPP_EffectSettings *)M4OSA_32bitAlignedMalloc \
            (xVSS_context->pSettings->nbEffects * sizeof(M4VSS3GPP_EffectSettings),
            M4VS, (M4OSA_Char *)"effects settings");

        if( xVSS_context->pSettings->Effects == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            /*FB: to avoid leaks when there is an error in the send command*/
            /* Free Send command */
            M4xVSS_freeCommand(xVSS_context);
            /**/
            return M4ERR_ALLOC;
        }
        /*FB bug fix 19.03.2008: these pointers were not initialized -> crash when free*/
        for ( i = 0; i < xVSS_context->pSettings->nbEffects; i++ )
        {
            xVSS_context->pSettings->Effects[i].xVSS.pFramingFilePath =
                M4OSA_NULL;
            xVSS_context->pSettings->Effects[i].xVSS.pFramingBuffer =
                M4OSA_NULL;
            xVSS_context->pSettings->Effects[i].xVSS.pTextBuffer = M4OSA_NULL;
        }
        /**/
    }

    if( xVSS_context->targetedTimescale == 0 )
    {
        M4OSA_UInt32 pTargetedTimeScale = 0;

        err = M4xVSS_internalGetTargetedTimeScale(xVSS_context, pSettings,
            &pTargetedTimeScale);

        if( M4NO_ERROR != err || pTargetedTimeScale == 0 )
        {
            M4OSA_TRACE1_1("M4xVSS_SendCommand: M4xVSS_internalGetTargetedTimeScale\
                           returned 0x%x", err);
            /*FB: to avoid leaks when there is an error in the send command*/
            /* Free Send command */
            M4xVSS_freeCommand(xVSS_context);
            /**/
            return err;
        }
        xVSS_context->targetedTimescale = pTargetedTimeScale;
    }

    /* Initialize total duration variable */
    totalDuration = 0;

    /* Parsing list of clips given by application, and prepare analyzing */
    for ( i = 0; i < xVSS_context->pSettings->uiClipNumber; i++ )
    {
        /* Allocate current clip */
        xVSS_context->pSettings->pClipList[i] =
            (M4VSS3GPP_ClipSettings *)M4OSA_32bitAlignedMalloc \
            (sizeof(M4VSS3GPP_ClipSettings), M4VS, (M4OSA_Char *)"clip settings");

        if( xVSS_context->pSettings->pClipList[i] == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            /*FB: to avoid leaks when there is an error in the send command*/
            /* Free Send command */
            M4xVSS_freeCommand(xVSS_context);
            /**/
            return M4ERR_ALLOC;
        }

        /* Copy clip settings from given structure to our xVSS_context structure */
        err =
            M4xVSS_DuplicateClipSettings(xVSS_context->pSettings->pClipList[i],
            pSettings->pClipList[i], M4OSA_TRUE);

        if( err != M4NO_ERROR )
        {
            M4OSA_TRACE1_1(
                "M4xVSS_SendCommand: M4xVSS_DuplicateClipSettings return error 0x%x",
                err);
            /*FB: to avoid leaks when there is an error in the send command*/
            /* Free Send command */
            M4xVSS_freeCommand(xVSS_context);
            /**/
            return err;
        }

        xVSS_context->pSettings->pClipList[i]->bTranscodingRequired =
            M4OSA_FALSE;

        /* Because there is 1 less transition than clip number */
        if( i < xVSS_context->pSettings->uiClipNumber - 1 )
        {
            xVSS_context->pSettings->pTransitionList[i] =
                (M4VSS3GPP_TransitionSettings
                *)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_TransitionSettings),
                M4VS, (M4OSA_Char *)"transition settings");

            if( xVSS_context->pSettings->pTransitionList[i] == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                /*FB: to avoid leaks when there is an error in the send command*/
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                /**/
                return M4ERR_ALLOC;
            }

            memcpy(
                (void *)xVSS_context->pSettings->pTransitionList[i],
                (void *)pSettings->pTransitionList[i],
                sizeof(M4VSS3GPP_TransitionSettings));
            /* Initialize external effect context to NULL, to know if input jpg has already been
            decoded or not */
            xVSS_context->pSettings->pTransitionList[i]->
                pExtVideoTransitionFctCtxt = M4OSA_NULL;

            switch( xVSS_context->pSettings->
                pTransitionList[i]->VideoTransitionType )
            {
                    /* If transition type is alpha magic, we need to decode input file */
                case M4xVSS_kVideoTransitionType_AlphaMagic:
                    /* Allocate our alpha magic settings structure to have a copy of the
                    provided one */
                    xVSS_context->pSettings->pTransitionList[i]->      \
                     xVSS.transitionSpecific.pAlphaMagicSettings =
                        (M4xVSS_AlphaMagicSettings *)M4OSA_32bitAlignedMalloc \
                        (sizeof(M4xVSS_AlphaMagicSettings), M4VS,
                        (M4OSA_Char *)"Input Alpha magic settings structure");

                    if( xVSS_context->pSettings->pTransitionList[i]-> \
                        xVSS.transitionSpecific.pAlphaMagicSettings == M4OSA_NULL )
                    {
                        M4OSA_TRACE1_0(
                            "Allocation error in M4xVSS_SendCommand");
                        /*FB: to avoid leaks when there is an error in the send command*/
                        /* Free Send command */
                        M4xVSS_freeCommand(xVSS_context);
                        /**/
                        return M4ERR_ALLOC;
                    }
                    /* Copy data from the provided alpha magic settings structure tou our
                    structure */
                    memcpy((void *)xVSS_context->pSettings->
                        pTransitionList[i]-> \
                        xVSS.transitionSpecific.pAlphaMagicSettings,
                        (void *)pSettings->pTransitionList[i]-> \
                        xVSS.transitionSpecific.pAlphaMagicSettings,
                        sizeof(M4xVSS_AlphaMagicSettings));

                    /* Allocate our alpha magic input filename */
                    xVSS_context->pSettings->pTransitionList[i]-> \
                        xVSS.transitionSpecific.pAlphaMagicSettings->
                        pAlphaFilePath = M4OSA_32bitAlignedMalloc(
                        (strlen(pSettings->pTransitionList[i]-> \
                        xVSS.transitionSpecific.pAlphaMagicSettings->pAlphaFilePath)
                        + 1), M4VS, (M4OSA_Char *)"Alpha magic file path");

                    if( xVSS_context->pSettings->pTransitionList[i]-> \
                        xVSS.transitionSpecific.pAlphaMagicSettings->pAlphaFilePath
                        == M4OSA_NULL )
                    {
                        M4OSA_TRACE1_0(
                            "Allocation error in M4xVSS_SendCommand");
                        /*FB: to avoid leaks when there is an error in the send command*/
                        /* Free Send command */
                        M4xVSS_freeCommand(xVSS_context);
                        /**/
                        return M4ERR_ALLOC;
                    }
                    /* Copy data from the provided alpha magic filename to our */
                    M4OSA_chrNCopy(
                        xVSS_context->pSettings->pTransitionList[i]->xVSS.
                        transitionSpecific.pAlphaMagicSettings->
                        pAlphaFilePath,
                        pSettings->pTransitionList[i]->xVSS.
                        transitionSpecific.pAlphaMagicSettings->
                        pAlphaFilePath, strlen(
                        pSettings->pTransitionList[i]->xVSS.
                        transitionSpecific.pAlphaMagicSettings->
                        pAlphaFilePath) + 1);

                    /* Parse all transition to know if the input jpg has already been decoded */
                    for ( j = 0; j < i; j++ )
                    {
                        if( xVSS_context->pSettings->
                            pTransitionList[j]->VideoTransitionType
                            == M4xVSS_kVideoTransitionType_AlphaMagic )
                        {
                            M4OSA_UInt32 pCmpResult = 0;
                            pCmpResult = strcmp((const char *)xVSS_context->pSettings->
                                pTransitionList[i]->xVSS.
                                transitionSpecific.pAlphaMagicSettings->
                                pAlphaFilePath, (const char *)xVSS_context->pSettings->
                                pTransitionList[j]->xVSS.
                                transitionSpecific.
                                pAlphaMagicSettings->pAlphaFilePath);

                            if( pCmpResult == 0 )
                            {
                                M4xVSS_internal_AlphaMagicSettings
                                    *alphaSettings;

                                alphaSettings =
                                    (M4xVSS_internal_AlphaMagicSettings
                                    *)M4OSA_32bitAlignedMalloc(
                                    sizeof(
                                    M4xVSS_internal_AlphaMagicSettings),
                                    M4VS,
                                    (M4OSA_Char
                                    *)
                                    "Alpha magic settings structure 1");

                                if( alphaSettings == M4OSA_NULL )
                                {
                                    M4OSA_TRACE1_0(
                                        "Allocation error in M4xVSS_SendCommand");
                                    /*FB: to avoid leaks when there is an error in the send
                                     command*/
                                    /* Free Send command */
                                    M4xVSS_freeCommand(xVSS_context);
                                    /**/
                                    return M4ERR_ALLOC;
                                }
                                alphaSettings->pPlane =
                                    ((M4xVSS_internal_AlphaMagicSettings *)(
                                    xVSS_context->pSettings->
                                    pTransitionList[j]->
                                    pExtVideoTransitionFctCtxt))->
                                    pPlane;

                                if( xVSS_context->pSettings->
                                    pTransitionList[i]->xVSS.transitionSpecific.
                                    pAlphaMagicSettings->blendingPercent > 0
                                    && xVSS_context->pSettings->
                                    pTransitionList[i]->xVSS.
                                    transitionSpecific.
                                    pAlphaMagicSettings->blendingPercent
                                    <= 100 )
                                {
                                    alphaSettings->blendingthreshold =
                                        ( xVSS_context->pSettings->
                                        pTransitionList[i]->xVSS.
                                        transitionSpecific.
                                        pAlphaMagicSettings->
                                        blendingPercent) * 255 / 200;
                                }
                                else
                                {
                                    alphaSettings->blendingthreshold = 0;
                                }
                                alphaSettings->isreverse =
                                    xVSS_context->pSettings->
                                    pTransitionList[i]->xVSS.
                                    transitionSpecific.
                                    pAlphaMagicSettings->isreverse;
                                /* It means that the input jpg file for alpha magic has already
                                 been decoded -> no nedd to decode it again */
                                if( alphaSettings->blendingthreshold == 0 )
                                {
                                    xVSS_context->pSettings->
                                        pTransitionList[i]->
                                        ExtVideoTransitionFct =
                                        M4xVSS_AlphaMagic;
                                }
                                else
                                {
                                    xVSS_context->pSettings->
                                        pTransitionList[i]->
                                        ExtVideoTransitionFct =
                                        M4xVSS_AlphaMagicBlending;
                                }
                                xVSS_context->pSettings->pTransitionList[i]->
                                    pExtVideoTransitionFctCtxt = alphaSettings;
                                break;
                            }
                        }
                    }

                    /* If the jpg has not been decoded yet ... */
                    if( xVSS_context->pSettings->
                        pTransitionList[i]->pExtVideoTransitionFctCtxt
                        == M4OSA_NULL )
                    {
                        M4VIFI_ImagePlane *outputPlane;
                        M4xVSS_internal_AlphaMagicSettings *alphaSettings;
                        /*UTF conversion support*/
                        M4OSA_Void *pDecodedPath = M4OSA_NULL;

                        /*To support ARGB8888 : get the width and height */
                        M4OSA_UInt32 width_ARGB888 =
                            xVSS_context->pSettings->pTransitionList[i]->xVSS.
                            transitionSpecific.pAlphaMagicSettings->width;
                        M4OSA_UInt32 height_ARGB888 =
                            xVSS_context->pSettings->pTransitionList[i]->xVSS.
                            transitionSpecific.pAlphaMagicSettings->height;
                        M4OSA_TRACE1_1(
                            " TransitionListM4xVSS_SendCommand width State is %d",
                            width_ARGB888);
                        M4OSA_TRACE1_1(
                            " TransitionListM4xVSS_SendCommand height! State is %d",
                            height_ARGB888);
                        /* Allocate output plane */
                        outputPlane = (M4VIFI_ImagePlane *)M4OSA_32bitAlignedMalloc(3
                            * sizeof(M4VIFI_ImagePlane), M4VS, (M4OSA_Char
                            *)
                            "Output plane for Alpha magic transition");

                        if( outputPlane == M4OSA_NULL )
                        {
                            M4OSA_TRACE1_0(
                                "Allocation error in M4xVSS_SendCommand");
                            /*FB: to avoid leaks when there is an error in the send command*/
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            /**/
                            return M4ERR_ALLOC;
                        }

                        outputPlane[0].u_width = width;
                        outputPlane[0].u_height = height;
                        outputPlane[0].u_topleft = 0;
                        outputPlane[0].u_stride = width;
                        outputPlane[0].pac_data = (M4VIFI_UInt8
                            *)M4OSA_32bitAlignedMalloc(( width * height * 3)
                            >> 1,
                            M4VS,
                            (M4OSA_Char
                            *)
                            "Alloc for the Alpha magic pac_data output YUV");
                        ;

                        if( outputPlane[0].pac_data == M4OSA_NULL )
                        {
                            free(outputPlane);
                            outputPlane = M4OSA_NULL;
                            M4OSA_TRACE1_0(
                                "Allocation error in M4xVSS_SendCommand");
                            /*FB: to avoid leaks when there is an error in the send command*/
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            /**/
                            return M4ERR_ALLOC;
                        }
                        outputPlane[1].u_width = width >> 1;
                        outputPlane[1].u_height = height >> 1;
                        outputPlane[1].u_topleft = 0;
                        outputPlane[1].u_stride = width >> 1;
                        outputPlane[1].pac_data = outputPlane[0].pac_data
                            + outputPlane[0].u_width * outputPlane[0].u_height;
                        outputPlane[2].u_width = width >> 1;
                        outputPlane[2].u_height = height >> 1;
                        outputPlane[2].u_topleft = 0;
                        outputPlane[2].u_stride = width >> 1;
                        outputPlane[2].pac_data = outputPlane[1].pac_data
                            + outputPlane[1].u_width * outputPlane[1].u_height;

                        pDecodedPath =
                            xVSS_context->pSettings->pTransitionList[i]->xVSS.
                            transitionSpecific.pAlphaMagicSettings->
                            pAlphaFilePath;
                        /**
                        * UTF conversion: convert into the customer format, before being used*/
                        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                            != M4OSA_NULL && xVSS_context->
                            UTFConversionContext.
                            pTempOutConversionBuffer != M4OSA_NULL )
                        {
                            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                                (M4OSA_Void *)xVSS_context->pSettings->
                                pTransitionList[i]->xVSS.
                                transitionSpecific.
                                pAlphaMagicSettings->pAlphaFilePath,
                                (M4OSA_Void *)xVSS_context->
                                UTFConversionContext.
                                pTempOutConversionBuffer, &length);

                            if( err != M4NO_ERROR )
                            {
                                M4OSA_TRACE1_1(
                                    "M4xVSS_SendCommand: pConvFromUTF8Fct returns err: 0x%x",
                                    err);
                                /* Free Send command */
                                M4xVSS_freeCommand(xVSS_context);
                                return err;
                            }
                            pDecodedPath =
                                xVSS_context->UTFConversionContext.
                                pTempOutConversionBuffer;
                        }
                        /**
                        End of the conversion, use the decoded path*/
                        /*To support ARGB8888 : convert + resizing from ARGB8888 to yuv420 */

                        err = M4xVSS_internalConvertAndResizeARGB8888toYUV420(
                            pDecodedPath,
                            xVSS_context->pFileReadPtr, outputPlane,
                            width_ARGB888, height_ARGB888);

                        if( err != M4NO_ERROR )
                        {
                            free(outputPlane[0].pac_data);
                            outputPlane[0].pac_data = M4OSA_NULL;
                            free(outputPlane);
                            outputPlane = M4OSA_NULL;
                            M4xVSS_freeCommand(xVSS_context);
                            M4OSA_TRACE1_1(
                                "M4xVSS_SendCommand: error when decoding alpha magic JPEG: 0x%x",
                                err);
                            return err;
                        }

                        /* Allocate alpha settings structure */
                        alphaSettings =
                            (M4xVSS_internal_AlphaMagicSettings *)M4OSA_32bitAlignedMalloc(
                            sizeof(M4xVSS_internal_AlphaMagicSettings),
                            M4VS, (M4OSA_Char
                            *)"Alpha magic settings structure 2");

                        if( alphaSettings == M4OSA_NULL )
                        {
                            M4OSA_TRACE1_0(
                                "Allocation error in M4xVSS_SendCommand");
                            /*FB: to avoid leaks when there is an error in the send command*/
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            /**/
                            return M4ERR_ALLOC;
                        }
                        alphaSettings->pPlane = outputPlane;

                        if( xVSS_context->pSettings->pTransitionList[i]->xVSS.
                            transitionSpecific.pAlphaMagicSettings->
                            blendingPercent > 0 && xVSS_context->pSettings->
                            pTransitionList[i]->xVSS.
                            transitionSpecific.pAlphaMagicSettings->
                            blendingPercent <= 100 )
                        {
                            alphaSettings->blendingthreshold =
                                ( xVSS_context->pSettings->
                                pTransitionList[i]->xVSS.
                                transitionSpecific.pAlphaMagicSettings->
                                blendingPercent) * 255 / 200;
                        }
                        else
                        {
                            alphaSettings->blendingthreshold = 0;
                        }
                        alphaSettings->isreverse =
                            xVSS_context->pSettings->pTransitionList[i]->xVSS.
                            transitionSpecific.pAlphaMagicSettings->
                            isreverse;

                        if( alphaSettings->blendingthreshold == 0 )
                        {
                            xVSS_context->pSettings->pTransitionList[i]->
                                ExtVideoTransitionFct = M4xVSS_AlphaMagic;
                        }
                        else
                        {
                            xVSS_context->pSettings->pTransitionList[i]->
                                ExtVideoTransitionFct =
                                M4xVSS_AlphaMagicBlending;
                        }
                        xVSS_context->pSettings->pTransitionList[i]->
                            pExtVideoTransitionFctCtxt = alphaSettings;
                    }

                    break;

                case M4xVSS_kVideoTransitionType_SlideTransition:
                    {
                        M4xVSS_internal_SlideTransitionSettings *slideSettings;
                        slideSettings =
                            (M4xVSS_internal_SlideTransitionSettings *)M4OSA_32bitAlignedMalloc(
                            sizeof(M4xVSS_internal_SlideTransitionSettings),
                            M4VS, (M4OSA_Char
                            *)"Internal slide transition settings");

                        if( M4OSA_NULL == slideSettings )
                        {
                            M4OSA_TRACE1_0(
                                "Allocation error in M4xVSS_SendCommand");
                            /*FB: to avoid leaks when there is an error in the send command*/
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            /**/
                            return M4ERR_ALLOC;
                        }
                        /* Just copy the lone parameter from the input settings to the internal
                         context. */

                        slideSettings->direction =
                            pSettings->pTransitionList[i]->xVSS.transitionSpecific.
                            pSlideTransitionSettings->direction;

                        /* No need to keep our copy of the settings. */
                        xVSS_context->pSettings->pTransitionList[i]->
                            xVSS.transitionSpecific.pSlideTransitionSettings =
                            M4OSA_NULL;
                        xVSS_context->pSettings->pTransitionList[i]->
                            ExtVideoTransitionFct = &M4xVSS_SlideTransition;
                        xVSS_context->pSettings->pTransitionList[i]->
                            pExtVideoTransitionFctCtxt = slideSettings;
                    }
                    break;

                case M4xVSS_kVideoTransitionType_FadeBlack:
                    {
                        xVSS_context->pSettings->pTransitionList[i]->
                            ExtVideoTransitionFct = &M4xVSS_FadeBlackTransition;
                    }
                    break;

                case M4xVSS_kVideoTransitionType_External:
                    {
                        xVSS_context->pSettings->pTransitionList[i]->
                            ExtVideoTransitionFct =
                            pSettings->pTransitionList[i]->ExtVideoTransitionFct;
                        xVSS_context->pSettings->pTransitionList[i]->
                            pExtVideoTransitionFctCtxt =
                            pSettings->pTransitionList[i]->
                            pExtVideoTransitionFctCtxt;
                        xVSS_context->pSettings->pTransitionList[i]->
                            VideoTransitionType =
                            M4VSS3GPP_kVideoTransitionType_External;
                    }
                    break;

                default:
                    break;
                } // switch

            /* Update total_duration with transition duration */
            totalDuration -= xVSS_context->pSettings->
                pTransitionList[i]->uiTransitionDuration;
        }


        if( xVSS_context->pSettings->pClipList[i]->FileType
            == M4VIDEOEDITING_kFileType_ARGB8888 )
        {
            if(M4OSA_TRUE ==
                   xVSS_context->pSettings->pClipList[i]->xVSS.isPanZoom) {
                M4OSA_Char out_img[M4XVSS_MAX_PATH_LEN];
                M4OSA_Char out_img_tmp[M4XVSS_MAX_PATH_LEN];
                M4xVSS_Pto3GPP_params *pParams = M4OSA_NULL;
                M4OSA_Context pARGBFileIn;
                /*UTF conversion support*/
                M4OSA_Void *pDecodedPath = pSettings->pClipList[i]->pFile;

                /* Parse Pto3GPP params chained list to know if input file has already been
                converted */
                if( xVSS_context->pPTo3GPPparamsList != M4OSA_NULL )
                {
                    M4OSA_UInt32 pCmpResult = 0;

                    pParams = xVSS_context->pPTo3GPPparamsList;
                    /* We parse all Pto3gpp Param chained list */
                    while( pParams != M4OSA_NULL )
                    {
                        pCmpResult = strcmp((const char *)pSettings->pClipList[i]->pFile,
                            (const char *)pParams->pFileIn);

                        if( pCmpResult == 0
                            && (pSettings->pClipList[i]->uiEndCutTime
                            == pParams->duration
                            || pSettings->pClipList[i]->xVSS.uiDuration
                            == pParams->duration)
                            && pSettings->pClipList[i]->xVSS.MediaRendering
                            == pParams->MediaRendering )



                        {
                            /* Replace JPG filename with existing 3GP filename */
                            goto replaceARGB_3GP;
                        }
                        /* We need to update this variable, in case some pictures have been
                         added between two */
                        /* calls to M4xVSS_sendCommand */
                        pPto3GPP_last = pParams;
                        pParams = pParams->pNext;
                    }
                }

                /* Construct output temporary 3GP filename */
                err = M4OSA_chrSPrintf(out_img, M4XVSS_MAX_PATH_LEN - 1, (M4OSA_Char *)"%simg%d.3gp",
                    xVSS_context->pTempPath, xVSS_context->tempFileIndex);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1("Error in M4OSA_chrSPrintf: 0x%x", err);
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return err;
                }

    #ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE

                err = M4OSA_chrSPrintf(out_img_tmp, M4XVSS_MAX_PATH_LEN - 1, "%simg%d.tmp",
                    xVSS_context->pTempPath, xVSS_context->tempFileIndex);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1("Error in M4OSA_chrSPrintf: 0x%x", err);
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return err;
                }

    #endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/

                xVSS_context->tempFileIndex++;

                /* Allocate last element Pto3GPP params structure */
                pParams = (M4xVSS_Pto3GPP_params
                    *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_Pto3GPP_params),
                    M4VS, (M4OSA_Char *)"Element of Pto3GPP Params");

                if( pParams == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0(
                        "M4xVSS_sendCommand: Problem when allocating one element Pto3GPP Params");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }

                /* Initializes pfilexxx members of pParams to be able to free them correctly */
                pParams->pFileIn = M4OSA_NULL;
                pParams->pFileOut = M4OSA_NULL;
                pParams->pFileTemp = M4OSA_NULL;
                pParams->pNext = M4OSA_NULL;
                pParams->MediaRendering = M4xVSS_kResizing;

                /*To support ARGB8888 :get the width and height */
                pParams->height = pSettings->pClipList[
                    i]->ClipProperties.uiStillPicHeight; //ARGB_Height;
                    pParams->width = pSettings->pClipList[
                        i]->ClipProperties.uiStillPicWidth; //ARGB_Width;
                        M4OSA_TRACE3_1("CLIP M4xVSS_SendCommand ARGB8888 H = %d", pParams->height);
                        M4OSA_TRACE3_1("CLIP M4xVSS_SendCommand ARGB8888 W = %d", pParams->width);

                        if( xVSS_context->pPTo3GPPparamsList
                            == M4OSA_NULL ) /* Means it is the first element of the list */
                        {
                            /* Initialize the xVSS context with the first element of the list */
                            xVSS_context->pPTo3GPPparamsList = pParams;

                            /* Save this element in case of other file to convert */
                            pPto3GPP_last = pParams;
                        }
                        else
                        {
                            /* Update next pointer of the previous last element of the chain */
                            pPto3GPP_last->pNext = pParams;

                            /* Update save of last element of the chain */
                            pPto3GPP_last = pParams;
                        }

                        /* Fill the last M4xVSS_Pto3GPP_params element */
                        pParams->duration =
                            xVSS_context->pSettings->pClipList[i]->uiEndCutTime;
                        /* If duration is filled, let's use it instead of EndCutTime */
                        if( xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration != 0 )
                        {
                            pParams->duration =
                                xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration;
                        }

                        pParams->InputFileType = M4VIDEOEDITING_kFileType_ARGB8888;

                        /**
                        * UTF conversion: convert into the customer format, before being used*/
                        pDecodedPath = xVSS_context->pSettings->pClipList[i]->pFile;
                        length = strlen(pDecodedPath);

                        /**
                        * UTF conversion: convert into the customer format, before being used*/
                        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                            != M4OSA_NULL && xVSS_context->
                            UTFConversionContext.pTempOutConversionBuffer
                            != M4OSA_NULL )
                        {
                            err = M4xVSS_internalConvertFromUTF8(xVSS_context, (M4OSA_Void
                                *)xVSS_context->pSettings->pClipList[i]->pFile,
                                (M4OSA_Void *)xVSS_context->
                                UTFConversionContext.pTempOutConversionBuffer,
                                &length);

                            if( err != M4NO_ERROR )
                            {
                                M4OSA_TRACE1_1(
                                    "M4xVSS_SendCommand: pConvFromUTF8Fct returns err: 0x%x",
                                    err);
                                /* Free Send command */
                                M4xVSS_freeCommand(xVSS_context);
                                return err;
                            }
                            pDecodedPath =
                                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
                        }

                        /**
                        * End of the UTF conversion, use the converted file path*/
                        pParams->pFileIn = (M4OSA_Void *)M4OSA_32bitAlignedMalloc(length + 1, M4VS,
                            (M4OSA_Char *)"Pto3GPP Params: file in");

                        if( pParams->pFileIn == M4OSA_NULL )
                        {
                            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                            /*FB: to avoid leaks when there is an error in the send command*/
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            /**/
                            return M4ERR_ALLOC;
                        }
                        memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
                            (length + 1)); /* Copy input file path */

                        /* Check that JPG file is present on the FS (P4ME00002974) by just opening
                         and closing it */
                        err =
                            xVSS_context->pFileReadPtr->openRead(&pARGBFileIn, pDecodedPath,
                            M4OSA_kFileRead);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_2("Can't open input jpg file %s, error: 0x%x\n",
                                pDecodedPath, err);
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            return err;
                        }
                        err = xVSS_context->pFileReadPtr->closeRead(pARGBFileIn);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_2("Can't close input jpg file %s, error: 0x%x\n",
                                pDecodedPath, err);
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            return err;
                        }

                        /**
                        * UTF conversion: convert into the customer format, before being used*/
                        pDecodedPath = out_img;
                        length = strlen(pDecodedPath);

                        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                            != M4OSA_NULL && xVSS_context->
                            UTFConversionContext.pTempOutConversionBuffer
                            != M4OSA_NULL )
                        {
                            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                                (M4OSA_Void *)out_img, (M4OSA_Void *)xVSS_context->
                                UTFConversionContext.pTempOutConversionBuffer, &length);

                            if( err != M4NO_ERROR )
                            {
                                M4OSA_TRACE1_1(
                                    "M4xVSS_SendCommand: pConvFromUTF8Fct returns err: 0x%x",
                                    err);
                                /* Free Send command */
                                M4xVSS_freeCommand(xVSS_context);
                                return err;
                            }
                            pDecodedPath =
                                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
                        }

                        /**
                        * End of the UTF conversion, use the converted file path*/
                        pParams->pFileOut = (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
                            (M4OSA_Char *)"Pto3GPP Params: file out");

                        if( pParams->pFileOut == M4OSA_NULL )
                        {
                            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                            /*FB: to avoid leaks when there is an error in the send command*/
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            /**/
                            return M4ERR_ALLOC;
                        }
                        memcpy((void *)pParams->pFileOut, (void *)pDecodedPath,
                            (length + 1)); /* Copy output file path */

    #ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
                        /**
                        * UTF conversion: convert into the customer format, before being used*/

                        pDecodedPath = out_img_tmp;
                        length = strlen(pDecodedPath);

                        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                            != M4OSA_NULL && xVSS_context->
                            UTFConversionContext.pTempOutConversionBuffer
                            != M4OSA_NULL )
                        {
                            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                                (M4OSA_Void *)out_img_tmp, (M4OSA_Void *)xVSS_context->
                                UTFConversionContext.pTempOutConversionBuffer, &length);

                            if( err != M4NO_ERROR )
                            {
                                M4OSA_TRACE1_1("M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8\
                                     returns err: 0x%x",
                                    err);
                                /* Free Send command */
                                M4xVSS_freeCommand(xVSS_context);
                                return err;
                            }
                            pDecodedPath =
                                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
                        }

                        /**
                        * End of the UTF conversion, use the converted file path*/
                        pParams->pFileTemp = (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
                            (M4OSA_Char *)"Pto3GPP Params: file temp");

                        if( pParams->pFileTemp == M4OSA_NULL )
                        {
                            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                            /*FB: to avoid leaks when there is an error in the send command*/
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            /**/
                            return M4ERR_ALLOC;
                        }
                        memcpy((void *)pParams->pFileTemp, (void *)pDecodedPath,
                            (length + 1)); /* Copy temporary file path */

    #endif                         /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/

                        /* Fill PanAndZoom settings if needed */

                        if( M4OSA_TRUE
                            == xVSS_context->pSettings->pClipList[i]->xVSS.isPanZoom )
                        {
                            pParams->isPanZoom =
                                xVSS_context->pSettings->pClipList[i]->xVSS.isPanZoom;
                            /* Check that Pan & Zoom parameters are corrects */
                            if( xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa > 1000
                                || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa
                                <= 0 || xVSS_context->pSettings->pClipList[i]->xVSS.
                                PanZoomTopleftXa > 1000
                                || xVSS_context->pSettings->pClipList[i]->xVSS.
                                PanZoomTopleftYa > 1000
                                || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb
                                > 1000
                                || xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb
                                <= 0 || xVSS_context->pSettings->pClipList[i]->xVSS.
                                PanZoomTopleftXb > 1000
                                || xVSS_context->pSettings->pClipList[i]->xVSS.
                                PanZoomTopleftYb > 1000)
                            {
                                M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                                M4xVSS_freeCommand(xVSS_context);
                                return M4ERR_PARAMETER;
                            }

                            pParams->PanZoomXa =
                                xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXa;
                            pParams->PanZoomTopleftXa =
                                xVSS_context->pSettings->
                                pClipList[i]->xVSS.PanZoomTopleftXa;
                            pParams->PanZoomTopleftYa =
                                xVSS_context->pSettings->
                                pClipList[i]->xVSS.PanZoomTopleftYa;
                            pParams->PanZoomXb =
                                xVSS_context->pSettings->pClipList[i]->xVSS.PanZoomXb;
                            pParams->PanZoomTopleftXb =
                                xVSS_context->pSettings->
                                pClipList[i]->xVSS.PanZoomTopleftXb;
                            pParams->PanZoomTopleftYb =
                                xVSS_context->pSettings->
                                pClipList[i]->xVSS.PanZoomTopleftYb;
                        }
                        else
                        {
                            pParams->isPanZoom = M4OSA_FALSE;
                        }
                        /*+ PR No: blrnxpsw#223*/
                        /*Intializing the Video Frame Rate as it may not be intialized*/
                        /*Other changes made is @ M4xVSS_Internal.c @ line 1518 in
                        M4xVSS_internalStartConvertPictureTo3gp*/
                        switch( xVSS_context->pSettings->videoFrameRate )
                        {
                            case M4VIDEOEDITING_k30_FPS:
                                pParams->framerate = 33;
                                break;

                            case M4VIDEOEDITING_k25_FPS:
                                pParams->framerate = 40;
                                break;

                            case M4VIDEOEDITING_k20_FPS:
                                pParams->framerate = 50;
                                break;

                            case M4VIDEOEDITING_k15_FPS:
                                pParams->framerate = 66;
                                break;

                            case M4VIDEOEDITING_k12_5_FPS:
                                pParams->framerate = 80;
                                break;

                            case M4VIDEOEDITING_k10_FPS:
                                pParams->framerate = 100;
                                break;

                            case M4VIDEOEDITING_k7_5_FPS:
                                pParams->framerate = 133;
                                break;

                            case M4VIDEOEDITING_k5_FPS:
                                pParams->framerate = 200;
                                break;

                            default:
                                /*Making Default Frame Rate @ 15 FPS*/
                                pParams->framerate = 66;
                                break;
                        }
                        /*-PR No: blrnxpsw#223*/
                        if( xVSS_context->pSettings->pClipList[i]->xVSS.MediaRendering
                            == M4xVSS_kCropping
                            || xVSS_context->pSettings->pClipList[i]->xVSS.
                            MediaRendering == M4xVSS_kBlackBorders
                            || xVSS_context->pSettings->pClipList[i]->xVSS.
                            MediaRendering == M4xVSS_kResizing )
                        {
                            pParams->MediaRendering =
                                xVSS_context->pSettings->pClipList[i]->xVSS.MediaRendering;
                        }

                        pParams->pNext = M4OSA_NULL;
                        pParams->isCreated = M4OSA_FALSE;
                        xVSS_context->nbStepTotal++;
                       /* Set bTranscodingRequired to TRUE to indicate the kenburn video has
                        * been generated in analysis phase, and does not need to be tanscoded again
                        * in saving phase */
                        xVSS_context->pSettings->pClipList[i]->bTranscodingRequired =
                           M4OSA_TRUE;

    replaceARGB_3GP:
                        /* Update total duration */
                        totalDuration += pParams->duration;

                        /* Replacing in VSS structure the JPG file by the 3gp file */
                        xVSS_context->pSettings->pClipList[i]->FileType =
                            M4VIDEOEDITING_kFileType_3GPP;

                        if( xVSS_context->pSettings->pClipList[i]->pFile != M4OSA_NULL )
                        {
                            free(xVSS_context->pSettings->pClipList[i]->pFile);
                            xVSS_context->pSettings->pClipList[i]->pFile = M4OSA_NULL;
                        }

                        /**
                        * UTF conversion: convert into UTF8, before being used*/
                        pDecodedPath = pParams->pFileOut;

                        if( xVSS_context->UTFConversionContext.pConvToUTF8Fct != M4OSA_NULL
                            && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
                            != M4OSA_NULL )
                        {
                            err = M4xVSS_internalConvertToUTF8(xVSS_context,
                                (M4OSA_Void *)pParams->pFileOut,
                                (M4OSA_Void *)xVSS_context->
                                UTFConversionContext.pTempOutConversionBuffer,
                                &length);

                            if( err != M4NO_ERROR )
                            {
                                M4OSA_TRACE1_1(
                                    "M4xVSS_SendCommand: M4xVSS_internalConvertToUTF8 returns err: \
                                    0x%x",err);
                                /* Free Send command */
                                M4xVSS_freeCommand(xVSS_context);
                                return err;
                            }
                            pDecodedPath =
                                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
                        }
                        else
                        {
                            length = strlen(pDecodedPath);
                        }
                        /**
                        * End of the UTF conversion, use the converted file path*/
                        xVSS_context->pSettings->pClipList[i]->pFile = M4OSA_32bitAlignedMalloc((length
                            + 1), M4VS, (M4OSA_Char *)"xVSS file path of ARGB to 3gp");

                        if( xVSS_context->pSettings->pClipList[i]->pFile == M4OSA_NULL )
                        {
                            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                            /*FB: to avoid leaks when there is an error in the send command*/
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            /**/
                            return M4ERR_ALLOC;
                        }
                        memcpy((void *)xVSS_context->pSettings->pClipList[i]->pFile,
                            (void *)pDecodedPath, (length + 1));
                        /*FB: add file path size because of UTF16 conversion*/
                        xVSS_context->pSettings->pClipList[i]->filePathSize = length+1;
            }
        }
        /************************
        3GP input file type case
        *************************/
        else if( xVSS_context->pSettings->pClipList[i]->FileType
            == M4VIDEOEDITING_kFileType_3GPP
            || xVSS_context->pSettings->pClipList[i]->FileType
            == M4VIDEOEDITING_kFileType_MP4
            || xVSS_context->pSettings->pClipList[i]->FileType
            == M4VIDEOEDITING_kFileType_M4V )
        {
            /*UTF conversion support*/
            M4OSA_Void *pDecodedPath = M4OSA_NULL;

            /* Need to call MCS in case 3GP video/audio types are not compatible
            (H263/MPEG4 or AMRNB/AAC) */
            /* => Need to fill MCS_Params structure with the right parameters ! */
            /* Need also to parse MCS params struct to check if file has already been transcoded */

            M4VIDEOEDITING_ClipProperties fileProperties;
            M4xVSS_MCS_params *pParams;
            M4OSA_Bool audioIsDifferent = M4OSA_FALSE;
            M4OSA_Bool videoIsDifferent = M4OSA_FALSE;
            M4OSA_Bool bAudioMono;
            /* Initialize file properties structure */

            memset((void *) &fileProperties,0,
                sizeof(M4VIDEOEDITING_ClipProperties));

            //fileProperties.AudioStreamType = M4VIDEOEDITING_kNoneAudio;

            /* Prevent from bad initializing of percentage cut time */
            if( xVSS_context->pSettings->pClipList[i]->xVSS.uiEndCutPercent
                            > 100 || xVSS_context->pSettings->pClipList[i]->xVSS.
                            uiBeginCutPercent > 100 )
            {
                /* These percentage cut time have probably not been initialized */
                /* Let's not use them by setting them to 0 */
                xVSS_context->pSettings->pClipList[i]->xVSS.uiEndCutPercent = 0;
                xVSS_context->pSettings->pClipList[i]->xVSS.uiBeginCutPercent =
                    0;
            }

            /**
            * UTF conversion: convert into the customer format, before being used*/
            pDecodedPath = xVSS_context->pSettings->pClipList[i]->pFile;

            if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                != M4OSA_NULL && xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer
                != M4OSA_NULL )
            {
                err = M4xVSS_internalConvertFromUTF8(xVSS_context, (M4OSA_Void
                    *)xVSS_context->pSettings->pClipList[i]->pFile,
                    (M4OSA_Void *)xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer,
                    &length);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1(
                        "M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                        err);
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    return err;
                }
                pDecodedPath =
                    xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
            }
            /**
            * End of the UTF conversion, use the converted file path*/
            err = M4xVSS_internalGetProperties(xVSS_context, pDecodedPath,
                &fileProperties);

            if( err != M4NO_ERROR )
            {
                M4xVSS_freeCommand(xVSS_context);
                M4OSA_TRACE1_1(
                    "M4xVSS_sendCommand: M4xVSS_internalGetProperties returned 0x%x",
                    err);
                /* TODO: Translate error code of MCS to an xVSS error code */
                return err;
            }

            /* Parse MCS params chained list to know if input file has already been converted */
            if( xVSS_context->pMCSparamsList != M4OSA_NULL )
            {
                M4OSA_UInt32 pCmpResult = 0;

                pParams = xVSS_context->pMCSparamsList;
                /* We parse all MCS Param chained list */
                while( pParams != M4OSA_NULL )
                {

                    /**
                    * UTF conversion: convert into UTF8, before being used*/
                    pDecodedPath = pParams->pFileIn;

                    if( xVSS_context->UTFConversionContext.pConvToUTF8Fct
                        != M4OSA_NULL && xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer
                        != M4OSA_NULL )
                    {
                        err = M4xVSS_internalConvertToUTF8(xVSS_context,
                            (M4OSA_Void *)pParams->pFileIn,
                            (M4OSA_Void *)xVSS_context->
                            UTFConversionContext.
                            pTempOutConversionBuffer, &length);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_1(
                                "M4xVSS_SendCommand: M4xVSS_internalConvertToUTF8 returns err:\
                                 0x%x", err);
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            return err;
                        }
                        pDecodedPath = xVSS_context->
                            UTFConversionContext.pTempOutConversionBuffer;
                    }

                    /**
                    * End of the UTF conversion, use the converted file path*/
                    pCmpResult = strcmp((const char *)pSettings->pClipList[i]->pFile,
                        (const char *)pDecodedPath);

                    /* If input filenames are the same, and if this is not a BGM, we can reuse
                    the transcoded file */
                    if( pCmpResult == 0 && pParams->isBGM == M4OSA_FALSE
                        && pParams->BeginCutTime
                        == pSettings->pClipList[i]->uiBeginCutTime
                        && (pParams->EndCutTime
                        == pSettings->pClipList[i]->uiEndCutTime
                        || pParams->EndCutTime
                        == pSettings->pClipList[i]->uiBeginCutTime
                        + pSettings->pClipList[i]->xVSS.uiDuration)
                        && pSettings->pClipList[i]->xVSS.MediaRendering
                        == pParams->MediaRendering )
                    {
                        if( pSettings->xVSS.pBGMtrack != M4OSA_NULL )
                        {
                            if( pSettings->xVSS.pBGMtrack->uiAddVolume == 100
                                || (pParams->OutputAudioFormat
                                == M4VIDEOEDITING_kNullAudio
                                && fileProperties.AudioStreamType
                                == pSettings->xVSS.outputAudioFormat)
                                || pParams->OutputAudioFormat
                                == pSettings->xVSS.outputAudioFormat
                                || fileProperties.AudioStreamType
                                == M4VIDEOEDITING_kNoneAudio )
                            {
                                /* Replace 3GP filename with transcoded 3GP filename */
                                goto replace3GP_3GP;
                            }
                        }
                        else if( ( pParams->OutputAudioFormat
                            == M4VIDEOEDITING_kNullAudio
                            && fileProperties.AudioStreamType
                            == pSettings->xVSS.outputAudioFormat)
                            || pParams->OutputAudioFormat
                            == pSettings->xVSS.outputAudioFormat
                            || fileProperties.AudioStreamType
                            == M4VIDEOEDITING_kNoneAudio )
                        {
                            /* Replace 3GP filename with transcoded 3GP filename */
                            goto replace3GP_3GP;
                        }
                    }

                    /* We need to update this variable, in case some 3GP files have been added
                    between two */
                    /* calls to M4xVSS_sendCommand */
                    pMCS_last = pParams;
                    pParams = pParams->pNext;
                }
            }

            /* If we have percentage information let's use it... */
            if( xVSS_context->pSettings->pClipList[i]->xVSS.uiEndCutPercent != 0
                || xVSS_context->pSettings->pClipList[i]->xVSS.uiBeginCutPercent
                != 0 )
            {
                /* If percentage information are not correct and if duration field is not filled */
                if( ( xVSS_context->pSettings->pClipList[i]->xVSS.
                    uiEndCutPercent
                    <= xVSS_context->pSettings->pClipList[i]->xVSS.
                    uiBeginCutPercent)
                    && xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration
                    == 0 )
                {
                    M4OSA_TRACE1_0(
                        "M4xVSS_sendCommand: Bad percentage for begin and end cut time !");
                    M4xVSS_freeCommand(xVSS_context);
                    return M4ERR_PARAMETER;
                }

                /* We transform the percentage into absolute time */
                xVSS_context->pSettings->pClipList[i]->uiBeginCutTime
                    = (M4OSA_UInt32)(
                    xVSS_context->pSettings->pClipList[i]->xVSS.
                    uiBeginCutPercent
                    * fileProperties.uiClipDuration / 100);
                xVSS_context->pSettings->pClipList[i]->uiEndCutTime
                    = (M4OSA_UInt32)(
                    xVSS_context->pSettings->pClipList[i]->xVSS.
                    uiEndCutPercent
                    * fileProperties.uiClipDuration / 100);
            }
            /* ...Otherwise, we use absolute time. */
            else
            {
                /* If endCutTime == 0, it means all the file is taken. Let's change to the file
                duration, to accurate preview. */
                if( xVSS_context->pSettings->pClipList[i]->uiEndCutTime == 0
                    || xVSS_context->pSettings->pClipList[i]->uiEndCutTime
                    > fileProperties.uiClipDuration )
                {
                    xVSS_context->pSettings->pClipList[i]->uiEndCutTime =
                        fileProperties.uiClipDuration;
                }
            }

            /* If duration field is filled, it has priority on other fields on EndCutTime,
             so let's use it */
            if( xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration != 0 )
            {
                xVSS_context->pSettings->pClipList[i]->uiEndCutTime =
                    xVSS_context->pSettings->pClipList[i]->uiBeginCutTime
                    +xVSS_context->pSettings->pClipList[i]->xVSS.uiDuration;

                if( xVSS_context->pSettings->pClipList[i]->uiEndCutTime
                    > fileProperties.uiClipDuration )
                {
                    xVSS_context->pSettings->pClipList[i]->uiEndCutTime =
                        fileProperties.uiClipDuration;
                }
            }

            /* If output video format is not set, we take video format of the first 3GP video */
            if( xVSS_context->pSettings->xVSS.outputVideoFormat
                == M4VIDEOEDITING_kNoneVideo )
            {
                //xVSS_context->pSettings->xVSS.outputVideoFormat = fileProperties.VideoStreamType;
                //M4OSA_TRACE2_1("Output video format is not set, set it to current clip: %d",
                // xVSS_context->pSettings->xVSS.outputVideoFormat);
                M4OSA_TRACE1_0(
                    "Output video format is not set, an error parameter is returned.");
                M4xVSS_freeCommand(xVSS_context);
                return M4ERR_PARAMETER;
            }

            if( xVSS_context->pSettings->xVSS.outputAudioFormat
                == M4VIDEOEDITING_kNoneAudio )
            {
                //xVSS_context->pSettings->xVSS.outputAudioFormat = fileProperties.AudioStreamType;
                M4OSA_TRACE2_1(
                    "Output audio format is not set -> remove audio track of clip: %d",
                    i);
            }

            if( fileProperties.uiNbChannels == 1 )
            {
                bAudioMono = M4OSA_TRUE;
            }
            else
            {
                bAudioMono = M4OSA_FALSE;
            }

            if( fileProperties.AudioStreamType
                != xVSS_context->pSettings->xVSS.outputAudioFormat
                || (fileProperties.AudioStreamType == M4VIDEOEDITING_kAAC
                && (fileProperties.uiSamplingFrequency != samplingFreq
                || bAudioMono
                != xVSS_context->pSettings->xVSS.bAudioMono)) )
            {
                audioIsDifferent = M4OSA_TRUE;
                /* If we want to replace audio, there is no need to transcode audio */
                if( pSettings->xVSS.pBGMtrack != M4OSA_NULL )
                {
                    /* temp fix :PT volume not herad in the second clip */
                    if( /*(pSettings->xVSS.pBGMtrack->uiAddVolume == 100
                        && xVSS_context->pSettings->xVSS.outputFileSize == 0)
                        ||*/
                        fileProperties.AudioStreamType
                        == M4VIDEOEDITING_kNoneAudio ) /*11/12/2008 CR 3283 VAL for the MMS
                        use case, we need to transcode except the media without audio*/
                    {
                        audioIsDifferent = M4OSA_FALSE;
                    }
                }
                else if( fileProperties.AudioStreamType
                    == M4VIDEOEDITING_kNoneAudio )
                {
                    audioIsDifferent = M4OSA_FALSE;
                }
            }
            /* Here check the clip video profile and level, if it exceeds
             * the profile and level of export file, then the file needs
             * to be transcoded(do not do compress domain trim).
             * Also for MPEG4 fomart, always do transcoding since HW encoder
             * may use different time scale value than the input clip*/
           if ((fileProperties.uiVideoProfile >
                     xVSS_context->pSettings->xVSS.outputVideoProfile) ||
                (fileProperties.uiVideoLevel >
                     xVSS_context->pSettings->xVSS.outputVideoLevel) ||
                (fileProperties.VideoStreamType == M4VIDEOEDITING_kMPEG4)) {
               /* Set bTranscodingRequired to TRUE to indicate the video will be
                * transcoded in MCS. */
               xVSS_context->pSettings->pClipList[i]->bTranscodingRequired =
                   M4OSA_TRUE;
               videoIsDifferent = M4OSA_TRUE;
           }

            if( videoIsDifferent == M4OSA_TRUE || audioIsDifferent == M4OSA_TRUE)
            {
                M4OSA_Char out_3gp[M4XVSS_MAX_PATH_LEN];
                M4OSA_Char out_3gp_tmp[M4XVSS_MAX_PATH_LEN];

                /* Construct output temporary 3GP filename */
                err = M4OSA_chrSPrintf(out_3gp, M4XVSS_MAX_PATH_LEN - 1, (M4OSA_Char *)"%svid%d.3gp",
                    xVSS_context->pTempPath, xVSS_context->tempFileIndex);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1("Error in M4OSA_chrSPrintf: 0x%x", err);
                    return err;
                }

#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE

                err = M4OSA_chrSPrintf(out_3gp_tmp, M4XVSS_MAX_PATH_LEN - 1, "%svid%d.tmp",
                    xVSS_context->pTempPath, xVSS_context->tempFileIndex);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1("Error in M4OSA_chrSPrintf: 0x%x", err);
                    return err;
                }

#endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/

                xVSS_context->tempFileIndex++;

                pParams =
                    (M4xVSS_MCS_params *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_MCS_params),
                    M4VS, (M4OSA_Char *)"Element of MCS Params (for 3GP)");

                if( pParams == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0(
                        "M4xVSS_sendCommand: Problem when allocating one element MCS Params");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }
                pParams->MediaRendering = M4xVSS_kResizing;
                pParams->videoclipnumber = i; // Indicates video clip index

                if( xVSS_context->pMCSparamsList
                    == M4OSA_NULL ) /* Means it is the first element of the list */
                {
                    /* Initialize the xVSS context with the first element of the list */
                    xVSS_context->pMCSparamsList = pParams;
                }
                else
                {
                    /* Update next pointer of the previous last element of the chain */
                    pMCS_last->pNext = pParams;
                }

                /* Save this element in case of other file to convert */
                pMCS_last = pParams;

                /* Fill the last M4xVSS_MCS_params element */
                pParams->InputFileType = M4VIDEOEDITING_kFileType_3GPP;
                pParams->OutputFileType = M4VIDEOEDITING_kFileType_3GPP;

                pParams->OutputVideoTimescale = xVSS_context->targetedTimescale;

                /* We do not need to reencode video if its parameters do not differ */
                /* from output settings parameters */
                if( videoIsDifferent == M4OSA_TRUE )
                {
                    pParams->OutputVideoFormat =
                        xVSS_context->pSettings->xVSS.outputVideoFormat;
                    pParams->outputVideoProfile =
                        xVSS_context->pSettings->xVSS.outputVideoProfile;
                    pParams->outputVideoLevel =
                        xVSS_context->pSettings->xVSS.outputVideoLevel;
                    pParams->OutputVideoFrameRate =
                        xVSS_context->pSettings->videoFrameRate;
                    pParams->OutputVideoFrameSize =
                        xVSS_context->pSettings->xVSS.outputVideoSize;

                    /*FB: VAL CR P4ME00003076
                    The output video bitrate is now directly given by the user in the edition
                    settings structure If the bitrate given by the user is irrelevant
                    (the MCS minimum and maximum video bitrate are used),
                    the output video bitrate is hardcoded according to the output video size*/
                    if( xVSS_context->pSettings->xVSS.outputVideoBitrate
                        >= M4VIDEOEDITING_k16_KBPS
                        && xVSS_context->pSettings->xVSS.outputVideoBitrate
                        <= M4VIDEOEDITING_k8_MBPS ) /*+ New Encoder bitrates */
                    {
                        pParams->OutputVideoBitrate =
                            xVSS_context->pSettings->xVSS.outputVideoBitrate;
                    }
                    else
                    {
                        switch( xVSS_context->pSettings->xVSS.outputVideoSize )
                        {
                            case M4VIDEOEDITING_kSQCIF:
                                pParams->OutputVideoBitrate =
                                    M4VIDEOEDITING_k48_KBPS;
                                break;

                            case M4VIDEOEDITING_kQQVGA:
                                pParams->OutputVideoBitrate =
                                    M4VIDEOEDITING_k64_KBPS;
                                break;

                            case M4VIDEOEDITING_kQCIF:
                                pParams->OutputVideoBitrate =
                                    M4VIDEOEDITING_k128_KBPS;
                                break;

                            case M4VIDEOEDITING_kQVGA:
                                pParams->OutputVideoBitrate =
                                    M4VIDEOEDITING_k384_KBPS;
                                break;

                            case M4VIDEOEDITING_kCIF:
                                pParams->OutputVideoBitrate =
                                    M4VIDEOEDITING_k384_KBPS;
                                break;

                            case M4VIDEOEDITING_kVGA:
                                pParams->OutputVideoBitrate =
                                    M4VIDEOEDITING_k512_KBPS;
                                break;

                            default: /* Should not happen !! */
                                pParams->OutputVideoBitrate =
                                    M4VIDEOEDITING_k64_KBPS;
                                break;
                        }
                    }
                }
                else
                {
                    pParams->outputVideoProfile =
                        xVSS_context->pSettings->xVSS.outputVideoProfile;
                    pParams->outputVideoLevel =
                        xVSS_context->pSettings->xVSS.outputVideoLevel;
                    pParams->OutputVideoFormat = M4VIDEOEDITING_kNullVideo;
                    pParams->OutputVideoFrameRate =
                        M4VIDEOEDITING_k15_FPS; /* Must be set, otherwise, MCS returns an error */
                }

                if( audioIsDifferent == M4OSA_TRUE )
                {
                    pParams->OutputAudioFormat =
                        xVSS_context->pSettings->xVSS.outputAudioFormat;

                    switch( xVSS_context->pSettings->xVSS.outputAudioFormat )
                    {
                        case M4VIDEOEDITING_kNoneAudio:
                            break;

                        case M4VIDEOEDITING_kAMR_NB:
                            pParams->OutputAudioBitrate =
                                M4VIDEOEDITING_k12_2_KBPS;
                            pParams->bAudioMono = M4OSA_TRUE;
                            pParams->OutputAudioSamplingFrequency =
                                M4VIDEOEDITING_kDefault_ASF;
                            break;

                        case M4VIDEOEDITING_kAAC:
                            {
                                /*FB: VAL CR P4ME00003076
                                The output audio bitrate in the AAC case is now directly given by
                                the user in the edition settings structure
                                If the bitrate given by the user is irrelevant or undefined
                                (the MCS minimum and maximum audio bitrate are used),
                                the output audio bitrate is hard coded according to the output
                                audio sampling frequency*/

                                /*Check if the audio bitrate is correctly defined*/

                                /*Mono
                                MCS values for AAC Mono are min: 16kbps and max: 192 kbps*/
                                if( xVSS_context->pSettings->xVSS.outputAudioBitrate
                                    >= M4VIDEOEDITING_k16_KBPS
                                    && xVSS_context->pSettings->
                                    xVSS.outputAudioBitrate
                                    <= M4VIDEOEDITING_k192_KBPS
                                    && xVSS_context->pSettings->xVSS.bAudioMono
                                    == M4OSA_TRUE )
                                {
                                    pParams->OutputAudioBitrate =
                                        xVSS_context->pSettings->
                                        xVSS.outputAudioBitrate;
                                }
                                /*Stereo
                                MCS values for AAC Mono are min: 32kbps and max: 192 kbps*/
                                else if( xVSS_context->pSettings->
                                    xVSS.outputAudioBitrate
                                    >= M4VIDEOEDITING_k32_KBPS
                                    && xVSS_context->pSettings->
                                    xVSS.outputAudioBitrate
                                    <= M4VIDEOEDITING_k192_KBPS
                                    && xVSS_context->pSettings->xVSS.bAudioMono
                                    == M4OSA_FALSE )
                                {
                                    pParams->OutputAudioBitrate =
                                        xVSS_context->pSettings->
                                        xVSS.outputAudioBitrate;
                                }

                                /*The audio bitrate is hard coded according to the output audio
                                 sampling frequency*/
                                else
                                {
                                    switch( xVSS_context->pSettings->
                                        xVSS.outputAudioSamplFreq )
                                    {
                                        case M4VIDEOEDITING_k16000_ASF:
                                            pParams->OutputAudioBitrate =
                                                M4VIDEOEDITING_k24_KBPS;
                                            break;

                                        case M4VIDEOEDITING_k22050_ASF:
                                        case M4VIDEOEDITING_k24000_ASF:
                                            pParams->OutputAudioBitrate =
                                                M4VIDEOEDITING_k32_KBPS;
                                            break;

                                        case M4VIDEOEDITING_k32000_ASF:
                                            pParams->OutputAudioBitrate =
                                                M4VIDEOEDITING_k48_KBPS;
                                            break;

                                        case M4VIDEOEDITING_k44100_ASF:
                                        case M4VIDEOEDITING_k48000_ASF:
                                            pParams->OutputAudioBitrate =
                                                M4VIDEOEDITING_k64_KBPS;
                                            break;

                                        default:
                                            pParams->OutputAudioBitrate =
                                                M4VIDEOEDITING_k64_KBPS;
                                            break;
                                    }

                                    if( xVSS_context->pSettings->xVSS.bAudioMono
                                        == M4OSA_FALSE )
                                    {
                                        /* Output bitrate have to be doubled */
                                        pParams->OutputAudioBitrate +=
                                            pParams->OutputAudioBitrate;
                                    }
                                }

                                pParams->bAudioMono =
                                    xVSS_context->pSettings->xVSS.bAudioMono;

                                if( xVSS_context->pSettings->
                                    xVSS.outputAudioSamplFreq
                                    == M4VIDEOEDITING_k8000_ASF )
                                {
                                    /* Prevent from unallowed sampling frequencies */
                                    pParams->OutputAudioSamplingFrequency =
                                        M4VIDEOEDITING_kDefault_ASF;
                                }
                                else
                                {
                                    pParams->OutputAudioSamplingFrequency =
                                        xVSS_context->pSettings->
                                        xVSS.outputAudioSamplFreq;
                                }
                                break;
                            }

                        default: /* Should not happen !! */
                            pParams->OutputAudioFormat = M4VIDEOEDITING_kAMR_NB;
                            pParams->OutputAudioBitrate =
                                M4VIDEOEDITING_k12_2_KBPS;
                            pParams->bAudioMono = M4OSA_TRUE;
                            pParams->OutputAudioSamplingFrequency =
                                M4VIDEOEDITING_kDefault_ASF;
                            break;
                        }
                }
                else
                {
                    pParams->OutputAudioFormat = M4VIDEOEDITING_kNullAudio;
                }

                /**
                * UTF conversion: convert into the customer format, before being used*/
                pDecodedPath = xVSS_context->pSettings->pClipList[i]->pFile;
                length = strlen(pDecodedPath);

                if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                    != M4OSA_NULL && xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer
                    != M4OSA_NULL )
                {
                    err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                        (M4OSA_Void *)xVSS_context->pSettings->
                        pClipList[i]->pFile,
                        (M4OSA_Void *)xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer,
                        &length);

                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                            err);
                        /* Free Send command */
                        M4xVSS_freeCommand(xVSS_context);
                        return err;
                    }
                    pDecodedPath = xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer;
                }

                /**
                * End of the UTF conversion, use the converted file path*/
                pParams->pFileIn =
                    (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
                    (M4OSA_Char *)"MCS 3GP Params: file in");

                if( pParams->pFileIn == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }
                memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
                    (length + 1)); /* Copy input file path */

                /**
                * UTF conversion: convert into the customer format, before being used*/
                pDecodedPath = out_3gp;
                length = strlen(pDecodedPath);

                if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                    != M4OSA_NULL && xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer
                    != M4OSA_NULL )
                {
                    err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                        (M4OSA_Void *)out_3gp, (M4OSA_Void *)xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer,
                        &length);

                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                            err);
                        /* Free Send command */
                        M4xVSS_freeCommand(xVSS_context);
                        return err;
                    }
                    pDecodedPath = xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer;
                }

                /**
                * End of the UTF conversion, use the converted file path*/
                pParams->pFileOut =
                    (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
                    (M4OSA_Char *)"MCS 3GP Params: file out");

                if( pParams->pFileOut == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }
                memcpy((void *)pParams->pFileOut, (void *)pDecodedPath,
                    (length + 1)); /* Copy output file path */

#ifdef M4xVSS_RESERVED_MOOV_DISK_SPACE
                /**
                * UTF conversion: convert into the customer format, before being used*/

                pDecodedPath = out_3gp_tmp;
                length = strlen(pDecodedPath);

                if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                    != M4OSA_NULL && xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer
                    != M4OSA_NULL )
                {
                    err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                        (M4OSA_Void *)out_3gp_tmp,
                        (M4OSA_Void *)xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer,
                        &length);

                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                            err);
                        /* Free Send command */
                        M4xVSS_freeCommand(xVSS_context);
                        return err;
                    }
                    pDecodedPath = xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer;
                }

                /**
                * End of the UTF conversion, use the converted file path*/
                pParams->pFileTemp =
                    (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
                    (M4OSA_Char *)"MCS 3GP Params: file temp");

                if( pParams->pFileTemp == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }
                memcpy((void *)pParams->pFileTemp, (void *)pDecodedPath,
                    (length + 1)); /* Copy temporary file path */

#else

                pParams->pFileTemp = M4OSA_NULL;

#endif /*M4xVSS_RESERVED_MOOV_DISK_SPACE*/

                /*FB 2008/10/20 keep media aspect ratio, add media rendering parameter*/

                if( xVSS_context->pSettings->pClipList[i]->xVSS.MediaRendering
                    == M4xVSS_kCropping
                    || xVSS_context->pSettings->pClipList[i]->xVSS.
                    MediaRendering == M4xVSS_kBlackBorders
                    || xVSS_context->pSettings->pClipList[i]->xVSS.
                    MediaRendering == M4xVSS_kResizing )
                {
                    pParams->MediaRendering =
                        xVSS_context->pSettings->pClipList[i]->xVSS.
                        MediaRendering;
                }

                /*FB: transcoding per parts*/
                pParams->BeginCutTime =
                    xVSS_context->pSettings->pClipList[i]->uiBeginCutTime;
                pParams->EndCutTime =
                    xVSS_context->pSettings->pClipList[i]->uiEndCutTime;

                pParams->pNext = M4OSA_NULL;
                pParams->isBGM = M4OSA_FALSE;
                pParams->isCreated = M4OSA_FALSE;
                xVSS_context->nbStepTotal++;
                bIsTranscoding = M4OSA_TRUE;

replace3GP_3GP:
                /* Update total duration */
                totalDuration +=
                    xVSS_context->pSettings->pClipList[i]->uiEndCutTime
                    - xVSS_context->pSettings->pClipList[i]->uiBeginCutTime;

                /* Replacing in VSS structure the original 3GP file by the transcoded 3GP file */
                xVSS_context->pSettings->pClipList[i]->FileType =
                    M4VIDEOEDITING_kFileType_3GPP;

                if( xVSS_context->pSettings->pClipList[i]->pFile != M4OSA_NULL )
                {
                    free(xVSS_context->pSettings->pClipList[i]->pFile);
                    xVSS_context->pSettings->pClipList[i]->pFile = M4OSA_NULL;
                }

                /**
                * UTF conversion: convert into the customer format, before being used*/
                pDecodedPath = pParams->pFileOut;

                if( xVSS_context->UTFConversionContext.pConvToUTF8Fct
                    != M4OSA_NULL && xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer
                    != M4OSA_NULL )
                {
                    err = M4xVSS_internalConvertToUTF8(xVSS_context,
                        (M4OSA_Void *)pParams->pFileOut,
                        (M4OSA_Void *)xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer,
                        &length);

                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_SendCommand: M4xVSS_internalConvertToUTF8 returns err: 0x%x",
                            err);
                        /* Free Send command */
                        M4xVSS_freeCommand(xVSS_context);
                        return err;
                    }
                    pDecodedPath = xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer;
                }
                else
                {
                    length = strlen(pDecodedPath);
                }
                /**
                * End of the UTF conversion, use the converted file path*/
                xVSS_context->pSettings->pClipList[i]->pFile = M4OSA_32bitAlignedMalloc(
                    (length + 1),
                    M4VS, (M4OSA_Char *)"xVSS file path of 3gp to 3gp");

                if( xVSS_context->pSettings->pClipList[i]->pFile == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }
                memcpy((void *)xVSS_context->pSettings->pClipList[i]->pFile,
                    (void *)pDecodedPath, (length + 1));
                /*FB: add file path size because of UTF 16 conversion*/
                xVSS_context->pSettings->pClipList[i]->filePathSize = length+1;

                /* We define master clip as first 3GP input clip */
                /*if(xVSS_context->pSettings->uiMasterClip == 0 && fileProperties.
                AudioStreamType != M4VIDEOEDITING_kNoneAudio)
                {
                xVSS_context->pSettings->uiMasterClip = i;
                }*/
            }
            else
            {
                /* Update total duration */
                totalDuration +=
                    xVSS_context->pSettings->pClipList[i]->uiEndCutTime
                    - xVSS_context->pSettings->pClipList[i]->uiBeginCutTime;
            }
            /* We define master clip as first 3GP input clip */
            if( masterClip == -1
                && fileProperties.AudioStreamType != M4VIDEOEDITING_kNoneAudio )
            {
                masterClip = i;
                xVSS_context->pSettings->uiMasterClip = i;
            }

        }
        /**************************
        Other input file type case
        ***************************/
        else
        {
            M4OSA_TRACE1_0("Bad file type as input clip");
            /*FB: to avoid leaks when there is an error in the send command*/
            /* Free Send command */
            M4xVSS_freeCommand(xVSS_context);
            /**/
            return M4ERR_PARAMETER;
        }
    }

    /*********************************************************
    * Parse all effects to make some adjustment for framing, *
    * text and to transform relative time into absolute time *
    **********************************************************/
    for ( j = 0; j < xVSS_context->pSettings->nbEffects; j++ )
    {
        /* Copy effect to "local" structure */
        memcpy((void *) &(xVSS_context->pSettings->Effects[j]),
            (void *) &(pSettings->Effects[j]),
            sizeof(M4VSS3GPP_EffectSettings));

        /* Prevent from bad initializing of effect percentage time */
        if( xVSS_context->pSettings->Effects[j].xVSS.uiDurationPercent > 100
            || xVSS_context->pSettings->Effects[j].xVSS.uiStartPercent > 100 )
        {
            /* These percentage time have probably not been initialized */
            /* Let's not use them by setting them to 0 */
            xVSS_context->pSettings->Effects[j].xVSS.uiDurationPercent = 0;
            xVSS_context->pSettings->Effects[j].xVSS.uiStartPercent = 0;
        }

        /* If we have percentage information let's use it... Otherwise, we use absolute time. */
        if( xVSS_context->pSettings->Effects[j].xVSS.uiDurationPercent != 0 )
        {
            xVSS_context->pSettings->
                Effects[j].uiStartTime = (M4OSA_UInt32)(totalDuration
                * xVSS_context->pSettings->Effects[j].xVSS.uiStartPercent
                / 100);
            /* The percentage of effect duration is based on the duration of the clip -
            start time */
            xVSS_context->pSettings->
                Effects[j].uiDuration = (M4OSA_UInt32)(totalDuration
                * xVSS_context->pSettings->Effects[j].xVSS.uiDurationPercent
                / 100);
        }

        /* If there is a framing effect, we need to allocate framing effect structure */
        if( xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_Framing )
        {
#ifdef DECODE_GIF_ON_SAVING

            M4xVSS_FramingContext *framingCtx;
            /*UTF conversion support*/
            M4OSA_Void *pDecodedPath = M4OSA_NULL;

#else

            M4xVSS_FramingStruct *framingCtx;

#endif /*DECODE_GIF_ON_SAVING*/

            M4OSA_Char *pExt2 = M4OSA_NULL;
            M4VIFI_ImagePlane *pPlane =
                xVSS_context->pSettings->Effects[j].xVSS.pFramingBuffer;
            M4OSA_Int32 result1, result2;

            /* Copy framing file path */
            if( pSettings->Effects[j].xVSS.pFramingFilePath != M4OSA_NULL )
            {
                xVSS_context->pSettings->
                    Effects[j].xVSS.pFramingFilePath = M4OSA_32bitAlignedMalloc(
                    strlen(pSettings->Effects[j].xVSS.pFramingFilePath)
                    + 1, M4VS, (M4OSA_Char *)"Local Framing file path");

                if( xVSS_context->pSettings->Effects[j].xVSS.pFramingFilePath
                    == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }
                memcpy((void *)xVSS_context->pSettings->
                    Effects[j].xVSS.pFramingFilePath,
                    (void *)pSettings->
                    Effects[j].xVSS.pFramingFilePath, strlen(
                    pSettings->Effects[j].xVSS.pFramingFilePath) + 1);

                pExt2 =
                    xVSS_context->pSettings->Effects[j].xVSS.pFramingFilePath;
            }

#ifdef DECODE_GIF_ON_SAVING

            framingCtx = (M4xVSS_FramingContext
                *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FramingContext),
                M4VS, (M4OSA_Char *)"Context of the framing effect");

            if( framingCtx == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                /*FB: to avoid leaks when there is an error in the send command*/
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                /**/
                return M4ERR_ALLOC;
            }
            framingCtx->aFramingCtx = M4OSA_NULL;
            framingCtx->aFramingCtx_last = M4OSA_NULL;
            framingCtx->pSPSContext = M4OSA_NULL;
            framingCtx->outputVideoSize =
                xVSS_context->pSettings->xVSS.outputVideoSize;
            framingCtx->topleft_x =
                xVSS_context->pSettings->Effects[j].xVSS.topleft_x;
            framingCtx->topleft_y =
                xVSS_context->pSettings->Effects[j].xVSS.topleft_y;
            framingCtx->bEffectResize =
                xVSS_context->pSettings->Effects[j].xVSS.bResize;
            framingCtx->pEffectFilePath =
                xVSS_context->pSettings->Effects[j].xVSS.pFramingFilePath;
            framingCtx->pFileReadPtr = xVSS_context->pFileReadPtr;
            framingCtx->pFileWritePtr = xVSS_context->pFileWritePtr;
            framingCtx->effectDuration =
                xVSS_context->pSettings->Effects[j].uiDuration;
            framingCtx->b_IsFileGif = M4OSA_FALSE;
            framingCtx->alphaBlendingStruct = M4OSA_NULL;
            framingCtx->b_animated = M4OSA_FALSE;

            /* Output ratio for the effect is stored in uiFiftiesOutFrameRate parameters of the
            extended xVSS effects structure */
            if( xVSS_context->pSettings->Effects[j].xVSS.uiFiftiesOutFrameRate
                != 0 )
            {
                framingCtx->frameDurationRatio =
                    (M4OSA_Float)(( xVSS_context->pSettings->
                    Effects[j].xVSS.uiFiftiesOutFrameRate) / 1000.0);
            }
            else
            {
                framingCtx->frameDurationRatio = 1.0;
            }

            /*Alpha blending*/
            /*Check if the alpha blending parameters are corrects*/
            if( pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime > 100 )
            {
                pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime = 0;
            }

            if( pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime > 100 )
            {
                pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime = 0;
            }

            if( pSettings->Effects[j].xVSS.uialphaBlendingEnd > 100 )
            {
                pSettings->Effects[j].xVSS.uialphaBlendingEnd = 100;
            }

            if( pSettings->Effects[j].xVSS.uialphaBlendingMiddle > 100 )
            {
                pSettings->Effects[j].xVSS.uialphaBlendingMiddle = 100;
            }

            if( pSettings->Effects[j].xVSS.uialphaBlendingStart > 100 )
            {
                pSettings->Effects[j].xVSS.uialphaBlendingStart = 100;
            }

            if( pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime > 0
                || pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime > 0 )
            {
                /*Allocate the alpha blending structure*/
                framingCtx->alphaBlendingStruct =
                    (M4xVSS_internalEffectsAlphaBlending *)M4OSA_32bitAlignedMalloc(
                    sizeof(M4xVSS_internalEffectsAlphaBlending),
                    M4VS, (M4OSA_Char *)"alpha blending structure");

                if( framingCtx->alphaBlendingStruct == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    M4xVSS_freeCommand(xVSS_context);
                    return M4ERR_ALLOC;
                }
                /*Fill the alpha blending structure*/
                framingCtx->alphaBlendingStruct->m_fadeInTime =
                    pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime;
                framingCtx->alphaBlendingStruct->m_fadeOutTime =
                    pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime;
                framingCtx->alphaBlendingStruct->m_end =
                    pSettings->Effects[j].xVSS.uialphaBlendingEnd;
                framingCtx->alphaBlendingStruct->m_middle =
                    pSettings->Effects[j].xVSS.uialphaBlendingMiddle;
                framingCtx->alphaBlendingStruct->m_start =
                    pSettings->Effects[j].xVSS.uialphaBlendingStart;

                if( pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime
                    + pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime
                        > 100 )
                {
                    framingCtx->alphaBlendingStruct->m_fadeOutTime =
                        100 - framingCtx->alphaBlendingStruct->m_fadeInTime;
                }
            }

            /**
            * UTF conversion: convert into the customer format, before being used*/
            pDecodedPath =
                xVSS_context->pSettings->Effects[j].xVSS.pFramingFilePath;
            length = strlen(pDecodedPath);

            if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                != M4OSA_NULL && xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer
                != M4OSA_NULL )
            {
                err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                    (M4OSA_Void *)xVSS_context->pSettings->
                    Effects[j].xVSS.pFramingFilePath,
                    (M4OSA_Void *)xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer,
                    &length);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1(
                        "M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                        err);
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    return err;
                }
                pDecodedPath =
                    xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
            }

            /**
            * End of the UTF conversion, use the converted file path*/
            framingCtx->pEffectFilePath = M4OSA_32bitAlignedMalloc(length + 1, M4VS,
                (M4OSA_Char *)"Local Framing file path");

            if( framingCtx->pEffectFilePath == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                /*FB: to avoid leaks when there is an error in the send command*/
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                /**/
                return M4ERR_ALLOC;
            }
            memcpy((void *)framingCtx->pEffectFilePath,
                (void *)pDecodedPath, length + 1);

            /* Save framing structure associated with corresponding effect */
            xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
                framingCtx;

#else

            framingCtx = (M4xVSS_FramingStruct
                *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FramingStruct),
                M4VS, (M4OSA_Char *)"Context of the framing effect");

            if( framingCtx == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                /*FB: to avoid leaks when there is an error in the send command*/
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                /**/
                return M4ERR_ALLOC;
            }

            framingCtx->topleft_x =
                xVSS_context->pSettings->Effects[j].xVSS.topleft_x;
            framingCtx->topleft_y =
                xVSS_context->pSettings->Effects[j].xVSS.topleft_y;

            /* BugFix 1.2.0: Leak when decoding error */
            framingCtx->FramingRgb = M4OSA_NULL;
            framingCtx->FramingYuv = M4OSA_NULL;
            framingCtx->pNext = framingCtx;
            /* Save framing structure associated with corresponding effect */
            xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
                framingCtx;

#endif /*DECODE_GIF_ON_SAVING*/

            if( pExt2 != M4OSA_NULL )
            {
                /* Decode the image associated to the effect, and fill framing structure */
                pExt2 += (strlen((const char *)pExt2) - 4);

                result1 = strcmp((const char *)pExt2,(const char *)".rgb");
                result2 = strcmp((const char *)pExt2,(const char *)".RGB");

                if( 0 == result1 || 0 == result2 )
                {
#ifdef DECODE_GIF_ON_SAVING

                    framingCtx->aFramingCtx =
                        (M4xVSS_FramingStruct
                        *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FramingStruct),
                        M4VS,
                        (M4OSA_Char
                        *)
                        "M4xVSS_internalDecodeGIF: Context of the framing effect");

                    if( framingCtx->aFramingCtx == M4OSA_NULL )
                    {
                        M4OSA_TRACE1_0(
                            "Allocation error in M4xVSS_SendCommand");
                        /* TODO: Translate error code of SPS to an xVSS error code */
                        M4xVSS_freeCommand(xVSS_context);
                        return M4ERR_ALLOC;
                    }
                    framingCtx->aFramingCtx->pCurrent =
                        M4OSA_NULL; /* Only used by the first element of the chain */
                    framingCtx->aFramingCtx->previousClipTime = -1;
                    framingCtx->aFramingCtx->FramingYuv = M4OSA_NULL;
                    framingCtx->aFramingCtx->FramingRgb = M4OSA_NULL;
                    framingCtx->aFramingCtx->topleft_x =
                        xVSS_context->pSettings->Effects[j].xVSS.topleft_x;
                    framingCtx->aFramingCtx->topleft_y =
                        xVSS_context->pSettings->Effects[j].xVSS.topleft_y;
                    /*To support ARGB8888 : get the width and height */

                    framingCtx->aFramingCtx->width =
                        xVSS_context->pSettings->Effects[j].xVSS.width;
                    framingCtx->aFramingCtx->height =
                        xVSS_context->pSettings->Effects[j].xVSS.height;
                    M4OSA_TRACE1_1("FRAMMING BEFORE M4xVSS_SendCommand  %d",
                        framingCtx->aFramingCtx->width);
                    M4OSA_TRACE1_1("FRAMMING BEFORE M4xVSS_SendCommand  %d",
                        framingCtx->aFramingCtx->height);

#endif

                    err = M4xVSS_internalConvertARGB888toYUV420_FrammingEffect(
                        xVSS_context,
                        &(xVSS_context->pSettings->Effects[j]),
                        framingCtx->aFramingCtx,xVSS_context->pSettings->xVSS.outputVideoSize);
                    M4OSA_TRACE3_1("FRAMING WIDTH BEFORE M4xVSS_SendCommand  %d",
                        framingCtx->aFramingCtx->width);
                    M4OSA_TRACE3_1("FRAMING HEIGHT BEFORE M4xVSS_SendCommand  %d",
                        framingCtx->aFramingCtx->height);

                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_SendCommand: M4xVSS_internalDecodePNG returned 0x%x",
                            err);
                        /* TODO: Translate error code of SPS to an xVSS error code */
                        M4xVSS_freeCommand(xVSS_context);
                        return err;
                    }
                }
                else
                {
                    M4OSA_TRACE1_1(
                        "M4xVSS_SendCommand: Not supported still picture format 0x%x",
                        err);
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_PARAMETER;
                }
            }
            else if( pPlane != M4OSA_NULL )
            {
#ifdef DECODE_GIF_ON_SAVING

                framingCtx->aFramingCtx = (M4xVSS_FramingStruct
                    *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FramingStruct),
                    M4VS, (M4OSA_Char *)"Context of the framing effect");

                if( framingCtx->aFramingCtx == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }

                framingCtx->aFramingCtx->topleft_x =
                    xVSS_context->pSettings->Effects[j].xVSS.topleft_x;
                framingCtx->aFramingCtx->topleft_y =
                    xVSS_context->pSettings->Effects[j].xVSS.topleft_y;

                /* BugFix 1.2.0: Leak when decoding error */
                framingCtx->aFramingCtx->FramingRgb = M4OSA_NULL;
                framingCtx->aFramingCtx->FramingYuv = M4OSA_NULL;
                framingCtx->aFramingCtx->pNext = framingCtx->aFramingCtx;
                framingCtx->aFramingCtx->pCurrent = framingCtx->aFramingCtx;
                framingCtx->aFramingCtx->duration = 0;
                framingCtx->aFramingCtx->previousClipTime = -1;
                framingCtx->aFramingCtx->FramingRgb =
                    xVSS_context->pSettings->Effects[j].xVSS.pFramingBuffer;
                /* Force input RGB buffer to even size to avoid errors in YUV conversion */
                framingCtx->aFramingCtx->FramingRgb->u_width =
                    framingCtx->aFramingCtx->FramingRgb->u_width & ~1;
                framingCtx->aFramingCtx->FramingRgb->u_height =
                    framingCtx->aFramingCtx->FramingRgb->u_height & ~1;
                /* Input RGB plane is provided, let's convert it to YUV420, and update framing
                structure  */
                err = M4xVSS_internalConvertRGBtoYUV(framingCtx->aFramingCtx);

#else

                framingCtx->FramingRgb =
                    xVSS_context->pSettings->Effects[j].xVSS.pFramingBuffer;
                /* Force input RGB buffer to even size to avoid errors in YUV conversion */
                framingCtx->FramingRgb.u_width =
                    framingCtx->FramingRgb.u_width & ~1;
                framingCtx->FramingRgb.u_height =
                    framingCtx->FramingRgb.u_height & ~1;
                /* Input RGB plane is provided, let's convert it to YUV420, and update framing
                 structure  */
                err = M4xVSS_internalConvertRGBtoYUV(framingCtx);

#endif

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1(
                        "M4xVSS_sendCommand: error when converting RGB to YUV: 0w%x",
                        err);
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return err;
                }
            }
            else
            {
                M4OSA_TRACE1_0(
                    "M4xVSS_sendCommand: No input image/plane provided for framing effect.");
                /*FB: to avoid leaks when there is an error in the send command*/
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                /**/
                return M4ERR_PARAMETER;
            }
        }
        /* CR: Add text handling with external text interface */
        /* If effect type is text, we call external text function to get RGB 565 buffer */
        if( xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_Text )
        {
            /* Call the font engine function pointer to get RGB565 buffer */
            /* We transform text effect into framing effect from buffer */
            if( xVSS_context->pSettings->xVSS.pTextRenderingFct != M4OSA_NULL )
            {
                /*FB: add UTF convertion for text buffer*/
                M4OSA_Void *pDecodedPath = M4OSA_NULL;
#ifdef DECODE_GIF_ON_SAVING

                M4xVSS_FramingContext *framingCtx;

#else

                M4xVSS_FramingStruct *framingCtx;

#endif /*DECODE_GIF_ON_SAVING*/

#ifdef DECODE_GIF_ON_SAVING

                framingCtx = (M4xVSS_FramingContext
                    *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FramingContext),
                    M4VS, (M4OSA_Char *)"Context of the framing effect");

                if( framingCtx == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }
                framingCtx->aFramingCtx = M4OSA_NULL;
                framingCtx->aFramingCtx_last = M4OSA_NULL;
                framingCtx->pSPSContext = M4OSA_NULL;
                framingCtx->outputVideoSize =
                    xVSS_context->pSettings->xVSS.outputVideoSize;
                framingCtx->topleft_x =
                    xVSS_context->pSettings->Effects[j].xVSS.topleft_x;
                framingCtx->topleft_y =
                    xVSS_context->pSettings->Effects[j].xVSS.topleft_y;
                framingCtx->bEffectResize =
                    xVSS_context->pSettings->Effects[j].xVSS.bResize;
                framingCtx->pEffectFilePath =
                    xVSS_context->pSettings->Effects[j].xVSS.pFramingFilePath;
                framingCtx->pFileReadPtr = xVSS_context->pFileReadPtr;
                framingCtx->pFileWritePtr = xVSS_context->pFileWritePtr;
                framingCtx->effectDuration =
                    xVSS_context->pSettings->Effects[j].uiDuration;
                framingCtx->b_IsFileGif = M4OSA_FALSE;
                framingCtx->b_animated = M4OSA_FALSE;
                framingCtx->alphaBlendingStruct = M4OSA_NULL;

                /* Save framing structure associated with corresponding effect */
                xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
                    framingCtx;

                framingCtx->aFramingCtx = (M4xVSS_FramingStruct
                    *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FramingStruct),
                    M4VS, (M4OSA_Char *)"Context of the framing effect");

                if( framingCtx->aFramingCtx == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }

                framingCtx->aFramingCtx->topleft_x =
                    xVSS_context->pSettings->Effects[j].xVSS.topleft_x;
                framingCtx->aFramingCtx->topleft_y =
                    xVSS_context->pSettings->Effects[j].xVSS.topleft_y;

                /* BugFix 1.2.0: Leak when decoding error */
                framingCtx->aFramingCtx->FramingRgb = M4OSA_NULL;
                framingCtx->aFramingCtx->FramingYuv = M4OSA_NULL;
                framingCtx->aFramingCtx->pNext = framingCtx->aFramingCtx;
                framingCtx->aFramingCtx->pCurrent = framingCtx->aFramingCtx;
                framingCtx->aFramingCtx->duration = 0;
                framingCtx->aFramingCtx->previousClipTime = -1;

                /*Alpha blending*/
                /*Check if the alpha blending parameters are corrects*/
                if( pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime > 100 )
                {
                    pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime = 0;
                }

                if( pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime > 100 )
                {
                    pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime = 0;
                }

                if( pSettings->Effects[j].xVSS.uialphaBlendingEnd > 100 )
                {
                    pSettings->Effects[j].xVSS.uialphaBlendingEnd = 100;
                }

                if( pSettings->Effects[j].xVSS.uialphaBlendingMiddle > 100 )
                {
                    pSettings->Effects[j].xVSS.uialphaBlendingMiddle = 100;
                }

                if( pSettings->Effects[j].xVSS.uialphaBlendingStart > 100 )
                {
                    pSettings->Effects[j].xVSS.uialphaBlendingStart = 100;
                }

                if( pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime > 0
                    || pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime
                    > 0 )
                {
                    /*Allocate the alpha blending structure*/
                    framingCtx->alphaBlendingStruct =
                        (M4xVSS_internalEffectsAlphaBlending *)M4OSA_32bitAlignedMalloc(
                        sizeof(M4xVSS_internalEffectsAlphaBlending),
                        M4VS, (M4OSA_Char *)"alpha blending structure");

                    if( framingCtx->alphaBlendingStruct == M4OSA_NULL )
                    {
                        M4OSA_TRACE1_0(
                            "Allocation error in M4xVSS_SendCommand");
                        M4xVSS_freeCommand(xVSS_context);
                        return M4ERR_ALLOC;
                    }
                    /*Fill the alpha blending structure*/
                    framingCtx->alphaBlendingStruct->m_fadeInTime =
                        pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime;
                    framingCtx->alphaBlendingStruct->m_fadeOutTime =
                        pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime;
                    framingCtx->alphaBlendingStruct->m_end =
                        pSettings->Effects[j].xVSS.uialphaBlendingEnd;
                    framingCtx->alphaBlendingStruct->m_middle =
                        pSettings->Effects[j].xVSS.uialphaBlendingMiddle;
                    framingCtx->alphaBlendingStruct->m_start =
                        pSettings->Effects[j].xVSS.uialphaBlendingStart;

                    if( pSettings->Effects[j].xVSS.uialphaBlendingFadeInTime
                        + pSettings->Effects[j].xVSS.uialphaBlendingFadeOutTime
                            > 100 )
                    {
                        framingCtx->alphaBlendingStruct->m_fadeOutTime =
                            100 - framingCtx->alphaBlendingStruct->m_fadeInTime;
                    }
                }
#else

                framingCtx = (M4xVSS_FramingStruct
                    *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FramingStruct),
                    M4VS, (M4OSA_Char
                    *)"Context of the framing effect (for text)");

                if( framingCtx == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }

                framingCtx->topleft_x =
                    xVSS_context->pSettings->Effects[j].xVSS.topleft_x;
                framingCtx->topleft_y =
                    xVSS_context->pSettings->Effects[j].xVSS.topleft_y;
                framingCtx->FramingRgb = M4OSA_NULL;

                /* BugFix 1.2.0: Leak when decoding error */
                framingCtx->FramingYuv = M4OSA_NULL;
                framingCtx->pNext = framingCtx;

#endif
                /* Save framing structure associated with corresponding effect */

                xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
                    framingCtx;

                /* FB: changes for Video Artist: memcopy pTextBuffer so that it can be changed
                after a complete analysis*/
                if( pSettings->Effects[j].xVSS.pTextBuffer == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("M4xVSS_SendCommand: pTextBuffer is null");
                    M4xVSS_freeCommand(xVSS_context);
                    return M4ERR_PARAMETER;
                }

                /*Convert text buffer into customer format before being used*/
                /**
                * UTF conversion: convert into the customer format, before being used*/
                pDecodedPath = pSettings->Effects[j].xVSS.pTextBuffer;
                xVSS_context->pSettings->Effects[j].xVSS.textBufferSize =
                    pSettings->Effects[j].xVSS.textBufferSize;

                if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                    != M4OSA_NULL && xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer
                    != M4OSA_NULL )
                {
                    err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                        (M4OSA_Void *)pSettings->
                        Effects[j].xVSS.pTextBuffer,
                        (M4OSA_Void *)xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer,
                        &length);

                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                            err);
                        /* Free Send command */
                        M4xVSS_freeCommand(xVSS_context);
                        return err;
                    }
                    pDecodedPath = xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer;
                    xVSS_context->pSettings->Effects[j].xVSS.textBufferSize =
                        length;
                }
                /**
                * End of the UTF conversion, use the converted file path*/

                xVSS_context->pSettings->
                    Effects[j].xVSS.pTextBuffer = M4OSA_32bitAlignedMalloc(
                    xVSS_context->pSettings->Effects[j].xVSS.textBufferSize + 1,
                    M4VS, (M4OSA_Char *)"Local text buffer effect");

                //xVSS_context->pSettings->Effects[j].xVSS.pTextBuffer =
                // M4OSA_32bitAlignedMalloc(strlen(pSettings->Effects[j].xVSS.pTextBuffer)+1,
                // M4VS, "Local text buffer effect");
                if( xVSS_context->pSettings->Effects[j].xVSS.pTextBuffer
                    == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }

                if( pSettings->Effects[j].xVSS.pTextBuffer != M4OSA_NULL )
                {
                    //memcpy((M4OSA_MemAddr8)xVSS_context->pSettings->Effects[j]
                    //.xVSS.pTextBuffer, (M4OSA_MemAddr8)pSettings->Effects[j].xVSS.pTextBuffer,
                    // strlen(pSettings->Effects[j].xVSS.pTextBuffer)+1);
                    memcpy((void *)xVSS_context->pSettings->
                        Effects[j].xVSS.pTextBuffer,
                        (void *)pDecodedPath, xVSS_context->pSettings->
                        Effects[j].xVSS.textBufferSize + 1);
                }

                /*Allocate the text RGB buffer*/
                framingCtx->aFramingCtx->FramingRgb =
                    (M4VIFI_ImagePlane *)M4OSA_32bitAlignedMalloc(sizeof(M4VIFI_ImagePlane),
                    M4VS,
                    (M4OSA_Char *)"RGB structure for the text effect");

                if( framingCtx->aFramingCtx->FramingRgb == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }

                if( xVSS_context->pSettings->Effects[j].xVSS.uiTextBufferWidth
                    == 0 || xVSS_context->pSettings->
                    Effects[j].xVSS.uiTextBufferHeight == 0 )
                {
                    M4OSA_TRACE1_0(
                        "M4xVSS_SendCommand: text plane width and height are not defined");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_PARAMETER;
                }
                /* Allocate input RGB text buffer and force it to even size to avoid errors in
                 YUV conversion */
                framingCtx->aFramingCtx->FramingRgb->u_width =
                    xVSS_context->pSettings->
                    Effects[j].xVSS.uiTextBufferWidth & ~1;
                framingCtx->aFramingCtx->FramingRgb->u_height =
                    xVSS_context->pSettings->
                    Effects[j].xVSS.uiTextBufferHeight & ~1;
                framingCtx->aFramingCtx->FramingRgb->u_stride =
                    2 * framingCtx->aFramingCtx->FramingRgb->u_width;
                framingCtx->aFramingCtx->FramingRgb->u_topleft = 0;
                framingCtx->aFramingCtx->FramingRgb->pac_data =
                    (M4VIFI_UInt8 *)M4OSA_32bitAlignedMalloc(
                    framingCtx->aFramingCtx->FramingRgb->u_height
                    * framingCtx->aFramingCtx->FramingRgb->u_stride,
                    M4VS, (M4OSA_Char *)"Text RGB plane->pac_data");

                if( framingCtx->aFramingCtx->FramingRgb->pac_data
                    == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                    /*FB: to avoid leaks when there is an error in the send command*/
                    /* Free Send command */
                    M4xVSS_freeCommand(xVSS_context);
                    /**/
                    return M4ERR_ALLOC;
                }

#ifdef DECODE_GIF_ON_SAVING
                /**/
                /* Call text rendering function */

                err = xVSS_context->pSettings->xVSS.pTextRenderingFct(
                    xVSS_context->pSettings->Effects[j].xVSS.pRenderingData,
                    xVSS_context->pSettings->
                    Effects[j].xVSS.pTextBuffer,
                    xVSS_context->pSettings->
                    Effects[j].xVSS.textBufferSize,
                    &(framingCtx->aFramingCtx->FramingRgb));

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_0("Text rendering external function failed\n");
                    M4xVSS_freeCommand(xVSS_context);
                    return err;
                }

                /* Check that RGB buffer is set */
                if( framingCtx->aFramingCtx->FramingRgb == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0(
                        "Text rendering function did not set RGB buffer correctly !");
                    M4xVSS_freeCommand(xVSS_context);
                    return M4ERR_PARAMETER;
                }

                /* Convert RGB plane to YUV420 and update framing structure */
                err = M4xVSS_internalConvertRGBtoYUV(framingCtx->aFramingCtx);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1(
                        "M4xVSS_sendCommand: error when converting RGB to YUV: 0w%x",
                        err);
                    M4xVSS_freeCommand(xVSS_context);
                    return err;
                }

#else
                /**/
                /* Call text rendering function */

                err = xVSS_context->pSettings->xVSS.pTextRenderingFct(
                    xVSS_context->pSettings->Effects[j].xVSS.pRenderingData,
                    xVSS_context->pSettings->
                    Effects[j].xVSS.pTextBuffer,
                    xVSS_context->pSettings->
                    Effects[j].xVSS.textBufferSize,
                    &(framingCtx->FramingRgb));

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_0("Text rendering external function failed\n");
                    M4xVSS_freeCommand(xVSS_context);
                    return err;
                }

                /* Check that RGB buffer is set */
                if( framingCtx->FramingRgb == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0(
                        "Text rendering function did not set RGB buffer correctly !");
                    M4xVSS_freeCommand(xVSS_context);
                    return M4ERR_PARAMETER;
                }

                /* Convert RGB plane to YUV420 and update framing structure */
                err = M4xVSS_internalConvertRGBtoYUV(framingCtx);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1(
                        "M4xVSS_sendCommand: error when converting RGB to YUV: 0w%x",
                        err);
                    M4xVSS_freeCommand(xVSS_context);
                    return err;
                }

#endif /*DECODE_GIF_ON_SAVING*/

                /* Change internally effect type from "text" to framing */

                xVSS_context->pSettings->Effects[j].VideoEffectType =
                    M4xVSS_kVideoEffectType_Framing;
                xVSS_context->pSettings->Effects[j].xVSS.bResize = M4OSA_FALSE;
            }
            else
            {
                M4OSA_TRACE1_0(
                    "M4xVSS_sendCommand: No text rendering function set !!");
                M4xVSS_freeCommand(xVSS_context);
                return M4ERR_PARAMETER;
            }
        }

        /* Allocate the structure to store the data needed by the Fifties effect */
        else if( xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_Fifties )
        {
            M4xVSS_FiftiesStruct *fiftiesCtx;

            /* Check the expected frame rate for the fifties effect (must be above 0) */
            if( 0 == xVSS_context->pSettings->
                Effects[j].xVSS.uiFiftiesOutFrameRate )
            {
                M4OSA_TRACE1_0(
                    "The frame rate for the fifties effect must be greater than 0 !");
                M4xVSS_freeCommand(xVSS_context);
                return M4ERR_PARAMETER;
            }

            fiftiesCtx = (M4xVSS_FiftiesStruct
                *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_FiftiesStruct),
                M4VS, (M4OSA_Char *)"Context of the fifties effect");

            if( fiftiesCtx == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                return M4ERR_ALLOC;
            }

            fiftiesCtx->previousClipTime = -1;
            fiftiesCtx->fiftiesEffectDuration = 1000 / xVSS_context->pSettings->
                Effects[j].xVSS.uiFiftiesOutFrameRate;
            fiftiesCtx->shiftRandomValue = 0;
            fiftiesCtx->stripeRandomValue = 0;

            /* Save the structure associated with corresponding effect */
            xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
                fiftiesCtx;
        }

        /* Allocate the structure to store the data needed by the Color effect */
        else if( xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_ColorRGB16
            || xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_BlackAndWhite
            || xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_Pink
            || xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_Green
            || xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_Sepia
            || xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_Negative
            || xVSS_context->pSettings->Effects[j].VideoEffectType
            == M4xVSS_kVideoEffectType_Gradient )
        {
            M4xVSS_ColorStruct *ColorCtx;

            ColorCtx =
                (M4xVSS_ColorStruct *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_ColorStruct),
                M4VS, (M4OSA_Char *)"Context of the color effect");

            if( ColorCtx == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                return M4ERR_ALLOC;
            }

            ColorCtx->colorEffectType =
                xVSS_context->pSettings->Effects[j].VideoEffectType;

            if( xVSS_context->pSettings->Effects[j].VideoEffectType
                == M4xVSS_kVideoEffectType_ColorRGB16
                || xVSS_context->pSettings->Effects[j].VideoEffectType
                == M4xVSS_kVideoEffectType_Gradient )
            {
                ColorCtx->rgb16ColorData =
                    xVSS_context->pSettings->Effects[j].xVSS.uiRgb16InputColor;
            }
            else
            {
                ColorCtx->rgb16ColorData = 0;
            }

            /* Save the structure associated with corresponding effect */
            xVSS_context->pSettings->Effects[j].pExtVideoEffectFctCtxt =
                ColorCtx;
        }
    }

    /**********************************
    Background music registering
    **********************************/
    if( pSettings->xVSS.pBGMtrack != M4OSA_NULL && isNewBGM == M4OSA_TRUE )
    {
#ifdef PREVIEW_ENABLED

        M4xVSS_MCS_params *pParams;
        M4OSA_Char *out_pcm;
        /*UTF conversion support*/
        M4OSA_Void *pDecodedPath = M4OSA_NULL;

#endif

        /* We save output file pointer, because we will need to use it when saving audio mixed
         file (last save step) */

        xVSS_context->pOutputFile = xVSS_context->pSettings->pOutputFile;
        xVSS_context->pTemporaryFile = xVSS_context->pSettings->pTemporaryFile;

        /* If a previous BGM has already been registered, delete it */
        /* Here can be implemented test to know if the same BGM is registered */
        if( xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL )
        {
            if( xVSS_context->pSettings->xVSS.pBGMtrack->pFile != M4OSA_NULL )
            {
                free(xVSS_context->pSettings->xVSS.pBGMtrack->
                    pFile);
                xVSS_context->pSettings->xVSS.pBGMtrack->pFile = M4OSA_NULL;
            }
            free(xVSS_context->pSettings->xVSS.pBGMtrack);
            xVSS_context->pSettings->xVSS.pBGMtrack = M4OSA_NULL;
        }

        /* Allocate BGM */
        xVSS_context->pSettings->xVSS.pBGMtrack =
            (M4xVSS_BGMSettings *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_BGMSettings), M4VS,
            (M4OSA_Char *)"xVSS_context->pSettings->xVSS.pBGMtrack");

        if( xVSS_context->pSettings->xVSS.pBGMtrack == M4OSA_NULL )
        {
            M4xVSS_freeCommand(xVSS_context);
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            return M4ERR_ALLOC;
        }

        /* Copy input structure to our structure */
        memcpy((void *)xVSS_context->pSettings->xVSS.pBGMtrack,
            (void *)pSettings->xVSS.pBGMtrack,
            sizeof(M4xVSS_BGMSettings));
        /* Allocate file name, and copy file name buffer to our structure */
        xVSS_context->pSettings->xVSS.pBGMtrack->pFile =
            M4OSA_32bitAlignedMalloc((strlen(pSettings->xVSS.pBGMtrack->pFile)
            + 1), M4VS, (M4OSA_Char *)"xVSS BGM file path");

        if( xVSS_context->pSettings->xVSS.pBGMtrack->pFile == M4OSA_NULL )
        {
            M4xVSS_freeCommand(xVSS_context);
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            return M4ERR_ALLOC;
        }
        memcpy((void *)xVSS_context->pSettings->xVSS.pBGMtrack->pFile,
            (void *)pSettings->xVSS.pBGMtrack->pFile,
            strlen(pSettings->xVSS.pBGMtrack->pFile) + 1);

#ifdef PREVIEW_ENABLED
        /* Decode BGM track to pcm output file */

        pParams =
            (M4xVSS_MCS_params *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_MCS_params), M4VS,
            (M4OSA_Char *)"Element of MCS Params (for BGM)");

        if( pParams == M4OSA_NULL )
        {
            M4xVSS_freeCommand(xVSS_context);
            M4OSA_TRACE1_0(
                "M4xVSS_sendCommand: Problem when allocating one element MCS Params");
            return M4ERR_ALLOC;
        }

        /* Initialize the pointers in case of problem (PR 2273) */
        pParams->pFileIn = M4OSA_NULL;
        pParams->pFileOut = M4OSA_NULL;
        pParams->pFileTemp = M4OSA_NULL;
        pParams->pNext = M4OSA_NULL;
        pParams->BeginCutTime = 0;
        pParams->EndCutTime = 0;

        if( xVSS_context->pMCSparamsList
            == M4OSA_NULL ) /* Means it is the first element of the list */
        {
            /* Initialize the xVSS context with the first element of the list */
            xVSS_context->pMCSparamsList = pParams;

        }
        else
        {
            M4xVSS_MCS_params *pParams_temp = xVSS_context->pMCSparamsList;
            M4xVSS_MCS_params *pParams_prev = M4OSA_NULL;

            /* Parse MCS params chained list to find and delete BGM element */
            while( pParams_temp != M4OSA_NULL )
            {
                if( pParams_temp->isBGM == M4OSA_TRUE )
                {
                    /* Remove this element */
                    if( pParams_temp->pFileIn != M4OSA_NULL )
                    {
                        free(pParams_temp->pFileIn);
                        pParams_temp->pFileIn = M4OSA_NULL;
                    }

                    if( pParams_temp->pFileOut != M4OSA_NULL )
                    {
                        /* Remove PCM temporary file */
                        remove((const char *)pParams_temp->pFileOut);
                        free(pParams_temp->pFileOut);
                        pParams_temp->pFileOut = M4OSA_NULL;
                    }
                    /* Chain previous element with next element = remove BGM chained
                         list element */
                    if( pParams_prev != M4OSA_NULL )
                    {
                        pParams_prev->pNext = pParams_temp->pNext;
                    }
                    /* If current pointer is the first of the chained list and next pointer of
                    the chained list is NULL */
                    /* it means that there was only one element in the list */
                    /* => we put the context variable to NULL to reaffect the first chained list
                     element */
                    if( pParams_temp == xVSS_context->pMCSparamsList
                        && pParams_temp->pNext == M4OSA_NULL )
                    {
                        xVSS_context->pMCSparamsList = M4OSA_NULL;
                    }
                    /* In that case, BGM pointer is the first one, but there are others elements
                     after it */
                    /* So, we need to change first chained list element */
                    else if( pParams_temp->pNext != M4OSA_NULL
                        && pParams_prev == M4OSA_NULL )
                    {
                        xVSS_context->pMCSparamsList = pParams_temp->pNext;
                    }

                    if( pParams_temp->pNext != M4OSA_NULL )
                    {
                        pParams_prev = pParams_temp->pNext;
                        free(pParams_temp);
                        pParams_temp = M4OSA_NULL;
                        pParams_temp = pParams_prev;
                    }
                    else
                    {
                        free(pParams_temp);
                        pParams_temp = M4OSA_NULL;
                    }
                }
                else
                {
                    pParams_prev = pParams_temp;
                    pParams_temp = pParams_temp->pNext;
                }
            }
            /* We need to initialize the last element of the chained list to be able to add new
             BGM element */
            pMCS_last = pParams_prev;

            if( xVSS_context->pMCSparamsList == M4OSA_NULL )
            {
                /* In that case, it means that there was only one element in the chained list */
                /* So, we need to save the new params*/
                xVSS_context->pMCSparamsList = pParams;
            }
            else
            {
                /* Update next pointer of the previous last element of the chain */
                pMCS_last->pNext = pParams;
            }

        }

        /* Fill the last M4xVSS_MCS_params element */
        pParams->InputFileType =
            xVSS_context->pSettings->xVSS.pBGMtrack->FileType;
        pParams->OutputFileType = M4VIDEOEDITING_kFileType_PCM;
        pParams->OutputVideoFormat = M4VIDEOEDITING_kNoneVideo;
        pParams->OutputVideoFrameSize = M4VIDEOEDITING_kQCIF;
        pParams->OutputVideoFrameRate = M4VIDEOEDITING_k15_FPS;

        if( xVSS_context->pSettings->xVSS.outputAudioFormat
            == M4VIDEOEDITING_kAAC )
        {
            pParams->OutputAudioFormat = M4VIDEOEDITING_kAAC;
            pParams->OutputAudioSamplingFrequency = M4VIDEOEDITING_kDefault_ASF;

            /*FB: VAL CR P4ME00003076
            The output audio bitrate in the AAC case is now directly given by the user*/
            /*Check if the audio bitrate is correctly defined*/
            /*Mono
            MCS values for AAC Mono are min: 16kbps and max: 192 kbps*/
            if( xVSS_context->pSettings->xVSS.outputAudioBitrate
                >= M4VIDEOEDITING_k16_KBPS
                && xVSS_context->pSettings->xVSS.outputAudioBitrate
                <= M4VIDEOEDITING_k192_KBPS
                && xVSS_context->pSettings->xVSS.bAudioMono == M4OSA_TRUE )
            {
                pParams->OutputAudioBitrate =
                    xVSS_context->pSettings->xVSS.outputAudioBitrate;
            }
            /*Stereo
            MCS values for AAC Mono are min: 32kbps and max: 192 kbps*/
            else if( xVSS_context->pSettings->xVSS.outputAudioBitrate
                >= M4VIDEOEDITING_k32_KBPS
                && xVSS_context->pSettings->xVSS.outputAudioBitrate
                <= M4VIDEOEDITING_k192_KBPS
                && xVSS_context->pSettings->xVSS.bAudioMono == M4OSA_FALSE )
            {
                pParams->OutputAudioBitrate =
                    xVSS_context->pSettings->xVSS.outputAudioBitrate;
            }
            else
            {
                pParams->OutputAudioBitrate = M4VIDEOEDITING_k32_KBPS;
            }
            pParams->bAudioMono = xVSS_context->pSettings->xVSS.bAudioMono;
        }
        else
        {
            pParams->OutputAudioFormat = M4VIDEOEDITING_kAMR_NB;
            pParams->OutputAudioSamplingFrequency = M4VIDEOEDITING_kDefault_ASF;
            pParams->OutputAudioBitrate = M4VIDEOEDITING_k12_2_KBPS;
            pParams->bAudioMono = M4OSA_TRUE;
        }
        pParams->OutputVideoBitrate = M4VIDEOEDITING_kUndefinedBitrate;

        /* Prepare output filename */
        /* 21 is the size of "preview_16000_2.pcm" + \0 */
        out_pcm =
            (M4OSA_Char *)M4OSA_32bitAlignedMalloc(strlen(xVSS_context->pTempPath)
            + 21, M4VS, (M4OSA_Char *)"Temp char* for pcmPreviewFile");

        if( out_pcm == M4OSA_NULL )
        {
            M4xVSS_freeCommand(xVSS_context);
            M4OSA_TRACE1_0("Allocation error in M4xVSS_Init");
            return M4ERR_ALLOC;
        }

        /* Copy temporary path to final preview path string */
        M4OSA_chrNCopy(out_pcm, xVSS_context->pTempPath,
            strlen(xVSS_context->pTempPath) + 1);

        /* Depending of the output sample frequency and nb of channels, we construct preview
        output filename */
        if( xVSS_context->pSettings->xVSS.outputAudioFormat
            == M4VIDEOEDITING_kAAC )
        {
            /* Construct output temporary PCM filename */
            if( xVSS_context->pSettings->xVSS.bAudioMono == M4OSA_TRUE )
            {
                strncat((char *)out_pcm, (const char *)"preview_16000_1.pcm\0",
                    20);
            }
            else
            {
                strncat((char *)out_pcm, (const char *)"preview_16000_2.pcm\0",
                    20);
            }
        }
        else if( xVSS_context->pSettings->xVSS.outputAudioFormat
            == M4VIDEOEDITING_kAMR_NB )
        {
            /* Construct output temporary PCM filename */
            strncat((char *)out_pcm, (const char *)"preview_08000_1.pcm\0", 20);
        }
        else
        {
            if( out_pcm != M4OSA_NULL )
            {
                free(out_pcm);
                out_pcm = M4OSA_NULL;
            }
            M4xVSS_freeCommand(xVSS_context);
            M4OSA_TRACE1_0("Bad audio output format \n");
            return M4ERR_PARAMETER;
        }

        xVSS_context->pcmPreviewFile = out_pcm;

        /**
        * UTF conversion: convert into the customer format, before being used*/
        pDecodedPath = out_pcm;
        length = strlen(pDecodedPath);

        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
            && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
            != M4OSA_NULL )
        {
            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                (M4OSA_Void *)out_pcm, (M4OSA_Void *)xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer, &length);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                    err);
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                return err;
            }
            pDecodedPath =
                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
        }

        /**
        * End of the UTF conversion, use the converted file path*/
        xVSS_context->pcmPreviewFile =
            (M4OSA_Void *)M4OSA_32bitAlignedMalloc(length + 1, M4VS,
            (M4OSA_Char *)"pcmPreviewFile");

        if( xVSS_context->pcmPreviewFile == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            free(out_pcm);
            out_pcm = M4OSA_NULL;
            /*FB: to avoid leaks when there is an error in the send command*/
            /* Free Send command */
            M4xVSS_freeCommand(xVSS_context);
            /**/
            return M4ERR_ALLOC;
        }
        memcpy((void *)xVSS_context->pcmPreviewFile, (void *)pDecodedPath, length + 1);

        /* Free temporary output filename */
        if( out_pcm != M4OSA_NULL )
        {
            free(out_pcm);
            out_pcm = M4OSA_NULL;
        }

        pParams->pFileOut = M4OSA_32bitAlignedMalloc((length + 1), M4VS,
            (M4OSA_Char *)"MCS BGM Params: file out");

        if( pParams->pFileOut == M4OSA_NULL )
        {
            M4xVSS_freeCommand(xVSS_context);
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            return M4ERR_ALLOC;
        }
        pParams->pFileTemp = M4OSA_NULL;

        memcpy((void *)pParams->pFileOut,(void *) xVSS_context->pcmPreviewFile,
            (length + 1)); /* Copy output file path */

        /**
        * UTF conversion: convert into the customer format, before being used*/

        pDecodedPath = xVSS_context->pSettings->xVSS.pBGMtrack->pFile;
        length = strlen(pDecodedPath);

        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
            && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
            != M4OSA_NULL )
        {
            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                (M4OSA_Void *)xVSS_context->pSettings->xVSS.pBGMtrack->
                pFile, (M4OSA_Void *)xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer, &length);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4xVSS_SendCommand: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                    err);
                /* Free Send command */
                M4xVSS_freeCommand(xVSS_context);
                return err;
            }
            pDecodedPath =
                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
        }

        /**
        * End of the UTF conversion, use the converted file path*/
        pParams->pFileIn = (M4OSA_Void *)M4OSA_32bitAlignedMalloc((length + 1), M4VS,
            (M4OSA_Char *)"MCS BGM Params: file in");

        if( pParams->pFileIn == M4OSA_NULL )
        {
            M4xVSS_freeCommand(xVSS_context);
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SendCommand");
            return M4ERR_ALLOC;
        }
        memcpy((void *)pParams->pFileIn, (void *)pDecodedPath,
            (length + 1)); /* Copy input file path */

        pParams->isBGM = M4OSA_TRUE;
        pParams->isCreated = M4OSA_FALSE;
        xVSS_context->nbStepTotal++;
        bIsTranscoding = M4OSA_TRUE;
#endif /* PREVIEW_ENABLED */

    }
    else if( pSettings->xVSS.pBGMtrack != M4OSA_NULL
        && isNewBGM == M4OSA_FALSE )
    {
#ifdef PREVIEW_ENABLED
        /* BGM is the same as previously, no need to redecode audio */
        /* Need to update MCS params chained list, to signal M4xVSS_step function to skip
        BGM decoding */

        M4xVSS_MCS_params *pParams_temp = xVSS_context->pMCSparamsList;
        M4xVSS_MCS_params *pParams_prev = M4OSA_NULL;

#endif /* PREVIEW_ENABLED */
        /* We save output file pointer, because we will need to use it when saving audio
         mixed file (last save step) */

        xVSS_context->pOutputFile = xVSS_context->pSettings->pOutputFile;
        xVSS_context->pTemporaryFile = xVSS_context->pSettings->pTemporaryFile;

        /* Re-write BGM settings in case they have changed between two sendCommand */
        xVSS_context->pSettings->xVSS.pBGMtrack->uiAddCts =
            pSettings->xVSS.pBGMtrack->uiAddCts;
        xVSS_context->pSettings->xVSS.pBGMtrack->uiAddVolume =
            pSettings->xVSS.pBGMtrack->uiAddVolume;
        xVSS_context->pSettings->xVSS.pBGMtrack->uiBeginLoop =
            pSettings->xVSS.pBGMtrack->uiBeginLoop;
        xVSS_context->pSettings->xVSS.pBGMtrack->uiEndLoop =
            pSettings->xVSS.pBGMtrack->uiEndLoop;

#ifdef PREVIEW_ENABLED
        /* Parse MCS params chained list to find and delete BGM element */

        while( pParams_temp != M4OSA_NULL )
        {
            if( pParams_temp->isBGM == M4OSA_TRUE )
            {
                pParams_temp->isCreated = M4OSA_TRUE;
                break;
            }
            pParams_prev = pParams_temp;
            pParams_temp = pParams_temp->pNext;
        }

#endif /* PREVIEW_ENABLED */

        M4OSA_TRACE2_0("M4xVSS_SendCommand has been recalled, BGM is the same");
    }
    else
    {
        M4OSA_TRACE1_0("No BGM in this xVSS command");

        if( xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL )
        {
#ifdef PREVIEW_ENABLED
            /* Need to remove MCS previous params chained list */

            M4xVSS_MCS_params *pParams_temp = xVSS_context->pMCSparamsList;
            M4xVSS_MCS_params *pParams_prev = M4OSA_NULL;

            /* Parse MCS params chained list to find and delete BGM element */
            while( pParams_temp != M4OSA_NULL )
            {
                if( pParams_temp->isBGM == M4OSA_TRUE )
                {
                    /* Remove this element */
                    if( pParams_temp->pFileIn != M4OSA_NULL )
                    {
                        free(pParams_temp->pFileIn);
                        pParams_temp->pFileIn = M4OSA_NULL;
                    }

                    if( pParams_temp->pFileOut != M4OSA_NULL )
                    {
                        free(pParams_temp->pFileOut);
                        pParams_temp->pFileOut = M4OSA_NULL;
                    }
                    /* Chain previous element with next element */
                    if( pParams_prev != M4OSA_NULL )
                    {
                        pParams_prev->pNext = pParams_temp->pNext;
                    }
                    /* If current pointer is the first of the chained list and next pointer
                     of the chained list is NULL */
                    /* it means that there was only one element in the list */
                    /* => we put the context variable to NULL */
                    if( pParams_temp == xVSS_context->pMCSparamsList
                        && pParams_temp->pNext == M4OSA_NULL )
                    {
                        free(pParams_temp);
                        xVSS_context->pMCSparamsList = M4OSA_NULL;
                    }
                    /* In that case, BGM pointer is the first one, but there are others
                     elements after it */
                    /* So, we need to change first chained list element */
                    else if( pParams_temp->pNext != M4OSA_NULL )
                    {
                        xVSS_context->pMCSparamsList = pParams_temp->pNext;
                        free(pParams_temp);
                        pParams_temp = M4OSA_NULL;
                    }
                    /* In all other cases, nothing else to do except freeing the chained
                    list element */
                    else
                    {
                        free(pParams_temp);
                        pParams_temp = M4OSA_NULL;
                    }
                    break;
                }
                pParams_prev = pParams_temp;
                pParams_temp = pParams_temp->pNext;
            }

#endif /* PREVIEW_ENABLED */
            /* Here, we unallocate all BGM components and put xVSS_context->pSettings->
            xVSS.pBGMtrack to NULL */

            if( xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL )
            {
                if( xVSS_context->pSettings->xVSS.pBGMtrack->pFile
                    != M4OSA_NULL )
                {
                    free(xVSS_context->pSettings->xVSS.pBGMtrack->pFile);
                    xVSS_context->pSettings->xVSS.pBGMtrack->pFile = M4OSA_NULL;
                }
                free(xVSS_context->pSettings->xVSS.pBGMtrack);
                xVSS_context->pSettings->xVSS.pBGMtrack = M4OSA_NULL;
            }
        }
    }

    /* Changed to be able to mix with video only files -> in case no master clip is found
    (i.e only JPG input or video only input) */
    /* and if there is a BGM, we force the added volume to 100 (i.e replace audio) */

    if( masterClip == -1
        && xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL )
    {
        /* In that case, it means that no input 3GP file has a video track.
        Therefore, if a mixing is asked, it will fail. Thus, we force replace audio. */
        xVSS_context->pSettings->xVSS.pBGMtrack->uiAddVolume = 100;
    }

    /* Save clip number to know if a M4xVSS_sendCommand has already been called */
    xVSS_context->previousClipNumber = xVSS_context->pSettings->uiClipNumber;

    /* Change state */
    xVSS_context->m_state = M4xVSS_kStateAnalyzing;

    /* In case of MMS use case, we compute here the max video bitrate */
    /* In case of too low bitrate, a specific warning is returned */
    if( xVSS_context->pSettings->xVSS.outputFileSize != 0 && totalDuration > 0 )
    {
        M4OSA_UInt32 targetedBitrate = 0;
        M4VIDEOEDITING_ClipProperties fileProperties;
        M4OSA_Double ratio;

        if( xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL )
        {
            if( xVSS_context->pSettings->xVSS.pBGMtrack->uiAddVolume
                == 100 ) /* We are in "replace audio mode, need to check the filetype */
            {
                if( xVSS_context->pSettings->xVSS.pBGMtrack->FileType
                    == M4VIDEOEDITING_kFileType_3GPP )
                {
                    M4OSA_Void *pDecodedPath;
                    /**
                    * UTF conversion: convert into the customer format, before being used*/
                    pDecodedPath =
                        xVSS_context->pSettings->xVSS.pBGMtrack->pFile;
                    length = strlen(pDecodedPath);

                    if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                        != M4OSA_NULL && xVSS_context->
                        UTFConversionContext.pTempOutConversionBuffer
                        != M4OSA_NULL )
                    {
                        err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                            (M4OSA_Void *)xVSS_context->pSettings->
                            xVSS.pBGMtrack->pFile,
                            (M4OSA_Void *)xVSS_context->
                            UTFConversionContext.
                            pTempOutConversionBuffer, &length);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_1("M4xVSS_SendCommand: \
                                M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                                err);
                            /* Free Send command */
                            M4xVSS_freeCommand(xVSS_context);
                            return err;
                        }
                        pDecodedPath = xVSS_context->
                            UTFConversionContext.pTempOutConversionBuffer;
                    }

                    /**
                    * End of the UTF conversion, use the converted file path*/
                    err =
                        M4xVSS_internalGetProperties(xVSS_context, pDecodedPath,
                        &fileProperties);

                    /* Get the properties of the BGM track */
                    /*err = M4xVSS_internalGetProperties(xVSS_context, xVSS_context->pSettings->
                    xVSS.pBGMtrack->pFile, &fileProperties);*/
                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_sendCommand: M4xVSS_internalGetProperties returned an error:\
                             0x%x", err);
                        return err;
                    }

                    if( fileProperties.AudioStreamType
                        != M4VIDEOEDITING_kAMR_NB )
                    {
                        M4OSA_TRACE1_0(
                            "M4xVSS_sendCommand: Impossible to use MMS mode with BGM != AMR-NB");
                        return M4ERR_PARAMETER;
                    }
                }
                else if( xVSS_context->pSettings->xVSS.pBGMtrack->FileType
                    != M4VIDEOEDITING_kFileType_AMR
                    && xVSS_context->pSettings->xVSS.pBGMtrack->FileType
                    != M4VIDEOEDITING_kFileType_MP3 )
                {
                    M4OSA_TRACE1_0("M4xVSS_sendCommand: Bad input BGM file");
                    return M4ERR_PARAMETER;
                }
            }
        }

        /* Compute targeted bitrate, with 8% margin (moov) */
        if( totalDuration > 1000 )
        {
            targetedBitrate =
                (M4OSA_UInt32)(( xVSS_context->pSettings->xVSS.outputFileSize
                * 8 * 0.84) / (totalDuration / 1000));
        }
        else
        {
            targetedBitrate = 0;
        }

        /* Remove audio bitrate */
        if( targetedBitrate >= 12200 )
        {
            targetedBitrate -= 12200; /* Only AMR is supported in MMS case */
        }
        else
        {
            targetedBitrate = 0;
        }

        /* Compute an indicator of "complexity" depending on nb of sequences and total duration */
        /* The highest is the number of sequences, the more there are some I frames */
        /* In that case, it is necessary to reduce the target bitrate */
        ratio =
            (M4OSA_Double)((M4OSA_Double)(xVSS_context->pSettings->uiClipNumber
            * 100000) / (M4OSA_Double)(totalDuration));
        M4OSA_TRACE2_3(
            "Ratio clip_nb/duration = %f\nTargeted bitrate = %d\nTotal duration: %d",
            (M4OSA_Double)((M4OSA_Double)(xVSS_context->pSettings->uiClipNumber
            * 100000) / (M4OSA_Double)(totalDuration)),
            targetedBitrate, totalDuration);

        if( ratio > 50 && ratio <= 75 )
        {
            /* It means that there is a potential risk of having a higher file size
            than specified */
            targetedBitrate -= (M4OSA_UInt32)(targetedBitrate * 0.1);
            M4OSA_TRACE2_2(
                "New bitrate1 !!\nRatio clip_nb/duration = %f\nTargeted bitrate = %d",
                ratio, targetedBitrate);
        }
        else if( ratio > 75 )
        {
            targetedBitrate -= (M4OSA_UInt32)(targetedBitrate * 0.15);
            M4OSA_TRACE2_2(
                "New bitrate2 !!\nRatio clip_nb/duration = %f\nTargeted bitrate = %d",
                ratio, targetedBitrate);
        }

        /*CR 3283 MMS use case for VAL:
        Decrease the output file size to keep a margin of 5%
        The writer will stop when the targeted output file size will be reached*/
        xVSS_context->pSettings->xVSS.outputFileSize -=
            (M4OSA_UInt32)(xVSS_context->pSettings->xVSS.outputFileSize * 0.05);

        switch( xVSS_context->pSettings->xVSS.outputVideoSize )
        {
            case M4VIDEOEDITING_kSQCIF:
                if( targetedBitrate < 32000 )
                {
                    xVSS_context->targetedBitrate = 32000;
                    return M4VSS3GPP_WAR_OUTPUTFILESIZE_EXCEED;
                }
                break;

            case M4VIDEOEDITING_kQQVGA:
                if( targetedBitrate < 32000 )              /*48000)*/
                {
                    xVSS_context->targetedBitrate = 32000; /*48000;*/
                    return M4VSS3GPP_WAR_OUTPUTFILESIZE_EXCEED;
                }
                break;

            case M4VIDEOEDITING_kQCIF:
                if( targetedBitrate < 48000 )              /*64000)*/
                {
                    xVSS_context->targetedBitrate = 48000; /*64000;*/
                    return M4VSS3GPP_WAR_OUTPUTFILESIZE_EXCEED;
                }
                break;

            case M4VIDEOEDITING_kQVGA:
                if( targetedBitrate < 64000 )              /*128000)*/
                {
                    xVSS_context->targetedBitrate = 64000; /*128000;*/
                    return M4VSS3GPP_WAR_OUTPUTFILESIZE_EXCEED;
                }
                break;

            case M4VIDEOEDITING_kCIF:
                if( targetedBitrate < 128000 )
                {
                    xVSS_context->targetedBitrate = 128000;
                    return M4VSS3GPP_WAR_OUTPUTFILESIZE_EXCEED;
                }
                break;

            case M4VIDEOEDITING_kVGA:
                if( targetedBitrate < 192000 )
                {
                    xVSS_context->targetedBitrate = 192000;
                    return M4VSS3GPP_WAR_OUTPUTFILESIZE_EXCEED;
                }
                break;

            default:
                /* Cannot happen */
                M4OSA_TRACE1_0(
                    "M4xVSS_sendCommand: Error in output fileSize !");
                return M4ERR_PARAMETER;
                break;
        }
        xVSS_context->targetedBitrate = (M4OSA_UInt32)targetedBitrate;
    }

    if( bIsTranscoding )
    {
        return M4VSS3GPP_WAR_TRANSCODING_NECESSARY;
    }
    else
    {
        return M4NO_ERROR;
    }
}

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_SaveStart(M4OSA_Context pContext, M4OSA_Char* pFilePath)
 * @brief        This function prepare the save
 * @note        The xVSS create 3GP edited final file
 *                This function must be called once M4xVSS_Step has returned
 *                M4VSS3GPP_WAR_ANALYZING_DONE
 *                After this function, the user must call M4xVSS_Step until
 *                it returns another error than M4NO_ERROR.
 *
 * @param    pContext            (IN) Pointer on the xVSS edit context
 * @param    pFilePath            (IN) If the user wants to provide a different
 *                                output filename, else can be NULL (allocated by the user)
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_ALLOC:        Memory allocation has failed
 * @return    M4ERR_STATE:        This function cannot not be called at this time
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_SaveStart( M4OSA_Context pContext, M4OSA_Void *pFilePath,
                           M4OSA_UInt32 filePathSize )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4OSA_ERR err;

    /*Add for UTF conversion: copy the pSettings structure into a new pCurrentEditSettings*/
    M4VSS3GPP_EditSettings *pEditSavingSettings = M4OSA_NULL;
    M4OSA_UInt8 i, j;
    M4OSA_UInt32 offset = 0;
    M4OSA_UInt8 nbEffects = 0;
    /*only for UTF conversion support*/
    M4OSA_Void *pDecodedPath = M4OSA_NULL;
    M4OSA_UInt32 length = 0;
    /**/

    /* Check state */
    if( xVSS_context->m_state != M4xVSS_kStateOpened )
    {
        M4OSA_TRACE1_1(
            "Bad state when calling M4xVSS_SaveStart function! State is %d",
            xVSS_context->m_state);
        return M4ERR_STATE;
    }

    /* RC: to temporary handle changing of output filepath */
    /* TO BE CHANGED CLEANLY WITH A MALLOC/MEMCPY !!!! */
    if( pFilePath != M4OSA_NULL )
    {
        if( xVSS_context->pSettings->pOutputFile != M4OSA_NULL )
        {
            /*it means that pOutputFile has been allocated in M4xVSS_sendCommand()*/
            free(xVSS_context->pSettings->pOutputFile);
            xVSS_context->pSettings->pOutputFile = M4OSA_NULL;
            xVSS_context->pSettings->uiOutputPathSize = 0;
        }

        pDecodedPath = pFilePath;
        /*As all inputs of the xVSS are in UTF8, convert the output file path into the customer
         format*/
        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
            && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
            != M4OSA_NULL )
        {
            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                (M4OSA_Void *)pFilePath, (M4OSA_Void *)xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer, &length);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4xVSS_SaveStart: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                    err);
                return err;
            }
            pDecodedPath =
                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
            filePathSize = length;
        }

        xVSS_context->pOutputFile =
            (M4OSA_Void *)M4OSA_32bitAlignedMalloc(filePathSize + 1, M4VS,
            (M4OSA_Char *)"M4xVSS_SaveStart: output file");

        if( xVSS_context->pOutputFile == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");
            return M4ERR_ALLOC;
        }
        memcpy((void *)xVSS_context->pOutputFile, (void *)pDecodedPath, filePathSize + 1);
        xVSS_context->pOutputFile[filePathSize] = '\0';
        xVSS_context->pSettings->pOutputFile = xVSS_context->pOutputFile;
        xVSS_context->pSettings->uiOutputPathSize = filePathSize;
    }

    /**
    ***/

    /*FB: Add for UTF conversion: copy the pSettings structure into a new pCurrentEditSettings*/
    /*It is the same principle as in the PreviewStart()*/
    pEditSavingSettings =
        (M4VSS3GPP_EditSettings *)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_EditSettings),
        M4VS, (M4OSA_Char *)"Saving, copy of VSS structure");

    if( pEditSavingSettings == M4OSA_NULL )
    {
        M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

        if( xVSS_context->pOutputFile != M4OSA_NULL )
        {
            free(xVSS_context->pOutputFile);
            xVSS_context->pOutputFile = M4OSA_NULL;
        }
        return M4ERR_ALLOC;
    }

    /* Copy settings from input structure */
    memcpy((void *) &(pEditSavingSettings->xVSS),
        (void *) &(xVSS_context->pSettings->xVSS),
        sizeof(M4xVSS_EditSettings));

    /* Initialize pEditSavingSettings structure */
    pEditSavingSettings->xVSS.pBGMtrack = M4OSA_NULL;

    pEditSavingSettings->videoFrameRate =
        xVSS_context->pSettings->videoFrameRate;
    pEditSavingSettings->uiClipNumber = xVSS_context->pSettings->uiClipNumber;
    pEditSavingSettings->uiMasterClip =
        xVSS_context->pSettings->uiMasterClip; /* VSS2.0 mandatory parameter */

    /* Allocate savingSettings.pClipList/pTransitions structure */
    pEditSavingSettings->pClipList = (M4VSS3GPP_ClipSettings *
        * )M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_ClipSettings *)
        *pEditSavingSettings->uiClipNumber,
        M4VS, (M4OSA_Char *)"xVSS, saving , copy of pClipList");

    if( pEditSavingSettings->pClipList == M4OSA_NULL )
    {
        M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

        if( xVSS_context->pOutputFile != M4OSA_NULL )
        {
            free(xVSS_context->pOutputFile);
            xVSS_context->pOutputFile = M4OSA_NULL;
        }
        return M4ERR_ALLOC;
    }

    if( pEditSavingSettings->uiClipNumber > 1 )
    {
        pEditSavingSettings->pTransitionList = (M4VSS3GPP_TransitionSettings *
            * )M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_TransitionSettings *)
            *(pEditSavingSettings->uiClipNumber - 1),
            M4VS, (M4OSA_Char *)"xVSS, saving, copy of pTransitionList");

        if( pEditSavingSettings->pTransitionList == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

            if( xVSS_context->pOutputFile != M4OSA_NULL )
            {
                free(xVSS_context->pOutputFile);
                xVSS_context->pOutputFile = M4OSA_NULL;
            }
            return M4ERR_ALLOC;
        }
    }
    else
    {
        pEditSavingSettings->pTransitionList = M4OSA_NULL;
    }

    for ( i = 0; i < pEditSavingSettings->uiClipNumber; i++ )
    {
        pEditSavingSettings->pClipList[i] = (M4VSS3GPP_ClipSettings
            *)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_ClipSettings),
            M4VS, (M4OSA_Char *)"saving clip settings");

        if( pEditSavingSettings->pClipList[i] == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

            if( xVSS_context->pOutputFile != M4OSA_NULL )
            {
                free(xVSS_context->pOutputFile);
                xVSS_context->pOutputFile = M4OSA_NULL;
            }
            return M4ERR_ALLOC;
        }

        if( i < pEditSavingSettings->uiClipNumber
            - 1 ) /* Because there is 1 less transition than clip number */
        {
            pEditSavingSettings->pTransitionList[i] =
                (M4VSS3GPP_TransitionSettings
                *)M4OSA_32bitAlignedMalloc(sizeof(M4VSS3GPP_TransitionSettings),
                M4VS, (M4OSA_Char *)"saving transition settings");

            if( pEditSavingSettings->pTransitionList[i] == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

                if( xVSS_context->pOutputFile != M4OSA_NULL )
                {
                    free(xVSS_context->pOutputFile);
                    xVSS_context->pOutputFile = M4OSA_NULL;
                }
                return M4ERR_ALLOC;
            }
        }
    }

    for ( i = 0; i < xVSS_context->pSettings->uiClipNumber; i++ )
    {
        // Add MP4 file support

        if( ( xVSS_context->pSettings->pClipList[i]->FileType
            == M4VIDEOEDITING_kFileType_3GPP)
            || (xVSS_context->pSettings->pClipList[i]->FileType
            == M4VIDEOEDITING_kFileType_MP4)
            || (xVSS_context->pSettings->pClipList[i]->FileType
            == M4VIDEOEDITING_kFileType_M4V)
            || (xVSS_context->pSettings->pClipList[i]->FileType
            == M4VIDEOEDITING_kFileType_ARGB8888))

        {
            /* Copy data from given structure to our saving structure */
            M4xVSS_DuplicateClipSettings(pEditSavingSettings->pClipList[i],
                xVSS_context->pSettings->pClipList[i],
                M4OSA_FALSE /* remove effects */);

            /**
            * UTF conversion: convert into the customer format, before being used*/
            pDecodedPath = pEditSavingSettings->pClipList[i]->pFile;
            length = strlen(pDecodedPath);

            if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct
                != M4OSA_NULL && xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer
                != M4OSA_NULL )
            {
                err =
                    M4xVSS_internalConvertFromUTF8(xVSS_context, (M4OSA_Void
                    *)pEditSavingSettings->pClipList[i]->pFile,
                    (M4OSA_Void *)xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer,
                    &length);

                if( err != M4NO_ERROR )
                {
                    M4OSA_TRACE1_1(
                        "M4xVSS_SaveStart: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                        err);

                    if( xVSS_context->pOutputFile != M4OSA_NULL )
                    {
                        free(xVSS_context->pOutputFile);
                        xVSS_context->pOutputFile = M4OSA_NULL;
                    }
                    return err;
                }
                pDecodedPath = xVSS_context->
                    UTFConversionContext.pTempOutConversionBuffer;

                /**
                * End of the UTF conversion, use the converted file path*/
                free(
                    pEditSavingSettings->pClipList[i]->pFile);
                pEditSavingSettings->pClipList[i]->pFile = (M4OSA_Void
                    *)M4OSA_32bitAlignedMalloc((length + 1),
                    M4VS, (M4OSA_Char *)"saving transition settings");

                if( pEditSavingSettings->pClipList[i]->pFile == M4OSA_NULL )
                {
                    M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

                    if( xVSS_context->pOutputFile != M4OSA_NULL )
                    {
                        free(xVSS_context->pOutputFile);
                        xVSS_context->pOutputFile = M4OSA_NULL;
                    }
                    return M4ERR_ALLOC;
                }
                memcpy((void *)pEditSavingSettings->pClipList[i]->pFile,
                    (void *)pDecodedPath, length + 1);
            }
            /*FB: add file path size because of UTF 16 conversion*/
            pEditSavingSettings->pClipList[i]->filePathSize = length+1;

            if( i
                < xVSS_context->pSettings->uiClipNumber
                - 1 ) /* Because there is 1 less transition than clip number */
            {
                memcpy(
                    (void *)pEditSavingSettings->pTransitionList[i],
                    (void *)xVSS_context->pSettings->
                    pTransitionList[i],
                    sizeof(M4VSS3GPP_TransitionSettings));
            }
        }
        else
        {
            M4OSA_TRACE1_0(
                "M4xVSS_SaveStart: Error when parsing xVSS_context->pSettings->pClipList[i]:\
                 Bad file type");

            if( xVSS_context->pOutputFile != M4OSA_NULL )
            {
                free(xVSS_context->pOutputFile);
                xVSS_context->pOutputFile = M4OSA_NULL;
            }
            return M4ERR_PARAMETER;
        }
    }

    /* Count the number of video effects, used to know how much memory is needed to allocate*/
    /* FB 2008/10/15: removed : not compatible with M4VSS3GPP_kVideoEffectType_None
    for(j=0;j<xVSS_context->pSettings->nbEffects;j++)
    {
    if(xVSS_context->pSettings->Effects[j].VideoEffectType != M4VSS3GPP_kVideoEffectType_None)
    {
    nbEffects++;
    }
    }*/
    nbEffects = xVSS_context->pSettings->nbEffects;

    /* Allocate effects saving structure with correct number of effects */
    if( nbEffects != 0 )
    {
        pEditSavingSettings->Effects =
            (M4VSS3GPP_EffectSettings *)M4OSA_32bitAlignedMalloc(nbEffects
            * sizeof(M4VSS3GPP_EffectSettings), M4VS, (M4OSA_Char
            *)"Saving settings, effects table of structure settings");

        if( pEditSavingSettings->Effects == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

            if( xVSS_context->pOutputFile != M4OSA_NULL )
            {
                free(xVSS_context->pOutputFile);
                xVSS_context->pOutputFile = M4OSA_NULL;
            }
            return M4ERR_ALLOC;
        }

        /* Just copy effect structure to saving structure, as effects time are now */
        /* relative to output clip time*/
        memcpy((void *)pEditSavingSettings->Effects,
            (void *)xVSS_context->pSettings->Effects,
            nbEffects * sizeof(M4VSS3GPP_EffectSettings));
    }
    else
    {
        pEditSavingSettings->Effects = M4OSA_NULL;
        pEditSavingSettings->nbEffects = 0;
    }
    pEditSavingSettings->nbEffects = nbEffects;

    if( pFilePath != M4OSA_NULL )
    {
        pEditSavingSettings->pOutputFile = pFilePath;
    }

    /* Save pointer of saving video editor to use in step function */
    xVSS_context->pCurrentEditSettings = pEditSavingSettings;

    /* Change output file name to temporary output file name, because final file will be
     generated by audio mixer */
    if( xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL )
    {

        M4OSA_Char out_3gp[M4XVSS_MAX_PATH_LEN];
        M4OSA_Char out_3gp_tmp[M4XVSS_MAX_PATH_LEN];

        /**/
        pEditSavingSettings->xVSS.pBGMtrack =
            (M4xVSS_BGMSettings *)M4OSA_32bitAlignedMalloc(sizeof(M4xVSS_BGMSettings), M4VS,
            (M4OSA_Char
            *)"Saving settings, effects table of structure settings");

        if( pEditSavingSettings->xVSS.pBGMtrack == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

            if( xVSS_context->pOutputFile != M4OSA_NULL )
            {
                free(xVSS_context->pOutputFile);
                xVSS_context->pOutputFile = M4OSA_NULL;
            }
            return M4ERR_ALLOC;
        }

        /* Just copy effect structure to saving structure, as effects time are now */
        /* relative to output clip time*/
        memcpy((void *)pEditSavingSettings->xVSS.pBGMtrack,
            (void *)xVSS_context->pSettings->xVSS.pBGMtrack,
            sizeof(M4xVSS_BGMSettings));

        /* Allocate file name, and copy file name buffer to our structure */
        pEditSavingSettings->xVSS.pBGMtrack->pFile = M4OSA_32bitAlignedMalloc(
            (strlen(xVSS_context->pSettings->xVSS.pBGMtrack->pFile)
            + 1),
            M4VS, (M4OSA_Char *)"Saving struct xVSS BGM file path");

        if( pEditSavingSettings->xVSS.pBGMtrack->pFile == M4OSA_NULL )
        {
            M4xVSS_freeCommand(xVSS_context);
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

            if( xVSS_context->pOutputFile != M4OSA_NULL )
            {
                free(xVSS_context->pOutputFile);
                xVSS_context->pOutputFile = M4OSA_NULL;
            }
            return M4ERR_ALLOC;
        }
        memcpy((void *)pEditSavingSettings->xVSS.pBGMtrack->pFile,
            (void *)xVSS_context->pSettings->xVSS.pBGMtrack->pFile,
            strlen(xVSS_context->pSettings->xVSS.pBGMtrack->pFile)
            + 1);

        /*Copy BGM track file path*/

        /**
        * UTF conversion*/
        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
            && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
            != M4OSA_NULL )
        {
            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                (M4OSA_Void *)pEditSavingSettings->xVSS.pBGMtrack->pFile,
                (M4OSA_Void *)xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer, &length);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4xVSS_SaveStart: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                    err);

                if( xVSS_context->pOutputFile != M4OSA_NULL )
                {
                    free(xVSS_context->pOutputFile);
                    xVSS_context->pOutputFile = M4OSA_NULL;
                }
                return err;
            }
            pDecodedPath =
                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;

            free(pEditSavingSettings->xVSS.pBGMtrack->pFile);
            pEditSavingSettings->xVSS.pBGMtrack->pFile =
                (M4OSA_Void *)M4OSA_32bitAlignedMalloc(length + 1, M4VS, (M4OSA_Char
                *)"M4xVSS_SaveStart: Temp filename in case of BGM");

            if( pEditSavingSettings->xVSS.pBGMtrack->pFile == M4OSA_NULL )
            {
                M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

                if( xVSS_context->pOutputFile != M4OSA_NULL )
                {
                    free(xVSS_context->pOutputFile);
                    xVSS_context->pOutputFile = M4OSA_NULL;
                }
                return M4ERR_ALLOC;
            }
            memcpy((void *)pEditSavingSettings->xVSS.pBGMtrack->pFile,
                (void *)pDecodedPath, length + 1);
        }

        /**/

        M4OSA_chrNCopy(out_3gp, xVSS_context->pTempPath, M4XVSS_MAX_PATH_LEN - 1);
        M4OSA_chrNCopy(out_3gp_tmp, xVSS_context->pTempPath, M4XVSS_MAX_PATH_LEN - 1);

        /* Construct output temporary 3GP filename */
        strncat((char *)out_3gp, (const char *)"savetemp.3gp\0", 13);
        strncat((char *)out_3gp_tmp, (const char *)"savetemp.tmp\0", 13);

        /**
        * UTF conversion: convert into the customer format, before being used*/
        pDecodedPath = out_3gp;
        length = strlen(pDecodedPath);

        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
            && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
            != M4OSA_NULL )
        {
            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                (M4OSA_Void *)out_3gp, (M4OSA_Void *)xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer, &length);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4xVSS_SaveStart: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                    err);

                if( xVSS_context->pOutputFile != M4OSA_NULL )
                {
                    free(xVSS_context->pOutputFile);
                    xVSS_context->pOutputFile = M4OSA_NULL;
                }
                return err;
            }
            pDecodedPath =
                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
        }

        /**
        * End of the UTF conversion, use the converted file path*/
        xVSS_context->pCurrentEditSettings->pOutputFile =
            (M4OSA_Void *)M4OSA_32bitAlignedMalloc(length + 1, M4VS,
            (M4OSA_Char *)"M4xVSS_SaveStart: Temp filename in case of BGM");

        if( xVSS_context->pCurrentEditSettings->pOutputFile == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

            if( xVSS_context->pOutputFile != M4OSA_NULL )
            {
                free(xVSS_context->pOutputFile);
                xVSS_context->pOutputFile = M4OSA_NULL;
            }
            return M4ERR_ALLOC;
        }
        memcpy((void *)xVSS_context->pCurrentEditSettings->pOutputFile,
            (void *)pDecodedPath, length + 1);
        xVSS_context->pCurrentEditSettings->uiOutputPathSize = length + 1;

        /**
        * UTF conversion: convert into the customer format, before being used*/
        pDecodedPath = out_3gp_tmp;
        length = strlen(pDecodedPath);

        if( xVSS_context->UTFConversionContext.pConvFromUTF8Fct != M4OSA_NULL
            && xVSS_context->UTFConversionContext.pTempOutConversionBuffer
            != M4OSA_NULL )
        {
            err = M4xVSS_internalConvertFromUTF8(xVSS_context,
                (M4OSA_Void *)out_3gp_tmp, (M4OSA_Void *)xVSS_context->
                UTFConversionContext.pTempOutConversionBuffer, &length);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4xVSS_SaveStart: M4xVSS_internalConvertFromUTF8 returns err: 0x%x",
                    err);

                if( xVSS_context->pOutputFile != M4OSA_NULL )
                {
                    free(xVSS_context->pOutputFile);
                    xVSS_context->pOutputFile = M4OSA_NULL;
                }
                return err;
            }
            pDecodedPath =
                xVSS_context->UTFConversionContext.pTempOutConversionBuffer;
        }

        /**
        * End of the UTF conversion, use the converted file path*/
        xVSS_context->pCurrentEditSettings->pTemporaryFile =
            (M4OSA_Void *)M4OSA_32bitAlignedMalloc(length + 1, M4VS,
            (M4OSA_Char *)"M4xVSS_SaveStart: Temporary file");

        if( xVSS_context->pCurrentEditSettings->pTemporaryFile == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("Allocation error in M4xVSS_SaveStart");

            if( xVSS_context->pOutputFile != M4OSA_NULL )
            {
                free(xVSS_context->pOutputFile);
                xVSS_context->pOutputFile = M4OSA_NULL;
            }
            return M4ERR_ALLOC;
        }
        memcpy((void *)xVSS_context->pCurrentEditSettings->pTemporaryFile,
            (void *)pDecodedPath, length + 1);

        /* Put nb of step for progression monitoring to 2, because audio mixing is needed */
        xVSS_context->nbStepTotal = 2;
    }
    else
    {
        xVSS_context->pCurrentEditSettings->pOutputFile =
            xVSS_context->pOutputFile;
        xVSS_context->pCurrentEditSettings->pTemporaryFile = M4OSA_NULL;

        /* Put nb of step for progression monitoring to 1, because no audio mixing is needed */
        xVSS_context->nbStepTotal = 1;
    }

    /**
    ***/

    err = M4xVSS_internalGenerateEditedFile(xVSS_context);

    if( err != M4NO_ERROR )
    {
        M4OSA_TRACE1_1(
            "M4xVSS_SaveStart: M4xVSS_internalGenerateEditedFile returned an error: 0x%x",
            err);

        /**/
        if( xVSS_context->pCurrentEditSettings->pOutputFile != M4OSA_NULL
            && xVSS_context->pSettings->xVSS.pBGMtrack == M4OSA_NULL )
        {
            free(xVSS_context->pCurrentEditSettings->
                pOutputFile);
            xVSS_context->pCurrentEditSettings->pOutputFile = M4OSA_NULL;
            xVSS_context->pOutputFile = M4OSA_NULL;
        }

        if( xVSS_context->pCurrentEditSettings->pTemporaryFile != M4OSA_NULL
            && xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL )
        {
            free(xVSS_context->pCurrentEditSettings->
                pTemporaryFile);
            xVSS_context->pCurrentEditSettings->pTemporaryFile = M4OSA_NULL;
        }

        if( xVSS_context->pOutputFile != M4OSA_NULL )
        {
            free(xVSS_context->pOutputFile);
            xVSS_context->pOutputFile = M4OSA_NULL;
        }
        /* TODO: Translate error code of VSS to an xVSS error code */
        return err;
    }

    /* Reinitialize current step number for progression monitoring */
    xVSS_context->currentStep = 0;

    /* Change xVSS state */
    xVSS_context->m_state = M4xVSS_kStateSaving;

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_SaveStop(M4OSA_Context pContext)
 * @brief        This function unallocate save ressources and change xVSS
 *                internal state.
 * @note        This function must be called once M4xVSS_Step has returned
 *                M4VSS3GPP_WAR_SAVING_DONE
 *
 * @param    pContext            (IN) Pointer on the xVSS edit context
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_STATE:        This function cannot not be called at this time
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_SaveStop( M4OSA_Context pContext )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4OSA_ERR err = M4NO_ERROR;

    /* Check state */
    if( xVSS_context->m_state != M4xVSS_kStateSaving )
    {
        M4OSA_TRACE1_1(
            "Bad state when calling M4xVSS_SaveStop function! State is %d",
            xVSS_context->m_state);
        return M4ERR_STATE;
    }

    /* Free saving structures */
    M4xVSS_internalFreeSaving(xVSS_context);

    if( xVSS_context->pOutputFile != M4OSA_NULL )
    {
        free(xVSS_context->pOutputFile);
        xVSS_context->pOutputFile = M4OSA_NULL;
    }

    /* Change xVSS state */
    xVSS_context->m_state = M4xVSS_kStateSaved;

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_Step(M4OSA_Context pContext, M4OSA_UInt8 *pProgress)
 * @brief        This function executes differents tasks, depending of xVSS
 *                internal state.
 * @note        This function:
 *                    - analyses editing structure if called after M4xVSS_SendCommand
 *                    - generates preview file if called after M4xVSS_PreviewStart
 *                    - generates final edited file if called after M4xVSS_SaveStart
 *
 * @param    pContext                        (IN) Pointer on the xVSS edit context
 * @param    pProgress                        (IN/OUT) Pointer on an integer giving a
 *                                            progress indication (between 0-100)
 * @return    M4NO_ERROR:                        No error, the user must call M4xVSS_Step again
 * @return    M4ERR_PARAMETER:                At least one parameter is M4OSA_NULL
 * @return    M4ERR_STATE:                    This function cannot not be called at this time
 * @return    M4VSS3GPP_WAR_PREVIEW_READY:    Preview file is generated
 * @return    M4VSS3GPP_WAR_SAVING_DONE:        Final edited file is generated
 * @return    M4VSS3GPP_WAR_ANALYZING_DONE:    Analyse is done
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_Step( M4OSA_Context pContext, M4OSA_UInt8 *pProgress )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4VSS3GPP_EditContext pVssCtxt = xVSS_context->pCurrentEditContext;
    M4VSS3GPP_AudioMixingContext pAudioMixingCtxt =
        xVSS_context->pAudioMixContext;
    M4OSA_ERR err = M4NO_ERROR;
    M4OSA_UInt8 uiProgress = 0;

    switch( xVSS_context->m_state )
    {
        case M4xVSS_kStateSaving:
        //case M4xVSS_kStateGeneratingPreview:
            {
                if( xVSS_context->editingStep
                    == M4xVSS_kMicroStateEditing ) /* VSS -> creating effects, transitions ... */
                {
                    /* RC: to delete unecessary temp files on the fly */
                    M4VSS3GPP_InternalEditContext *pVSSContext =
                        (M4VSS3GPP_InternalEditContext *)pVssCtxt;

                    err = M4VSS3GPP_editStep(pVssCtxt, &uiProgress);

                    if( ( err != M4NO_ERROR) && (err != M4VSS3GPP_WAR_EDITING_DONE)
                        && (err != M4VSS3GPP_WAR_SWITCH_CLIP) )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_Step: M4VSS3GPP_editStep returned 0x%x\n", err);
                        M4VSS3GPP_editCleanUp(pVssCtxt);
                        /* TODO ? : Translate error code of VSS to an xVSS error code ? */
                        xVSS_context->pCurrentEditContext = M4OSA_NULL;
                        return err;
                    }

                    /* RC: to delete unecessary temp files on the fly */
                    if( err == M4VSS3GPP_WAR_SWITCH_CLIP )
                    {
#ifndef DO_NOT_REMOVE_TEMP_FILES
                        /* It means we can delete the temporary file */
                        /* First step, check the temp file is not use somewhere else after */

                        M4OSA_UInt32 i;
                        M4OSA_Int32 cmpResult = -1;

                        for ( i = pVSSContext->uiCurrentClip;
                            i < pVSSContext->uiClipNumber; i++ )
                        {
                            if( pVSSContext->pClipList[pVSSContext->uiCurrentClip
                                - 1].filePathSize
                                == pVSSContext->pClipList[i].filePathSize )
                            {
                                cmpResult = memcmp((void *)pVSSContext->
                                    pClipList[pVSSContext->uiCurrentClip
                                    - 1].pFile, (void *)pVSSContext->pClipList[i].pFile,
                                    pVSSContext->
                                    pClipList[pVSSContext->uiCurrentClip
                                    - 1].filePathSize);

                                if( cmpResult == 0 )
                                {
                                    /* It means we found a corresponding file, we do not delete
                                    this temporary file */
                                    break;
                                }
                            }
                        }

                        if( cmpResult != 0 )
                        {
                            M4OSA_UInt32 ConvertedSize = 0;
                            M4OSA_Char *toto;
                            M4OSA_Char *pTmpStr;

                            /* Convert result in UTF8 to check if we can delete it or not */
                            if( xVSS_context->UTFConversionContext.pConvToUTF8Fct
                                != M4OSA_NULL && xVSS_context->
                                UTFConversionContext.
                                pTempOutConversionBuffer != M4OSA_NULL )
                            {
                                M4xVSS_internalConvertToUTF8(xVSS_context,
                                    (M4OSA_Void *)pVSSContext->
                                    pClipList[pVSSContext->uiCurrentClip
                                    - 1].pFile, (M4OSA_Void *)xVSS_context->
                                    UTFConversionContext.
                                    pTempOutConversionBuffer, &ConvertedSize);
                                toto = (M4OSA_Char *)strstr((const char *)xVSS_context->
                                    UTFConversionContext.
                                    pTempOutConversionBuffer,
                                    (const char *)xVSS_context->pTempPath);
                                pTmpStr =
                                    xVSS_context->UTFConversionContext.
                                    pTempOutConversionBuffer;
                            }
                            else
                            {
                                toto = (M4OSA_Char *)strstr((const char *)pVSSContext->
                                    pClipList[pVSSContext->uiCurrentClip
                                    - 1].pFile, (const char *)xVSS_context->pTempPath);
                                pTmpStr = pVSSContext->
                                    pClipList[pVSSContext->uiCurrentClip
                                    - 1].pFile;
                            }

                            if( toto != M4OSA_NULL )
                            {
                                /* As temporary files can be imgXXX.3gp or vidXXX.3gp */
                                pTmpStr +=
                                    (strlen((const char *)pTmpStr)
                                    - 10); /* Because temporary files have a length at most of
                                    10 bytes */
                                toto = (M4OSA_Char *)strstr((const char *)pTmpStr,
                                    (const char *)"img");

                                if( toto != M4OSA_NULL )
                                {
                                    toto = (M4OSA_Char *)strstr((const char *)pTmpStr,
                                        (const char *)"vid");
                                }

                                if( err
                                    == M4NO_ERROR ) /* It means the file is a temporary file, we
                                    can delete it */
                                {
                                    remove((const char *)pVSSContext->
                                        pClipList[pVSSContext->uiCurrentClip
                                        - 1].pFile);
                                }
                            }
                        }

#endif /* DO_NOT_REMOVE_TEMP_FILES*/
                        /* */

                        err = M4NO_ERROR;
                    }

                    if( err == M4VSS3GPP_WAR_EDITING_DONE )
                    {
                        xVSS_context->currentStep++;
                        /* P4ME00003276: When a step is complete, increment currentStep and reset
                        uiProgress unless progress would be wrong */
                        uiProgress = 0;
                        err = M4xVSS_internalCloseEditedFile(xVSS_context);
                        /* Fix for  blrnxpsw#234---> */
                        if( err != M4NO_ERROR )
                        {
                            if( err == ((M4OSA_UInt32)M4ERR_FILE_INVALID_POSITION) )
                            {
                                err = M4xVSSERR_NO_MORE_SPACE;
                            }
                            M4OSA_TRACE1_1(
                                "M4xVSS_internalCloseEditedFile returned an error: 0x%x",
                                err);
                            return err;
                        }
                        /*<---- Fix for  blrnxpsw#234 */
                        if( xVSS_context->pCurrentEditSettings->xVSS.pBGMtrack
                            != M4OSA_NULL )
                        {
                            xVSS_context->editingStep =
                                M4xVSS_kMicroStateAudioMixing;
                            /* Open Audio mixing component */
                            err = M4xVSS_internalGenerateAudioMixFile(xVSS_context);

                            if( err != M4NO_ERROR )
                            {
                                M4OSA_TRACE1_1(
                                    "M4xVSS_internalGenerateAudioMixFile returned an error: 0x%x",
                                    err);
                                /* TODO ? : Translate error code of VSS to an xVSS error code */
                                return err;
                            }
                            err = M4NO_ERROR;
                            goto end_step;
                        }
                        else
                        {

                            err = M4VSS3GPP_WAR_SAVING_DONE;
                            goto end_step;

                        }
                    }
                }
                else if( xVSS_context->editingStep
                    == M4xVSS_kMicroStateAudioMixing ) /* Audio mixing: mix/replace audio track
                    with given BGM */
                {
                    err = M4VSS3GPP_audioMixingStep(pAudioMixingCtxt, &uiProgress);

                    if( ( err != M4NO_ERROR)
                        && (err != M4VSS3GPP_WAR_END_OF_AUDIO_MIXING) )
                    {
                        M4OSA_TRACE1_1(
                            "M4VSS3GPP_audioMixingMain: M4VSS3GPP_audioMixingStep returned 0x%x\n",
                            err);
                        /* TODO ? : Translate error code of VSS to an xVSS error code */
                        return err;
                    }

                    if( err == M4VSS3GPP_WAR_END_OF_AUDIO_MIXING )
                    {
                        xVSS_context->currentStep++;
                        /* P4ME00003276: When a step is complete, increment currentStep and reset
                        uiProgress unless progress would be wrong */
                        uiProgress = 0;
                        err = M4xVSS_internalCloseAudioMixedFile(xVSS_context);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_1(
                                "M4xVSS_internalCloseAudioMixedFile returned an error: 0x%x",
                                err);
                            /* TODO ? : Translate error code of VSS to an xVSS error code */
                            return err;
                        }

                            err = M4VSS3GPP_WAR_SAVING_DONE;
                            goto end_step;

                    }
                }
                else
                {
                    M4OSA_TRACE1_0("Bad state in step function !");
                    return M4ERR_STATE;
                }
            }
            break;

        case M4xVSS_kStateAnalyzing:
            {
                if( xVSS_context->analyseStep
                    == M4xVSS_kMicroStateAnalysePto3GPP ) /* Pto3GPP, analysing input parameters */
                {
                    if( xVSS_context->pPTo3GPPcurrentParams == M4OSA_NULL
                        && xVSS_context->pPTo3GPPparamsList != M4OSA_NULL )
                    {
                        xVSS_context->pPTo3GPPcurrentParams =
                            xVSS_context->
                            pPTo3GPPparamsList; /* Current Pto3GPP Parameter is the first element
                            of the list */
                    }
                    else if( xVSS_context->pPTo3GPPcurrentParams != M4OSA_NULL
                        && xVSS_context->pPTo3GPPparamsList != M4OSA_NULL )
                    {
                        xVSS_context->pPTo3GPPcurrentParams =
                            xVSS_context->pPTo3GPPcurrentParams->
                            pNext; /* Current Pto3GPP Parameter is the next element of the list */

                        if( xVSS_context->pPTo3GPPcurrentParams
                            == M4OSA_NULL ) /* It means there is no next image to convert */
                        {
                            /* We step to MCS phase */
                            xVSS_context->analyseStep =
                                M4xVSS_kMicroStateAnalyzeMCS;
                            err = M4NO_ERROR;
                            goto end_step;
                        }
                    }
                    else if( xVSS_context->pPTo3GPPparamsList == M4OSA_NULL )
                    {
                        xVSS_context->analyseStep =
                            M4xVSS_kMicroStateAnalyzeMCS; /* Change Analyzing micro state to
                             MCS phase */
                        err = M4NO_ERROR;
                        goto end_step;
                    }

                    /* Check if this file has to be converted or not */
                    /* If not, we just return M4NO_ERROR, and go to next file */
                    if( xVSS_context->pPTo3GPPcurrentParams->isCreated
                        == M4OSA_FALSE )
                    {
                        /* Opening Pto3GPP */
                        err = M4xVSS_internalStartConvertPictureTo3gp(xVSS_context);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_1("M4xVSS_Step: M4xVSS_internalStartConvertPictureTo3gp \
                            returned error: 0x%x",
                                err)
                                /* TODO ? : Translate error code of VSS to an xVSS error code */
                                return err;
                        }
                        xVSS_context->analyseStep =
                            M4xVSS_kMicroStateConvertPto3GPP;
                    }
                }
                else if( xVSS_context->analyseStep
                    == M4xVSS_kMicroStateConvertPto3GPP ) /* Pto3GPP, converting */
                {
                    err = M4PTO3GPP_Step(xVSS_context->pM4PTO3GPP_Ctxt);
                    /* update progress bar */
                    if(xVSS_context->pCallBackCtxt->m_NbImage > 1)
                    {
                        uiProgress = (xVSS_context->pCallBackCtxt->m_ImageCounter * 100) / (xVSS_context->pCallBackCtxt->m_NbImage -1);
                    }

                    if( ( err != M4NO_ERROR) && (err
                        != ((M4OSA_UInt32)M4PTO3GPP_WAR_END_OF_PROCESSING)) )
                    {
                        /* TO BE CHECKED NO LEAKS  !!!!! */
                        M4OSA_TRACE1_1(
                            "M4xVSS_Step: M4PTO3GPP_Step returned 0x%x\n", err);
                        /* TODO ? : Translate error code of VSS to an xVSS error code */
                        return err;
                    }
                    else if( err
                        == ((M4OSA_UInt32)M4PTO3GPP_WAR_END_OF_PROCESSING) )
                    {
                        xVSS_context->currentStep++;
                        /* P4ME00003276: When a step is complete, increment currentStep and reset
                         uiProgress unless progress would be wrong */
                        uiProgress = 0;
                        xVSS_context->analyseStep =
                            M4xVSS_kMicroStateAnalysePto3GPP; /* We go back to analyze parameters
                            to see if there is a next file to convert */
                        /* RC !!!!!!!! */
                        xVSS_context->pPTo3GPPcurrentParams->isCreated =
                            M4OSA_TRUE; /* To avoid reconverting it if another SendCommand is
                            called */
                        err = M4xVSS_internalStopConvertPictureTo3gp(xVSS_context);
                        /*SS:blrnxpsw#  234 */
                        if( err == ((M4OSA_UInt32)M4ERR_FILE_INVALID_POSITION) )
                        {
                            err = M4xVSSERR_NO_MORE_SPACE;
                        }

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_1("M4xVSS_Step:\
                                           M4xVSS_internalStopConvertPictureTo3gp returned 0x%x",
                                            err);
                            /* TODO ? : Translate error code of VSS to an xVSS error code */
                            return err;
                        }
                    }
                }
                else if( xVSS_context->analyseStep
                    ==
                    M4xVSS_kMicroStateAnalyzeMCS ) /* MCS: analyzing input parameters */
                {
                    if( xVSS_context->pMCScurrentParams == M4OSA_NULL \
                        && xVSS_context->pMCSparamsList != M4OSA_NULL )
                    {
                        xVSS_context->pMCScurrentParams = xVSS_context->
                            pMCSparamsList; /* Current MCS Parameter is the first
                                            element of the list */
                    }
                    else if( xVSS_context->pMCScurrentParams != M4OSA_NULL \
                        && xVSS_context->pMCSparamsList != M4OSA_NULL )
                    {
                        xVSS_context->pMCScurrentParams =
                            xVSS_context->pMCScurrentParams->
                            pNext; /* Current MCS Parameter
                                   is the next element of the list */

                        if( xVSS_context->pMCScurrentParams == M4OSA_NULL )
                            /* It means there is no next image to convert */
                        {
                            xVSS_context->analyseStep =
                                M4xVSS_kMicroStateAnalysePto3GPP; /* Reinit Analyzing micro state */
                            xVSS_context->m_state =
                                M4xVSS_kStateOpened; /* Change xVSS state */
                            err = M4VSS3GPP_WAR_ANALYZING_DONE;
                            goto end_step; /* End of Analysis */
                        }
                    }
                    else if( xVSS_context->pMCSparamsList == M4OSA_NULL )
                    {
                        xVSS_context->analyseStep =
                            M4xVSS_kMicroStateAnalysePto3GPP; /* Reinit Analyzing micro state */
                        xVSS_context->m_state =
                            M4xVSS_kStateOpened; /* Change xVSS state */
                        err = M4VSS3GPP_WAR_ANALYZING_DONE;
                        goto end_step;                        /* End of Analysis */
                    }

                    /* Check if this file has to be transcoded or not */
                    /* If not, we just return M4NO_ERROR, and go to next file */
                    if( xVSS_context->pMCScurrentParams->isCreated == M4OSA_FALSE )
                    {
                        /* Opening MCS */
                        M4OSA_UInt32 rotationDegree = 0;
                        err = M4xVSS_internalStartTranscoding(xVSS_context, &rotationDegree);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_1("M4xVSS_Step: M4xVSS_internalStartTranscoding returned\
                                 error: 0x%x", err);
                            return err;
                        }
                        int32_t index = xVSS_context->pMCScurrentParams->videoclipnumber;

                        /* The cuts are done in the MCS, so we need to replace
                           the beginCutTime and endCutTime to keep the entire video*/
                        xVSS_context->pSettings->pClipList[index]->uiBeginCutTime = 0;
                        xVSS_context->pSettings->pClipList[index]->uiEndCutTime = 0;


                        M4OSA_TRACE1_1("M4xVSS_Step: \
                            M4xVSS_internalStartTranscoding returned \
                                success; MCS context: 0x%x",
                                 xVSS_context->pMCS_Ctxt);
                        xVSS_context->analyseStep =
                            M4xVSS_kMicroStateTranscodeMCS;

                        // Retain rotation info of trimmed / transcoded file
                        xVSS_context->pSettings->pClipList[index]->\
                            ClipProperties.videoRotationDegrees = rotationDegree;
                    }
                }
                else if( xVSS_context->analyseStep
                    == M4xVSS_kMicroStateTranscodeMCS )
                    /* MCS: transcoding file */
                {
                    err = M4MCS_step(xVSS_context->pMCS_Ctxt, &uiProgress);
                    /*SS:blrnxpsw#  234 */
                    if( err == ((M4OSA_UInt32)M4MCS_ERR_NOMORE_SPACE) )
                    {
                        err = M4xVSSERR_NO_MORE_SPACE;
                    }

                    if( ( err != M4NO_ERROR)
                        && (err != M4MCS_WAR_TRANSCODING_DONE) )
                    {
                        /* TO BE CHECKED NO LEAKS  !!!!! */
                        M4OSA_TRACE1_1("M4xVSS_Step: M4MCS_step returned 0x%x\n",
                            err);
                        /* TODO ? : Translate error code of MCS to an xVSS error code ? */
                        return err;
                    }
                    else if( err == M4MCS_WAR_TRANSCODING_DONE )
                    {
                        xVSS_context->currentStep++;
                        /* P4ME00003276: When a step is complete, increment currentStep and reset
                        uiProgress unless progress would be wrong */
                        uiProgress = 0;
                        xVSS_context->analyseStep =
                            M4xVSS_kMicroStateAnalyzeMCS; /* We go back to
                                                          analyze parameters to see if there is
                                                           a next file to transcode */
                        /* RC !!!!!!!!!*/
                        xVSS_context->pMCScurrentParams->isCreated =
                            M4OSA_TRUE; /* To avoid
                                        reconverting it if another SendCommand is called */
                        err = M4xVSS_internalStopTranscoding(xVSS_context);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_1("M4xVSS_Step:\
                                           M4xVSS_internalStopTranscoding returned 0x%x", err);
                            /* TODO ? : Translate error code of MCS to an xVSS error code ? */
                            return err;
                        }
                    }
                }
                else
                {
                    M4OSA_TRACE1_0("Bad micro state in analyzing state")
                        return M4ERR_STATE;
                }
            }
            break;

        default:
            M4OSA_TRACE1_1(
                "Bad state when calling M4xVSS_Step function! State is %d",
                xVSS_context->m_state);
            return M4ERR_STATE;
    }

end_step:
    /* Compute progression */
    if( xVSS_context->nbStepTotal != 0 )
    {
        *pProgress = (M4OSA_UInt8)(( ( xVSS_context->currentStep * 100) \
            / (xVSS_context->nbStepTotal))
            + (uiProgress / (xVSS_context->nbStepTotal)));

        if( *pProgress > 100 )
        {
            *pProgress = 100;
        }
    }
    else
    {
        *pProgress = 100;
    }

    return err;
}

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_CloseCommand(M4OSA_Context pContext)
 * @brief        This function deletes current editing profile, unallocate
 *                ressources and change xVSS internal state.
 * @note        After this function, the user can call a new M4xVSS_SendCommand
 *
 * @param    pContext            (IN) Pointer on the xVSS edit context
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_STATE:        This function cannot not be called at this time
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_CloseCommand( M4OSA_Context pContext )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4OSA_ERR err = M4NO_ERROR;

    /* Check state */
    /* Depending of the state, differents things have to be done */
    switch( xVSS_context->m_state )
    {
        case M4xVSS_kStateOpened:
            /* Nothing to do here */
            err = M4xVSS_internalFreeSaving(xVSS_context);
            break;

        case M4xVSS_kStateSaving:
            {
                if( xVSS_context->editingStep == M4xVSS_kMicroStateEditing )
                {
                    err = M4xVSS_internalCloseEditedFile(xVSS_context);

                    if( err != M4NO_ERROR )
                    {
                        /* Fix for blrnxpsw#234---->*/
                        if( err == ((M4OSA_UInt32)M4ERR_FILE_INVALID_POSITION) )
                        {
                            err = M4xVSSERR_NO_MORE_SPACE;
                        }
                        M4OSA_TRACE1_1("M4xVSS_CloseCommand:\
                                       M4xVSS_internalCloseEditedFile returned an error: 0x%x",
                                        err);
                        /* we are retaining error here and returning error  in the end of the
                        function  as to aviod memory leak*/
                        //return err;
                    }
                }
                else if( xVSS_context->editingStep
                    == M4xVSS_kMicroStateAudioMixing )
                {
                    err = M4xVSS_internalCloseAudioMixedFile(xVSS_context);

                    if( err != M4NO_ERROR )
                    {
                        /* Fix for blrnxpsw#234---->*/
                        if( err == ((M4OSA_UInt32)M4ERR_FILE_INVALID_POSITION) )
                        {
                            err = M4xVSSERR_NO_MORE_SPACE;
                        }
                        M4OSA_TRACE1_1("M4xVSS_CloseCommand: \
                                M4xVSS_internalCloseAudioMixedFile returned an error: 0x%x", err);
                        /* we are retaining error here and returning error  in the end of
                        the function  as to aviod memory leak*/
                        //return err;
                        /* <----Fix for blrnxpsw#234*/
                    }
                }
                err = M4xVSS_internalFreeSaving(xVSS_context);
                /* We free this pointer only if a BGM track is present, because in that case,
                this pointer owns to us */
                if( xVSS_context->pSettings->xVSS.pBGMtrack != M4OSA_NULL ) {
                    /*if(M4OSA_NULL != xVSS_context->pSettings->pOutputFile)
                    {
                    free(xVSS_context->pSettings->pOutputFile);
                    xVSS_context->pSettings->pOutputFile = M4OSA_NULL;
                    }*/
                    /*if(M4OSA_NULL != xVSS_context->pSettings->pTemporaryFile)
                    {
                    free(xVSS_context->pSettings->pTemporaryFile);
                    xVSS_context->pSettings->pTemporaryFile = M4OSA_NULL;
                    }*/
                }
            }
            break;

        case M4xVSS_kStateSaved:
            break;

        case M4xVSS_kStateAnalyzing:
            {
                if( xVSS_context->analyseStep == M4xVSS_kMicroStateConvertPto3GPP )
                {
                    /* Free Pto3GPP module */
                    err = M4xVSS_internalStopConvertPictureTo3gp(xVSS_context);
                    /* Fix for blrnxpsw#234---->*/
                    if( err != M4NO_ERROR )
                    {
                        if( err == ((M4OSA_UInt32)M4ERR_FILE_INVALID_POSITION) )
                        {
                            err = M4xVSSERR_NO_MORE_SPACE;
                        }
                        M4OSA_TRACE1_1("M4xVSS_Step: \
                                       M4xVSS_internalStopConvertPictureTo3gp returned 0x%x", err);
                        /* we are retaining error here and returning error  in the end of the
                        function  as to aviod memory leak*/
                        //return err;
                    }
                    /* <-----Fix for blrnxpsw#234>*/
                }
                else if( xVSS_context->analyseStep
                    == M4xVSS_kMicroStateTranscodeMCS )
                {
                    /* Free MCS module */
                    err = M4MCS_abort(xVSS_context->pMCS_Ctxt);
                    /* Fix for blrnxpsw#234---->*/
                    if( err != M4NO_ERROR )
                    {
                        if( err == ((M4OSA_UInt32)M4ERR_FILE_INVALID_POSITION) )
                        {
                            err = M4xVSSERR_NO_MORE_SPACE;
                        }
                        M4OSA_TRACE1_1("M4xVSS_Step: M4MCS_abort returned 0x%x",
                            err);
                        /* we are retaining error here and returning error  in the end of the
                        function  as to aviod memory leak*/
                        //return err;
                    }
                    /* <---Fix for blrnxpsw#234*/
                }
            }
            break;

        default:
            M4OSA_TRACE1_1(
                "Bad state when calling M4xVSS_CloseCommand function! State is %d",
                xVSS_context->m_state);
            return M4ERR_STATE;
    }

    /* Free Send command */
    M4xVSS_freeCommand(xVSS_context);

    xVSS_context->m_state = M4xVSS_kStateInitialized; /* Change xVSS state */

    return err;
}

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_CleanUp(M4OSA_Context pContext)
 * @brief        This function deletes all xVSS ressources
 * @note        This function must be called after M4xVSS_CloseCommand.
 *
 * @param    pContext            (IN) Pointer on the xVSS edit context
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_STATE:        This function cannot not be called at this time
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_CleanUp( M4OSA_Context pContext )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4OSA_TRACE3_0("M4xVSS_CleanUp:entering");

    /* Check state */
    if( xVSS_context->m_state != M4xVSS_kStateInitialized )
    {
        M4OSA_TRACE1_1(\
            "Bad state when calling M4xVSS_CleanUp function! State is %d",\
            xVSS_context->m_state);
        return M4ERR_STATE;
    }

    /**
    * UTF conversion: free temporary buffer*/
    if( xVSS_context->UTFConversionContext.pTempOutConversionBuffer
        != M4OSA_NULL )
    {
        free(xVSS_context->
            UTFConversionContext.pTempOutConversionBuffer);
        xVSS_context->UTFConversionContext.pTempOutConversionBuffer =
            M4OSA_NULL;
    }

    free(xVSS_context->pTempPath);
    xVSS_context->pTempPath = M4OSA_NULL;

    free(xVSS_context->pSettings);
    xVSS_context->pSettings = M4OSA_NULL;

    free(xVSS_context);
    xVSS_context = M4OSA_NULL;
    M4OSA_TRACE3_0("M4xVSS_CleanUp:leaving ");

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * prototype    M4xVSS_GetVersion(M4_VersionInfo *pVersion)
 * @brief        This function get the version of the Video Studio 2.1
 *
 * @param    pVersion            (IN) Pointer on the version info struct
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_GetVersion( M4_VersionInfo *pVersion )
{
    /* Just used for a grep in code */
    /* CHANGE_VERSION_HERE */
    static const M4OSA_Char cVersion[26] = "NXPSW_VideoStudio21_1_3_0";

    if( M4OSA_NULL == pVersion )
    {
        return M4ERR_PARAMETER;
    }

    pVersion->m_major = M4_xVSS_MAJOR;
    pVersion->m_minor = M4_xVSS_MINOR;
    pVersion->m_revision = M4_xVSS_REVISION;
    pVersion->m_structSize = sizeof(M4_VersionInfo);

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4xVSS_CreateClipSettings()
 * @brief    Allows filling a clip settings structure with default values
 *
 * @note    WARNING: pClipSettings->Effects[ ] will be allocated in this function.
 *                   pClipSettings->pFile      will be allocated in this function.
 *
 * @param    pClipSettings        (IN) Pointer to a valid M4VSS3GPP_ClipSettings structure
 * @param   pFile               (IN) Clip file name
 * @param   filePathSize        (IN) Size of the clip path (needed for the UTF16 conversion)
 * @param    nbEffects           (IN) Nb of effect settings to allocate
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    pClipSettings is M4OSA_NULL (debug only)
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_CreateClipSettings( M4VSS3GPP_ClipSettings *pClipSettings,
                                    M4OSA_Void *pFile, M4OSA_UInt32 filePathSize,
                                     M4OSA_UInt8 nbEffects )
{
    M4OSA_ERR err = M4NO_ERROR;

    M4OSA_TRACE3_1("M4xVSS_CreateClipSettings called with pClipSettings=0x%p",
        pClipSettings);

    /**
    *    Check input parameter */
    M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettings), M4ERR_PARAMETER,
        "M4xVSS_CreateClipSettings: pClipSettings is NULL");

    /* Create inherited VSS3GPP stuff */
    /*err = M4VSS3GPP_editCreateClipSettings(pClipSettings, pFile,nbEffects);*/
    /*FB: add clip path size (needed for UTF 16 conversion)*/
    err = M4VSS3GPP_editCreateClipSettings(pClipSettings, pFile, filePathSize,
        nbEffects);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1("M4xVSS_CreateClipSettings :\
                       ERROR in M4VSS3GPP_editCreateClipSettings = 0x%x", err);
        return err;
    }

    /* Set the clip settings to default */
    pClipSettings->xVSS.uiBeginCutPercent = 0;
    pClipSettings->xVSS.uiEndCutPercent = 0;
    pClipSettings->xVSS.uiDuration = 0;
    pClipSettings->xVSS.isPanZoom = M4OSA_FALSE;
    pClipSettings->xVSS.PanZoomTopleftXa = 0;
    pClipSettings->xVSS.PanZoomTopleftYa = 0;
    pClipSettings->xVSS.PanZoomTopleftXb = 0;
    pClipSettings->xVSS.PanZoomTopleftYb = 0;
    pClipSettings->xVSS.PanZoomXa = 0;
    pClipSettings->xVSS.PanZoomXb = 0;

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4xVSS_CreateClipSettings(): returning M4NO_ERROR");

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4xVSS_DuplicateClipSettings()
 * @brief    Duplicates a clip settings structure, performing allocations if required
 *
 * @param    pClipSettingsDest    (IN) Pointer to a valid M4VSS3GPP_ClipSettings structure
 * @param    pClipSettingsOrig    (IN) Pointer to a valid M4VSS3GPP_ClipSettings structure
 * @param   bCopyEffects        (IN) Flag to know if we have to duplicate effects
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    pClipSettings is M4OSA_NULL (debug only)
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_DuplicateClipSettings( M4VSS3GPP_ClipSettings
                                       *pClipSettingsDest,
                                       M4VSS3GPP_ClipSettings *pClipSettingsOrig,
                                        M4OSA_Bool bCopyEffects )
{
    M4OSA_ERR err = M4NO_ERROR;

    M4OSA_TRACE3_2(
        "M4xVSS_DuplicateClipSettings called with dest=0x%p src=0x%p",
        pClipSettingsDest, pClipSettingsOrig);

    /* Check input parameter */
    M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettingsDest), M4ERR_PARAMETER,
        "M4xVSS_DuplicateClipSettings: pClipSettingsDest is NULL");
    M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettingsOrig), M4ERR_PARAMETER,
        "M4xVSS_DuplicateClipSettings: pClipSettingsOrig is NULL");

    /* Call inherited VSS3GPP duplication */
    err = M4VSS3GPP_editDuplicateClipSettings(pClipSettingsDest,
        pClipSettingsOrig, bCopyEffects);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1("M4xVSS_CreateClipSettings :\
                       ERROR in M4VSS3GPP_editDuplicateClipSettings = 0x%x", err);
        return err;
    }

    /* Return with no error */
    M4OSA_TRACE3_0("M4xVSS_DuplicateClipSettings(): returning M4NO_ERROR");

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4xVSS_FreeClipSettings()
 * @brief    Free the pointers allocated in the ClipSetting structure (pFile, Effects, ...).
 *
 * @param    pClipSettings        (IN) Pointer to a valid M4VSS3GPP_ClipSettings structure
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    pClipSettings is M4OSA_NULL (debug only)
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_FreeClipSettings( M4VSS3GPP_ClipSettings *pClipSettings )
{
    /**
    *    Check input parameter */
    M4OSA_DEBUG_IF2((M4OSA_NULL == pClipSettings), M4ERR_PARAMETER,
        "M4xVSS_FreeClipSettings: pClipSettings is NULL");

    /* Free inherited VSS3GPP stuff */
    M4VSS3GPP_editFreeClipSettings(pClipSettings);

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_getMCSContext(M4OSA_Context pContext, M4OSA_Context* mcsContext)
 * @brief        This function returns the MCS context within the xVSS internal context
 * @note        This function must be called only after VSS state has moved to analyzing state or
 * beyond
 *
 * @param    pContext            (IN) Pointer on the xVSS edit context
 * @param    mcsContext        (OUT) Pointer to pointer of mcs context to return
 * @return    M4NO_ERROR:        No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_STATE:        This function cannot not be called at this time
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_getMCSContext( M4OSA_Context pContext,
                               M4OSA_Context *mcsContext )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4OSA_ERR err = M4NO_ERROR;

    /**
    *    Check input parameter */
    M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER,
        "M4xVSS_getMCSContext: pContext is NULL");

    if( xVSS_context->m_state == M4xVSS_kStateInitialized )
    {
        M4OSA_TRACE1_1("M4xVSS_getMCSContext: Bad state! State is %d",\
            xVSS_context->m_state);
        return M4ERR_STATE;
    }

    *mcsContext = xVSS_context->pMCS_Ctxt;

    return err;
}

/**
 ******************************************************************************
 * prototype    M4OSA_ERR M4xVSS_getVSS3GPPContext(M4OSA_Context pContext,
 *                                                   M4OSA_Context* mcsContext)
 * @brief        This function returns the VSS3GPP context within the xVSS internal context
 * @note        This function must be called only after VSS state has moved to Generating preview
 *              or beyond
 * @param    pContext            (IN) Pointer on the xVSS edit context
 * @param    vss3gppContext        (OUT) Pointer to pointer of vss3gpp context to return
 * @return    M4NO_ERROR:        No error
 * @return    M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return    M4ERR_STATE:        This function cannot not be called at this time
 ******************************************************************************
 */
M4OSA_ERR M4xVSS_getVSS3GPPContext( M4OSA_Context pContext,
                                   M4OSA_Context *vss3gppContext )
{
    M4xVSS_Context *xVSS_context = (M4xVSS_Context *)pContext;
    M4OSA_ERR err = M4NO_ERROR;

    /**
    *    Check input parameter */
    M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER,
        "M4xVSS_getVSS3GPPContext: pContext is NULL");

    if( xVSS_context->m_state < M4xVSS_kStateSaving )
    {
        M4OSA_TRACE1_1("M4xVSS_getVSS3GPPContext: Bad state! State is %d",\
            xVSS_context->m_state);
        return M4ERR_STATE;
    }

    *vss3gppContext = xVSS_context->pCurrentEditContext;

    return err;
}

M4OSA_ERR M4xVSS_getVideoDecoderCapabilities(M4DECODER_VideoDecoders **decoders) {
    M4OSA_ERR err = M4NO_ERROR;

    // Call the decoder api directly
    // to get all the video decoder capablities.
    err = VideoEditorVideoDecoder_getVideoDecodersAndCapabilities(decoders);
    return err;
}