/*

* Copyright (c) 2009 Aricent and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Aricent - initial contribution.

*

* Contributors:

*

* Description:

* Implementation of member functions of Plugin class

* (CAriHeAacDecMmfCodec).

*

*/

#include <ecom.h>

#include <implementationproxy.h>

#include "ariheaacdecwrapper.h"

#include "ariheaacdecmmfcodec.h"

#include "ariheaacdecmmfcodec_uid.hrh"

#include "ariprint.h"

//Maximum size of a single input frame in an AAC stream

const TInt KMinBytesInput = 1536;

//Maximum size of a single output frame in an AAC stream

const TInt KMaxOutputBufSize = 8192;

const TInt KMinParamSize = 11;

const TInt KRenderStatusIndex = 13;

const TInt KMarkPlayStatusIndex = 14;

const TInt KEnableStatusIndex = 15;

// ---------------------------------------------------------------------------

//  Two-phased constructor.

//  Creates an instance of CAriHeAacDecMmfCodec.

//  Instance is not left on cleanup stack.

// ---------------------------------------------------------------------------

//

CMMFCodec* CAriHeAacDecMmfCodec::NewL()

    {

    PRINT_ENTRY;

    CAriHeAacDecMmfCodec* self = new ( ELeave ) CAriHeAacDecMmfCodec();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    PRINT_EXIT;

    return ( CMMFCodec* )self;

    }

// ---------------------------------------------------------------------------

//  Destructor;Destroys the decoder instance and any internal buffers

// ---------------------------------------------------------------------------

//

CAriHeAacDecMmfCodec::~CAriHeAacDecMmfCodec()

    {

    PRINT_ENTRY;

    if ( iInternalInputBuffer )

        {

        delete iInternalInputBuffer;

        iInternalInputBuffer = NULL;

        }

    if ( iInternalOutputBuffer )

        {

        delete iInternalOutputBuffer;

        iInternalOutputBuffer = NULL;

        }

    if ( iCodec )

        {

        delete iCodec;

        iCodec = NULL;

        }

    iConfigured = EFalse;

    PRINT_EXIT;

    }

// ---------------------------------------------------------------------------

//  From class CMMFCodec.

//  The function Sets codec configuration.

//  The value used for aConfigType must be KUidMmfCodecAudioSettings

//  (defined in include\mmf\plugins\mmfCodecImplementationUIDs.hrh)

// ---------------------------------------------------------------------------

//

