/*

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

#include "ProcAMRInFileHandler.h"

#include "ProcMP4InFileHandler.h"

#include "ProcADTSInFileHandler.h"

#include "ProcMP3InFileHandler.h"

#include "ProcAWBInFileHandler.h"

#include "ProcWAVInFileHandler.h"

#include "ProcAMRFrameHandler.h"

#include "ProcAACFrameHandler.h"

#include "ProcMP3FrameHandler.h"

#include "ProcAWBFrameHandler.h"

#include "ProcWAVFrameHandler.h"

#include "AudCommon.h"

#include "ProcTools.h"

#include "AudPanic.h"

// Debug print macro

#if defined _DEBUG 

#include <e32svr.h>

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

#else

#define PRINT(x)

#endif

const TInt KTimeEstimateTime = 2000; // 1000 ms

CAudProcessorImpl* CAudProcessorImpl::NewL()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CAudProcessorImpl* CAudProcessorImpl::NewLC()

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CAudProcessorImpl::~CAudProcessorImpl() 

    {

	PRINT((_L("CAudProcessorImpl::~CAudProcessorImpl() in")));

    TInt a = 0;

    for (a = 0; a < iInFiles.Count() ; a++) 

        {

        delete iInFiles[a];

        }

    iInFiles.Reset();

	PRINT((_L("CAudProcessorImpl::~CAudProcessorImpl() deleted iInFiles")));

    delete iWAVFrameHandler; 

    iClipsWritten.Reset();

    iProcessingEvents.ResetAndDestroy();

	PRINT((_L("CAudProcessorImpl::~CAudProcessorImpl() out")));

    }

void CAudProcessorImpl::ConstructL() 

    {

    }

CAudProcessorImpl::CAudProcessorImpl() : iInFiles(8), iSong(0), 

                                            iTimeLeft(0),

                                            iCurEvent(0),

                                            iProcessingEvents(8),

                                            iSongDurationMilliSeconds(0),

                                            iSongProcessedMilliSeconds(0)

    {

    }

void CAudProcessorImpl::ProcessSongL(const CAudSong* aSong, TInt aRawFrameSize, TBool aGetTimeEstimation) 

{

    PRINT((_L("CAudProcessorImpl::ProcessSongL in")));

    iGetTimeEstimation = aGetTimeEstimation;

    iSilenceStarted = EFalse;

    iSong = aSong;

    TInt clips = aSong->iClipArray.Count();

    // bitdepth always 16

    const TInt KBitDepth = 16;

    iWAVFrameHandler = CProcWAVFrameHandler::NewL(KBitDepth);

    // create inFileHandlers for each input clips--->

    for (TInt a = 0 ; a < clips ; a++) 

    {

        if (aSong->iClipArray[a]->Info()->Properties().iFileFormat == EAudFormatAMR) 

        {

            PRINT((_L("CAudProcessorImpl::ProcessSongL create AMRNB file handler")));

            CProcInFileHandler* inFileHandler = 

                CProcAMRInFileHandler::NewL(aSong->iClipArray[a]->Info()->FileName(), 

                aSong->iClipArray[a]->Info()->FileHandle(), aSong->iClipArray[a],

                4096, iSong->OutputFileProperties().iSamplingRate,

                iSong->OutputFileProperties().iChannelMode);

            iInFiles.Insert(inFileHandler, iInFiles.Count());

            inFileHandler->SetPropertiesL(aSong->iClipArray[a]->Info()->Properties());

            inFileHandler->SetPriority(aSong->iClipArray[a]->Priority());

            inFileHandler->SeekCutInFrame();

            if (IsDecodingRequired(aSong->OutputFileProperties(), 

                                   aSong->iClipArray[a]->Info()->Properties()))

                {

                inFileHandler->SetDecodingRequired(ETrue);

                }

        }            

        else if (aSong->iClipArray[a]->Info()->Properties().iFileFormat == EAudFormatMP4) 

        {

            PRINT((_L("CAudProcessorImpl::ProcessSongL create MP4 file handler")));

            CProcInFileHandler* inFileHandler = 

                CProcMP4InFileHandler::NewL(aSong->iClipArray[a]->Info()->FileName(), 

                aSong->iClipArray[a]->Info()->FileHandle(),

                aSong->iClipArray[a],

                4096, iSong->OutputFileProperties().iSamplingRate,

                iSong->OutputFileProperties().iChannelMode);

            iInFiles.Insert(inFileHandler, iInFiles.Count());

            TAudFileProperties prororo;

            inFileHandler->GetPropertiesL(&prororo);

            inFileHandler->SetPriority(aSong->iClipArray[a]->Priority());

            inFileHandler->SeekCutInFrame();

            if (IsDecodingRequired(aSong->OutputFileProperties(), 

                                   aSong->iClipArray[a]->Info()->Properties()))

                {

                inFileHandler->SetDecodingRequired(ETrue);

                }

        }

        else if (aSong->iClipArray[a]->Info()->Properties().iFileFormat == EAudFormatAAC_ADTS) 

        {

            PRINT((_L("CAudProcessorImpl::ProcessSongL create AAC ADTS file handler")));

            CProcInFileHandler* inFileHandler = 

                CProcADTSInFileHandler::NewL(aSong->iClipArray[a]->Info()->FileName(), 

                aSong->iClipArray[a]->Info()->FileHandle(),

                aSong->iClipArray[a],

                8092, iSong->OutputFileProperties().iSamplingRate,

                iSong->OutputFileProperties().iChannelMode);

            TAudFileProperties pro;

            iInFiles.Insert(inFileHandler, iInFiles.Count());

            inFileHandler->GetPropertiesL(&pro);

            inFileHandler->SetPriority(aSong->iClipArray[a]->Priority());

            inFileHandler->SeekCutInFrame();

            if (IsDecodingRequired(aSong->OutputFileProperties(), 

                                   aSong->iClipArray[a]->Info()->Properties()))

                {

                inFileHandler->SetDecodingRequired(ETrue);

                }

        }

        else if (aSong->iClipArray[a]->Info()->Properties().iFileFormat == EAudFormatMP3) 

            {

            PRINT((_L("CAudProcessorImpl::ProcessSongL create MP3 file handler")));

            CProcInFileHandler* inFileHandler = 

                CProcMP3InFileHandler::NewL(aSong->iClipArray[a]->Info()->FileName(), 

                aSong->iClipArray[a]->Info()->FileHandle(), 

                aSong->iClipArray[a],

                4096, iSong->OutputFileProperties().iSamplingRate,

                iSong->OutputFileProperties().iChannelMode);

            iInFiles.Insert(inFileHandler, iInFiles.Count());

            inFileHandler->SetPropertiesL(aSong->iClipArray[a]->Info()->Properties());

            inFileHandler->SetPriority(aSong->iClipArray[a]->Priority());

            inFileHandler->SeekCutInFrame();

            if (IsDecodingRequired(aSong->OutputFileProperties(), 

                                   aSong->iClipArray[a]->Info()->Properties()))

                {

                inFileHandler->SetDecodingRequired(ETrue);

                }

            }

        else if (aSong->iClipArray[a]->Info()->Properties().iFileFormat == EAudFormatAMRWB) 

            {

            PRINT((_L("CAudProcessorImpl::ProcessSongL create AMRWB file handler")));

            CProcInFileHandler* inFileHandler = 

                CProcAWBInFileHandler::NewL(aSong->iClipArray[a]->Info()->FileName(), 

                aSong->iClipArray[a]->Info()->FileHandle(), 

                aSong->iClipArray[a],

                4096, iSong->OutputFileProperties().iSamplingRate,

                iSong->OutputFileProperties().iChannelMode);

            iInFiles.Insert(inFileHandler, iInFiles.Count());

            inFileHandler->SetPropertiesL(aSong->iClipArray[a]->Info()->Properties());

            inFileHandler->SetPriority(aSong->iClipArray[a]->Priority());

            inFileHandler->SeekCutInFrame();

            if (IsDecodingRequired(aSong->OutputFileProperties(), 

                                   aSong->iClipArray[a]->Info()->Properties()))

                {

                inFileHandler->SetDecodingRequired(ETrue);

                }

            }

        else if (aSong->iClipArray[a]->Info()->Properties().iFileFormat == EAudFormatWAV) 

            {

            PRINT((_L("CAudProcessorImpl::ProcessSongL create WAV file handler")));

            CProcInFileHandler* inFileHandler = 

                CProcWAVInFileHandler::NewL(aSong->iClipArray[a]->Info()->FileName(), 

                aSong->iClipArray[a]->Info()->FileHandle(), 

                aSong->iClipArray[a],

                4096, iSong->OutputFileProperties().iSamplingRate,

                iSong->OutputFileProperties().iChannelMode);

            iInFiles.Insert(inFileHandler, iInFiles.Count());

            inFileHandler->SetPropertiesL(aSong->iClipArray[a]->Info()->Properties());

            inFileHandler->SetPriority(aSong->iClipArray[a]->Priority());

            inFileHandler->SeekCutInFrame();

            if (IsDecodingRequired(aSong->OutputFileProperties(), 

                                   aSong->iClipArray[a]->Info()->Properties()))

                {

                inFileHandler->SetDecodingRequired(ETrue);

                }

            }

        }

    // find the biggest frame size for mixing buffer

    TInt maxFrameSize = 0;

    for (TInt q = 0 ; q < iInFiles.Count() ; q++)

        {

        iInFiles[q]->SetRawAudioFrameSize(aRawFrameSize);

        if (iInFiles[q]->GetDecodedFrameSize() > maxFrameSize)

            {

            maxFrameSize = iInFiles[q]->GetDecodedFrameSize();

            }

        }

    GetProcessingEventsL();

    iProcessingEvents[0]->GetAllIndexes(iClipsWritten);

    iTimeLeft = iProcessingEvents[1]->iPosition;

    iCurEvent = 0;

    if (iGetTimeEstimation)

        {

        iTimer.HomeTime();

        if (iTimeLeft >= KTimeEstimateTime)

            {

            iTimeEstimateCoefficient = iTimeLeft/KTimeEstimateTime;

            iTimeLeft = KTimeEstimateTime;

            }

        else

            {

            iTimeEstimateCoefficient = 1;

            }

        }

    PRINT((_L("CAudProcessorImpl::ProcessSongL out")));

    }

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

                                       TTimeIntervalMicroSeconds& aDuration, TBool& aRaw) 

{

    PRINT((_L("CAudProcessorImpl::ProcessSyncPieceL in")));

    aDuration = 0;

    if (iSongProcessedMilliSeconds > iSongDurationMilliSeconds)

        {

        // processing is ready

        StopProcessing();

        PRINT((_L("CAudProcessorImpl::ProcessSyncPieceL stopped processing 1, out")));

        return ETrue;

        }

    while (iTimeLeft <= 0) 

        {

        iCurEvent++;

        if (iCurEvent >= iProcessingEvents.Count()-1) 

            {

            // do we need silence in the end?

            if (iSongProcessedMilliSeconds < ProcTools::MilliSeconds(iSong->iSongDuration))

                {

                if (iGetTimeEstimation)

                    {

                    StopProcessing();

                    PRINT((_L("CAudProcessorImpl::ProcessSyncPieceL stopped processing in time estimate case, out")));

                    return ETrue;        

                    }

                WriteSilenceL(aFrame, aProgress, aDuration, aRaw);

                return EFalse;

                }

            // processing is ready

            StopProcessing();

            PRINT((_L("CAudProcessorImpl::ProcessSyncPieceL stopped processing 2, out")));

            return ETrue;

            }

        iClipsWritten.Reset();

        for (TInt tr = 0 ; tr < iProcessingEvents[iCurEvent]->IndexCount() ; tr++)

            {

            TInt clipIndex = iProcessingEvents[iCurEvent]->GetIndex(tr);

            if (clipIndex == -1 || !iSong->Clip(clipIndex, KAllTrackIndices)->Muting())

                {

                iClipsWritten.Append(iProcessingEvents[iCurEvent]->GetIndex(tr));

                }

            }

        iTimeLeft = iProcessingEvents[iCurEvent+1]->iPosition -

                iProcessingEvents[iCurEvent]->iPosition;

        if (iGetTimeEstimation)

            {

            TTime timeNow;

            timeNow.HomeTime();

            // how long has it been from the previous event?

            TTimeIntervalMicroSeconds msFromPrev = timeNow.MicroSecondsFrom(iTimer);

            iTimeEstimate += msFromPrev.Int64() * iTimeEstimateCoefficient;

            // set iTimer to home time

            iTimer.HomeTime();

            if (iTimeLeft > KTimeEstimateTime)

                {

                iTimeEstimateCoefficient = iTimeLeft/KTimeEstimateTime;

                iTimeLeft = KTimeEstimateTime;

                }

            else

                {

                iTimeEstimateCoefficient = 1;

                }

            }

        }

    if (iClipsWritten.Count() == 1) 

        {

        // if silence

        WriteSilenceL(aFrame, aProgress, aDuration, aRaw);

        PRINT((_L("CAudProcessorImpl::ProcessSyncPieceL silence, out")));

        return EFalse;

        }

    else if (iTimeLeft > 0) 

        {

        TInt inClipIndex1 = 0;

        TInt inClipIndex2 = 0;

        HighestInFilePriority(inClipIndex1, inClipIndex2);

        CAudClip* clip1 = iSong->iClipArray[iClipsWritten[inClipIndex1]];

        CAudClip* clip2 = iSong->iClipArray[iClipsWritten[inClipIndex2]];

        CProcInFileHandler* inHandler1 = iInFiles[iClipsWritten[inClipIndex1]];

        CProcInFileHandler* inHandler2 = iInFiles[iClipsWritten[inClipIndex2]];

        TBool writeClip1 = ETrue;

        TBool writeClip2 = ETrue;

        if (clip1 == clip2)

            {

            writeClip2 = EFalse;

            }

        if (clip1->Muting())

            {

            writeClip1 = EFalse;

            }

        if (clip2->Muting())

            {

            writeClip2 = EFalse;

            }

        HBufC8* frame1 = 0;

        HBufC8* frame2 = 0;

        TInt siz1 = 0;

        TInt32 tim1 = 0;

        TInt siz2 = 0;

        TInt32 tim2 = 0;

        TBool getFrameRet1 = EFalse;

        TBool getFrameRet2 = EFalse;

        // If the clip is muted -> return silence

        if (!writeClip1 && !writeClip2)

            {

            getFrameRet1 = inHandler1->GetSilentAudioFrameL(frame1, siz1, tim1, aRaw);

            }

        else if (!writeClip1 && writeClip2)

            {

            getFrameRet2 = inHandler2->GetAudioFrameL(frame2, siz2, tim2, aRaw);

            }

        else if (writeClip1 && !writeClip2)

            {

            getFrameRet1 = inHandler1->GetAudioFrameL(frame1, siz1, tim1, aRaw);

            }

        else

            {

            TBool decodingRequired1 = inHandler1->DecodingRequired();

            TBool decodingRequired2 = inHandler2->DecodingRequired();

            // decoding is needed due to mixing

            inHandler1->SetDecodingRequired(ETrue);

            inHandler2->SetDecodingRequired(ETrue);

            getFrameRet1 = inHandler1->GetAudioFrameL(frame1, siz1, tim1, aRaw);

            // fix to rel2, put frame1 to cleanup stack for the next operation

            CleanupStack::PushL(frame1);

            getFrameRet2 = inHandler2->GetAudioFrameL(frame2, siz2, tim2, aRaw);

            CleanupStack::Pop(); // frame1, will be put to cleanupstack later->

            inHandler1->SetDecodingRequired(decodingRequired1);

            inHandler2->SetDecodingRequired(decodingRequired2);

            }

        if(!getFrameRet1 && !getFrameRet2)

            {

            // no audio frames left -> write silence

            getFrameRet1 = inHandler1->GetSilentAudioFrameL(frame1, siz1, tim1, aRaw);

        }

        if (frame1 != 0)

            {

            CleanupStack::PushL(frame1);

            }

        if (frame2 != 0)

            {

            CleanupStack::PushL(frame2);

            }