xref: /frameworks/av/libvideoeditor/vss/mcs/src/M4MCS_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   M4MCS_API.c
 * @brief  MCS implementation (Video Compressor Service)
 * @note   This file implements the API and the processing of the MCS
 *************************************************************************
 **/

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

/* PCM samples */
#include "VideoEditorResampler.h"
/**
 * Decoder interface */
#include "M4DECODER_Common.h"

/* Encoder interface*/
#include "M4ENCODER_common.h"

/* Enable for DEBUG logging */
//#define MCS_DUMP_PCM_TO_FILE
#ifdef MCS_DUMP_PCM_TO_FILE
#include <stdio.h>
FILE *file_au_reader = NULL;
FILE *file_pcm_decoder = NULL;
FILE *file_pcm_encoder = NULL;
#endif

/* Core headers */
#include "M4MCS_API.h"
#include "M4MCS_ErrorCodes.h"
#include "M4MCS_InternalTypes.h"
#include "M4MCS_InternalConfig.h"
#include "M4MCS_InternalFunctions.h"

#ifdef M4MCS_SUPPORT_STILL_PICTURE
#include "M4MCS_StillPicture.h"
#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

/* Common headers (for aac) */
#include "M4_Common.h"

#include "NXPSW_CompilerSwitches.h"

#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
#include "M4VD_EXTERNAL_Interface.h"
#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */

#include "M4AIR_API.h"

/* Version */
#define M4MCS_VERSION_MAJOR 3
#define M4MCS_VERSION_MINOR 4
#define M4MCS_VERSION_REVISION  3

/**
 ********************************************************************
 * Static local functions
 ********************************************************************
 */

static M4OSA_ERR M4MCS_intStepSet( M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intPrepareVideoDecoder(
                                    M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intPrepareVideoEncoder(
                                    M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intPrepareAudioProcessing(
                                    M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intPrepareWriter( M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intPrepareAudioBeginCut(
                                    M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intStepEncoding(
                                    M4MCS_InternalContext *pC,
                                    M4OSA_UInt8 *pTranscodedTime );
static M4OSA_ERR M4MCS_intStepBeginVideoJump(
                                    M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intStepBeginVideoDecode(
                                    M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intAudioNullEncoding( M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intAudioTranscoding( M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intVideoNullEncoding( M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intVideoTranscoding( M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intGetInputClipProperties(
                                    M4MCS_InternalContext   *pContext );
static M4OSA_UInt32 M4MCS_intGetFrameSize_AMRNB(
                                    M4OSA_MemAddr8 pAudioFrame );
static M4OSA_UInt32 M4MCS_intGetFrameSize_EVRC(
                                    M4OSA_MemAddr8 pAudioFrame );
static M4OSA_ERR M4MCS_intCheckMaxFileSize( M4MCS_Context pContext );
static M4VIDEOEDITING_Bitrate M4MCS_intGetNearestBitrate(
                                    M4OSA_Int32 freebitrate,
                                    M4OSA_Int8 mode );
static M4OSA_ERR M4MCS_intCleanUp_ReadersDecoders(
                                    M4MCS_InternalContext *pC );
static M4OSA_ERR M4MCS_intReallocTemporaryAU(
                                    M4OSA_MemAddr8 *addr,
                                    M4OSA_UInt32 newSize );
static M4OSA_ERR M4MCS_intCheckAndGetCodecAacProperties(
                                 M4MCS_InternalContext *pC);

/**
 **********************************************************************
 * External function used only by VideoEditor and that does not appear
 * in the API
 **********************************************************************
 */

M4OSA_ERR M4MCS_open_normalMode( M4MCS_Context pContext,
                                 M4OSA_Void *pFileIn,
                                 M4VIDEOEDITING_FileType InputFileType,
                                 M4OSA_Void *pFileOut,
                                 M4OSA_Void *pTempFile );

/* All errors are fatal in the MCS */
#define M4ERR_CHECK_RETURN(err) if(M4NO_ERROR!=err) return err;

/* A define used with SSRC 1.04 and above to avoid taking blocks smaller
 * that the minimal block size
 */
#define M4MCS_SSRC_MINBLOCKSIZE        100

static M4OSA_UChar Tab_MCS[8] =
{
    17, 5, 3, 3, 1, 1, 1, 1
};

M4OSA_ERR H264MCS_Getinstance( NSWAVC_MCS_t ** instance )
{
    NSWAVC_MCS_t *p_bs = M4OSA_NULL;
    M4OSA_ERR err = M4NO_ERROR;
    p_bs = (NSWAVC_MCS_t *)M4OSA_32bitAlignedMalloc(sizeof(NSWAVC_MCS_t), M4MCS,
        (M4OSA_Char *)"NSWAVC_MCS_t");

    if( M4OSA_NULL == p_bs )
    {
        M4OSA_TRACE1_0("H264MCS_Getinstance: allocation error");
        return M4ERR_ALLOC;
    }

    p_bs->prev_frame_num = 0;
    p_bs->cur_frame_num = 0;
    p_bs->log2_max_frame_num_minus4 = 0;
    p_bs->prev_new_frame_num = 0;
    p_bs->is_done = 0;
    p_bs->is_first = 1;

    p_bs->m_pDecoderSpecificInfo = M4OSA_NULL;
    p_bs->m_decoderSpecificInfoSize = 0;

    p_bs->m_pEncoderSPS = M4OSA_NULL;
    p_bs->m_encoderSPSSize = 0;

    p_bs->m_pEncoderPPS = M4OSA_NULL;
    p_bs->m_encoderPPSSize = 0;

    p_bs->m_pFinalDSI = M4OSA_NULL;
    p_bs->m_pFinalDSISize = 0;

    p_bs->p_clip_sps = M4OSA_NULL;
    p_bs->m_encoder_SPS_Cnt = 0;

    p_bs->p_clip_pps = M4OSA_NULL;
    p_bs->m_encoder_PPS_Cnt = 0;

    p_bs->p_encoder_sps = M4OSA_NULL;
    p_bs->p_encoder_pps = M4OSA_NULL;

    p_bs->encoder_pps.slice_group_id = M4OSA_NULL;

    *instance = (NSWAVC_MCS_t *)p_bs;
    return err;
}

M4OSA_UInt32 H264MCS_getBits( ComBitStreamMCS_t *p_bs, M4OSA_UInt32 numBits )
{
    M4OSA_UInt32 ui32RetBits;
    M4OSA_UInt8 *pbs;
    M4OSA_Int32 bcnt;
    p_bs->i8BitCnt -= numBits;
    bcnt = p_bs->i8BitCnt;

    /* Measure the quantity of bits to be read in ui32TempBuff */
    ui32RetBits = p_bs->ui32TempBuff >> (32 - numBits);

    /* Read numBits in ui32TempBuff */
    p_bs->ui32TempBuff <<= numBits;
    p_bs->bitPos += numBits;

    if( bcnt > 24 )
    {
        return (ui32RetBits);
    }
    else
    { /* at least one byte can be buffered in ui32TempBuff */
        pbs = (M4OSA_UInt8 *)p_bs->pui8BfrPtr;

        if( bcnt < (int)(p_bs->numBitsInBuffer - p_bs->bitPos) )
        { /* not enough remaining bits in ui32TempBuff: need to be filled */
            do
            {
                /* On the fly detection of EPB byte */
                if( ( *(pbs) == 0x03)
                    && (!(( pbs[-1])
                    | (pbs[-2])))) //(p_bs->ui32LastTwoBytes & 0x0000FFFF) == 0)
                {
                    /* EPB byte found: skip it and update bitPos accordingly */
                            (pbs)++;
                            p_bs->bitPos += 8;
                        }

                        p_bs->ui32TempBuff |= *(pbs)++ << (24 - bcnt);
                        bcnt += 8;
            } while ( bcnt <= 24 );

            p_bs->pui8BfrPtr = (M4OSA_Int8 *)pbs;
            p_bs->i8BitCnt = bcnt;
            return (ui32RetBits);
        }
    }

    if( p_bs->bitPos <= p_bs->numBitsInBuffer )
    {
        return (ui32RetBits);
    }
    else
    {
        return (0);
    }
}

M4OSA_Void H264MCS_flushBits( ComBitStreamMCS_t *p_bs, M4OSA_UInt32 numBits )
{
    M4OSA_UInt8 *pbs;
    M4OSA_UInt32 bcnt;
    p_bs->i8BitCnt -= numBits;
    bcnt = p_bs->i8BitCnt;

    p_bs->ui32TempBuff <<= numBits;
    p_bs->bitPos += numBits;

    if( bcnt > 24 )
    {
        return;
    }
    else
    { /* at least one byte can be buffered in ui32TempBuff */
        pbs = (M4OSA_UInt8 *)p_bs->pui8BfrPtr;

        if( bcnt < (p_bs->numBitsInBuffer - p_bs->bitPos) )
        {   /* Not enough remaining bits in ui32TempBuff: need to be filled */
            do
            {
                /*  On the fly detection of EPB byte */
                if( ( *(pbs) == 0x03) && (!(( pbs[-1]) | (pbs[-2]))) )
                { /* JC: EPB byte found: skip it and update bitPos accordingly */
                    (pbs)++;
                    p_bs->bitPos += 8;
                }
                p_bs->ui32TempBuff |= *(pbs)++ << (24 - bcnt);
                bcnt += 8;
            } while ( bcnt <= 24 );

            p_bs->pui8BfrPtr = (M4OSA_Int8 *)pbs;
            p_bs->i8BitCnt = bcnt;
        }
    }

    return;
}

M4OSA_UInt32 H264MCS_DecVLCReadExpGolombCode( ComBitStreamMCS_t *p_bs )
{
    M4OSA_UInt32 code, l0 = 0, l1;
    /* Reading 32 Bits from local cache buffer of Bitstream structure*/
    code = p_bs->ui32TempBuff;

    /* Checking in first 3 bits*/
    if( code >> 29 )
    {
        l0 = Tab_MCS[(code >> 29)];
        code = code >> (32 - l0);
        H264MCS_flushBits(p_bs, l0);
    }
    else
        {
            if( code )
            {
                code <<= 3;

                for ( l0 = 3; code < 0x80000000; code <<= 1, l0++ );

                if( l0 < 16 ) /*all useful bits are inside the 32 bits read */
                {
                    code = code >> (31 - l0);
                    H264MCS_flushBits(p_bs, 2 * l0 + 1);
                }
                else
            { /* Read the useful bits in 2 parts */
                    l1 = ( l0 << 1) - 31;
                    code >>= l0;
                    H264MCS_flushBits(p_bs, 32);
                    code = ( code << l1) | H264MCS_getBits(p_bs, l1);
                }
            }
            else
            {
                H264MCS_flushBits(p_bs, 32);

                if( H264MCS_getBits(p_bs, 1) )
                {
                    /* if number of leading 0's is 32, the only code allowed is 1 followed
                    by 32 0's */

                    /*reading 32 more bits from bitstream buffer*/
                    code = H264MCS_getBits(p_bs, 32);

                    if( code == 0 )
                    {
                        return (code - 1);
                    }
                }
                /*if number of leading 0's is >32, then symbol is >32 bits,
                which is an error */
                //p_bs->state = _BS_ERR;
                //p_bs->flags |= _BF_SYM_ERR;
                return (0);
            }
        }

        if( 1 ) //(p_bs->state == _BS_OK)
        {
            return (code - 1);
        }
        else
        {
            return (0);
        }
    }

M4OSA_Int32 H264MCS_DecVLCReadSignedExpGolombCode( ComBitStreamMCS_t *p_bs )
{
    M4OSA_Int32 codeNo, ret;

    /* read the unsigned code number */
    codeNo = H264MCS_DecVLCReadExpGolombCode(p_bs);

    /* map to the signed value, if value is odd then it's positive,
    if even then it's negative, formula is (-1)^(k+1)*CEIL(k/2) */

    ret = (codeNo & 0x01) ? (( codeNo + 1) >> 1) : (( -codeNo) >> 1);

    return ret;
}

M4OSA_Void DecBitStreamReset_MCS( ComBitStreamMCS_t *p_bs,
                                 M4OSA_UInt32 bytes_read )
{
    p_bs->bitPos = 0;

    p_bs->lastTotalBits = 0;
    p_bs->numBitsInBuffer = bytes_read << 3;
    p_bs->readableBytesInBuffer = bytes_read;
    //p_bs->state = M4NO_ERROR;//_BS_OK;
    //p_bs->flags = 0;

    p_bs->ui32TempBuff = 0;
    p_bs->i8BitCnt = 0;
    p_bs->pui8BfrPtr = (M4OSA_Int8 *)p_bs->Buffer;
    p_bs->ui32LastTwoBytes = 0xFFFFFFFF;
    H264MCS_getBits(p_bs, 0);
}

M4OSA_ERR NSWAVCMCS_initBitstream( NSWAVC_bitStream_t_MCS *bS )
{
    bS->bitPos = 0;
    bS->byteCnt = 0;
    bS->currBuff = 0;
    bS->prevByte = 0xff;
    bS->prevPrevByte = 0xff;

    return M4NO_ERROR;
}

M4OSA_ERR NSWAVCMCS_putBits( NSWAVC_bitStream_t_MCS *bS, M4OSA_UInt32 value,
                            M4OSA_UInt8 length )
{
    M4OSA_UInt32 maskedValue = 0, temp = 0;
    M4OSA_UInt8 byteOne;

    M4OSA_UInt32 len1 = (length == 32) ? 31 : length;

    if( !(length) )
    {
        /* Length = 0, return OK*/
        return M4NO_ERROR;
    }

    maskedValue = (M4OSA_UInt32)(value &(( 1 << len1) - 1));

    if( 32 > (length + bS->bitPos) )
    {
        bS->bitPos += length;
        bS->currBuff |= maskedValue << (32 - bS->bitPos);
    }
    else
    {
        temp = (( bS->bitPos + length) - 32);

        bS->currBuff |= (maskedValue >> (temp));

        byteOne =
            bS->streamBuffer[bS->byteCnt++] = (M4OSA_UInt8)(bS->currBuff >> 24);

        if( (( bS->prevPrevByte
            == 0) & (bS->prevByte == 0) & (!(byteOne & 0xFC))) )
        {
            bS->byteCnt -= 1;
            bS->prevPrevByte = bS->streamBuffer[bS->byteCnt++] = 0x03;
            bS->prevByte = bS->streamBuffer[bS->byteCnt++] = byteOne;
        }
        else
        {
            bS->prevPrevByte = bS->prevByte;
            bS->prevByte = byteOne;
        }
        byteOne = bS->streamBuffer[bS->byteCnt++] =
            (M4OSA_UInt8)(( bS->currBuff >> 16) & 0xff);

        if( (( bS->prevPrevByte
            == 0) & (bS->prevByte == 0) & (!(byteOne & 0xFC))) )
        {
            bS->byteCnt -= 1;
            bS->prevPrevByte = bS->streamBuffer[bS->byteCnt++] = 0x03;
            bS->prevByte = bS->streamBuffer[bS->byteCnt++] = byteOne;
        }
        else
        {
            bS->prevPrevByte = bS->prevByte;
            bS->prevByte = byteOne;
        }
        byteOne = bS->streamBuffer[bS->byteCnt++] =
            (M4OSA_UInt8)(( bS->currBuff >> 8) & 0xff);

        if( (( bS->prevPrevByte
            == 0) & (bS->prevByte == 0) & (!(byteOne & 0xFC))) )
        {
            bS->byteCnt -= 1;
            bS->prevPrevByte = bS->streamBuffer[bS->byteCnt++] = 0x03;
            bS->prevByte = bS->streamBuffer[bS->byteCnt++] = byteOne;
        }
        else
        {
            bS->prevPrevByte = bS->prevByte;
            bS->prevByte = byteOne;
        }
        byteOne = bS->streamBuffer[bS->byteCnt++] =
            (M4OSA_UInt8)((bS->currBuff) &0xff);

        if( (( bS->prevPrevByte
            == 0) & (bS->prevByte == 0) & (!(byteOne & 0xFC))) )
        {
            bS->byteCnt -= 1;
            bS->prevPrevByte = bS->streamBuffer[bS->byteCnt++] = 0x03;
            bS->prevByte = bS->streamBuffer[bS->byteCnt++] = byteOne;
        }
        else
        {
            bS->prevPrevByte = bS->prevByte;
            bS->prevByte = byteOne;
        }

        bS->currBuff = 0;

        bS->currBuff |= ( maskedValue &(( 1 << temp) - 1)) << (32 - temp);

        bS->bitPos = temp;
    }

    return M4NO_ERROR;
}

M4OSA_ERR NSWAVCMCS_putBit( NSWAVC_bitStream_t_MCS *bS, M4OSA_UInt32 value )
{
    M4OSA_UInt32 maskedValue = 0, temp = 0;
    M4OSA_UInt8 byteOne;

    maskedValue = (value ? 1 : 0);

    if( 32 > (1 + bS->bitPos) )
    {
        bS->bitPos += 1;
        bS->currBuff |= maskedValue << (32 - bS->bitPos);
    }
    else
    {
        temp = 0;

        bS->currBuff |= (maskedValue);

        /* writing it to memory*/
        byteOne =
            bS->streamBuffer[bS->byteCnt++] =
            (M4OSA_UInt8)(bS->currBuff >> 24);

        if( (( bS->prevPrevByte
            == 0) & (bS->prevByte == 0) & (!(byteOne & 0xFC))) )
        {
            bS->byteCnt -= 1;
            bS->prevPrevByte = bS->streamBuffer[bS->byteCnt++] = 0x03;
            bS->prevByte = bS->streamBuffer[bS->byteCnt++] = byteOne;
        }
        else
        {
            bS->prevPrevByte = bS->prevByte;
            bS->prevByte = byteOne;
        }
        byteOne = bS->streamBuffer[bS->byteCnt++] =
            (M4OSA_UInt8)(( bS->currBuff >> 16) & 0xff);

        if( (( bS->prevPrevByte
            == 0) & (bS->prevByte == 0) & (!(byteOne & 0xFC))) )
        {
            bS->byteCnt -= 1;
            bS->prevPrevByte = bS->streamBuffer[bS->byteCnt++] = 0x03;
            bS->prevByte = bS->streamBuffer[bS->byteCnt++] = byteOne;
        }
        else
        {
            bS->prevPrevByte = bS->prevByte;
            bS->prevByte = byteOne;
        }
        byteOne = bS->streamBuffer[bS->byteCnt++] =
            (M4OSA_UInt8)(( bS->currBuff >> 8) & 0xff);

        if( (( bS->prevPrevByte
            == 0) & (bS->prevByte == 0) & (!(byteOne & 0xFC))) )
        {
            bS->byteCnt -= 1;
            bS->prevPrevByte = bS->streamBuffer[bS->byteCnt++] = 0x03;
            bS->prevByte = bS->streamBuffer[bS->byteCnt++] = byteOne;
        }
        else
        {
            bS->prevPrevByte = bS->prevByte;
            bS->prevByte = byteOne;
        }
        byteOne = bS->streamBuffer[bS->byteCnt++] =
            (M4OSA_UInt8)((bS->currBuff) &0xff);

        if( (( bS->prevPrevByte
            == 0) & (bS->prevByte == 0) & (!(byteOne & 0xFC))) )
        {
            bS->byteCnt -= 1;
            bS->prevPrevByte = bS->streamBuffer[bS->byteCnt++] = 0x03;
            bS->prevByte = bS->streamBuffer[bS->byteCnt++] = byteOne;
        }
        else
        {
            bS->prevPrevByte = bS->prevByte;
            bS->prevByte = byteOne;
        }
        bS->currBuff = 0;
        bS->bitPos = 0;
    }

    return M4NO_ERROR;
}

M4OSA_Int32 NSWAVCMCS_putRbspTbits( NSWAVC_bitStream_t_MCS *bS )
{
    M4OSA_UInt8 trailBits = 0;
    M4OSA_UInt8 byteCnt = 0;

    trailBits = (M4OSA_UInt8)(bS->bitPos % 8);

    /* Already in the byte aligned position,
    RBSP trailing bits will be 1000 0000 */
    if( 0 == trailBits )
    {
        trailBits = (1 << 7);
        NSWAVCMCS_putBits(bS, trailBits, 8);
    }
    else
    {
        trailBits = (8 - trailBits);
        NSWAVCMCS_putBit(bS, 1);
        trailBits--;

        if( trailBits )
        { /* put trailBits times zeros */
            NSWAVCMCS_putBits(bS, 0, trailBits);
        }
    }

    /* For writting the currBuff in streamBuff 4byte alignment is required*/
    byteCnt = (M4OSA_UInt8)(( bS->bitPos + 4) / 8);

    switch( byteCnt )
    {
        case 1:
            bS->streamBuffer[bS->byteCnt++] = (M4OSA_UInt8)(bS->currBuff >> 24);
            break;

        case 2:
            bS->streamBuffer[bS->byteCnt++] = (M4OSA_UInt8)(bS->currBuff >> 24);
            bS->streamBuffer[bS->byteCnt++] =
                (M4OSA_UInt8)(( bS->currBuff >> 16) & 0xff);
            break;

        case 3:
            bS->streamBuffer[bS->byteCnt++] = (M4OSA_UInt8)(bS->currBuff >> 24);
            bS->streamBuffer[bS->byteCnt++] =
                (M4OSA_UInt8)(( bS->currBuff >> 16) & 0xff);
            bS->streamBuffer[bS->byteCnt++] =
                (M4OSA_UInt8)(( bS->currBuff >> 8) & 0xff);

            break;

        default:
            /* It will not come here */
            break;
    }

    //    bS->bitPos =0;
    //    bS->currBuff = 0;

    return M4NO_ERROR;
}

M4OSA_ERR NSWAVCMCS_uExpVLC( NSWAVC_bitStream_t_MCS *bS, M4OSA_Int32 codeNum )
{

    M4OSA_Int32 loop, temp;
    M4OSA_Int32 data = 0;
    M4OSA_UInt8 codeLen = 0;

    /* The codeNum cannot be less than zero for this ue(v) */
    if( codeNum < 0 )
    {
        return 0;
    }

    /* Implementation for Encoding of the Table 9-1 in the Standard */
    temp = codeNum + 1;

    for ( loop = 0; temp != 0; loop++ )
    {
        temp /= 2;
    }

    codeLen = (( loop * 2) - 1);

    data = codeNum + 1;

    NSWAVCMCS_putBits(bS, data, codeLen);

    return M4NO_ERROR;
}

M4OSA_ERR NSWAVCMCS_sExpVLC( NSWAVC_bitStream_t_MCS *bS, M4OSA_Int32 codeNum )
{

    M4OSA_Int32 loop, temp1, temp2;
    M4OSA_Int32 data = 0;
    M4OSA_UInt8 codeLen = 0, isPositive = 0;
    M4OSA_UInt32 abscodeNum;

    if( codeNum > 0 )
    {
        isPositive = 1;
    }

    if( codeNum > 0 )
    {
        abscodeNum = codeNum;
    }
    else
    {
        abscodeNum = -codeNum;
    }

    temp1 = ( ( ( abscodeNum) << 1) - isPositive) + 1;
    temp2 = temp1;

    for ( loop = 0; loop < 16 && temp2 != 0; loop++ )
    {
        temp2 /= 2;
    }

    codeLen = ( loop * 2) - 1;

    data = temp1;

    NSWAVCMCS_putBits(bS, data, codeLen);

    return M4NO_ERROR;
}

M4OSA_ERR H264MCS_ProcessEncodedNALU(   M4OSA_Void *ainstance,
                                        M4OSA_UInt8 *inbuff,
                                        M4OSA_Int32 inbuf_size,
                                        M4OSA_UInt8 *outbuff,
                                        M4OSA_Int32 *outbuf_size )
{
    ComBitStreamMCS_t *p_bs, bs;
    NSWAVC_MCS_t *instance;
    M4OSA_UInt8 nalu_info;
    M4OSA_Int32 forbidden_bit, nal_ref_idc, nal_unit_type;
    M4OSA_Int32 first_mb_in_slice, slice_type, pic_parameter_set_id, frame_num;
    M4OSA_Int32 seq_parameter_set_id;
    M4OSA_UInt8 temp1, temp2, temp3, temp4;
    M4OSA_Int32 temp_frame_num;
    M4OSA_Int32 bitstoDiacard, bytes;
    M4OSA_UInt32 mask_bits = 0xFFFFFFFF;
    M4OSA_Int32 new_bytes, init_bit_pos;
    M4OSA_UInt32 nal_size;
    M4OSA_UInt32 cnt;
    M4OSA_UInt32 outbuffpos = 0;
    M4OSA_UInt32 nal_size_low16, nal_size_high16;
    M4OSA_UInt32 frame_size = 0;
    M4OSA_UInt32 temp = 0;

    // StageFright encoder does not provide the size in the first 4 bytes of the AU, add it
    M4OSA_Int8 *pTmpBuff1 = M4OSA_NULL;
    M4OSA_Int8 *pTmpBuff2 = M4OSA_NULL;

    p_bs = &bs;
    instance = (NSWAVC_MCS_t *)ainstance;

    M4OSA_TRACE1_2(
        "In  H264MCS_ProcessEncodedNALU with FrameSize = %d  inBuf_Size=%d",
        frame_size, inbuf_size);

    // StageFright codecs may add a start code, make sure it is not present

    if( !memcmp((void *)inbuff,
        "\x00\x00\x00\x01", 4) )
    {
        M4OSA_TRACE1_3(
            "H264MCS_ProcessNALU ERROR : NALU start code has not been removed %d "
            "0x%X 0x%X", inbuf_size, ((M4OSA_UInt32 *)inbuff)[0],
            ((M4OSA_UInt32 *)inbuff)[1]);

        return M4ERR_PARAMETER;
    }

    // StageFright encoder does not provide the size in the first 4 bytes of the AU, add it
    pTmpBuff1 = (M4OSA_Int8 *)M4OSA_32bitAlignedMalloc(inbuf_size + 4, M4MCS,
        (M4OSA_Char *)"tmpNALU");
    memcpy((void *)(pTmpBuff1 + 4), (void *)inbuff,
        inbuf_size);
    pTmpBuff1[3] = ( (M4OSA_UInt32)inbuf_size) & 0x000000FF;
    pTmpBuff1[2] = ( (M4OSA_UInt32)inbuf_size >> 8) & 0x000000FF;
    pTmpBuff1[1] = ( (M4OSA_UInt32)inbuf_size >> 16) & 0x000000FF;
    pTmpBuff1[0] = ( (M4OSA_UInt32)inbuf_size >> 24) & 0x000000FF;
    pTmpBuff2 = (M4OSA_Int8 *)inbuff;
    inbuff = (M4OSA_UInt8 *)pTmpBuff1;
    inbuf_size += 4;

    // Make sure the available size was set
    if( inbuf_size >= *outbuf_size )
    {
        M4OSA_TRACE1_1(
            "!!! H264MCS_ProcessNALU ERROR : specified available size is incorrect %d ",
            *outbuf_size);
        return M4ERR_PARAMETER;
    }



    while( (M4OSA_Int32)frame_size < inbuf_size )
    {
        mask_bits = 0xFFFFFFFF;
        p_bs->Buffer = (M4OSA_UInt8 *)(inbuff + frame_size);

        // Use unsigned value to fix errors due to bit sign extension, this fix should be generic

        nal_size_high16 = ( ( (M4OSA_UInt8 *)p_bs->Buffer)[0] << 8)
            + ((M4OSA_UInt8 *)p_bs->Buffer)[1];
        nal_size_low16 = ( ( (M4OSA_UInt8 *)p_bs->Buffer)[2] << 8)
            + ((M4OSA_UInt8 *)p_bs->Buffer)[3];

        nalu_info = (unsigned char)p_bs->Buffer[4];

        outbuff[outbuffpos] = p_bs->Buffer[4];

        p_bs->Buffer = p_bs->Buffer + 5;

        p_bs->bitPos = 0;
        p_bs->lastTotalBits = 0;
        p_bs->numBitsInBuffer = ( inbuf_size - frame_size - 5) << 3;
        p_bs->readableBytesInBuffer = inbuf_size - frame_size - 5;

        p_bs->ui32TempBuff = 0;
        p_bs->i8BitCnt = 0;
        p_bs->pui8BfrPtr = (M4OSA_Int8 *)p_bs->Buffer;
        p_bs->ui32LastTwoBytes = 0xFFFFFFFF;

        H264MCS_getBits(p_bs, 0);

        nal_size = ( nal_size_high16 << 16) + nal_size_low16;

        frame_size += nal_size + 4;

        forbidden_bit = ( nalu_info >> 7) & 1;
        nal_ref_idc = ( nalu_info >> 5) & 3;
        nal_unit_type = (nalu_info) &0x1f;

        NSWAVCMCS_initBitstream(&instance->encbs);

        instance->encbs.streamBuffer = outbuff + outbuffpos + 1;

        if( nal_unit_type == 8 )
        {
            M4OSA_TRACE1_0("Error : PPS");
            return 0;
        }

        if( nal_unit_type == 7 )
        {
            /*SPS Packet */
            M4OSA_TRACE1_0("Error : SPS");
            return 0;
        }

        if( (nal_unit_type == 5) )
        {
            instance->frame_count = 0;
            instance->POC_lsb = 0;
        }

        if( ( nal_unit_type == 1) || (nal_unit_type == 5) )
        {
            first_mb_in_slice = H264MCS_DecVLCReadExpGolombCode(p_bs);
            slice_type = H264MCS_DecVLCReadExpGolombCode(p_bs);
            pic_parameter_set_id = H264MCS_DecVLCReadExpGolombCode(p_bs);

            /* First MB in slice */
            NSWAVCMCS_uExpVLC(&instance->encbs, first_mb_in_slice);

            /* Slice Type */
            NSWAVCMCS_uExpVLC(&instance->encbs, slice_type);

            /* Picture Parameter set Id */
            pic_parameter_set_id = instance->encoder_pps.pic_parameter_set_id;
            NSWAVCMCS_uExpVLC(&instance->encbs, pic_parameter_set_id);

            temp = H264MCS_getBits(p_bs,
                instance->encoder_sps.log2_max_frame_num_minus4 + 4);
            NSWAVCMCS_putBits(&instance->encbs, instance->frame_count,
                instance->clip_sps.log2_max_frame_num_minus4 + 4);

            // In Baseline Profile: frame_mbs_only_flag should be ON
            if( nal_unit_type == 5 )
            {
                temp = H264MCS_DecVLCReadExpGolombCode(p_bs);
                NSWAVCMCS_uExpVLC(&instance->encbs, temp);
            }

            if( instance->encoder_sps.pic_order_cnt_type == 0 )
            {
                temp = H264MCS_getBits(p_bs,
                    instance->encoder_sps.log2_max_pic_order_cnt_lsb_minus4
                    + 4);

                // in baseline profile field_pic_flag should be off.
                if( instance->encoder_pps.pic_order_present_flag )
                {
                    temp = H264MCS_DecVLCReadSignedExpGolombCode(p_bs);
                }
            }

            if( ( instance->encoder_sps.pic_order_cnt_type == 1)
                && (instance->encoder_sps.delta_pic_order_always_zero_flag) )
            {
                temp = H264MCS_DecVLCReadSignedExpGolombCode(p_bs);

                // in baseline profile field_pic_flag should be off.
                if( instance->encoder_pps.pic_order_present_flag )
                {
                    temp = H264MCS_DecVLCReadSignedExpGolombCode(p_bs);
                }
            }

            if( instance->clip_sps.pic_order_cnt_type == 0 )
            {
                NSWAVCMCS_putBits(&instance->encbs, instance->POC_lsb,
                    instance->clip_sps.log2_max_pic_order_cnt_lsb_minus4 + 4);

                // in baseline profile field_pic_flag should be off.
                if( instance->encoder_pps.pic_order_present_flag )
                {
                    NSWAVCMCS_sExpVLC(&instance->encbs, 0);
                }
            }

            if( ( instance->clip_sps.pic_order_cnt_type == 1)
                && (instance->clip_sps.delta_pic_order_always_zero_flag) )
            {
                NSWAVCMCS_sExpVLC(&instance->encbs, 0);

                // in baseline profile field_pic_flag should be off.
                if( instance->encoder_pps.pic_order_present_flag )
                {
                    NSWAVCMCS_sExpVLC(&instance->encbs, 0);
                }
            }

            cnt = p_bs->bitPos & 0x7;

            if( cnt )
            {
                cnt = 8 - cnt;
                temp = H264MCS_getBits(p_bs, cnt);
                NSWAVCMCS_putBits(&instance->encbs, temp, cnt);
            }

            cnt = p_bs->bitPos >> 3;

            while( cnt < (nal_size - 2) )
            {
                temp = H264MCS_getBits(p_bs, 8);
                NSWAVCMCS_putBits(&instance->encbs, temp, 8);
                cnt = p_bs->bitPos >> 3;
            }

            temp = H264MCS_getBits(p_bs, 8);

            if( temp != 0 )
            {
                cnt = 0;

                while( ( temp & 0x1) == 0 )
                {
                    cnt++;
                    temp = temp >> 1;
                }
                cnt++;
                temp = temp >> 1;

                if( 8 - cnt )
                {
                    NSWAVCMCS_putBits(&instance->encbs, temp, (8 - cnt));
                }

                NSWAVCMCS_putRbspTbits(&instance->encbs);
            }
            else
            {

                M4OSA_TRACE1_1(
                    "H264MCS_ProcessEncodedNALU : 13 temp = 0 trailing bits = %d",
                    instance->encbs.bitPos % 8);

                if( instance->encbs.bitPos % 8 )
                {
                    NSWAVCMCS_putBits(&instance->encbs, 0,
                        (8 - instance->encbs.bitPos % 8));
                }
            }

            temp = instance->encbs.byteCnt;
            temp = temp + 1;

            outbuffpos = outbuffpos + temp;
        }
    }

    *outbuf_size = outbuffpos;

    instance->POC_lsb = instance->POC_lsb + 1;

    if( instance->POC_lsb == instance->POC_lsb_mod )
    {
        instance->POC_lsb = 0;
    }
    instance->frame_count = instance->frame_count + 1;

    if( instance->frame_count == instance->frame_mod_count )
    {
        instance->frame_count = 0;
    }

    // StageFright encoder does not provide the size in the first 4 bytes of the AU, add it

    free(pTmpBuff1);
    pTmpBuff1 = M4OSA_NULL;
    inbuff = (M4OSA_UInt8 *)pTmpBuff2;

    return M4NO_ERROR;
}

M4OSA_Int32 DecSPSMCS( ComBitStreamMCS_t *p_bs,
                      ComSequenceParameterSet_t_MCS *sps )
{
    M4OSA_UInt32 i;
    M4OSA_Int32 temp_max_dpb_size;
    M4OSA_Int32 nb_ignore_bits;
    M4OSA_Int32 error;
    M4OSA_UInt8 profile_idc, level_idc, reserved_zero_4bits,
        seq_parameter_set_id;
    M4OSA_UInt8 constraint_set0_flag, constraint_set1_flag,
        constraint_set2_flag, constraint_set3_flag;

    sps->profile_idc = (M4OSA_UInt8)H264MCS_getBits(p_bs, 8);
    sps->constraint_set0_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
    sps->constraint_set1_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
    sps->constraint_set2_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
    sps->constraint_set3_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
    reserved_zero_4bits = (M4OSA_UInt8)H264MCS_getBits(p_bs, 4);
    sps->level_idc = (M4OSA_UInt8)H264MCS_getBits(p_bs, 8);
    sps->seq_parameter_set_id =
        (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);
    sps->log2_max_frame_num_minus4 =
        (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);
    sps->MaxFrameNum = 1 << (sps->log2_max_frame_num_minus4 + 4);
    sps->pic_order_cnt_type =
        (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);

    if (sps->pic_order_cnt_type == 0)
    {
        sps->log2_max_pic_order_cnt_lsb_minus4 =
            (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);
        sps->MaxPicOrderCntLsb =
            1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4);
    }
    else if( sps->pic_order_cnt_type == 1 )
    {
        sps->delta_pic_order_always_zero_flag =
            (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

        // This fix should be generic to remove codec dependency

        sps->offset_for_non_ref_pic =
            H264MCS_DecVLCReadSignedExpGolombCode(p_bs);
        sps->offset_for_top_to_bottom_field =
            H264MCS_DecVLCReadSignedExpGolombCode(p_bs);


        /*num_ref_frames_in_pic_order_cnt_cycle must be in the range 0, 255*/

        sps->num_ref_frames_in_pic_order_cnt_cycle =
            (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);

        /* compute deltaPOC */
        sps->expectedDeltaPerPicOrderCntCycle = 0;

        for ( i = 0; i < sps->num_ref_frames_in_pic_order_cnt_cycle; i++ )
        {
            // This fix should be generic to remove codec dependency
            sps->offset_for_ref_frame[i] =
                H264MCS_DecVLCReadSignedExpGolombCode(p_bs);

            sps->expectedDeltaPerPicOrderCntCycle +=
                sps->offset_for_ref_frame[i];
        }
    }

    /* num_ref_frames must be in the range 0,16 */
    sps->num_ref_frames = (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);
    sps->gaps_in_frame_num_value_allowed_flag =
        (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

    sps->pic_width_in_mbs_minus1 =
        (M4OSA_UInt16)H264MCS_DecVLCReadExpGolombCode(p_bs);
    sps->pic_height_in_map_units_minus1 =
        (M4OSA_UInt16)H264MCS_DecVLCReadExpGolombCode(p_bs);

    sps->frame_mbs_only_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

    if (!sps->frame_mbs_only_flag)
    {
        sps->mb_adaptive_frame_field_flag =
            (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
    }
    else
    {
        sps->mb_adaptive_frame_field_flag = 0;
    }

    sps->PicWidthInMbs = sps->pic_width_in_mbs_minus1 + 1;
    sps->FrameHeightInMbs = ( 2 - sps->frame_mbs_only_flag) * \
        (sps->pic_height_in_map_units_minus1 + 1);
#ifdef _CAP_FMO_

    sps->NumSliceGroupMapUnits =
        sps->PicWidthInMbs * (sps->pic_height_in_map_units_minus1 + 1);
    sps->MaxPicSizeInMbs = sps->PicWidthInMbs * sps->FrameHeightInMbs;

#endif /*_CAP_FMO_*/

    sps->direct_8x8_inference_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

    if( sps->frame_mbs_only_flag == 0 )
        sps->direct_8x8_inference_flag = 1;

    sps->frame_cropping_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

    if( sps->frame_cropping_flag )
    {
        sps->frame_crop_left_offset = H264MCS_DecVLCReadExpGolombCode(p_bs);
        sps->frame_crop_right_offset = H264MCS_DecVLCReadExpGolombCode(p_bs);
        sps->frame_crop_top_offset = H264MCS_DecVLCReadExpGolombCode(p_bs);
        sps->frame_crop_bottom_offset = H264MCS_DecVLCReadExpGolombCode(p_bs);
    }
    else
    {
        sps->frame_crop_left_offset = 0;
        sps->frame_crop_right_offset = 0;
        sps->frame_crop_top_offset = 0;
        sps->frame_crop_bottom_offset = 0;
    }

    sps->vui_parameters_present_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

    if (sps->vui_parameters_present_flag) {
        /* no error message as stream can be decoded without VUI messages */
    }

    return M4NO_ERROR;
}

M4OSA_Int32 DecPPSMCS( ComBitStreamMCS_t *p_bs,
                      ComPictureParameterSet_t_MCS *pps )
{
    M4OSA_Int32 error;
    M4OSA_UInt32 pic_parameter_set_id;

#ifdef _CAP_FMO_
    M4OSA_UInt32 i, length, v;
#endif

    M4OSA_Int32 nb_ignore_bits;

    pic_parameter_set_id = H264MCS_DecVLCReadExpGolombCode(p_bs);
    pps->pic_parameter_set_id = (M4OSA_UInt8)pic_parameter_set_id;

    pps->seq_parameter_set_id =
        (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);

    /* entropy_coding_mode_flag must be 0 or 1 */
    pps->entropy_coding_mode_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
    pps->pic_order_present_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

    pps->num_slice_groups_minus1 =
        (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);

#ifdef _CAP_FMO_
    /* FMO stuff begins here */

    pps->map_initialized = FALSE;

    if( pps->num_slice_groups_minus1 > 0 )
    {
        pps->slice_group_map_type =
            (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);

        switch( pps->slice_group_map_type )
        {
            case 0:
                for ( i = 0; i <= pps->num_slice_groups_minus1; i++ )
                {
                    pps->run_length_minus1[i] =
                        (M4OSA_UInt16)H264MCS_DecVLCReadExpGolombCode(p_bs);
                }
                break;

            case 2:
                for ( i = 0; i < pps->num_slice_groups_minus1; i++ )
                {
                    pps->top_left[i] =
                        (M4OSA_UInt16)H264MCS_DecVLCReadExpGolombCode(p_bs);
                    pps->bottom_right[i] =
                        (M4OSA_UInt16)H264MCS_DecVLCReadExpGolombCode(p_bs);
                }
                break;

            case 3:
            case 4:
            case 5:
                pps->slice_group_change_direction_flag =
                    (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
                pps->slice_group_change_rate_minus1 =
                    (M4OSA_UInt16)H264MCS_DecVLCReadExpGolombCode(p_bs);
                break;

            case 6:
                pps->pic_size_in_map_units_minus1 =
                    (M4OSA_UInt16)H264MCS_DecVLCReadExpGolombCode(p_bs);

                pps->slice_group_id = (H264UInt8
                    *)M4H264Dec_malloc((pps->pic_size_in_map_units_minus1
                    + 1), M4H264_COREID, (M4OSA_Char *)"PPS");

                if (M4OSA_NULL == pps->slice_group_id)
                {
                    M4OSA_TRACE1_0("DecPPSMCS: allocation error");
                    return M4ERR_ALLOC;
                }

                for ( length = 0, v = pps->num_slice_groups_minus1 + 1; v != 0;
                    v >>= 1, length++ );

                    for ( i = 0; i <= pps->pic_size_in_map_units_minus1; i++ )
                    {
                        pps->slice_group_id[i] =
                            (M4OSA_UInt8)getBits(p_vlc_engine->p_bs, length);
                    }
                    break;
        }
    }
    else
    {
        pps->slice_group_map_type = 0;
    }
    /* End of FMO stuff */

#else

#endif /* _CAP_FMO_ */

    /* num_ref_idx_l0_active_minus1 must be in the range 0, 31 */

    pps->num_ref_idx_l0_active_minus1 =
        (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);
    /* num_ref_idx_l1_active_minus1 must be in the range 0, 31 */
    pps->num_ref_idx_l1_active_minus1 =
        (M4OSA_UInt8)H264MCS_DecVLCReadExpGolombCode(p_bs);
    pps->weighted_pred_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

    /* weighted_bipred_idc must be in the range 0,2 */
    pps->weighted_bipred_idc = (M4OSA_Bool)H264MCS_getBits(p_bs, 2);

    /* pic_init_qp_minus26 must be in the range -26,25 */
    pps->pic_init_qp_minus26 =
        (M4OSA_Int16)H264MCS_DecVLCReadSignedExpGolombCode(p_bs);

    /* pic_init_qs_minus26 must be in the range -26,25 */
    pps->pic_init_qs_minus26 =
        (M4OSA_Int16)H264MCS_DecVLCReadSignedExpGolombCode(p_bs);

    /* chroma_qp_index_offset must be in the range -12,+12 */
    pps->chroma_qp_index_offset =
        (M4OSA_Int16)H264MCS_DecVLCReadSignedExpGolombCode(p_bs);
    pps->deblocking_filter_control_present_flag =
        (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
    pps->constrained_intra_pred_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);
    pps->redundant_pic_cnt_present_flag = (M4OSA_Bool)H264MCS_getBits(p_bs, 1);

    return M4NO_ERROR;
}

M4OSA_ERR H264MCS_ProcessSPS_PPS( NSWAVC_MCS_t *instance, M4OSA_UInt8 *inbuff,
                                 M4OSA_Int32 inbuf_size )
{
    ComBitStreamMCS_t *p_bs, bs;
    ComBitStreamMCS_t *p_bs1, bs1;

    M4OSA_UInt8 nalu_info = 0;
    M4OSA_Int32 forbidden_bit, nal_ref_idc, nal_unit_type;
    M4OSA_Int32 first_mb_in_slice, slice_type, pic_parameter_set_id = 0,
        frame_num;
    M4OSA_Int32 seq_parameter_set_id;
    M4OSA_UInt8 temp1, temp2, temp3, temp4;
    M4OSA_Int32 temp_frame_num;
    M4OSA_Int32 bitstoDiacard, bytes;
    M4OSA_UInt32 mask_bits = 0xFFFFFFFF;
    M4OSA_Int32 new_bytes, init_bit_pos;
    M4OSA_UInt32 nal_size = 0;
    M4OSA_UInt32 cnt, cnt1;
    M4OSA_UInt32 outbuffpos = 0;
    M4OSA_UInt32 nal_size_low16, nal_size_high16;
    M4OSA_UInt32 frame_size = 0;
    M4OSA_UInt32 temp = 0;
    M4OSA_UInt8 *lClipDSI;
    M4OSA_UInt8 *lClipDSI_PPS_start;
    M4OSA_UInt32 lClipDSI_PPS_offset = 0;

    M4OSA_UInt8 *lPPS_Buffer = M4OSA_NULL;
    M4OSA_UInt32 lPPS_Buffer_Size = 0;

    M4OSA_UInt32 lSize, lSize1;
    M4OSA_UInt32 lActiveSPSID_Clip;
    M4OSA_UInt32 lClipPPSRemBits = 0;

    M4OSA_UInt32 lEncoder_SPSID = 0;
    M4OSA_UInt32 lEncoder_PPSID = 0;
    M4OSA_UInt32 lEncoderPPSRemBits = 0;
    M4OSA_UInt32 lFound = 0;
    M4OSA_UInt32 size;

    M4OSA_UInt8 Clip_SPSID[32] = { 0 };
    M4OSA_UInt8 Clip_UsedSPSID[32] = { 0 };
    M4OSA_UInt8 Clip_PPSID[256] = { 0 };
    M4OSA_UInt8 Clip_SPSID_in_PPS[256] = { 0 };
    M4OSA_UInt8 Clip_UsedPPSID[256] = { 0 };
    M4OSA_ERR err = M4NO_ERROR;

    p_bs = &bs;
    p_bs1 = &bs1;

    /* Find the active SPS ID */
    M4OSA_DEBUG_IF2((M4OSA_NULL == instance), M4ERR_PARAMETER,
        "H264MCS_ProcessSPS_PPS: instance is M4OSA_NULL");

    switch( instance->m_pDecoderSpecificInfo[4] & 0x3 )
    {
        case 0:
            instance->m_Num_Bytes_NALUnitLength = 1;
            break;

        case 1:
            instance->m_Num_Bytes_NALUnitLength = 2;
            break;

        case 3:
            //Note: Current code supports only this...
            instance->m_Num_Bytes_NALUnitLength = 4;
            break;
    }

    instance->m_encoder_SPS_Cnt = instance->m_pDecoderSpecificInfo[5] & 0x1F;

    lClipDSI = instance->m_pDecoderSpecificInfo + 6;

    lClipDSI_PPS_offset = 6;

    for ( cnt = 0; cnt < instance->m_encoder_SPS_Cnt; cnt++ )
    {
        lSize = ( lClipDSI[0] << 8) + lClipDSI[1];
        lClipDSI = lClipDSI + 2;

        p_bs->Buffer = (M4OSA_UInt8 *)(lClipDSI + 4);
        DecBitStreamReset_MCS(p_bs, lSize - 4);

        Clip_SPSID[cnt] = H264MCS_DecVLCReadExpGolombCode(p_bs);
        Clip_UsedSPSID[Clip_SPSID[cnt]] = 1;

        lClipDSI = lClipDSI + lSize;
        lClipDSI_PPS_offset = lClipDSI_PPS_offset + 2 + lSize;
    }

    instance->m_encoder_PPS_Cnt = lClipDSI[0];
    lClipDSI = lClipDSI + 1;

    lClipDSI_PPS_start = lClipDSI;

    for ( cnt = 0; cnt < instance->m_encoder_PPS_Cnt; cnt++ )
    {
        lSize = ( lClipDSI[0] << 8) + lClipDSI[1];
        lClipDSI = lClipDSI + 2;

        p_bs->Buffer = (M4OSA_UInt8 *)(lClipDSI + 1);
        DecBitStreamReset_MCS(p_bs, lSize - 1);

        Clip_PPSID[cnt] = H264MCS_DecVLCReadExpGolombCode(p_bs);
        Clip_UsedPPSID[Clip_PPSID[cnt]] = 1;
        Clip_SPSID_in_PPS[Clip_PPSID[cnt]] =
            H264MCS_DecVLCReadExpGolombCode(p_bs);

        lClipDSI = lClipDSI + lSize;
    }

    /* Find the clip SPS ID used at the cut start frame */
    while( ( (M4OSA_Int32)frame_size) < inbuf_size )
    {
        mask_bits = 0xFFFFFFFF;
        p_bs->Buffer = (M4OSA_UInt8 *)(inbuff + frame_size);

        switch( instance->m_Num_Bytes_NALUnitLength )
        {
            case 1:
                nal_size = (unsigned char)p_bs->Buffer[0];
                nalu_info = (unsigned char)p_bs->Buffer[1];
                p_bs->Buffer = p_bs->Buffer + 2;

                break;

            case 2:
                nal_size_high16 = ( p_bs->Buffer[0] << 8) + p_bs->Buffer[1];
                nal_size = nal_size_high16;
                nalu_info = (unsigned char)p_bs->Buffer[2];
                p_bs->Buffer = p_bs->Buffer + 3;

                break;

            case 4:
                nal_size_high16 = ( p_bs->Buffer[0] << 8) + p_bs->Buffer[1];
                nal_size_low16 = ( p_bs->Buffer[2] << 8) + p_bs->Buffer[3];
                nal_size = ( nal_size_high16 << 16) + nal_size_low16;
                nalu_info = (unsigned char)p_bs->Buffer[4];
                p_bs->Buffer = p_bs->Buffer + 5;

                break;
        }

        p_bs->bitPos = 0;
        p_bs->lastTotalBits = 0;
        p_bs->numBitsInBuffer =
            ( inbuf_size - frame_size - instance->m_Num_Bytes_NALUnitLength - 1)
            << 3;
        p_bs->readableBytesInBuffer =
            inbuf_size - frame_size - instance->m_Num_Bytes_NALUnitLength - 1;

        p_bs->ui32TempBuff = 0;
        p_bs->i8BitCnt = 0;
        p_bs->pui8BfrPtr = (M4OSA_Int8 *)p_bs->Buffer;
        p_bs->ui32LastTwoBytes = 0xFFFFFFFF;

        H264MCS_getBits(p_bs, 0);

        frame_size += nal_size + instance->m_Num_Bytes_NALUnitLength;

        forbidden_bit = ( nalu_info >> 7) & 1;
        nal_ref_idc = ( nalu_info >> 5) & 3;
        nal_unit_type = (nalu_info) &0x1f;

        if( nal_unit_type == 8 )
        {
            M4OSA_TRACE1_0("H264MCS_ProcessSPS_PPS() Error: PPS");
            return err;
        }

        if( nal_unit_type == 7 )
        {
            /*SPS Packet */
            M4OSA_TRACE1_0("H264MCS_ProcessSPS_PPS() Error: SPS");
            return err;
        }

        if( ( nal_unit_type == 1) || (nal_unit_type == 5) )
        {
            first_mb_in_slice = H264MCS_DecVLCReadExpGolombCode(p_bs);
            slice_type = H264MCS_DecVLCReadExpGolombCode(p_bs);
            pic_parameter_set_id = H264MCS_DecVLCReadExpGolombCode(p_bs);
            break;
        }
    }

    lActiveSPSID_Clip = Clip_SPSID_in_PPS[pic_parameter_set_id];

    instance->final_SPS_ID = lActiveSPSID_Clip;
    /* Do we need to add encoder PPS to clip PPS */

    lClipDSI = lClipDSI_PPS_start;

    for ( cnt = 0; cnt < instance->m_encoder_PPS_Cnt; cnt++ )
    {
        lSize = ( lClipDSI[0] << 8) + lClipDSI[1];
        lClipDSI = lClipDSI + 2;

        if( lActiveSPSID_Clip == Clip_SPSID_in_PPS[Clip_PPSID[cnt]] )
        {
            lPPS_Buffer = lClipDSI + 1;
            lPPS_Buffer_Size = lSize - 1;

            p_bs->Buffer = (M4OSA_UInt8 *)(lClipDSI + 1);
            DecBitStreamReset_MCS(p_bs, lSize - 1);

            Clip_PPSID[cnt] = H264MCS_DecVLCReadExpGolombCode(p_bs);
            Clip_UsedPPSID[Clip_SPSID[cnt]] = 1;
            Clip_SPSID_in_PPS[cnt] = H264MCS_DecVLCReadExpGolombCode(p_bs);
            lClipPPSRemBits = ( lSize - 1) << 3;
            lClipPPSRemBits -= p_bs->bitPos;

            temp = lClipDSI[lSize - 1];

            cnt1 = 0;

            while( ( temp & 0x1) == 0 )
            {
                cnt1++;
                temp = temp >> 1;
            }
            cnt1++;
            lClipPPSRemBits -= cnt1;

            lSize1 = instance->m_encoderPPSSize - 1;
            p_bs1->Buffer = (M4OSA_UInt8 *)(instance->m_pEncoderPPS + 1);
            DecBitStreamReset_MCS(p_bs1, lSize1);

            lEncoder_PPSID = H264MCS_DecVLCReadExpGolombCode(p_bs1);
            lEncoder_SPSID = H264MCS_DecVLCReadExpGolombCode(p_bs1);

            lEncoderPPSRemBits = ( lSize1) << 3;
            lEncoderPPSRemBits -= p_bs1->bitPos;

            temp = instance->m_pEncoderPPS[lSize1];

            cnt1 = 0;

            while( ( temp & 0x1) == 0 )
            {
                cnt1++;
                temp = temp >> 1;
            }
            cnt1++;
            lEncoderPPSRemBits -= cnt1;

            if( lEncoderPPSRemBits == lClipPPSRemBits )
            {
                while( lEncoderPPSRemBits > 8 )
                {
                    temp1 = H264MCS_getBits(p_bs, 8);
                    temp2 = H264MCS_getBits(p_bs1, 8);
                    lEncoderPPSRemBits = lEncoderPPSRemBits - 8;

                    if( temp1 != temp2 )
                    {
                        break;
                    }
                }

                if( lEncoderPPSRemBits < 8 )
                {
                    if( lEncoderPPSRemBits )
                    {
                        temp1 = H264MCS_getBits(p_bs, lEncoderPPSRemBits);
                        temp2 = H264MCS_getBits(p_bs1, lEncoderPPSRemBits);

                        if( temp1 == temp2 )
                        {
                            lFound = 1;
                        }
                    }
                    else
                    {
                        lFound = 1;
                    }
                }
                break;
            }
        }

        lClipDSI = lClipDSI + lSize;
    }

    /* Form the final SPS and PPS data */

    if( lFound == 1 )
    {
        /* No need to add PPS */
        instance->final_PPS_ID = Clip_PPSID[cnt];

        instance->m_pFinalDSI =
            (M4OSA_UInt8 *)M4OSA_32bitAlignedMalloc(instance->m_decoderSpecificInfoSize,
            M4MCS, (M4OSA_Char *)"instance->m_pFinalDSI");

        if( instance->m_pFinalDSI == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("instance->m_pFinalDSI: allocation error");
            return M4ERR_ALLOC;
        }

        instance->m_pFinalDSISize = instance->m_decoderSpecificInfoSize;
        memcpy((void *)instance->m_pFinalDSI,
            (void *)instance->m_pDecoderSpecificInfo,
            instance->m_decoderSpecificInfoSize);
    }
    else
    {
        /* ADD PPS */
        /* find the free PPS ID */

        cnt = 0;

        while( Clip_UsedPPSID[cnt] )
        {
            cnt++;
        }
        instance->final_PPS_ID = cnt;

        size = instance->m_decoderSpecificInfoSize + instance->m_encoderPPSSize
            + 10;

        instance->m_pFinalDSI = (M4OSA_UInt8 *)M4OSA_32bitAlignedMalloc(size, M4MCS,
            (M4OSA_Char *)"instance->m_pFinalDSI");

        if( instance->m_pFinalDSI == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("instance->m_pFinalDSI: allocation error");
            return M4ERR_ALLOC;
        }

        memcpy((void *)instance->m_pFinalDSI,
            (void *)instance->m_pDecoderSpecificInfo,
            instance->m_decoderSpecificInfoSize);

        temp = instance->m_pFinalDSI[lClipDSI_PPS_offset];
        temp = temp + 1;
        instance->m_pFinalDSI[lClipDSI_PPS_offset] = temp;

        //temp = instance->m_pEncoderPPS[0];
        lSize1 = instance->m_encoderPPSSize - 1;
        p_bs1->Buffer = (M4OSA_UInt8 *)(instance->m_pEncoderPPS + 1);
        DecBitStreamReset_MCS(p_bs1, lSize1);

        lEncoder_PPSID = H264MCS_DecVLCReadExpGolombCode(p_bs1);
        lEncoder_SPSID = H264MCS_DecVLCReadExpGolombCode(p_bs1);

        lEncoderPPSRemBits = ( lSize1) << 3;
        lEncoderPPSRemBits -= p_bs1->bitPos;

        temp = instance->m_pEncoderPPS[lSize1];

        cnt1 = 0;

        while( ( temp & 0x1) == 0 )
        {
            cnt1++;
            temp = temp >> 1;
        }
        cnt1++;
        lEncoderPPSRemBits -= cnt1;

        instance->m_pFinalDSI[instance->m_decoderSpecificInfoSize + 2] =
            instance->m_pEncoderPPS[0];

        NSWAVCMCS_initBitstream(&instance->encbs);
        instance->encbs.streamBuffer =
            &(instance->m_pFinalDSI[instance->m_decoderSpecificInfoSize + 3]);
        lPPS_Buffer = instance->encbs.streamBuffer;

        NSWAVCMCS_uExpVLC(&instance->encbs, instance->final_PPS_ID);
        NSWAVCMCS_uExpVLC(&instance->encbs, instance->final_SPS_ID);

        while( lEncoderPPSRemBits > 8 )
        {
            temp = H264MCS_getBits(p_bs1, 8);
            NSWAVCMCS_putBits(&instance->encbs, temp, 8);
            lEncoderPPSRemBits = lEncoderPPSRemBits - 8;
        }

        if( lEncoderPPSRemBits )
        {
            temp = H264MCS_getBits(p_bs1, lEncoderPPSRemBits);
            NSWAVCMCS_putBits(&instance->encbs, temp, lEncoderPPSRemBits);
        }
        NSWAVCMCS_putRbspTbits(&instance->encbs);

        temp = instance->encbs.byteCnt;
        lPPS_Buffer_Size = temp;
        temp = temp + 1;

        instance->m_pFinalDSI[instance->m_decoderSpecificInfoSize] =
            ( temp >> 8) & 0xFF;
        instance->m_pFinalDSI[instance->m_decoderSpecificInfoSize + 1] =
            (temp) &0xFF;
        instance->m_pFinalDSISize =
            instance->m_decoderSpecificInfoSize + 2 + temp;
    }

    /* Decode the clip SPS */

    lClipDSI = instance->m_pDecoderSpecificInfo + 6;

    lClipDSI_PPS_offset = 6;

    for ( cnt = 0; cnt < instance->m_encoder_SPS_Cnt; cnt++ )
    {
        lSize = ( lClipDSI[0] << 8) + lClipDSI[1];
        lClipDSI = lClipDSI + 2;

        if( Clip_SPSID[cnt] == instance->final_SPS_ID )
        {
            p_bs->Buffer = (M4OSA_UInt8 *)(lClipDSI + 1);
            DecBitStreamReset_MCS(p_bs, lSize - 1);

            DecSPSMCS(p_bs, &instance->clip_sps);

            //Clip_SPSID[cnt] = H264MCS_DecVLCReadExpGolombCode(p_bs);
            //Clip_UsedSPSID[Clip_SPSID[cnt]] = 1;
            break;
        }

        lClipDSI = lClipDSI + lSize;
    }

    /* Decode encoder SPS */
    p_bs->Buffer = (M4OSA_UInt8 *)(instance->m_pEncoderSPS + 1);
    DecBitStreamReset_MCS(p_bs, instance->m_encoderSPSSize - 1);
    DecSPSMCS(p_bs, &instance->encoder_sps);

    if( instance->encoder_sps.num_ref_frames
    > instance->clip_sps.num_ref_frames )
    {
        return 100; //not supported
    }

    p_bs->Buffer = (M4OSA_UInt8 *)lPPS_Buffer;
    DecBitStreamReset_MCS(p_bs, lPPS_Buffer_Size);
    DecPPSMCS(p_bs, &instance->encoder_pps);

    instance->frame_count = 0;
    instance->frame_mod_count =
        1 << (instance->clip_sps.log2_max_frame_num_minus4 + 4);

    instance->POC_lsb = 0;
    instance->POC_lsb_mod =
        1 << (instance->clip_sps.log2_max_pic_order_cnt_lsb_minus4 + 4);

    return M4NO_ERROR;
}

M4OSA_ERR H264MCS_ProcessNALU( NSWAVC_MCS_t *ainstance, M4OSA_UInt8 *inbuff,
                               M4OSA_Int32 inbuf_size, M4OSA_UInt8 *outbuff,
                               M4OSA_Int32 *outbuf_size )
{
    ComBitStreamMCS_t *p_bs, bs;
    NSWAVC_MCS_t *instance;
    M4OSA_UInt8 nalu_info;
    M4OSA_Int32 forbidden_bit, nal_ref_idc, nal_unit_type;
    M4OSA_Int32 first_mb_in_slice, slice_type, pic_parameter_set_id, frame_num;
    M4OSA_Int32 seq_parameter_set_id;
    M4OSA_UInt8 temp1, temp2, temp3, temp4;
    M4OSA_Int32 temp_frame_num;
    M4OSA_Int32 bitstoDiacard, bytes;
    M4OSA_UInt32 mask_bits = 0xFFFFFFFF;
    M4OSA_Int32 new_bytes, init_bit_pos;
    M4OSA_UInt32 nal_size;
    M4OSA_UInt32 cnt;
    M4OSA_UInt32 outbuffpos = 0;
    //#ifndef DGR_FIX // + new
    M4OSA_UInt32 nal_size_low16, nal_size_high16;
    //#endif // + end new
    M4OSA_UInt32 frame_size = 0;
    M4OSA_UInt32 temp = 0;
    M4OSA_ERR err = M4NO_ERROR;
    M4OSA_UInt8 *buff;

    p_bs = &bs;
    instance = (NSWAVC_MCS_t *)ainstance;
    M4OSA_DEBUG_IF2((M4OSA_NULL == instance), M4ERR_PARAMETER,
        "H264MCS_ProcessNALU: instance is M4OSA_NULL");

    if( instance->is_done )
        return err;

    inbuff[0] = 0x00;
    inbuff[1] = 0x00;
    inbuff[2] = 0x00;
    inbuff[3] = 0x01;


    while( (M4OSA_Int32)frame_size < inbuf_size )
    {
        mask_bits = 0xFFFFFFFF;
        p_bs->Buffer = (M4OSA_UInt8 *)(inbuff + frame_size);


        nalu_info = (unsigned char)p_bs->Buffer[4];

        outbuff[outbuffpos] = p_bs->Buffer[0];
        outbuff[outbuffpos + 1] = p_bs->Buffer[1];
        outbuff[outbuffpos + 2] = p_bs->Buffer[2];
        outbuff[outbuffpos + 3] = p_bs->Buffer[3];
        outbuff[outbuffpos + 4] = p_bs->Buffer[4];

        p_bs->Buffer = p_bs->Buffer + 5;

        p_bs->bitPos = 0;
        p_bs->lastTotalBits = 0;
        p_bs->numBitsInBuffer = ( inbuf_size - frame_size - 5) << 3;
        p_bs->readableBytesInBuffer = inbuf_size - frame_size - 5;

        p_bs->ui32TempBuff = 0;
        p_bs->i8BitCnt = 0;
        p_bs->pui8BfrPtr = (M4OSA_Int8 *)p_bs->Buffer;
        p_bs->ui32LastTwoBytes = 0xFFFFFFFF;

        H264MCS_getBits(p_bs, 0);



        nal_size = inbuf_size - frame_size - 4;
        buff = inbuff + frame_size + 4;

        while( nal_size > 4 )
        {
            if( ( buff[0] == 0x00) && (buff[1] == 0x00) && (buff[2] == 0x00)
                && (buff[3] == 0x01) )
            {
                break;
            }
            buff = buff + 1;
            nal_size = nal_size - 1;
        }

        if( nal_size <= 4 )
        {
            nal_size = 0;
        }
        nal_size = ( inbuf_size - frame_size - 4) - nal_size;

        //      M4OSA_TRACE1_3("H264MCS_ProcessNALU frame  input buff size = %d  current position
        //= %d   nal size = %d",
        //  inbuf_size, frame_size,  nal_size + 4);
        frame_size += nal_size + 4;



        forbidden_bit = ( nalu_info >> 7) & 1;
        nal_ref_idc = ( nalu_info >> 5) & 3;
        nal_unit_type = (nalu_info) &0x1f;

        if( nal_unit_type == 5 )
        {
            /*IDR/PPS Packet - Do nothing*/
            instance->is_done = 1;
            return err;
        }

        NSWAVCMCS_initBitstream(&instance->encbs);
        instance->encbs.streamBuffer = outbuff + outbuffpos + 5;

        if( nal_unit_type == 8 )
        {
            M4OSA_TRACE1_0("H264MCS_ProcessNALU() Error: PPS");
            return err;
        }

        if( nal_unit_type == 7 )
        {
            /*SPS Packet */
            M4OSA_TRACE1_0("H264MCS_ProcessNALU() Error: SPS");
            return 0;
        }

        if( (nal_unit_type == 5) )
        {
            instance->frame_count = 0;
            instance->POC_lsb = 0;
        }

        if( (nal_unit_type == 1) )
        {
            first_mb_in_slice = H264MCS_DecVLCReadExpGolombCode(p_bs);
            NSWAVCMCS_uExpVLC(&instance->encbs, first_mb_in_slice);

            slice_type = H264MCS_DecVLCReadExpGolombCode(p_bs);
            NSWAVCMCS_uExpVLC(&instance->encbs, slice_type);

            pic_parameter_set_id = H264MCS_DecVLCReadExpGolombCode(p_bs);
            NSWAVCMCS_uExpVLC(&instance->encbs, pic_parameter_set_id);

            temp = H264MCS_getBits(p_bs,
                instance->clip_sps.log2_max_frame_num_minus4 + 4);
            NSWAVCMCS_putBits(&instance->encbs, instance->frame_count,
                instance->clip_sps.log2_max_frame_num_minus4 + 4);

            // In Baseline Profile: frame_mbs_only_flag should be ON

            if( nal_unit_type == 5 )
            {
                temp = H264MCS_DecVLCReadExpGolombCode(p_bs);
                NSWAVCMCS_uExpVLC(&instance->encbs, temp);
            }

            if( instance->clip_sps.pic_order_cnt_type == 0 )
            {
                temp = H264MCS_getBits(p_bs,
                    instance->clip_sps.log2_max_pic_order_cnt_lsb_minus4
                    + 4);
                NSWAVCMCS_putBits(&instance->encbs, instance->POC_lsb,
                    instance->clip_sps.log2_max_pic_order_cnt_lsb_minus4 + 4);
            }

            if( ( instance->clip_sps.pic_order_cnt_type == 1)
                && (instance->clip_sps.delta_pic_order_always_zero_flag) )
            {
                temp = H264MCS_DecVLCReadSignedExpGolombCode(p_bs);
                NSWAVCMCS_sExpVLC(&instance->encbs, temp);
            }

            cnt = p_bs->bitPos & 0x7;

            if( cnt )
            {
                cnt = 8 - cnt;
                temp = H264MCS_getBits(p_bs, cnt);
                NSWAVCMCS_putBits(&instance->encbs, temp, cnt);
            }

            cnt = p_bs->bitPos >> 3;

            while( cnt < (nal_size - 2) )
            {
                temp = H264MCS_getBits(p_bs, 8);
                NSWAVCMCS_putBits(&instance->encbs, temp, 8);
                cnt = p_bs->bitPos >> 3;
            }

            temp = H264MCS_getBits(p_bs, 8);

            if( temp != 0 )
            {
                cnt = 0;

                while( ( temp & 0x1) == 0 )
                {
                    cnt++;
                    temp = temp >> 1;
                }
                cnt++;
                temp = temp >> 1;

                if( 8 - cnt )
                {
                    NSWAVCMCS_putBits(&instance->encbs, temp, (8 - cnt));
                }

                NSWAVCMCS_putRbspTbits(&instance->encbs);
            }
            else
            {
                if( instance->encbs.bitPos % 8 )
                {
                    NSWAVCMCS_putBits(&instance->encbs, 0,
                        (8 - instance->encbs.bitPos % 8));
                }
            }

            temp = instance->encbs.byteCnt;
            temp = temp + 1;

            outbuff[outbuffpos] = (M4OSA_UInt8)(( temp >> 24) & 0xFF);
            outbuff[outbuffpos + 1] = (M4OSA_UInt8)(( temp >> 16) & 0xFF);
            outbuff[outbuffpos + 2] = (M4OSA_UInt8)(( temp >> 8) & 0xFF);
            outbuff[outbuffpos + 3] = (M4OSA_UInt8)((temp) &0xFF);
            outbuffpos = outbuffpos + temp + 4;
        }
        else
        {
            p_bs->Buffer = p_bs->Buffer - 5;
            memcpy((void *) &outbuff[outbuffpos],
                (void *)p_bs->Buffer, nal_size + 4);

            outbuff[outbuffpos] = (M4OSA_UInt8)((nal_size >> 24)& 0xFF);
        outbuff[outbuffpos + 1] = (M4OSA_UInt8)((nal_size >> 16)& 0xFF);;
        outbuff[outbuffpos + 2] = (M4OSA_UInt8)((nal_size >> 8)& 0xFF);;
        outbuff[outbuffpos + 3] = (M4OSA_UInt8)((nal_size)& 0xFF);;

            outbuffpos = outbuffpos + nal_size + 4;
        }
    }

    *outbuf_size = outbuffpos;

    instance->POC_lsb = instance->POC_lsb + 1;

    if( instance->POC_lsb == instance->POC_lsb_mod )
    {
        instance->POC_lsb = 0;
    }
    instance->frame_count = instance->frame_count + 1;

    if( instance->frame_count == instance->frame_mod_count )
    {
        instance->frame_count = 0;
    }
    return M4NO_ERROR;
}

M4OSA_ERR   M4MCS_convetFromByteStreamtoNALStream(  M4OSA_UInt8 *inbuff,
                                                    M4OSA_UInt32 inbuf_size )
{
    M4OSA_ERR err = M4NO_ERROR;
    M4OSA_UInt32 framesize = 0;
    M4OSA_UInt32 nal_size =0;
    M4OSA_UInt8 *buff;


    while(framesize < inbuf_size)
    {
            nal_size = inbuf_size - framesize - 4;
            buff =  inbuff + framesize + 4;

            while(nal_size > 4){
                if((buff[0] == 0x00) &&
                (buff[1] == 0x00) &&
                (buff[2] == 0x00) &&
                (buff[3] == 0x01)){
                    break;
                }
                buff = buff + 1;
                nal_size = nal_size -1;
            }

            if(nal_size <= 4){
                nal_size = 0;
            }
            nal_size = (inbuf_size - framesize - 4) - nal_size;

        inbuff[framesize + 0]  = (M4OSA_UInt8)((nal_size >> 24)& 0xFF);
        inbuff[framesize + 1]  = (M4OSA_UInt8)((nal_size >> 16)& 0xFF);
        inbuff[framesize + 2]  = (M4OSA_UInt8)((nal_size >> 8)& 0xFF);
        inbuff[framesize + 3]  = (M4OSA_UInt8)((nal_size )& 0xFF);
        framesize += nal_size + 4;

        M4OSA_TRACE1_2("M4MCS_convetFromByteStreamtoNALStream framesize = %x nalsize = %x",
            framesize, nal_size)
    }

    return  err;
}


M4OSA_ERR H264MCS_Freeinstance( NSWAVC_MCS_t *instance )
{
    M4OSA_ERR err = M4NO_ERROR;
    M4OSA_DEBUG_IF2((M4OSA_NULL == instance), M4ERR_PARAMETER,
        "H264MCS_Freeinstance: instance is M4OSA_NULL");

    if( M4OSA_NULL != instance->encoder_pps.slice_group_id )
    {
        free(instance->encoder_pps.slice_group_id);
    }

    if( M4OSA_NULL != instance->p_encoder_sps )
    {
        free(instance->p_encoder_sps);
        instance->p_encoder_sps = M4OSA_NULL;
    }

    if( M4OSA_NULL != instance->p_encoder_pps )
    {
        free(instance->p_encoder_pps);
        instance->p_encoder_pps = M4OSA_NULL;
    }

    if( M4OSA_NULL != instance->m_pFinalDSI )
    {
        free(instance->m_pFinalDSI);
        instance->m_pFinalDSI = M4OSA_NULL;
    }

    if( M4OSA_NULL != instance )
    {
        free(instance);
        instance = M4OSA_NULL;
    }

    return err;
}
/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_getVersion(M4_VersionInfo* pVersionInfo);
 * @brief    Get the MCS 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 M4MCS_getVersion( M4_VersionInfo *pVersionInfo )
{
    M4OSA_TRACE3_1("M4MCS_getVersion called with pVersionInfo=0x%x",
        pVersionInfo);

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

    pVersionInfo->m_major = M4MCS_VERSION_MAJOR;
    pVersionInfo->m_minor = M4MCS_VERSION_MINOR;
    pVersionInfo->m_revision = M4MCS_VERSION_REVISION;

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_getVersion(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * @brief    Initializes the MCS (allocates an execution context).
 * @note
 * @param    pContext            (OUT) Pointer on the MCS 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 M4MCS_init( M4MCS_Context *pContext,
                     M4OSA_FileReadPointer *pFileReadPtrFct,
                     M4OSA_FileWriterPointer *pFileWritePtrFct )
{
    M4MCS_InternalContext *pC = M4OSA_NULL;
    M4OSA_ERR err;

    M4OSA_TRACE3_3(
        "M4MCS_init called with pContext=0x%x, pFileReadPtrFct=0x%x, pFileWritePtrFct=0x%x",
        pContext, pFileReadPtrFct, pFileWritePtrFct);

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

    /**
    * Allocate the MCS context and return it to the user */
    pC = (M4MCS_InternalContext *)M4OSA_32bitAlignedMalloc(sizeof(M4MCS_InternalContext),
        M4MCS, (M4OSA_Char *)"M4MCS_InternalContext");
    *pContext = pC;

    if( M4OSA_NULL == pC )
    {
        M4OSA_TRACE1_0(
            "M4MCS_init(): unable to allocate M4MCS_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->State = M4MCS_kState_CREATED;
    pC->pOsaFileReadPtr = pFileReadPtrFct;
    pC->pOsaFileWritPtr = pFileWritePtrFct;
    pC->VideoState = M4MCS_kStreamState_NOSTREAM;
    pC->AudioState = M4MCS_kStreamState_NOSTREAM;
    pC->noaudio = M4OSA_FALSE;
    pC->novideo = M4OSA_FALSE;
    pC->uiProgress = 0;

    /**
    * Reader stuff */
    pC->pInputFile = M4OSA_NULL;
    pC->InputFileType = M4VIDEOEDITING_kFileType_Unsupported;
    pC->bFileOpenedInFastMode = M4OSA_FALSE;
    pC->pReaderContext = M4OSA_NULL;
    pC->pReaderVideoStream = M4OSA_NULL;
    pC->pReaderAudioStream = M4OSA_NULL;
    pC->bUnsupportedVideoFound = M4OSA_FALSE;
    pC->bUnsupportedAudioFound = M4OSA_FALSE;
    pC->iAudioCtsOffset = 0;
    /* First temporary video AU to have more precise end video cut*/
    pC->ReaderVideoAU1.m_structSize = 0;
    /* Second temporary video AU to have more precise end video cut*/
    pC->ReaderVideoAU2.m_structSize = 0;
    pC->ReaderAudioAU1.m_structSize = 0;
    pC->ReaderAudioAU2.m_structSize = 0;
    pC->m_audioAUDuration = 0;
    pC->m_pDataAddress1 = M4OSA_NULL;
    pC->m_pDataAddress2 = M4OSA_NULL;
    /* First temporary video AU data to have more precise end video cut*/
    pC->m_pDataVideoAddress1 = M4OSA_NULL;
    /* Second temporary video AU data to have more precise end video cut*/
    pC->m_pDataVideoAddress2 = M4OSA_NULL;

    /**
    * Video decoder stuff */
    pC->pViDecCtxt = M4OSA_NULL;
    pC->dViDecStartingCts = 0.0;
    pC->iVideoBeginDecIncr = 0;
    pC->dViDecCurrentCts = 0.0;
    pC->dCtsIncrement = 0.0;
    pC->isRenderDup = M4OSA_FALSE;

    /**
    * Video encoder stuff */
    pC->pViEncCtxt = M4OSA_NULL;
    pC->pPreResizeFrame = M4OSA_NULL;
    pC->uiEncVideoBitrate = 0;
    pC->bActivateEmp = M4OSA_FALSE;
    pC->encoderState = M4MCS_kNoEncoder;

    /**
    * Audio decoder stuff */
    pC->pAudioDecCtxt = M4OSA_NULL;
    pC->AudioDecBufferIn.m_dataAddress = M4OSA_NULL;
    pC->AudioDecBufferIn.m_bufferSize = 0;
    pC->AudioDecBufferOut.m_dataAddress = M4OSA_NULL;
    pC->AudioDecBufferOut.m_bufferSize = 0;
    pC->pPosInDecBufferOut = M4OSA_NULL;
    /**
    * Ssrc stuff */
    pC->pSsrcBufferIn = M4OSA_NULL;
    pC->pSsrcBufferOut = M4OSA_NULL;
    pC->pPosInSsrcBufferIn = M4OSA_NULL;
    pC->pPosInSsrcBufferOut = M4OSA_NULL;
    pC->iSsrcNbSamplIn = 0;
    pC->iSsrcNbSamplOut = 0;
    pC->SsrcScratch = M4OSA_NULL;
    pC->pLVAudioResampler = M4OSA_NULL;
    /**
    * Audio encoder */
    pC->pAudioEncCtxt = M4OSA_NULL;
    pC->pAudioEncDSI.infoSize = 0;
    pC->pAudioEncDSI.pInfo = M4OSA_NULL;
    pC->pAudioEncoderBuffer = M4OSA_NULL;
    pC->pPosInAudioEncoderBuffer = M4OSA_NULL;
    pC->audioEncoderGranularity = 0;

    /**
    * Writer stuff */
    pC->pOutputFile = M4OSA_NULL;
    pC->pTemporaryFile = M4OSA_NULL;
    pC->pWriterContext = M4OSA_NULL;
    pC->uiVideoAUCount = 0;
    pC->uiVideoMaxAuSize = 0;
    pC->uiVideoMaxChunckSize = 0;
    pC->uiAudioAUCount = 0;
    pC->uiAudioMaxAuSize = 0;

    pC->uiAudioCts = 0;
    pC->b_isRawWriter = M4OSA_FALSE;
    pC->pOutputPCMfile = M4OSA_NULL;

    /* Encoding config */
    pC->EncodingVideoFormat = M4ENCODER_kNULL; /**< No format set yet */
    pC->EncodingWidth = 0;                     /**< No size set yet */
    pC->EncodingHeight = 0;                    /**< No size set yet */
    pC->EncodingVideoFramerate = 0;            /**< No framerate set yet */

    pC->uiBeginCutTime = 0;                    /**< No begin cut */
    pC->uiEndCutTime = 0;                      /**< No end cut */
    pC->uiMaxFileSize = 0;                     /**< No limit */
    pC->uiAudioBitrate =
        M4VIDEOEDITING_kUndefinedBitrate; /**< No bitrate set yet */
    pC->uiVideoBitrate =
        M4VIDEOEDITING_kUndefinedBitrate; /**< No bitrate set yet */

    pC->WriterVideoStream.streamType = M4SYS_kVideoUnknown;
    pC->WriterVideoStreamInfo.Header.pBuf = M4OSA_NULL;
    pC->WriterAudioStream.streamType = M4SYS_kAudioUnknown;

    pC->outputVideoTimescale = 0;

    /*FB 2008/10/20: add media rendering parameter and AIR context to keep media aspect ratio*/
    pC->MediaRendering = M4MCS_kResizing;
    pC->m_air_context = M4OSA_NULL;
    /**/

    /**
    * FlB 2009.03.04: add audio Effects*/
    pC->pEffects = M4OSA_NULL;
    pC->nbEffects = 0;
    pC->pActiveEffectNumber = -1;
    /**/

    /*
    * Reset pointers for media and codecs interfaces */
    err = M4MCS_clearInterfaceTables(pC);
    M4ERR_CHECK_RETURN(err);

    /*
    *  Call the media and codecs subscription module */
    err = M4MCS_subscribeMediaAndCodec(pC);
    M4ERR_CHECK_RETURN(err);

#ifdef M4MCS_SUPPORT_STILL_PICTURE
    /**
    * Initialize the Still picture part of MCS*/

    err = M4MCS_stillPicInit(pC, pFileReadPtrFct, pFileWritePtrFct);
    M4ERR_CHECK_RETURN(err);

    pC->m_bIsStillPicture = M4OSA_FALSE;

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    pC->m_pInstance = M4OSA_NULL;
    pC->H264MCSTempBuffer = M4OSA_NULL;
    pC->H264MCSTempBufferSize = 0;
    pC->H264MCSTempBufferDataSize = 0;
    pC->bH264Trim = M4OSA_FALSE;

    /* Flag to get the last decoded frame cts */
    pC->bLastDecodedFrameCTS = M4OSA_FALSE;

    if( pC->m_pInstance == M4OSA_NULL )
    {
        err = H264MCS_Getinstance(&pC->m_pInstance);
    }
    pC->bExtOMXAudDecoder = M4OSA_FALSE;

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_init(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_open(M4MCS_Context pContext, M4OSA_Void* pFileIn,
 *                         M4OSA_Void* pFileOut, M4OSA_Void* pTempFile);
 * @brief   Set the MCS input and output files.
 * @note    It opens the input file, but the output file is not created yet.
 * @param   pContext            (IN) MCS context
 * @param   pFileIn             (IN) Input file to transcode (The type of this parameter
 *                                 (URL, pipe...) depends on the OSAL implementation).
 * @param   mediaType           (IN) Container type (.3gp,.amr,mp3 ...) of input file.
 * @param   pFileOut            (IN) Output file to create  (The type of this parameter
 *                                    (URL, pipe...) depends on the OSAL implementation).
 * @param   pTempFile           (IN) Temporary file for the constant memory writer to
 *                                     store metadata ("moov.bin").
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 * @return  M4ERR_ALLOC:        There is no more available memory
 * @return  M4ERR_FILE_NOT_FOUND:   The input file has not been found
 * @return  M4MCS_ERR_INVALID_INPUT_FILE:   The input file is not a valid file, or is corrupted
 * @return  M4MCS_ERR_INPUT_FILE_CONTAINS_NO_SUPPORTED_STREAM:  The input file contains no
 *                                supported audio or video stream
 ******************************************************************************
 */
M4OSA_ERR M4MCS_open( M4MCS_Context pContext, M4OSA_Void *pFileIn,
                     M4VIDEOEDITING_FileType InputFileType, M4OSA_Void *pFileOut,
                     M4OSA_Void *pTempFile )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);
    M4OSA_ERR err;

    M4READER_MediaFamily mediaFamily;
    M4_StreamHandler *pStreamHandler;

    M4OSA_TRACE2_3(
        "M4MCS_open called with pContext=0x%x, pFileIn=0x%x, pFileOut=0x%x",
        pContext, pFileIn, pFileOut);

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

    if( ( InputFileType == M4VIDEOEDITING_kFileType_JPG)
        || (InputFileType == M4VIDEOEDITING_kFileType_PNG)
        || (InputFileType == M4VIDEOEDITING_kFileType_GIF)
        || (InputFileType == M4VIDEOEDITING_kFileType_BMP) )
    {
#ifdef M4MCS_SUPPORT_STILL_PICTURE
        /**
        * Indicate that we must use the still picture functions*/

        pC->m_bIsStillPicture = M4OSA_TRUE;

        /**
        * Call the still picture MCS functions*/
        return M4MCS_stillPicOpen(pC, pFileIn, InputFileType, pFileOut);

#else

        M4OSA_TRACE1_0(
            "M4MCS_open: Still picture is not supported with this version of MCS");
        return M4MCS_ERR_INPUT_FILE_CONTAINS_NO_SUPPORTED_STREAM;

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    }

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

    /* Copy function input parameters into our context */
    pC->pInputFile = pFileIn;
    pC->InputFileType = InputFileType;
    pC->pOutputFile = pFileOut;
    pC->pTemporaryFile = pTempFile;
    pC->uiProgress = 0;

    /***********************************/
    /* Open input file with the reader */
    /***********************************/

    err = M4MCS_setCurrentReader(pContext, pC->InputFileType);
    M4ERR_CHECK_RETURN(err);

    /**
    * Reset reader related variables */
    pC->VideoState = M4MCS_kStreamState_NOSTREAM;
    pC->AudioState = M4MCS_kStreamState_NOSTREAM;
    pC->pReaderVideoStream = M4OSA_NULL;
    pC->pReaderAudioStream = M4OSA_NULL;

    /*******************************************************/
    /* Initializes the reader shell and open the data file */
    /*******************************************************/
    err = pC->m_pReader->m_pFctCreate(&pC->pReaderContext);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1("M4MCS_open(): m_pReader->m_pFctCreate returns 0x%x",
            err);
        return err;
    }

    /**
    * Link the reader interface to the reader context */
    pC->m_pReaderDataIt->m_readerContext = pC->pReaderContext;

    /**
    * Set the reader shell file access functions */
    err = pC->m_pReader->m_pFctSetOption(pC->pReaderContext,
        M4READER_kOptionID_SetOsaFileReaderFctsPtr,
        (M4OSA_DataOption)pC->pOsaFileReadPtr);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1("M4MCS_open(): m_pReader->m_pFctSetOption returns 0x%x",
            err);
        return err;
    }

#ifdef M4MCS_WITH_FAST_OPEN

    if( M4OSA_FALSE == pC->bFileOpenedInFastMode )
    {
        M4OSA_Bool trueValue = M4OSA_TRUE;

        /* For first call use fast open mode */
        err = pC->m_pReader->m_pFctSetOption(pC->pReaderContext,
            M4READER_3GP_kOptionID_FastOpenMode, &trueValue);

        if( M4NO_ERROR == err )
        {
            pC->bFileOpenedInFastMode = M4OSA_TRUE;
        }
        else
        {
            M4OSA_TRACE1_1(
                "M4MCS_open(): M4READER_3GP_kOptionID_FastOpenMode returns 0x%x",
                err);

            if( ( ( (M4OSA_UInt32)M4ERR_BAD_OPTION_ID) == err)
                || (( (M4OSA_UInt32)M4ERR_PARAMETER) == err) )
            {
                /* Not fatal, some readers may not support fast open mode */
                pC->bFileOpenedInFastMode = M4OSA_FALSE;
            }
            else
                return err;
        }
    }
    else
    {
        M4OSA_Bool falseValue = M4OSA_FALSE;

        /* For second call use normal open mode */
        err = pC->m_pReader->m_pFctSetOption(pC->pReaderContext,
            M4READER_3GP_kOptionID_FastOpenMode, &falseValue);
    }

#endif /* M4MCS_WITH_FAST_OPEN */

    /**
    * Open the input file */

    err = pC->m_pReader->m_pFctOpen(pC->pReaderContext, pC->pInputFile);

    if( M4NO_ERROR != err )
    {
        M4OSA_UInt32 uiDummy, uiCoreId;
        M4OSA_TRACE1_1("M4MCS_open(): m_pReader->m_pFctOpen returns 0x%x", err);

        /**
        * If the error is from the core reader, we change it to a public VXS error */
        M4OSA_ERR_SPLIT(err, uiDummy, uiCoreId, uiDummy);

        if( M4MP4_READER == uiCoreId )
        {
            M4OSA_TRACE1_0(
                "M4MCS_open(): returning M4MCS_ERR_INVALID_INPUT_FILE");
            return M4MCS_ERR_INVALID_INPUT_FILE;
        }
        return err;
    }

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

        /**
        * In case we found a BIFS stream or something else...*/
        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 the first video stream */
            if( ( M4READER_kMediaFamilyVideo == mediaFamily)
                && (M4OSA_NULL == pC->pReaderVideoStream) )
            {
                if( ( M4DA_StreamTypeVideoH263 == pStreamHandler->m_streamType)
                    || (M4DA_StreamTypeVideoMpeg4
                    == pStreamHandler->m_streamType)
                    || (M4DA_StreamTypeVideoMpeg4Avc
                    == pStreamHandler->m_streamType) )
                {
                    M4OSA_TRACE3_0(
                        "M4MCS_open(): Found a H263 or MPEG-4 video stream in input 3gpp clip");

                    /**
                    * Keep pointer to the video stream */
                    pC->pReaderVideoStream =
                        (M4_VideoStreamHandler *)pStreamHandler;
                    pC->bUnsupportedVideoFound = M4OSA_FALSE;
                    pStreamHandler->m_bStreamIsOK = M4OSA_TRUE;

                    /**
                    * Init our video stream state variable */
                    pC->VideoState = M4MCS_kStreamState_STARTED;

                    /**
                    * Reset the stream reader */
                    err = pC->m_pReader->m_pFctReset(pC->pReaderContext,
                        (M4_StreamHandler *)pC->pReaderVideoStream);

                    if( M4NO_ERROR != err )
                    {
                        M4OSA_TRACE1_1(
                            "M4MCS_open():\
                            m_pReader->m_pFctReset(video) returns 0x%x",
                            err);
                        return err;
                    }

                    /**
                    * Initializes an access Unit */
                    err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext,
                        pStreamHandler, &pC->ReaderVideoAU);

                    if( M4NO_ERROR != err )
                    {
                        M4OSA_TRACE1_1(
                            "M4MCS_open():\
                            m_pReader->m_pFctFillAuStruct(video) returns 0x%x",
                            err);
                        return err;
                    }
                }
                else /**< Not H263 or MPEG-4 (H264, etc.) */
                {
                    M4OSA_TRACE1_1("M4MCS_open(): Found an unsupported video stream (0x%x) in\
                                   input 3gpp clip",
                                   pStreamHandler->m_streamType);

                    pC->bUnsupportedVideoFound = M4OSA_TRUE;
                    pStreamHandler->m_bStreamIsOK = M4OSA_FALSE;
                }
                /* +CRLV6775 -H.264 Trimming */
                if( M4DA_StreamTypeVideoMpeg4Avc
                    == pStreamHandler->m_streamType )
                {

                    // SPS and PPS are storead as per the 3gp file format
                    pC->m_pInstance->m_pDecoderSpecificInfo =
                        pStreamHandler->m_pH264DecoderSpecificInfo;
                    pC->m_pInstance->m_decoderSpecificInfoSize =
                        pStreamHandler->m_H264decoderSpecificInfoSize;
                }
                /* -CRLV6775 -H.264 Trimming */
            }
            /**
            * Found the first audio stream */
            else if( ( M4READER_kMediaFamilyAudio == mediaFamily)
                && (M4OSA_NULL == pC->pReaderAudioStream) )
            {
                if( ( M4DA_StreamTypeAudioAmrNarrowBand
                    == pStreamHandler->m_streamType)
                    || (M4DA_StreamTypeAudioAac == pStreamHandler->m_streamType)
                    || (M4DA_StreamTypeAudioMp3
                    == pStreamHandler->m_streamType)
                    || (M4DA_StreamTypeAudioEvrc
                    == pStreamHandler->m_streamType) )
                {
                    M4OSA_TRACE3_0(
                        "M4MCS_open(): Found an AMR-NB, AAC or MP3 audio stream in input clip");

                    /**
                    * Keep pointer to the audio stream */
                    pC->pReaderAudioStream =
                        (M4_AudioStreamHandler *)pStreamHandler;
                    pStreamHandler->m_bStreamIsOK = M4OSA_TRUE;
                    pC->bUnsupportedAudioFound = M4OSA_FALSE;

                    /**
                    * Init our audio stream state variable */
                    pC->AudioState = M4MCS_kStreamState_STARTED;

                    /**
                    * Reset the stream reader */
                    err = pC->m_pReader->m_pFctReset(pC->pReaderContext,
                        (M4_StreamHandler *)pC->pReaderAudioStream);

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

                    /**
                    * Initializes an access Unit */
                    err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext,
                        pStreamHandler, &pC->ReaderAudioAU);

                    if( M4NO_ERROR != err )
                    {
                        M4OSA_TRACE1_1(
                            "M4MCS_open():\
                            m_pReader->m_pFctFillAuStruct(audio) returns 0x%x",
                            err);
                        return err;
                    }

                    /**
                    * Output max AU size is equal to input max AU size (this value
                    * will be changed if there is audio transcoding) */
                    pC->uiAudioMaxAuSize = pStreamHandler->m_maxAUSize;
                }
                else
                {
                    /**< Not AMR-NB, AAC, MP3 nor EVRC (AMR-WB, WAV...) */
                    M4OSA_TRACE1_1("M4MCS_open(): Found an unsupported audio stream (0x%x) in \
                                   input 3gpp clip", pStreamHandler->m_streamType);

                    pC->bUnsupportedAudioFound = M4OSA_TRUE;
                    pStreamHandler->m_bStreamIsOK = M4OSA_FALSE;
                }
            }
        }
    } /**< end of while (M4NO_ERROR == err) */

    /**
    * Check we found at least one supported stream */
    if( ( M4OSA_NULL == pC->pReaderVideoStream)
        && (M4OSA_NULL == pC->pReaderAudioStream) )
    {
        M4OSA_TRACE1_0(
            "M4MCS_open(): returning M4MCS_ERR_INPUT_FILE_CONTAINS_NO_SUPPORTED_STREAM");
        return M4MCS_ERR_INPUT_FILE_CONTAINS_NO_SUPPORTED_STREAM;
    }

    if( pC->VideoState == M4MCS_kStreamState_STARTED )
    {
        err = M4MCS_setCurrentVideoDecoder(pContext,
            pC->pReaderVideoStream->m_basicProperties.m_streamType);
        /*FB 2009-02-09: the error is check and returned only if video codecs are compiled,
        else only audio is used, that is why the editing process can continue*/
#ifndef M4MCS_AUDIOONLY

        M4ERR_CHECK_RETURN(err);

#else

        if( ( M4NO_ERROR != err) && (M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED != err) )
        {
            M4ERR_CHECK_RETURN(err);
        }

#endif /*M4MCS_AUDIOONLY*/

    }

    if( pC->AudioState == M4MCS_kStreamState_STARTED )
    {
        //EVRC
        if( M4DA_StreamTypeAudioEvrc
            != pStreamHandler->
            m_streamType ) /* decoder not supported yet, but allow to do null encoding */
        {
            err = M4MCS_setCurrentAudioDecoder(pContext,
                pC->pReaderAudioStream->m_basicProperties.m_streamType);
            M4ERR_CHECK_RETURN(err);
        }
    }

    /**
    * Get the audio and video stream properties */
    err = M4MCS_intGetInputClipProperties(pC);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_open(): M4MCS_intGetInputClipProperties returns 0x%x", err);
        return err;
    }

    /**
    * Set the begin cut decoding increment according to the input frame rate */
    if( 0. != pC->InputFileProperties.fAverageFrameRate ) /**< sanity check */
    {
        pC->iVideoBeginDecIncr = (M4OSA_Int32)(3000.
            / pC->InputFileProperties.
            fAverageFrameRate); /**< about 3 frames */
    }
    else
    {
        pC->iVideoBeginDecIncr =
            200; /**< default value: 200 milliseconds (3 frames @ 15fps)*/
    }

    /**
    * Update state automaton */
    pC->State = M4MCS_kState_OPENED;

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_open(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_step(M4MCS_Context pContext, M4OSA_UInt8 *pProgress);
 * @brief   Perform one step of trancoding.
 * @note
 * @param   pContext            (IN) MCS context
 * @param   pProgress           (OUT) Progress percentage (0 to 100) of the transcoding
 * @note    pProgress must be a valid address.
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    One of the parameters is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 * @return  M4MCS_WAR_TRANSCODING_DONE: Transcoding is over, user should now call M4MCS_close()
 * @return  M4MCS_ERR_AUDIO_CONVERSION_FAILED: The audio conversion (AAC to AMR-NB or MP3) failed
 * @return  M4MCS_ERR_INVALID_AAC_SAMPLING_FREQUENCY: The input file contains an AAC audio track
 *                                 with an invalid sampling frequency (should never happen)
 ******************************************************************************
 */
M4OSA_ERR M4MCS_step( M4MCS_Context pContext, M4OSA_UInt8 *pProgress )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);

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

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

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Call the still picture MCS functions*/
        return M4MCS_stillPicStep(pC, pProgress);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Check state automaton */

    switch( pC->State )
    {
        case M4MCS_kState_READY:
            *pProgress = 0;
            return M4MCS_intStepSet(pC);
            break;

        case M4MCS_kState_BEGINVIDEOJUMP:
            *pProgress = pC->uiProgress;
            return M4MCS_intStepBeginVideoJump(pC);
            break;

        case M4MCS_kState_BEGINVIDEODECODE:
            *pProgress = pC->uiProgress;
            return M4MCS_intStepBeginVideoDecode(pC);
            break;

        case M4MCS_kState_PROCESSING:
            {
                M4OSA_ERR err = M4NO_ERROR;
                err = M4MCS_intStepEncoding(pC, pProgress);
                /* Save progress info in case of pause */
                pC->uiProgress = *pProgress;
                return err;
            }
            break;

        default: /**< State error */
            M4OSA_TRACE1_1(
                "M4MCS_step(): Wrong State (%d), returning M4ERR_STATE",
                pC->State);
            return M4ERR_STATE;
    }
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_pause(M4MCS_Context pContext);
 * @brief   Pause the transcoding i.e. release the (external hardware) video decoder.
 * @note    This function is not needed if no hardware accelerators are used.
 *          In that case, pausing the MCS is simply achieved by temporarily suspending
 *          the M4MCS_step function calls.
 * @param   pContext            (IN) MCS context
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    pContext is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 ******************************************************************************
 */
M4OSA_ERR M4MCS_pause( M4MCS_Context pContext )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);
    M4OSA_ERR err;

    M4OSA_TRACE2_1("M4MCS_pause called with pContext=0x%x", pContext);

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

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Call the corresponding still picture MCS function*/
        return M4MCS_stillPicPause(pC);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Check state automaton */

    switch( pC->State )
    {
        case M4MCS_kState_BEGINVIDEOJUMP: /**< the video decoder has been created,
                                            we must destroy it */
        case M4MCS_kState_BEGINVIDEODECODE: /**< the video is being used, we must destroy it */
        case M4MCS_kState_PROCESSING: /**< the video is being used, we must destroy it */
                    /**< OK, nothing to do here */
            break;

        default: /**< State error */
            M4OSA_TRACE1_1(
                "M4MCS_pause(): Wrong State (%d), returning M4ERR_STATE",
                pC->State);
            return M4ERR_STATE;
    }

    /**
    * Set the CTS at which we will resume the decoding */
    if( pC->dViDecCurrentCts > pC->dViDecStartingCts )
    {
        /**
        * We passed the starting CTS, so the resume target is the current CTS */
        pC->dViDecStartingCts = pC->dViDecCurrentCts;
    }
    else {
        /**
        * We haven't passed the starting CTS yet, so the resume target is still the starting CTS
        * --> nothing to do in the else block */
    }

    /**
    * Free video decoder stuff */
    if( M4OSA_NULL != pC->pViDecCtxt )
    {
        err = pC->m_pVideoDecoder->m_pFctDestroy(pC->pViDecCtxt);
        pC->pViDecCtxt = M4OSA_NULL;

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_pause: m_pVideoDecoder->pFctDestroy returns 0x%x", err);
            return err;
        }
    }

    /**
    * State transition */
    pC->State = M4MCS_kState_PAUSED;

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

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_resume(M4MCS_Context pContext);
 * @brief   Resume the transcoding after a pause (see M4MCS_pause).
 * @note    This function is not needed if no hardware accelerators are used.
 *          In that case, resuming the MCS is simply achieved by calling
 *          the M4MCS_step function.
 * @param   pContext            (IN) MCS context
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    pContext is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 ******************************************************************************
 */
M4OSA_ERR M4MCS_resume( M4MCS_Context pContext )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);
    M4OSA_ERR err;

    M4OSA_TRACE2_1("M4MCS_resume called with pContext=0x%x", pContext);

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

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Call the corresponding still picture MCS function*/
        return M4MCS_stillPicResume(pC);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Check state automaton */

    switch( pC->State )
    {
        case M4MCS_kState_PAUSED: /**< OK, nothing to do here */
            break;

        default:                  /**< State error */
            M4OSA_TRACE1_1(
                "M4MCS_resume(): Wrong State (%d), returning M4ERR_STATE",
                pC->State);
            return M4ERR_STATE;
            break;
    }

    /**
    * Prepare the video decoder */
    err = M4MCS_intPrepareVideoDecoder(pC);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_resume(): M4MCS_intPrepareVideoDecoder() returns 0x%x", err);
        return err;
    }

    /**
    * State transition */
    if( 0.0 == pC->dViDecStartingCts )
    {
        /**
        * We are still at the beginning of the decoded stream, no need to jump, we can proceed */
        pC->State = M4MCS_kState_PROCESSING;
    }
    else
    {
        /**
        * Jumping */
        pC->State = M4MCS_kState_BEGINVIDEOJUMP;
    }

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

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

    M4OSA_ERR err = M4NO_ERROR, err2;

    M4OSA_TRACE2_1("M4MCS_close called with pContext=0x%x", pContext);

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

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Indicate that current file is no longer a still picture*/
        pC->m_bIsStillPicture = M4OSA_FALSE;

        /**
        * Call the corresponding still picture MCS function*/
        return M4MCS_stillPicClose(pC);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Check state automaton */

    if( M4MCS_kState_FINISHED != pC->State )
    {
        M4OSA_TRACE1_1("M4MCS_close(): Wrong State (%d), returning M4ERR_STATE",
            pC->State);
        return M4ERR_STATE;
    }

    /* Close the encoder before the writer to be certain all the AUs have been written and we can
    get the DSI. */

    /* Has the encoder actually been started? Don't stop it if that's not the case. */
    if( M4MCS_kEncoderRunning == pC->encoderState )
    {
        if( pC->pVideoEncoderGlobalFcts->pFctStop != M4OSA_NULL )
        {
            err = pC->pVideoEncoderGlobalFcts->pFctStop(pC->pViEncCtxt);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_close: pVideoEncoderGlobalFcts->pFctStop returns 0x%x",
                    err);
                /* Well... how the heck do you handle a failed cleanup? */
            }
        }

        pC->encoderState = M4MCS_kEncoderStopped;
    }

    /* Has the encoder actually been opened? Don't close it if that's not the case. */
    if( M4MCS_kEncoderStopped == pC->encoderState )
    {
        err = pC->pVideoEncoderGlobalFcts->pFctClose(pC->pViEncCtxt);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_close: pVideoEncoderGlobalFcts->pFctClose returns 0x%x",
                err);
            /* Well... how the heck do you handle a failed cleanup? */
        }

        pC->encoderState = M4MCS_kEncoderClosed;
    }

    /**********************************/
    /******** Close the writer ********/
    /**********************************/
    if( M4OSA_NULL != pC->pWriterContext ) /* happens in state _SET */
    {
        /* HW encoder: fetch the DSI from the shell video encoder, and feed it to the writer before
        closing it. */

        if( pC->novideo != M4OSA_TRUE )
        {
            if( ( M4ENCODER_kMPEG4 == pC->EncodingVideoFormat)
                || (M4ENCODER_kH264 == pC->EncodingVideoFormat) )
            {
                err = pC->pVideoEncoderGlobalFcts->pFctGetOption(pC->pViEncCtxt,
                    M4ENCODER_kOptionID_EncoderHeader,
                    (M4OSA_DataOption) &encHeader);

                if( ( M4NO_ERROR != err) || (M4OSA_NULL == encHeader->pBuf) )
                {
                    M4OSA_TRACE1_1(
                        "M4MCS_close: failed to get the encoder header (err 0x%x)",
                        err);
                    /**< no return here, we still have stuff to deallocate after close, even
                     if it fails. */
                }
                else
                {
                    /* set this header in the writer */
                    streamHeader.streamID = M4MCS_WRITER_VIDEO_STREAM_ID;
                    streamHeader.size = encHeader->Size;
                    streamHeader.addr = (M4OSA_MemAddr32)encHeader->pBuf;
                }

                M4OSA_TRACE1_0("calling set option");
                err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
                    M4WRITER_kDSI, &streamHeader);
                M4OSA_TRACE1_0("set option done");

                if( M4NO_ERROR != err )
                {
                    M4OSA_TRACE1_1(
                        "M4MCS_close: failed to set the DSI in the writer (err 0x%x)",
                        err);
                }
            }

            if( ( M4OSA_TRUE == pC->bH264Trim)
                && (M4ENCODER_kNULL == pC->EncodingVideoFormat) )
            {
                if(pC->uiBeginCutTime == 0)
                {
                    M4OSA_TRACE1_1("Decoder specific info size = %d",
                        pC->m_pInstance->m_decoderSpecificInfoSize);
                    pC->m_pInstance->m_pFinalDSISize =
                        pC->m_pInstance->m_decoderSpecificInfoSize;
                    M4OSA_TRACE1_1("Decoder specific info pointer = %d",
                        (M4OSA_MemAddr8)pC->m_pInstance->m_pDecoderSpecificInfo);

                    pC->m_pInstance->m_pFinalDSI =
                        (M4OSA_UInt8 *)M4OSA_32bitAlignedMalloc(pC->m_pInstance-> \
                        m_decoderSpecificInfoSize, M4MCS,
                        (M4OSA_Char *)"instance->m_pFinalDSI");

                    if( pC->m_pInstance->m_pFinalDSI == M4OSA_NULL )
                    {
                        M4OSA_TRACE1_0("instance->m_pFinalDSI: allocation error");
                        return M4ERR_ALLOC;
                    }
                    memcpy((void *)pC->m_pInstance->m_pFinalDSI,
                        (void *)pC-> \
                        m_pInstance->m_pDecoderSpecificInfo,
                        pC->m_pInstance->m_decoderSpecificInfoSize);
                }
                streamHeader.streamID = M4MCS_WRITER_VIDEO_STREAM_ID;
                streamHeader.size = pC->m_pInstance->m_pFinalDSISize;
                streamHeader.addr =
                    (M4OSA_MemAddr32)pC->m_pInstance->m_pFinalDSI;
                M4OSA_TRACE1_0("calling set option");
                err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
                    M4WRITER_kDSI, &streamHeader);
                M4OSA_TRACE1_0("set option done");

                if( M4NO_ERROR != err )
                {
                    M4OSA_TRACE1_1(
                        "M4MCS_close: failed to set the DSI in the writer (err 0x%x)",
                        err);
                }
            }
        }
        /* Write and close the 3GP output file */
        err2 = pC->pWriterGlobalFcts->pFctCloseWrite(pC->pWriterContext);
        pC->pWriterContext = M4OSA_NULL;

        if( M4NO_ERROR != err2 )
        {
            M4OSA_TRACE1_1(
                "M4MCS_close: pWriterGlobalFcts->pFctCloseWrite returns 0x%x",
                err2);

            if( M4NO_ERROR == err )
                err = err2;
            /**< no return here, we still have stuff to deallocate after close, even if it fails.*/
        }
    }

    /* Close output PCM file if needed */
    if( pC->pOutputPCMfile != M4OSA_NULL )
    {
        pC->pOsaFileWritPtr->closeWrite(pC->pOutputPCMfile);
        pC->pOutputPCMfile = M4OSA_NULL;
    }

    /*FlB 2009.03.04: add audio effects,
    free effects list*/
    if( M4OSA_NULL != pC->pEffects )
    {
        free(pC->pEffects);
        pC->pEffects = M4OSA_NULL;
    }
    pC->nbEffects = 0;
    pC->pActiveEffectNumber = -1;

    /**
    * State transition */
    pC->State = M4MCS_kState_CLOSED;

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

    M4OSA_TRACE3_0("M4MCS_close(): returning M4NO_ERROR");
    return err;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_cleanUp(M4MCS_Context pContext);
 * @brief    Free all resources used by the MCS.
 * @note The context is no more valid after this call
 * @param    pContext            (IN) MCS context
 * @return   M4NO_ERROR:         No error
 * @return   M4ERR_PARAMETER:    pContext is M4OSA_NULL (If Debug Level >= 2)
 * @return   M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 ******************************************************************************
 */
M4OSA_ERR M4MCS_cleanUp( M4MCS_Context pContext )
{
    M4OSA_ERR err = M4NO_ERROR;
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);

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

#ifdef MCS_DUMP_PCM_TO_FILE

    if( file_au_reader )
    {
        fclose(file_au_reader);
        file_au_reader = NULL;
    }

    if( file_pcm_decoder )
    {
        fclose(file_pcm_decoder);
        file_pcm_decoder = NULL;
    }

    if( file_pcm_encoder )
    {
        fclose(file_pcm_encoder);
        file_pcm_encoder = NULL;
    }

#endif

    /**
    * Check input parameter */

    if( M4OSA_NULL == pContext )
    {
        M4OSA_TRACE1_0(
            "M4MCS_cleanUp: pContext is M4OSA_NULL, returning M4ERR_PARAMETER");
        return M4ERR_PARAMETER;
    }

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

    if( M4OSA_NULL != pC->m_pInstance )
    {
        err = H264MCS_Freeinstance(pC->m_pInstance);
        pC->m_pInstance = M4OSA_NULL;
    }

    /* ----- Free video encoder stuff, if needed ----- */

    if( ( M4OSA_NULL != pC->pViEncCtxt)
        && (M4OSA_NULL != pC->pVideoEncoderGlobalFcts) )
    {
        err = pC->pVideoEncoderGlobalFcts->pFctCleanup(pC->pViEncCtxt);
        pC->pViEncCtxt = M4OSA_NULL;

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_cleanUp: pVideoEncoderGlobalFcts->pFctCleanup returns 0x%x",
                err);
            /**< don't return, we still have stuff to free */
        }

        pC->encoderState = M4MCS_kNoEncoder;
    }

    /**
    * In the H263 case, we allocated our own DSI buffer */
    if( ( M4ENCODER_kH263 == pC->EncodingVideoFormat)
        && (M4OSA_NULL != pC->WriterVideoStreamInfo.Header.pBuf) )
    {
        free(pC->WriterVideoStreamInfo.Header.pBuf);
        pC->WriterVideoStreamInfo.Header.pBuf = M4OSA_NULL;
    }

    if( M4OSA_NULL != pC->pPreResizeFrame )
    {
        if( M4OSA_NULL != pC->pPreResizeFrame[0].pac_data )
        {
            free(pC->pPreResizeFrame[0].pac_data);
            pC->pPreResizeFrame[0].pac_data = M4OSA_NULL;
        }

        if( M4OSA_NULL != pC->pPreResizeFrame[1].pac_data )
        {
            free(pC->pPreResizeFrame[1].pac_data);
            pC->pPreResizeFrame[1].pac_data = M4OSA_NULL;
        }

        if( M4OSA_NULL != pC->pPreResizeFrame[2].pac_data )
        {
            free(pC->pPreResizeFrame[2].pac_data);
            pC->pPreResizeFrame[2].pac_data = M4OSA_NULL;
        }
        free(pC->pPreResizeFrame);
        pC->pPreResizeFrame = M4OSA_NULL;
    }

    /* ----- Free the ssrc stuff ----- */

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

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

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

    if (pC->pLVAudioResampler != M4OSA_NULL)
    {
        LVDestroy(pC->pLVAudioResampler);
        pC->pLVAudioResampler = M4OSA_NULL;
    }

    /* ----- Free the audio encoder stuff ----- */

    if( M4OSA_NULL != pC->pAudioEncCtxt )
    {
        err = pC->pAudioEncoderGlobalFcts->pFctClose(pC->pAudioEncCtxt);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_cleanUp: pAudioEncoderGlobalFcts->pFctClose returns 0x%x",
                err);
            /**< don't return, we still have stuff to free */
        }

        err = pC->pAudioEncoderGlobalFcts->pFctCleanUp(pC->pAudioEncCtxt);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_cleanUp: pAudioEncoderGlobalFcts->pFctCleanUp returns 0x%x",
                err);
            /**< don't return, we still have stuff to free */
        }

        pC->pAudioEncCtxt = M4OSA_NULL;
    }

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

    /* ----- Free all other stuff ----- */

    /**
    * Free the readers and the decoders */
    M4MCS_intCleanUp_ReadersDecoders(pC);

#ifdef M4MCS_SUPPORT_STILL_PICTURE
    /**
    * Free the still picture resources */

    M4MCS_stillPicCleanUp(pC);

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Free the shells interfaces */

    M4MCS_unRegisterAllWriters(pContext);
    M4MCS_unRegisterAllEncoders(pContext);
    M4MCS_unRegisterAllReaders(pContext);
    M4MCS_unRegisterAllDecoders(pContext);

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

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

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_abort(M4MCS_Context pContext);
 * @brief    Finish the MCS transcoding and free all resources used by the MCS
 *          whatever the state is.
 * @note    The context is no more valid after this call
 * @param    pContext            (IN) MCS context
 * @return    M4NO_ERROR:            No error
 * @return    M4ERR_PARAMETER:    pContext is M4OSA_NULL (debug only)
 ******************************************************************************
 */
M4OSA_ERR M4MCS_abort( M4MCS_Context pContext )
{
    M4OSA_ERR err = M4NO_ERROR;
    M4OSA_ERR err1 = M4NO_ERROR;
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);

    if( M4OSA_NULL == pContext )
    {
        return M4NO_ERROR;
    }

    if( ( pC->State == M4MCS_kState_CREATED)
        || (pC->State == M4MCS_kState_CLOSED) )
    {
        pC->State = M4MCS_kState_CLOSED;

        err = M4MCS_cleanUp(pContext);

        if( err != M4NO_ERROR )
        {
            M4OSA_TRACE1_1("M4MCS_abort : M4MCS_cleanUp fails err = 0x%x", err);
        }
    }
    else
    {
#ifdef M4MCS_SUPPORT_STILL_PICTURE

        if( pC->m_bIsStillPicture )
        {
            /**
            * Cancel the ongoing processes if any*/
            err = M4MCS_stillPicCancel(pC);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_abort : M4MCS_stillPicCancel fails err = 0x%x", err);
            }
            /*Still picture process is now stopped; Carry on with close and cleanup*/
        }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

        pC->State = M4MCS_kState_FINISHED;

        err = M4MCS_close(pContext);

        if( err != M4NO_ERROR )
        {
            M4OSA_TRACE1_1("M4MCS_abort : M4MCS_close fails err = 0x%x", err);
            err1 = err;
        }

        err = M4MCS_cleanUp(pContext);

        if( err != M4NO_ERROR )
        {
            M4OSA_TRACE1_1("M4MCS_abort : M4MCS_cleanUp fails err = 0x%x", err);
        }
    }
    err = (err1 == M4NO_ERROR) ? err : err1;
    return err;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_getInputFileProperties(M4MCS_Context pContext,
 *                                         M4VIDEOEDITING_ClipProperties* pFileProperties);
 * @brief   Retrieves the properties of the audio and video streams from the input file.
 * @param   pContext            (IN) MCS context
 * @param   pProperties         (OUT) Pointer on an allocated M4VIDEOEDITING_ClipProperties
structure which is filled with the input stream properties.
 * @note    The structure pProperties must be allocated and further de-allocated
by the application. The function must be called in the opened state.
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 ******************************************************************************
 */
M4OSA_ERR M4MCS_getInputFileProperties( M4MCS_Context pContext,
                                       M4VIDEOEDITING_ClipProperties *pFileProperties )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);

    M4OSA_TRACE2_2("M4MCS_getInputFileProperties called with pContext=0x%x, \
                   pFileProperties=0x%x", pContext, pFileProperties);

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

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Call the corresponding still picture MCS function*/
        return M4MCS_stillPicGetInputFileProperties(pC, pFileProperties);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Check state automaton */

    if( M4MCS_kState_OPENED != pC->State )
    {
        M4OSA_TRACE1_1(
            "M4MCS_getInputFileProperties(): Wrong State (%d), returning M4ERR_STATE",
            pC->State);
        return M4ERR_STATE;
    }

    /**
    * Copy previously computed properties into given structure */
    memcpy((void *)pFileProperties,
        (void *) &pC->InputFileProperties,
        sizeof(M4VIDEOEDITING_ClipProperties));

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_setOutputParams(M4MCS_Context pContext, M4MCS_OutputParams* pParams);
 * @brief   Set the MCS video output parameters.
 * @note    Must be called after M4MCS_open. Must be called before M4MCS_step.
 * @param   pContext            (IN) MCS context
 * @param   pParams             (IN/OUT) Transcoding parameters
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 * @return  M4MCS_ERR_INVALID_VIDEO_FRAME_SIZE_FOR_H263 : Output video frame size parameter is
 *                                                        incompatible with H263 encoding
 * @return  M4MCS_ERR_INVALID_VIDEO_FRAME_RATE_FOR_H263 : Output video frame size parameter is
 *                                                        incompatible with H263 encoding
 * @return  M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FORMAT     : Undefined output video format parameter
 * @return  M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE : Undefined output video frame size
 * @return  M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_RATE : Undefined output video frame rate
 * @return  M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT : Undefined output audio format parameter
 * @return  M4MCS_ERR_DURATION_IS_NULL : Specified output parameters define a null duration stream
 *                                         (no audio and video)
 ******************************************************************************
 */
M4OSA_ERR M4MCS_setOutputParams( M4MCS_Context pContext,
                                M4MCS_OutputParams *pParams )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);
    M4OSA_UInt32 uiFrameWidth;
    M4OSA_UInt32 uiFrameHeight;
    M4OSA_ERR err;

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

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

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Call the corresponding still picture MCS function*/
        return M4MCS_stillPicSetOutputParams(pC, pParams);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Check state automaton */

    if( M4MCS_kState_OPENED != pC->State )
    {
        M4OSA_TRACE1_1(
            "M4MCS_setOutputParams(): Wrong State (%d), returning M4ERR_STATE",
            pC->State);
        return M4ERR_STATE;
    }

    /* Ignore audio or video stream if the output do not need it, */
    /* or if the input file does not have any audio or video stream */
    /*FlB 26.02.2009: add mp3 as mcs output format*/
    if( ( pParams->OutputVideoFormat == M4VIDEOEDITING_kNoneVideo)
        || (pC->VideoState == M4MCS_kStreamState_NOSTREAM)
        || (pParams->OutputFileType == M4VIDEOEDITING_kFileType_AMR)
        || (pParams->OutputFileType == M4VIDEOEDITING_kFileType_MP3) )
    {
        pC->novideo = M4OSA_TRUE;
    }

    if( ( pParams->OutputAudioFormat == M4VIDEOEDITING_kNoneAudio)
        || (pC->AudioState == M4MCS_kStreamState_NOSTREAM) )
    {
        pC->noaudio = M4OSA_TRUE;
    }

    if( pC->noaudio && pC->novideo )
    {
        M4OSA_TRACE1_0(
            "!!! M4MCS_setOutputParams : clip is NULL, there is no audio, no video");
        return M4MCS_ERR_DURATION_IS_NULL;
    }

    /* Set writer */
    err = M4MCS_setCurrentWriter(pContext, pParams->OutputFileType);
    M4ERR_CHECK_RETURN(err);

    /* Set video parameters */
    if( pC->novideo == M4OSA_FALSE )
    {
        /**
        * Check Video Format correctness */

        switch( pParams->OutputVideoFormat )
        {
            case M4VIDEOEDITING_kH263:
                if( pParams->OutputFileType == M4VIDEOEDITING_kFileType_MP4 )
                    return M4MCS_ERR_H263_FORBIDDEN_IN_MP4_FILE;

                pC->EncodingVideoFormat = M4ENCODER_kH263;
                err = M4MCS_setCurrentVideoEncoder(pContext,
                    pParams->OutputVideoFormat);
                M4ERR_CHECK_RETURN(err);
                break;

            case M4VIDEOEDITING_kMPEG4_EMP:
                pC->bActivateEmp = M4OSA_TRUE;

            case M4VIDEOEDITING_kMPEG4:

                pC->EncodingVideoFormat = M4ENCODER_kMPEG4;
                err = M4MCS_setCurrentVideoEncoder(pContext,
                    pParams->OutputVideoFormat);
                M4ERR_CHECK_RETURN(err);
                break;

            case M4VIDEOEDITING_kH264:

                pC->EncodingVideoFormat = M4ENCODER_kH264;
                err = M4MCS_setCurrentVideoEncoder(pContext,
                    pParams->OutputVideoFormat);
                M4ERR_CHECK_RETURN(err);
                break;

            case M4VIDEOEDITING_kNullVideo:
                if( ( pParams->OutputFileType == M4VIDEOEDITING_kFileType_MP4)
                    && (pC->InputFileProperties.VideoStreamType
                    == M4VIDEOEDITING_kH263) )
                    return M4MCS_ERR_H263_FORBIDDEN_IN_MP4_FILE;


                /* If input file is EMP, output file will be too */

                if( pC->InputFileProperties.VideoStreamType
                    == M4VIDEOEDITING_kMPEG4_EMP )
                    pC->bActivateEmp = M4OSA_TRUE;

                /* Encoder needed for begin cut to generate an I-frame */
                pC->EncodingVideoFormat = M4ENCODER_kNULL;
                err = M4MCS_setCurrentVideoEncoder(pContext,
                    pC->InputFileProperties.VideoStreamType);
                M4ERR_CHECK_RETURN(err);
                break;

            default:
                M4OSA_TRACE1_1("M4MCS_setOutputParams: Undefined output video format (%d),\
                               returning M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FORMAT",
                               pParams->OutputVideoFormat);
                return M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FORMAT;
        }

        /**
        * Check Video frame size correctness */
        if( M4VIDEOEDITING_kNullVideo == pParams->OutputVideoFormat )
        {
            uiFrameWidth =
                pC->EncodingWidth = pC->InputFileProperties.uiVideoWidth;
            uiFrameHeight =
                pC->EncodingHeight = pC->InputFileProperties.uiVideoHeight;
        }
        else
        {
            switch( pParams->OutputVideoFrameSize )
            {
                case M4VIDEOEDITING_kSQCIF:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_SQCIF_Width;
                    uiFrameHeight = pC->EncodingHeight = M4ENCODER_SQCIF_Height;
                    break;

                case M4VIDEOEDITING_kQQVGA:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_QQVGA_Width;
                    uiFrameHeight = pC->EncodingHeight = M4ENCODER_QQVGA_Height;
                    break;

                case M4VIDEOEDITING_kQCIF:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_QCIF_Width;
                    uiFrameHeight = pC->EncodingHeight = M4ENCODER_QCIF_Height;
                    break;

                case M4VIDEOEDITING_kQVGA:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_QVGA_Width;
                    uiFrameHeight = pC->EncodingHeight = M4ENCODER_QVGA_Height;
                    break;

                case M4VIDEOEDITING_kCIF:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_CIF_Width;
                    uiFrameHeight = pC->EncodingHeight = M4ENCODER_CIF_Height;
                    break;

                case M4VIDEOEDITING_kVGA:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_VGA_Width;
                    uiFrameHeight = pC->EncodingHeight = M4ENCODER_VGA_Height;
                    break;
                    /* +PR LV5807 */
                case M4VIDEOEDITING_kWVGA:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_WVGA_Width;
                    uiFrameHeight = pC->EncodingHeight = M4ENCODER_WVGA_Height;
                    break;

                case M4VIDEOEDITING_kNTSC:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_NTSC_Width;
                    uiFrameHeight = pC->EncodingHeight = M4ENCODER_NTSC_Height;
                    break;
                    /* -PR LV5807*/
                    /* +CR Google */
                case M4VIDEOEDITING_k640_360:
                    uiFrameWidth = pC->EncodingWidth = M4ENCODER_640_360_Width;
                    uiFrameHeight =
                        pC->EncodingHeight = M4ENCODER_640_360_Height;
                    break;

                case M4VIDEOEDITING_k854_480:
                    uiFrameWidth =
                        pC->EncodingWidth = M4ENCODER_854_480_Width;
                    uiFrameHeight =
                        pC->EncodingHeight = M4ENCODER_854_480_Height;
                    break;

                case M4VIDEOEDITING_k1280_720:
                    uiFrameWidth =
                        pC->EncodingWidth = M4ENCODER_1280_720_Width;
                    uiFrameHeight =
                        pC->EncodingHeight = M4ENCODER_1280_720_Height;
                    break;

                case M4VIDEOEDITING_k1080_720:
                    uiFrameWidth =
                        pC->EncodingWidth = M4ENCODER_1080_720_Width;
                    uiFrameHeight =
                        pC->EncodingHeight = M4ENCODER_1080_720_Height;
                    break;

                case M4VIDEOEDITING_k960_720:
                    uiFrameWidth =
                        pC->EncodingWidth = M4ENCODER_960_720_Width;
                    uiFrameHeight =
                        pC->EncodingHeight = M4ENCODER_960_720_Height;
                    break;

                case M4VIDEOEDITING_k1920_1080:
                    uiFrameWidth =
                        pC->EncodingWidth = M4ENCODER_1920_1080_Width;
                    uiFrameHeight =
                        pC->EncodingHeight = M4ENCODER_1920_1080_Height;
                    break;
                    /* -CR Google */
                default:
                    M4OSA_TRACE1_1(
                        "M4MCS_setOutputParams: Undefined output video frame size \
                        (%d), returning M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE",
                        pParams->OutputVideoFrameSize);
                    return M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE;
            }
        }

        /**
        * Compute video max au size and max chunck size.
        * We do it here because it depends on the frame size only, and
        * because we need it for the file size/video bitrate estimations */
        pC->uiVideoMaxAuSize =
            (M4OSA_UInt32)(1.5F *(M4OSA_Float)(uiFrameWidth * uiFrameHeight) \
            *M4MCS_VIDEO_MIN_COMPRESSION_RATIO);
        pC->uiVideoMaxChunckSize = (M4OSA_UInt32)(pC->uiVideoMaxAuSize       \
            *
            M4MCS_VIDEO_CHUNK_AU_SIZE_RATIO); /**< from max AU size to max Chunck size */

        if( 0 == pC->uiVideoMaxAuSize )
        {
            /* Size may be zero in case of null encoding with unrecognized stream */
            M4OSA_TRACE1_0("M4MCS_setOutputParams: video frame size is 0 returning\
                           M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE");
            return M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_SIZE;
        }


        /**
        * Size check for H263 (only valid sizes are CIF, QCIF and SQCIF) */

        if( M4VIDEOEDITING_kH263 == pParams->OutputVideoFormat )
        {
            switch( pParams->OutputVideoFrameSize )
            {
                case M4VIDEOEDITING_kSQCIF:
                case M4VIDEOEDITING_kQCIF:
                case M4VIDEOEDITING_kCIF:
                    /* OK */
                    break;

                default:
                    M4OSA_TRACE1_0(
                        "M4MCS_setOutputParams():\
                        returning M4MCS_ERR_INVALID_VIDEO_FRAME_SIZE_FOR_H263");
                    return M4MCS_ERR_INVALID_VIDEO_FRAME_SIZE_FOR_H263;
            }
        }

        /**
        * Check Video Frame rate correctness */
        if( M4VIDEOEDITING_kNullVideo != pParams->OutputVideoFormat )
        {
            switch( pParams->OutputVideoFrameRate )
            {
                case M4VIDEOEDITING_k5_FPS:
                    pC->EncodingVideoFramerate = M4ENCODER_k5_FPS;
                    break;

                case M4VIDEOEDITING_k7_5_FPS:
                    pC->EncodingVideoFramerate = M4ENCODER_k7_5_FPS;
                    break;

                case M4VIDEOEDITING_k10_FPS:
                    pC->EncodingVideoFramerate = M4ENCODER_k10_FPS;
                    break;

                case M4VIDEOEDITING_k12_5_FPS:
                    pC->EncodingVideoFramerate = M4ENCODER_k12_5_FPS;
                    break;

                case M4VIDEOEDITING_k15_FPS:
                    pC->EncodingVideoFramerate = M4ENCODER_k15_FPS;
                    break;

                case M4VIDEOEDITING_k20_FPS:
                    pC->EncodingVideoFramerate = M4ENCODER_k20_FPS;
                    break;

                case M4VIDEOEDITING_k25_FPS:
                    pC->EncodingVideoFramerate = M4ENCODER_k25_FPS;
                    break;

                case M4VIDEOEDITING_k30_FPS:
                    pC->EncodingVideoFramerate = M4ENCODER_k30_FPS;
                    break;

                default:
                    M4OSA_TRACE1_1(
                        "M4MCS_setOutputParams: Undefined output video frame rate\
                        (%d), returning M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_RATE",
                        pParams->OutputVideoFrameRate);
                    return M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_RATE;
            }
        }

        /**
        * Frame rate check for H263 (only dividers of 30 fps (29.97 actually)) */
        if( M4VIDEOEDITING_kH263 == pParams->OutputVideoFormat )
        {
            switch( pC->EncodingVideoFramerate )
            {
                case M4ENCODER_k5_FPS:
                case M4ENCODER_k7_5_FPS:
                case M4ENCODER_k10_FPS:
                case M4ENCODER_k15_FPS:
                case M4ENCODER_k30_FPS:
                    /* OK */
                    break;

                default:
                    M4OSA_TRACE1_0(
                        "M4MCS_setOutputParams():\
                        returning M4MCS_ERR_INVALID_VIDEO_FRAME_RATE_FOR_H263");
                    return M4MCS_ERR_INVALID_VIDEO_FRAME_RATE_FOR_H263;
            }
        }
    }

    /* Set audio parameters */
    if( pC->noaudio == M4OSA_FALSE )
    {
        /**
        * Check Audio Format correctness */
        switch( pParams->OutputAudioFormat )
        {
            case M4VIDEOEDITING_kAMR_NB:

                err = M4MCS_setCurrentAudioEncoder(pContext,
                    pParams->OutputAudioFormat);
                M4ERR_CHECK_RETURN(err);

                pC->AudioEncParams.Format = M4ENCODER_kAMRNB;
                pC->AudioEncParams.Frequency = M4ENCODER_k8000Hz;
                pC->AudioEncParams.ChannelNum = M4ENCODER_kMono;
                pC->AudioEncParams.SpecifParam.AmrSID = M4ENCODER_kAmrNoSID;
                break;

            case M4VIDEOEDITING_kAAC:

                err = M4MCS_setCurrentAudioEncoder(pContext,
                    pParams->OutputAudioFormat);
                M4ERR_CHECK_RETURN(err);

                pC->AudioEncParams.Format = M4ENCODER_kAAC;
                pC->AudioEncParams.Frequency = M4ENCODER_k16000Hz;

                switch( pParams->OutputAudioSamplingFrequency )
                {
                    case M4VIDEOEDITING_k8000_ASF:
                        pC->AudioEncParams.Frequency = M4ENCODER_k8000Hz;
                        break;

                    case M4VIDEOEDITING_k16000_ASF:
                        pC->AudioEncParams.Frequency = M4ENCODER_k16000Hz;
                        break;

                    case M4VIDEOEDITING_k22050_ASF:
                        pC->AudioEncParams.Frequency = M4ENCODER_k22050Hz;
                        break;

                    case M4VIDEOEDITING_k24000_ASF:
                        pC->AudioEncParams.Frequency = M4ENCODER_k24000Hz;
                        break;

                    case M4VIDEOEDITING_k32000_ASF:
                        pC->AudioEncParams.Frequency = M4ENCODER_k32000Hz;
                        break;

                    case M4VIDEOEDITING_k44100_ASF:
                        pC->AudioEncParams.Frequency = M4ENCODER_k44100Hz;
                        break;

                    case M4VIDEOEDITING_k48000_ASF:
                        pC->AudioEncParams.Frequency = M4ENCODER_k48000Hz;
                        break;

                    case M4VIDEOEDITING_k11025_ASF:
                    case M4VIDEOEDITING_k12000_ASF:
                    case M4VIDEOEDITING_kDefault_ASF:
                        break;
                }
                    pC->AudioEncParams.ChannelNum =
                        (pParams->bAudioMono == M4OSA_TRUE) ? \
                        M4ENCODER_kMono : M4ENCODER_kStereo;
                    pC->AudioEncParams.SpecifParam.AacParam.Regulation =
                        M4ENCODER_kAacRegulNone; //M4ENCODER_kAacBitReservoir
                    /* unused */
                    pC->AudioEncParams.SpecifParam.AacParam.bIS = M4OSA_FALSE;
                    pC->AudioEncParams.SpecifParam.AacParam.bMS = M4OSA_FALSE;
                    pC->AudioEncParams.SpecifParam.AacParam.bPNS = M4OSA_FALSE;
                    pC->AudioEncParams.SpecifParam.AacParam.bTNS = M4OSA_FALSE;
                    /* TODO change into highspeed asap */
                    pC->AudioEncParams.SpecifParam.AacParam.bHighSpeed =
                        M4OSA_FALSE;
                    break;

                    /*FlB 26.02.2009: add mp3 as mcs output format, add mp3 encoder*/
                case M4VIDEOEDITING_kMP3:
                    err = M4MCS_setCurrentAudioEncoder(pContext,
                        pParams->OutputAudioFormat);
                    M4ERR_CHECK_RETURN(err);

                    pC->AudioEncParams.Format = M4ENCODER_kMP3;
                    pC->AudioEncParams.ChannelNum =
                        (pParams->bAudioMono == M4OSA_TRUE) ? \
                        M4ENCODER_kMono : M4ENCODER_kStereo;

                    pC->AudioEncParams.Frequency = M4ENCODER_k16000Hz;

                    switch( pParams->OutputAudioSamplingFrequency )
                    {
                        case M4VIDEOEDITING_k8000_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k8000Hz;
                            break;

                        case M4VIDEOEDITING_k11025_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k11025Hz;
                            break;

                        case M4VIDEOEDITING_k12000_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k12000Hz;
                            break;

                        case M4VIDEOEDITING_k16000_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k16000Hz;
                            break;

                        case M4VIDEOEDITING_k22050_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k22050Hz;
                            break;

                        case M4VIDEOEDITING_k24000_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k24000Hz;
                            break;

                        case M4VIDEOEDITING_k32000_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k32000Hz;
                            break;

                        case M4VIDEOEDITING_k44100_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k44100Hz;
                            break;

                        case M4VIDEOEDITING_k48000_ASF:
                            pC->AudioEncParams.Frequency = M4ENCODER_k48000Hz;
                            break;

                        case M4VIDEOEDITING_kDefault_ASF:
                            break;
                    }

                    break;

                case M4VIDEOEDITING_kNullAudio:
                    if( pParams->pEffects == M4OSA_NULL || pParams->nbEffects == 0 )
                    {
                        /* no encoder needed */
                        pC->AudioEncParams.Format = M4ENCODER_kAudioNULL;
                        pC->AudioEncParams.Frequency =
                            pC->pReaderAudioStream->m_samplingFrequency;
                        pC->AudioEncParams.ChannelNum =
                            (pC->pReaderAudioStream->m_nbChannels == 1) ? \
                            M4ENCODER_kMono : M4ENCODER_kStereo;
                    }
                    else
                    {
                        pC->AudioEncParams.Frequency =
                            pC->pReaderAudioStream->m_samplingFrequency;
                        pC->AudioEncParams.ChannelNum =
                            (pC->pReaderAudioStream->m_nbChannels == 1) ? \
                            M4ENCODER_kMono : M4ENCODER_kStereo;

                        switch( pC->InputFileProperties.AudioStreamType )
                        {
                            case M4VIDEOEDITING_kAMR_NB:
                                M4OSA_TRACE3_0(
                                    "M4MCS_setOutputParams calling \
                                    M4MCS_setCurrentAudioEncoder M4VIDEOEDITING_kNull, AMR");
                                err = M4MCS_setCurrentAudioEncoder(pContext,
                                    pC->InputFileProperties.AudioStreamType);
                                M4ERR_CHECK_RETURN(err);

                                pC->AudioEncParams.Format = M4ENCODER_kAMRNB;
                                pC->AudioEncParams.Frequency = M4ENCODER_k8000Hz;
                                pC->AudioEncParams.ChannelNum = M4ENCODER_kMono;

                                if( pC->pReaderAudioStream->m_samplingFrequency
                                    != 8000 )
                                {
                                    pC->AudioEncParams.Format = M4ENCODER_kAMRNB;
                                }
                                pC->AudioEncParams.SpecifParam.AmrSID =
                                    M4ENCODER_kAmrNoSID;
                                break;

                            case M4VIDEOEDITING_kAAC:
                                M4OSA_TRACE3_0(
                                    "M4MCS_setOutputParams calling \
                                    M4MCS_setCurrentAudioEncoder M4VIDEOEDITING_kNull, AAC");
                                err = M4MCS_setCurrentAudioEncoder(pContext,
                                    pC->InputFileProperties.AudioStreamType);
                                M4ERR_CHECK_RETURN(err);

                                pC->AudioEncParams.Format = M4ENCODER_kAAC;
                                pC->AudioEncParams.SpecifParam.AacParam.Regulation =
                                    M4ENCODER_kAacRegulNone; //M4ENCODER_kAacBitReservoir
                                pC->AudioEncParams.Frequency = M4ENCODER_k16000Hz;
                                pC->AudioEncParams.Frequency = M4ENCODER_k16000Hz;

                                switch( pC->pReaderAudioStream->
                                    m_samplingFrequency )
                                {
                                case 16000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k16000Hz;
                                    break;

                                case 22050:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k22050Hz;
                                    break;

                                case 24000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k24000Hz;
                                    break;

                                case 32000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k32000Hz;
                                    break;

                                case 44100:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k44100Hz;
                                    break;

                                case 48000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k48000Hz;
                                    break;

                                default:
                                    pC->AudioEncParams.Format = M4ENCODER_kAAC;
                                    break;
                            }
                            /* unused */
                            pC->AudioEncParams.SpecifParam.AacParam.bIS =
                                M4OSA_FALSE;
                            pC->AudioEncParams.SpecifParam.AacParam.bMS =
                                M4OSA_FALSE;
                            pC->AudioEncParams.SpecifParam.AacParam.bPNS =
                                M4OSA_FALSE;
                            pC->AudioEncParams.SpecifParam.AacParam.bTNS =
                                M4OSA_FALSE;
                            /* TODO change into highspeed asap */
                            pC->AudioEncParams.SpecifParam.AacParam.bHighSpeed =
                                M4OSA_FALSE;
                            break;

                        case M4VIDEOEDITING_kMP3:
                            M4OSA_TRACE3_0(
                                "M4MCS_setOutputParams calling\
                                M4MCS_setCurrentAudioEncoder M4VIDEOEDITING_kNull, MP3");
                            err = M4MCS_setCurrentAudioEncoder(pContext,
                                pC->InputFileProperties.AudioStreamType);
                            M4ERR_CHECK_RETURN(err);

                            pC->AudioEncParams.Format = M4ENCODER_kMP3;
                            pC->AudioEncParams.Frequency = M4ENCODER_k16000Hz;

                            switch( pC->pReaderAudioStream->
                                m_samplingFrequency )
                            {
                                case 8000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k8000Hz;
                                    break;

                                case 16000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k16000Hz;
                                    break;

                                case 22050:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k22050Hz;
                                    break;

                                case 24000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k24000Hz;
                                    break;

                                case 32000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k32000Hz;
                                    break;

                                case 44100:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k44100Hz;
                                    break;

                                case 48000:
                                    pC->AudioEncParams.Frequency =
                                        M4ENCODER_k48000Hz;
                                    break;

                                default:
                                    pC->AudioEncParams.Format = M4ENCODER_kMP3;
                                    break;
                            }
                            break;

                        case M4VIDEOEDITING_kEVRC:
                        case M4VIDEOEDITING_kUnsupportedAudio:
                        default:
                            M4OSA_TRACE1_1(
                                "M4MCS_setOutputParams: Output audio format (%d) is\
                                incompatible with audio effects, returning \
                                M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT",
                                pC->InputFileProperties.AudioStreamType);
                            return M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT;
                        }
                    }
                    break;
                    /* EVRC
                    //            case M4VIDEOEDITING_kEVRC:
                    //
                    //                err = M4MCS_setCurrentAudioEncoder(pContext, pParams->\
                    //                    OutputAudioFormat);
                    //                M4ERR_CHECK_RETURN(err);
                    //
                    //                pC->AudioEncParams.Format = M4ENCODER_kEVRC;
                    //                pC->AudioEncParams.Frequency = M4ENCODER_k8000Hz;
                    //                pC->AudioEncParams.ChannelNum = M4ENCODER_kMono;
                    //                break; */

                default:
                    M4OSA_TRACE1_1("M4MCS_setOutputParams: Undefined output audio format (%d),\
                                   returning M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT",
                                   pParams->OutputAudioFormat);
                    return M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT;
        }
    }

    if( pParams->pOutputPCMfile != M4OSA_NULL )
    {
        pC->pOutputPCMfile = pParams->pOutputPCMfile;

        /* Open output PCM file */
        pC->pOsaFileWritPtr->openWrite(&(pC->pOutputPCMfile),
            pParams->pOutputPCMfile, M4OSA_kFileWrite);
    }
    else
    {
        pC->pOutputPCMfile = M4OSA_NULL;
    }

    /*Store media rendering parameter into the internal context*/
    pC->MediaRendering = pParams->MediaRendering;

    /* Add audio effects*/
    /*Copy MCS effects structure into internal context*/
    if( pParams->nbEffects > 0 )
    {
        M4OSA_UInt32 j = 0;
        pC->nbEffects = pParams->nbEffects;
        pC->pEffects = (M4MCS_EffectSettings *)M4OSA_32bitAlignedMalloc(pC->nbEffects \
            *sizeof(M4MCS_EffectSettings), M4MCS,
            (M4OSA_Char *)"Allocation of effects list");

        if( pC->pEffects == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("M4MCS_setOutputParams(): allocation error");
            return M4ERR_ALLOC;
        }

        for ( j = 0; j < pC->nbEffects; j++ )
        {
            /* Copy effect to "local" structure */
            memcpy((void *) &(pC->pEffects[j]),
                (void *) &(pParams->pEffects[j]),
                sizeof(M4MCS_EffectSettings));

            switch( pC->pEffects[j].AudioEffectType )
            {
                case M4MCS_kAudioEffectType_None:
                    M4OSA_TRACE3_1(
                        "M4MCS_setOutputParams(): effect type %i is None", j);
                    pC->pEffects[j].pExtAudioEffectFctCtxt = M4OSA_NULL;
                    pC->pEffects[j].ExtAudioEffectFct = M4OSA_NULL;
                    break;

                case M4MCS_kAudioEffectType_FadeIn:
                    M4OSA_TRACE3_1(
                        "M4MCS_setOutputParams(): effect type %i is FadeIn", j);
                    pC->pEffects[j].pExtAudioEffectFctCtxt = M4OSA_NULL;
                    pC->pEffects[j].ExtAudioEffectFct =
                        M4MCS_editAudioEffectFct_FadeIn;
                    break;

                case M4MCS_kAudioEffectType_FadeOut:
                    M4OSA_TRACE3_1(
                        "M4MCS_setOutputParams(): effect type %i is FadeOut",
                        j);
                    pC->pEffects[j].pExtAudioEffectFctCtxt = M4OSA_NULL;
                    pC->pEffects[j].ExtAudioEffectFct =
                        M4MCS_editAudioEffectFct_FadeOut;
                    break;

                case M4MCS_kAudioEffectType_External:
                    M4OSA_TRACE3_1(
                        "M4MCS_setOutputParams(): effect type %i is External",
                        j);

                    if( pParams->pEffects != M4OSA_NULL )
                    {
                        if( pParams->pEffects[j].ExtAudioEffectFct
                            == M4OSA_NULL )
                        {
                            M4OSA_TRACE1_1("M4MCS_setOutputParams(): no external effect function\
                                           associated to external effect number %i", j);
                            return M4ERR_PARAMETER;
                        }
                        pC->pEffects[j].pExtAudioEffectFctCtxt =
                            pParams->pEffects[j].pExtAudioEffectFctCtxt;

                        pC->pEffects[j].ExtAudioEffectFct =
                            pParams->pEffects[j].ExtAudioEffectFct;
                    }

                    break;

                default:
                    M4OSA_TRACE1_0(
                        "M4MCS_setOutputParams(): effect type not recognized");
                    return M4ERR_PARAMETER;
            }
        }
    }
    else
    {
        pC->nbEffects = 0;
        pC->pEffects = M4OSA_NULL;
    }

    /**
    * Update state automaton */
    pC->State = M4MCS_kState_SET;

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_setOutputParams(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_setEncodingParams(M4MCS_Context pContext, M4MCS_EncodingParams* pRates)
 * @brief   Set the values of the encoding parameters
 * @note    Must be called before M4MCS_checkParamsAndStart().
 * @param   pContext           (IN) MCS context
 * @param   pRates             (IN) Transcoding parameters
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 * @return  M4MCS_ERR_AUDIOBITRATE_TOO_HIGH: Audio bitrate too high (we limit to 96 kbps)
 * @return  M4MCS_ERR_AUDIOBITRATE_TOO_LOW: Audio bitrate is too low (16 kbps min for aac, 12.2
 *                                            for amr, 8 for mp3)
 * @return  M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT: Begin cut and End cut are equals
 * @return  M4MCS_ERR_BEGIN_CUT_LARGER_THAN_DURATION: Begin cut time is larger than the input clip
 *                                                     duration
 * @return  M4MCS_ERR_END_CUT_SMALLER_THAN_BEGIN_CUT: End cut time is smaller than begin cut time
 * @return  M4MCS_ERR_MAXFILESIZE_TOO_SMALL: Not enough space to store whole output file at given
 *                                             bitrates
 * @return  M4MCS_ERR_VIDEOBITRATE_TOO_HIGH: Video bitrate too high (we limit to 800 kbps)
 * @return  M4MCS_ERR_VIDEOBITRATE_TOO_LOW:  Video bitrate too low
 ******************************************************************************
 */
M4OSA_ERR M4MCS_setEncodingParams( M4MCS_Context pContext,
                                  M4MCS_EncodingParams *pRates )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);
    M4OSA_UInt32 j = 0;

    M4OSA_TRACE2_2(
        "M4MCS_setEncodingParams called with pContext=0x%x, pRates=0x%x",
        pContext, pRates);

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

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Call the corresponding still picture MCS function*/
        return M4MCS_stillPicSetEncodingParams(pC, pRates);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Check state automaton */

    if( M4MCS_kState_SET != pC->State )
    {
        M4OSA_TRACE1_1(
            "M4MCS_setEncodingParams(): Wrong State (%d), returning M4ERR_STATE",
            pC->State);
        return M4ERR_STATE;
    }

    /* Set given values */
    pC->uiVideoBitrate = pRates->OutputVideoBitrate;
    pC->uiAudioBitrate = pRates->OutputAudioBitrate;
    pC->uiBeginCutTime = pRates->BeginCutTime;
    pC->uiEndCutTime = pRates->EndCutTime;
    pC->uiMaxFileSize = pRates->OutputFileSize;

    /**
    * Check begin cut time validity */
    if( pC->uiBeginCutTime >= pC->InputFileProperties.uiClipDuration )
    {
        M4OSA_TRACE1_2("M4MCS_setEncodingParams(): Begin cut larger than duration (%d>%d),\
                       returning M4MCS_ERR_BEGIN_CUT_LARGER_THAN_DURATION",
                       pC->uiBeginCutTime, pC->InputFileProperties.uiClipDuration);
        return M4MCS_ERR_BEGIN_CUT_LARGER_THAN_DURATION;
    }

    /**
    * If end cut time is too large, we set it to the clip duration */
    if( pC->uiEndCutTime > pC->InputFileProperties.uiClipDuration )
    {
        pC->uiEndCutTime = pC->InputFileProperties.uiClipDuration;
    }

    /**
    * Check end cut time validity */
    if( pC->uiEndCutTime > 0 )
    {
        if( pC->uiEndCutTime < pC->uiBeginCutTime )
        {
            M4OSA_TRACE1_2("M4MCS_setEncodingParams(): Begin cut greater than end cut (%d,%d), \
                           returning M4MCS_ERR_END_CUT_SMALLER_THAN_BEGIN_CUT",
                           pC->uiBeginCutTime, pC->uiEndCutTime);
            return M4MCS_ERR_END_CUT_SMALLER_THAN_BEGIN_CUT;
        }

        if( pC->uiEndCutTime == pC->uiBeginCutTime )
        {
            M4OSA_TRACE1_2("M4MCS_setEncodingParams(): Begin and End cuts are equal (%d,%d),\
                           returning M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT",
                           pC->uiBeginCutTime, pC->uiEndCutTime);
            return M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT;
        }
    }

    /**
    * FlB 2009.03.04: check audio effects start time and duration validity*/
    for ( j = 0; j < pC->nbEffects; j++ )
    {
        M4OSA_UInt32 outputEndCut = pC->uiEndCutTime;

        if( pC->uiEndCutTime == 0 )
        {
            outputEndCut = pC->InputFileProperties.uiClipDuration;
        }

        if( pC->pEffects[j].uiStartTime > (outputEndCut - pC->uiBeginCutTime) )
        {
            M4OSA_TRACE1_2("M4MCS_setEncodingParams(): Effects start time is larger than\
                           duration (%d,%d), returning M4ERR_PARAMETER",
                           pC->pEffects[j].uiStartTime,
                           (pC->uiEndCutTime - pC->uiBeginCutTime));
            return M4ERR_PARAMETER;
        }

        if( pC->pEffects[j].uiStartTime + pC->pEffects[j].uiDuration > \
            (outputEndCut - pC->uiBeginCutTime) )
        {
            /* Re-adjust the effect duration until the end of the output clip*/
            pC->pEffects[j].uiDuration = (outputEndCut - pC->uiBeginCutTime) - \
                pC->pEffects[j].uiStartTime;
        }
    }

    /* Check audio bitrate consistency */
    if( ( pC->noaudio == M4OSA_FALSE)
        && (pC->AudioEncParams.Format != M4ENCODER_kAudioNULL) )
    {
        if( pC->uiAudioBitrate != M4VIDEOEDITING_kUndefinedBitrate )
        {
            if( pC->AudioEncParams.Format == M4ENCODER_kAMRNB )
            {
                if( pC->uiAudioBitrate > M4VIDEOEDITING_k12_2_KBPS )
                    return M4MCS_ERR_AUDIOBITRATE_TOO_HIGH;

                if( pC->uiAudioBitrate < M4VIDEOEDITING_k12_2_KBPS )
                    return M4MCS_ERR_AUDIOBITRATE_TOO_LOW;
            }
            //EVRC
            //            else if(pC->AudioEncParams.Format == M4ENCODER_kEVRC)
            //            {
            //                if(pC->uiAudioBitrate > M4VIDEOEDITING_k9_2_KBPS)
            //                    return M4MCS_ERR_AUDIOBITRATE_TOO_HIGH;
            //                if(pC->uiAudioBitrate < M4VIDEOEDITING_k9_2_KBPS)
            //                     return M4MCS_ERR_AUDIOBITRATE_TOO_LOW;
            //            }
            /*FlB 26.02.2009: add mp3 as mcs output format, add mp3 encoder*/
            else if( pC->AudioEncParams.Format == M4ENCODER_kMP3 )
            {
                if( pC->AudioEncParams.Frequency >= M4ENCODER_k32000Hz )
                {
                    /*Mpeg layer 1*/
                    if( pC->uiAudioBitrate > 320000 )
                        return M4MCS_ERR_AUDIOBITRATE_TOO_HIGH;

                    if( pC->uiAudioBitrate < 32000 )
                        return M4MCS_ERR_AUDIOBITRATE_TOO_LOW;
                }
                else if( pC->AudioEncParams.Frequency >= M4ENCODER_k16000Hz )
                {
                    /*Mpeg layer 2*/
                    if( pC->uiAudioBitrate > 160000 )
                        return M4MCS_ERR_AUDIOBITRATE_TOO_HIGH;

                    if( ( pC->uiAudioBitrate < 8000
                        && pC->AudioEncParams.ChannelNum == M4ENCODER_kMono)
                        || (pC->uiAudioBitrate < 16000
                        && pC->AudioEncParams.ChannelNum
                        == M4ENCODER_kStereo) )
                        return M4MCS_ERR_AUDIOBITRATE_TOO_LOW;
                }
                else if( pC->AudioEncParams.Frequency == M4ENCODER_k8000Hz
                    || pC->AudioEncParams.Frequency == M4ENCODER_k11025Hz
                    || pC->AudioEncParams.Frequency == M4ENCODER_k12000Hz )
                {
                    /*Mpeg layer 2.5*/
                    if( pC->uiAudioBitrate > 64000 )
                        return M4MCS_ERR_AUDIOBITRATE_TOO_HIGH;

                    if( ( pC->uiAudioBitrate < 8000
                        && pC->AudioEncParams.ChannelNum == M4ENCODER_kMono)
                        || (pC->uiAudioBitrate < 16000
                        && pC->AudioEncParams.ChannelNum
                        == M4ENCODER_kStereo) )
                        return M4MCS_ERR_AUDIOBITRATE_TOO_LOW;
                }
                else
                {
                    M4OSA_TRACE1_1("M4MCS_setEncodingParams: MP3 audio sampling frequency error\
                                   (%d)", pC->AudioEncParams.Frequency);
                    return M4ERR_PARAMETER;
                }
            }
            else
            {
                if( pC->uiAudioBitrate > M4VIDEOEDITING_k192_KBPS )
                    return M4MCS_ERR_AUDIOBITRATE_TOO_HIGH;

                if( pC->AudioEncParams.ChannelNum == M4ENCODER_kMono )
                {
                    if( pC->uiAudioBitrate < M4VIDEOEDITING_k16_KBPS )
                        return M4MCS_ERR_AUDIOBITRATE_TOO_LOW;
                }
                else
                {
                    if( pC->uiAudioBitrate < M4VIDEOEDITING_k32_KBPS )
                        return M4MCS_ERR_AUDIOBITRATE_TOO_LOW;
                }
            }
        }
    }
    else
    {
        /* NULL audio : copy input file bitrate */
        pC->uiAudioBitrate = pC->InputFileProperties.uiAudioBitrate;
    }

    /* Check video bitrate consistency */
    if( ( pC->novideo == M4OSA_FALSE)
        && (pC->EncodingVideoFormat != M4ENCODER_kNULL) )
    {
        if( pC->uiVideoBitrate != M4VIDEOEDITING_kUndefinedBitrate )
        {
            if( pC->uiVideoBitrate > M4VIDEOEDITING_k8_MBPS )
                return M4MCS_ERR_VIDEOBITRATE_TOO_HIGH;

            if( pC->uiVideoBitrate < M4VIDEOEDITING_k16_KBPS )
                return M4MCS_ERR_VIDEOBITRATE_TOO_LOW;
        }
    }
    else
    {
        /* NULL video : copy input file bitrate */
        pC->uiVideoBitrate = pC->InputFileProperties.uiVideoBitrate;
    }

    if( pRates->OutputVideoTimescale <= 30000
        && pRates->OutputVideoTimescale > 0 )
    {
        pC->outputVideoTimescale = pRates->OutputVideoTimescale;
    }

    /* Check file size */
    return M4MCS_intCheckMaxFileSize(pC);
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_getExtendedEncodingParams(M4MCS_Context pContext, M4MCS_EncodingParams* pRates)
 * @brief   Get the extended values of the encoding parameters
 * @note    Could be called after M4MCS_setEncodingParams.
 * @param   pContext           (IN) MCS context
 * @param   pRates             (OUT) Transcoding parameters
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 * @return  M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT: Encoding settings would produce a null duration
 *                                             clip = encoding is impossible
 ******************************************************************************
 */
M4OSA_ERR M4MCS_getExtendedEncodingParams( M4MCS_Context pContext,
                                          M4MCS_EncodingParams *pRates )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);

    M4OSA_Int32 minaudiobitrate;
    M4OSA_Int32 minvideobitrate;
    M4OSA_Int32 maxcombinedbitrate;

    M4OSA_Int32 calcbitrate;

    M4OSA_UInt32 maxduration;
    M4OSA_UInt32 calcduration;

    M4OSA_Bool fixed_audio = M4OSA_FALSE;
    M4OSA_Bool fixed_video = M4OSA_FALSE;

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Call the corresponding still picture MCS function*/
        return M4MCS_stillPicGetExtendedEncodingParams(pC, pRates);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    pRates->OutputVideoBitrate =
        M4MCS_intGetNearestBitrate(pC->uiVideoBitrate, 0);
    pRates->OutputAudioBitrate =
        M4MCS_intGetNearestBitrate(pC->uiAudioBitrate, 0);
    pRates->BeginCutTime = pC->uiBeginCutTime;
    pRates->EndCutTime = pC->uiEndCutTime;
    pRates->OutputFileSize = pC->uiMaxFileSize;

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

    /* Compute min audio bitrate */
    if( pC->noaudio )
    {
        fixed_audio = M4OSA_TRUE;
        pRates->OutputAudioBitrate = 0;
        minaudiobitrate = 0;
    }
    else if( pC->AudioEncParams.Format == M4ENCODER_kAudioNULL )
    {
        fixed_audio = M4OSA_TRUE;
        pRates->OutputAudioBitrate = pC->InputFileProperties.uiAudioBitrate;
        minaudiobitrate = pC->InputFileProperties.uiAudioBitrate;
    }
    else
    {
        if( pC->AudioEncParams.Format == M4ENCODER_kAMRNB )
        {
            fixed_audio = M4OSA_TRUE;
            pRates->OutputAudioBitrate = M4VIDEOEDITING_k12_2_KBPS;
            minaudiobitrate = M4VIDEOEDITING_k12_2_KBPS;
        }
        //EVRC
        //        if(pC->AudioEncParams.Format == M4ENCODER_kEVRC)
        //        {
        //            fixed_audio = M4OSA_TRUE;
        //            pRates->OutputAudioBitrate = M4VIDEOEDITING_k9_2_KBPS;
        //            minaudiobitrate = M4VIDEOEDITING_k9_2_KBPS;
        //        }
        /*FlB 26.02.2009: add mp3 as mcs output format*/
        else if( pC->AudioEncParams.Format == M4ENCODER_kMP3 )
        {
            minaudiobitrate =
                M4VIDEOEDITING_k32_KBPS; /*Default min audio bitrate for MPEG layer 1,
                                             for both mono and stereo channels*/
        }
        else
        {
            minaudiobitrate = (pC->AudioEncParams.ChannelNum == M4ENCODER_kMono)
                ? M4VIDEOEDITING_k16_KBPS : M4VIDEOEDITING_k32_KBPS;
        }
    }

    /* Check audio bitrate is in the correct range */
    if( fixed_audio == M4OSA_FALSE )
    {
        if( ( pC->uiAudioBitrate > 0)
            && (pRates->OutputAudioBitrate < minaudiobitrate) )
        {
            pRates->OutputAudioBitrate = minaudiobitrate;
        }

        if( pRates->OutputAudioBitrate > M4VIDEOEDITING_k96_KBPS )
        {
            pRates->OutputAudioBitrate = M4VIDEOEDITING_k96_KBPS;
        }
    }

    /* Compute min video bitrate */
    if( pC->novideo )
    {
        fixed_video = M4OSA_TRUE;
        pRates->OutputVideoBitrate = 0;
        minvideobitrate = 0;
    }
    else if( pC->EncodingVideoFormat == M4ENCODER_kNULL )
    {
        fixed_video = M4OSA_TRUE;
        pRates->OutputVideoBitrate = pC->InputFileProperties.uiVideoBitrate;
        minvideobitrate = pC->InputFileProperties.uiVideoBitrate;
    }
    else
    {
        minvideobitrate = M4VIDEOEDITING_k16_KBPS;
    }

    /* Check video bitrate is in the correct range */
    if( fixed_video == M4OSA_FALSE )
    {
        if( ( pC->uiVideoBitrate > 0)
            && (pRates->OutputVideoBitrate < minvideobitrate) )
        {
            pRates->OutputVideoBitrate = minvideobitrate;
        }
        /*+ New Encoder bitrates */
        if( pRates->OutputVideoBitrate > M4VIDEOEDITING_k8_MBPS )
        {
            pRates->OutputVideoBitrate = M4VIDEOEDITING_k8_MBPS;
        }
        /*- New Encoder bitrates */
    }

    /* Check cut times are in correct range */
    if( ( pRates->BeginCutTime >= pC->InputFileProperties.uiClipDuration)
        || (( pRates->BeginCutTime >= pRates->EndCutTime)
        && (pRates->EndCutTime > 0)) )
    {
        pRates->BeginCutTime = 0;
        pRates->EndCutTime = 0;
    }

    if( pRates->EndCutTime == 0 )
        calcduration =
        pC->InputFileProperties.uiClipDuration - pRates->BeginCutTime;
    else
        calcduration = pRates->EndCutTime - pRates->BeginCutTime;

    /* priority 1 : max file size */
    if( pRates->OutputFileSize == 0 )
    {
        /* we can put maximum values for all undefined parameters */
        if( pRates->EndCutTime == 0 )
        {
            pRates->EndCutTime = pC->InputFileProperties.uiClipDuration;
        }

        if( ( pRates->OutputAudioBitrate == M4VIDEOEDITING_kUndefinedBitrate)
            && (fixed_audio == M4OSA_FALSE) )
        {
            pRates->OutputAudioBitrate = M4VIDEOEDITING_k96_KBPS;
        }

        if( ( pRates->OutputVideoBitrate == M4VIDEOEDITING_kUndefinedBitrate)
            && (fixed_video == M4OSA_FALSE) )
        {
            /*+ New Encoder bitrates */
            pRates->OutputVideoBitrate = M4VIDEOEDITING_k8_MBPS;
            /*- New Encoder bitrates */
        }
    }
    else
    {
        /* compute max duration */
        maxduration = (M4OSA_UInt32)(pRates->OutputFileSize
            / M4MCS_MOOV_OVER_FILESIZE_RATIO
            / (minvideobitrate + minaudiobitrate) * 8000.0);

        if( maxduration
            + pRates->BeginCutTime > pC->InputFileProperties.uiClipDuration )
        {
            maxduration =
                pC->InputFileProperties.uiClipDuration - pRates->BeginCutTime;
        }

        /* priority 2 : cut times */
        if( ( pRates->BeginCutTime > 0) || (pRates->EndCutTime > 0) )
        {
            if( calcduration > maxduration )
            {
                calcduration = maxduration;
            }

            if( calcduration == 0 )
            {
                return M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT;
            }

            maxcombinedbitrate = (M4OSA_UInt32)(pRates->OutputFileSize
                / M4MCS_MOOV_OVER_FILESIZE_RATIO / (calcduration / 8000.0));

            /* audio and video bitrates */
            if( ( pRates->OutputAudioBitrate
                == M4VIDEOEDITING_kUndefinedBitrate)
                && (pRates->OutputVideoBitrate
                == M4VIDEOEDITING_kUndefinedBitrate) )
            {
                /* set audio = 1/3 and video = 2/3 */
                if( fixed_audio == M4OSA_FALSE )
                {
                    if( pC->novideo )
                        pRates->OutputAudioBitrate =
                        M4MCS_intGetNearestBitrate(maxcombinedbitrate, 0);
                    else
                        pRates->OutputAudioBitrate =
                        M4MCS_intGetNearestBitrate(maxcombinedbitrate / 3,
                        0);

                    if( pRates->OutputAudioBitrate < minaudiobitrate )
                        pRates->OutputAudioBitrate = minaudiobitrate;

                    if( pRates->OutputAudioBitrate > M4VIDEOEDITING_k96_KBPS )
                        pRates->OutputAudioBitrate = M4VIDEOEDITING_k96_KBPS;
                }

                if( fixed_video == M4OSA_FALSE )
                {
                    pRates->OutputVideoBitrate =
                        M4MCS_intGetNearestBitrate(maxcombinedbitrate
                        - pRates->OutputAudioBitrate, 0);

                    if( pRates->OutputVideoBitrate < minvideobitrate )
                        pRates->OutputVideoBitrate = minvideobitrate;

                    if( pRates->OutputVideoBitrate > M4VIDEOEDITING_k8_MBPS )
                        pRates->OutputVideoBitrate =
                        M4VIDEOEDITING_k8_MBPS; /*+ New Encoder
                                                bitrates */
                }
            }
            else
            {
                /* priority 3 : audio bitrate */
                if( pRates->OutputAudioBitrate
                    != M4VIDEOEDITING_kUndefinedBitrate )
                {
                    while( ( fixed_audio == M4OSA_FALSE)
                        && (pRates->OutputAudioBitrate >= minaudiobitrate)
                        && (pRates->OutputAudioBitrate
                        + minvideobitrate > maxcombinedbitrate) )
                    {
                        pRates->OutputAudioBitrate =
                            M4MCS_intGetNearestBitrate(
                            pRates->OutputAudioBitrate, -1);
                    }

                    if( ( fixed_audio == M4OSA_FALSE)
                        && (pRates->OutputAudioBitrate < minaudiobitrate) )
                    {
                        pRates->OutputAudioBitrate = minaudiobitrate;
                    }

                    calcbitrate = M4MCS_intGetNearestBitrate(
                                    maxcombinedbitrate
                                    - pRates->OutputAudioBitrate, 0);

                    if( calcbitrate < minvideobitrate )
                        calcbitrate = minvideobitrate;

                    if( calcbitrate > M4VIDEOEDITING_k8_MBPS )
                        calcbitrate = M4VIDEOEDITING_k8_MBPS;

                    if( ( fixed_video == M4OSA_FALSE)
                        && (( pRates->OutputVideoBitrate
                        == M4VIDEOEDITING_kUndefinedBitrate)
                        || (pRates->OutputVideoBitrate > calcbitrate)) )
                    {
                        pRates->OutputVideoBitrate = calcbitrate;
                    }
                }
                else
                {
                    /* priority 4 : video bitrate */
                    if( pRates->OutputVideoBitrate
                        != M4VIDEOEDITING_kUndefinedBitrate )
                    {
                        while( ( fixed_video == M4OSA_FALSE)
                            && (pRates->OutputVideoBitrate >= minvideobitrate)
                            && (pRates->OutputVideoBitrate
                            + minaudiobitrate > maxcombinedbitrate) )
                        {
                            pRates->OutputVideoBitrate =
                                M4MCS_intGetNearestBitrate(
                                pRates->OutputVideoBitrate, -1);
                        }

                        if( ( fixed_video == M4OSA_FALSE)
                            && (pRates->OutputVideoBitrate < minvideobitrate) )
                        {
                            pRates->OutputVideoBitrate = minvideobitrate;
                        }

                        calcbitrate =
                            M4MCS_intGetNearestBitrate(maxcombinedbitrate
                            - pRates->OutputVideoBitrate, 0);

                        if( calcbitrate < minaudiobitrate )
                            calcbitrate = minaudiobitrate;

                        if( calcbitrate > M4VIDEOEDITING_k96_KBPS )
                            calcbitrate = M4VIDEOEDITING_k96_KBPS;

                        if( ( fixed_audio == M4OSA_FALSE)
                            && (( pRates->OutputAudioBitrate
                            == M4VIDEOEDITING_kUndefinedBitrate)
                            || (pRates->OutputAudioBitrate > calcbitrate)) )
                        {
                            pRates->OutputAudioBitrate = calcbitrate;
                        }
                    }
                }
            }
        }
        else
        {
            /* priority 3 : audio bitrate */
            if( pRates->OutputAudioBitrate != M4VIDEOEDITING_kUndefinedBitrate )
            {
                /* priority 4 : video bitrate */
                if( pRates->OutputVideoBitrate
                    != M4VIDEOEDITING_kUndefinedBitrate )
                {
                    /* compute max duration */
                    maxduration = (M4OSA_UInt32)(pRates->OutputFileSize
                        / M4MCS_MOOV_OVER_FILESIZE_RATIO
                        / (pRates->OutputVideoBitrate
                        + pRates->OutputAudioBitrate) * 8000.0);

                    if( maxduration + pRates->BeginCutTime
                        > pC->InputFileProperties.uiClipDuration )
                    {
                        maxduration = pC->InputFileProperties.uiClipDuration
                            - pRates->BeginCutTime;
                    }

                    if( calcduration > maxduration )
                    {
                        calcduration = maxduration;
                    }

                    if( calcduration == 0 )
                    {
                        return M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT;
                    }
                }
                else
                {
                    /* start with min video bitrate */
                    pRates->OutputVideoBitrate = minvideobitrate;

                    /* compute max duration */
                    maxduration = (M4OSA_UInt32)(pRates->OutputFileSize
                        / M4MCS_MOOV_OVER_FILESIZE_RATIO
                        / (pRates->OutputVideoBitrate
                        + pRates->OutputAudioBitrate) * 8000.0);

                    if( maxduration + pRates->BeginCutTime
                        > pC->InputFileProperties.uiClipDuration )
                    {
                        maxduration = pC->InputFileProperties.uiClipDuration
                            - pRates->BeginCutTime;
                    }

                    if( calcduration > maxduration )
                    {
                        calcduration = maxduration;
                    }

                    if( calcduration == 0 )
                    {
                        return M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT;
                    }

                    /* search max possible video bitrate */
                    maxcombinedbitrate = (M4OSA_UInt32)(pRates->OutputFileSize
                        / M4MCS_MOOV_OVER_FILESIZE_RATIO
                        / (calcduration / 8000.0));

                    while( ( fixed_video == M4OSA_FALSE)
                        && (pRates->OutputVideoBitrate
                        < M4VIDEOEDITING_k8_MBPS) ) /*+ New Encoder bitrates */
                    {
                        calcbitrate = M4MCS_intGetNearestBitrate(
                            pRates->OutputVideoBitrate, +1);

                        if( calcbitrate
                            + pRates->OutputAudioBitrate <= maxcombinedbitrate )
                            pRates->OutputVideoBitrate = calcbitrate;
                        else
                            break;
                    }
                }
            }
            else
            {
                /* priority 4 : video bitrate */
                if( pRates->OutputVideoBitrate
                    != M4VIDEOEDITING_kUndefinedBitrate )
                {
                    /* start with min audio bitrate */
                    pRates->OutputAudioBitrate = minaudiobitrate;

                    /* compute max duration */
                    maxduration = (M4OSA_UInt32)(pRates->OutputFileSize
                        / M4MCS_MOOV_OVER_FILESIZE_RATIO
                        / (pRates->OutputVideoBitrate
                        + pRates->OutputAudioBitrate) * 8000.0);

                    if( maxduration + pRates->BeginCutTime
                        > pC->InputFileProperties.uiClipDuration )
                    {
                        maxduration = pC->InputFileProperties.uiClipDuration
                            - pRates->BeginCutTime;
                    }

                    if( calcduration > maxduration )
                    {
                        calcduration = maxduration;
                    }

                    if( calcduration == 0 )
                    {
                        return M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT;
                    }

                    /* search max possible audio bitrate */
                    maxcombinedbitrate = (M4OSA_UInt32)(pRates->OutputFileSize
                        / M4MCS_MOOV_OVER_FILESIZE_RATIO
                        / (calcduration / 8000.0));

                    while( ( fixed_audio == M4OSA_FALSE)
                        && (pRates->OutputAudioBitrate
                        < M4VIDEOEDITING_k96_KBPS) )
                    {
                        calcbitrate = M4MCS_intGetNearestBitrate(
                            pRates->OutputAudioBitrate, +1);

                        if( calcbitrate
                            + pRates->OutputVideoBitrate <= maxcombinedbitrate )
                            pRates->OutputAudioBitrate = calcbitrate;
                        else
                            break;
                    }
                }
                else
                {
                    /* compute max duration */
                    maxduration = (M4OSA_UInt32)(pRates->OutputFileSize
                        / M4MCS_MOOV_OVER_FILESIZE_RATIO
                        / (minvideobitrate + minaudiobitrate) * 8000.0);

                    if( maxduration + pRates->BeginCutTime
                        > pC->InputFileProperties.uiClipDuration )
                    {
                        maxduration = pC->InputFileProperties.uiClipDuration
                            - pRates->BeginCutTime;
                    }

                    if( calcduration > maxduration )
                    {
                        calcduration = maxduration;
                    }

                    if( calcduration == 0 )
                    {
                        return M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT;
                    }

                    /* set audio = 1/3 and video = 2/3 */
                    maxcombinedbitrate = (M4OSA_UInt32)(pRates->OutputFileSize
                        / M4MCS_MOOV_OVER_FILESIZE_RATIO
                        / (calcduration / 8000.0));

                    if( fixed_audio == M4OSA_FALSE )
                    {
                        if( pC->novideo )
                            pRates->OutputAudioBitrate =
                            M4MCS_intGetNearestBitrate(maxcombinedbitrate,
                            0);
                        else
                            pRates->OutputAudioBitrate =
                            M4MCS_intGetNearestBitrate(maxcombinedbitrate
                            / 3, 0);

                        if( pRates->OutputAudioBitrate < minaudiobitrate )
                            pRates->OutputAudioBitrate = minaudiobitrate;

                        if( pRates->OutputAudioBitrate
                        > M4VIDEOEDITING_k96_KBPS )
                        pRates->OutputAudioBitrate =
                        M4VIDEOEDITING_k96_KBPS;
                    }

                    if( fixed_video == M4OSA_FALSE )
                    {
                        pRates->OutputVideoBitrate =
                            M4MCS_intGetNearestBitrate(maxcombinedbitrate
                            - pRates->OutputAudioBitrate, 0);

                        if( pRates->OutputVideoBitrate < minvideobitrate )
                            pRates->OutputVideoBitrate = minvideobitrate;

                        if( pRates->OutputVideoBitrate
                        > M4VIDEOEDITING_k8_MBPS )
                        pRates->OutputVideoBitrate =
                        M4VIDEOEDITING_k8_MBPS; /*+ New Encoder
                                                bitrates */
                    }
                }
            }
        }
    }

    /* recompute max duration with final bitrates */
    if( pRates->OutputFileSize > 0 )
    {
        maxduration = (M4OSA_UInt32)(pRates->OutputFileSize
            / M4MCS_MOOV_OVER_FILESIZE_RATIO
            / (pRates->OutputVideoBitrate + pRates->OutputAudioBitrate)
            * 8000.0);
    }
    else
    {
        maxduration = pC->InputFileProperties.uiClipDuration;
    }

    if( maxduration
        + pRates->BeginCutTime > pC->InputFileProperties.uiClipDuration )
    {
        maxduration =
            pC->InputFileProperties.uiClipDuration - pRates->BeginCutTime;
    }

    if( pRates->EndCutTime == 0 )
    {
        pRates->EndCutTime = pRates->BeginCutTime + maxduration;
    }
    else
    {
        calcduration = pRates->EndCutTime - pRates->BeginCutTime;

        if( calcduration > maxduration )
        {
            pRates->EndCutTime = pRates->BeginCutTime + maxduration;
        }
    }

    /* Should never happen : constraints are too strong */
    if( pRates->EndCutTime == pRates->BeginCutTime )
    {
        return M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT;
    }

    /* estimated resulting file size */
    pRates->OutputFileSize = (M4OSA_UInt32)(M4MCS_MOOV_OVER_FILESIZE_RATIO
        * (pRates->OutputVideoBitrate + pRates->OutputAudioBitrate)
        * (( pRates->EndCutTime - pRates->BeginCutTime) / 8000.0));

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_checkParamsAndStart(M4MCS_Context pContext)
 * @brief   Check parameters to start
 * @note
 * @param   pContext           (IN) MCS context
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for
 *                              this function to be called
 * @return  M4MCS_ERR_AUDIOBITRATE_TOO_HIGH:
 *                              Audio bitrate too high (we limit to 96 kbps)
 * @return  M4MCS_ERR_AUDIOBITRATE_TOO_LOW:
 *                              Audio bitrate is too low (16 kbps min for aac,
 *                              12.2 for amr, 8 for mp3)
 * @return  M4MCS_ERR_BEGIN_CUT_EQUALS_END_CUT:
 *                              Begin cut and End cut are equals
 * @return  M4MCS_ERR_BEGIN_CUT_LARGER_THAN_DURATION:
 *                              Begin cut time is larger than the input
 *                              clip duration
 * @return  M4MCS_ERR_END_CUT_SMALLER_THAN_BEGIN_CUT:
 *                              End cut time is smaller than begin cut time
 * @return  M4MCS_ERR_MAXFILESIZE_TOO_SMALL:
 *                              Not enough space to store whole output
 *                              file at given bitrates
 * @return  M4MCS_ERR_VIDEOBITRATE_TOO_HIGH:
 *                              Video bitrate too high (we limit to 800 kbps)
 * @return  M4MCS_ERR_VIDEOBITRATE_TOO_LOW:
 *                              Video bitrate too low
 ******************************************************************************
 */
M4OSA_ERR M4MCS_checkParamsAndStart( M4MCS_Context pContext )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);
    M4MCS_EncodingParams VerifyRates;
    M4OSA_ERR err;

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

#ifdef M4MCS_SUPPORT_STILL_PICTURE

    if( pC->m_bIsStillPicture )
    {
        /**
        * Call the corresponding still picture MCS function*/
        return M4MCS_stillPicCheckParamsAndStart(pC);
    }

#endif /*M4MCS_SUPPORT_STILL_PICTURE*/

    /**
    * Check state automaton */

    if( M4MCS_kState_SET != pC->State )
    {
        M4OSA_TRACE1_1(
            "M4MCS_checkParamsAndStart(): Wrong State (%d), returning M4ERR_STATE",
            pC->State);
        return M4ERR_STATE;
    }

    /* Audio bitrate should not stay undefined at this point */
    if( ( pC->noaudio == M4OSA_FALSE)
        && (pC->AudioEncParams.Format != M4ENCODER_kAudioNULL)
        && (pC->uiAudioBitrate == M4VIDEOEDITING_kUndefinedBitrate) )
    {
        M4OSA_TRACE1_0("M4MCS_checkParamsAndStart : undefined audio bitrate");
        return M4MCS_ERR_AUDIOBITRATE_TOO_LOW;
    }

    /* Video bitrate should not stay undefined at this point */
    if( ( pC->novideo == M4OSA_FALSE)
        && (pC->EncodingVideoFormat != M4ENCODER_kNULL)
        && (pC->uiVideoBitrate == M4VIDEOEDITING_kUndefinedBitrate) )
    {
        M4OSA_TRACE1_0("M4MCS_checkParamsAndStart : undefined video bitrate");
        return M4MCS_ERR_VIDEOBITRATE_TOO_LOW;
    }

    /* Set end cut time if necessary (not an error) */
    if( pC->uiEndCutTime == 0 )
    {
        pC->uiEndCutTime = pC->InputFileProperties.uiClipDuration;
    }

    /* Force a re-set to check validity of parameters */
    VerifyRates.OutputVideoBitrate = pC->uiVideoBitrate;
    VerifyRates.OutputAudioBitrate = pC->uiAudioBitrate;
    VerifyRates.BeginCutTime = pC->uiBeginCutTime;
    VerifyRates.EndCutTime = pC->uiEndCutTime;
    VerifyRates.OutputFileSize = pC->uiMaxFileSize;
    VerifyRates.OutputVideoTimescale = pC->outputVideoTimescale;

    err = M4MCS_setEncodingParams(pContext, &VerifyRates);

    /**
    * Check parameters consistency */
    if( err != M4NO_ERROR )
    {
        M4OSA_TRACE1_0("M4MCS_checkParamsAndStart : invalid parameter found");
        return err;
    }

    /**
    * All is OK : update state automaton */
    pC->uiEncVideoBitrate = pC->uiVideoBitrate;
    pC->AudioEncParams.Bitrate = pC->uiAudioBitrate;

#ifdef M4MCS_WITH_FAST_OPEN
    /**
    * Remake the open if it was done in fast mode */

    if( M4OSA_TRUE == pC->bFileOpenedInFastMode )
    {
        /* Close the file opened in fast mode */
        M4MCS_intCleanUp_ReadersDecoders(pC);

        pC->State = M4MCS_kState_CREATED;

        /* Reopen it in normal mode */
        err = M4MCS_open(pContext, pC->pInputFile, pC->InputFileType,
            pC->pOutputFile, pC->pTemporaryFile);

        if( err != M4NO_ERROR )
        {
            M4OSA_TRACE1_1(
                "M4MCS_checkParamsAndStart : M4MCS_Open returns 0x%x", err);
            return err;
        }
    }

#endif /* M4MCS_WITH_FAST_OPEN */

    pC->State = M4MCS_kState_READY;

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intStepSet(M4MCS_InternalContext* pC)
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intStepSet( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;
    M4ENCODER_Header *encHeader;

    /**
    * Prepare the video decoder */
    err = M4MCS_intPrepareVideoDecoder(pC);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepSet(): M4MCS_intPrepareVideoDecoder() returns 0x%x",
            err);
        return err;
    }

    if( ( pC->InputFileProperties.VideoStreamType == M4VIDEOEDITING_kH264)
        && (pC->EncodingVideoFormat == M4ENCODER_kNULL) )
    {
        pC->bH264Trim = M4OSA_TRUE;
    }

    /**
    * Prepare the video encoder */
    err = M4MCS_intPrepareVideoEncoder(pC);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepSet(): M4MCS_intPrepareVideoEncoder() returns 0x%x",
            err);
        return err;
    }

    if( ( pC->uiBeginCutTime != 0)
        && (pC->InputFileProperties.VideoStreamType == M4VIDEOEDITING_kH264)
        && (pC->EncodingVideoFormat == M4ENCODER_kNULL) )
    {

        err = pC->pVideoEncoderGlobalFcts->pFctSetOption(pC->pViEncCtxt,
            M4ENCODER_kOptionID_H264ProcessNALUContext,
            (M4OSA_DataOption)pC->m_pInstance);

        if( err != M4NO_ERROR )
        {
            M4OSA_TRACE1_1("M4MCS_intStetSet :pFctSetOption failed  (err 0x%x)",
                err);
            return err;
        }

        err = pC->pVideoEncoderGlobalFcts->pFctSetOption(pC->pViEncCtxt,
            M4ENCODER_kOptionID_SetH264ProcessNALUfctsPtr,
            (M4OSA_DataOption) &H264MCS_ProcessEncodedNALU);

        if( err != M4NO_ERROR )
        {
            M4OSA_TRACE1_1("M4MCS_intStetSet :pFctSetOption failed  (err 0x%x)",
                err);
            return err;
        }

        err = pC->pVideoEncoderGlobalFcts->pFctGetOption(pC->pViEncCtxt,
            M4ENCODER_kOptionID_EncoderHeader,
            (M4OSA_DataOption) &encHeader);

        if( ( M4NO_ERROR != err) || (M4OSA_NULL == encHeader->pBuf) )
        {
            M4OSA_TRACE1_1(
                "M4MCS_close: failed to get the encoder header (err 0x%x)",
                err);
            /**< no return here, we still have stuff to deallocate after close, even if it fails.*/
        }
        else
        {
            // Handle DSI first bits
#define SPS_START_POS 6

            pC->m_pInstance->m_encoderSPSSize =
                ( encHeader->pBuf[SPS_START_POS] << 8)
                + encHeader->pBuf[SPS_START_POS + 1];
            pC->m_pInstance->m_pEncoderSPS =
                (M4OSA_UInt8 *)(encHeader->pBuf) + SPS_START_POS + 2;

            pC->m_pInstance->m_encoderPPSSize =
                ( encHeader->pBuf[SPS_START_POS + 3
                + pC->m_pInstance->m_encoderSPSSize] << 8)
                + encHeader->pBuf[SPS_START_POS + 4
                + pC->m_pInstance->m_encoderSPSSize];
            pC->m_pInstance->m_pEncoderPPS = (M4OSA_UInt8 *)encHeader->pBuf + SPS_START_POS + 5
                + pC->m_pInstance->m_encoderSPSSize;

            /* Check the DSI integrity */
            if( encHeader->Size != (pC->m_pInstance->m_encoderSPSSize
                + pC->m_pInstance->m_encoderPPSSize + 5 + SPS_START_POS) )
            {
                M4OSA_TRACE1_3(
                    "!!! M4MCS_intStepSet ERROR : invalid SPS / PPS %d %d %d",
                    encHeader->Size, pC->m_pInstance->m_encoderSPSSize,
                    pC->m_pInstance->m_encoderPPSSize);
                return M4ERR_PARAMETER;
            }
        }
    }

    /**
    * Prepare audio processing */
    err = M4MCS_intPrepareAudioProcessing(pC);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepSet(): M4MCS_intPrepareAudioProcessing() returns 0x%x",
            err);
        return err;
    }

    /**
    * Prepare the writer */
    err = M4MCS_intPrepareWriter(pC);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepSet(): M4MCS_intPrepareWriter() returns 0x%x", err);
        return err;
    }

    /**
    * Jump the audio stream to the begin cut time (all AUs are RAP)
    * Must be done after the 3gpp writer init, because it may write the first
    * audio AU in some cases */
    err = M4MCS_intPrepareAudioBeginCut(pC);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepSet(): M4MCS_intPrepareAudioBeginCut() returns 0x%x",
            err);
        return err;
    }

    /**
    * Update state automaton */
    if( 0 == pC->uiBeginCutTime )
    {
        pC->dViDecStartingCts = 0.0;
        /**
        * No begin cut, do the encoding */
        pC->State = M4MCS_kState_PROCESSING;
    }
    else
    {
        /**
        * Remember that we must start the decode/encode process at the begin cut time */
        pC->dViDecStartingCts = (M4OSA_Double)pC->uiBeginCutTime;

        /**
        * Jumping */
        pC->State = M4MCS_kState_BEGINVIDEOJUMP;
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intStepSet(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intPrepareVideoDecoder(M4MCS_InternalContext* pC);
 * @brief    Prepare the video decoder.
 * @param    pC          (IN) MCS private context
 * @return   M4NO_ERROR  No error
 * @return   M4MCS_ERR_H263_PROFILE_NOT_SUPPORTED
 * @return   Any error returned by an underlaying module
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intPrepareVideoDecoder( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;
    M4OSA_Void *decoderUserData;
    M4DECODER_OutputFilter FilterOption;

    if( pC->novideo )
        return M4NO_ERROR;

    /**
    * Create the decoder, if it has not been created yet (to get video properties for example) */
    if( M4OSA_NULL == pC->pViDecCtxt )
    {
#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS

        decoderUserData = pC->m_pCurrentVideoDecoderUserData;

#else

        decoderUserData = M4OSA_NULL;

#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS ? */

        err = pC->m_pVideoDecoder->m_pFctCreate(&pC->pViDecCtxt,
            &pC->pReaderVideoStream->m_basicProperties, pC->m_pReaderDataIt,
            &pC->ReaderVideoAU, decoderUserData);

        if( (M4OSA_UInt32)(M4ERR_DECODER_H263_PROFILE_NOT_SUPPORTED) == err )
        {
            /**
            * Our decoder is not compatible with H263 profile other than 0.
            * So it returns this internal error code.
            * We translate it to our own error code */
            M4OSA_TRACE1_0("M4MCS_intPrepareVideoDecoder:\
                           returning M4MCS_ERR_H263_PROFILE_NOT_SUPPORTED");
            return M4MCS_ERR_H263_PROFILE_NOT_SUPPORTED;
        }
        else if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1("M4MCS_intPrepareVideoDecoder:\
                           m_pVideoDecoder->m_pFctCreate returns 0x%x", err);
            return err;
        }

        if( M4VIDEOEDITING_kH264 == pC->InputFileProperties.VideoStreamType )
        {
            FilterOption.m_pFilterFunction =
                (M4OSA_Void *) &M4VIFI_ResizeBilinearYUV420toYUV420;
            FilterOption.m_pFilterUserData = M4OSA_NULL;
            err = pC->m_pVideoDecoder->m_pFctSetOption(pC->pViDecCtxt,
                M4DECODER_kOptionID_OutputFilter,
                (M4OSA_DataOption) &FilterOption);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1("M4MCS_intPrepareVideoDecoder:\
                               m_pVideoDecoder->m_pFctSetOption returns 0x%x", err);
                return err;
            }
        }
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intPrepareVideoDecoder(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intPrepareVideoEncoder(M4MCS_InternalContext* pC);
 * @brief    Prepare the video encoder.
 * @param    pC          (IN) MCS private context
 * @return   M4NO_ERROR  No error
 * @return   Any error returned by an underlaying module
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intPrepareVideoEncoder( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;
    M4ENCODER_AdvancedParams EncParams; /**< Encoder advanced parameters */
    M4ENCODER_Params EncParams1;
    M4OSA_Double dFrameRate;            /**< tmp variable */

    if( pC->novideo )
        return M4NO_ERROR;

    if( pC->EncodingVideoFormat == M4ENCODER_kNULL )
    {
        /* Approximative cts increment */
        pC->dCtsIncrement = 1000.0 / pC->pReaderVideoStream->m_averageFrameRate;

        if( pC->uiBeginCutTime == 0 )
        {
            M4OSA_TRACE3_0(
                "M4MCS_intPrepareVideoEncoder(): Null encoding, do nothing.");
            return M4NO_ERROR;
        }
        else
        {
            M4OSA_TRACE3_0(
                "M4MCS_intPrepareVideoEncoder(): Null encoding, I-frame defaults.");

            /* Set useful parameters to encode the first I-frame */
            EncParams.InputFormat = M4ENCODER_kIYUV420;

            switch( pC->InputFileProperties.VideoStreamType )
            {
                case M4VIDEOEDITING_kH263:
                    EncParams.Format = M4ENCODER_kH263;
                    break;

                case M4VIDEOEDITING_kMPEG4:
                case M4VIDEOEDITING_kMPEG4_EMP:
                    EncParams.Format = M4ENCODER_kMPEG4;
                    break;

                case M4VIDEOEDITING_kH264:
                    EncParams.Format = M4ENCODER_kH264;
                    break;

                default:
                    M4OSA_TRACE1_1("M4MCS_intPrepareVideoEncoder: unknown encoding video format\
                                   (%d), returning M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED",
                                   pC->InputFileProperties.VideoStreamType);
                    return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
            }

            EncParams.FrameWidth = pC->EncodingWidth;
            EncParams.FrameHeight = pC->EncodingHeight;
            EncParams.Bitrate = pC->uiEncVideoBitrate;
            EncParams.bInternalRegulation =
                M4OSA_FALSE; /* do not constrain the I-frame */
            EncParams.FrameRate = pC->EncodingVideoFramerate;

            /* Other encoding settings (quite all dummy...) */
            EncParams.uiHorizontalSearchRange = 0;    /* use default */
            EncParams.uiVerticalSearchRange = 0;      /* use default */
            EncParams.bErrorResilience = M4OSA_FALSE; /* no error resilience */
            EncParams.uiIVopPeriod = 0;               /* use default */
            EncParams.uiMotionEstimationTools =
                0; /* M4V_MOTION_EST_TOOLS_ALL */
            EncParams.bAcPrediction = M4OSA_TRUE;     /* use AC prediction */
            EncParams.uiStartingQuantizerValue = 5;   /* initial QP = 5 */
            EncParams.bDataPartitioning =
                M4OSA_FALSE; /* no data partitioning */

            /* Rate factor */
            EncParams.uiTimeScale = pC->InputFileProperties.uiVideoTimeScale;
            EncParams.uiRateFactor = 1;
        }
    }
    else
    {
        M4OSA_TRACE3_0(
            "M4MCS_intPrepareVideoEncoder(): Normal encoding, set full config.");

        /**
        * Set encoder shell parameters according to MCS settings */
        EncParams.Format = pC->EncodingVideoFormat;
        EncParams.InputFormat = M4ENCODER_kIYUV420;

        /**
        * Video frame size */
        EncParams.FrameWidth = pC->EncodingWidth;
        EncParams.FrameHeight = pC->EncodingHeight;

        /**
        * Video bitrate has been previously computed */
        EncParams.Bitrate = pC->uiEncVideoBitrate;

        /**
        * MCS use the "true" core internal bitrate regulation */
        EncParams.bInternalRegulation = M4OSA_TRUE;

        /**
        * Other encoder settings */
        if( M4OSA_TRUE == pC->bActivateEmp )
        {
            EncParams.uiHorizontalSearchRange = 15;   /* set value */
            EncParams.uiVerticalSearchRange = 15;     /* set value */
            EncParams.bErrorResilience = M4OSA_FALSE; /* no error resilience */
            EncParams.uiIVopPeriod = 15; /* one I frame every 15 frames */
            EncParams.uiMotionEstimationTools =
                1; /* M4V_MOTION_EST_TOOLS_NO_4MV */
            EncParams.bAcPrediction = M4OSA_FALSE;    /* no AC prediction */
            EncParams.uiStartingQuantizerValue = 10;  /* initial QP = 10 */
            EncParams.bDataPartitioning =
                M4OSA_FALSE; /* no data partitioning */
        }
        else
        {
            EncParams.uiHorizontalSearchRange = 0;    /* use default */
            EncParams.uiVerticalSearchRange = 0;      /* use default */
            EncParams.bErrorResilience = M4OSA_FALSE; /* no error resilience */
            EncParams.uiIVopPeriod = 0;               /* use default */
            EncParams.uiMotionEstimationTools =
                0; /* M4V_MOTION_EST_TOOLS_ALL */
            EncParams.bAcPrediction = M4OSA_TRUE;     /* use AC prediction */
            EncParams.uiStartingQuantizerValue = 10;  /* initial QP = 10 */
            EncParams.bDataPartitioning =
                M4OSA_FALSE; /* no data partitioning */
        }

        /**
        * Video encoder frame rate and rate factor */
        EncParams.FrameRate = pC->EncodingVideoFramerate;
        EncParams.uiTimeScale = pC->outputVideoTimescale;

        switch( pC->EncodingVideoFramerate )
        {
            case M4ENCODER_k5_FPS:
                dFrameRate = 5.0;
                break;

            case M4ENCODER_k7_5_FPS:
                dFrameRate = 7.5;
                break;

            case M4ENCODER_k10_FPS:
                dFrameRate = 10.0;
                break;

            case M4ENCODER_k12_5_FPS:
                dFrameRate = 12.5;
                break;

            case M4ENCODER_k15_FPS:
                dFrameRate = 15.0;
                break;

            case M4ENCODER_k20_FPS: /**< MPEG-4 only */
                dFrameRate = 20.0;
                break;

            case M4ENCODER_k25_FPS: /**< MPEG-4 only */
                dFrameRate = 25.0;
                break;

            case M4ENCODER_k30_FPS:
                dFrameRate = 30.0;
                break;

            default:
                M4OSA_TRACE1_1(
                    "M4MCS_intPrepareVideoEncoder: unknown encoding video frame rate\
                    (0x%x), returning M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_RATE",
                    pC->EncodingVideoFramerate);
                return M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FRAME_RATE;
        }

        /**
        * Compute the number of milliseconds between two frames */
        if( M4ENCODER_kH263 == EncParams.Format )
        {
            pC->dCtsIncrement = 1001.0 / dFrameRate;
        }
        else /**< MPEG4 or H.264 */
        {
            pC->dCtsIncrement = 1000.0 / dFrameRate;
        }
    }

    /**
    * Create video encoder */
    err = pC->pVideoEncoderGlobalFcts->pFctInit(&pC->pViEncCtxt,
        pC->pWriterDataFcts, \
        M4MCS_intApplyVPP, pC, pC->pCurrentVideoEncoderExternalAPI, \
        pC->pCurrentVideoEncoderUserData);

    /**< We put the MCS context in place of the VPP context */
    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareVideoEncoder: EncoderInt->pFctInit returns 0x%x",
            err);
        return err;
    }

    pC->encoderState = M4MCS_kEncoderClosed;

    if( M4OSA_TRUE == pC->bH264Trim )
        //if((M4ENCODER_kNULL == pC->EncodingVideoFormat)
        //    && (M4VIDEOEDITING_kH264 == pC->InputFileProperties.VideoStreamType))
    {
        EncParams1.InputFormat = EncParams.InputFormat;
        //EncParams1.InputFrameWidth = EncParams.InputFrameWidth;
        //EncParams1.InputFrameHeight = EncParams.InputFrameHeight;
        EncParams1.FrameWidth = EncParams.FrameWidth;
        EncParams1.FrameHeight = EncParams.FrameHeight;
        EncParams1.Bitrate = EncParams.Bitrate;
        EncParams1.FrameRate = EncParams.FrameRate;
        EncParams1.Format = M4ENCODER_kH264; //EncParams.Format;

        err = pC->pVideoEncoderGlobalFcts->pFctOpen(pC->pViEncCtxt,
            &pC->WriterVideoAU, &EncParams1);
    }
    else
    {
        err = pC->pVideoEncoderGlobalFcts->pFctOpen(pC->pViEncCtxt,
            &pC->WriterVideoAU, &EncParams);
    }

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

    pC->encoderState = M4MCS_kEncoderStopped;

    if( M4OSA_NULL != pC->pVideoEncoderGlobalFcts->pFctStart )
    {
        err = pC->pVideoEncoderGlobalFcts->pFctStart(pC->pViEncCtxt);

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

    pC->encoderState = M4MCS_kEncoderRunning;

    /******************************/
    /* Video resize management    */
    /******************************/
    /**
    * Compare video input size and video output size to check if resize is needed */
    if( ( (M4OSA_UInt32)EncParams.FrameWidth
        != pC->pReaderVideoStream->m_videoWidth)
        || ((M4OSA_UInt32)EncParams.FrameHeight
        != pC->pReaderVideoStream->m_videoHeight) )
    {
        /**
        * Allocate the intermediate video plane that will receive the decoded image before
         resizing */
        pC->pPreResizeFrame =
            (M4VIFI_ImagePlane *)M4OSA_32bitAlignedMalloc(3 * sizeof(M4VIFI_ImagePlane),
            M4MCS, (M4OSA_Char *)"m_pPreResizeFrame");

        if( M4OSA_NULL == pC->pPreResizeFrame )
        {
            M4OSA_TRACE1_0("M4MCS_intPrepareVideoEncoder():\
                           unable to allocate m_pPreResizeFrame, returning M4ERR_ALLOC");
            return M4ERR_ALLOC;
        }

        pC->pPreResizeFrame[0].pac_data = M4OSA_NULL;
        pC->pPreResizeFrame[1].pac_data = M4OSA_NULL;
        pC->pPreResizeFrame[2].pac_data = M4OSA_NULL;

        /**
        * Allocate the Y plane */
        pC->pPreResizeFrame[0].u_topleft = 0;
        pC->pPreResizeFrame[0].u_width = pC->pReaderVideoStream->
            m_videoWidth; /**< input width */
        pC->pPreResizeFrame[0].u_height = pC->pReaderVideoStream->
            m_videoHeight; /**< input height */
        pC->pPreResizeFrame[0].u_stride = pC->
            pPreResizeFrame[0].u_width; /**< simple case: stride equals width */

        pC->pPreResizeFrame[0].pac_data =
            (M4VIFI_UInt8 *)M4OSA_32bitAlignedMalloc(pC->pPreResizeFrame[0].u_stride \
            *pC->pPreResizeFrame[0].u_height, M4MCS,
            (M4OSA_Char *)"m_pPreResizeFrame[0].pac_data");

        if( M4OSA_NULL == pC->pPreResizeFrame[0].pac_data )
        {
            M4OSA_TRACE1_0(
                "M4MCS_intPrepareVideoEncoder():\
                     unable to allocate m_pPreResizeFrame[0].pac_data, returning M4ERR_ALLOC");
            return M4ERR_ALLOC;
        }

        /**
        * Allocate the U plane */
        pC->pPreResizeFrame[1].u_topleft = 0;
        pC->pPreResizeFrame[1].u_width = pC->pPreResizeFrame[0].u_width
            >> 1; /**< U width is half the Y width */
        pC->pPreResizeFrame[1].u_height = pC->pPreResizeFrame[0].u_height
            >> 1; /**< U height is half the Y height */
        pC->pPreResizeFrame[1].u_stride = pC->
            pPreResizeFrame[1].u_width; /**< simple case: stride equals width */

        pC->pPreResizeFrame[1].pac_data =
            (M4VIFI_UInt8 *)M4OSA_32bitAlignedMalloc(pC->pPreResizeFrame[1].u_stride \
            *pC->pPreResizeFrame[1].u_height, M4MCS,
            (M4OSA_Char *)"m_pPreResizeFrame[1].pac_data");

        if( M4OSA_NULL == pC->pPreResizeFrame[1].pac_data )
        {
            M4OSA_TRACE1_0(
                "M4MCS_intPrepareVideoEncoder():\
                 unable to allocate m_pPreResizeFrame[1].pac_data, returning M4ERR_ALLOC");
            return M4ERR_ALLOC;
        }

        /**
        * Allocate the V plane */
        pC->pPreResizeFrame[2].u_topleft = 0;
        pC->pPreResizeFrame[2].u_width = pC->
            pPreResizeFrame[1].u_width; /**< V width equals U width */
        pC->pPreResizeFrame[2].u_height = pC->
            pPreResizeFrame[1].u_height; /**< V height equals U height */
        pC->pPreResizeFrame[2].u_stride = pC->
            pPreResizeFrame[2].u_width; /**< simple case: stride equals width */

        pC->pPreResizeFrame[2].pac_data =
            (M4VIFI_UInt8 *)M4OSA_32bitAlignedMalloc(pC->pPreResizeFrame[2].u_stride \
            *pC->pPreResizeFrame[2].u_height, M4MCS,
            (M4OSA_Char *)"m_pPreResizeFrame[1].pac_data");

        if( M4OSA_NULL == pC->pPreResizeFrame[2].pac_data )
        {
            M4OSA_TRACE1_0(
                "M4MCS_intPrepareVideoEncoder():\
                 unable to allocate m_pPreResizeFrame[2].pac_data, returning M4ERR_ALLOC");
            return M4ERR_ALLOC;
        }
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intPrepareVideoEncoder(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intPrepareAudioProcessing(M4MCS_InternalContext* pC);
 * @brief    Prepare the AAC decoder, the SRC and the AMR-NB encoder and the MP3 encoder.
 * @param    pC          (IN) MCS private context
 * @return   M4NO_ERROR  No error
 * @return   Any error returned by an underlaying module
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intPrepareAudioProcessing( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;

    SSRC_ReturnStatus_en
        ReturnStatus; /* Function return status                       */
    LVM_INT16 NrSamplesMin =
        0; /* Minimal number of samples on the input or on the output */
    LVM_INT32 ScratchSize; /* The size of the scratch memory               */
    LVM_INT16
        *pInputInScratch; /* Pointer to input in the scratch buffer       */
    LVM_INT16
        *pOutputInScratch; /* Pointer to the output in the scratch buffer  */
    SSRC_Params_t ssrcParams;          /* Memory for init parameters                    */

#ifdef MCS_DUMP_PCM_TO_FILE

    file_au_reader = fopen("mcs_ReaderOutput.raw", "wb");
    file_pcm_decoder = fopen("mcs_DecoderOutput.pcm", "wb");
    file_pcm_encoder = fopen("mcs_EncoderInput.pcm", "wb");

#endif

    if( pC->noaudio )
        return M4NO_ERROR;

    if( pC->AudioEncParams.Format == M4ENCODER_kAudioNULL )
    {
        M4OSA_TRACE3_0(
            "M4MCS_intPrepareAudioProcessing(): Null encoding, do nothing.");
        return M4NO_ERROR;
    }

    /* ________________________________ */
    /*|                                |*/
    /*| Create and "start" the decoder |*/
    /*|________________________________|*/

    if( M4OSA_NULL == pC->m_pAudioDecoder )
    {
        M4OSA_TRACE1_0(
            "M4MCS_intPrepareAudioProcessing(): Fails to initiate the audio decoder.");
        return M4MCS_ERR_AUDIO_CONVERSION_FAILED;
    }

    if( M4OSA_NULL == pC->pAudioDecCtxt )
    {
        err = pC->m_pAudioDecoder->m_pFctCreateAudioDec(&pC->pAudioDecCtxt,
            pC->pReaderAudioStream, pC->m_pCurrentAudioDecoderUserData);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareVideoDecoder: m_pAudioDecoder->m_pFctCreateAudioDec returns 0x%x",
                err);
            return err;
        }
    }

    if( M4VIDEOEDITING_kAMR_NB == pC->InputFileProperties.AudioStreamType ) {
        /* AMR DECODER CONFIGURATION */

        /* nothing specific to do */
    }
    else if( M4VIDEOEDITING_kEVRC == pC->InputFileProperties.AudioStreamType ) {
        /* EVRC DECODER CONFIGURATION */

        /* nothing specific to do */
    }
    else if( M4VIDEOEDITING_kMP3 == pC->InputFileProperties.AudioStreamType ) {
        /* MP3 DECODER CONFIGURATION */

        /* nothing specific to do */
    }
    else
    {
        /* AAC DECODER CONFIGURATION */
        M4_AacDecoderConfig AacDecParam;

        AacDecParam.m_AACDecoderProfile = AAC_kAAC;
        AacDecParam.m_DownSamplingMode = AAC_kDS_OFF;

        if( pC->AudioEncParams.Format == M4ENCODER_kAMRNB )
        {
            AacDecParam.m_OutputMode = AAC_kMono;
        }
        else
        {
            /* For this version, we encode only in AAC */
            if( M4ENCODER_kMono == pC->AudioEncParams.ChannelNum )
            {
                AacDecParam.m_OutputMode = AAC_kMono;
            }
            else
            {
                AacDecParam.m_OutputMode = AAC_kStereo;
            }
        }

        pC->m_pAudioDecoder->m_pFctSetOptionAudioDec(pC->pAudioDecCtxt,
            M4AD_kOptionID_UserParam, (M4OSA_DataOption) &AacDecParam);
    }

    pC->m_pAudioDecoder->m_pFctSetOptionAudioDec(pC->pAudioDecCtxt,
           M4AD_kOptionID_3gpReaderInterface, (M4OSA_DataOption) pC->m_pReaderDataIt);

    pC->m_pAudioDecoder->m_pFctSetOptionAudioDec(pC->pAudioDecCtxt,
           M4AD_kOptionID_AudioAU, (M4OSA_DataOption) &pC->ReaderAudioAU);

    if( pC->m_pAudioDecoder->m_pFctStartAudioDec != M4OSA_NULL )
    {
        /* Not implemented in all decoders */
        err = pC->m_pAudioDecoder->m_pFctStartAudioDec(pC->pAudioDecCtxt);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareVideoDecoder: m_pAudioDecoder->m_pFctStartAudioDec returns 0x%x",
                err);
            return err;
        }
    }

    /**
    * Allocate output buffer for the audio decoder */
    pC->InputFileProperties.uiDecodedPcmSize =
        pC->pReaderAudioStream->m_byteFrameLength
        * pC->pReaderAudioStream->m_byteSampleSize
        * pC->pReaderAudioStream->m_nbChannels;

    if( pC->InputFileProperties.uiDecodedPcmSize > 0 )
    {
        pC->AudioDecBufferOut.m_bufferSize =
            pC->InputFileProperties.uiDecodedPcmSize;
        pC->AudioDecBufferOut.m_dataAddress =
            (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->AudioDecBufferOut.m_bufferSize \
            *sizeof(short), M4MCS, (M4OSA_Char *)"AudioDecBufferOut.m_bufferSize");
    }

    if( M4OSA_NULL == pC->AudioDecBufferOut.m_dataAddress )
    {
        M4OSA_TRACE1_0(
            "M4MCS_intPrepareVideoDecoder():\
             unable to allocate AudioDecBufferOut.m_dataAddress, returning M4ERR_ALLOC");
        return M4ERR_ALLOC;
    }

    /* _________________________ */
    /*|                         |*/
    /*| Set the SSRC parameters |*/
    /*|_________________________|*/

    switch( pC->pReaderAudioStream->m_samplingFrequency )
    {
        case 8000:
            ssrcParams.SSRC_Fs_In = LVM_FS_8000;
            break;

        case 11025:
            ssrcParams.SSRC_Fs_In = LVM_FS_11025;
            break;

        case 12000:
            ssrcParams.SSRC_Fs_In = LVM_FS_12000;
            break;

        case 16000:
            ssrcParams.SSRC_Fs_In = LVM_FS_16000;
            break;

        case 22050:
            ssrcParams.SSRC_Fs_In = LVM_FS_22050;
            break;

        case 24000:
            ssrcParams.SSRC_Fs_In = LVM_FS_24000;
            break;

        case 32000:
            ssrcParams.SSRC_Fs_In = LVM_FS_32000;
            break;

        case 44100:
            ssrcParams.SSRC_Fs_In = LVM_FS_44100;
            break;

        case 48000:
            ssrcParams.SSRC_Fs_In = LVM_FS_48000;
            break;

        default:
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareVideoDecoder: invalid input AAC sampling frequency (%d Hz),\
                 returning M4MCS_ERR_INVALID_AAC_SAMPLING_FREQUENCY",
                pC->pReaderAudioStream->m_samplingFrequency);
            return M4MCS_ERR_INVALID_AAC_SAMPLING_FREQUENCY;
    }

    if( 1 == pC->pReaderAudioStream->m_nbChannels )
    {
        ssrcParams.SSRC_NrOfChannels = LVM_MONO;
    }
    else
    {
        ssrcParams.SSRC_NrOfChannels = LVM_STEREO;
    }

    /*FlB 26.02.2009: add mp3 as output format*/
    if( pC->AudioEncParams.Format == M4ENCODER_kAAC
        || pC->AudioEncParams.Format == M4ENCODER_kMP3 )
    {
        switch( pC->AudioEncParams.Frequency )
        {
            case M4ENCODER_k8000Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_8000;
                break;

            case M4ENCODER_k11025Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_11025;
                break;

            case M4ENCODER_k12000Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_12000;
                break;

            case M4ENCODER_k16000Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_16000;
                break;

            case M4ENCODER_k22050Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_22050;
                break;

            case M4ENCODER_k24000Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_24000;
                break;

            case M4ENCODER_k32000Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_32000;
                break;

            case M4ENCODER_k44100Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_44100;
                break;

            case M4ENCODER_k48000Hz:
                ssrcParams.SSRC_Fs_Out = LVM_FS_48000;
                break;

            default:
                M4OSA_TRACE1_1(
                    "M4MCS_intPrepareAudioProcessing: invalid output AAC sampling frequency \
                    (%d Hz), returning M4MCS_ERR_INVALID_AAC_SAMPLING_FREQUENCY",
                    pC->AudioEncParams.Frequency);
                return M4MCS_ERR_INVALID_AAC_SAMPLING_FREQUENCY;
                break;
        }
    }
    else
    {
        ssrcParams.SSRC_Fs_Out = LVM_FS_8000;
    }



    ReturnStatus = 0;

    switch( ssrcParams.SSRC_Fs_In )
    {
        case LVM_FS_8000:
            ssrcParams.NrSamplesIn = 320;
            break;

        case LVM_FS_11025:
            ssrcParams.NrSamplesIn = 441;
            break;

        case LVM_FS_12000:
            ssrcParams.NrSamplesIn = 480;
            break;

        case LVM_FS_16000:
            ssrcParams.NrSamplesIn = 640;
            break;

        case LVM_FS_22050:
            ssrcParams.NrSamplesIn = 882;
            break;

        case LVM_FS_24000:
            ssrcParams.NrSamplesIn = 960;
            break;

        case LVM_FS_32000:
            ssrcParams.NrSamplesIn = 1280;
            break;

        case LVM_FS_44100:
            ssrcParams.NrSamplesIn = 1764;
            break;

        case LVM_FS_48000:
            ssrcParams.NrSamplesIn = 1920;
            break;

        default:
            ReturnStatus = -1;
            break;
    }

    switch( ssrcParams.SSRC_Fs_Out )
    {
        case LVM_FS_8000:
            ssrcParams.NrSamplesOut = 320;
            break;

        case LVM_FS_11025:
            ssrcParams.NrSamplesOut = 441;
            break;

        case LVM_FS_12000:
            ssrcParams.NrSamplesOut = 480;
            break;

        case LVM_FS_16000:
            ssrcParams.NrSamplesOut = 640;
            break;

        case LVM_FS_22050:
            ssrcParams.NrSamplesOut = 882;
            break;

        case LVM_FS_24000:
            ssrcParams.NrSamplesOut = 960;
            break;

        case LVM_FS_32000:
            ssrcParams.NrSamplesOut = 1280;
            break;

        case LVM_FS_44100:
            ssrcParams.NrSamplesOut = 1764;
            break;

        case LVM_FS_48000:
            ssrcParams.NrSamplesOut = 1920;
            break;

        default:
            ReturnStatus = -1;
            break;
    }



    if( ReturnStatus != SSRC_OK )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareAudioProcessing:\
             Error code %d returned by the SSRC_GetNrSamples function",
            ReturnStatus);
        return M4MCS_ERR_AUDIO_CONVERSION_FAILED;
    }

    NrSamplesMin =
        (LVM_INT16)((ssrcParams.NrSamplesIn > ssrcParams.NrSamplesOut)
        ? ssrcParams.NrSamplesOut : ssrcParams.NrSamplesIn);

    while( NrSamplesMin < M4MCS_SSRC_MINBLOCKSIZE )
    { /* Don't take blocks smaller that the minimal block size */
        ssrcParams.NrSamplesIn = (LVM_INT16)(ssrcParams.NrSamplesIn << 1);
        ssrcParams.NrSamplesOut = (LVM_INT16)(ssrcParams.NrSamplesOut << 1);
        NrSamplesMin = (LVM_INT16)(NrSamplesMin << 1);
    }


    pC->iSsrcNbSamplIn = (LVM_INT16)(
        ssrcParams.
        NrSamplesIn); /* multiplication by NrOfChannels is done below */
    pC->iSsrcNbSamplOut = (LVM_INT16)(ssrcParams.NrSamplesOut);

    /**
    * Allocate buffer for the input of the SSRC */
    pC->pSsrcBufferIn =
        (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->iSsrcNbSamplIn * sizeof(short) \
        *pC->pReaderAudioStream->m_nbChannels, M4MCS,
        (M4OSA_Char *)"pSsrcBufferIn");

    if( M4OSA_NULL == pC->pSsrcBufferIn )
    {
        M4OSA_TRACE1_0(
            "M4MCS_intPrepareVideoDecoder():\
             unable to allocate pSsrcBufferIn, returning M4ERR_ALLOC");
        return M4ERR_ALLOC;
    }
    pC->pPosInSsrcBufferIn = (M4OSA_MemAddr8)pC->pSsrcBufferIn;

    /**
    * Allocate buffer for the output of the SSRC */
    pC->pSsrcBufferOut =
        (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->iSsrcNbSamplOut * sizeof(short) \
        *pC->pReaderAudioStream->m_nbChannels, M4MCS,
        (M4OSA_Char *)"pSsrcBufferOut");

    if( M4OSA_NULL == pC->pSsrcBufferOut )
    {
        M4OSA_TRACE1_0(
            "M4MCS_intPrepareVideoDecoder():\
             unable to allocate pSsrcBufferOut, returning M4ERR_ALLOC");
        return M4ERR_ALLOC;
    }


    pC->pLVAudioResampler = LVAudioResamplerCreate(
        16, /*gInputParams.lvBTChannelCount*/
        (M4OSA_Int16)pC->InputFileProperties.uiNbChannels/*ssrcParams.SSRC_NrOfChannels*/,
        (M4OSA_Int32)(pC->AudioEncParams.Frequency)/*ssrcParams.SSRC_Fs_Out*/, 1);

     if( M4OSA_NULL == pC->pLVAudioResampler)
     {
         return M4ERR_ALLOC;
     }

    LVAudiosetSampleRate(pC->pLVAudioResampler,
        /*gInputParams.lvInSampleRate*/
        /*pC->pAddedClipCtxt->pSettings->ClipProperties.uiSamplingFrequency*/
        pC->InputFileProperties.uiSamplingFrequency/*ssrcParams.SSRC_Fs_In*/);

    LVAudiosetVolume(pC->pLVAudioResampler, (M4OSA_Int16)(0x1000 /* 0x7fff */),
        (M4OSA_Int16)(0x1000/*0x7fff*/));


    /* ________________________ */
    /*|                        |*/
    /*| Init the audio encoder |*/
    /*|________________________|*/

    /* Initialise the audio encoder */

    err = pC->pAudioEncoderGlobalFcts->pFctInit(&pC->pAudioEncCtxt,
        pC->pCurrentAudioEncoderUserData);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareAudioProcessing: pAudioEncoderGlobalFcts->pFctInit returns 0x%x",
            err);
        return err;
    }

    /* Open the audio encoder */
    err = pC->pAudioEncoderGlobalFcts->pFctOpen(pC->pAudioEncCtxt,
        &pC->AudioEncParams, &pC->pAudioEncDSI,
        M4OSA_NULL /* no grabbing */);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareAudioProcessing: pAudioEncoderGlobalFcts->pFctOpen returns 0x%x",
            err);
        return err;
    }

    /* Allocate the input buffer for the audio encoder */
    switch( pC->AudioEncParams.Format )
    {
        case M4ENCODER_kAMRNB:
            pC->audioEncoderGranularity = M4MCS_PCM_AMR_GRANULARITY_SAMPLES;
            break;

        case M4ENCODER_kAAC:
            pC->audioEncoderGranularity = M4MCS_PCM_AAC_GRANULARITY_SAMPLES;
            break;

            /*FlB 26.02.2009: add mp3 as output format*/
        case M4ENCODER_kMP3:
            pC->audioEncoderGranularity = M4MCS_PCM_MP3_GRANULARITY_SAMPLES;
            break;

         default:
         break;
    }

    if( M4ENCODER_kMono == pC->AudioEncParams.ChannelNum )
        pC->audioEncoderGranularity *= sizeof(short);
    else
        pC->audioEncoderGranularity *= sizeof(short) * 2;

    pC->pPosInAudioEncoderBuffer = M4OSA_NULL;
    pC->pAudioEncoderBuffer =
        (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->audioEncoderGranularity, M4MCS,
        (M4OSA_Char *)"pC->pAudioEncoderBuffer");

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intPrepareAudioProcessing(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intPrepareWriter(M4MCS_InternalContext* pC);
 * @brief    Prepare the writer.
 * @param    pC          (IN) MCS private context
 * @return   M4NO_ERROR  No error
 * @return   Any error returned by an underlaying module
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intPrepareWriter( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;
    M4OSA_UInt32 uiVersion; /**< To write component version in 3gp writer */
    M4OSA_MemAddr8 pDSI = M4OSA_NULL; /**< To create the Decoder Specific Info */
    M4SYS_StreamIDValue optionValue; /**< For the setoption calls */
    M4OSA_UInt32 TargetedFileSize;
    M4OSA_Bool bMULPPSSPS = M4OSA_FALSE;

    /**
    * Init the writer */
    err = pC->pWriterGlobalFcts->pFctOpen(&pC->pWriterContext, pC->pOutputFile,
        pC->pOsaFileWritPtr, pC->pTemporaryFile, pC->pOsaFileReadPtr);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareWriter: pWriterGlobalFcts->pFctOpen returns 0x%x",
            err);
        return err;
    }

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

    /**
    * Set the product description string in the written file */
    err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
        M4WRITER_kEmbeddedString, (M4OSA_DataOption)"NXP-SW : MCS    ");

    if( ( M4NO_ERROR != err) && (( (M4OSA_UInt32)M4ERR_BAD_OPTION_ID)
        != err) ) /* this option may not be implemented by some writers */
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareWriter:\
             pWriterGlobalFcts->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->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
        M4WRITER_kEmbeddedVersion, (M4OSA_DataOption) &uiVersion);

    if( ( M4NO_ERROR != err) && (( (M4OSA_UInt32)M4ERR_BAD_OPTION_ID)
        != err) ) /* this option may not be implemented by some writers */
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareWriter: \
            pWriterGlobalFcts->pFctSetOption(M4WRITER_kEmbeddedVersion) returns 0x%x",
            err);
        return err;
    }

    /**
    * In case of EMP, we have to explicitely give an emp ftyp to the writer */
    if( M4OSA_TRUE == pC->bActivateEmp )
    {
        M4VIDEOEDITING_FtypBox ftyp;

        ftyp.major_brand = M4VIDEOEDITING_BRAND_3GP4;
        ftyp.minor_version = M4VIDEOEDITING_BRAND_0000;
        ftyp.nbCompatibleBrands = 2;
        ftyp.compatible_brands[0] = M4VIDEOEDITING_BRAND_3GP4;
        ftyp.compatible_brands[1] = M4VIDEOEDITING_BRAND_EMP;

        err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
            (M4OSA_UInt32)M4WRITER_kSetFtypBox, (M4OSA_DataOption) &ftyp);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareWriter:\
                 pWriterGlobalFcts->pFctSetOption(M4WRITER_kSetFtypBox) returns 0x%x!",
                err);
            return err;
        }
    }

    /**
    * If there is a video input, allocate and fill the video stream structures for the writer */
    if( pC->novideo == M4OSA_FALSE )
    {
        /**
        * Fill Video properties structure for the AddStream method */
        pC->WriterVideoStreamInfo.height = pC->EncodingHeight;
        pC->WriterVideoStreamInfo.width = pC->EncodingWidth;
        pC->WriterVideoStreamInfo.fps =
            0; /**< Not used by the shell/core writer */
        pC->WriterVideoStreamInfo.Header.pBuf =
            M4OSA_NULL; /**< Will be updated later */
        pC->WriterVideoStreamInfo.Header.Size = 0; /**< Will be updated later */

        /**
        * Fill Video stream description structure for the AddStream method */
        switch( pC->EncodingVideoFormat )
        {
            case M4ENCODER_kMPEG4:
                pC->WriterVideoStream.streamType = M4SYS_kMPEG_4;
                break;

            case M4ENCODER_kH263:
                pC->WriterVideoStream.streamType = M4SYS_kH263;
                break;

            case M4ENCODER_kH264:
                pC->WriterVideoStream.streamType = M4SYS_kH264;
                break;

            case M4ENCODER_kNULL:
                switch( pC->InputFileProperties.VideoStreamType )
                {
                    case M4VIDEOEDITING_kMPEG4:
                    case M4VIDEOEDITING_kMPEG4_EMP: /* RC */
                        pC->WriterVideoStream.streamType = M4SYS_kMPEG_4;
                        break;

                    case M4VIDEOEDITING_kH263:
                        pC->WriterVideoStream.streamType = M4SYS_kH263;
                        break;

                    case M4VIDEOEDITING_kH264:
                        pC->WriterVideoStream.streamType = M4SYS_kH264;
                        break;

                    default:
                        M4OSA_TRACE1_1(
                            "M4MCS_intPrepareWriter: case input=M4ENCODER_kNULL, \
                            unknown format (0x%x),\
                             returning M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FORMAT",
                            pC->EncodingVideoFormat);
                        return M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FORMAT;
                }
                break;

            default: /**< It should never happen, already tested */
                M4OSA_TRACE1_1(
                    "M4MCS_intPrepareWriter: unknown format (0x%x),\
                     returning M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FORMAT",
                    pC->EncodingVideoFormat);
                return M4MCS_ERR_UNDEFINED_OUTPUT_VIDEO_FORMAT;
        }

        /**
        * Video bitrate value will be the real value */
        pC->WriterVideoStream.averageBitrate =
            (M4OSA_Int32)pC->uiEncVideoBitrate;
        pC->WriterVideoStream.maxBitrate = (M4OSA_Int32)pC->uiEncVideoBitrate;

        /**
        * most other parameters are "dummy" */
        pC->WriterVideoStream.streamID = M4MCS_WRITER_VIDEO_STREAM_ID;
        pC->WriterVideoStream.timeScale =
            0; /**< Not used by the shell/core writer */
        pC->WriterVideoStream.profileLevel =
            0; /**< Not used by the shell/core writer */
        pC->WriterVideoStream.duration =
            0; /**< Not used by the shell/core writer */
        pC->WriterVideoStream.decoderSpecificInfoSize =
            sizeof(M4WRITER_StreamVideoInfos);
        pC->WriterVideoStream.decoderSpecificInfo =
            (M4OSA_MemAddr32) &(pC->WriterVideoStreamInfo);

        /**
        * Update Encoder Header properties for Video stream if needed */
        if( M4ENCODER_kH263 == pC->EncodingVideoFormat )
        {
            /**
            * Creates the H263 DSI */
            pC->WriterVideoStreamInfo.Header.Size =
                7; /**< H263 output DSI is always 7 bytes */
            pDSI = (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(7, M4MCS, (M4OSA_Char
                *)"pC->WriterVideoStreamInfo.Header.pBuf (DSI H263)");

            if( M4OSA_NULL == pDSI )
            {
                M4OSA_TRACE1_0("M4MCS_intPrepareWriter(): unable to allocate pDSI (H263),\
                               returning M4ERR_ALLOC");
                return M4ERR_ALLOC;
            }

            /**
            * Vendor is NXP Software: N, X, P, S. */
            pDSI[0] = 'N';
            pDSI[1] = 'X';
            pDSI[2] = 'P';
            pDSI[3] = 'S';

            /**
            * Decoder version is 0 */
            pDSI[4] = 0;

            /**
            * Level is the sixth byte of the DSI. */
            switch( pC->EncodingWidth )
            {
                case M4ENCODER_SQCIF_Width:
                case M4ENCODER_QCIF_Width:
                    if( ( pC->uiEncVideoBitrate <= M4ENCODER_k64_KBPS)
                        && (pC->EncodingVideoFramerate <= M4ENCODER_k15_FPS) )
                    {
                        pDSI[5] = 10;
                    }
                    else if( ( pC->uiEncVideoBitrate <= M4ENCODER_k128_KBPS)
                        && (pC->EncodingVideoFramerate <= M4ENCODER_k15_FPS) )
                    {
                        pDSI[5] = 45;
                    }
                    else if( ( pC->uiEncVideoBitrate <= M4ENCODER_k128_KBPS)
                        && (pC->EncodingVideoFramerate <= M4ENCODER_k30_FPS) )
                    {
                        pDSI[5] = 20;
                    }
                    else if( ( pC->uiEncVideoBitrate <= M4ENCODER_k384_KBPS)
                        && (pC->EncodingVideoFramerate <= M4ENCODER_k30_FPS) )
                    {
                        pDSI[5] = 30;
                    }
                    else if( ( pC->uiEncVideoBitrate
                        <= M4ENCODER_k800_KBPS/*2048*/)
                        && (pC->EncodingVideoFramerate <= M4ENCODER_k30_FPS) )
                    {
                        pDSI[5] = 40;
                    }
                    break;

                case M4ENCODER_CIF_Width:
                    if( ( pC->uiEncVideoBitrate <= M4ENCODER_k128_KBPS)
                        && (pC->EncodingVideoFramerate <= M4ENCODER_k15_FPS) )
                    {
                        pDSI[5] = 20;
                    }
                    else if( ( pC->uiEncVideoBitrate <= M4ENCODER_k384_KBPS)
                        && (pC->EncodingVideoFramerate <= M4ENCODER_k30_FPS) )
                    {
                        pDSI[5] = 30;
                    }
                    else if( ( pC->uiEncVideoBitrate
                        <= M4ENCODER_k800_KBPS/*2048*/)
                        && (pC->EncodingVideoFramerate <= M4ENCODER_k30_FPS) )
                    {
                        pDSI[5] = 40;
                    }
                    break;

                    default:
                    break;
            }

            /**
            * Profile is the seventh byte of the DSI. */
            pDSI[6] = 0;

            pC->WriterVideoStreamInfo.Header.pBuf = pDSI;
        }
        else if( M4ENCODER_kNULL == pC->EncodingVideoFormat )
        {
            /* If we copy the stream from the input, we copy its DSI */

            pC->WriterVideoStreamInfo.Header.Size = pC->pReaderVideoStream->
                m_basicProperties.m_decoderSpecificInfoSize;
            pC->WriterVideoStreamInfo.Header.pBuf =
                (M4OSA_MemAddr8)pC->pReaderVideoStream->
                m_basicProperties.m_pDecoderSpecificInfo;

        }
        /* otherwise (MPEG4), the DSI will be recovered from the encoder later on. */

        /*+CRLV6775 - H.264 Trimming  */
        if( pC->bH264Trim == M4OSA_TRUE )
        {
            bMULPPSSPS = M4OSA_TRUE;
            err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
                (M4OSA_UInt32)M4WRITER_kMUL_PPS_SPS,
                (M4OSA_DataOption) &bMULPPSSPS);

            if( ( M4NO_ERROR != err)
                && (( (M4OSA_UInt32)M4ERR_BAD_OPTION_ID)
                != err) ) /* this option may not be implemented by some writers */
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intPrepareWriter:\
                     pWriterGlobalFcts->pFctSetOption(M4WRITER_kMUL_PPS_SPS) returns 0x%x",
                    err);
                return err;
            }
        }
        /*-CRLV6775 - H.264 Trimming  */
        /**
        * Add the video stream */
        err = pC->pWriterGlobalFcts->pFctAddStream(pC->pWriterContext,
            &pC->WriterVideoStream);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareWriter: pWriterGlobalFcts->pFctAddStream(video) returns 0x%x!",
                err);
            return err;
        }

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

        /**
        * Set the writer max video AU size */
        optionValue.streamID = M4MCS_WRITER_VIDEO_STREAM_ID;
        optionValue.value = pC->uiVideoMaxAuSize;
        err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
            (M4OSA_UInt32)M4WRITER_kMaxAUSize,
            (M4OSA_DataOption) &optionValue);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareWriter: \
                pWriterGlobalFcts->pFctSetOption(M4WRITER_kMaxAUSize, video) returns 0x%x!",
                err);
            return err;
        }

        /**
        * Set the writer max video chunk size */
        optionValue.value = pC->uiVideoMaxChunckSize;
        err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
            (M4OSA_UInt32)M4WRITER_kMaxChunckSize,
            (M4OSA_DataOption) &optionValue);

        if( ( M4NO_ERROR != err) && (( (M4OSA_UInt32)M4ERR_BAD_OPTION_ID)
            != err) ) /* this option may not be implemented by some writers */
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareWriter:\
                 pWriterGlobalFcts->pFctSetOption(M4WRITER_kMaxAUSize, video) returns 0x%x!",
                err);
            return err;
        }
    }

    /**
    * If there is an audio input, allocate and fill the audio stream structures for the writer */
    if( pC->noaudio == M4OSA_FALSE )
    {
        M4WRITER_StreamAudioInfos streamAudioInfo;

        streamAudioInfo.nbSamplesPerSec = 0; /**< unused by our shell writer */
        streamAudioInfo.nbBitsPerSample = 0; /**< unused by our shell writer */
        streamAudioInfo.nbChannels = 1;      /**< unused by our shell writer */

        pC->WriterAudioStream.averageBitrate =
            0; /**< It is not used by the shell, the DSI is taken into account instead */
        pC->WriterAudioStream.maxBitrate =
            0; /**< Not used by the shell/core writer */

        /**
        * Fill Audio stream description structure for the AddStream method */
        switch( pC->AudioEncParams.Format )
        {
            case M4ENCODER_kAMRNB:
                pC->WriterAudioStream.streamType = M4SYS_kAMR;
                break;

            case M4ENCODER_kAAC:
                pC->WriterAudioStream.streamType = M4SYS_kAAC;
                pC->WriterAudioStream.averageBitrate =
                    pC->AudioEncParams.Bitrate;
                pC->WriterAudioStream.maxBitrate = pC->AudioEncParams.Bitrate;
                break;

                /*FlB 26.02.2009: add mp3 as output format*/
            case M4ENCODER_kMP3:
                pC->WriterAudioStream.streamType = M4SYS_kMP3;
                break;

            case M4ENCODER_kAudioNULL:
                switch( pC->InputFileProperties.AudioStreamType )
                {
                case M4VIDEOEDITING_kAMR_NB:
                    pC->WriterAudioStream.streamType = M4SYS_kAMR;
                    break;
                    /*FlB 26.02.2009: add mp3 as output format*/
                case M4VIDEOEDITING_kMP3:
                    pC->WriterAudioStream.streamType = M4SYS_kMP3;
                    break;

                case M4VIDEOEDITING_kAAC:
                case M4VIDEOEDITING_kAACplus:
                case M4VIDEOEDITING_keAACplus:
                    pC->WriterAudioStream.streamType = M4SYS_kAAC;
                    pC->WriterAudioStream.averageBitrate =
                        pC->AudioEncParams.Bitrate;
                    pC->WriterAudioStream.maxBitrate =
                        pC->AudioEncParams.Bitrate;
                    break;

                case M4VIDEOEDITING_kEVRC:
                    pC->WriterAudioStream.streamType = M4SYS_kEVRC;
                    break;

                case M4VIDEOEDITING_kNoneAudio:
                case M4VIDEOEDITING_kPCM:
                case M4VIDEOEDITING_kNullAudio:
                case M4VIDEOEDITING_kUnsupportedAudio:
                    break;
                }
                break;

            default: /**< It should never happen, already tested */
                M4OSA_TRACE1_1(
                    "M4MCS_intPrepareWriter: \
                    unknown format (0x%x), returning M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT",
                    pC->AudioEncParams.Format);
                return M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT;
        }

        /**
        * MCS produces only AMR-NB output */
        pC->WriterAudioStream.streamID = M4MCS_WRITER_AUDIO_STREAM_ID;
        pC->WriterAudioStream.duration =
            0; /**< Not used by the shell/core writer */
        pC->WriterAudioStream.profileLevel =
            0; /**< Not used by the shell/core writer */
        pC->WriterAudioStream.timeScale = pC->AudioEncParams.Frequency;

        if( pC->AudioEncParams.Format == M4ENCODER_kAudioNULL )
        {
            /* If we copy the stream from the input, we copy its DSI */
            streamAudioInfo.Header.Size = pC->pReaderAudioStream->
                m_basicProperties.m_decoderSpecificInfoSize;
            streamAudioInfo.Header.pBuf =
                (M4OSA_MemAddr8)pC->pReaderAudioStream->
                m_basicProperties.m_pDecoderSpecificInfo;
        }
        else
        {
            if( pC->pAudioEncDSI.pInfo != M4OSA_NULL )
            {
                /* Use the DSI given by the encoder open() */
                streamAudioInfo.Header.Size = pC->pAudioEncDSI.infoSize;
                streamAudioInfo.Header.pBuf = pC->pAudioEncDSI.pInfo;
            }
            else
            {
                /* Writer will put a default Philips DSI */
                streamAudioInfo.Header.Size = 0;
                streamAudioInfo.Header.pBuf = M4OSA_NULL;
            }
        }

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

        /**
        * Add the audio stream to the writer */
        err = pC->pWriterGlobalFcts->pFctAddStream(pC->pWriterContext,
            &pC->WriterAudioStream);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareWriter: pWriterGlobalFcts->pFctAddStream(audio) returns 0x%x",
                err);
            return err;
        }

        /**
        * Link the AU and the stream */
        pC->WriterAudioAU.stream = &(pC->WriterAudioStream);
        pC->WriterAudioAU.dataAddress = M4OSA_NULL;
        pC->WriterAudioAU.size = 0;
        pC->WriterAudioAU.CTS = 0; /** Reset time */
        pC->WriterAudioAU.DTS = 0;
        pC->WriterAudioAU.attribute = 0;
        pC->WriterAudioAU.nbFrag = 0; /** No fragment */
        pC->WriterAudioAU.frag = M4OSA_NULL;

        /**
        * Set the writer audio max AU size */
        /* As max bitrate is now 320kbps instead of 128kbps, max AU
         * size has to be increased adapt the max AU size according to the stream type and the
         * channels numbers*/
        /* After tests, a margin of 3 is taken (2 was not enough and raises to memory overwrite)
         */
        //pC->uiAudioMaxAuSize = M4MCS_AUDIO_MAX_AU_SIZE;
        switch( pC->WriterAudioStream.streamType )
        {
            case M4SYS_kAMR:
                pC->uiAudioMaxAuSize = M4MCS_PCM_AMR_GRANULARITY_SAMPLES
                    * (( pC->InputFileProperties.uiNbChannels
                    * sizeof(short)) + 3);
                break;

            case M4SYS_kMP3:
                pC->uiAudioMaxAuSize = M4MCS_PCM_MP3_GRANULARITY_SAMPLES
                    * (( pC->InputFileProperties.uiNbChannels
                    * sizeof(short)) + 3);
                break;

            case M4SYS_kAAC:
                pC->uiAudioMaxAuSize = M4MCS_PCM_AAC_GRANULARITY_SAMPLES
                    * (( pC->InputFileProperties.uiNbChannels
                    * sizeof(short)) + 3);
                break;
                /*case M4SYS_kEVRC:
                pC->uiAudioMaxAuSize = M4MCS_PCM_EVRC_GRANULARITY_SAMPLES*
                ((pC->InputFileProperties.uiNbChannels * sizeof(short))+3);
                break;*/
            default: /**< It should never happen, already tested */
                M4OSA_TRACE1_1(
                    "M4MCS_intPrepareWriter: unknown format (0x%x),\
                     returning M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT",
                    pC->WriterAudioStream.streamType);
                return M4MCS_ERR_UNDEFINED_OUTPUT_AUDIO_FORMAT;
        }

        optionValue.streamID = M4MCS_WRITER_AUDIO_STREAM_ID;
        optionValue.value = pC->uiAudioMaxAuSize;
        err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
            (M4OSA_UInt32)M4WRITER_kMaxAUSize,
            (M4OSA_DataOption) &optionValue);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareWriter: pWriterGlobalFcts->pFctSetOption(audio,\
                M4WRITER_kMaxAUSize) returns 0x%x",
                err);
            return err;
        }

        optionValue.value = M4MCS_AUDIO_MAX_CHUNK_SIZE;
        err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
            (M4OSA_UInt32)M4WRITER_kMaxChunckSize,
            (M4OSA_DataOption) &optionValue);

        if( ( M4NO_ERROR != err) && (( (M4OSA_UInt32)M4ERR_BAD_OPTION_ID)
            != err) ) /* this option may not be implemented by some writers */
        {
            M4OSA_TRACE1_1(
                "M4MCS_intPrepareWriter: pWriterGlobalFcts->pFctSetOption(audio,\
                M4WRITER_kMaxChunckSize) returns 0x%x",
                err);
            return err;
        }
    }

    /*
    * Set the limitation size of the writer */
    TargetedFileSize = pC->uiMaxFileSize;
    /* add 1 kB margin */
    if( TargetedFileSize > 8192 )
        TargetedFileSize -= 1024;

    err = pC->pWriterGlobalFcts->pFctSetOption(pC->pWriterContext,
        (M4OSA_UInt32)M4WRITER_kMaxFileSize,
        (M4OSA_DataOption) &TargetedFileSize);

    if( ( M4NO_ERROR != err) && (( (M4OSA_UInt32)M4ERR_BAD_OPTION_ID)
        != err) ) /* this option may not be implemented by some writers */
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareWriter: pWriterGlobalFcts->pFctSetOption\
            (M4WRITER_kMaxFileSize) returns 0x%x!",
            err);
        return err;
    }

    /**
    * Close the stream registering in order to be ready to write data */
    err = pC->pWriterGlobalFcts->pFctStartWriting(pC->pWriterContext);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareWriter: pWriterGlobalFcts->pFctStartWriting returns 0x%x",
            err);
        return err;
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intPrepareWriter(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intPrepareAudioBeginCut(M4MCS_InternalContext* pC);
 * @brief    DO the audio begin cut.
 * @param    pC          (IN) MCS private context
 * @return   M4NO_ERROR  No error
 * @return   Any error returned by an underlaying module
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intPrepareAudioBeginCut( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;
    M4OSA_Int32 iCts;
    M4OSA_UInt32 uiFrameSize;

    if( pC->noaudio )
        return M4NO_ERROR;

    /**
    * Check if an audio begin cut is needed */
    if( ( M4OSA_NULL == pC->pReaderAudioStream) || (0 == pC->uiBeginCutTime) )
    {
        /**
        * Return with no error */
        M4OSA_TRACE3_0(
            "M4MCS_intPrepareAudioBeginCut(): returning M4NO_ERROR (a)");
        return M4NO_ERROR;
    }

    /**
    * Jump at the begin cut time */
    iCts = pC->uiBeginCutTime;
    err = pC->m_pReader->m_pFctJump(pC->pReaderContext,
        (M4_StreamHandler *)pC->pReaderAudioStream, &iCts);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intPrepareAudioBeginCut: m_pFctJump(Audio) returns 0x%x!",
            err);
        return err;
    }

    /**
    * Remember audio begin cut offset */
    pC->iAudioCtsOffset = iCts;

    /**
    * AMR-NB & EVRC: there may be many frames per AU.
    * In that case we need to slice the first AU to keep the 20 ms cut precision */
    if( ( M4DA_StreamTypeAudioAmrNarrowBand
        == pC->pReaderAudioStream->m_basicProperties.m_streamType)
        || (M4DA_StreamTypeAudioEvrc
        == pC->pReaderAudioStream->m_basicProperties.m_streamType) )
    {
        /**
        * If the next frame CTS is lower than the begin cut time,
        * we must read the AU and parse its frames to reach the
        * nearest to the begin cut */
        if( ( iCts + 20) < (M4OSA_Int32)pC->uiBeginCutTime )
        {
            /**
            * Read the first audio AU after the jump */
            err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
                (M4_StreamHandler *)pC->pReaderAudioStream,
                &pC->ReaderAudioAU);

            if( M4WAR_NO_MORE_AU == err )
            {
                M4OSA_TRACE1_0(
                    "M4MCS_intPrepareAudioBeginCut(): m_pReaderDataIt->m_pFctGetNextAu(audio)\
                     returns M4WAR_NO_MORE_AU! Returning M4NO_ERROR");
                return
                    M4NO_ERROR; /**< no fatal error here, we should be able to pursue */
            }
            else if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intPrepareAudioBeginCut(): m_pReaderDataIt->m_pFctGetNextAu(Audio)\
                     returns 0x%x",
                    err);
                return err;
            }

            /**
            * While the next AU has a lower CTS than the begin cut time, we advance to
            the next frame */
            while( ( iCts + 20) <= (M4OSA_Int32)pC->uiBeginCutTime )
            {
                /**
                * Get the size of the frame */
                switch( pC->pReaderAudioStream->m_basicProperties.m_streamType )
                {
                    case M4DA_StreamTypeAudioAmrNarrowBand:
                        uiFrameSize = M4MCS_intGetFrameSize_AMRNB(
                            pC->ReaderAudioAU.m_dataAddress);
                        break;

                    case M4DA_StreamTypeAudioEvrc:
                        uiFrameSize = M4MCS_intGetFrameSize_EVRC(
                            pC->ReaderAudioAU.m_dataAddress);
                        break;

                    default:
                        uiFrameSize = 0;
                        break;
                }

                if( 0 == uiFrameSize )
                {
                    /**
                    * Corrupted frame! We get out of this mess!
                    * We don't want to crash here... */
                    M4OSA_TRACE1_0(
                        "M4MCS_intPrepareAudioBeginCut(): \
                        M4MCS_intGetFrameSize_xxx returns 0! Returning M4NO_ERROR");
                    return
                        M4NO_ERROR; /**< no fatal error here, we should be able to pursue */
                }

                /**
                * Go to the next frame */
                pC->ReaderAudioAU.m_dataAddress += uiFrameSize;
                pC->ReaderAudioAU.m_size -= uiFrameSize;

                /**
                * Get the CTS of the next frame */
                iCts += 20; /**< AMR, EVRC frame duration is always 20 ms */
                pC->ReaderAudioAU.m_CTS = iCts;
                pC->ReaderAudioAU.m_DTS = iCts;
            }

            /**
            * Update the audio begin cut offset */
            pC->iAudioCtsOffset = iCts;
        }
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intPrepareAudioBeginCut(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intStepEncoding(M4MCS_InternalContext* pC, M4OSA_UInt8* pProgress)
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intStepEncoding( M4MCS_InternalContext *pC,
                                       M4OSA_UInt8 *pProgress )
{
    M4OSA_ERR err;
    M4OSA_UInt32 uiAudioStepCount = 0;

    /* ---------- VIDEO TRANSCODING ---------- */

    if( ( pC->novideo == M4OSA_FALSE) && (M4MCS_kStreamState_STARTED
        == pC->VideoState) ) /**< If the video encoding is going on */
    {
        if( pC->EncodingVideoFormat == M4ENCODER_kNULL )
        {
            err = M4MCS_intVideoNullEncoding(pC);
        }
        else
        {
            err = M4MCS_intVideoTranscoding(pC);
        }

        /**
        * No more space, quit properly */
        if( M4WAR_WRITER_STOP_REQ == err )
        {
            *pProgress = (M4OSA_UInt8)(( ( (M4OSA_UInt32)pC->dViDecCurrentCts
                - pC->uiBeginCutTime) * 100)
                / (pC->uiEndCutTime - pC->uiBeginCutTime));

            pC->State = M4MCS_kState_FINISHED;

            /* bad file produced on very short 3gp file */
            if( pC->dViDecCurrentCts - pC->uiBeginCutTime == 0 )
            {
                /* Nothing has been encoded -> bad produced file -> error returned */
                M4OSA_TRACE2_0(
                    "M4MCS_intStepEncoding(): video transcoding returns\
                     M4MCS_ERR_OUTPUT_FILE_SIZE_TOO_SMALL");
                return M4MCS_ERR_OUTPUT_FILE_SIZE_TOO_SMALL;
            }
            else
            {
#ifndef M4MCS_AUDIOONLY
                /* clean AIR context needed to keep media aspect ratio*/

                if( M4OSA_NULL != pC->m_air_context )
                {
                    err = M4AIR_cleanUp(pC->m_air_context);

                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4xVSS_PictureCallbackFct: Error when cleaning AIR: 0x%x",
                            err);
                        return err;
                    }
                    pC->m_air_context = M4OSA_NULL;
                }

#endif /*M4MCS_AUDIOONLY*/

                M4OSA_TRACE2_0(
                    "M4MCS_intStepEncoding(): video transcoding returns M4MCS_ERR_NOMORE_SPACE");
                return M4MCS_ERR_NOMORE_SPACE;
            }
        }

        /**< The input plane is null because the input image will be obtained by the
        VPP filter from the context */
        if( ( M4NO_ERROR != err) && (M4WAR_NO_MORE_AU != err) )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intStepEncoding(): video transcoding returns 0x%x!",
                err);
            return err;
        }
    }

    /* ---------- AUDIO TRANSCODING ---------- */

    if( ( pC->noaudio == M4OSA_FALSE) && (M4MCS_kStreamState_STARTED
        == pC->AudioState) ) /**< If there is an audio stream */
    {
        while(
            /**< If the video encoding is running, encode audio until we reach video time */
            ( ( pC->novideo == M4OSA_FALSE)
            && (M4MCS_kStreamState_STARTED == pC->VideoState)
            && (pC->ReaderAudioAU.m_CTS
            + pC->m_audioAUDuration < pC->ReaderVideoAU.m_CTS)) ||
            /**< If the video encoding is not running, perform 1 step of audio encoding */
            (( M4MCS_kStreamState_STARTED == pC->AudioState)
            && (uiAudioStepCount < 1)) )
        {
            uiAudioStepCount++;

            /**< check if an adio effect has to be applied*/
            err = M4MCS_intCheckAudioEffects(pC);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intStepEncoding(): M4MCS_intCheckAudioEffects returns err: 0x%x",
                    err);
                return err;
            }

            if( pC->AudioEncParams.Format == M4ENCODER_kAudioNULL )
            {
                err = M4MCS_intAudioNullEncoding(pC);
            }
            else /**< Audio transcoding */
            {
                err = M4MCS_intAudioTranscoding(pC);
            }

            /**
            * No more space, quit properly */
            if( M4WAR_WRITER_STOP_REQ == err )
            {
                *pProgress =
                    (M4OSA_UInt8)(( ( (M4OSA_UInt32)pC->ReaderAudioAU.m_CTS
                    - pC->uiBeginCutTime) * 100)
                    / (pC->uiEndCutTime - pC->uiBeginCutTime));

                pC->State = M4MCS_kState_FINISHED;

                /* bad file produced on very short 3gp file */
                if( pC->ReaderAudioAU.m_CTS - pC->uiBeginCutTime == 0 )
                {
                    /* Nothing has been encoded -> bad produced file -> error returned */
                    M4OSA_TRACE2_0(
                        "M4MCS_intStepEncoding():\
                         audio transcoding returns M4MCS_ERR_OUTPUT_FILE_SIZE_TOO_SMALL");
                    return M4MCS_ERR_OUTPUT_FILE_SIZE_TOO_SMALL;
                }
                else
                {
#ifndef M4MCS_AUDIOONLY
                    /* clean AIR context needed to keep media aspect ratio*/

                    if( M4OSA_NULL != pC->m_air_context )
                    {
                        err = M4AIR_cleanUp(pC->m_air_context);

                        if( err != M4NO_ERROR )
                        {
                            M4OSA_TRACE1_1(
                                "M4xVSS_PictureCallbackFct: Error when cleaning AIR: 0x%x",
                                err);
                            return err;
                        }
                        pC->m_air_context = M4OSA_NULL;
                    }

#endif /*M4MCS_AUDIOONLY*/

                    M4OSA_TRACE2_0(
                        "M4MCS_intStepEncoding(): \
                        audio transcoding returns M4MCS_ERR_NOMORE_SPACE");
                    return M4MCS_ERR_NOMORE_SPACE;
                }
            }

            if( M4WAR_NO_MORE_AU == err )
            {
                pC->AudioState = M4MCS_kStreamState_FINISHED;
                M4OSA_TRACE3_0(
                    "M4MCS_intStepEncoding(): audio transcoding returns M4WAR_NO_MORE_AU");
                break;
            }
            else if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intStepEncoding(): audio transcoding returns 0x%x",
                    err);
                return err;
            }

            /**
            * Check for end cut */
            /* We absolutely want to have less or same audio duration as video ->
            (2*pC->m_audioAUDuration) */
            if( (M4OSA_UInt32)pC->ReaderAudioAU.m_CTS
                + (2 *pC->m_audioAUDuration) > pC->uiEndCutTime )
            {
                pC->AudioState = M4MCS_kStreamState_FINISHED;
                break;
            }
        }
    }

    /* ---------- PROGRESS MANAGEMENT ---------- */

    /**
    * Compute progress */
    if( pC->novideo )
    {
        if( pC->ReaderAudioAU.m_CTS < pC->uiBeginCutTime )
        {
            *pProgress = 0;
        }
        else
        {
            *pProgress = (M4OSA_UInt8)(( ( (M4OSA_UInt32)pC->ReaderAudioAU.m_CTS
                - pC->uiBeginCutTime) * 100)
                / (pC->uiEndCutTime - pC->uiBeginCutTime));
        }
        //printf(": %6.0f\b\b\b\b\b\b\b\b", pC->ReaderAudioAU.m_CTS);

    }
    else
    {
        if( pC->dViDecCurrentCts < pC->uiBeginCutTime )
        {
            *pProgress = 0;
        }
        else
        {
            *pProgress = (M4OSA_UInt8)(( ( (M4OSA_UInt32)pC->dViDecCurrentCts
                - pC->uiBeginCutTime) * 100)
                / (pC->uiEndCutTime - pC->uiBeginCutTime));
        }
        //printf(": %6.0f\b\b\b\b\b\b\b\b", pC->dViDecCurrentCts);
    }

    /**
    * Sanity check */
    if( *pProgress > 99 )
    {
        *pProgress = 99;
    }

    /**
    * Increment CTS for next step */
    if( pC->novideo == M4OSA_FALSE )
    {
        if( pC->EncodingVideoFormat == M4ENCODER_kNULL )
        {
           pC->dViDecCurrentCts +=  1;
        }
        else
        {
            pC->dViDecCurrentCts += pC->dCtsIncrement;
        }
    }

    /**
    * The transcoding is finished when no stream is being encoded anymore */
    if( ( ( pC->novideo) || (M4MCS_kStreamState_FINISHED == pC->VideoState))
        && (( pC->noaudio) || (M4MCS_kStreamState_FINISHED == pC->AudioState)) )
    {
        /* the AIR part can only be used when video codecs are compiled*/
#ifndef M4MCS_AUDIOONLY
        /* clean AIR context needed to keep media aspect ratio*/

        if( M4OSA_NULL != pC->m_air_context )
        {
            err = M4AIR_cleanUp(pC->m_air_context);

            if( err != M4NO_ERROR )
            {
                M4OSA_TRACE1_1(
                    "M4xVSS_PictureCallbackFct: Error when cleaning AIR: 0x%x",
                    err);
                return err;
            }
            pC->m_air_context = M4OSA_NULL;
        }

#endif /*M4MCS_AUDIOONLY*/
        /**/

        *pProgress = 100;
        pC->State = M4MCS_kState_FINISHED;
        M4OSA_TRACE2_0(
            "M4MCS_intStepEncoding(): transcoding finished, returning M4MCS_WAR_TRANSCODING_DONE");
        return M4MCS_WAR_TRANSCODING_DONE;
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intStepEncoding(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intStepBeginVideoJump(M4MCS_InternalContext* pC)
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intStepBeginVideoJump( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;
    M4OSA_Int32 iCts;

    if( pC->novideo )
    {
        pC->State = M4MCS_kState_BEGINVIDEODECODE;
        return M4NO_ERROR;
    }

    /**
    * Jump to the previous RAP in the clip (first get the time, then jump) */
    iCts = (M4OSA_Int32)pC->dViDecStartingCts;
    err = pC->m_pReader->m_pFctGetPrevRapTime(pC->pReaderContext,
        (M4_StreamHandler *)pC->pReaderVideoStream, &iCts);

    if( M4WAR_READER_INFORMATION_NOT_PRESENT == err )
    {
        /* No RAP table, jump backward and predecode */
        iCts = (M4OSA_Int32)pC->dViDecStartingCts - M4MCS_NO_STSS_JUMP_POINT;

        if( iCts < 0 )
            iCts = 0;
    }
    else if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepBeginVideoJump: m_pFctGetPrevRapTime returns 0x%x!",
            err);
        return err;
    }

    /* + CRLV6775 -H.264 Trimming */

    if( M4OSA_TRUE == pC->bH264Trim )
    {

        // Save jump time for safety, this fix should be generic

        M4OSA_Int32 iCtsOri = iCts;


        err = pC->m_pReader->m_pFctJump(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream, &iCts);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intStepBeginVideoJump: m_pFctJump(V) returns 0x%x!",
                err);
            return err;
        }

        if( pC->ReaderVideoAU1.m_structSize == 0 )
        {
            /**
            * Initializes an access Unit */
            err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext,
                (M4_StreamHandler *)pC->pReaderVideoStream,
                &pC->ReaderVideoAU1);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_open(): m_pReader->m_pFctFillAuStruct(video) returns 0x%x",
                    err);
                return err;
            }
            err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
                (M4_StreamHandler *)pC->pReaderVideoStream,
                &pC->ReaderVideoAU1);

            if( M4WAR_NO_MORE_AU == err )
            {
                M4OSA_TRACE2_0(
                    "M4MCS_intVideoNullEncoding(): \
                    m_pReaderDataIt->m_pFctGetNextAu(video) returns M4WAR_NO_MORE_AU");
                /* The audio transcoding is finished */
                pC->VideoState = M4MCS_kStreamState_FINISHED;
                return err;
            }
            else if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intVideoNullEncoding():\
                     m_pReaderDataIt->m_pFctGetNextAu(video) returns 0x%x",
                    err);
                return err;
            }

            pC->ReaderVideoAU1.m_structSize = 0;
        }

        err = H264MCS_ProcessSPS_PPS(pC->m_pInstance,
            (M4OSA_UInt8 *)pC->ReaderVideoAU1.m_dataAddress, pC->ReaderVideoAU1.m_size);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intStepBeginVideoJump: H264MCS_ProcessSPS_PPS returns 0x%x!",
                err);
            return err;
        }


        // Restore jump time for safety, this fix should be generic

        iCts = iCtsOri;


    }
    /* - CRLV6775 -H.264 Trimming */
    err = pC->m_pReader->m_pFctJump(pC->pReaderContext,
        (M4_StreamHandler *)pC->pReaderVideoStream, &iCts);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepBeginVideoJump: m_pFctJump(V) returns 0x%x!", err);
        return err;
    }

    /**
    * Decode one step */
    pC->dViDecCurrentCts = (M4OSA_Double)(iCts + pC->iVideoBeginDecIncr);

    /**
    * Be sure we don't decode too far */
    if( pC->dViDecCurrentCts > pC->dViDecStartingCts )
    {
        pC->dViDecCurrentCts = pC->dViDecStartingCts;
    }

    /**
    * Decode at least once with the bJump flag to true */
    M4OSA_TRACE3_1(
        "M4VSS3GPP_intClipDecodeVideoUpToCts: Decoding upTo CTS %.3f",
        pC->dViDecCurrentCts);
    pC->isRenderDup = M4OSA_FALSE;
    err =
        pC->m_pVideoDecoder->m_pFctDecode(pC->pViDecCtxt, &pC->dViDecCurrentCts,
        M4OSA_TRUE);

    if( ( M4NO_ERROR != err) && (M4WAR_NO_MORE_AU != err)
        && (err != M4WAR_VIDEORENDERER_NO_NEW_FRAME) )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepBeginVideoJump: m_pFctDecode returns 0x%x!", err);
        return err;
    }

    if( err == M4WAR_VIDEORENDERER_NO_NEW_FRAME )
    {
        M4OSA_TRACE2_0("Decoding output the same frame as before 1");
        pC->isRenderDup = M4OSA_TRUE;
    }

    /**
    * Increment decoding cts for the next step */
    pC->dViDecCurrentCts += (M4OSA_Double)pC->iVideoBeginDecIncr;

    /**
    * Update state automaton */
    if( pC->dViDecCurrentCts > pC->dViDecStartingCts )
    {
        /**
        * Be sure we don't decode too far */
        pC->dViDecCurrentCts = pC->dViDecStartingCts;
        pC->State = M4MCS_kState_PROCESSING;
    }
    else
    {
        pC->State = M4MCS_kState_BEGINVIDEODECODE;
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intStepBeginVideoJump(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intStepBeginVideoDecode(M4MCS_InternalContext* pC)
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intStepBeginVideoDecode( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;
    M4_MediaTime dDecTarget;

    if( pC->novideo )
    {
        pC->State = M4MCS_kState_PROCESSING;
        return M4NO_ERROR;
    }

    /**
    * Decode */
    dDecTarget = pC->dViDecCurrentCts;
    M4OSA_TRACE3_1("M4MCS_intStepBeginDecode: Decoding upTo CTS %.3f",
        pC->dViDecCurrentCts);
    pC->isRenderDup = M4OSA_FALSE;
    err = pC->m_pVideoDecoder->m_pFctDecode(pC->pViDecCtxt, &dDecTarget,
        M4OSA_FALSE);

    if( ( M4NO_ERROR != err) && (M4WAR_NO_MORE_AU != err)
        && (err != M4WAR_VIDEORENDERER_NO_NEW_FRAME) )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intStepBeginVideoDecode: m_pFctDecode returns 0x%x!", err);
        return err;
    }

    if( err == M4WAR_VIDEORENDERER_NO_NEW_FRAME )
    {
        M4OSA_TRACE2_0("Decoding output the same frame as before 2");
        pC->isRenderDup = M4OSA_TRUE;
    }

    /**
    * Increment decoding cts for the next step */
    pC->dViDecCurrentCts += (M4OSA_Double)pC->iVideoBeginDecIncr;

    /**
    * Update state automaton, if needed */
    if( ( (M4OSA_UInt32)pC->dViDecCurrentCts > pC->dViDecStartingCts)
        || (M4WAR_NO_MORE_AU == err) )
    {
        /**
        * Be sure we don't decode too far */
        pC->dViDecCurrentCts = (M4OSA_Double)pC->dViDecStartingCts;
        pC->State = M4MCS_kState_PROCESSING;
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intStepBeginVideoDecode(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/*****************************/
/* define AMR silence frames */
/*****************************/

#define M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE 13
#define M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_DURATION 160

#ifdef M4VSS3GPP_SILENCE_FRAMES

const M4OSA_UInt8 M4VSS3GPP_AMR_AU_SILENCE_FRAME_048[
    M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE] =
    {
        0x04, 0xFF, 0x18, 0xC7, 0xF0, 0x0D, 0x04, 0x33, 0xFF, 0xE0, 0x00, 0x00, 0x00
    };
#else

extern
const
M4OSA_UInt8
M4VSS3GPP_AMR_AU_SILENCE_FRAME_048[M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE];

#endif

/*****************************/
/* define AAC silence frames */
/*****************************/

#define M4VSS3GPP_AAC_AU_SILENCE_MONO_SIZE      4

#ifdef M4VSS3GPP_SILENCE_FRAMES

const M4OSA_UInt8 M4VSS3GPP_AAC_AU_SILENCE_MONO[
    M4VSS3GPP_AAC_AU_SILENCE_MONO_SIZE] =
    {
        0x00, 0xC8, 0x20, 0x07
    };
#else

extern const M4OSA_UInt8
M4VSS3GPP_AAC_AU_SILENCE_MONO[M4VSS3GPP_AAC_AU_SILENCE_MONO_SIZE];

#endif

#define M4VSS3GPP_AAC_AU_SILENCE_STEREO_SIZE        6

#ifdef M4VSS3GPP_SILENCE_FRAMES

const M4OSA_UInt8 M4VSS3GPP_AAC_AU_SILENCE_STEREO[
    M4VSS3GPP_AAC_AU_SILENCE_STEREO_SIZE] =
    {
        0x21, 0x10, 0x03, 0x20, 0x54, 0x1C
    };
#else

extern const
M4OSA_UInt8
M4VSS3GPP_AAC_AU_SILENCE_STEREO[M4VSS3GPP_AAC_AU_SILENCE_STEREO_SIZE];

#endif

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intAudioNullEncoding(M4MCS_InternalContext* pC)
 * @return   M4NO_ERROR:         No error
 ******************************************************************************
 */

static M4OSA_ERR M4MCS_intAudioNullEncoding( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;

    if( pC->noaudio )
        return M4NO_ERROR;

    /* Check if all audio frame has been written (happens at begin cut) */
    if( pC->ReaderAudioAU.m_size == 0 )
    {
        /**
        * Initializes a new AU if needed */
        if( pC->ReaderAudioAU1.m_structSize == 0 )
        {
            /**
            * Initializes an access Unit */
            err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext,
                (M4_StreamHandler *)pC->pReaderAudioStream,
                &pC->ReaderAudioAU1);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_open(): m_pReader->m_pFctFillAuStruct(audio) returns 0x%x",
                    err);
                return err;
            }

            pC->m_pDataAddress1 =
                (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->ReaderAudioAU1.m_maxsize,
                M4MCS, (M4OSA_Char *)"Temporary AU1 buffer");

            if( pC->m_pDataAddress1 == M4OSA_NULL )
            {
                M4OSA_TRACE1_0(
                    "M4MCS_intAudioNullEncoding(): allocation error");
                return M4ERR_ALLOC;
            }

            err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
                (M4_StreamHandler *)pC->pReaderAudioStream,
                &pC->ReaderAudioAU1);

            if( M4WAR_NO_MORE_AU == err )
            {
                M4OSA_TRACE2_0(
                    "M4MCS_intAudioNullEncoding():\
                     m_pReaderDataIt->m_pFctGetNextAu(audio) returns M4WAR_NO_MORE_AU");
                /* The audio transcoding is finished */
                pC->AudioState = M4MCS_kStreamState_FINISHED;
                return err;
            }
            else if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intAudioNullEncoding(): \
                    m_pReaderDataIt->m_pFctGetNextAu(Audio) returns 0x%x",
                    err);
                return err;
            }
            /*FB 2009.04.02: PR surnxp#616: Crash in MCS while Audio AU copying ,
             constant memory reader case*/
            if( pC->ReaderAudioAU1.m_maxsize
        > pC->pReaderAudioStream->m_basicProperties.m_maxAUSize )
            {
                /* Constant memory reader case, we need to reallocate the temporary buffers */
                M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                    *) &(pC->m_pDataAddress1), pC->ReaderAudioAU1.m_maxsize);
                /* pC->m_pDataAddress1 and
                pC->m_pDataAddress2 must be reallocated at the same time */
                /* because pC->pReaderAudioStream->m_basicProperties.m_maxAUSize take
                 maximum value. Then the test "if(pC->ReaderAudioAU?.m_maxsize >
                  pC->pReaderAudioStream->m_basicProperties.m_maxAUSize)" is never true */
                /* and the size of the second buffer is never changed. */
                M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                    *) &(pC->m_pDataAddress2), pC->ReaderAudioAU1.m_maxsize);
                /* pC->m_pDataAddress1 and
                pC->m_pDataAddress2 must be reallocated at the same time */
                /* Update stream properties */
                pC->pReaderAudioStream->m_basicProperties.m_maxAUSize =
                    pC->ReaderAudioAU1.m_maxsize;
            }
            /**/
            memcpy((void *)pC->m_pDataAddress1,
                (void *)pC->ReaderAudioAU1.m_dataAddress,
                pC->ReaderAudioAU1.m_size);
        }

        if( pC->ReaderAudioAU2.m_structSize == 0 )
        {
            /**
            * Initializes an access Unit */
            err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext,
                (M4_StreamHandler *)pC->pReaderAudioStream,
                &pC->ReaderAudioAU2);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_open(): m_pReader->m_pFctFillAuStruct(audio) returns 0x%x",
                    err);
                return err;
            }
            pC->m_pDataAddress2 =
                (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->ReaderAudioAU2.m_maxsize,
                M4MCS, (M4OSA_Char *)"Temporary AU buffer");

            if( pC->m_pDataAddress2 == M4OSA_NULL )
            {
                M4OSA_TRACE1_0(
                    "M4MCS_intAudioNullEncoding(): allocation error");
                return M4ERR_ALLOC;
            }
        }
        /**
        * Read the next audio AU in the input file */
        if( pC->ReaderAudioAU2.m_CTS > pC->ReaderAudioAU1.m_CTS )
        {
            memcpy((void *) &pC->ReaderAudioAU,
                (void *) &pC->ReaderAudioAU2, sizeof(M4_AccessUnit));
            err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
                (M4_StreamHandler *)pC->pReaderAudioStream,
                &pC->ReaderAudioAU1);

            if( pC->ReaderAudioAU1.m_maxsize
                > pC->pReaderAudioStream->m_basicProperties.m_maxAUSize )
            {
                /* Constant memory reader case, we need to reallocate the temporary buffers */
                M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                    *) &(pC->m_pDataAddress1), pC->ReaderAudioAU1.m_maxsize);
                /*   pC->m_pDataAddress1
                 * and pC->m_pDataAddress2 must be reallocated at the same time *
                 * because pC->pReaderAudioStream->m_basicProperties.m_maxAUSize take
                 * maximum value. Then the test "if(pC->ReaderAudioAU?.m_maxsize >
                 * pC->pReaderAudioStream->m_basicProperties.m_maxAUSize)" is never true *
                 * and the size of the second buffer is never changed.
                 */
                M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                    *) &(pC->m_pDataAddress2), pC->ReaderAudioAU1.m_maxsize);
                /* pC->m_pDataAddress1 and
                 * pC->m_pDataAddress2 must be reallocated at the same time
                 * Update stream properties
                 */
                pC->pReaderAudioStream->m_basicProperties.m_maxAUSize =
                    pC->ReaderAudioAU1.m_maxsize;
            }
            /**/
            memcpy((void *)pC->m_pDataAddress1,
                (void *)pC->ReaderAudioAU1.m_dataAddress,
                pC->ReaderAudioAU1.m_size);
            pC->m_audioAUDuration =
                pC->ReaderAudioAU1.m_CTS - pC->ReaderAudioAU2.m_CTS;
            pC->ReaderAudioAU.m_dataAddress = pC->m_pDataAddress2;
        }
        else
        {
            memcpy((void *) &pC->ReaderAudioAU,
                (void *) &pC->ReaderAudioAU1, sizeof(M4_AccessUnit));
            err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
                (M4_StreamHandler *)pC->pReaderAudioStream,
                &pC->ReaderAudioAU2);
            /* Crash in MCS while Audio AU copying ,
             * constant memory reader case
             */
            if( pC->ReaderAudioAU2.m_maxsize
                > pC->pReaderAudioStream->m_basicProperties.m_maxAUSize )
            {
                /* Constant memory reader case, we need to reallocate the temporary buffers */
                M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                    *) &(pC->m_pDataAddress2), pC->ReaderAudioAU2.m_maxsize);
                /* pC->m_pDataAddress1 and
                 * pC->m_pDataAddress2 must be reallocated at the same time
                 * because pC->pReaderAudioStream->m_basicProperties.m_maxAUSize take maximum
                 * value. Then the test "if(pC->ReaderAudioAU?.m_maxsize > pC->pReaderAudioStream->
                 * m_basicProperties.m_maxAUSize)" is never true
                 * and the size of the second buffer is never changed.
                 */
                M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                    *) &(pC->m_pDataAddress1), pC->ReaderAudioAU2.m_maxsize);
                /* [ END ] 20091008  JFV PR fix surnxpsw#1071: pC->m_pDataAddress1 and
                 pC->m_pDataAddress2 must be reallocated at the same time */
                /* Update stream properties */
                pC->pReaderAudioStream->m_basicProperties.m_maxAUSize =
                    pC->ReaderAudioAU2.m_maxsize;
            }
            /**/
            memcpy((void *)pC->m_pDataAddress2,
                (void *)pC->ReaderAudioAU2.m_dataAddress,
                pC->ReaderAudioAU2.m_size);
            pC->m_audioAUDuration =
                pC->ReaderAudioAU2.m_CTS - pC->ReaderAudioAU1.m_CTS;
            pC->ReaderAudioAU.m_dataAddress = pC->m_pDataAddress1;
        }

        if( M4WAR_NO_MORE_AU == err )
        {
            M4OSA_TRACE2_0(
                "M4MCS_intAudioNullEncoding(): \
                m_pReaderDataIt->m_pFctGetNextAu(audio) returns M4WAR_NO_MORE_AU");
            /* The audio transcoding is finished */
            pC->AudioState = M4MCS_kStreamState_FINISHED;
            return err;
        }
        else if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intAudioNullEncoding(): \
                m_pReaderDataIt->m_pFctGetNextAu(Audio) returns 0x%x",
                err);
            return err;
        }
    }

    /**
    * Prepare the writer AU */
    err = pC->pWriterDataFcts->pStartAU(pC->pWriterContext,
        M4MCS_WRITER_AUDIO_STREAM_ID, &pC->WriterAudioAU);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intAudioNullEncoding(): pWriterDataFcts->pStartAU(Audio) returns 0x%x",
            err);
        return err;
    }

    if( pC->uiAudioAUCount
        == 0 ) /* If it is the first AU, we set it to silence
        (else, errors 0x3841, 0x3847 in our AAC decoder) */
    {
        if( pC->InputFileProperties.AudioStreamType == M4VIDEOEDITING_kAAC
            || pC->InputFileProperties.AudioStreamType
            == M4VIDEOEDITING_kAACplus
            || pC->InputFileProperties.AudioStreamType
            == M4VIDEOEDITING_keAACplus )
        {
            if( pC->InputFileProperties.uiNbChannels == 1 )
            {
                pC->WriterAudioAU.size = M4VSS3GPP_AAC_AU_SILENCE_MONO_SIZE;
                memcpy((void *)pC->WriterAudioAU.dataAddress,
                    (void *)M4VSS3GPP_AAC_AU_SILENCE_MONO,
                    pC->WriterAudioAU.size);
            }
            else if( pC->InputFileProperties.uiNbChannels == 2 )
            {
                pC->WriterAudioAU.size = M4VSS3GPP_AAC_AU_SILENCE_STEREO_SIZE;
                memcpy((void *)pC->WriterAudioAU.dataAddress,
                    (void *)M4VSS3GPP_AAC_AU_SILENCE_STEREO,
                    pC->WriterAudioAU.size);
            }
            else
            {
                /* Must never happen ...*/
                M4OSA_TRACE1_0(
                    "M4MCS_intAudioNullEncoding: Bad number of channels in audio input");
                return M4MCS_ERR_INVALID_INPUT_FILE;
            }
        }
        else if( pC->InputFileProperties.AudioStreamType
            == M4VIDEOEDITING_kAMR_NB )
        {
            pC->WriterAudioAU.size = M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE;
            memcpy((void *)pC->WriterAudioAU.dataAddress,
                (void *)M4VSS3GPP_AMR_AU_SILENCE_FRAME_048,
                pC->WriterAudioAU.size);
            /* Some remaining AMR AU needs to be copied */
            if( pC->ReaderAudioAU.m_size != 0 )
            {
                /* Update Writer AU */
                pC->WriterAudioAU.size += pC->ReaderAudioAU.m_size;
                memcpy((void *)(pC->WriterAudioAU.dataAddress
                    + M4VSS3GPP_AMR_AU_SILENCE_FRAME_048_SIZE),
                    (void *)pC->ReaderAudioAU.m_dataAddress,
                    pC->ReaderAudioAU.m_size);
            }
        }
        else
        {
            /*MP3 case: copy the AU*/
            M4OSA_TRACE3_1(
                "M4MCS_intAudioNullEncoding(): Copying audio AU: size=%d",
                pC->ReaderAudioAU.m_size);
            memcpy((void *)pC->WriterAudioAU.dataAddress,
                (void *)pC->ReaderAudioAU.m_dataAddress,
                pC->ReaderAudioAU.m_size);
            pC->WriterAudioAU.size = pC->ReaderAudioAU.m_size;
        }
    }
    else
    {
        /**
        * Copy audio data from reader AU to writer AU */
        M4OSA_TRACE3_1(
            "M4MCS_intAudioNullEncoding(): Copying audio AU: size=%d",
            pC->ReaderAudioAU.m_size);
        memcpy((void *)pC->WriterAudioAU.dataAddress,
            (void *)pC->ReaderAudioAU.m_dataAddress,
            pC->ReaderAudioAU.m_size);
        pC->WriterAudioAU.size = pC->ReaderAudioAU.m_size;
    }

    /**
    * Convert CTS unit from milliseconds to timescale */
    pC->WriterAudioAU.CTS =
        (M4OSA_Time)((( pC->ReaderAudioAU.m_CTS - pC->iAudioCtsOffset)
        * (pC->WriterAudioStream.timeScale / 1000.0)));

    if( pC->InputFileProperties.AudioStreamType == M4VIDEOEDITING_kAMR_NB
        && pC->uiAudioAUCount == 0 )
    {
        pC->iAudioCtsOffset -=
            20; /* Duration of a silence AMR AU, to handle the duration of the added
                silence frame */
    }
    pC->WriterAudioAU.nbFrag = 0;
    M4OSA_TRACE3_1("M4MCS_intAudioNullEncoding(): audio AU: CTS=%d ms",
        pC->WriterAudioAU.CTS);

    /**
    * Write it to the output file */
    pC->uiAudioAUCount++;
    err = pC->pWriterDataFcts->pProcessAU(pC->pWriterContext,
        M4MCS_WRITER_AUDIO_STREAM_ID, &pC->WriterAudioAU);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intAudioNullEncoding(): pWriterDataFcts->pProcessAU(Audio) returns 0x%x",
            err);
        return err;
    }

    /* All the audio has been written */
    pC->ReaderAudioAU.m_size = 0;

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intAudioNullEncoding(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * @brief    Init Audio Transcoding
 * @return   M4NO_ERROR:         No error
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intAudioTranscoding( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err;                        /**< General error */

    M4OSA_UInt32
        uiBytesDec; /**< Nb of bytes available in the decoder OUT buffer */
    M4OSA_UInt32
        uiDecoder2Ssrc_NbBytes; /**< Nb of bytes copied into the ssrc IN buffer */

    int ssrcErr;                          /**< Error while ssrc processing */
    M4OSA_UInt32 uiSsrcInSize; /**< Size in bytes of ssrc intput buffer */
    M4OSA_UInt32
        uiSsrcInRoom; /**< Nb of bytes available in the ssrc IN buffer */
    M4OSA_MemAddr8
        pSsrcInput; /**< Pointer to the good buffer location for ssrc input */
    M4OSA_UInt32 uiSsrcOutSize; /**< Size in bytes of ssrc output buffer */
    M4OSA_UInt32
        uiBytesSsrc; /**< Nb of bytes available in the ssrc OUT buffer */

    M4OSA_UInt8
        needChannelConversion; /**< Flag to indicate if a stereo <-> mono conversion is needed */
    M4OSA_UInt32
        uiChannelConvertorCoeff; /**< Multiplicative coefficient if stereo
                                    <-> mono conversion is applied */
    M4OSA_MemAddr8 pChannelConvertorInput =
        M4OSA_NULL; /**< Pointer to the good buffer location for channel convertor input */
    M4OSA_UInt32 uiChannelConvertorNbSamples =
        0; /**< Nb of pcm samples to convert in channel convertor */
    M4OSA_MemAddr8 pChannelConvertorOutput =
        M4OSA_NULL; /**< Pointer to the good buffer location for channel convertor output */

    M4OSA_Time
        frameTimeDelta; /**< Duration of the encoded (then written) data */
    M4OSA_UInt32
        uiEncoderInRoom; /**< Nb of bytes available in the encoder IN buffer */
    M4OSA_UInt32
        uiSsrc2Encoder_NbBytes; /**< Nb of bytes copied from the ssrc OUT buffer */
    M4OSA_MemAddr8
        pEncoderInput; /**< Pointer to the good buffer location for encoder input */
    M4ENCODER_AudioBuffer pEncInBuffer;   /**< Encoder input buffer for api */
    M4ENCODER_AudioBuffer pEncOutBuffer;  /**< Encoder output buffer for api */

    M4OSA_Int16 *tempBuffOut = M4OSA_NULL;
    /*FlB 2009.03.04: apply audio effects if an effect is active*/
    M4OSA_Int8 *pActiveEffectNumber = &(pC->pActiveEffectNumber);

    uint32_t errCode = M4NO_ERROR;

    if( pC->noaudio )
        return M4NO_ERROR;

    /* _________________ */
    /*|                 |*/
    /*| READ AND DECODE |*/
    /*|_________________|*/

    /* Check if we have to empty the decoder out buffer first */
    if( M4OSA_NULL != pC->pPosInDecBufferOut )
    {
        goto m4mcs_intaudiotranscoding_feed_resampler;
    }

    err = pC->m_pAudioDecoder->m_pFctStepAudioDec(pC->pAudioDecCtxt,
        M4OSA_NULL, &pC->AudioDecBufferOut, M4OSA_FALSE);


    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intAudioTranscoding(): m_pAudioDecoder->m_pFctStepAudio returns 0x%x",
            err);
        return err;
    }

#ifdef MCS_DUMP_PCM_TO_FILE

    fwrite(pC->AudioDecBufferOut.m_dataAddress,
        pC->AudioDecBufferOut.m_bufferSize, 1, file_pcm_decoder);

#endif

    pC->m_pAudioDecoder->m_pFctGetOptionAudioDec(pC->pAudioDecCtxt,
           M4AD_kOptionID_GetAudioAUErrCode, (M4OSA_DataOption) &errCode);

    if ( M4WAR_NO_MORE_AU == errCode ) {
        pC->AudioState = M4MCS_kStreamState_FINISHED;
            M4OSA_TRACE2_0(
                "M4MCS_intAudioTranscoding():\
                 m_pReaderDataIt->m_pFctGetNextAu(audio) returns M4WAR_NO_MORE_AU");
            return errCode;
   }

    /* Set the current position in the decoder out buffer */
    pC->pPosInDecBufferOut = pC->AudioDecBufferOut.m_dataAddress;

    /* ________________ */
    /*|                |*/
    /*| FEED RESAMPLER |*/
    /*|________________|*/

m4mcs_intaudiotranscoding_feed_resampler:

    /* Check if we have to empty the ssrc out buffer first */
    if( M4OSA_NULL != pC->pPosInSsrcBufferOut )
    {
        goto m4mcs_intaudiotranscoding_prepare_input_buffer;
    }

    /* Compute number of bytes remaining in the decoder buffer */
    uiSsrcInSize = pC->iSsrcNbSamplIn * sizeof(short)
        * pC->pReaderAudioStream->m_nbChannels;
    uiBytesDec = ( pC->AudioDecBufferOut.m_dataAddress
        + pC->AudioDecBufferOut.m_bufferSize) - pC->pPosInDecBufferOut;

    /* Check if we can feed directly the Ssrc with the decoder out buffer */
    if( ( pC->pPosInSsrcBufferIn == pC->pSsrcBufferIn)
        && (uiBytesDec >= uiSsrcInSize) )
    {
        pSsrcInput = pC->pPosInDecBufferOut;

        /* update data consumed into decoder buffer after resampling */
        if( uiBytesDec == uiSsrcInSize )
            pC->pPosInDecBufferOut = M4OSA_NULL;
        else
            pC->pPosInDecBufferOut += uiSsrcInSize;

        goto m4mcs_intaudiotranscoding_do_resampling;
    }

    /**
    * Compute remaining space in Ssrc buffer in */
    uiSsrcInRoom = ( pC->pSsrcBufferIn + uiSsrcInSize) - pC->pPosInSsrcBufferIn;

    /**
    * Nb of bytes copied is the minimum between nb of bytes remaining in
    * decoder out buffer and space remaining in ssrc in buffer */
    uiDecoder2Ssrc_NbBytes =
        (uiSsrcInRoom < uiBytesDec) ? uiSsrcInRoom : uiBytesDec;

    /**
    * Copy from the decoder out buffer into the Ssrc in buffer */
    memcpy((void *)pC->pPosInSsrcBufferIn, (void *)pC->pPosInDecBufferOut,
        uiDecoder2Ssrc_NbBytes);

    /**
    * Update the position in the decoder out buffer */
    pC->pPosInDecBufferOut += uiDecoder2Ssrc_NbBytes;

    /**
    * Update the position in the Ssrc in buffer */
    pC->pPosInSsrcBufferIn += uiDecoder2Ssrc_NbBytes;

    /**
    * Check if the decoder buffer out is empty */
    if( ( pC->pPosInDecBufferOut - pC->AudioDecBufferOut.m_dataAddress)
        == (M4OSA_Int32)pC->AudioDecBufferOut.m_bufferSize )
    {
        pC->pPosInDecBufferOut = M4OSA_NULL;
    }

    /* Check if the Ssrc in buffer is ready (= full) */
    if( ( pC->pPosInSsrcBufferIn - pC->pSsrcBufferIn)
        < (M4OSA_Int32)uiSsrcInSize )
    {
        goto m4mcs_intaudiotranscoding_end;
    }

    pSsrcInput = pC->pSsrcBufferIn;

    /* update data consumed into ssrc buffer in after resampling (empty) */
    pC->pPosInSsrcBufferIn = pC->pSsrcBufferIn;

    /* ___________________ */
    /*|                   |*/
    /*| DO THE RESAMPLING |*/
    /*|___________________|*/

m4mcs_intaudiotranscoding_do_resampling:

    /**
    * No need for memcopy, we can feed Ssrc directly with the data in the audio
    decoder out buffer*/

    ssrcErr = 0;

    if( pC->pReaderAudioStream->m_nbChannels == 1 )
    {
        tempBuffOut =
            (short *)M4OSA_32bitAlignedMalloc((pC->iSsrcNbSamplOut * sizeof(short) * 2
            * ((*pC).InputFileProperties).uiNbChannels),
            M4VSS3GPP,(M4OSA_Char *) "tempBuffOut");
        memset((void *)tempBuffOut, 0,(pC->iSsrcNbSamplOut * sizeof(short) * 2
            * ((*pC).InputFileProperties).uiNbChannels));

        LVAudioresample_LowQuality((short *)tempBuffOut, (short *)pSsrcInput,
            pC->iSsrcNbSamplOut, pC->pLVAudioResampler);
    }
    else
    {
        memset((void *)pC->pSsrcBufferOut, 0, (pC->iSsrcNbSamplOut * sizeof(short)
            * ((*pC).InputFileProperties).uiNbChannels));

        LVAudioresample_LowQuality((short *)pC->pSsrcBufferOut,
            (short *)pSsrcInput, pC->iSsrcNbSamplOut, pC->pLVAudioResampler);
    }

    if( pC->pReaderAudioStream->m_nbChannels == 1 )
    {
        From2iToMono_16((short *)tempBuffOut, (short *)pC->pSsrcBufferOut,
            (short)pC->iSsrcNbSamplOut);
        free(tempBuffOut);
    }


    if( 0 != ssrcErr )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intAudioTranscoding: SSRC_Process returns 0x%x, \
            returning M4MCS_ERR_AUDIO_CONVERSION_FAILED",
            ssrcErr);
        return M4MCS_ERR_AUDIO_CONVERSION_FAILED;
    }

    pC->pPosInSsrcBufferOut = pC->pSsrcBufferOut;

    /* ______________________ */
    /*|                      |*/
    /*| PREPARE INPUT BUFFER |*/
    /*|______________________|*/

m4mcs_intaudiotranscoding_prepare_input_buffer:

    /* Set the flag for channel conversion requirement */
    if( ( pC->AudioEncParams.ChannelNum == M4ENCODER_kMono)
        && (pC->pReaderAudioStream->m_nbChannels == 2) )
    {
        needChannelConversion = 1;
        uiChannelConvertorCoeff = 4;
    }
    else if( ( pC->AudioEncParams.ChannelNum == M4ENCODER_kStereo)
        && (pC->pReaderAudioStream->m_nbChannels == 1) )
    {
        needChannelConversion = 2;
        uiChannelConvertorCoeff = 1;
    }
    else
    {
        needChannelConversion = 0;
        uiChannelConvertorCoeff = 2;
    }

    /* Compute number of bytes remaining in the Ssrc buffer */
    uiSsrcOutSize = pC->iSsrcNbSamplOut * sizeof(short)
        * pC->pReaderAudioStream->m_nbChannels;
    uiBytesSsrc =
        ( pC->pSsrcBufferOut + uiSsrcOutSize) - pC->pPosInSsrcBufferOut;

    /* Check if the ssrc buffer is full */
    if( pC->pPosInSsrcBufferOut == pC->pSsrcBufferOut )
    {
        uiSsrc2Encoder_NbBytes =
            pC->audioEncoderGranularity * uiChannelConvertorCoeff / 2;

        /* Check if we can feed directly the encoder with the ssrc out buffer */
        if( ( pC->pPosInAudioEncoderBuffer == M4OSA_NULL)
            && (uiBytesSsrc >= uiSsrc2Encoder_NbBytes) )
        {
            /* update position in ssrc out buffer after encoding */
            if( uiBytesSsrc == uiSsrc2Encoder_NbBytes )
                pC->pPosInSsrcBufferOut = M4OSA_NULL;
            else
                pC->pPosInSsrcBufferOut += uiSsrc2Encoder_NbBytes;

            /* mark the encoder buffer ready (= full) */
            pC->pPosInAudioEncoderBuffer =
                pC->pAudioEncoderBuffer + pC->audioEncoderGranularity;

            if( needChannelConversion > 0 )
            {
                /* channel convertor writes directly into encoder buffer */
                pEncoderInput = pC->pAudioEncoderBuffer;

                pChannelConvertorInput = pC->pSsrcBufferOut;
                pChannelConvertorOutput = pC->pAudioEncoderBuffer;
                uiChannelConvertorNbSamples =
                    uiSsrc2Encoder_NbBytes / sizeof(short);

                goto m4mcs_intaudiotranscoding_channel_convertor;
            }
            else
            {
                /* encode directly from ssrc out buffer */
                pEncoderInput = pC->pSsrcBufferOut;

                goto m4mcs_intaudiotranscoding_encode_and_write;
            }
        }
    }

    /**
    * Compute remaining space in encoder buffer in */
    if( pC->pPosInAudioEncoderBuffer == M4OSA_NULL )
    {
        pC->pPosInAudioEncoderBuffer = pC->pAudioEncoderBuffer;
    }

    uiEncoderInRoom = ( pC->pAudioEncoderBuffer + pC->audioEncoderGranularity)
        - pC->pPosInAudioEncoderBuffer;
    pEncoderInput = pC->pAudioEncoderBuffer;

    /**
    * Nb of bytes copied is the minimum between nb of bytes remaining in
    * decoder out buffer and space remaining in ssrc in buffer */
    uiSsrc2Encoder_NbBytes =
        (( uiEncoderInRoom * uiChannelConvertorCoeff / 2) < uiBytesSsrc)
        ? (uiEncoderInRoom * uiChannelConvertorCoeff / 2) : uiBytesSsrc;

    if( needChannelConversion > 0 )
    {
        /* channel convertor writes directly into encoder buffer */
        pChannelConvertorInput = pC->pPosInSsrcBufferOut;
        pChannelConvertorOutput = pC->pPosInAudioEncoderBuffer;
        uiChannelConvertorNbSamples = uiSsrc2Encoder_NbBytes / sizeof(short);
    }
    else
    {
        /* copy from the ssrc out buffer into the encoder in buffer */
        memcpy((void *)pC->pPosInAudioEncoderBuffer, (void *)pC->pPosInSsrcBufferOut,
            uiSsrc2Encoder_NbBytes);
    }

    /* Update position in ssrc out buffer after encoding */
    pC->pPosInSsrcBufferOut += uiSsrc2Encoder_NbBytes;

    /* Update the position in the encoder in buffer */
    pC->pPosInAudioEncoderBuffer +=
        uiSsrc2Encoder_NbBytes * 2 / uiChannelConvertorCoeff;

    /* Check if the ssrc buffer out is empty */
    if( ( pC->pPosInSsrcBufferOut - pC->pSsrcBufferOut)
        == (M4OSA_Int32)uiSsrcOutSize )
    {
        pC->pPosInSsrcBufferOut = M4OSA_NULL;
    }

    /* go to next statement */
    if( needChannelConversion > 0 )
        goto m4mcs_intaudiotranscoding_channel_convertor;
    else
        goto m4mcs_intaudiotranscoding_encode_and_write;

    /* _________________ */
    /*|                 |*/
    /*| STEREO <-> MONO |*/
    /*|_________________|*/

m4mcs_intaudiotranscoding_channel_convertor:

    /* convert the input pcm stream to mono or to stereo */
    switch( needChannelConversion )
    {
        case 1: /* stereo to mono */
            From2iToMono_16((short *)pChannelConvertorInput,
                (short *)pChannelConvertorOutput,
                (short)(uiChannelConvertorNbSamples / 2));
            break;

        case 2: /* mono to stereo */
            MonoTo2I_16((short *)pChannelConvertorInput,
                (short *)pChannelConvertorOutput,
                (short)uiChannelConvertorNbSamples);
            break;
    }

    /* __________________ */
    /*|                  |*/
    /*| ENCODE AND WRITE |*/
    /*|__________________|*/

m4mcs_intaudiotranscoding_encode_and_write:

    /* Check if the encoder in buffer is ready (= full) */
    if( ( pC->pPosInAudioEncoderBuffer - pC->pAudioEncoderBuffer)
        < (M4OSA_Int32)pC->audioEncoderGranularity )
    {
        goto m4mcs_intaudiotranscoding_end;
    }

    /* [Mono] or [Stereo interleaved] : all is in one buffer */
    pEncInBuffer.pTableBuffer[0] = pEncoderInput;
    pEncInBuffer.pTableBufferSize[0] = pC->audioEncoderGranularity;
    pEncInBuffer.pTableBuffer[1] = M4OSA_NULL;
    pEncInBuffer.pTableBufferSize[1] = 0;

    /* Time in ms from data size, because it is PCM16 samples */
    frameTimeDelta =
        ( pEncInBuffer.pTableBufferSize[0] * uiChannelConvertorCoeff / 2)
        / sizeof(short) / pC->pReaderAudioStream->m_nbChannels;

    /**
    * Prepare the writer AU */
    err = pC->pWriterDataFcts->pStartAU(pC->pWriterContext,
        M4MCS_WRITER_AUDIO_STREAM_ID, &pC->WriterAudioAU);

    if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intAudioTranscoding(): pWriterDataFcts->pStartAU(Audio) returns 0x%x",
            err);
        return err;
    }

    /*FlB 2009.03.04: apply audio effects if an effect is active*/
    if( *pActiveEffectNumber >= 0 && *pActiveEffectNumber < pC->nbEffects )
    {
        if( pC->pEffects[*pActiveEffectNumber].ExtAudioEffectFct != M4OSA_NULL )
        {
            M4MCS_ExternalProgress pProgress;
            M4OSA_UInt32 tempProgress = 0;
            pProgress.uiClipTime = (M4OSA_UInt32)pC->ReaderAudioAU.m_CTS;

            pProgress.uiOutputTime = ( pC->WriterAudioAU.CTS * 1000)
                / pC->WriterAudioStream.timeScale;
            tempProgress = ( (M4OSA_UInt32)pC->ReaderAudioAU.m_CTS
                - pC->pEffects[*pActiveEffectNumber].uiStartTime
                - pC->uiBeginCutTime) * 1000;
            pProgress.uiProgress =
                (M4OSA_UInt32)(tempProgress / (M4OSA_UInt32)pC->pEffects[
                    *pActiveEffectNumber].uiDuration);

                    err = pC->pEffects[*pActiveEffectNumber].ExtAudioEffectFct(
                        pC->pEffects[*pActiveEffectNumber].pExtAudioEffectFctCtxt,
                        (M4OSA_Int16 *)pEncInBuffer.pTableBuffer[0],
                        pEncInBuffer.pTableBufferSize[0], &pProgress);

                    if( err != M4NO_ERROR )
                    {
                        M4OSA_TRACE1_1(
                            "M4MCS_intAudioTranscoding(): ExtAudioEffectFct() returns 0x%x",
                            err);
                        return err;
                    }
        }
    }

    /**
    * Prepare output buffer */
    pEncOutBuffer.pTableBuffer[0] =
        (M4OSA_MemAddr8)pC->WriterAudioAU.dataAddress;
    pEncOutBuffer.pTableBufferSize[0] = 0;

#ifdef MCS_DUMP_PCM_TO_FILE

    fwrite(pEncInBuffer.pTableBuffer[0], pEncInBuffer.pTableBufferSize[0], 1,
        file_pcm_encoder);

#endif

    if( M4OSA_FALSE == pC->b_isRawWriter )
    {
        /* This allow to write PCM data to file and to encode AMR data,
         when output file is not RAW */
        if( pC->pOutputPCMfile != M4OSA_NULL )
        {
            pC->pOsaFileWritPtr->writeData(pC->pOutputPCMfile,
                pEncInBuffer.pTableBuffer[0], pEncInBuffer.pTableBufferSize[0]);
        }

        /**
        * Encode the PCM audio */
        err = pC->pAudioEncoderGlobalFcts->pFctStep(pC->pAudioEncCtxt,
            &pEncInBuffer, &pEncOutBuffer);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intAudioTranscoding(): pAudioEncoderGlobalFcts->pFctStep returns 0x%x",
                err);
            return err;
        }

        /* update data consumed into encoder buffer in after encoding (empty) */
        pC->pPosInAudioEncoderBuffer = M4OSA_NULL;

        /**
        * Set AU cts and size */
        pC->WriterAudioAU.size =
            pEncOutBuffer.
            pTableBufferSize[0]; /**< Get the size of encoded data */
        pC->WriterAudioAU.CTS += frameTimeDelta;

        /**
        * Update duration of the encoded AU */
        pC->m_audioAUDuration =
            ( frameTimeDelta * 1000) / pC->WriterAudioStream.timeScale;

        /**
        * Write the encoded AU to the output file */
        pC->uiAudioAUCount++;
        err = pC->pWriterDataFcts->pProcessAU(pC->pWriterContext,
            M4MCS_WRITER_AUDIO_STREAM_ID, &pC->WriterAudioAU);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intAudioTranscoding(): pWriterDataFcts->pProcessAU(Audio) returns 0x%x",
                err);
            return err;
        }
    }
    else
    {
        /* update data consumed into encoder buffer in after encoding (empty) */
        pC->pPosInAudioEncoderBuffer = M4OSA_NULL;

        pC->WriterAudioAU.dataAddress =
            (M4OSA_MemAddr32)
            pEncoderInput; /* will be converted back to u8* in file write */
        pC->WriterAudioAU.size = pC->audioEncoderGranularity;
        pC->uiAudioAUCount++;

        err = pC->pWriterDataFcts->pProcessAU(pC->pWriterContext,
            M4MCS_WRITER_AUDIO_STREAM_ID, &pC->WriterAudioAU);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intAudioTranscoding(): pWriterDataFcts->pProcessAU(Audio) returns 0x%x",
                err);
            return err;
        }
    }

    /* _______________ */
    /*|               |*/
    /*| ONE PASS DONE |*/
    /*|_______________|*/

m4mcs_intaudiotranscoding_end:

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intAudioTranscoding(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intReallocTemporaryAU(M4OSA_MemAddr8* addr, M4OSA_UInt32 newSize)
 * Used only in case of 3GP constant memory reader, to be able to realloc temporary AU
 * because max AU size can be reevaluated during reading
 * @return   M4NO_ERROR:         No error
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intReallocTemporaryAU( M4OSA_MemAddr8 *addr,
                                             M4OSA_UInt32 newSize )
{
    if( *addr != M4OSA_NULL )
    {
        free(*addr);
        *addr = (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(newSize, M4MCS,
            (M4OSA_Char *)"Reallocation of temporary AU buffer");

        if( *addr == M4OSA_NULL )
        {
            return M4ERR_ALLOC;
        }
    }

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intVideoNullEncoding(M4MCS_InternalContext* pC)
 * @author   Alexis Vapillon (NXP Software Vision)
 * @return   M4NO_ERROR:         No error
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intVideoNullEncoding( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err = M4NO_ERROR;
    /* Duration of the AU (find the next AU duration
     * to obtain a more precise video end cut)
     */
    M4OSA_UInt32 videoAUDuration = 0;

    M4OSA_MemAddr8 WritebufferAdd = M4OSA_NULL;
    M4OSA_Int32 lastdecodedCTS = 0;
    M4_AccessUnit lReaderVideoAU; /**< Read video access unit */

    if( pC->novideo )
        return M4NO_ERROR;

    /* H.264 Trimming */
    if( ( ( pC->bH264Trim == M4OSA_TRUE)
        && (pC->uiVideoAUCount < pC->m_pInstance->clip_sps.num_ref_frames)
        && (pC->uiBeginCutTime > 0))
        || (( pC->uiVideoAUCount == 0) && (pC->uiBeginCutTime > 0)) )
    {
        err = M4MCS_intVideoTranscoding(pC);
        return err;
    }


    if((pC->bLastDecodedFrameCTS == M4OSA_FALSE) && (pC->uiBeginCutTime > 0))
    {
        // StageFright encoder does prefetch, the one frame we requested will not be written until
        // the encoder is closed, so do it now rather than in MCS_close
        if( ( M4NO_ERROR != err)
            || (M4MCS_kEncoderRunning != pC->encoderState) )
        {
            M4OSA_TRACE1_2(
                "!!! M4MCS_intVideoNullEncoding ERROR : M4MCS_intVideoTranscoding "
                "returns 0x%X w/ encState=%d", err, pC->encoderState);

            return err;
        }

        /* Stop and close the encoder now to flush the frame (prefetch) */
        if( pC->pVideoEncoderGlobalFcts->pFctStop != M4OSA_NULL )
        {
            err = pC->pVideoEncoderGlobalFcts->pFctStop(pC->pViEncCtxt);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "!!! M4MCS_intVideoNullEncoding ERROR : encoder stop returns 0x%X",
                    err);
                return err;
            }
        }
        pC->encoderState = M4MCS_kEncoderStopped;
        err = pC->pVideoEncoderGlobalFcts->pFctClose(pC->pViEncCtxt);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "!!! M4MCS_intVideoNullEncoding ERROR : encoder close returns 0x%X",
                err);
            return err;
        }
        pC->encoderState = M4MCS_kEncoderClosed;
    }


    if( ( pC->bH264Trim == M4OSA_TRUE)
        && (pC->bLastDecodedFrameCTS == M4OSA_FALSE)
        && (pC->uiBeginCutTime > 0) )
    {

        pC->bLastDecodedFrameCTS = M4OSA_TRUE;
        err = pC->m_pVideoDecoder->m_pFctGetOption(pC->pViDecCtxt,
            M4DECODER_kOptionID_AVCLastDecodedFrameCTS, &lastdecodedCTS);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intVideoNullEncoding: m_pVideoDecoder->m_pFctGetOption returns 0x%x!",
                err);
            return err;
        }

        err = pC->m_pReader->m_pFctJump(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream, &lastdecodedCTS);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intStepBeginVideoJump: m_pFctJump(V) returns 0x%x!",
                err);
            return err;
        }


        /* Initializes an access Unit */

        err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream, &lReaderVideoAU);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_open(): m_pReader->m_pFctFillAuStruct(video) returns 0x%x",
                err);
            return err;
        }

        err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream, &lReaderVideoAU);

        if( M4WAR_NO_MORE_AU == err )
        {
            M4OSA_TRACE2_0(
                "M4MCS_intVideoNullEncoding():\
                 m_pReaderDataIt->m_pFctGetNextAu(video) returns M4WAR_NO_MORE_AU");
            /* The audio transcoding is finished */
            pC->VideoState = M4MCS_kStreamState_FINISHED;
            return err;
        }
        else if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intVideoNullEncoding():\
                 m_pReaderDataIt->m_pFctGetNextAu(video) returns 0x%x",
                err);
            return err;
        }

        M4OSA_TRACE1_1(
            "### [TS_CHECK] M4MCS_intVideoNullEncoding  video AU CTS: %d ",
            lReaderVideoAU.m_CTS);


    }


    pC->bLastDecodedFrameCTS = M4OSA_TRUE;


    /* Find the next AU duration to obtain a more precise video end cut*/
    /**
    * Initializes a new AU if needed */

    if( pC->ReaderVideoAU1.m_structSize == 0 )
    {
        /**
        * Initializes an access Unit */
        err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream,
            &pC->ReaderVideoAU1);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_open(): m_pReader->m_pFctFillAuStruct(video) returns 0x%x",
                err);
            return err;
        }

        pC->m_pDataVideoAddress1 =
            (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->ReaderVideoAU1.m_maxsize, M4MCS,
            (M4OSA_Char *)"Temporary video AU1 buffer");

        if( pC->m_pDataVideoAddress1 == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("M4MCS_intVideoNullEncoding(): allocation error");
            return M4ERR_ALLOC;
        }

        err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream,
            &pC->ReaderVideoAU1);

        if( M4WAR_NO_MORE_AU == err )
        {
            M4OSA_TRACE2_0(
                "M4MCS_intVideoNullEncoding():\
                 m_pReaderDataIt->m_pFctGetNextAu(video) returns M4WAR_NO_MORE_AU");
            /* The audio transcoding is finished */
            pC->VideoState = M4MCS_kStreamState_FINISHED;
            return err;
        }
        else if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intVideoNullEncoding(): m_pReaderDataIt->m_pFctGetNextAu(video)\
                 returns 0x%x", err);
            return err;
        }

        if( pC->ReaderVideoAU1.m_maxsize
            > pC->pReaderVideoStream->m_basicProperties.m_maxAUSize )
        {
            /* Constant memory reader case, we need to reallocate the temporary buffers */
            M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                *) &(pC->m_pDataVideoAddress1), pC->ReaderVideoAU1.m_maxsize);
            /* pC->m_pDataVideoAddress1
            and pC->m_pDataVideoAddress2 must be reallocated at the same time */
            /* because pC->pReaderVideoStream->m_basicProperties.m_maxAUSize take maximum value.
             Then the test "if(pC->ReaderVideoAU?.m_maxsize > pC->pReaderVideoStream->
             m_basicProperties.m_maxAUSize)" is never true */
            /* and the size of the second buffer is never changed. */
            M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                *) &(pC->m_pDataVideoAddress2), pC->ReaderVideoAU1.m_maxsize);
            /* pC->m_pDataVideoAddress1 and
            pC->m_pDataVideoAddress2 must be reallocated at the same time */
            /* Update stream properties */
            pC->pReaderVideoStream->m_basicProperties.m_maxAUSize =
                pC->ReaderVideoAU1.m_maxsize;
        }
        memcpy((void *)pC->m_pDataVideoAddress1,
            (void *)pC->ReaderVideoAU1.m_dataAddress,
            pC->ReaderVideoAU1.m_size);
    }

    if( pC->ReaderVideoAU2.m_structSize == 0 )
    {
        /**
        * Initializes an access Unit */
        err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream,
            &pC->ReaderVideoAU2);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_open(): m_pReader->m_pFctFillAuStruct(video) returns 0x%x",
                err);
            return err;
        }
        pC->m_pDataVideoAddress2 =
            (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(pC->ReaderVideoAU2.m_maxsize, M4MCS,
            (M4OSA_Char *)"Temporary video AU buffer");

        if( pC->m_pDataVideoAddress2 == M4OSA_NULL )
        {
            M4OSA_TRACE1_0("M4MCS_intVideoNullEncoding(): allocation error");
            return M4ERR_ALLOC;
        }
    }
    /**
    * Read the next video AU in the input file */
    if( pC->ReaderVideoAU2.m_CTS > pC->ReaderVideoAU1.m_CTS )
    {
        memcpy((void *) &pC->ReaderVideoAU,
            (void *) &pC->ReaderVideoAU2, sizeof(M4_AccessUnit));
        err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream,
            &pC->ReaderVideoAU1);

        if( pC->ReaderVideoAU1.m_maxsize
            > pC->pReaderVideoStream->m_basicProperties.m_maxAUSize )
        {
            /* Constant memory reader case, we need to reallocate the temporary buffers */
            M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                *) &(pC->m_pDataVideoAddress1), pC->ReaderVideoAU1.m_maxsize);
            /* pC->m_pDataVideoAddress1 and
             pC->m_pDataVideoAddress2 must be reallocated at the same time */
            /* because pC->pReaderVideoStream->m_basicProperties.m_maxAUSize take maximum value.
             Then the test "if(pC->ReaderVideoAU?.m_maxsize > pC->pReaderVideoStream->
             m_basicProperties.m_maxAUSize)" is never true */
            /* and the size of the second buffer is never changed. */
            M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                *) &(pC->m_pDataVideoAddress2), pC->ReaderVideoAU1.m_maxsize);
            /* pC->m_pDataVideoAddress1 and
            pC->m_pDataVideoAddress2 must be reallocated at the same time */
            /* Update stream properties */
            pC->pReaderVideoStream->m_basicProperties.m_maxAUSize =
                pC->ReaderVideoAU1.m_maxsize;
        }
        memcpy((void *)pC->m_pDataVideoAddress1,
            (void *)pC->ReaderVideoAU1.m_dataAddress,
            pC->ReaderVideoAU1.m_size);
        videoAUDuration = pC->ReaderVideoAU1.m_CTS - pC->ReaderVideoAU2.m_CTS;
        pC->ReaderVideoAU.m_dataAddress = pC->m_pDataVideoAddress2;
    }
    else
    {
        memcpy((void *) &pC->ReaderVideoAU,
            (void *) &pC->ReaderVideoAU1, sizeof(M4_AccessUnit));
        err = pC->m_pReaderDataIt->m_pFctGetNextAu(pC->pReaderContext,
            (M4_StreamHandler *)pC->pReaderVideoStream,
            &pC->ReaderVideoAU2);

        if( pC->ReaderVideoAU2.m_maxsize
            > pC->pReaderVideoStream->m_basicProperties.m_maxAUSize )
        {
            /* Constant memory reader case, we need to reallocate the temporary buffers */
            M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                *) &(pC->m_pDataVideoAddress2), pC->ReaderVideoAU2.m_maxsize);
            /* pC->m_pDataVideoAddress1 and
             pC->m_pDataVideoAddress2 must be reallocated at the same time */
            /* because pC->pReaderVideoStream->m_basicProperties.m_maxAUSize take maximum value.
             Then the test "if(pC->ReaderVideoAU?.m_maxsize > pC->pReaderVideoStream->
             m_basicProperties.m_maxAUSize)" is never true */
            /* and the size of the second buffer is never changed. */
            M4MCS_intReallocTemporaryAU((M4OSA_MemAddr8
                *) &(pC->m_pDataVideoAddress1), pC->ReaderVideoAU2.m_maxsize);
            /* pC->m_pDataVideoAddress1 and
            pC->m_pDataVideoAddress2 must be reallocated at the same time */
            /* Update stream properties */
            pC->pReaderVideoStream->m_basicProperties.m_maxAUSize =
                pC->ReaderVideoAU2.m_maxsize;
        }
        memcpy((void *)pC->m_pDataVideoAddress2,
            (void *)pC->ReaderVideoAU2.m_dataAddress,
            pC->ReaderVideoAU2.m_size);
        videoAUDuration = pC->ReaderVideoAU2.m_CTS - pC->ReaderVideoAU1.m_CTS;
        pC->ReaderVideoAU.m_dataAddress = pC->m_pDataVideoAddress1;
    }

    if( M4WAR_NO_MORE_AU == err )
    {
        M4OSA_TRACE2_0(
            "M4MCS_intVideoNullEncoding():\
             m_pReaderDataIt->m_pFctGetNextAu(video) returns M4WAR_NO_MORE_AU");
        /* The video transcoding is finished */
        pC->VideoState = M4MCS_kStreamState_FINISHED;
        return err;
    }
    else if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intVideoNullEncoding(): m_pReaderDataIt->m_pFctGetNextAu(Video) returns 0x%x",
            err);
        return err;
    }
    else
    {
        /**
        * Prepare the writer AU */
        err = pC->pWriterDataFcts->pStartAU(pC->pWriterContext,
            M4MCS_WRITER_VIDEO_STREAM_ID, &pC->WriterVideoAU);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intVideoNullEncoding(): pWriterDataFcts->pStartAU(Video) returns 0x%x",
                err);
            return err;
        }
            /**
            * Copy video data from reader AU to writer AU */
            M4OSA_TRACE3_1(
                "M4MCS_intVideoNullEncoding(): Copying video AU: size=%d",
                pC->ReaderVideoAU.m_size);
            /* + CRLV6775 -H.264 Trimming */
            if( M4OSA_TRUE == pC->bH264Trim )
            {
                if( pC->H264MCSTempBufferSize
                    < (pC->ReaderVideoAU.m_size + 2048) )
                {
                    pC->H264MCSTempBufferSize =
                        (pC->ReaderVideoAU.m_size + 2048);

                    if( pC->H264MCSTempBuffer != M4OSA_NULL )
                    {
                        free(pC->H264MCSTempBuffer);
                    }
                    pC->H264MCSTempBuffer =
                        (M4OSA_UInt8 *)M4OSA_32bitAlignedMalloc(pC->H264MCSTempBufferSize,
                        M4MCS, (M4OSA_Char *)"pC->H264MCSTempBuffer");

                    if( pC->H264MCSTempBuffer == M4OSA_NULL )
                    {
                        M4OSA_TRACE1_0(
                            "M4MCS_intVideoNullEncoding(): allocation error");
                        return M4ERR_ALLOC;
                    }
                }

                pC->H264MCSTempBufferDataSize = pC->H264MCSTempBufferSize;

                err = H264MCS_ProcessNALU(pC->m_pInstance,
                    (M4OSA_UInt8 *)pC->ReaderVideoAU.m_dataAddress,
                    pC->ReaderVideoAU.m_size, pC->H264MCSTempBuffer,
                    (M4OSA_Int32 *)&pC->H264MCSTempBufferDataSize);

                if( pC->m_pInstance->is_done == 1 )
                {
                    M4MCS_convetFromByteStreamtoNALStream(
                        (M4OSA_UInt8 *)pC->ReaderVideoAU.m_dataAddress ,
                        pC->ReaderVideoAU.m_size);

                    memcpy((void *)pC->WriterVideoAU.dataAddress,
                        (void *)(pC->ReaderVideoAU.m_dataAddress + 4),
                        pC->ReaderVideoAU.m_size - 4);
                    pC->WriterVideoAU.size = pC->ReaderVideoAU.m_size - 4;
                    WritebufferAdd =
                        (M4OSA_MemAddr8)pC->WriterVideoAU.dataAddress;
                }
                else
                {
                    memcpy((void *)pC->WriterVideoAU.dataAddress,
                        (void *)(pC->H264MCSTempBuffer + 4),
                        pC->H264MCSTempBufferDataSize - 4);
                    pC->WriterVideoAU.size = pC->H264MCSTempBufferDataSize - 4;
                    WritebufferAdd =
                        (M4OSA_MemAddr8)pC->WriterVideoAU.dataAddress;
                }
            }
            /* H.264 Trimming */
            else
            {
                memcpy((void *)pC->WriterVideoAU.dataAddress,
                    (void *)pC->ReaderVideoAU.m_dataAddress,
                    pC->ReaderVideoAU.m_size);
                pC->WriterVideoAU.size = pC->ReaderVideoAU.m_size;
            }
            /**
            * Convert CTS unit from milliseconds to timescale */
            pC->WriterVideoAU.CTS =
                (M4OSA_Time)((( pC->ReaderVideoAU.m_CTS - pC->dViDecStartingCts)
                * (pC->WriterVideoStream.timeScale / 1000.0)));
            pC->WriterVideoAU.nbFrag = 0;
            pC->WriterVideoAU.attribute = pC->ReaderVideoAU.m_attribute;

            M4OSA_TRACE3_1("M4MCS_intVideoNullEncoding(): video AU: CTS=%d ms",
                pC->WriterVideoAU.CTS);

        /**
        * Write it to the output file */
        pC->uiVideoAUCount++;
        err = pC->pWriterDataFcts->pProcessAU(pC->pWriterContext,
            M4MCS_WRITER_VIDEO_STREAM_ID, &pC->WriterVideoAU);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_intVideoNullEncoding(): pWriterDataFcts->pProcessAU(Video) returns 0x%x",
                err);
            return err;
        }
        /* + CRLV6775 -H.264 Trimming */
        if( M4OSA_TRUE == pC->bH264Trim )
        {
            if( pC->m_pInstance->is_done == 1 )
            {
                memcpy((void *)(WritebufferAdd - 4),
                    (void *)(pC->ReaderVideoAU.m_dataAddress), 4);
            }
            else
            {
                memcpy((void *)(WritebufferAdd - 4),
                    (void *)(pC->H264MCSTempBuffer), 4);
            }
        } /* H.264 Trimming */
    }
    /**
    * Check for end cut. */
    /* Bug fix 11/12/2008: We absolutely want to have less or same video duration ->
    (2*videoAUDuration) to have a more precise end cut*/
    if( pC->ReaderVideoAU.m_CTS + (2 *videoAUDuration) > pC->uiEndCutTime )
    {
        pC->VideoState = M4MCS_kStreamState_FINISHED;
    }

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_intVideoNullEncoding(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intVideoTranscoding(M4MCS_InternalContext* pC)
 * @author   Alexis Vapillon (NXP Software Vision)
 * @return   M4NO_ERROR:         No error
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intVideoTranscoding( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err = M4NO_ERROR;
    M4_MediaTime mtTranscodedTime = 0.0;
    M4ENCODER_FrameMode FrameMode;
    M4OSA_Int32 derive = 0;

    /**
    * Get video CTS to decode */
    mtTranscodedTime = pC->dViDecCurrentCts;
    FrameMode = M4ENCODER_kNormalFrame;

    /**
    * Decode video */
    M4OSA_TRACE3_1(
        "M4MCS_intVideoTranscoding(): Calling m_pVideoDecoder->m_pFctDecode(%.2f)",
        mtTranscodedTime);
    pC->isRenderDup = M4OSA_FALSE;
    err = pC->m_pVideoDecoder->m_pFctDecode(pC->pViDecCtxt, &mtTranscodedTime,
        M4OSA_FALSE);

    if( M4WAR_NO_MORE_AU == err )
    {
        FrameMode =
            M4ENCODER_kLastFrame; /**< We will give this value to the encoder to
            ask for the end of the encoding */
        pC->VideoState = M4MCS_kStreamState_FINISHED;
    }
    else if( err == M4WAR_VIDEORENDERER_NO_NEW_FRAME )
    {
        M4OSA_TRACE2_0("Decoding output the same frame as before 3");
        pC->isRenderDup = M4OSA_TRUE;
    }
    else if( M4NO_ERROR != err )
    {
        M4OSA_TRACE1_1(
            "M4MCS_intVideoTranscoding(): m_pVideoDecoder->m_pFctDecode returns 0x%x!",
            err);
        return err;
    }

    /**
    * Check for end cut.
    * We must check here if the end cut is reached, because in that case we must
    * call the last encode step (-> bLastFrame set to true) */
    if( ( pC->dViDecCurrentCts + pC->dCtsIncrement ) >= (pC->uiEndCutTime
        + M4MCS_ABS(pC->dViDecStartingCts - pC->uiBeginCutTime)) )
    {
        FrameMode =
            M4ENCODER_kLastFrame; /**< We will give this value to the encoder to
            ask for the end of the encoding */
        pC->VideoState = M4MCS_kStreamState_FINISHED;
        derive = (M4OSA_Int32)(( pC->dViDecCurrentCts + pC->dCtsIncrement + 0.5)
            - (pC->uiEndCutTime
            + M4MCS_ABS(pC->dViDecStartingCts - pC->uiBeginCutTime)));
    }

    /* Update starting CTS to have a more precise value (
    the begin cut is not a real CTS)*/
    if( pC->uiVideoAUCount == 0 )
    {
        pC->dViDecStartingCts = mtTranscodedTime;
        pC->dViDecCurrentCts = pC->dViDecStartingCts;
    }

    /**
    * Encode video */
    M4OSA_TRACE3_1(
        "M4MCS_intVideoTranscoding(): Calling pVideoEncoderGlobalFcts->pFctEncode with videoCts\
         = %.2f",pC->ReaderVideoAU.m_CTS);
    pC->uiVideoAUCount++;
    /* update the given duration (the begin cut is not a real CTS)*/
    err = pC->pVideoEncoderGlobalFcts->pFctEncode(pC->pViEncCtxt, M4OSA_NULL,
        (pC->dViDecCurrentCts - pC->dViDecStartingCts - (derive >> 1)),
        FrameMode);

    return err;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intGetInputClipProperties(M4MCS_InternalContext* pContext)
 * @author   Dounya Manai (NXP Software Vision)
 * @brief    Retrieve the properties of the audio and video streams from the input file.
 * @param    pContext            (IN) MCS context
 * @return   M4NO_ERROR:         No error
 * @return   M4ERR_PARAMETER:    pContext is M4OSA_NULL (If Debug Level >= 2)
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intGetInputClipProperties( M4MCS_InternalContext *pC )
{
    M4DECODER_MPEG4_DecoderConfigInfo DecConfInfo;
    M4READER_3GP_H263Properties H263prop;
    M4OSA_ERR err;
    M4OSA_UInt32 videoBitrate;
    M4DECODER_AVCProfileLevel AVCProfle;
#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS

    M4DECODER_VideoSize videoSize;

#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */

    M4_AACType iAacType = 0;

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

    /**
    * Reset common characteristics */
    pC->InputFileProperties.bAnalysed = M4OSA_FALSE;
    pC->InputFileProperties.FileType = 0;
    pC->InputFileProperties.Version[0] = M4VIDEOEDITING_VERSION_MAJOR;
    pC->InputFileProperties.Version[1] = M4VIDEOEDITING_VERSION_MINOR;
    pC->InputFileProperties.Version[2] = M4VIDEOEDITING_VERSION_REVISION;
    pC->InputFileProperties.uiClipDuration = 0;

    memset((void *) &pC->InputFileProperties.ftyp,
        0, sizeof(M4VIDEOEDITING_FtypBox));

    /**
    * Reset video characteristics */
    pC->InputFileProperties.VideoStreamType = M4VIDEOEDITING_kNoneVideo;
    pC->InputFileProperties.uiClipVideoDuration = 0;
    pC->InputFileProperties.uiVideoBitrate = 0;
    pC->InputFileProperties.uiVideoMaxAuSize = 0;
    pC->InputFileProperties.uiVideoWidth = 0;
    pC->InputFileProperties.uiVideoHeight = 0;
    pC->InputFileProperties.uiVideoTimeScale = 0;
    pC->InputFileProperties.fAverageFrameRate = 0.0;
    pC->InputFileProperties.ProfileAndLevel =
        M4VIDEOEDITING_kProfile_and_Level_Out_Of_Range;
    pC->InputFileProperties.uiH263level = 0;
    pC->InputFileProperties.uiVideoProfile = 0;
    pC->InputFileProperties.bMPEG4dataPartition = M4OSA_FALSE;
    pC->InputFileProperties.bMPEG4rvlc = M4OSA_FALSE;
    pC->InputFileProperties.bMPEG4resynchMarker = M4OSA_FALSE;

    /**
    * Reset audio characteristics */
    pC->InputFileProperties.AudioStreamType = M4VIDEOEDITING_kNoneAudio;
    pC->InputFileProperties.uiClipAudioDuration = 0;
    pC->InputFileProperties.uiAudioBitrate = 0;
    pC->InputFileProperties.uiAudioMaxAuSize = 0;
    pC->InputFileProperties.uiNbChannels = 0;
    pC->InputFileProperties.uiSamplingFrequency = 0;
    pC->InputFileProperties.uiExtendedSamplingFrequency = 0;
    pC->InputFileProperties.uiDecodedPcmSize = 0;

    /* Reset compatibility chart (not used in MCS) */
    pC->InputFileProperties.bVideoIsEditable = M4OSA_FALSE;
    pC->InputFileProperties.bAudioIsEditable = M4OSA_FALSE;
    pC->InputFileProperties.bVideoIsCompatibleWithMasterClip = M4OSA_FALSE;
    pC->InputFileProperties.bAudioIsCompatibleWithMasterClip = M4OSA_FALSE;

    /**
    * Video stream properties */
    if( M4OSA_NULL != pC->pReaderVideoStream )
    {
        switch( pC->pReaderVideoStream->m_basicProperties.m_streamType )
        {
            case M4DA_StreamTypeVideoMpeg4:
                pC->InputFileProperties.VideoStreamType = M4VIDEOEDITING_kMPEG4;
                break;

            case M4DA_StreamTypeVideoH263:
                pC->InputFileProperties.VideoStreamType = M4VIDEOEDITING_kH263;
                break;

            case M4DA_StreamTypeVideoMpeg4Avc:
                pC->InputFileProperties.VideoStreamType = M4VIDEOEDITING_kH264;
                break;

            case M4DA_StreamTypeUnknown:
            default:
                pC->InputFileProperties.VideoStreamType =
                    M4VIDEOEDITING_kUnsupportedVideo;
                break;
        }

        /* if bitrate not available retrieve an estimation of the overall bitrate */
        pC->InputFileProperties.uiVideoBitrate =
            pC->pReaderVideoStream->m_basicProperties.m_averageBitRate;

        if( 0 == pC->InputFileProperties.uiVideoBitrate )
        {
            pC->m_pReader->m_pFctGetOption(pC->pReaderContext,
                M4READER_kOptionID_Bitrate, &videoBitrate);

            if( M4OSA_NULL != pC->pReaderAudioStream )
            {
                /* we get the overall bitrate, substract the audio bitrate if any */
                videoBitrate -=
                    pC->pReaderAudioStream->m_basicProperties.m_averageBitRate;
            }
            pC->InputFileProperties.uiVideoBitrate = videoBitrate;
        }

        /**
        * Retrieve the Profile & Level */
        if( ( M4VIDEOEDITING_kH263 != pC->InputFileProperties.VideoStreamType)
            && (M4VIDEOEDITING_kH264
            != pC->InputFileProperties.VideoStreamType) )
        {
#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
            /* Use the DSI parsing function from the external video shell decoder.
            See the comments in M4VSS3GPP_ClipAnalysis.c, it's pretty much the
            same issue. */

            err = M4DECODER_EXTERNAL_ParseVideoDSI(pC->pReaderVideoStream->
                m_basicProperties.m_pDecoderSpecificInfo,
                pC->pReaderVideoStream->
                m_basicProperties.m_decoderSpecificInfoSize,
                &DecConfInfo, &videoSize);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intGetInputClipProperties():\
                     M4DECODER_EXTERNAL_ParseVideoDSI returns 0x%08X",
                    err);
                return err;
            }

            pC->pReaderVideoStream->m_videoWidth = videoSize.m_uiWidth;
            pC->pReaderVideoStream->m_videoHeight = videoSize.m_uiHeight;

#else
            /*FB 2009-02-09: add a check on the video decoder context to
            avoid crash when the MCS is used only with audio codecs compilated*/

            if( pC->m_pVideoDecoder != M4OSA_NULL )
            {
                if( M4OSA_NULL == pC->pViDecCtxt )
                {
                    err = pC->m_pVideoDecoder->m_pFctCreate(&pC->pViDecCtxt,
                        &pC->pReaderVideoStream->m_basicProperties,
                        pC->m_pReaderDataIt, &pC->ReaderVideoAU,
                        M4OSA_NULL);

                    if( M4NO_ERROR != err )
                    {
                        M4OSA_TRACE1_1(
                            "M4MCS_intGetInputClipProperties:\
                             m_pVideoDecoder->m_pFctCreate returns 0x%x!",
                            err);
                        return err;
                    }
                }

                err = pC->m_pVideoDecoder->m_pFctGetOption(pC->pViDecCtxt,
                    M4DECODER_MPEG4_kOptionID_DecoderConfigInfo,
                    &DecConfInfo);

                if( M4NO_ERROR != err )
                {
                    M4OSA_TRACE1_1(
                        "M4MCS_intGetInputClipProperties:\
                         m_pVideoDecoder->m_pFctGetOption returns 0x%x!",
                        err);
                    return err;
                }
            }

#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */

            pC->InputFileProperties.uiVideoProfile = DecConfInfo.uiProfile;
            pC->InputFileProperties.uiVideoTimeScale = DecConfInfo.uiTimeScale;
            pC->InputFileProperties.bMPEG4dataPartition =
                DecConfInfo.bDataPartition;
            pC->InputFileProperties.bMPEG4rvlc = DecConfInfo.bUseOfRVLC;
            pC->InputFileProperties.bMPEG4resynchMarker =
                DecConfInfo.uiUseOfResynchMarker;

            /* Supported enum value for profile and level */
            switch( pC->InputFileProperties.uiVideoProfile )
            {
                case 0x08:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kMPEG4_SP_Level_0;
                    break;

                case 0x09:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kMPEG4_SP_Level_0b;
                    break;

                case 0x01:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kMPEG4_SP_Level_1;
                    break;

                case 0x02:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kMPEG4_SP_Level_2;
                    break;

                case 0x03:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kMPEG4_SP_Level_3;
                    break;

                case 0x04:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kMPEG4_SP_Level_4a;
                    break;

                case 0x05:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kMPEG4_SP_Level_5;
                    break;
            }
        }
        else if( M4VIDEOEDITING_kH263
            == pC->InputFileProperties.VideoStreamType )
        {
            err = pC->m_pReader->m_pFctGetOption(pC->pReaderContext,
                M4READER_3GP_kOptionID_H263Properties, &H263prop);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intGetInputClipProperties: m_pReader->m_pFctGetOption returns 0x%x!",
                    err);
                return err;
            }

            pC->InputFileProperties.uiH263level = H263prop.uiLevel;
            pC->InputFileProperties.uiVideoProfile = H263prop.uiProfile;

            /* Supported enum value for profile and level */
            if( pC->InputFileProperties.uiVideoProfile == 0 )
            {
                switch( pC->InputFileProperties.uiH263level )
                {
                    case 10:
                        pC->InputFileProperties.ProfileAndLevel =
                            M4VIDEOEDITING_kH263_Profile_0_Level_10;
                        break;

                    case 20:
                        pC->InputFileProperties.ProfileAndLevel =
                            M4VIDEOEDITING_kH263_Profile_0_Level_20;
                        break;

                    case 30:
                        pC->InputFileProperties.ProfileAndLevel =
                            M4VIDEOEDITING_kH263_Profile_0_Level_30;
                        break;

                    case 40:
                        pC->InputFileProperties.ProfileAndLevel =
                            M4VIDEOEDITING_kH263_Profile_0_Level_40;
                        break;

                    case 45:
                        pC->InputFileProperties.ProfileAndLevel =
                            M4VIDEOEDITING_kH263_Profile_0_Level_45;
                        break;
                }
            }

            /* For h263 set default timescale : 30000:1001 */
            pC->InputFileProperties.uiVideoTimeScale = 30000;
        }
        else if( M4VIDEOEDITING_kH264
            == pC->InputFileProperties.VideoStreamType )
        {
            AVCProfle = M4DECODER_AVC_kProfile_and_Level_Out_Of_Range;
            pC->InputFileProperties.uiVideoTimeScale = 30000;
#ifdef M4VSS_ENABLE_EXTERNAL_DECODERS

            err = M4DECODER_EXTERNAL_ParseAVCDSI(pC->pReaderVideoStream->
                m_basicProperties.m_pDecoderSpecificInfo,
                pC->pReaderVideoStream->
                m_basicProperties.m_decoderSpecificInfoSize,
                &AVCProfle);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intGetInputClipProperties():\
                     M4DECODER_EXTERNAL_ParseAVCDSI returns 0x%08X",
                    err);
                return err;
            }

#else

            if( pC->m_pVideoDecoder != M4OSA_NULL )
            {
                if( M4OSA_NULL == pC->pViDecCtxt )
                {
                    err = pC->m_pVideoDecoder->m_pFctCreate(&pC->pViDecCtxt,
                        &pC->pReaderVideoStream->m_basicProperties,
                        pC->m_pReaderDataIt, &pC->ReaderVideoAU,
                        M4OSA_NULL);

                    if( M4NO_ERROR != err )
                    {
                        M4OSA_TRACE1_1(
                            "M4MCS_intGetInputClipProperties:\
                             m_pVideoDecoder->m_pFctCreate returns 0x%x!",
                            err);
                        return err;
                    }
                }
                err = pC->m_pVideoDecoder->m_pFctGetOption(pC->pViDecCtxt,
                    M4DECODER_kOptionID_AVCProfileAndLevel, &AVCProfle);

                if( M4NO_ERROR != err )
                {
                    M4OSA_TRACE1_1(
                        "M4MCS_intGetInputClipProperties:\
                         m_pVideoDecoder->m_pFctGetOption returns 0x%x!",
                        err);
                    return err;
                }
            }

#endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */

            switch( AVCProfle )
            {
                case M4DECODER_AVC_kProfile_0_Level_1:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_1;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_1b:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_1b;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_1_1:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_1_1;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_1_2:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_1_2;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_1_3:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_1_3;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_2:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_2;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_2_1:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_2_1;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_2_2:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_2_2;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_3:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_3;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_3_1:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_3_1;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_3_2:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_3_2;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_4:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_4;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_4_1:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_4_1;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_4_2:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_4_2;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_5:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_5;
                    break;

                case M4DECODER_AVC_kProfile_0_Level_5_1:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kH264_Profile_0_Level_5_1;
                    break;

                case M4DECODER_AVC_kProfile_and_Level_Out_Of_Range:
                default:
                    pC->InputFileProperties.ProfileAndLevel =
                        M4VIDEOEDITING_kProfile_and_Level_Out_Of_Range;
            }
        }

        /* Here because width x height is correct only after dsi parsing
        (done in create decoder) */
        pC->InputFileProperties.uiVideoHeight =
            pC->pReaderVideoStream->m_videoHeight;
        pC->InputFileProperties.uiVideoWidth =
            pC->pReaderVideoStream->m_videoWidth;
        pC->InputFileProperties.uiClipVideoDuration =
            (M4OSA_UInt32)pC->pReaderVideoStream->m_basicProperties.m_duration;
        pC->InputFileProperties.fAverageFrameRate =
            pC->pReaderVideoStream->m_averageFrameRate;
        pC->InputFileProperties.uiVideoMaxAuSize =
            pC->pReaderVideoStream->m_basicProperties.m_maxAUSize;
    }
    else
    {
        if( M4OSA_TRUE == pC->bUnsupportedVideoFound )
        {
            pC->InputFileProperties.VideoStreamType =
                M4VIDEOEDITING_kUnsupportedVideo;
        }
        else
        {
            pC->InputFileProperties.VideoStreamType = M4VIDEOEDITING_kNoneVideo;
        }
    }

    /**
    * Audio stream properties */
    if( M4OSA_NULL != pC->pReaderAudioStream )
    {
        switch( pC->pReaderAudioStream->m_basicProperties.m_streamType )
        {
            case M4DA_StreamTypeAudioAmrNarrowBand:
                pC->InputFileProperties.AudioStreamType =
                    M4VIDEOEDITING_kAMR_NB;
                break;

            case M4DA_StreamTypeAudioAac:
                pC->InputFileProperties.AudioStreamType = M4VIDEOEDITING_kAAC;
                break;

            case M4DA_StreamTypeAudioMp3:
                pC->InputFileProperties.AudioStreamType = M4VIDEOEDITING_kMP3;
                break;

            case M4DA_StreamTypeAudioEvrc:
                pC->InputFileProperties.AudioStreamType = M4VIDEOEDITING_kEVRC;
                break;

            case M4DA_StreamTypeUnknown:
            default:
                pC->InputFileProperties.AudioStreamType =
                    M4VIDEOEDITING_kUnsupportedAudio;
                break;
        }

        if( ( M4OSA_NULL != pC->m_pAudioDecoder)
            && (M4OSA_NULL == pC->pAudioDecCtxt) )
        {
            M4OSA_TRACE3_1(
                "M4MCS_intGetInputClipProperties: calling CreateAudioDecoder, userData= 0x%x",
                pC->m_pCurrentAudioDecoderUserData);
            /* Trick, I use pUserData to retrieve aac properties, waiting for some
             better implementation... */
            if( M4DA_StreamTypeAudioAac
                == pC->pReaderAudioStream->m_basicProperties.m_streamType )
            {
                if( M4OSA_FALSE == pC->bExtOMXAudDecoder ) {
                    err = M4MCS_intCheckAndGetCodecAacProperties(pC);
                }
                else
                {
                    err = pC->m_pAudioDecoder->m_pFctCreateAudioDec(
                        &pC->pAudioDecCtxt, pC->pReaderAudioStream,
                        pC->m_pCurrentAudioDecoderUserData);

                    if( M4NO_ERROR == err )
                    {
                        /* AAC properties*/
                        //get from Reader; temporary, till Audio decoder shell API available to
                        //get the AAC properties
                        pC->AacProperties.aNumChan =
                            pC->pReaderAudioStream->m_nbChannels;
                        pC->AacProperties.aSampFreq =
                            pC->pReaderAudioStream->m_samplingFrequency;

                        err = pC->m_pAudioDecoder->m_pFctGetOptionAudioDec(
                            pC->pAudioDecCtxt, M4AD_kOptionID_StreamType,
                            (M4OSA_DataOption) &iAacType);

                        if( M4NO_ERROR != err )
                        {
                            M4OSA_TRACE1_1(
                                "M4MCS_intGetInputClipProperties:\
                                 m_pAudioDecoder->m_pFctGetOptionAudioDec returns err 0x%x",
                                err);
                            iAacType = M4_kAAC; //set to default
                            err = M4NO_ERROR;
                        }
                        else
                        {
                            M4OSA_TRACE3_1(
                                "M4MCS_intGetInputClipProperties:\
                                 m_pAudioDecoder->m_pFctGetOptionAudioDec returns streamType %d",
                                iAacType);
                        }

                        switch( iAacType )
                        {
                            case M4_kAAC:
                                pC->AacProperties.aSBRPresent = 0;
                                pC->AacProperties.aPSPresent = 0;
                                break;

                            case M4_kAACplus:
                                pC->AacProperties.aSBRPresent = 1;
                                pC->AacProperties.aPSPresent = 0;
                                pC->AacProperties.aExtensionSampFreq =
                                    pC->pReaderAudioStream->
                                    m_samplingFrequency; //TODO
                                break;

                            case M4_keAACplus:
                                pC->AacProperties.aSBRPresent = 1;
                                pC->AacProperties.aPSPresent = 1;
                                pC->AacProperties.aExtensionSampFreq =
                                    pC->pReaderAudioStream->
                                    m_samplingFrequency; //TODO
                                break;
                              case M4_kUnknown:
                              break;
                              default:
                              break;
                            }
                            M4OSA_TRACE3_2(
                                "M4MCS_intGetInputClipProperties: AAC NBChans=%d, SamplFreq=%d",
                                pC->AacProperties.aNumChan,
                                pC->AacProperties.aSampFreq);
                    }
                }
            }
            else
                err = pC->m_pAudioDecoder->m_pFctCreateAudioDec(
                &pC->pAudioDecCtxt, pC->pReaderAudioStream,
                pC->m_pCurrentAudioDecoderUserData);

            if( M4NO_ERROR != err )
            {
                M4OSA_TRACE1_1(
                    "M4MCS_intGetInputClipProperties:\
                     m_pAudioDecoder->m_pFctCreateAudioDec returns 0x%x",
                    err);
                return err;
            }
        }

        //EVRC
        if( pC->pReaderAudioStream->m_basicProperties.m_streamType
            == M4DA_StreamTypeAudioEvrc )
        {
            /* decoder not implemented yet, provide some default values for the null encoding */
            pC->pReaderAudioStream->m_nbChannels = 1;
            pC->pReaderAudioStream->m_samplingFrequency = 8000;
        }

        /**
        * Bugfix P4ME00001128: With some IMTC files, the AMR bit rate is 0 kbps according
         the GetProperties function */
        if( 0 == pC->pReaderAudioStream->m_basicProperties.m_averageBitRate )
        {
            if( M4VIDEOEDITING_kAMR_NB
                == pC->InputFileProperties.AudioStreamType )
            {
                /**
                * Better returning a guessed 12.2 kbps value than a sure-to-be-false
                0 kbps value! */
                pC->InputFileProperties.uiAudioBitrate =
                    M4VIDEOEDITING_k12_2_KBPS;
            }
            else if( M4VIDEOEDITING_kEVRC
                == pC->InputFileProperties.AudioStreamType )
            {
                /**
                * Better returning a guessed 8.5 kbps value than a sure-to-be-false
                0 kbps value! */
                pC->InputFileProperties.uiAudioBitrate =
                    M4VIDEOEDITING_k9_2_KBPS;
            }
            else
            {
                M4OSA_UInt32 FileBitrate;

                /* Can happen also for aac, in this case we calculate an approximative */
                /* value from global bitrate and video bitrate */
                err = pC->m_pReader->m_pFctGetOption(pC->pReaderContext,
                    M4READER_kOptionID_Bitrate,
                    (M4OSA_DataOption) &FileBitrate);

                if( M4NO_ERROR != err )
                {
                    M4OSA_TRACE1_1(
                        "M4MCS_intGetInputClipProperties: M4READER_kOptionID_Bitrate returns 0x%x",
                        err);
                    return err;
                }
                pC->InputFileProperties.uiAudioBitrate =
                    FileBitrate
                    - pC->
                    InputFileProperties.
                    uiVideoBitrate /* normally setted to 0, if no video */;
            }
        }
        else
        {
            pC->InputFileProperties.uiAudioBitrate =
                pC->pReaderAudioStream->m_basicProperties.m_averageBitRate;
        }

        pC->InputFileProperties.uiNbChannels =
            pC->pReaderAudioStream->m_nbChannels;
        pC->InputFileProperties.uiSamplingFrequency =
            pC->pReaderAudioStream->m_samplingFrequency;
        pC->InputFileProperties.uiClipAudioDuration =
            (M4OSA_UInt32)pC->pReaderAudioStream->m_basicProperties.m_duration;
        pC->InputFileProperties.uiAudioMaxAuSize =
            pC->pReaderAudioStream->m_basicProperties.m_maxAUSize;

        /* Bug: with aac, value is 0 until decoder start() is called */
        pC->InputFileProperties.uiDecodedPcmSize =
            pC->pReaderAudioStream->m_byteFrameLength
            * pC->pReaderAudioStream->m_byteSampleSize
            * pC->pReaderAudioStream->m_nbChannels;

        /* New aac properties */
        if( M4DA_StreamTypeAudioAac
            == pC->pReaderAudioStream->m_basicProperties.m_streamType )
        {
            pC->InputFileProperties.uiNbChannels = pC->AacProperties.aNumChan;
            pC->InputFileProperties.uiSamplingFrequency =
                pC->AacProperties.aSampFreq;

            if( pC->AacProperties.aSBRPresent )
            {
                pC->InputFileProperties.AudioStreamType =
                    M4VIDEOEDITING_kAACplus;
                pC->InputFileProperties.uiExtendedSamplingFrequency =
                    pC->AacProperties.aExtensionSampFreq;
            }

            if( pC->AacProperties.aPSPresent )
            {
                pC->InputFileProperties.AudioStreamType =
                    M4VIDEOEDITING_keAACplus;
            }
        }
    }
    else
    {
        if( M4OSA_TRUE == pC->bUnsupportedAudioFound )
        {
            pC->InputFileProperties.AudioStreamType =
                M4VIDEOEDITING_kUnsupportedAudio;
        }
        else
        {
            pC->InputFileProperties.AudioStreamType = M4VIDEOEDITING_kNoneAudio;
        }
    }

    /* Get 'ftyp' atom */
    err = pC->m_pReader->m_pFctGetOption(pC->pReaderContext,
        M4READER_kOptionID_3gpFtypBox, &pC->InputFileProperties.ftyp);

    if( M4NO_ERROR == err )
    {
        M4OSA_UInt8 i;

        for ( i = 0; i < pC->InputFileProperties.ftyp.nbCompatibleBrands; i++ )
            if( M4VIDEOEDITING_BRAND_EMP
                == pC->InputFileProperties.ftyp.compatible_brands[i] )
                pC->InputFileProperties.VideoStreamType =
                M4VIDEOEDITING_kMPEG4_EMP;
    }

    /* Analysis is successful */
    if( pC->InputFileProperties.uiClipVideoDuration
        > pC->InputFileProperties.uiClipAudioDuration )
        pC->InputFileProperties.uiClipDuration =
        pC->InputFileProperties.uiClipVideoDuration;
    else
        pC->InputFileProperties.uiClipDuration =
        pC->InputFileProperties.uiClipAudioDuration;

    pC->InputFileProperties.FileType = pC->InputFileType;
    pC->InputFileProperties.bAnalysed = M4OSA_TRUE;

    return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4OSA_UInt32 M4MCS_intGetFrameSize_AMRNB(M4OSA_MemAddr8 pAudioFrame)
 * @brief   Return the length, in bytes, of the AMR Narrow-Band frame contained in the given buffer
 * @note
 * @param   pCpAudioFrame   (IN) AMRNB frame
 * @return  M4NO_ERROR: No error
 ******************************************************************************
 */
static M4OSA_UInt32 M4MCS_intGetFrameSize_AMRNB( M4OSA_MemAddr8 pAudioFrame )
{
    M4OSA_UInt32 frameSize = 0;
    M4OSA_UInt32 frameType = ( ( *pAudioFrame) &(0xF << 3)) >> 3;

    switch( frameType )
    {
        case 0:
            frameSize = 95;
            break; /*  4750 bps */

        case 1:
            frameSize = 103;
            break; /*  5150 bps */

        case 2:
            frameSize = 118;
            break; /*  5900 bps */

        case 3:
            frameSize = 134;
            break; /*  6700 bps */

        case 4:
            frameSize = 148;
            break; /*  7400 bps */

        case 5:
            frameSize = 159;
            break; /*  7950 bps */

        case 6:
            frameSize = 204;
            break; /* 10200 bps */

        case 7:
            frameSize = 244;
            break; /* 12000 bps */

        case 8:
            frameSize = 39;
            break; /* SID (Silence) */

        case 15:
            frameSize = 0;
            break; /* No data */

        default:
            M4OSA_TRACE3_0(
                "M4MCS_intGetFrameSize_AMRNB(): Corrupted AMR frame! returning 0.");
            return 0;
    }

    return (1 + (( frameSize + 7) / 8));
}

/**
 ******************************************************************************
 * M4OSA_UInt32 M4MCS_intGetFrameSize_EVRC(M4OSA_MemAddr8 pAudioFrame)
 * @brief   Return the length, in bytes, of the EVRC frame contained in the given buffer
 * @note
 *     0 1 2 3
 *    +-+-+-+-+
 *    |fr type|              RFC 3558
 *    +-+-+-+-+
 *
 * Frame Type: 4 bits
 *    The frame type indicates the type of the corresponding codec data
 *    frame in the RTP packet.
 *
 * For EVRC and SMV codecs, the frame type values and size of the
 * associated codec data frame are described in the table below:
 *
 * Value   Rate      Total codec data frame size (in octets)
 * ---------------------------------------------------------
 *   0     Blank      0    (0 bit)
 *   1     1/8        2    (16 bits)
 *   2     1/4        5    (40 bits; not valid for EVRC)
 *   3     1/2       10    (80 bits)
 *   4     1         22    (171 bits; 5 padded at end with zeros)
 *   5     Erasure    0    (SHOULD NOT be transmitted by sender)
 *
 * @param   pCpAudioFrame   (IN) EVRC frame
 * @return  M4NO_ERROR: No error
 ******************************************************************************
 */
static M4OSA_UInt32 M4MCS_intGetFrameSize_EVRC( M4OSA_MemAddr8 pAudioFrame )
{
    M4OSA_UInt32 frameSize = 0;
    M4OSA_UInt32 frameType = ( *pAudioFrame) &0x0F;

    switch( frameType )
    {
        case 0:
            frameSize = 0;
            break; /*  blank */

        case 1:
            frameSize = 16;
            break; /*  1/8 */

        case 2:
            frameSize = 40;
            break; /*  1/4 */

        case 3:
            frameSize = 80;
            break; /*  1/2 */

        case 4:
            frameSize = 171;
            break; /*  1 */

        case 5:
            frameSize = 0;
            break; /*  erasure */

        default:
            M4OSA_TRACE3_0(
                "M4MCS_intGetFrameSize_EVRC(): Corrupted EVRC frame! returning 0.");
            return 0;
    }

    return (1 + (( frameSize + 7) / 8));
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intCheckMaxFileSize(M4MCS_Context pContext)
 * @brief    Check if max file size is greater enough to encode a file with the
 *           current selected bitrates and duration.
 * @param    pContext            (IN) MCS context
 * @return   M4NO_ERROR
 * @return   M4MCS_ERR_MAXFILESIZE_TOO_SMALL
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intCheckMaxFileSize( M4MCS_Context pContext )
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext *)(pContext);

    M4OSA_UInt32 duration;
    M4OSA_UInt32 audiobitrate;
    M4OSA_UInt32 videobitrate;

    /* free file size : OK */
    if( pC->uiMaxFileSize == 0 )
        return M4NO_ERROR;

    /* duration */
    if( pC->uiEndCutTime == 0 )
    {
        duration = pC->InputFileProperties.uiClipDuration - pC->uiBeginCutTime;
    }
    else
    {
        duration = pC->uiEndCutTime - pC->uiBeginCutTime;
    }

    /* audio bitrate */
    if( pC->noaudio )
    {
        audiobitrate = 0;
    }
    else if( pC->AudioEncParams.Format == M4ENCODER_kAudioNULL )
    {
        audiobitrate = pC->InputFileProperties.uiAudioBitrate;
    }
    else if( pC->uiAudioBitrate == M4VIDEOEDITING_kUndefinedBitrate )
    {
        switch( pC->AudioEncParams.Format )
        {
            case M4ENCODER_kAMRNB:
                audiobitrate = M4VIDEOEDITING_k12_2_KBPS;
                break;
                //EVRC
                //            case M4ENCODER_kEVRC:
                //                audiobitrate = M4VIDEOEDITING_k9_2_KBPS;
                //                break;

            default: /* AAC and MP3*/
                audiobitrate =
                    (pC->AudioEncParams.ChannelNum == M4ENCODER_kMono)
                    ? M4VIDEOEDITING_k16_KBPS : M4VIDEOEDITING_k32_KBPS;
                break;
        }
    }
    else
    {
        audiobitrate = pC->uiAudioBitrate;
    }

    /* video bitrate */
    if( pC->novideo )
    {
        videobitrate = 0;
    }
    else if( pC->EncodingVideoFormat == M4ENCODER_kNULL )
    {
        videobitrate = pC->InputFileProperties.uiVideoBitrate;
    }
    else if( pC->uiVideoBitrate == M4VIDEOEDITING_kUndefinedBitrate )
    {
        videobitrate = M4VIDEOEDITING_k16_KBPS;
    }
    else
    {
        videobitrate = pC->uiVideoBitrate;
    }

    /* max file size */
    if( (M4OSA_UInt32)pC->uiMaxFileSize
        < (M4OSA_UInt32)(M4MCS_MOOV_OVER_FILESIZE_RATIO
        * (audiobitrate + videobitrate) * (duration / 8000.0)) )
        return M4MCS_ERR_MAXFILESIZE_TOO_SMALL;
    else
        return M4NO_ERROR;
}

/**
 ******************************************************************************
 * M4VIDEOEDITING_Bitrate M4MCS_intGetNearestBitrate(M4OSA_UInt32 freebitrate, M4OSA_Int8 mode)
 * @brief    Returns the closest bitrate value from the enum list of type M4VIDEOEDITING_Bitrate
 * @param    freebitrate: unsigned int value
 * @param    mode: -1:previous,0:current,1:next
 * @return   bitrate value in enum list M4VIDEOEDITING_Bitrate
 ******************************************************************************
 */
static M4VIDEOEDITING_Bitrate
M4MCS_intGetNearestBitrate( M4OSA_Int32 freebitrate, M4OSA_Int8 mode )
{
    M4OSA_Int32 bitarray [] =
    {
        0, M4VIDEOEDITING_k16_KBPS, M4VIDEOEDITING_k24_KBPS,
        M4VIDEOEDITING_k32_KBPS, M4VIDEOEDITING_k48_KBPS,
        M4VIDEOEDITING_k64_KBPS, M4VIDEOEDITING_k96_KBPS,
        M4VIDEOEDITING_k128_KBPS, M4VIDEOEDITING_k192_KBPS,
        M4VIDEOEDITING_k256_KBPS, M4VIDEOEDITING_k288_KBPS,
        M4VIDEOEDITING_k384_KBPS, M4VIDEOEDITING_k512_KBPS,
        M4VIDEOEDITING_k800_KBPS, M4VIDEOEDITING_k2_MBPS,
        M4VIDEOEDITING_k5_MBPS,
        M4VIDEOEDITING_k8_MBPS, /*+ New Encoder bitrates */
        M4OSA_INT32_MAX
    };

    const M4OSA_UInt32 nbbitrates = 14;
    M4OSA_UInt32 i;

    for ( i = 0; freebitrate >= bitarray[i]; i++ );

    switch( mode )
    {
        case -1: /* previous */
            if( i <= 2 )
                return 0;
            else
                return bitarray[i - 2];
            break;

        case 0: /* current */
            if( i <= 1 )
                return 0;
            else
                return bitarray[i - 1];
            break;

        case 1: /* next */
            if( i >= nbbitrates )
                return M4OSA_INT32_MAX;
            else
                return bitarray[i];
            break;
    }

    return 0;
}

/**
 ******************************************************************************
 * M4OSA_ERR M4MCS_intCleanUp_ReadersDecoders(M4MCS_InternalContext* pC);
 * @brief    Free all resources allocated by M4MCS_open()
 * @param    pContext            (IN) MCS context
 * @return   M4NO_ERROR:         No error
 ******************************************************************************
 */
static M4OSA_ERR M4MCS_intCleanUp_ReadersDecoders( M4MCS_InternalContext *pC )
{
    M4OSA_ERR err = M4NO_ERROR;

    M4OSA_TRACE2_1("M4MCS_intCleanUp_ReadersDecoders called with pC=0x%x", pC);

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

    if( M4OSA_NULL != pC->
        pReaderContext ) /**< may be M4OSA_NULL if M4MCS_open was not called */
    {
        err = pC->m_pReader->m_pFctClose(pC->pReaderContext);

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1("M4MCS_cleanUp: m_pReader->m_pFctClose returns 0x%x",
                err);
            /**< don't return, we still have stuff to free */
        }

        err = pC->m_pReader->m_pFctDestroy(pC->pReaderContext);
        pC->pReaderContext = M4OSA_NULL;

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_cleanUp: m_pReader->m_pFctDestroy returns 0x%x", err);
            /**< don't return, we still have stuff to free */
        }
    }

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

    if( pC->m_pDataAddress2 != M4OSA_NULL )
    {
        free(pC->m_pDataAddress2);
        pC->m_pDataAddress2 = M4OSA_NULL;
    }
    /*Bug fix 11/12/2008 (to obtain more precise video end cut)*/
    if( pC->m_pDataVideoAddress1 != M4OSA_NULL )
    {
        free(pC->m_pDataVideoAddress1);
        pC->m_pDataVideoAddress1 = M4OSA_NULL;
    }

    if( pC->m_pDataVideoAddress2 != M4OSA_NULL )
    {
        free(pC->m_pDataVideoAddress2);
        pC->m_pDataVideoAddress2 = M4OSA_NULL;
    }
    /**/
    /* ----- Free video decoder stuff, if needed ----- */

    if( M4OSA_NULL != pC->pViDecCtxt )
    {
        err = pC->m_pVideoDecoder->m_pFctDestroy(pC->pViDecCtxt);
        pC->pViDecCtxt = M4OSA_NULL;

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_cleanUp: m_pVideoDecoder->pFctDestroy returns 0x%x",
                err);
            /**< don't return, we still have stuff to free */
        }
    }

    /* ----- Free the audio decoder stuff ----- */

    if( M4OSA_NULL != pC->pAudioDecCtxt )
    {
        err = pC->m_pAudioDecoder->m_pFctDestroyAudioDec(pC->pAudioDecCtxt);
        pC->pAudioDecCtxt = M4OSA_NULL;

        if( M4NO_ERROR != err )
        {
            M4OSA_TRACE1_1(
                "M4MCS_cleanUp: m_pAudioDecoder->m_pFctDestroyAudioDec returns 0x%x",
                err);
            /**< don't return, we still have stuff to free */
        }
    }

    if( M4OSA_NULL != pC->AudioDecBufferOut.m_dataAddress )
    {
        free(pC->AudioDecBufferOut.m_dataAddress);
        pC->AudioDecBufferOut.m_dataAddress = M4OSA_NULL;
    }

    return M4NO_ERROR;
}


/**

 ******************************************************************************
 * M4OSA_ERR M4MCS_open_normalMode(M4MCS_Context pContext, M4OSA_Void* pFileIn,
 *                             M4OSA_Void* pFileOut, M4OSA_Void* pTempFile);
 * @brief   Set the MCS input and output files. It is the same as M4MCS_open without
 *                                M4MCS_WITH_FAST_OPEN flag
It is used in VideoArtist
 * @note    It opens the input file, but the output file is not created yet.
 * @param   pContext            (IN) MCS context
 * @param   pFileIn             (IN) Input file to transcode (The type of this parameter
 *                                    (URL, pipe...) depends on the OSAL implementation).
 * @param   mediaType           (IN) Container type (.3gp,.amr, ...) of input file.
 * @param   pFileOut            (IN) Output file to create  (The type of this parameter
 *                                (URL, pipe...) depends on the OSAL implementation).
 * @param   pTempFile           (IN) Temporary file for the constant memory writer to store
 *                                 metadata ("moov.bin").
 * @return  M4NO_ERROR:         No error
 * @return  M4ERR_PARAMETER:    At least one parameter is M4OSA_NULL (debug only)
 * @return  M4ERR_STATE:        MCS is not in an appropriate state for this function to be called
 * @return  M4ERR_ALLOC:        There is no more available memory
 * @return  M4ERR_FILE_NOT_FOUND:   The input file has not been found
 * @return  M4MCS_ERR_INVALID_INPUT_FILE:   The input file is not a valid file, or is corrupted
 * @return  M4MCS_ERR_INPUT_FILE_CONTAINS_NO_SUPPORTED_STREAM:  The input file contains no
 *                                                         supported audio or video stream
 ******************************************************************************
 */
M4OSA_ERR M4MCS_open_normalMode(M4MCS_Context pContext, M4OSA_Void* pFileIn,
                                 M4VIDEOEDITING_FileType InputFileType,
                                  M4OSA_Void* pFileOut, M4OSA_Void* pTempFile)
{
    M4MCS_InternalContext *pC = (M4MCS_InternalContext*)(pContext);
    M4OSA_ERR err;

    M4READER_MediaFamily mediaFamily;
    M4_StreamHandler* pStreamHandler;

    M4OSA_TRACE2_3("M4MCS_open_normalMode called with pContext=0x%x, pFileIn=0x%x,\
     pFileOut=0x%x", pContext, pFileIn, pFileOut);

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

    if ((InputFileType == M4VIDEOEDITING_kFileType_JPG)
        ||(InputFileType == M4VIDEOEDITING_kFileType_PNG)
        ||(InputFileType == M4VIDEOEDITING_kFileType_GIF)
        ||(InputFileType == M4VIDEOEDITING_kFileType_BMP))
    {
        M4OSA_TRACE1_0("M4MCS_open_normalMode: Still picture is not\
             supported with this function");
        return M4MCS_ERR_INPUT_FILE_CONTAINS_NO_SUPPORTED_STREAM;
    }

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

    /* Copy function input parameters into our context */
    pC->pInputFile     = pFileIn;
    pC->InputFileType  = InputFileType;
    pC->pOutputFile    = pFileOut;
    pC->pTemporaryFile = pTempFile;

    /***********************************/
    /* Open input file with the reader */
    /***********************************/

    err = M4MCS_setCurrentReader(pContext, pC->InputFileType);
    M4ERR_CHECK_RETURN(err);

    /**
    * Reset reader related variables */
    pC->VideoState          = M4MCS_kStreamState_NOSTREAM;
    pC->AudioState          = M4MCS_kStreamState_NOSTREAM;
    pC->pReaderVideoStream  = M4OSA_NULL;
    pC->pReaderAudioStream  = M4OSA_NULL;

    /*******************************************************/
    /* Initializes the reader shell and open the data file */
    /*******************************************************/
    err = pC->m_pReader->m_pFctCreate(&pC->pReaderContext);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4MCS_open_normalMode(): m_pReader->m_pFctCreate returns 0x%x", err);
        return err;
    }

    /**
    * Link the reader interface to the reader context */
    pC->m_pReaderDataIt->m_readerContext = pC->pReaderContext;

    /**
    * Set the reader shell file access functions */
    err = pC->m_pReader->m_pFctSetOption(pC->pReaderContext,
         M4READER_kOptionID_SetOsaFileReaderFctsPtr,
        (M4OSA_DataOption)pC->pOsaFileReadPtr);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4MCS_open_normalMode(): m_pReader->m_pFctSetOption returns 0x%x", err);
        return err;
    }

    /**
    * Open the input file */
    err = pC->m_pReader->m_pFctOpen(pC->pReaderContext, pC->pInputFile);
    if (M4NO_ERROR != err)
    {
        M4OSA_UInt32 uiDummy, uiCoreId;
        M4OSA_TRACE1_1("M4MCS_open_normalMode(): m_pReader->m_pFctOpen returns 0x%x", err);

        if (err == ((M4OSA_UInt32)M4ERR_UNSUPPORTED_MEDIA_TYPE)) {
            M4OSA_TRACE1_0("M4MCS_open_normalMode(): returning M4MCS_ERR_FILE_DRM_PROTECTED");
            return M4MCS_ERR_FILE_DRM_PROTECTED;
        } else {
            /**
            * If the error is from the core reader, we change it to a public VXS error */
            M4OSA_ERR_SPLIT(err, uiDummy, uiCoreId, uiDummy);
            if (M4MP4_READER == uiCoreId)
            {
                M4OSA_TRACE1_0("M4MCS_open_normalMode(): returning M4MCS_ERR_INVALID_INPUT_FILE");
                return M4MCS_ERR_INVALID_INPUT_FILE;
            }
        }
        return err;
    }

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

        /**
        * In case we found a BIFS stream or something else...*/
        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 the first video stream */
            if ((M4READER_kMediaFamilyVideo == mediaFamily) \
                && (M4OSA_NULL == pC->pReaderVideoStream))
            {
                if ((M4DA_StreamTypeVideoH263==pStreamHandler->m_streamType) ||
                    (M4DA_StreamTypeVideoMpeg4==pStreamHandler->m_streamType)
#ifdef M4VSS_SUPPORT_VIDEO_AVC
                    ||(M4DA_StreamTypeVideoMpeg4Avc==pStreamHandler->m_streamType))
#else
                    ||((M4DA_StreamTypeVideoMpeg4Avc==pStreamHandler->m_streamType)
                    &&(pC->m_pVideoDecoderItTable[M4DECODER_kVideoTypeAVC] != M4OSA_NULL)))
#endif
                {
                    M4OSA_TRACE3_0("M4MCS_open_normalMode():\
                     Found a H263 or MPEG-4 video stream in input 3gpp clip");

                    /**
                    * Keep pointer to the video stream */
                    pC->pReaderVideoStream = (M4_VideoStreamHandler*)pStreamHandler;
                    pC->bUnsupportedVideoFound = M4OSA_FALSE;
                    pStreamHandler->m_bStreamIsOK = M4OSA_TRUE;

                    /**
                    * Init our video stream state variable */
                    pC->VideoState = M4MCS_kStreamState_STARTED;

                    /**
                    * Reset the stream reader */
                    err = pC->m_pReader->m_pFctReset(pC->pReaderContext,
                         (M4_StreamHandler*)pC->pReaderVideoStream);
                    if (M4NO_ERROR != err)
                    {
                        M4OSA_TRACE1_1("M4MCS_open_normalMode():\
                             m_pReader->m_pFctReset(video) returns 0x%x", err);
                        return err;
                    }

                    /**
                    * Initializes an access Unit */
                    err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext, pStreamHandler,
                         &pC->ReaderVideoAU);
                    if (M4NO_ERROR != err)
                    {
                        M4OSA_TRACE1_1("M4MCS_open_normalMode():\
                             m_pReader->m_pFctFillAuStruct(video) returns 0x%x", err);
                        return err;
                    }
                }
                else /**< Not H263 or MPEG-4 (H264, etc.) */
                {
                    M4OSA_TRACE1_1("M4MCS_open_normalMode():\
                         Found an unsupported video stream (0x%x) in input 3gpp clip",
                             pStreamHandler->m_streamType);

                    pC->bUnsupportedVideoFound = M4OSA_TRUE;
                    pStreamHandler->m_bStreamIsOK = M4OSA_FALSE;
                }
            }
            /**
            * Found the first audio stream */
            else if ((M4READER_kMediaFamilyAudio == mediaFamily)
                && (M4OSA_NULL == pC->pReaderAudioStream))
            {
                if ((M4DA_StreamTypeAudioAmrNarrowBand==pStreamHandler->m_streamType) ||
                    (M4DA_StreamTypeAudioAac==pStreamHandler->m_streamType) ||
                    (M4DA_StreamTypeAudioMp3==pStreamHandler->m_streamType) ||
                    (M4DA_StreamTypeAudioEvrc==pStreamHandler->m_streamType) )
                {
                    M4OSA_TRACE3_0("M4MCS_open_normalMode(): Found an AMR-NB, AAC \
                        or MP3 audio stream in input clip");

                    /**
                    * Keep pointer to the audio stream */
                    pC->pReaderAudioStream = (M4_AudioStreamHandler*)pStreamHandler;
                    pStreamHandler->m_bStreamIsOK = M4OSA_TRUE;
                    pC->bUnsupportedAudioFound = M4OSA_FALSE;

                    /**
                    * Init our audio stream state variable */
                    pC->AudioState = M4MCS_kStreamState_STARTED;

                    /**
                    * Reset the stream reader */
                    err = pC->m_pReader->m_pFctReset(pC->pReaderContext,
                         (M4_StreamHandler*)pC->pReaderAudioStream);
                    if (M4NO_ERROR != err)
                    {
                        M4OSA_TRACE1_1("M4MCS_open_normalMode():\
                             m_pReader->m_pFctReset(audio) returns 0x%x", err);
                        return err;
                    }

                    /**
                    * Initializes an access Unit */
                    err = pC->m_pReader->m_pFctFillAuStruct(pC->pReaderContext, pStreamHandler,
                         &pC->ReaderAudioAU);
                    if (M4NO_ERROR != err)
                    {
                        M4OSA_TRACE1_1("M4MCS_open_normalMode(): \
                            m_pReader->m_pFctFillAuStruct(audio) returns 0x%x", err);
                        return err;
                    }

                    /**
                    * Output max AU size is equal to input max AU size (this value
                    * will be changed if there is audio transcoding) */
                    pC->uiAudioMaxAuSize = pStreamHandler->m_maxAUSize;

                }
                else
                {
                    /**< Not AMR-NB, AAC, MP3 nor EVRC (AMR-WB, WAV...) */
                    M4OSA_TRACE1_1("M4MCS_open_normalMode(): Found an unsupported audio stream\
                         (0x%x) in input 3gpp clip", pStreamHandler->m_streamType);

                    pC->bUnsupportedAudioFound = M4OSA_TRUE;
                    pStreamHandler->m_bStreamIsOK = M4OSA_FALSE;
                }
            }
        }
    } /**< end of while (M4NO_ERROR == err) */

    /**
    * Check we found at least one supported stream */
    if((M4OSA_NULL == pC->pReaderVideoStream) && (M4OSA_NULL == pC->pReaderAudioStream))
    {
        M4OSA_TRACE1_0("M4MCS_open_normalMode(): returning \
            M4MCS_ERR_INPUT_FILE_CONTAINS_NO_SUPPORTED_STREAM");
        return M4MCS_ERR_INPUT_FILE_CONTAINS_NO_SUPPORTED_STREAM;
    }

#ifndef M4VSS_ENABLE_EXTERNAL_DECODERS
    if(pC->VideoState == M4MCS_kStreamState_STARTED)
    {
        err = M4MCS_setCurrentVideoDecoder(pContext,
            pC->pReaderVideoStream->m_basicProperties.m_streamType);
        M4ERR_CHECK_RETURN(err);
    }
#endif

    if(pC->AudioState == M4MCS_kStreamState_STARTED)
    {
        //EVRC
        if(M4DA_StreamTypeAudioEvrc != pStreamHandler->m_streamType)
         /* decoder not supported yet, but allow to do null encoding */
        {
            err = M4MCS_setCurrentAudioDecoder(pContext,
                 pC->pReaderAudioStream->m_basicProperties.m_streamType);
            M4ERR_CHECK_RETURN(err);
        }
    }

    /**
    * Get the audio and video stream properties */
    err = M4MCS_intGetInputClipProperties(pC);
    if (M4NO_ERROR != err)
    {
        M4OSA_TRACE1_1("M4MCS_open_normalMode():\
             M4MCS_intGetInputClipProperties returns 0x%x", err);
        return err;
    }

    /**
    * Set the begin cut decoding increment according to the input frame rate */
    if (0. != pC->InputFileProperties.fAverageFrameRate) /**< sanity check */
    {
        pC->iVideoBeginDecIncr = (M4OSA_Int32)(3000. \
            / pC->InputFileProperties.fAverageFrameRate); /**< about 3 frames */
    }
    else
    {
        pC->iVideoBeginDecIncr = 200; /**< default value: 200 milliseconds (3 frames @ 15fps)*/
    }

    /**
    * Update state automaton */
    pC->State = M4MCS_kState_OPENED;

    /**
    * Return with no error */
    M4OSA_TRACE3_0("M4MCS_open_normalMode(): returning M4NO_ERROR");
    return M4NO_ERROR;
}

M4OSA_ERR M4MCS_intCheckAndGetCodecAacProperties(
                                 M4MCS_InternalContext *pC) {

    M4OSA_ERR err = M4NO_ERROR;
    M4AD_Buffer outputBuffer;
    uint32_t optionValue =0;

    M4OSA_TRACE3_0("M4MCS_intCheckAndGetCodecAacProperties :start");

    // Decode first audio frame from clip to get properties from codec

    err = pC->m_pAudioDecoder->m_pFctCreateAudioDec(
                    &pC->pAudioDecCtxt,
                    pC->pReaderAudioStream, &(pC->AacProperties));

    pC->m_pAudioDecoder->m_pFctSetOptionAudioDec(pC->pAudioDecCtxt,
           M4AD_kOptionID_3gpReaderInterface, (M4OSA_DataOption) pC->m_pReaderDataIt);

    pC->m_pAudioDecoder->m_pFctSetOptionAudioDec(pC->pAudioDecCtxt,
           M4AD_kOptionID_AudioAU, (M4OSA_DataOption) &pC->ReaderAudioAU);

    if( pC->m_pAudioDecoder->m_pFctStartAudioDec != M4OSA_NULL ) {

        err = pC->m_pAudioDecoder->m_pFctStartAudioDec(pC->pAudioDecCtxt);
        if( M4NO_ERROR != err ) {

            M4OSA_TRACE1_1(
                "M4MCS_intCheckAndGetCodecAACProperties: m_pFctStartAudioDec \
                 returns 0x%x", err);
            return err;
        }
    }

    /**
    * Allocate output buffer for the audio decoder */
    outputBuffer.m_bufferSize =
        pC->pReaderAudioStream->m_byteFrameLength
        * pC->pReaderAudioStream->m_byteSampleSize
        * pC->pReaderAudioStream->m_nbChannels;

    if( outputBuffer.m_bufferSize > 0 ) {

        outputBuffer.m_dataAddress =
            (M4OSA_MemAddr8)M4OSA_32bitAlignedMalloc(outputBuffer.m_bufferSize \
            *sizeof(short), M4MCS, (M4OSA_Char *)"outputBuffer.m_bufferSize");

        if( M4OSA_NULL == outputBuffer.m_dataAddress ) {

            M4OSA_TRACE1_0(
                "M4MCS_intCheckAndGetCodecAACProperties():\
                 unable to allocate outputBuffer.m_dataAddress, returning M4ERR_ALLOC");
            return M4ERR_ALLOC;
        }
    }

    err = pC->m_pAudioDecoder->m_pFctStepAudioDec(pC->pAudioDecCtxt,
        M4OSA_NULL, &outputBuffer, M4OSA_FALSE);

    if ( err == M4WAR_INFO_FORMAT_CHANGE ) {

        // Get the properties from codec node
        pC->m_pAudioDecoder->m_pFctGetOptionAudioDec(pC->pAudioDecCtxt,
           M4AD_kOptionID_AudioNbChannels, (M4OSA_DataOption) &optionValue);

        pC->AacProperties.aNumChan = optionValue;
        // Reset Reader structure value also
        pC->pReaderAudioStream->m_nbChannels = optionValue;

        pC->m_pAudioDecoder->m_pFctGetOptionAudioDec(pC->pAudioDecCtxt,
         M4AD_kOptionID_AudioSampFrequency, (M4OSA_DataOption) &optionValue);

        pC->AacProperties.aSampFreq = optionValue;
        // Reset Reader structure value also
        pC->pReaderAudioStream->m_samplingFrequency = optionValue;

    } else if( err != M4NO_ERROR) {
        M4OSA_TRACE1_1("M4MCS_intCheckAndGetCodecAACProperties:\
            m_pFctStepAudioDec returns err = 0x%x", err);
    }

    free(outputBuffer.m_dataAddress);

    // Reset the stream reader
    err = pC->m_pReader->m_pFctReset(pC->pReaderContext,
                 (M4_StreamHandler *)pC->pReaderAudioStream);

    if (M4NO_ERROR != err) {
        M4OSA_TRACE1_1("M4MCS_intCheckAndGetCodecAACProperties\
            Error in reseting reader: 0x%x", err);
    }

    return err;

}