/*
 * 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    M4PTO3GPP_API.c
 * @brief   Picture to 3gpp Service implementation.
 * @note
 ******************************************************************************
*/

/*16 bytes signature to be written in the generated 3gp files */
#define M4PTO3GPP_SIGNATURE     "NXP-SW : PTO3GPP"

/****************/
/*** Includes ***/
/****************/

/**
 *  Our header */
#include "M4PTO3GPP_InternalTypes.h"
#include "M4PTO3GPP_API.h"

/**
 *  Our errors */
#include "M4PTO3GPP_ErrorCodes.h"

#ifdef M4VSS_SUPPORT_ENCODER_MPEG4
#include "VideoEditorVideoEncoder.h"
#endif


/**
 *  OSAL headers */
#include "M4OSA_Memory.h"       /* OSAL memory management */
#include "M4OSA_Debug.h"        /* OSAL debug management */


/************************/
/*** Various Magicals ***/
/************************/

#define M4PTO3GPP_WRITER_AUDIO_STREAM_ID                1
#define M4PTO3GPP_WRITER_VIDEO_STREAM_ID                2
#define M4PTO3GPP_QUANTIZER_STEP                        4       /**< Quantizer step */
#define M4PTO3GPP_WRITER_AUDIO_PROFILE_LEVEL            0xFF    /**< No specific profile and
                                                                     level */
#define M4PTO3GPP_WRITER_AUDIO_AMR_TIME_SCALE           8000    /**< AMR */
#define M4PTO3GPP_BITRATE_REGULATION_CTS_PERIOD_IN_MS   500     /**< MAGICAL */
#define M4PTO3GPP_MARGE_OF_FILE_SIZE                    25000   /**< MAGICAL */
/**
 ******************************************************************************
 * define   AMR 12.2 kbps silence frame
 ******************************************************************************
*/
#define M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE     32
#define M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_DURATION 20
const M4OSA_UInt8 M4PTO3GPP_AMR_AU_SILENCE_122_FRAME[M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE]=
{ 0x3C, 0x91, 0x17, 0x16, 0xBE, 0x66, 0x78, 0x00, 0x00, 0x01, 0xE7, 0xAF,
  0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

#define M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE     13
#define M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_DURATION 20
const M4OSA_UInt8 M4PTO3GPP_AMR_AU_SILENCE_048_FRAME[M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE] =
{ 0x04, 0xFF, 0x18, 0xC7, 0xF0, 0x0D, 0x04, 0x33, 0xFF, 0xE0, 0x00, 0x00, 0x00 };

/***************************/
/*** "Private" functions ***/
/***************************/
static M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC);

/****************************/
/*** "External" functions ***/
/****************************/
extern M4OSA_ERR M4WRITER_3GP_getInterfaces(M4WRITER_OutputFileType* pType,
                                            M4WRITER_GlobalInterface** SrcGlobalInterface,
                                            M4WRITER_DataInterface** SrcDataInterface);
extern M4OSA_ERR M4READER_AMR_getInterfaces(M4READER_MediaType *pMediaType,
                                            M4READER_GlobalInterface **pRdrGlobalInterface,
                                            M4READER_DataInterface **pRdrDataInterface);
extern M4OSA_ERR M4READER_3GP_getInterfaces(M4READER_MediaType *pMediaType,
                                            M4READER_GlobalInterface **pRdrGlobalInterface,
                                            M4READER_DataInterface **pRdrDataInterface);

/****************************/
/*** "Static" functions ***/
/****************************/
static M4OSA_ERR M4PTO3GPP_writeAmrSilence122Frame(
                                    M4WRITER_DataInterface* pWriterDataIntInterface,
                                    M4WRITER_Context* pWriterContext,
                                    M4SYS_AccessUnit* pWriterAudioAU,
                                    M4OSA_Time mtIncCts);
static M4OSA_ERR M4PTO3GPP_writeAmrSilence048Frame(
                                   M4WRITER_DataInterface* pWriterDataIntInterface,
                                   M4WRITER_Context* pWriterContext,
                                   M4SYS_AccessUnit* pWriterAudioAU,
                                   M4OSA_Time mtIncCts);
/**
 ******************************************************************************
 * M4OSA_ERR M4PTO3GPP_GetVersion(M4_VersionInfo* pVersionInfo);
 * @brief   Get the M4PTO3GPP version.
 * @note    Can be called anytime. Do not need any context.
 * @param   pVersionInfo        (OUT) Pointer to a version info structure
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    pVersionInfo is M4OSA_NULL (If Debug Level >= 2)
 ******************************************************************************
*/

