/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "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:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description:  

*

*/

#include "ProcEncoder.h"

#include "audconstants.h"

#include    <MmfDatabuffer.h>

#include    <mmfcontrollerpluginresolver.h>

#include    <mmfutilities.h>

#include    <mmf/plugin/mmfCodecImplementationUIDs.hrh>

#include    <MMFCodec.h>

// MACROS

// Debug print macro

#if defined _DEBUG 

#include <e32svr.h>

#define PRINT(x) RDebug::Print x; 

#else

#define PRINT(x)

#endif

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

// TCMRAMREncParams

// Encoding parameters structure for SW AMR codec

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

//

class TVedACAMREncParams

    {

public:

    // encoding mode (for AMR-NB: 0=MR475,1=MR515,...,7=MR122, default 7)

    TInt iMode;

    // DTX flag (TRUE or default FALSE)

    TInt iDTX;

    };

CProcEncoder* CProcEncoder::NewL()

    {

    CProcEncoder* self = NewLC();

    CleanupStack::Pop(self);

    return self;

    }

CProcEncoder* CProcEncoder::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CProcEncoder::~CProcEncoder()

    {

    delete iSourceInputBuffer;

    delete  iDestInputBuffer;

    delete iDestCodec;

    }

TBool CProcEncoder::InitL(TAudType aAudioType, TInt aTargetSamplingRate, TChannelMode aChannelMode,

                          TInt aBitrate)

    {

    PRINT((_L("CProcEncoder::InitL() in")));

    if (aAudioType == EAudAMR)

        {

        iOutputFrameDurationMilli = 20;

        }

    else if (aAudioType == EAudAAC_MPEG4)

        {

        iOutputFrameDurationMilli = (1024*1000)/(aTargetSamplingRate);

        }

    else

        {

        // only AMR & AAC encoding supported

        PRINT((_L("CProcEncoder::InitL() out, unsupported audio type")));

        User::Leave(KErrNotSupported);

        }

    iToBitRate = aBitrate;

    iAudioType = aAudioType;

    iNumberOfFramesInOutputBuffer = 0;

    iToSampleRate = aTargetSamplingRate;

    iToChannels = 1; 

    if (aChannelMode == EAudStereo)

        {

        iToChannels = 2;    

        }

    TInt destInputBufferSize = 0;

    TInt sourceInputBufferSize = 0;

    // input buffer size:

    // we never get longer than 64 milliseconds input

    // as it is limited by the input formats

    // for 16kHz AAC the frame duration is 64 ms

    //

    const TInt KMaxInputDurationMilli = 64;

    // multiplied by 2 as we have a bitdepth of 16

    sourceInputBufferSize = (2*aTargetSamplingRate*KMaxInputDurationMilli)/1000;

    if (aChannelMode == EAudStereo)

        {

        sourceInputBufferSize *= 2;

        }

    if ( aAudioType == EAudAMR )

        {

        // from 64 ms input we can have maximum 4 AMR frames

        destInputBufferSize = KAedMaxAMRFrameLength*4;

        }

    else if (aAudioType == EAudAAC_MPEG4)

        {

        if ( aChannelMode == EAudSingleChannel )

            {

            destInputBufferSize = KAedMaxAACFrameLengthPerChannel;

            }

        else

            {

            destInputBufferSize = 2 * KAedMaxAACFrameLengthPerChannel;

            }        

        }

    if ( iSourceInputBuffer )

        {

        delete iSourceInputBuffer;

        iSourceInputBuffer = NULL;

        }

    iSourceInputBuffer = CMMFDataBuffer::NewL(sourceInputBufferSize*5);

    if ( iDestInputBuffer )

        {

        delete iDestInputBuffer;

        iDestInputBuffer = NULL;

        }

    TInt errC = KErrNone;

    if (aAudioType == EAudAMR)

        {

        // shouldn't get more than 6 AMR frames at a time -> 120 ms

        iDestInputBuffer = CMMFDataBuffer::NewL( destInputBufferSize);

        }

    else

        {

        iDestInputBuffer = CMMFDataBuffer::NewL( destInputBufferSize);

        }

    TRAP (errC,SetDestCodecL());

    if (errC != KErrNone)

        {

        // initialization failed for some reason

        User::Leave(KErrNotSupported);

        }

    TInt err = KErrNone;

    if ( iAudioType == EAudAAC_MPEG4 )

        {

        TRAP( err, ConfigureAACEncoderL());

        }

    else if (iAudioType == EAudAMR)

        {

        TRAP( err, ConfigureAMREncoderL());

        }

    if (err != KErrNone || errC != KErrNone)

        {

        // initialization failed for some reason

        User::Leave(KErrNotSupported);

        }

    iReady = ETrue;

    PRINT((_L("CProcEncoder::InitL() out")));

    return ETrue;

    }

