/*

* 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

* (CAriAacLCEncMmfCodec).

*

*/

#include <ecom.h>

#include <implementationproxy.h>

#include "ariaaclcencwrapper.h"

#include "ariaaclcencmmfcodec.h"

#include "ariaaclcencmmfcodec_uid.hrh"

#include "ariprint.h"

const TUint KMinDstLen = 6144;

const TUint KMinBytesInput = 4096;

const TUint KFlagSet = 1;

const TUint KFlagNotSet = 0;

const TUint KNoOfSamples = 1024;

const TUint KDefaultChannels = 1;

const TUint KDefaultOutputBitrate = 16000;

const TUint KDefaultSamplingFrequency = 8000;

const TUint KDefaultFormat = 0;

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

//  Two-phased constructor.

//  Creates an instance of CAriAacLCEncMmfCodec.

//  Instance is not left on cleanup stack.

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

//

CMMFCodec* CAriAacLCEncMmfCodec::NewL()

    {

    PRINT_ENTRY;

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    PRINT_EXIT;

    return ( CMMFCodec* )self;

    }

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

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

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

//

CAriAacLCEncMmfCodec::~CAriAacLCEncMmfCodec()

    {

    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.

//  value used for aConfigType must be KUidMmfCodecAudioSettings

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

//

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

//

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

                                                    const TDesC8& aParam )

    {

    PRINT_ENTRY;

    if ( !iConfigured )

        {

        TInt numberOfChannels = 0;

        TInt samplingFrequency = 0;

        TInt outputFormat = 0;

        TInt outputBitRate = 0;

        TInt flags = 0;

        TInt fillBuffer = 0;

        TInt offset = 0;

        Mem::Copy( &outputBitRate, aParam.Ptr() + offset, sizeof( TUint ) );

        offset += sizeof( TUint );

        Mem::Copy( &samplingFrequency, aParam.Ptr() + offset,

                                                        sizeof( TUint ) );

        offset += sizeof( TUint );

        Mem::Copy( &flags, aParam.Ptr() + offset, sizeof( TUint ) );

        offset += sizeof( TUint );

        Mem::Copy( &numberOfChannels, aParam.Ptr() + offset,

                                                        sizeof( TUint ) );

        offset += sizeof( TUint );

        Mem::Copy( &outputFormat, aParam.Ptr() + offset, sizeof( TUint ) );

        offset += sizeof( TUint );

        Mem::Copy( &fillBuffer, aParam.Ptr() + offset, sizeof( TUint ) );

        offset += sizeof( TUint );

        if ( ( flags != 0 && flags != 1 ) ||

                                    ( fillBuffer != 0 && fillBuffer != 1 ) )

            {

            User::Leave( KErrArgument );

            }

        iParam.iNumberOfChannels = ( TUint )numberOfChannels;

        iParam.iOutputBitRate = ( TUint )outputBitRate;

        iParam.iOutputFormat = ( TOutputFormat )outputFormat;

        iParam.iSamplingFrequency = ( TUint )samplingFrequency;

        PRINT_MSG( LEVEL_HIGH,

                    ( "NumberOfChannels: %d", iParam.iNumberOfChannels ) );

        PRINT_MSG( LEVEL_HIGH,

                    ( "OutputBitRate: %d", iParam.iOutputBitRate ) );

        PRINT_MSG( LEVEL_HIGH,

                    ( "OutputFormat: %d", iParam.iOutputFormat ) );

        PRINT_MSG( LEVEL_HIGH,

                    ( "SamplingFrequenc: %d", iParam.iSamplingFrequency ) );

        PRINT_MSG( LEVEL_HIGH,

                    ( "FillBuffer: %d", iFillBuffer ) );

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

        iSrclenToProcess = sizeof( TInt16 ) * KNoOfSamples *

                                                iParam.iNumberOfChannels;

        if ( fillBuffer == KFlagSet )

            {

            iFillBuffer = ETrue;

            }

        else

            {

            iFillBuffer = EFalse;

            }

        iConfigured = ETrue;

        }

    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 CAriAacLCEncMmfCodec::ResetL()

    {

    PRINT_ENTRY;

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

    PRINT_EXIT;

    }

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

//  From class CMMFCodec.

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

//  buffer with the encode 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 is

//    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 CAriAacLCEncMmfCodec::ProcessL( const CMMFBuffer& aSrc,

                                                        CMMFBuffer& aDst )

    {

    PRINT_ENTRY;

    // total decoded bytes added to the dst buffer

    TInt totalDstBytesAdded = 0;

    // total src bytes added to the internal src buffer

    TInt totalSrcBytesCopied = 0;

    TInt internalInputBufferLen = 0;

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

    TInt numberOfBytesCopied;

    /**

    * 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 ) );

    TInt srcBufferRemainingBytes = 0;

    srcBufferRemainingBytes = srcBufferLen - srcBufferPos -

                                                        totalSrcBytesCopied;

    TInt totRemainingSrc = srcBufferRemainingBytes +

                                            iInternalInputBufferResidueLen;

    if ( ( iInternalOutputBufferResidueLen - iInternalOutputBufferPos == 0 )

            && ( totRemainingSrc < iSrclenToProcess ) && ( lastFrame ) )

        {

        totalSrcBytesCopied = 0;

        iInternalOutputBufferResidueLen = 0;

        iInternalInputBufferResidueLen = 0;

        iInternalOutputBufferPos = 0;

        PRINT_EXIT;

        return Result( TCodecProcessResult::EEndOfData,

                    totalSrcBytesCopied, totalDstBytesAdded );

        }

    /**

    * 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

            {

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

                                    ( iInternalInputBufferResidueLen == 0 ) )

                {

                totalSrcBytesCopied = 0;

                iInternalOutputBufferResidueLen = 0;

                iInternalInputBufferResidueLen = 0;

                iInternalOutputBufferPos = 0;

                PRINT_EXIT;

                return Result( TCodecProcessResult::EEndOfData,

                            totalSrcBytesCopied, totalDstBytesAdded );

                }

            iInternalOutputBufferPos = 0;

            iInternalOutputBufferResidueLen = 0;

            }

        }

    TInt dstBufferRemainingBytes = 0;

    dstBufferRemainingBytes = dstMaxLen - dstBufferPos - totalDstBytesAdded;

    if ( dstBufferRemainingBytes == 0 )

        {

        PRINT_EXIT;

        return Result( TCodecProcessResult::EProcessIncomplete,

                                totalSrcBytesCopied, totalDstBytesAdded );

        }

    //generate header for ADIF and Raw encoded formats

    if ( !iHeaderGenerated )

        {

        if ( ( iParam.iOutputFormat == EFormatADIF ) ||

                                    ( iParam.iOutputFormat == EFormatRaw ) )

            {

            TInt retval = KErrNone;

            TInt headerLen = KMinDstLen;

            retval = iCodec->GetHeader( iInternalOutputBuffer,headerLen );

            /**

            * Fill Destination Buffer

            */

            iInternalOutputBufferResidueLen = headerLen;

            numberOfBytesCopied = CopyToDstBuffer( dst, totalDstBytesAdded );

            dstBufferRemainingBytes -= numberOfBytesCopied;

            iHeaderGenerated = ETrue;

            if ( ( iInternalOutputBufferResidueLen -

                            iInternalOutputBufferPos > 0 ) ||

                                            dstBufferRemainingBytes == 0 )

                {

                totalSrcBytesCopied = 0;

                PRINT_EXIT;

                return Result(

                            TCodecProcessResult::EProcessIncomplete,

                            totalSrcBytesCopied, totalDstBytesAdded );

                }

            }

        else

            {

            iHeaderGenerated = ETrue;

            }

        }

    TInt newSrcCopied = 0;

    /**

    * 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 ( ( iSrclenToProcess - iInternalInputBufferResidueLen > 0 ) &&

                                        ( srcBufferLen - srcBufferPos > 0 ) )

        {

        numberOfBytesCopied = CopyFromSrcBuffer( src, totalSrcBytesCopied );

        newSrcCopied = numberOfBytesCopied;

        }

    if ( iSrclenToProcess > iInternalInputBufferResidueLen )

        {

        if ( !lastFrame )

            {

            PRINT_EXIT;

            return Result( TCodecProcessResult::EDstNotFilled,

                   srcBufferLen - srcBufferPos, totalDstBytesAdded );

            }

        else

            {

            totalSrcBytesCopied = 0;

            iInternalOutputBufferResidueLen = 0;

            iInternalInputBufferResidueLen = 0;

            iInternalOutputBufferPos = 0;

            PRINT_EXIT;

            return Result( TCodecProcessResult::EEndOfData,

                        totalSrcBytesCopied, totalDstBytesAdded );

            }

        }

    srcBufferRemainingBytes = srcBufferLen - srcBufferPos -

                                                        totalSrcBytesCopied;

    if ( lastFrame && ( ( iSrclenToProcess > iInternalInputBufferResidueLen )

            && ( iSrclenToProcess > srcBufferRemainingBytes ) )

            && ( iInternalOutputBufferResidueLen -

                                        iInternalOutputBufferPos == 0 ) )

        {

        totalSrcBytesCopied = 0;

        iInternalOutputBufferResidueLen = 0;

        iInternalInputBufferResidueLen = 0;

        iInternalOutputBufferPos = 0;

        PRINT_EXIT;

        return Result( TCodecProcessResult::EEndOfData,

                                    totalSrcBytesCopied, totalDstBytesAdded );

        }

    if ( iInternalOutputBufferResidueLen - iInternalOutputBufferPos == 0 )

        {

        iInternalOutputBufferResidueLen = 0;

        iInternalOutputBufferPos = 0;

        }

    /**

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

     * both buffers are exhausted.

     */

    do

        {

        srcBufferRemainingBytes = srcBufferLen - srcBufferPos -

                                                        totalSrcBytesCopied;

        dstBufferRemainingBytes = dstMaxLen - dstBufferPos -

                                                        totalDstBytesAdded;

        TInt internalInputBufferPos = 0;

        /**

        * initialize the variables like srcUsed and dstLen accordingly.

        * call Encode.

        */

        TInt srcUsed = iSrclenToProcess;

        TInt dstLen  = KMinDstLen;

        TInt16* tempIn = NULL;

        tempIn = ( TInt16* ) ( ( iInternalInputBuffer +

                                                internalInputBufferPos ) );

        TInt error = iCodec->Encode( tempIn, srcUsed, iInternalOutputBuffer,

                                                                    dstLen );

        if ( error != KErrNone )

            {

            iInternalInputBufferResidueLen = 0;

            totalSrcBytesCopied = srcBufferLen;

            PRINT_ERR( error );

            return Result(

                    TCodecProcessResult::EProcessError,

                    totalSrcBytesCopied, totalDstBytesAdded + dstBufferPos );

            }

        /**

         * Fill Destination Buffer

         */

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

        iInternalOutputBufferResidueLen = dstLen;

        numberOfBytesCopied = CopyToDstBuffer( dst, totalDstBytesAdded );

        dstBufferRemainingBytes -= numberOfBytesCopied;

        /***

        * Fill Source Buffer if FillBuffer flag is true

        */

        internalInputBufferPos += srcUsed ;

        ShiftData( internalInputBufferPos, 0 );

        if ( iFillBuffer )

            {

            numberOfBytesCopied = CopyFromSrcBuffer( src,

                                                        totalSrcBytesCopied );

            srcBufferRemainingBytes -= numberOfBytesCopied;

            }

        /***

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

        */

        // src has available bytes

        TInt totSrcUsed = 0;

        if ( ( iSrclenToProcess > srcBufferRemainingBytes ) &&

                    ( iSrclenToProcess > iInternalInputBufferResidueLen ) &&

                                                    ( lastFrame ) )

            {

            iInternalOutputBufferResidueLen = 0;

            iInternalInputBufferResidueLen = 0;

            iInternalOutputBufferPos = 0;

            PRINT_EXIT;

            return Result( TCodecProcessResult::EEndOfData,

                    totalSrcBytesCopied, totalDstBytesAdded );

            }

        if ( srcBufferRemainingBytes > 0 || iInternalInputBufferResidueLen >=

                                                            iSrclenToProcess )

            {

            if ( dstBufferRemainingBytes > 0 )

                {

                if ( !iFillBuffer )

                    {

                    totSrcUsed = srcBufferPos + srcUsed;

                    totalSrcBytesCopied = newSrcCopied;

                    PRINT_EXIT;

                    return Result(

                            TCodecProcessResult::EProcessIncomplete,

                            totalSrcBytesCopied, totalDstBytesAdded );

                    }

                }

            else

                {

                PRINT_EXIT;

                return Result(

                            TCodecProcessResult::EProcessIncomplete,

                            totalSrcBytesCopied, totalDstBytesAdded );

                }

            }

        else

            {

            if ( dstBufferRemainingBytes > 0 )

                {

                if ( lastFrame )

                    {

                    if ( iInternalInputBufferResidueLen >= iSrclenToProcess )

                        {

                        if ( !iFillBuffer )

                            {

                            totSrcUsed = srcBufferPos + srcUsed;

                            totalSrcBytesCopied = newSrcCopied;

                            PRINT_EXIT;

                            return Result(

                                    TCodecProcessResult::EProcessIncomplete,

                                    totalSrcBytesCopied, totalDstBytesAdded );

                            }

                        }

                    else

                        {

                        iInternalOutputBufferResidueLen = 0;