/*********************************************************/
M4OSA_ERR M4PTO3GPP_GetVersion(M4_VersionInfo* pVersionInfo)
/*********************************************************/
{
    M4OSA_TRACE3_1("M4PTO3GPP_GetVersion called with pVersionInfo=0x%x", pVersionInfo);

    /**
     *  Check input parameters */
    M4OSA_DEBUG_IF2((M4OSA_NULL==pVersionInfo),M4ERR_PARAMETER,
            "M4PTO3GPP_GetVersion: pVersionInfo is M4OSA_NULL");

    pVersionInfo->m_major       = M4PTO3GPP_VERSION_MAJOR;
    pVersionInfo->m_minor       = M4PTO3GPP_VERSION_MINOR;
    pVersionInfo->m_revision    = M4PTO3GPP_VERSION_REVISION;

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4PTO3GPP_Init(M4PTO3GPP_Context* pContext);
 * @brief   Initializes the M4PTO3GPP (allocates an execution context).
 * @note
 * @param   pContext            (OUT) Pointer on the M4PTO3GPP context to allocate
 * @param   pFileReadPtrFct     (IN) Pointer to OSAL file reader functions
 * @param   pFileWritePtrFct    (IN) Pointer to OSAL file writer functions
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (If Debug Level >= 2)
 * @return  M4ERR_ALLOC:        There is no more available memory
 ******************************************************************************
*/
/*********************************************************/
M4OSA_ERR M4PTO3GPP_Init(   M4PTO3GPP_Context* pContext,
                            M4OSA_FileReadPointer* pFileReadPtrFct,
                            M4OSA_FileWriterPointer* pFileWritePtrFct)
/*********************************************************/
{
    M4PTO3GPP_InternalContext *pC;
    M4OSA_UInt32 i;

    M4OSA_TRACE3_1("M4PTO3GPP_Init called with pContext=0x%x", pContext);

    /**
     *  Check input parameters */
    M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER,
            "M4PTO3GPP_Init: pContext is M4OSA_NULL");

    /**
     *  Allocate the M4PTO3GPP context and return it to the user */
    pC = (M4PTO3GPP_InternalContext*)M4OSA_32bitAlignedMalloc(sizeof(M4PTO3GPP_InternalContext), M4PTO3GPP,
        (M4OSA_Char *)"M4PTO3GPP_InternalContext");
    *pContext = pC;
    if (M4OSA_NULL == pC)
    {
        M4OSA_TRACE1_0("M4PTO3GPP_Step(): unable to allocate M4PTO3GPP_InternalContext,\
                       returning M4ERR_ALLOC");
        return M4ERR_ALLOC;
    }

    /**
     *  Init the context. All pointers must be initialized to M4OSA_NULL because CleanUp()
        can be called just after Init(). */
    pC->m_State = M4PTO3GPP_kState_CREATED;
    pC->m_VideoState = M4PTO3GPP_kStreamState_NOSTREAM;
    pC->m_AudioState = M4PTO3GPP_kStreamState_NOSTREAM;

    /**
     *  Reader stuff */
    pC->m_pReaderAudioAU        = M4OSA_NULL;
    pC->m_pReaderAudioStream    = M4OSA_NULL;

    /**
     *  Writer stuff */
    pC->m_pEncoderHeader        = M4OSA_NULL;
    pC->m_pWriterVideoStream    = M4OSA_NULL;
    pC->m_pWriterAudioStream    = M4OSA_NULL;
    pC->m_pWriterVideoStreamInfo= M4OSA_NULL;
    pC->m_pWriterAudioStreamInfo= M4OSA_NULL;

    /**
     *  Contexts of the used modules  */
    pC->m_pAudioReaderContext    = M4OSA_NULL;
    pC->m_p3gpWriterContext  = M4OSA_NULL;
    pC->m_pMp4EncoderContext = M4OSA_NULL;
    pC->m_eEncoderState = M4PTO3GPP_kNoEncoder;

    /**
     *  Interfaces of the used modules */
    pC->m_pReaderGlobInt    = M4OSA_NULL;
    pC->m_pReaderDataInt    = M4OSA_NULL;
    pC->m_pWriterGlobInt    = M4OSA_NULL;
    pC->m_pWriterDataInt    = M4OSA_NULL;
    pC->m_pEncoderInt       = M4OSA_NULL;
    pC->m_pEncoderExternalAPI = M4OSA_NULL;
    pC->m_pEncoderUserData = M4OSA_NULL;

    /**
     * Fill the OSAL file function set */
    pC->pOsalFileRead = pFileReadPtrFct;
    pC->pOsalFileWrite = pFileWritePtrFct;

    /**
     *  Video rate control stuff */
    pC->m_mtCts             = 0.0F;
    pC->m_mtNextCts         = 0.0F;
    pC->m_mtAudioCts        = 0.0F;
    pC->m_AudioOffSet       = 0.0F;
    pC->m_dLastVideoRegulCts= 0.0F;
    pC->m_PrevAudioCts      = 0.0F;
    pC->m_DeltaAudioCts     = 0.0F;

    pC->m_MaxFileSize       = 0;
    pC->m_CurrentFileSize   = 0;

    pC->m_IsLastPicture         = M4OSA_FALSE;
    pC->m_bAudioPaddingSilence  = M4OSA_FALSE;
    pC->m_bLastInternalCallBack = M4OSA_FALSE;
    pC->m_NbCurrentFrame        = 0;

    pC->pSavedPlane = M4OSA_NULL;
    pC->uiSavedDuration = 0;

    M4OSA_TRACE3_0("M4PTO3GPP_Init(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4PTO3GPP_Open(M4PTO3GPP_Context pContext, M4PTO3GPP_Params* pParams);
 * @brief   Set the M4PTO3GPP input and output files.
 * @note    It opens the input file, but the output file may not be created yet.
 * @param   pContext            (IN) M4PTO3GPP context
 * @param   pParams             (IN) Pointer to the parameters for the PTO3GPP.
 * @note    The pointed structure can be de-allocated after this function returns because
 *          it is internally copied by the PTO3GPP
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return  M4ERR_STATE:        M4PTO3GPP is not in an appropriate state for this function to be
                                 called
 * @return  M4ERR_ALLOC:        There is no more available memory
 * @return  ERR_PTO3GPP_INVALID_VIDEO_FRAME_SIZE_FOR_H263 The output video frame
 *                              size parameter is incompatible with H263 encoding
 * @return  ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT       The output video format
                                                            parameter is undefined
 * @return  ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE      The output video bit-rate parameter
                                                            is undefined
 * @return  ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE   The output video frame size parameter
                                                            is undefined
 * @return  ERR_PTO3GPP_UNDEFINED_OUTPUT_FILE_SIZE          The output file size parameter
                                                            is undefined
 * @return  ERR_PTO3GPP_UNDEFINED_AUDIO_PADDING             The output audio padding parameter
                                                            is undefined
 * @return  ERR_PTO3GPP_UNHANDLED_AUDIO_TRACK_INPUT_FILE    The input audio file contains
                                                            a track format not handled by PTO3GPP
 ******************************************************************************
*/
/*********************************************************/
M4OSA_ERR M4PTO3GPP_Open(M4PTO3GPP_Context pContext, M4PTO3GPP_Params* pParams)
/*********************************************************/
{
    M4PTO3GPP_InternalContext   *pC = (M4PTO3GPP_InternalContext*)(pContext);
    M4OSA_ERR                   err = M4NO_ERROR;

    M4READER_MediaFamily    mediaFamily;
    M4_StreamHandler*       pStreamHandler;
    M4READER_MediaType      readerMediaType;

    M4OSA_TRACE2_2("M4PTO3GPP_Open called with pContext=0x%x, pParams=0x%x", pContext, pParams);

    /**
     *  Check input parameters */
    M4OSA_DEBUG_IF2((M4OSA_NULL == pContext), M4ERR_PARAMETER, \
                    "M4PTO3GPP_Open: pContext is M4OSA_NULL");
    M4OSA_DEBUG_IF2((M4OSA_NULL == pParams),  M4ERR_PARAMETER, \
                    "M4PTO3GPP_Open: pParams is M4OSA_NULL");

    /**
     *  Check parameters correctness */
    M4OSA_DEBUG_IF2((M4OSA_NULL == pParams->pPictureCallbackFct),
               M4ERR_PARAMETER, "M4PTO3GPP_Open: pC->m_Params.pPictureCallbackFct is M4OSA_NULL");
    M4OSA_DEBUG_IF2((M4OSA_NULL == pParams->pPictureCallbackCtxt),
                M4ERR_PARAMETER,
                 "M4PTO3GPP_Open: pC->m_Params.pPictureCallbackCtxt is M4OSA_NULL");
    M4OSA_DEBUG_IF2((M4OSA_NULL == pParams->pOutput3gppFile),
                M4ERR_PARAMETER, "M4PTO3GPP_Open: pC->m_Params.pOutput3gppFile is M4OSA_NULL");
    M4OSA_DEBUG_IF2((M4OSA_NULL == pParams->pTemporaryFile),
                M4ERR_PARAMETER, "M4PTO3GPP_Open: pC->m_Params.pTemporaryFile is M4OSA_NULL");

    /**
     * Video Format */
    if( (M4VIDEOEDITING_kH263 != pParams->OutputVideoFormat) &&
        (M4VIDEOEDITING_kMPEG4 != pParams->OutputVideoFormat) &&
        (M4VIDEOEDITING_kH264 != pParams->OutputVideoFormat)) {
        M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined output video format");
        return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT;
     }

     /**
     * Video Bitrate */
    if(!((M4VIDEOEDITING_k16_KBPS       == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k24_KBPS       == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k32_KBPS       == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k48_KBPS       == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k64_KBPS       == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k96_KBPS       == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k128_KBPS      == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k192_KBPS      == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k256_KBPS      == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k288_KBPS      == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k384_KBPS      == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k512_KBPS      == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k800_KBPS      == pParams->OutputVideoBitrate) ||
         /*+ New Encoder bitrates */
         (M4VIDEOEDITING_k2_MBPS        == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k5_MBPS        == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_k8_MBPS        == pParams->OutputVideoBitrate) ||
         (M4VIDEOEDITING_kVARIABLE_KBPS == pParams->OutputVideoBitrate))) {
        M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined output video bitrate");
        return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE;
    }

    /**
     * Video frame size */
    if (!((M4VIDEOEDITING_kSQCIF == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_kQQVGA == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_kQCIF == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_kQVGA == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_kCIF  == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_kVGA  == pParams->OutputVideoFrameSize) ||

          (M4VIDEOEDITING_kNTSC == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_kWVGA == pParams->OutputVideoFrameSize) ||

          (M4VIDEOEDITING_k640_360 == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_k854_480 == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_k1280_720 == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_k1080_720 == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_k960_720 == pParams->OutputVideoFrameSize) ||
          (M4VIDEOEDITING_k1920_1080 == pParams->OutputVideoFrameSize))) {
        M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined output video frame size");
        return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE;
    }

    /**
     * Maximum size of the output 3GPP file */
    if (!((M4PTO3GPP_k50_KB     == pParams->OutputFileMaxSize) ||
          (M4PTO3GPP_k75_KB     == pParams->OutputFileMaxSize) ||
          (M4PTO3GPP_k100_KB    == pParams->OutputFileMaxSize) ||
          (M4PTO3GPP_k150_KB    == pParams->OutputFileMaxSize) ||
          (M4PTO3GPP_k200_KB    == pParams->OutputFileMaxSize) ||
          (M4PTO3GPP_k300_KB    == pParams->OutputFileMaxSize) ||
          (M4PTO3GPP_k400_KB    == pParams->OutputFileMaxSize) ||
          (M4PTO3GPP_k500_KB    == pParams->OutputFileMaxSize) ||
          (M4PTO3GPP_kUNLIMITED == pParams->OutputFileMaxSize))) {
        M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined output 3GPP file size");
        return ERR_PTO3GPP_UNDEFINED_OUTPUT_FILE_SIZE;
    }

    /* Audio padding */
    if (M4OSA_NULL != pParams->pInputAudioTrackFile) {
        if ((!( (M4PTO3GPP_kAudioPaddingMode_None   == pParams->AudioPaddingMode) ||
                (M4PTO3GPP_kAudioPaddingMode_Silence== pParams->AudioPaddingMode) ||
                (M4PTO3GPP_kAudioPaddingMode_Loop   == pParams->AudioPaddingMode)))) {
            M4OSA_TRACE1_0("M4PTO3GPP_Open: Undefined audio padding");
            return ERR_PTO3GPP_UNDEFINED_AUDIO_PADDING;
        }
    }

    /**< Size check for H263 (only valid sizes are CIF, QCIF and SQCIF) */
    if ((M4VIDEOEDITING_kH263 == pParams->OutputVideoFormat) &&
        (M4VIDEOEDITING_kSQCIF != pParams->OutputVideoFrameSize) &&
        (M4VIDEOEDITING_kQCIF != pParams->OutputVideoFrameSize) &&
        (M4VIDEOEDITING_kCIF != pParams->OutputVideoFrameSize)) {
        M4OSA_TRACE1_0("M4PTO3GPP_Open():\
             returning ERR_PTO3GPP_INVALID_VIDEO_FRAME_SIZE_FOR_H263");
        return ERR_PTO3GPP_INVALID_VIDEO_FRAME_SIZE_FOR_H263;
    }

    /**
     *  Check state automaton */
    if (M4PTO3GPP_kState_CREATED != pC->m_State) {
        M4OSA_TRACE1_1("M4PTO3GPP_Open(): Wrong State (%d), returning M4ERR_STATE", pC->m_State);
        return M4ERR_STATE;
    }

    /**
     * Copy the M4PTO3GPP_Params structure */
    memcpy((void *)(&pC->m_Params),
                (void *)pParams, sizeof(M4PTO3GPP_Params));
    M4OSA_TRACE1_1("M4PTO3GPP_Open: outputVideoBitrate = %d", pC->m_Params.OutputVideoBitrate);

    /***********************************/
    /* Open input file with the reader */
    /***********************************/
    if (M4OSA_NULL != pC->m_Params.pInputAudioTrackFile) {
        /**
         * Get the reader interface according to the input audio file type */
        switch(pC->m_Params.AudioFileFormat)
        {
#ifdef M4VSS_SUPPORT_READER_AMR
        case M4VIDEOEDITING_kFileType_AMR:
        err = M4READER_AMR_getInterfaces( &readerMediaType, &pC->m_pReaderGlobInt,
                &pC->m_pReaderDataInt);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Open(): M4READER_AMR_getInterfaces returns 0x%x", err);
            return err;
        }
            break;
#endif

#ifdef AAC_SUPPORTED
        case M4VIDEOEDITING_kFileType_3GPP:
            err = M4READER_3GP_getInterfaces( &readerMediaType, &pC->m_pReaderGlobInt,
                    &pC->m_pReaderDataInt);
            if (M4NO_ERROR != err)
            {
                M4OSA_TRACE1_1("M4PTO3GPP_Open(): M4READER_3GP_getInterfaces returns 0x%x", err);
                return err;
            }
            break;
#endif

        default:
            return ERR_PTO3GPP_UNHANDLED_AUDIO_TRACK_INPUT_FILE;
        }

        /**
         *  Initializes the reader shell */
        err = pC->m_pReaderGlobInt->m_pFctCreate(&pC->m_pAudioReaderContext);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Open(): pReaderGlobInt->m_pFctCreate returns 0x%x", err);
            return err;
        }

        pC->m_pReaderDataInt->m_readerContext = pC->m_pAudioReaderContext;
        /**< Link the reader interface to the reader context */

        /**
         *  Set the reader shell file access functions */
        err = pC->m_pReaderGlobInt->m_pFctSetOption(pC->m_pAudioReaderContext,
            M4READER_kOptionID_SetOsaFileReaderFctsPtr,  (M4OSA_DataOption)pC->pOsalFileRead);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Open(): pReaderGlobInt->m_pFctSetOption returns 0x%x", err);
            return err;
        }

        /**
         *  Open the input audio file */
        err = pC->m_pReaderGlobInt->m_pFctOpen(pC->m_pAudioReaderContext,
            pC->m_Params.pInputAudioTrackFile);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Open(): pReaderGlobInt->m_pFctOpen returns 0x%x", err);
            pC->m_pReaderGlobInt->m_pFctDestroy(pC->m_pAudioReaderContext);
            pC->m_pAudioReaderContext = M4OSA_NULL;
            return err;
        }

        /**
         *  Get the audio streams from the input file */
        err = M4NO_ERROR;
        while (M4NO_ERROR == err)
        {
            err = pC->m_pReaderGlobInt->m_pFctGetNextStream(pC->m_pAudioReaderContext,
                &mediaFamily, &pStreamHandler);

            if((err == ((M4OSA_UInt32)M4ERR_READER_UNKNOWN_STREAM_TYPE)) ||
                   (err == ((M4OSA_UInt32)M4WAR_TOO_MUCH_STREAMS)))
            {
                err = M4NO_ERROR;
                continue;
            }

            if (M4NO_ERROR == err) /**< One stream found */
            {
                /**< Found an audio stream */
                if ((M4READER_kMediaFamilyAudio == mediaFamily)
                    && (M4OSA_NULL == pC->m_pReaderAudioStream))
                {
                    pC->m_pReaderAudioStream = (M4_AudioStreamHandler*)pStreamHandler;
                    /**< Keep pointer to the audio stream */
                    M4OSA_TRACE3_0("M4PTO3GPP_Open(): Found an audio stream in input");
                    pStreamHandler->m_bStreamIsOK = M4OSA_TRUE;

                    /**
                     *  Allocate audio AU used for read operations */
                    pC->m_pReaderAudioAU = (M4_AccessUnit*)M4OSA_32bitAlignedMalloc(sizeof(M4_AccessUnit),
                        M4PTO3GPP,(M4OSA_Char *)"pReaderAudioAU");
                    if (M4OSA_NULL == pC->m_pReaderAudioAU)
                    {
                        M4OSA_TRACE1_0("M4PTO3GPP_Open(): unable to allocate pReaderAudioAU, \
                                       returning M4ERR_ALLOC");
                        return M4ERR_ALLOC;
                    }

                    /**
                     *  Initializes an access Unit */
                    err = pC->m_pReaderGlobInt->m_pFctFillAuStruct(pC->m_pAudioReaderContext,
                            pStreamHandler, pC->m_pReaderAudioAU);
                    if (M4NO_ERROR != err)
                    {
                        M4OSA_TRACE1_1("M4PTO3GPP_Open():\
                         pReaderGlobInt->m_pFctFillAuStruct(audio)returns 0x%x", err);
                        return err;
                    }
                }
                else
                {
                    pStreamHandler->m_bStreamIsOK = M4OSA_FALSE;
                }
            }
            else if (M4WAR_NO_MORE_STREAM != err) /**< Unexpected error code */
            {
                M4OSA_TRACE1_1("M4PTO3GPP_Open():\
                     pReaderGlobInt->m_pFctGetNextStream returns 0x%x",
                    err);
                return err;
            }
        } /* while*/
    } /*if (M4OSA_NULL != pC->m_Params.pInputAudioTrackFile)*/

    pC->m_VideoState = M4PTO3GPP_kStreamState_STARTED;

    /**
     * Init the audio stream */
    if (M4OSA_NULL != pC->m_pReaderAudioStream)
    {
        pC->m_AudioState = M4PTO3GPP_kStreamState_STARTED;
        err = pC->m_pReaderGlobInt->m_pFctReset(pC->m_pAudioReaderContext,
            (M4_StreamHandler*)pC->m_pReaderAudioStream);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Open(): pReaderDataInt->m_pFctReset(audio returns 0x%x",
                 err);
            return err;
        }
    }

    /**
     *  Update state automaton */
    pC->m_State = M4PTO3GPP_kState_OPENED;

    /**
     * Get the max File size */
    switch(pC->m_Params.OutputFileMaxSize)
    {
    case M4PTO3GPP_k50_KB:  pC->m_MaxFileSize = 50000;  break;
    case M4PTO3GPP_k75_KB:  pC->m_MaxFileSize = 75000;  break;
    case M4PTO3GPP_k100_KB: pC->m_MaxFileSize = 100000; break;
    case M4PTO3GPP_k150_KB: pC->m_MaxFileSize = 150000; break;
    case M4PTO3GPP_k200_KB: pC->m_MaxFileSize = 200000; break;
    case M4PTO3GPP_k300_KB: pC->m_MaxFileSize = 300000; break;
    case M4PTO3GPP_k400_KB: pC->m_MaxFileSize = 400000; break;
    case M4PTO3GPP_k500_KB: pC->m_MaxFileSize = 500000; break;
    case M4PTO3GPP_kUNLIMITED:
    default:                                            break;
    }

    M4OSA_TRACE3_0("M4PTO3GPP_Open(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4PTO3GPP_Step(M4PTO3GPP_Context pContext);
 * @brief   Perform one step of trancoding.
 * @note
 * @param   pContext            (IN) M4PTO3GPP context
 * @return  M4NO_ERROR          No error
 * @return  M4ERR_PARAMETER     pContext is M4OSA_NULL
 * @return  M4ERR_STATE:    M4PTO3GPP is not in an appropriate state for this function
 *                           to be called
 * @return  M4PTO3GPP_WAR_END_OF_PROCESSING Encoding completed
 ******************************************************************************
*/
/*********************************************************/
M4OSA_ERR M4PTO3GPP_Step(M4PTO3GPP_Context pContext)
/*********************************************************/
{
    M4PTO3GPP_InternalContext *pC = (M4PTO3GPP_InternalContext*)(pContext);
    M4OSA_ERR err = M4NO_ERROR;
    M4OSA_UInt32 l_uiAudioStepCount = 0;
    M4OSA_Int32  JumpToTime = 0;
    M4OSA_Time  mtIncCts;

    /**
     *  Check input parameters */
    M4OSA_DEBUG_IF2((M4OSA_NULL==pContext), M4ERR_PARAMETER,
                "M4PTO3GPP_Step: pContext is M4OSA_NULL");

    /**
     *  Check state automaton */
    if ( !((M4PTO3GPP_kState_OPENED == pC->m_State) || (M4PTO3GPP_kState_READY == pC->m_State)) )
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Step(): Wrong State (%d), returning M4ERR_STATE", pC->m_State);
        return M4ERR_STATE;
    }

    /******************************************************************/
    /**
     *  In case this is the first step, we prepare the decoder, the encoder and the writer */
    if (M4PTO3GPP_kState_OPENED == pC->m_State)
    {
        M4OSA_TRACE2_0("M4PTO3GPP_Step(): This is the first step, \
                       calling M4PTO3GPP_Ready4Processing");

        /**
         *  Prepare the reader, the decoder, the encoder, the writer... */
        err = M4PTO3GPP_Ready4Processing(pC);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Step(): M4PTO3GPP_Ready4Processing() returns 0x%x", err);
            return err;
        }

        /**
         *  Update state automaton */
        pC->m_State = M4PTO3GPP_kState_READY;

        M4OSA_TRACE3_0("M4PTO3GPP_Step(): returning M4NO_ERROR (a)");
        return M4NO_ERROR; /**< we only do that in the first step, \
                           first REAL step will be the next one */
    }


    /*
     * Check if we reached the targeted file size.
     * We do that before the encoding, because the core encoder has to know if this is
     * the last frame to encode */
    err = pC->m_pWriterGlobInt->pFctGetOption(pC->m_p3gpWriterContext,
        M4WRITER_kFileSizeAudioEstimated, (M4OSA_DataOption) &pC->m_CurrentFileSize);
    if ((0 != pC->m_MaxFileSize) &&
        /**< Add a marge to the file size in order to never exceed the max file size */
       ((pC->m_CurrentFileSize + M4PTO3GPP_MARGE_OF_FILE_SIZE) >= pC->m_MaxFileSize))
    {
        pC->m_IsLastPicture = M4OSA_TRUE;
    }

    /******************************************************************
    *  At that point we are in M4PTO3GPP_kState_READY state
    *  We perform one step of video encoding
    ******************************************************************/

    /************* VIDEO ENCODING ***************/
    if (M4PTO3GPP_kStreamState_STARTED == pC->m_VideoState) /**<If the video encoding is going on*/
    {   /**
         * Call the encoder  */
        pC->m_NbCurrentFrame++;

        /* Check if it is the last frame the to encode */
        if((pC->m_Params.NbVideoFrames > 0) \
            && (pC->m_NbCurrentFrame >= pC->m_Params.NbVideoFrames))
        {
            pC->m_IsLastPicture = M4OSA_TRUE;
        }

        M4OSA_TRACE2_2("M4PTO3GPP_Step(): Calling pEncoderInt->pFctEncode with videoCts = %.2f\
                       nb = %lu", pC->m_mtCts, pC->m_NbCurrentFrame);

        err = pC->m_pEncoderInt->pFctEncode(pC->m_pMp4EncoderContext, M4OSA_NULL,
            /**< The input plane is null because the input Picture will be obtained by the\
            VPP filter from the context */
                                        pC->m_mtCts,
                                        (pC->m_IsLastPicture ?
                                        M4ENCODER_kLastFrame : M4ENCODER_kNormalFrame) );
        /**< Last param set to M4OSA_TRUE signals that this is the last frame to be encoded,\
        M4OSA_FALSE else */

        M4OSA_TRACE3_2("M4PTO3GPP_Step(): pEncoderInt->pFctEncode returns 0x%x, vidFormat =0x%x",
            err, pC->m_Params.OutputVideoFormat);
        if((M4NO_ERROR == err) && (M4VIDEOEDITING_kH264 == pC->m_Params.OutputVideoFormat))
        {
            /* Check if last frame.*
            *                  */
            if(M4OSA_TRUE == pC->m_IsLastPicture)
            {
                M4OSA_TRACE3_0("M4PTO3GPP_Step(): Last picture");
                pC->m_VideoState = M4PTO3GPP_kStreamState_FINISHED;
            }

        }

        if (M4WAR_NO_MORE_AU == err) /**< The video encoding is finished */
        {
            M4OSA_TRACE3_0("M4PTO3GPP_Step(): pEncoderInt->pFctEncode returns M4WAR_NO_MORE_AU");
            pC->m_VideoState = M4PTO3GPP_kStreamState_FINISHED;
        }
        else if (M4NO_ERROR != err)     /**< Unexpected error code */
        {
            if( (((M4OSA_UInt32)M4WAR_WRITER_STOP_REQ) == err) ||
                    (((M4OSA_UInt32)M4ERR_ALLOC) == err) )
            {
                M4OSA_TRACE1_0("M4PTO3GPP_Step: returning ERR_PTO3GPP_ENCODER_ACCES_UNIT_ERROR");
                return ERR_PTO3GPP_ENCODER_ACCES_UNIT_ERROR;
            }
            else
            {
                M4OSA_TRACE1_1("M4PTO3GPP_Step(): pEncoderInt->pFctEncode(last) (a) returns 0x%x",
                    err);
                return err;
            }
        }
    } /**< End of video encoding */


    /****** AUDIO TRANSCODING (read + null encoding + write) ******/
    if (M4PTO3GPP_kStreamState_STARTED == pC->m_AudioState)
    {
        while ( (M4PTO3GPP_kStreamState_STARTED == pC->m_AudioState) &&
                (pC->m_mtAudioCts < pC->m_mtNextCts))

        {
            l_uiAudioStepCount++;
            if (M4OSA_FALSE == pC->m_bAudioPaddingSilence)
            {
                /**< Read the next audio AU in the input Audio file */
                err = pC->m_pReaderDataInt->m_pFctGetNextAu(pC->m_pAudioReaderContext,
                    (M4_StreamHandler*)pC->m_pReaderAudioStream, pC->m_pReaderAudioAU);
                pC->m_mtAudioCts = pC->m_pReaderAudioAU->m_CTS + pC->m_AudioOffSet;

                if (M4WAR_NO_MORE_AU == err)    /* The audio transcoding is finished */
                {
                    M4OSA_TRACE2_0("M4PTO3GPP_Step():\
                                  pReaderDataInt->m_pFctGetNextAu(audio) returns \
                                    M4WAR_NO_MORE_AU");
                    switch(pC->m_Params.AudioPaddingMode)
                    {
                        case M4PTO3GPP_kAudioPaddingMode_None:

                            pC->m_AudioState = M4PTO3GPP_kStreamState_FINISHED;
                            break;

                        case M4PTO3GPP_kAudioPaddingMode_Silence:

                            if (M4DA_StreamTypeAudioAmrNarrowBand
                                != pC->m_pReaderAudioStream->m_basicProperties.m_streamType)
                                /**< Do nothing if the input audio file format is not AMR */
                            {
                                pC->m_AudioState = M4PTO3GPP_kStreamState_FINISHED;
                            }
                            else
                            {
                                pC->m_bAudioPaddingSilence = M4OSA_TRUE;
                            }
                            break;

                        case M4PTO3GPP_kAudioPaddingMode_Loop:

                            /**< Jump to the beginning of the audio file */
                            err = pC->m_pReaderGlobInt->m_pFctJump(pC->m_pAudioReaderContext,
                                (M4_StreamHandler*)pC->m_pReaderAudioStream, &JumpToTime);

                            if (M4NO_ERROR != err)
                            {
                                M4OSA_TRACE1_1("M4PTO3GPP_Step(): \
                                              pReaderDataInt->m_pFctReset(audio returns 0x%x",
                                               err);
                                return err;
                            }

                            if (M4DA_StreamTypeAudioAmrNarrowBand
                                == pC->m_pReaderAudioStream->m_basicProperties.m_streamType)
                            {
                                pC->m_mtAudioCts += 20; /*< SEMC bug fixed at Lund */
                                pC->m_AudioOffSet = pC->m_mtAudioCts;

                                /**
                                 * 'BZZZ' bug fix:
                                 * add a silence frame */
                                mtIncCts = (M4OSA_Time)((pC->m_mtAudioCts) *
                                    (pC->m_pWriterAudioStream->timeScale / 1000.0));
                                err = M4PTO3GPP_writeAmrSilence122Frame(pC->m_pWriterDataInt,
                                    pC->m_p3gpWriterContext, &pC->m_WriterAudioAU, mtIncCts);

                                if (M4NO_ERROR != err)
                                {
                                    M4OSA_TRACE1_1("M4PTO3GPP_Step(): \
                                                   M4PTO3GPP_AddAmrSilenceSid returns 0x%x", err);
                                    return err;
                                }/**< Add => no audio cts increment...*/
                            }
                            else
                            {
                                pC->m_AudioOffSet = pC->m_mtAudioCts + pC->m_DeltaAudioCts;
                            }
                            break;
                    } /* end of: switch */
                }
                else if (M4NO_ERROR != err)
                {
                    M4OSA_TRACE1_1("M4PTO3GPP_Step(): pReaderDataInt->m_pFctGetNextAu(Audio)\
                                   returns 0x%x", err);
                    return err;
                }
                else
                {
                    /**
                     * Save the delta Cts (AAC only) */
                    pC->m_DeltaAudioCts = pC->m_pReaderAudioAU->m_CTS - pC->m_PrevAudioCts;
                    pC->m_PrevAudioCts  = pC->m_pReaderAudioAU->m_CTS;

                    /**
                     *  Prepare the writer AU */
                    err = pC->m_pWriterDataInt->pStartAU(pC->m_p3gpWriterContext, 1,
                        &pC->m_WriterAudioAU);
                    if (M4NO_ERROR != err)
                    {
                        M4OSA_TRACE1_1("M4PTO3GPP_Step(): pWriterDataInt->pStartAU(Audio)\
                                       returns 0x%x", err);
                        return err;
                    }

                    /**
                     *  Copy audio data from reader AU to writer AU */
                    M4OSA_TRACE2_1("M4PTO3GPP_Step(): Copying audio AU: size=%d",
                        pC->m_pReaderAudioAU->m_size);
                    memcpy((void *)pC->m_WriterAudioAU.dataAddress,
                        (void *)pC->m_pReaderAudioAU->m_dataAddress,
                        pC->m_pReaderAudioAU->m_size);
                    pC->m_WriterAudioAU.size = pC->m_pReaderAudioAU->m_size;

                    /**
                     *  Convert CTS unit from milliseconds to timescale */
                    if (M4DA_StreamTypeAudioAmrNarrowBand
                        != pC->m_pReaderAudioStream->m_basicProperties.m_streamType)
                    {
                        pC->m_WriterAudioAU.CTS  = (M4OSA_Time)
                            ((pC->m_AudioOffSet + pC->m_pReaderAudioAU->m_CTS)
                            * pC->m_pWriterAudioStream->timeScale / 1000.0);
                    }
                    else
                    {
                        pC->m_WriterAudioAU.CTS = (M4OSA_Time)(pC->m_mtAudioCts *
                            (pC->m_pWriterAudioStream->timeScale / 1000.0));
                    }
                    pC->m_WriterAudioAU.nbFrag = 0;
                    M4OSA_TRACE2_1("M4PTO3GPP_Step(): audio AU: CTS=%d ms", pC->m_mtAudioCts
                        /*pC->m_pReaderAudioAU->m_CTS*/);

                    /**
                     *  Write it to the output file */
                    err = pC->m_pWriterDataInt->pProcessAU(pC->m_p3gpWriterContext, 1,
                        &pC->m_WriterAudioAU);

                    if (M4NO_ERROR != err)
                    {
                        M4OSA_TRACE1_1("M4PTO3GPP_Step(): pWriterDataInt->pProcessAU(Audio)\
                                       returns 0x%x", err);
                        return err;
                    }
                }
            }
            else /**< M4OSA_TRUE == pC->m_bAudioPaddingSilence */
            {
                if (M4DA_StreamTypeAudioAmrNarrowBand ==
                    pC->m_pReaderAudioStream->m_basicProperties.m_streamType)
                {
                    /**
                     * Fill in audio au with silence */
                    pC->m_mtAudioCts += 20;

                    /**
                     * Padd with silence */
                    mtIncCts = (M4OSA_Time)(pC->m_mtAudioCts
                        * (pC->m_pWriterAudioStream->timeScale / 1000.0));
                    err = M4PTO3GPP_writeAmrSilence048Frame(pC->m_pWriterDataInt,
                        pC->m_p3gpWriterContext, &pC->m_WriterAudioAU, mtIncCts);

                    if (M4NO_ERROR != err)
                    {
                        M4OSA_TRACE1_1("M4PTO3GPP_Step(): M4PTO3GPP_AddAmrSilenceSid returns 0x%x",
                            err);
                        return err;
                    }
                }
                else /**< Do nothing if the input audio file format is not AMR */
                {
                    pC->m_AudioState = M4PTO3GPP_kStreamState_FINISHED;
                }

            }
        } /**< while */
    } /**< End of audio encoding */

    pC->m_mtCts = pC->m_mtNextCts;

    /**
     *  The transcoding is finished when no stream is being encoded anymore */
    if (M4PTO3GPP_kStreamState_FINISHED == pC->m_VideoState)
    {
        pC->m_State = M4PTO3GPP_kState_FINISHED;
        M4OSA_TRACE2_0("M4PTO3GPP_Step(): transcoding finished, returning M4WAR_NO_MORE_AU");
        return M4PTO3GPP_WAR_END_OF_PROCESSING;
    }

    M4OSA_TRACE3_0("M4PTO3GPP_Step(): returning M4NO_ERROR (b)");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4PTO3GPP_Close(M4PTO3GPP_Context pContext);
 * @brief   Finish the M4PTO3GPP transcoding.
 * @note    The output 3GPP file is ready to be played after this call
 * @param   pContext            (IN) M4PTO3GPP context
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    pContext is M4OSA_NULL (If Debug Level >= 2)
 * @return  M4ERR_STATE:    M4PTO3GPP is not in an appropriate state for this function to be called
 ******************************************************************************