TBool CProcEncoder::FillEncBufferL(const TDesC8& aRawFrame, HBufC8* aEncBuffer, TInt& aOutputDurationMilli)

    {

    PRINT((_L("CProcEncoder::FillEncBufferL() in")));

    aOutputDurationMilli = 0;

    if (!iReady)

        {

        User::Leave(KErrNotReady);

        }

    iEncBuffer = aEncBuffer;

    if (iEncBuffer->Length() == 0)

        {

        iNumberOfFramesInOutputBuffer = 0;

        }

    if ( !aRawFrame.Length() )

        {

        return EFalse;

        }

    if ( (TInt)(aRawFrame.Length() + iSourceInputBuffer->Position() ) > iSourceInputBuffer->Data().MaxLength() )

        {

        ReAllocBufferL( iSourceInputBuffer, aRawFrame.Length() + iSourceInputBuffer->Position() );

        }

    // copy the input data to MMF buffer

    iSourceInputBuffer->Data().SetLength( 0 );

    iSourceInputBuffer->SetPosition( 0 );

    iSourceInputBuffer->Data().Append( aRawFrame );

    iSourceInputBuffer->Data().SetLength( iSourceInputBuffer->Data().Length() );

    iSourceInputBuffer->SetStatus(EFull);

    iDestInputBuffer->Data().SetLength(0);

    iDestInputBuffer->SetPosition(0); 

    FeedCodecL( iDestCodec, iSourceInputBuffer, iDestInputBuffer);

    iDestInputBuffer->Data().SetLength(0);

    iDestInputBuffer->SetPosition(0); 

    if (iEncBuffer->Size() > 0)

       {

       aOutputDurationMilli = iOutputFrameDurationMilli * iNumberOfFramesInOutputBuffer;

       PRINT((_L("CProcEncoder::FillEncBufferL() out with ETrue (complete)")));

       return ETrue;

       }

    PRINT((_L("CProcEncoder::FillEncBufferL() out with EFalse (incomplete)")));

    return EFalse;

    }

TAudType CProcEncoder::DestAudType()

    {

    return iAudioType;

    }

void CProcEncoder::ConstructL()

    {

    }

CProcEncoder::CProcEncoder()

    {

    }

void CProcEncoder::ConfigureAMREncoderL()

    {

    PRINT((_L("CProcEncoder::ConfigureAMREncoderL() in")));

    if ( (iToBitRate < KAedMinAMRBitRate) || (iToBitRate > KAedMaxAMRBitRate) )

        {

        User::Leave( KErrArgument );

        }

    TVedACAMREncParams* configData = new (ELeave) TVedACAMREncParams;

    CleanupStack::PushL( configData );

    // the bitrates in the switch & if below are not magic numbers but AMR bitrates in bits per seconds and mode indices from TAmrEncParams

    switch ( iToBitRate )

        {

        case 4750:

            configData->iMode = 0;

            configData->iDTX = EFalse;

            break;

        case 5150:

            configData->iMode = 1;

            configData->iDTX = EFalse;

            break;

        case 5900:

            configData->iMode = 2;

            configData->iDTX = EFalse;

            break;

        case 6700:

            configData->iMode = 3;

            configData->iDTX = EFalse;

            break;

        case 7400:

            configData->iMode = 4;

            configData->iDTX = EFalse;

            break;

        case 7950:

            configData->iMode = 5;

            configData->iDTX = EFalse;

            break;

        case 10200:

            configData->iMode = 6;

            configData->iDTX = EFalse;

            break;

        case 12200:

            configData->iMode = 7;

            configData->iDTX = EFalse;

            break;

        default :

            // Interprets now the bitrate proprietarily: bitrates that are not exactly AMR bitrates 

            // mean that voice activity detection is used and the AMR bitrates is the given bitrate rounded upwards to the next AMR bitrate

            if ( iToBitRate < 4750 )

                {

                configData->iMode = 0;

                configData->iDTX = ETrue;

                }

            else if ( iToBitRate < 5150 )

                {

                configData->iMode = 1;

                configData->iDTX = ETrue;

                }

            else if ( iToBitRate < 5900 )

                {

                configData->iMode = 2;

                configData->iDTX = ETrue;

                }

            else if ( iToBitRate < 6700 )

                {

                configData->iMode = 3;

                configData->iDTX = ETrue;

                }

            else if ( iToBitRate < 7400 )

                {

                configData->iMode = 4;

                configData->iDTX = ETrue;

                }

            else if ( iToBitRate < 7950 )

                {

                configData->iMode = 5;

                configData->iDTX = ETrue;

                }

            else if ( iToBitRate < 10200 )

                {

                configData->iMode = 6;

                configData->iDTX = ETrue;

                }

            else // must be: ( iToBitRate < 12200 ) since checked earlier

                {

                configData->iMode = 7;

                configData->iDTX = ETrue;

                }

        }

    TUid uid ={KUidMmfCodecAudioSettings}; // Use Uid reserved for codec configurations

    iDestCodec->ConfigureL( uid, reinterpret_cast<TDesC8&>(*configData));

    CleanupStack::PopAndDestroy( configData );

    PRINT((_L("CProcEncoder::ConfigureAMREncoderL() out")));

    }

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