void CAriHeAacDecMmfCodec::ConfigureL( TUid /* aConfigType */,

                                    const TDesC8& aParam )

    {

    PRINT_ENTRY;

    TInt paramLen = aParam.Length();

    PRINT_MSG( LEVEL_HIGH, ( "param Len: %d",

                                        paramLen ) );

    if ( paramLen < KMinParamSize )

        {

        PRINT_MSG( LEVEL_HIGH, ( "param Len: %d",

                                    paramLen ) );

        PRINT_ERR( "Incorrect parameter descriptor " );

        User::Leave( KErrArgument );

        }

    if ( !iConfigured )

        {

        RArray<TInt>  configParam = ( RArray<TInt>& )( aParam );

        TInt index = 0;

        index++;

        //configParam[1] holds NoOfChannels

        iFrameInfo.iNoOfChannels = configParam[index++];

        //configParam[2] holds Profile

        iFrameInfo.iProfile = configParam[index++];

        //configParam[3] holds OutFrameSize

        iFrameInfo.iOutFrameSize = configParam[index++];

        //configParam[4] holds NoOfSamples

        iFrameInfo.iNoOfSamples = configParam[index++];

        //configParam[5] holds SamplingFrequency

        iFrameInfo.iSamplingFrequency = configParam[index++];

        //Ignore fields 6,7 & 8

        index++;

        index++;

        index++;

        //configParam[9] holds OutSamplingFrequency

        iFrameInfo.iOutSamplingFrequency = configParam[index++];

        //configParam[10] holds ExtObjectType

        iFrameInfo.iExtObjectType = configParam[index];

        iFrameInfo.iDownSampledMode = 0;

        if ( paramLen > KMinParamSize)

            {

            /**

             * Call Reset only if fields 13,14 and 15 of the

             * Param array are set to zero

             */

            if ( ( configParam[KRenderStatusIndex] == 0 &&

                                    configParam[KMarkPlayStatusIndex] == 0 &&

                                    configParam[KEnableStatusIndex] == 0 ) )

                {

                PRINT_MSG( LEVEL_HIGH, ( "frameInfo->OutFrameSize: %d",

                                            iFrameInfo.iOutFrameSize ) );

                PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->NoOfSamples: %d",

                                            iFrameInfo.iNoOfSamples ) );

                PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->SamplingFrequency: %d",

                                            iFrameInfo.iSamplingFrequency ) );

                PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->NoOfChannels: %d",

                                            iFrameInfo.iNoOfChannels ) );

                PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->Profile: %d",

                                            iFrameInfo.iProfile ) );

                PRINT_MSG( LEVEL_HIGH,

                                    ( "iFrameInfo->OutSamplingFrequency: %d",

                                        iFrameInfo.iOutSamplingFrequency ) );

                PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->ExtObjectType: %d",

                                            iFrameInfo.iExtObjectType ) );

                PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->DownSampledMode: %d",

                                            iFrameInfo.iDownSampledMode ) );

                User::LeaveIfError( iCodec->Reset( &iFrameInfo ) );

                iConfigured = ETrue;

                iOutFrameSize = iFrameInfo.iOutFrameSize;

                }

            }

        else

            {

            PRINT_MSG( LEVEL_HIGH, ( "frameInfo->OutFrameSize: %d",

                                               iFrameInfo.iOutFrameSize ) );

            PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->NoOfSamples: %d",

                                       iFrameInfo.iNoOfSamples ) );

            PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->SamplingFrequency: %d",

                                       iFrameInfo.iSamplingFrequency ) );

            PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->NoOfChannels: %d",

                                       iFrameInfo.iNoOfChannels ) );

            PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->Profile: %d",

                                       iFrameInfo.iProfile ) );

            PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->OutSamplingFrequency: %d",

                                       iFrameInfo.iOutSamplingFrequency ) );

            PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->ExtObjectType: %d",

                                       iFrameInfo.iExtObjectType ) );

            PRINT_MSG( LEVEL_HIGH, ( "iFrameInfo->DownSampledMode: %d",

                                       iFrameInfo.iDownSampledMode ) );

            User::LeaveIfError( iCodec->Reset( &iFrameInfo ) );

            iConfigured = ETrue;

            iOutFrameSize = iFrameInfo.iOutFrameSize;

            }

        }

    PRINT_EXIT;

    }

// ---------------------------------------------------------------------------

//  From class CMMFCodec.

//  This function is used to flush out status information when a

//  reposition occurs.

//  This is used if the codec requires resetting prior to use.

// ---------------------------------------------------------------------------

//

void CAriHeAacDecMmfCodec::ResetL()

    {

    PRINT_ENTRY;

    iInternalInputBufferResidueLen = 0;

    iInternalOutputBufferResidueLen = 0;

    iInternalOutputBufferPos = 0;

    PRINT_EXIT;

    }

// ---------------------------------------------------------------------------

//  From class CMMFCodec.

//  This function is used to decode the given source and fill the destination

//  buffer with the decode data.

//  The buffers can be of any size.  Since the buffers can be of any size

//  there is no guarantee that all the source buffer can be processed to fill

//  the destination buffer or that the all the source buffer may be processed

//  before the destination is full.  Therefore the ProcessL needs to return a

//  TCodecProcessResult returing the number of source bytes processed and the

//  number of destination bytes processed along with a process result code

//  defined thus:

//  - EProcessComplete: the codec processed all the source data into the sink

//    buffer

//  - EProcessIncomplete: the codec filled sink buffer before all the source

//    buffer was processed

//  - EDstNotFilled: the codec processed the source buffer but the sink buffer

//    was not filled

//  - EEndOfData: the codec detected the end data - all source data in