*/
/*********************************************************/
M4OSA_ERR M4PTO3GPP_Close(M4PTO3GPP_Context pContext)
/*********************************************************/
{
    M4PTO3GPP_InternalContext *pC = (M4PTO3GPP_InternalContext*)(pContext);
    M4OSA_ERR    osaErr = M4NO_ERROR;
    M4OSA_UInt32 lastCTS;
    M4ENCODER_Header* encHeader;
    M4SYS_StreamIDmemAddr streamHeader;

    M4OSA_TRACE3_1("M4PTO3GPP_Close called with pContext=0x%x", pContext);

    /**
     *  Check input parameters */
    M4OSA_DEBUG_IF2((M4OSA_NULL==pContext), M4ERR_PARAMETER, "M4PTO3GPP_Close:\
                                                             pContext is M4OSA_NULL");

    /* Check state automaton */
    if ((pC->m_State != M4PTO3GPP_kState_OPENED) &&
        (pC->m_State != M4PTO3GPP_kState_READY) &&
        (pC->m_State != M4PTO3GPP_kState_FINISHED))
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Close(): Wrong State (%d), returning M4ERR_STATE", pC->m_State);
        return M4ERR_STATE;
    }

    /*************************************/
    /******** Finish the encoding ********/
    /*************************************/
    if (M4PTO3GPP_kState_READY == pC->m_State)
    {
        pC->m_State = M4PTO3GPP_kState_FINISHED;
    }

    if (M4PTO3GPP_kEncoderRunning == pC->m_eEncoderState)
    {
        if (pC->m_pEncoderInt->pFctStop != M4OSA_NULL)
        {
            osaErr = pC->m_pEncoderInt->pFctStop(pC->m_pMp4EncoderContext);
            if (M4NO_ERROR != osaErr)
            {
                M4OSA_TRACE1_1("M4PTO3GPP_close: m_pEncoderInt->pFctStop returns 0x%x", osaErr);
                /* Well... how the heck do you handle a failed cleanup? */
            }
        }

        pC->m_eEncoderState = M4PTO3GPP_kEncoderStopped;
    }

    /* Has the encoder actually been opened? Don't close it if that's not the case. */
    if (M4PTO3GPP_kEncoderStopped == pC->m_eEncoderState)
    {
        osaErr = pC->m_pEncoderInt->pFctClose(pC->m_pMp4EncoderContext);
        if (M4NO_ERROR != osaErr)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_close: m_pEncoderInt->pFctClose returns 0x%x", osaErr);
            /* Well... how the heck do you handle a failed cleanup? */
        }

        pC->m_eEncoderState = M4PTO3GPP_kEncoderClosed;
    }

    /*******************************/
    /******** Close 3GP out ********/
    /*******************************/

    if (M4OSA_NULL != pC->m_p3gpWriterContext)  /* happens in state _SET */
    {
        /* HW encoder: fetch the DSI from the shell video encoder, and feed it to the writer before
        closing it. */
        if ((M4VIDEOEDITING_kMPEG4 == pC->m_Params.OutputVideoFormat)
            || (M4VIDEOEDITING_kH264 == pC->m_Params.OutputVideoFormat))
        {
            osaErr = pC->m_pEncoderInt->pFctGetOption(pC->m_pMp4EncoderContext,
                M4ENCODER_kOptionID_EncoderHeader,
                                                            (M4OSA_DataOption)&encHeader);
            if ( (M4NO_ERROR != osaErr) || (M4OSA_NULL == encHeader->pBuf) )
            {
                M4OSA_TRACE1_1("M4PTO3GPP_close: failed to get the encoder header (err 0x%x)",
                    osaErr);
                /**< no return here, we still have stuff to deallocate after close, even if \
                it fails. */
            }
            else
            {
                /* set this header in the writer */
                streamHeader.streamID = M4PTO3GPP_WRITER_VIDEO_STREAM_ID;
                streamHeader.size = encHeader->Size;
                streamHeader.addr = (M4OSA_MemAddr32)encHeader->pBuf;
                osaErr = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext,
                    M4WRITER_kDSI, &streamHeader);
                if (M4NO_ERROR != osaErr)
                {
                    M4OSA_TRACE1_1("M4PTO3GPP_close: failed to set the DSI in the writer \
                                (err 0x%x)   ", osaErr);
                }
            }
        }

        /* Update last Video CTS */
        lastCTS = (M4OSA_UInt32)pC->m_mtCts;

        osaErr = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext,
            (M4OSA_UInt32)M4WRITER_kMaxFileDuration, &lastCTS);
        if (M4NO_ERROR != osaErr)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Close: SetOption(M4WRITER_kMaxFileDuration) returns 0x%x",
                osaErr);
        }

        /* Write and close the 3GP output file */
        osaErr = pC->m_pWriterGlobInt->pFctCloseWrite(pC->m_p3gpWriterContext);
        if (M4NO_ERROR != osaErr)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Close: pWriterGlobInt->pFctCloseWrite returns 0x%x", osaErr);
            /**< don't return yet, we have to close other things */
        }
        pC->m_p3gpWriterContext = M4OSA_NULL;
    }

    /**
     * State transition */
    pC->m_State = M4PTO3GPP_kState_CLOSED;

    M4OSA_TRACE3_1("M4PTO3GPP_Close(): returning 0x%x", osaErr);
    return osaErr;
}