// CProcEncoder::ConfigureAACEncoderL

// 

// (other items were commented in a header).

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

//

void CProcEncoder::ConfigureAACEncoderL()

    {

    PRINT((_L("CProcEncoder::ConfigureAACEncoderL() in")));

    TInt i = 0;

    TBool iSet = EFalse;

    for ( i = 0; i < KAedNumSupportedAACSampleRates; i++ )

        {

        if ( iToSampleRate == KAedSupportedAACSampleRates[i] )

            {

            iSet = ETrue;

            }

        }

    if ( !iSet )

        {

        // given samplerate is not supported

        User::Leave( KErrNotSupported );

        }

    // AAC codec interprets the input as array of TInts, not as a class

    RArray<TInt> config;

    config.Append (iToBitRate); //BitRate

    config.Append (iToSampleRate);  //SamplingRate

    config.Append (0);  //iToolFlags

    config.Append (iToChannels);    //iNumChan

    // NOTE Ali: for 48kHz stereo we might need to use ADTS as output format

    // as we can get more than one frame in synchronous call!

    config.Append (0);  //iuseFormat 0=RAW; 1=ADTS; 2=ADIF

    config.Append (0);  // 0 = 1 Frame only; 1 = Full Buffer

    TUid uid ={KUidMmfCodecAudioSettings}; // Use Uid reserved for codec configurations

    iDestCodec->ConfigureL( uid,  reinterpret_cast<TDesC8&>(config));

    config.Close();

    PRINT((_L("CProcEncoder::ConfigureAACEncoderL() out")));

    }

void CProcEncoder::ReAllocBufferL( CMMFDataBuffer* aBuffer, TInt aNewMaxSize )

    {

    if ( aBuffer->Data().Length() )

        {

        TInt position = aBuffer->Position();

        TInt length = aBuffer->Data().Length();

        HBufC8* oldData = aBuffer->Data().AllocL();

        CleanupStack::PushL( oldData );

        ((CMMFDescriptorBuffer*)aBuffer)->ReAllocBufferL( aNewMaxSize );

        aBuffer->Data().Copy( *oldData );

        CleanupStack::PopAndDestroy( oldData );

        aBuffer->Data().SetLength( length );

        aBuffer->SetPosition( position );

        }

    else

        {

        ((CMMFDescriptorBuffer*)aBuffer)->ReAllocBufferL( aNewMaxSize );

        }

    }

void CProcEncoder::FeedCodecL( CMMFCodec* aCodec, CMMFDataBuffer* aSourceBuffer, CMMFDataBuffer* aDestBuffer )

    {

    PRINT((_L("CProcEncoder::FeedCodecL() in")));

    TBool completed = EFalse;

    TCodecProcessResult result;

    TInt aSrcUsed = 0;

    while ( !completed )

        {

        // encode and check the result

        result = EncodeL(aCodec, aSourceBuffer, aDestBuffer);

        switch ( result.iStatus )

            {

            case TCodecProcessResult::EProcessIncomplete:

                // Not all data from input was consumed (EncodeL updated buffer members), but output was generated

                iEncBuffer->Des().Append(aDestBuffer->Data());

                iNumberOfFramesInOutputBuffer++;

                aDestBuffer->Data().SetLength( 0 );

                aDestBuffer->SetPosition( 0 );

                break;

            case TCodecProcessResult::EProcessComplete:

                // all data from input was used and output was generated

                iEncBuffer->Des().Append(aDestBuffer->Data());

                iNumberOfFramesInOutputBuffer++;

                aDestBuffer->Data().SetLength( 0 );

                aDestBuffer->SetPosition( 0 );

                //completed = ETrue;

                break;

            case TCodecProcessResult::EDstNotFilled:

                // need more input data, can't fill the output yet; put it back to the empty queue

                //completed = ETrue;

                break;

            default:

                // EEndOfData, EProcessError, EProcessIncompleteRepositionRequest, EProcessCompleteRepositionRequest

                User::Leave( KErrUnknown );

            }

        aSrcUsed += result.iSrcBytesProcessed;

        if (aSrcUsed >= (STATIC_CAST(CMMFDataBuffer*, aSourceBuffer)->Data().Length()))

			{

            PRINT((_L("CProcEncoder::FeedCodecL() ProcessL is completed aSrcUsed[%d]"), aSrcUsed));

			completed = ETrue;