//    processed but sink may not be full

//  - EProcessError: the codec process error condition

//

//  The ProcessL should start processing the source buffer from the iPosition

//  data member of the source data and start filling the destination buffer

//  from its iPosition.

//  --------------------------------------------------------------------------

//

TCodecProcessResult CAriHeAacDecMmfCodec::ProcessL( const CMMFBuffer& aSrc,

                                                CMMFBuffer& aDst )

    {

    PRINT_ENTRY;

    if ( !iConfigured )

        {

        PRINT_ERR( "Decoder not yet configured" );

        User::Leave( KErrNotReady );

        }

    // total decoded bytes added to the dst buffer

    TInt totalDstBytesAdded = 0;

    // total src bytes added to the internal src buffer

    TInt totalSrcBytesCopied = 0;

    // temporary variable to use for copying the sorce or destination data

    TInt numberOfBytesCopied = 0;

    TInt dstBufferRemainingBytes = 0;

    /**

     * Process the dst buffer, update the dstBufferPos and check

     * whether dst buffer is NULL or not.

     */

    CMMFDataBuffer* dst = static_cast<CMMFDataBuffer*>( &aDst );

    const TInt dstMaxLen = dst->Data().MaxLength();

    TUint8* dstPtr = const_cast<TUint8*>( dst->Data().Ptr() );

    TInt dstBufferPos = dst->Position();

    /**

     * Process the src buffer, update srcbuffer length, position and

     * flag for last frame. check whether src buffer is NULL or not

     * and check src buffer contains any data

     */

    const CMMFDataBuffer* src = static_cast<const CMMFDataBuffer*>( &aSrc );

    TUint8* srcPtr = const_cast<TUint8*>( src->Data().Ptr() );

    TInt srcBufferLen = src->Data().Length();

    TInt srcBufferPos = src->Position();

    TBool lastFrame = src->LastBuffer();

    PRINT_MSG( LEVEL_HIGH, ( "Src Buffer Pos: %d", srcBufferPos ) );

    PRINT_MSG( LEVEL_HIGH, ( "Dst Buffer Pos: %d", dstBufferPos ) );

    PRINT_MSG( LEVEL_HIGH, ( "Residue in internal output buffer: %d",

           iInternalOutputBufferResidueLen - iInternalOutputBufferPos ) );

    PRINT_MSG( LEVEL_HIGH, ( "Residue in internal input buffer: %d",

                                      iInternalInputBufferResidueLen ) );

    /**

     * if any destination bytes from internal destination buffer is not

     * given to the dst buffer from the previous call, give it to the

     * dst buffer. After this block, it ensures that no bytes are remaining

     * in the internal destination buffer.

     */

    if ( iInternalOutputBufferResidueLen - iInternalOutputBufferPos > 0 )

        {

        numberOfBytesCopied = CopyToDstBuffer( dst, totalDstBytesAdded );

        if ( iInternalOutputBufferResidueLen - iInternalOutputBufferPos > 0 )

            {

            PRINT_EXIT;

            return Result( TCodecProcessResult::EProcessIncomplete,

                            totalSrcBytesCopied, totalDstBytesAdded );

            }

        else

            {

            //Decode NULL frame to handle error concealment

            if ( lastFrame && ( srcBufferLen - srcBufferPos == 0 )&&

            ( iInternalInputBufferResidueLen == 0 && !iLastFrameDecoded ) )

                {

                dstBufferRemainingBytes = dstMaxLen - dstBufferPos -

                                                    totalDstBytesAdded;

                if ( dstBufferRemainingBytes == 0 )

                    {

                    iInternalOutputBufferPos = 0;

                    iInternalOutputBufferResidueLen = 0;

                    totalSrcBytesCopied = 0;

                    PRINT_EXIT;

                    return Result( TCodecProcessResult::EProcessIncomplete,

                                    totalSrcBytesCopied, totalDstBytesAdded );

                     }

                TInt dstLen  = iOutFrameSize;

                DecodeLastFrame(dstLen);

                iInternalOutputBufferResidueLen = dstLen;

                numberOfBytesCopied =

                                CopyToDstBuffer( dst, totalDstBytesAdded );

                totalDstBytesAdded += numberOfBytesCopied;

                dstBufferRemainingBytes -= numberOfBytesCopied;

                if ( ( iInternalOutputBufferResidueLen -

                    iInternalOutputBufferPos == 0 ) && iLastFrameDecoded )

                    {

                    totalSrcBytesCopied = 0;

                    iInternalOutputBufferResidueLen = 0;

                    iInternalInputBufferResidueLen = 0;

                    iInternalOutputBufferPos = 0;

                    PRINT_EXIT;

                    return Result( TCodecProcessResult::EEndOfData,

                                totalSrcBytesCopied, totalDstBytesAdded );

                    }

                else

                    {

                    totalSrcBytesCopied = 0;

                    PRINT_EXIT;

                    return Result( TCodecProcessResult::EProcessIncomplete,

                                    totalSrcBytesCopied, totalDstBytesAdded );

                    }

                }

            iInternalOutputBufferPos = 0;

            iInternalOutputBufferResidueLen = 0;

            }

        }

    else

        {

        if ( lastFrame && ( srcBufferLen - srcBufferPos == 0 )&&

            ( iInternalInputBufferResidueLen == 0 && !iLastFrameDecoded ) )

            {

            TInt dstLen  = iOutFrameSize;

            DecodeLastFrame(dstLen);

            iInternalOutputBufferResidueLen = dstLen;

            numberOfBytesCopied = CopyToDstBuffer( dst, totalDstBytesAdded );

            totalDstBytesAdded += numberOfBytesCopied;

            dstBufferRemainingBytes -= numberOfBytesCopied;

            if ( ( iInternalOutputBufferResidueLen -

                    iInternalOutputBufferPos == 0 ) && iLastFrameDecoded )

                {

                totalSrcBytesCopied = 0;

                iInternalOutputBufferResidueLen = 0;

                iInternalInputBufferResidueLen = 0;

                iInternalOutputBufferPos = 0;

                PRINT_EXIT;

                return Result( TCodecProcessResult::EEndOfData,

                            totalSrcBytesCopied, totalDstBytesAdded );

                }

            else

                {

                totalSrcBytesCopied = 0;

                PRINT_EXIT;

                return Result( TCodecProcessResult::EProcessIncomplete,

                                totalSrcBytesCopied, totalDstBytesAdded );

                }

            }

        }

    /**

     * copy the src buffer data into the internal buffer till internal buffer

     * holds minimum bytes to process i.e KMinBytesInput. After this block,

     * it ensures that internal source buffer holds KMinBytesInput.

     * if it is a last frame, treat remaining residual buffer as internal

     * buffer.

     */

    if ( ( KMinBytesInput - iInternalInputBufferResidueLen > 0 ) &&

                                ( srcBufferLen - srcBufferPos > 0 ) )

        {

        numberOfBytesCopied = CopyFromSrcBuffer( src, totalSrcBytesCopied );

        }

    /**

     * update the internal buffer length.

     */

    if ( ( KMinBytesInput > iInternalInputBufferResidueLen ) &&

                                                        ( !lastFrame ) )

        {

        PRINT_EXIT;

        return Result( TCodecProcessResult::EDstNotFilled,

                srcBufferLen - srcBufferPos, totalDstBytesAdded );

        }

    if ( iLastFrameDecoded && iInternalInputBufferResidueLen == 0 &&

                                    iInternalOutputBufferResidueLen == 0 )

        {

        totalSrcBytesCopied = 0;

        iInternalOutputBufferResidueLen = 0;

        iInternalInputBufferResidueLen = 0;

        iInternalOutputBufferPos = 0;

        PRINT_EXIT;

        return Result( TCodecProcessResult::EEndOfData,

                    totalSrcBytesCopied, totalDstBytesAdded );

        }

    /**

     * process the src buffer till destination buffer or source buffer or

     * both buffers are exhausted.

     */

    do

        {

        TInt srcBufferRemainingBytes = srcBufferLen - srcBufferPos -

                                                        totalSrcBytesCopied;

        dstBufferRemainingBytes = dstMaxLen - dstBufferPos -

                                                        totalDstBytesAdded;

        TInt internalInputBufferPos = 0;

        /**

         * initialize the variables like iSrcUsed and dstLen accordingly.

         * call Decode.

         */

        iSrcUsed = iInternalInputBufferResidueLen - internalInputBufferPos;

        TInt dstLen  = iOutFrameSize;

        TInt error = iCodec->Decode(

                            &iInternalInputBuffer[internalInputBufferPos],

                                iSrcUsed, iInternalOutputBuffer, dstLen );

        if ( error != 0 )

            {

            iInternalInputBufferResidueLen = 0;

            totalSrcBytesCopied = srcBufferLen;

            PRINT_ERR( error );

            return Result(

                    TCodecProcessResult::EProcessError,

                    totalSrcBytesCopied, totalDstBytesAdded + dstBufferPos);

            }

        iFrameNum++;

        PRINT_MSG( LEVEL_HIGH, ( "Frame: %d", iFrameNum ) );

        PRINT_MSG( LEVEL_HIGH, ( "iSrcUsed: %d", iSrcUsed ) );

        PRINT_MSG( LEVEL_HIGH, ( "dstLen: %d", dstLen ) );

        /**

         * Fill Destination Buffer

         */

        iInternalOutputBufferResidueLen = dstLen;

        numberOfBytesCopied = CopyToDstBuffer( dst, totalDstBytesAdded );

        dstBufferRemainingBytes -= numberOfBytesCopied;

        /**

         * Fill Source Buffer

         */

        internalInputBufferPos += iSrcUsed ;

        ShiftData( internalInputBufferPos, 0 );

        numberOfBytesCopied = CopyFromSrcBuffer( src, totalSrcBytesCopied );

        srcBufferRemainingBytes -= numberOfBytesCopied;

        /**

         * check four conditions if else for src and if else for dst

         */

        /**

         * src has available bytes

         */

        if ( srcBufferRemainingBytes > 0  ||

                iInternalInputBufferResidueLen >= KMinBytesInput )

            {

            if ( dstBufferRemainingBytes == 0 )

                {

                PRINT_EXIT;

                return Result(

                        TCodecProcessResult::EProcessIncomplete,

                        totalSrcBytesCopied, totalDstBytesAdded );

                }

            }

        else

            {

            // dst buffer has availabe space for decoded bytes

            if ( dstBufferRemainingBytes > 0 )

                {

                if ( lastFrame )

                    {

                    if ( iInternalInputBufferResidueLen == 0 )

                        {

                        TInt dstLen  = iOutFrameSize;

                        DecodeLastFrame(dstLen);

                        iInternalOutputBufferResidueLen = dstLen;

                        numberOfBytesCopied =

                                CopyToDstBuffer( dst, totalDstBytesAdded );

                        totalDstBytesAdded += numberOfBytesCopied;

                        dstBufferRemainingBytes -= numberOfBytesCopied;

                        if ( ( iInternalOutputBufferResidueLen -

                                iInternalOutputBufferPos == 0 ) &&

                                iLastFrameDecoded )

                            {

                            totalSrcBytesCopied = 0;

                            iInternalOutputBufferResidueLen = 0;

                            iInternalInputBufferResidueLen = 0;

                            iInternalOutputBufferPos = 0;

                            PRINT_EXIT;

                            return Result( TCodecProcessResult::EEndOfData,

                                    totalSrcBytesCopied, totalDstBytesAdded );

                            }

                        else

                            {

                            totalSrcBytesCopied = 0;

                            PRINT_EXIT;

                            return Result(

                                    TCodecProcessResult::EProcessIncomplete,

                                    totalSrcBytesCopied, totalDstBytesAdded );

                            }

                        }

                    }

                else

                    {

                    PRINT_EXIT;

                    return Result( TCodecProcessResult::EDstNotFilled,

                            totalSrcBytesCopied, totalDstBytesAdded );