/**
 ******************************************************************************
 * M4OSA_ERR M4PTO3GPP_CleanUp(M4PTO3GPP_Context pContext);
 * @brief   Free all resources used by the M4PTO3GPP.
 * @note    The context is no more valid after this call
 * @param   pContext            (IN) M4PTO3GPP context
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    pContext is M4OSA_NULL (If Debug Level >= 2)
 ******************************************************************************
*/
/*********************************************************/
M4OSA_ERR M4PTO3GPP_CleanUp(M4PTO3GPP_Context pContext)
/*********************************************************/
{
    M4OSA_ERR err = M4NO_ERROR;
    M4PTO3GPP_InternalContext *pC = (M4PTO3GPP_InternalContext*)(pContext);

    M4OSA_TRACE3_1("M4PTO3GPP_CleanUp called with pContext=0x%x", pContext);

    /**
     *  Check input parameters */
    M4OSA_DEBUG_IF2((M4OSA_NULL==pContext),M4ERR_PARAMETER, "M4PTO3GPP_CleanUp: pContext \
                                                            is M4OSA_NULL");

    /**
     *  First call Close, if needed, to clean the video encoder */

    if ((M4PTO3GPP_kState_OPENED == pC->m_State) || (M4PTO3GPP_kState_READY == pC->m_State)
        || (M4PTO3GPP_kState_FINISHED == pC->m_State))
    {
        err = M4PTO3GPP_Close(pContext);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_CleanUp: M4PTO3GPP_Close returns 0x%x", err);
            /**< don't return, we have to free other components */
        }
    }

    /**
     *  Free Audio reader stuff, if needed */

    if (M4OSA_NULL != pC->m_pAudioReaderContext) /**< may be M4OSA_NULL if M4PTO3GPP_Open was not\
                                                 called */
    {

        err = pC->m_pReaderGlobInt->m_pFctClose(pC->m_pAudioReaderContext);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_CleanUp: pReaderGlobInt->m_pFctClose returns 0x%x", err);
            /**< don't return, we have to free other components */
        }
        err = pC->m_pReaderGlobInt->m_pFctDestroy(pC->m_pAudioReaderContext);
        pC->m_pAudioReaderContext = M4OSA_NULL;
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_CleanUp: pReaderGlobInt->m_pFctDestroy returns 0x%x", err);
            /**< don't return, we have to free other components */
        }
    }

    if (M4OSA_NULL != pC->m_pReaderAudioAU)
    {
        free(pC->m_pReaderAudioAU);
        pC->m_pReaderAudioAU = M4OSA_NULL;
    }

    /**
     *  Free video encoder stuff, if needed */
    if (M4OSA_NULL != pC->m_pMp4EncoderContext)
    {
        err = pC->m_pEncoderInt->pFctCleanup(pC->m_pMp4EncoderContext);
        pC->m_pMp4EncoderContext = M4OSA_NULL;
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_CleanUp: pEncoderInt->pFctDestroy returns 0x%x", err);
            /**< don't return, we have to free other components */
        }
    }

    if (M4OSA_NULL != pC->m_pWriterVideoStream)
    {
        free(pC->m_pWriterVideoStream);
        pC->m_pWriterVideoStream = M4OSA_NULL;
    }
    if (M4OSA_NULL != pC->m_pWriterAudioStream)
    {
        free(pC->m_pWriterAudioStream);
        pC->m_pWriterAudioStream = M4OSA_NULL;
    }
    if (M4OSA_NULL != pC->m_pWriterVideoStreamInfo)
    {
        free(pC->m_pWriterVideoStreamInfo);
        pC->m_pWriterVideoStreamInfo = M4OSA_NULL;
    }
    if (M4OSA_NULL != pC->m_pWriterAudioStreamInfo)
    {
        free(pC->m_pWriterAudioStreamInfo);
        pC->m_pWriterAudioStreamInfo = M4OSA_NULL;
    }


    /**
     *  Free the shells interfaces */
    if (M4OSA_NULL != pC->m_pReaderGlobInt)
    {
        free(pC->m_pReaderGlobInt);
        pC->m_pReaderGlobInt = M4OSA_NULL;
    }
    if (M4OSA_NULL != pC->m_pReaderDataInt)
    {
        free(pC->m_pReaderDataInt);
        pC->m_pReaderDataInt = M4OSA_NULL;
    }

    if(M4OSA_NULL != pC->m_pEncoderInt)
    {
        free(pC->m_pEncoderInt);
        pC->m_pEncoderInt = M4OSA_NULL;
    }
    if(M4OSA_NULL != pC->m_pWriterGlobInt)
    {
        free(pC->m_pWriterGlobInt);
        pC->m_pWriterGlobInt = M4OSA_NULL;
    }
    if(M4OSA_NULL != pC->m_pWriterDataInt)
    {
        free(pC->m_pWriterDataInt);
        pC->m_pWriterDataInt = M4OSA_NULL;
    }
    /**< Do not free pC->pOsaMemoryPtrFct and pC->pOsaMemoryPtrFct, because it's owned by the \
    application */

    /**
     *  Free the context itself */
    free(pC);
    pC = M4OSA_NULL;

    M4OSA_TRACE3_0("M4PTO3GPP_CleanUp(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/********************* INTERNAL FUNCTIONS *********************/

/**
 ******************************************************************************
 * M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC);
 * @brief   Prepare all resources and interfaces for the transcoding.
 * @note    It is called by the first M4OSA_Step() call
 * @param   pC          (IN) M4PTO3GPP private context
 * @return  M4NO_ERROR: No error
 * @return  Any error returned by an underlaying module
 ******************************************************************************
*/
/******************************************************/
M4OSA_ERR M4PTO3GPP_Ready4Processing(M4PTO3GPP_InternalContext* pC)
/******************************************************/
{
    M4OSA_ERR               err = M4NO_ERROR;
    M4WRITER_OutputFileType outputFileType;
    M4OSA_UInt32            uiVersion;
    M4ENCODER_Format        encFormat;
    M4ENCODER_AdvancedParams   EncParams;    /**< Encoder advanced parameters */
    M4SYS_StreamIDValue     optionValue;

    M4OSA_TRACE3_1("M4PTO3GPP_Ready4Processing called with pC=0x%x", pC);

    /******************************/
    /******************************/

    /********************************************/
    /********                            ********/
    /******** Video Encoder Parames init ********/
    /********                            ********/
    /********************************************/

    /**
     *  Get the correct encoder interface */
    switch(pC->m_Params.OutputVideoFormat)
    {
        case M4VIDEOEDITING_kMPEG4:
#ifdef M4VSS_SUPPORT_ENCODER_MPEG4
                err = VideoEditorVideoEncoder_getInterface_MPEG4(&encFormat, &pC->m_pEncoderInt,
                    M4ENCODER_OPEN_ADVANCED);
#else /* software MPEG4 encoder not available! */
                M4OSA_TRACE1_0("No MPEG4 encoder available! Did you forget to register one?");
                err = M4ERR_STATE;
#endif /* software MPEG4 encoder available? */
            break;
        case M4VIDEOEDITING_kH263:
#ifdef M4VSS_SUPPORT_ENCODER_MPEG4
                err = VideoEditorVideoEncoder_getInterface_H263(&encFormat, &pC->m_pEncoderInt,
                    M4ENCODER_OPEN_ADVANCED);
#else /* software H263 encoder not available! */
                M4OSA_TRACE1_0("No H263 encoder available! Did you forget to register one?");
                err = M4ERR_STATE;
#endif /* software H263 encoder available? */
            break;
        case M4VIDEOEDITING_kH264:
#ifdef M4VSS_SUPPORT_ENCODER_AVC
                err = VideoEditorVideoEncoder_getInterface_H264(&encFormat, &pC->m_pEncoderInt,
                    M4ENCODER_OPEN_ADVANCED);
#else /* software H264 encoder not available! */
                M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing: No H264 encoder available!\
                               Did you forget to register one?");
                err = M4ERR_STATE;
#endif /* software H264 encoder available? */
            break;
        default:
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning \
                           ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT",
                           pC->m_Params.OutputVideoFormat);
            return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT;
    }
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("switch(pC->m_Params.OutputVideoFormat): getInterfaces returns 0x%x", err);
        return err;
    }

    /**
     *  Fill encoder parameters according to M4PTO3GPP settings */

    /**
     * Video frame size */
    switch(pC->m_Params.OutputVideoFrameSize)
    {
        case M4VIDEOEDITING_kSQCIF :
            EncParams.FrameHeight = M4ENCODER_SQCIF_Height;
            EncParams.FrameWidth  = M4ENCODER_SQCIF_Width;
            break;
        case M4VIDEOEDITING_kQQVGA :
            EncParams.FrameHeight = M4ENCODER_QQVGA_Height;
            EncParams.FrameWidth  = M4ENCODER_QQVGA_Width;
            break;
        case M4VIDEOEDITING_kQCIF :
            EncParams.FrameHeight = M4ENCODER_QCIF_Height;
            EncParams.FrameWidth  = M4ENCODER_QCIF_Width;
            break;
        case M4VIDEOEDITING_kQVGA :
            EncParams.FrameHeight = M4ENCODER_QVGA_Height;
            EncParams.FrameWidth  = M4ENCODER_QVGA_Width;
            break;
        case M4VIDEOEDITING_kCIF :
            EncParams.FrameHeight = M4ENCODER_CIF_Height;
            EncParams.FrameWidth  = M4ENCODER_CIF_Width;
            break;
        case M4VIDEOEDITING_kVGA :
            EncParams.FrameHeight = M4ENCODER_VGA_Height;
            EncParams.FrameWidth  = M4ENCODER_VGA_Width;
            break;
/* +PR LV5807 */
        case M4VIDEOEDITING_kWVGA :
            EncParams.FrameHeight = M4ENCODER_WVGA_Height;
            EncParams.FrameWidth  = M4ENCODER_WVGA_Width;
            break;
        case M4VIDEOEDITING_kNTSC:
            EncParams.FrameHeight = M4ENCODER_NTSC_Height;
            EncParams.FrameWidth  = M4ENCODER_NTSC_Width;
            break;
/* -PR LV5807 */
/* +CR Google */
        case M4VIDEOEDITING_k640_360:
            EncParams.FrameHeight = M4ENCODER_640_360_Height;
            EncParams.FrameWidth  = M4ENCODER_640_360_Width;
            break;

        case M4VIDEOEDITING_k854_480:
            EncParams.FrameHeight = M4ENCODER_854_480_Height;
            EncParams.FrameWidth  = M4ENCODER_854_480_Width;
            break;

        case M4VIDEOEDITING_k1280_720:
            EncParams.FrameHeight = M4ENCODER_1280_720_Height;
            EncParams.FrameWidth  = M4ENCODER_1280_720_Width;
            break;

        case M4VIDEOEDITING_k1080_720:
            EncParams.FrameHeight = M4ENCODER_1080_720_Height;
            EncParams.FrameWidth  = M4ENCODER_1080_720_Width;
            break;

        case M4VIDEOEDITING_k960_720:
            EncParams.FrameHeight = M4ENCODER_960_720_Height;
            EncParams.FrameWidth  = M4ENCODER_960_720_Width;
            break;

        case M4VIDEOEDITING_k1920_1080:
            EncParams.FrameHeight = M4ENCODER_1920_1080_Height;
            EncParams.FrameWidth  = M4ENCODER_1920_1080_Width;
            break;
/* -CR Google */
        default :
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning \
                           ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE",
                           pC->m_Params.OutputVideoFrameSize);
            return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE;
    }

    EncParams.InputFormat = M4ENCODER_kIYUV420;

    /**
     * Video bitrate */
    switch(pC->m_Params.OutputVideoBitrate)
    {
        case M4VIDEOEDITING_k16_KBPS:
        case M4VIDEOEDITING_k24_KBPS:
        case M4VIDEOEDITING_k32_KBPS:
        case M4VIDEOEDITING_k48_KBPS:
        case M4VIDEOEDITING_k64_KBPS:
        case M4VIDEOEDITING_k96_KBPS:
        case M4VIDEOEDITING_k128_KBPS:
        case M4VIDEOEDITING_k192_KBPS:
        case M4VIDEOEDITING_k256_KBPS:
        case M4VIDEOEDITING_k288_KBPS:
        case M4VIDEOEDITING_k384_KBPS:
        case M4VIDEOEDITING_k512_KBPS:
        case M4VIDEOEDITING_k800_KBPS:
/*+ New Encoder bitrates */
        case M4VIDEOEDITING_k2_MBPS:
        case M4VIDEOEDITING_k5_MBPS:
        case M4VIDEOEDITING_k8_MBPS:
/*- New Encoder bitrates */
            EncParams.Bitrate = pC->m_Params.OutputVideoBitrate;
            break;

        case M4VIDEOEDITING_kVARIABLE_KBPS:
/*+ New Encoder bitrates */
            EncParams.Bitrate = M4VIDEOEDITING_k8_MBPS;
/*- New Encoder bitrates */
            break;

        default :
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning\
                           ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE",
                           pC->m_Params.OutputVideoBitrate);
            return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE;
    }

    /**
     * Video format */
    switch(pC->m_Params.OutputVideoFormat)
    {
        case M4VIDEOEDITING_kMPEG4 :
            EncParams.Format    = M4ENCODER_kMPEG4;
            break;
        case M4VIDEOEDITING_kH263 :
            EncParams.Format    = M4ENCODER_kH263;
            break;
        case M4VIDEOEDITING_kH264:
            EncParams.Format    = M4ENCODER_kH264;
            break;
        default :
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning\
                           ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT",
                           pC->m_Params.OutputVideoFormat);
            return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT;
    }

    /**
     * Video frame rate (set it to max = 30 fps) */
    EncParams.uiTimeScale = 30;
    EncParams.uiRateFactor = 1;

    EncParams.FrameRate = M4ENCODER_k30_FPS;


    /******************************/
    /******** 3GP out init ********/
    /******************************/

    /* Get the 3GPP writer interface */
    err = M4WRITER_3GP_getInterfaces(&outputFileType, &pC->m_pWriterGlobInt, &pC->m_pWriterDataInt);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4WRITER_3GP_getInterfaces: M4WRITER_3GP_getInterfaces returns 0x%x", err);
        return err;
    }

    /* Init the 3GPP writer */
    err = pC->m_pWriterGlobInt->pFctOpen(&pC->m_p3gpWriterContext, pC->m_Params.pOutput3gppFile,
        pC->pOsalFileWrite, pC->m_Params.pTemporaryFile, pC->pOsalFileRead);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctOpen returns 0x%x", err);
        return err;
    }

    /**
     *  Link to the writer context in the writer interface */
    pC->m_pWriterDataInt->pWriterContext = pC->m_p3gpWriterContext;

    /**
     *  Set the product description string in the written file */
    err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, M4WRITER_kEmbeddedString,
        (M4OSA_DataOption)M4PTO3GPP_SIGNATURE);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: \
                       pWriterGlobInt->pFctSetOption(M4WRITER_kEmbeddedString) returns 0x%x", err);
        return err;
    }

    /**
     *  Set the product version in the written file */
    uiVersion = M4VIDEOEDITING_VERSION_MAJOR*100 + M4VIDEOEDITING_VERSION_MINOR*10
        + M4VIDEOEDITING_VERSION_REVISION;
    err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext, M4WRITER_kEmbeddedVersion,
        (M4OSA_DataOption)&uiVersion);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: \
                       pWriterGlobInt->pFctSetOption(M4WRITER_kEmbeddedVersion) returns 0x%x", err);
        return err;
    }

    /**
     *  Allocate and fill the video stream structures for the writer */
    pC->m_pWriterVideoStream =
        (M4SYS_StreamDescription*)M4OSA_32bitAlignedMalloc(sizeof(M4SYS_StreamDescription), M4PTO3GPP,
        (M4OSA_Char *)"pWriterVideoStream");
    if (M4OSA_NULL == pC->m_pWriterVideoStream)
    {
        M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing(): unable to allocate pWriterVideoStream, \
                       returning M4ERR_ALLOC");
        return M4ERR_ALLOC;
    }
    pC->m_pWriterVideoStreamInfo =
        (M4WRITER_StreamVideoInfos*)M4OSA_32bitAlignedMalloc(sizeof(M4WRITER_StreamVideoInfos), M4PTO3GPP,
        (M4OSA_Char *)"pWriterVideoStreamInfo");
    if (M4OSA_NULL == pC->m_pWriterVideoStreamInfo)
    {
        M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing(): unable to allocate pWriterVideoStreamInfo,\
                       returning M4ERR_ALLOC");
        return M4ERR_ALLOC;
    }

    /**
     * Fill Video properties structure for the AddStream method */
    pC->m_pWriterVideoStreamInfo->height        = EncParams.FrameHeight;
    pC->m_pWriterVideoStreamInfo->width         = EncParams.FrameWidth;
    pC->m_pWriterVideoStreamInfo->fps           = 0;        /**< Not used by the core writer */
    pC->m_pWriterVideoStreamInfo->Header.pBuf   = M4OSA_NULL;
    /** No header, will be set by setOption */
    pC->m_pWriterVideoStreamInfo->Header.Size   = 0;

    /**
     *  Fill Video stream description structure for the AddStream method */
    pC->m_pWriterVideoStream->streamID = M4PTO3GPP_WRITER_VIDEO_STREAM_ID;

    /**
     * Video format */
    switch(pC->m_Params.OutputVideoFormat)
    {
        case M4VIDEOEDITING_kMPEG4:
            pC->m_pWriterVideoStream->streamType = M4SYS_kMPEG_4;   break;
        case M4VIDEOEDITING_kH263:
            pC->m_pWriterVideoStream->streamType = M4SYS_kH263;     break;
        case M4VIDEOEDITING_kH264:
            pC->m_pWriterVideoStream->streamType = M4SYS_kH264;     break;
        default :
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning \
                           ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT",
                           pC->m_Params.OutputVideoFormat);
            return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_FORMAT;
    }

    /**
     * Video bitrate */
    switch(pC->m_Params.OutputVideoBitrate)
    {
        case M4VIDEOEDITING_k16_KBPS:
        case M4VIDEOEDITING_k24_KBPS:
        case M4VIDEOEDITING_k32_KBPS:
        case M4VIDEOEDITING_k48_KBPS:
        case M4VIDEOEDITING_k64_KBPS:
        case M4VIDEOEDITING_k96_KBPS:
        case M4VIDEOEDITING_k128_KBPS:
        case M4VIDEOEDITING_k192_KBPS:
        case M4VIDEOEDITING_k256_KBPS:
        case M4VIDEOEDITING_k288_KBPS:
        case M4VIDEOEDITING_k384_KBPS:
        case M4VIDEOEDITING_k512_KBPS:
        case M4VIDEOEDITING_k800_KBPS:
/*+ New Encoder bitrates */
        case M4VIDEOEDITING_k2_MBPS:
        case M4VIDEOEDITING_k5_MBPS:
        case M4VIDEOEDITING_k8_MBPS:
/*- New Encoder bitrates */
            pC->m_pWriterVideoStream->averageBitrate = pC->m_Params.OutputVideoBitrate;
            break;

        case M4VIDEOEDITING_kVARIABLE_KBPS :
            pC->m_pWriterVideoStream->averageBitrate = 0;
            break;

        default :
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unknown format 0x%x returning\
                           ERR_M4PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE",
                           pC->m_Params.OutputVideoBitrate);
            return ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE;
    }

    pC->m_pWriterVideoStream->duration                  = 0;        /**< Duration is not known */
    pC->m_pWriterVideoStream->timeScale                 = 0;    /**< Not used by the core writer */
    pC->m_pWriterVideoStream->maxBitrate                = pC->m_pWriterVideoStream->averageBitrate;
    pC->m_pWriterVideoStream->profileLevel              = 0;    /**< Not used by the core writer */
    pC->m_pWriterVideoStream->decoderSpecificInfo       = (M4OSA_MemAddr32)
                                                            (pC->m_pWriterVideoStreamInfo);
    pC->m_pWriterVideoStream->decoderSpecificInfoSize   = sizeof(M4WRITER_StreamVideoInfos);

    /**
     * Update AU properties for video stream */
    pC->m_WriterVideoAU.CTS         = pC->m_WriterVideoAU.DTS = 0;  /** Reset time */
    pC->m_WriterVideoAU.size        = 0;
    pC->m_WriterVideoAU.frag        = M4OSA_NULL;
    pC->m_WriterVideoAU.nbFrag      = 0;                            /** No fragment */
    pC->m_WriterVideoAU.stream      = pC->m_pWriterVideoStream;
    pC->m_WriterVideoAU.attribute   = AU_RAP;
    pC->m_WriterVideoAU.dataAddress = M4OSA_NULL;

    /**
     *  If there is an audio input, allocate and fill the audio stream structures for the writer */
    if(M4OSA_NULL != pC->m_pReaderAudioStream)
    {
        pC->m_pWriterAudioStream =
            (M4SYS_StreamDescription*)M4OSA_32bitAlignedMalloc(sizeof(M4SYS_StreamDescription), M4PTO3GPP,
            (M4OSA_Char *)"pWriterAudioStream");
        if (M4OSA_NULL == pC->m_pWriterAudioStream)
        {
            M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing(): unable to allocate pWriterAudioStream, \
                           returning M4ERR_ALLOC");
            return M4ERR_ALLOC;
        }
        pC->m_pWriterAudioStreamInfo =
            (M4WRITER_StreamAudioInfos*)M4OSA_32bitAlignedMalloc(sizeof(M4WRITER_StreamAudioInfos), M4PTO3GPP,
            (M4OSA_Char *)"pWriterAudioStreamInfo");
        if (M4OSA_NULL == pC->m_pWriterAudioStreamInfo)
        {
            M4OSA_TRACE1_0("M4PTO3GPP_Ready4Processing(): unable to allocate \
                           pWriterAudioStreamInfo, returning M4ERR_ALLOC");
            return M4ERR_ALLOC;
        }

        pC->m_pWriterAudioStreamInfo->nbSamplesPerSec = 0; /**< unused by our shell writer */
        pC->m_pWriterAudioStreamInfo->nbBitsPerSample = 0; /**< unused by our shell writer */
        pC->m_pWriterAudioStreamInfo->nbChannels = 1;      /**< unused by our shell writer */

        if( (M4OSA_NULL != pC->m_pReaderAudioStream) && /* audio could have been discarded */
            (M4OSA_NULL != pC->m_pReaderAudioStream->m_basicProperties.m_pDecoderSpecificInfo) )
        {
            /* If we copy the stream from the input, we copy its DSI */
            pC->m_pWriterAudioStreamInfo->Header.Size =
                pC->m_pReaderAudioStream->m_basicProperties.m_decoderSpecificInfoSize;
            pC->m_pWriterAudioStreamInfo->Header.pBuf =
                (M4OSA_MemAddr8)pC->m_pReaderAudioStream->m_basicProperties.m_pDecoderSpecificInfo;
        }
        else
        {
            /* Writer will put a default DSI */
            pC->m_pWriterAudioStreamInfo->Header.Size = 0;
            pC->m_pWriterAudioStreamInfo->Header.pBuf = M4OSA_NULL;
        }

        /**
         * Add the audio stream */
        switch (pC->m_pReaderAudioStream->m_basicProperties.m_streamType)
        {
            case M4DA_StreamTypeAudioAmrNarrowBand:
                pC->m_pWriterAudioStream->streamType = M4SYS_kAMR;
                break;
            case M4DA_StreamTypeAudioAac:
                pC->m_pWriterAudioStream->streamType = M4SYS_kAAC;
                break;
            case M4DA_StreamTypeAudioEvrc:
                pC->m_pWriterAudioStream->streamType = M4SYS_kEVRC;
                break;
            default:
                M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: unhandled audio format (0x%x),\
                               returning ERR_PTO3GPP_UNDEFINED_OUTPUT_VIDEO_BITRATE",
                               pC->m_pReaderAudioStream->m_basicProperties.m_streamType);
                return ERR_PTO3GPP_UNDEFINED_OUTPUT_AUDIO_FORMAT;
        }

        /*
         * Fill Audio stream description structure for the AddStream method */
        pC->m_pWriterAudioStream->streamID                  = M4PTO3GPP_WRITER_AUDIO_STREAM_ID;
        pC->m_pWriterAudioStream->duration                  = 0;/**< Duration is not known yet */
        pC->m_pWriterAudioStream->timeScale                 = M4PTO3GPP_WRITER_AUDIO_AMR_TIME_SCALE;
        pC->m_pWriterAudioStream->profileLevel              = M4PTO3GPP_WRITER_AUDIO_PROFILE_LEVEL;
        pC->m_pWriterAudioStream->averageBitrate            =
                                pC->m_pReaderAudioStream->m_basicProperties.m_averageBitRate;
        pC->m_pWriterAudioStream->maxBitrate                =
                                pC->m_pWriterAudioStream->averageBitrate;

        /**
         * Our writer shell interface is a little tricky: we put M4WRITER_StreamAudioInfos \
            in the DSI pointer... */
        pC->m_pWriterAudioStream->decoderSpecificInfo =
                    (M4OSA_MemAddr32)pC->m_pWriterAudioStreamInfo;

        /**
         * Update AU properties for audio stream */
        pC->m_WriterAudioAU.CTS         = pC->m_WriterAudioAU.DTS = 0;  /** Reset time */
        pC->m_WriterAudioAU.size        = 0;
        pC->m_WriterAudioAU.frag        = M4OSA_NULL;
        pC->m_WriterAudioAU.nbFrag      = 0;                            /** No fragment */
        pC->m_WriterAudioAU.stream      = pC->m_pWriterAudioStream;
        pC->m_WriterAudioAU.attribute   = AU_RAP;
        pC->m_WriterAudioAU.dataAddress = M4OSA_NULL;
    }

    /************************************/
    /******** Video Encoder Init ********/
    /************************************/

    /**
     * PTO uses its own bitrate regulation, not the "true" core regulation */
    EncParams.bInternalRegulation = M4OSA_TRUE; //M4OSA_FALSE;
    EncParams.uiStartingQuantizerValue = M4PTO3GPP_QUANTIZER_STEP;

    EncParams.videoProfile = pC->m_Params.videoProfile;
    EncParams.videoLevel = pC->m_Params.videoLevel;

    /**
     * Other encoder settings */

    EncParams.uiHorizontalSearchRange  = 0;             /* use default */
    EncParams.uiVerticalSearchRange    = 0;             /* use default */
    EncParams.bErrorResilience         = M4OSA_FALSE;   /* no error resilience */
    EncParams.uiIVopPeriod             = 15;             /* use default */
    EncParams.uiMotionEstimationTools  = 0;             /* M4V_MOTION_EST_TOOLS_ALL */
    EncParams.bAcPrediction            = M4OSA_TRUE;    /* use AC prediction */
    EncParams.bDataPartitioning        = M4OSA_FALSE;   /* no data partitioning */


    /**
     * Create video encoder */
    err = pC->m_pEncoderInt->pFctInit(&pC->m_pMp4EncoderContext, pC->m_pWriterDataInt,
                                    M4PTO3GPP_applyVPP, pC, pC->m_pEncoderExternalAPI,
                                    pC->m_pEncoderUserData);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: EncoderInt->pFctInit returns 0x%x", err);
        return err;
    }

    pC->m_eEncoderState = M4PTO3GPP_kEncoderClosed;

    err = pC->m_pEncoderInt->pFctOpen(pC->m_pMp4EncoderContext, &pC->m_WriterVideoAU, &EncParams);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: EncoderInt->pFctOpen returns 0x%x", err);
        return err;
    }

    pC->m_eEncoderState = M4PTO3GPP_kEncoderStopped;

    if (M4OSA_NULL != pC->m_pEncoderInt->pFctStart)
    {
        err = pC->m_pEncoderInt->pFctStart(pC->m_pMp4EncoderContext);

        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: EncoderInt->pFctStart returns 0x%x", err);
            return err;
        }
    }

    pC->m_eEncoderState = M4PTO3GPP_kEncoderRunning;

    /**
     * No more  setoption on "M4ENCODER_kVideoFragmentSize" here.
     * It is now automaticly and "smartly" set in the encoder shell. */

    /**************************************/
    /******** 3GP out add streams  ********/
    /**************************************/

    err = pC->m_pWriterGlobInt->pFctAddStream(pC->m_p3gpWriterContext, pC->m_pWriterVideoStream);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctAddStream(video) returns\
                       0x%x", err);
        return err;
    }

    /**
     * Set video max au size */
    optionValue.streamID    = M4PTO3GPP_WRITER_VIDEO_STREAM_ID;
    optionValue.value = (M4OSA_UInt32)(1.5F * (M4OSA_Float)(pC->m_pWriterVideoStreamInfo->width
                                                * pC->m_pWriterVideoStreamInfo->height)
                                                * M4PTO3GPP_VIDEO_MIN_COMPRESSION_RATIO);
    M4OSA_TRACE3_1("M4PTO3GPP_Ready4Processing,M4WRITER_kMaxAUSize: %u",optionValue.value);
    err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext,
                                (M4OSA_UInt32)M4WRITER_kMaxAUSize,(M4OSA_DataOption) &optionValue);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctSetOption(video,\
                       M4WRITER_kMaxAUSize) returns 0x%x", err);
        return err;
    }

    /**
     * Set video max chunck size */
    optionValue.value = (M4OSA_UInt32)((M4OSA_Float)optionValue.value
                        * M4PTO3GPP_VIDEO_AU_SIZE_TO_CHUNCK_SIZE_RATIO);
    M4OSA_TRACE3_1("M4PTO3GPP_Ready4Processing,M4WRITER_kMaxChunckSize: %u",optionValue.value);
    err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext,
                        (M4OSA_UInt32)M4WRITER_kMaxChunckSize,(M4OSA_DataOption) &optionValue);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctSetOption(video,\
                       M4WRITER_kMaxChunckSize) returns 0x%x", err);
        return err;
    }

    if (M4OSA_NULL != pC->m_pReaderAudioStream)
    {
        err = pC->m_pWriterGlobInt->pFctAddStream(pC->m_p3gpWriterContext, pC->m_pWriterAudioStream);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctAddStream(audio) \
                           returns 0x%x", err);
            return err;
        }

        /**
         * Set audio max au size */
        optionValue.value       = M4PTO3GPP_AUDIO_MAX_AU_SIZE;
        optionValue.streamID    = M4PTO3GPP_WRITER_AUDIO_STREAM_ID;
        err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext,
            (M4OSA_UInt32)M4WRITER_kMaxAUSize,(M4OSA_DataOption) &optionValue);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctSetOption(audio,\
                           M4WRITER_kMaxAUSize) returns 0x%x", err);
            return err;
        }

        /**
         * Set audio max chunck size */
        optionValue.value = M4PTO3GPP_AUDIO_MAX_CHUNK_SIZE; /**< Magical */
        err = pC->m_pWriterGlobInt->pFctSetOption(pC->m_p3gpWriterContext,
                        (M4OSA_UInt32)M4WRITER_kMaxChunckSize,(M4OSA_DataOption) &optionValue);
        if (M4NO_ERROR != err)
        {
            M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctSetOption(audio,\
                           M4WRITER_kMaxChunckSize) returns 0x%x", err);
            return err;
        }
    }

    /*
     * Close the stream registering in order to be ready to write data */
    err = pC->m_pWriterGlobInt->pFctStartWriting(pC->m_p3gpWriterContext);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_Ready4Processing: pWriterGlobInt->pFctStartWriting returns 0x%x",
                        err);
        return err;
    }


    M4OSA_TRACE3_0("M4PTO3GPP_Ready4Processing: returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 M4OSA_ERR M4PTO3GPP_writeAmrSilence122Frame(M4WRITER_DataInterface* pWriterDataIntInterface,
                            M4WRITER_Context* pWriterContext,
                                      M4SYS_AccessUnit* pWriterAudioAU, M4OSA_Time mtIncCts)
 * @brief   Write an AMR 12.2kbps silence FRAME into the writer
 * @note    Mainly used to fix the 'bzz' bug...
 * @param   pWriterDataIntInterface (IN)    writer data interfaces
 *          pWriterContext          (IN/OUT)writer context
 *          pWriterAudioAU          (OUT)   writer audio access unit
 *          mtIncCts                (IN)    writer CTS
 * @return  M4NO_ERROR: No error
 ******************************************************************************
