/*

* 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 "ProcProcessAO.h"

#include "AudCommon.h"

#include "AudPanic.h"

#include "audconstants.h"

TBool CProcProcess::StartSyncProcessingL(const CAudSong* aSong, TBool aGetTimeEstimation)

    {

    iSong = aSong;

    if (iEncoder != 0)

        {

        delete iEncoder;

        iEncoder = 0;

        }

    iEncoder = CProcEncoder::NewL();

    iEncoder->InitL(iSong->OutputFileProperties().iAudioType, 

                    iSong->OutputFileProperties().iSamplingRate,

                    iSong->OutputFileProperties().iChannelMode, 

                    iSong->OutputFileProperties().iBitrate );

    if (iAMRBuf)

        {

        delete iAMRBuf;

        iAMRBuf = 0;

        }

    // buffer for extra AMR-frames

    iAMRBuf = HBufC8::NewL(KAedMaxAMRFrameLength);

    if (iDecBuffer)

        {

        delete iDecBuffer;   

        iDecBuffer = 0;

        }

    iDecBuffer = HBufC8::NewL(KAedMaxFeedBufferSize);

    TInt rawFrameSize = KAedSizeAMRBuffer;

    if (aSong->OutputFileProperties().iSamplingRate == KAedSampleRate8kHz)

        {

        rawFrameSize = KAedSizeAMRBuffer;

        }

    else 

        {

        rawFrameSize = KAedSizeAACBuffer;

        if ( aSong->OutputFileProperties().iChannelMode == EAudStereo )

            {

            rawFrameSize *= 2;

            }

        }

    CAudProcessorImpl* processorImpl = CAudProcessorImpl::NewLC();

    processorImpl->ProcessSongL(aSong, rawFrameSize, aGetTimeEstimation);

    CleanupStack::Pop(processorImpl);

    iProcessorImpl = processorImpl;

    return ETrue;

    }

TBool CProcProcess::ProcessSyncPieceL(HBufC8*& aFrame, TInt& aProgress,

                                       TTimeIntervalMicroSeconds& aDuration)

    {

    // first check if we have frames left from the previous encoding

    if (iAMRBuf->Length() > 0)

        {

        // we do have some frames left

        TInt frLen = ProcTools::GetNextAMRFrameLength(iAMRBuf, 0);

        if (frLen > iAMRBuf->Length())

            {

            // something has gone wrong, we don't have a proper AMR frame in the buffer

            User::Leave(KErrGeneral);

            }

        aFrame = HBufC8::NewL(frLen);

        aFrame->Des().Append(iAMRBuf->Left(frLen));

        iAMRBuf->Des().Delete(0, frLen);

        aDuration = KAedAMRFrameDuration;

        iProgress = aProgress;

        return EFalse;

        }

    iDecBuffer->Des().Delete(0, iDecBuffer->Size());

    HBufC8* frame = 0;

    TBool rawFrame = EFalse;

    TInt outDurationMilli = 0;

    TBool ret = iProcessorImpl->ProcessSyncPieceL(frame, aProgress, aDuration, rawFrame);

    iProgress = aProgress;

    if (!rawFrame)

        {

        // frame already in compressed domain, no need for encoding

        if (ret || frame == 0) 

            {

            iTimeEstimate = iProcessorImpl->GetFinalTimeEstimate();

            aFrame = frame;

            // no more frames left -> processing ready

            delete iProcessorImpl;

            iProcessorImpl = 0;

            delete iDecBuffer;

            iDecBuffer = 0;

            return ETrue;

            }

        else 

            {

            aFrame = frame;

            return EFalse;

            }

        }

    else

        {

        // frame needs to be encoded

        if (ret || frame == 0) 

            {

            iTimeEstimate = iProcessorImpl->GetFinalTimeEstimate();

            // no more frames left -> processing ready

            delete iProcessorImpl;

            iProcessorImpl = 0;

            delete iDecBuffer;

            iDecBuffer = 0;

            return ETrue;

            }    

        // feed encoder until we have something in the output buffer

        iEncoder->FillEncBufferL(*frame, iDecBuffer, outDurationMilli);

        delete frame;

        frame = 0;

        while (iDecBuffer->Size() == 0)

            {

            // we need more input for encoder

            TTimeIntervalMicroSeconds dur;

                       ret = iProcessorImpl->ProcessSyncPieceL(frame, aProgress, dur, rawFrame);

            if (!ret)

                {

                }

            else

                {

                // no more frames left -> processing ready

                iTimeEstimate = iProcessorImpl->GetFinalTimeEstimate();

                delete iProcessorImpl;

                iProcessorImpl = 0;

                delete iDecBuffer;

                iDecBuffer = 0;

                return ETrue;

                }

            iProgress = aProgress;

            if (ret) 

                {

                // no more frames left -> processing ready

                iTimeEstimate = iProcessorImpl->GetFinalTimeEstimate();

                delete iProcessorImpl;

                iProcessorImpl = 0;

                delete iDecBuffer;

                iDecBuffer = 0;

                return ETrue;

                }

            if (!rawFrame)

                {

                // we got encoded frame -> return it

                aFrame = frame;

                return EFalse;

                }

            // we should now have a raw frame in aFrame -> feed the encoder

            aDuration = aDuration.Int64() + dur.Int64();

            iEncoder->FillEncBufferL(*frame, iDecBuffer, outDurationMilli);

            delete frame;

            frame = 0;

            }

        }

    // read the encoded frame to aFrame

    TInt frameLen = 0;

    if (iEncoder->DestAudType() == EAudAMR)

        {

        frameLen = ProcTools::GetNextAMRFrameLength(iDecBuffer, 0);

        }

    if (frameLen < iDecBuffer->Length() && iEncoder->DestAudType() == EAudAMR)

        {

        // we got more than one AMR frame, return the first now

        // and the second when this function is called next time

        aFrame = HBufC8::NewL(frameLen);

        aFrame->Des().Append(iDecBuffer->Des().Left(frameLen));

        if ( (iDecBuffer->Length() + iAMRBuf->Length() - frameLen) > iAMRBuf->Des().MaxLength())

            {

            // if the temporary storage is too small, we need more space for it

            iAMRBuf = iAMRBuf->ReAlloc(iDecBuffer->Length() + iAMRBuf->Length() - frameLen);

            }

        iAMRBuf->Des().Append(iDecBuffer->Right(iDecBuffer->Length() - frameLen));

        }

    else

        {

        aFrame = HBufC8::NewL(iDecBuffer->Size());

        aFrame->Des().Append(iDecBuffer->Des());

        }

    iDecBuffer->Des().Delete(0, iDecBuffer->Size());

    aDuration = outDurationMilli*1000;

    return EFalse;

    }

TInt64 CProcProcess::GetFinalTimeEstimate() const

    {

    return iTimeEstimate;

    }

CProcProcess* CProcProcess::NewL() 

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CProcProcess::~CProcProcess() 

    {

    if (iProcessorImpl != 0)

        {

        delete iProcessorImpl;

        iProcessorImpl = 0;

        }

    delete iEncoder;

    delete iDecBuffer;

    iDecBuffer = 0;

    delete iAMRBuf;

    }

void CProcProcess::ConstructL() 

    {

    }

CProcProcess::CProcProcess() : iProcessorImpl(0), iSong(0)

    {

    }