*/
static M4OSA_ERR M4PTO3GPP_writeAmrSilence122Frame(M4WRITER_DataInterface* pWriterDataIntInterface,
                                                   M4WRITER_Context* pWriterContext,
                                                    M4SYS_AccessUnit* pWriterAudioAU,
                                                    M4OSA_Time mtIncCts)
{
    M4OSA_ERR err;

    err = pWriterDataIntInterface->pStartAU(pWriterContext, M4PTO3GPP_WRITER_AUDIO_STREAM_ID,
                                        pWriterAudioAU);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_writeAmrSilence122Frame: pWriterDataInt->pStartAU(audio) returns \
                                                    0x%x!", err);
        return err;
    }

    memcpy((void *)pWriterAudioAU->dataAddress,
     (void *)M4PTO3GPP_AMR_AU_SILENCE_122_FRAME, M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE);
    pWriterAudioAU->size    = M4PTO3GPP_AMR_AU_SILENCE_FRAME_122_SIZE;
    pWriterAudioAU->CTS     = mtIncCts;
    pWriterAudioAU->nbFrag  = 0;

    err = pWriterDataIntInterface->pProcessAU(pWriterContext, M4PTO3GPP_WRITER_AUDIO_STREAM_ID,
                                                pWriterAudioAU);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_writeAmrSilence122Frame: pWriterDataInt->pProcessAU(silence) \
                       returns 0x%x!", err);
        return err;
    }

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 M4OSA_ERR M4PTO3GPP_writeAmrSilence048Frame(M4WRITER_DataInterface* pWriterDataIntInterface,
                                        M4WRITER_Context* pWriterContext,
                                      M4SYS_AccessUnit* pWriterAudioAU, M4OSA_Time mtIncCts)
 * @brief   Write an AMR 12.2kbps silence FRAME into the writer
 * @note    Mainly used to fix the 'bzz' bug...
 * @param   pWriterDataIntInterface (IN)    writer data interfaces
 *          pWriterContext          (IN/OUT)writer context
 *          pWriterAudioAU          (OUT)   writer audio access unit
 *          mtIncCts                (IN)    writer CTS
 * @return  M4NO_ERROR: No error
 ******************************************************************************
*/
static M4OSA_ERR M4PTO3GPP_writeAmrSilence048Frame(M4WRITER_DataInterface* pWriterDataIntInterface,
                                                   M4WRITER_Context* pWriterContext,
                                                M4SYS_AccessUnit* pWriterAudioAU,
                                                M4OSA_Time mtIncCts)
{
    M4OSA_ERR err;

    err = pWriterDataIntInterface->pStartAU(pWriterContext, M4PTO3GPP_WRITER_AUDIO_STREAM_ID,
                                                        pWriterAudioAU);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_writeAmrSilence048Frame: pWriterDataInt->pStartAU(audio)\
                       returns 0x%x!", err);
        return err;
    }

    memcpy((void *)pWriterAudioAU->dataAddress,
                (void *)M4PTO3GPP_AMR_AU_SILENCE_048_FRAME,
                M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE);
    pWriterAudioAU->size    = M4PTO3GPP_AMR_AU_SILENCE_FRAME_048_SIZE;
    pWriterAudioAU->CTS     = mtIncCts;
    pWriterAudioAU->nbFrag  = 0;

    err = pWriterDataIntInterface->pProcessAU(pWriterContext,
                    M4PTO3GPP_WRITER_AUDIO_STREAM_ID, pWriterAudioAU);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4PTO3GPP_writeAmrSilence048Frame: \
                       pWriterDataInt->pProcessAU(silence) returns 0x%x!", err);
        return err;
    }

    return M4NO_ERROR;
}