/*

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

#include "AudClip.h"

#include "AudPanic.h"

#include "ProcInFileHandler.h"

#include "ProcADTSInFileHandler.h"

#include "ProcAMRInFileHandler.h"

#include "ProcMP4InFileHandler.h"

#include "ProcAWBInFileHandler.h"

#include "AACConstants.h"

#include "audconstants.h"

#include "AudProcessor.h"

#include "AACApi.h"

#include "aedproctimeestimate.h"

#include <e32base.h>

// Debug print macro

#if defined _DEBUG 

#include <e32svr.h>

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

#else

#define PRINT(x)

#endif

EXPORT_C CAudSong* CAudSong::NewL(RFs *aFs)

    {

    CAudSong* self = NewLC(aFs);

    CleanupStack::Pop(self);

    return self;

    }

EXPORT_C CAudSong* CAudSong::NewLC(RFs *aFs)

    {

    CAudSong* self = new (ELeave) CAudSong(aFs);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CAudSong::CAudSong(RFs *aFs) : iFs(aFs), iClipArray(32),  iSongDuration(0), 

                                iSongDurationManuallySet(EFalse), iObserverArray(16), iNormalize(EFalse)

    {

    }

void CAudSong::ConstructL()

    {

    iProperties = new (ELeave) TAudFileProperties();

    iProperties->iAudioType = EAudNoAudio;

    iProperties->iFileFormat = EAudFormatUnrecognized;

    iProperties->iDuration = 0;

    iProperties->iFrameCount = 0;

    iProperties->iFrameLen = 0;

    iProperties->iFrameDuration = 0;

    iProcessOperation = CAudSongProcessOperation::NewL(this);

    iAddOperation = CAudSongAddClipOperation::NewL(this);

#ifdef _WRITE_OUTPUT_TO_FILE_

    TBuf<32> fileName;

    _LIT(KFn, "C:\\audioEngineOut.");

    _LIT(KTextFileName, "C:\\audioEngineOut.txt");

    fileName.Append(KFn);

    if (iProperties->iAudioType == EAudAMR)

        {

        fileName.Append(_L("amr"));

        }

    else

        {

        fileName.Append(_L("aac"));

        }

    User::LeaveIfError(iDebFs.Connect());

    iDebFs.Delete(fileName);

    iDebFs.Delete(KTextFileName);

    iFileOpen = EFalse;

    TInt err1 = iAudioFile.Create(iDebFs, fileName, EFileWrite);

    TInt err2 = iTextFile.Create(iDebFs, KTextFileName, EFileWrite);

    if (err1 == KErrNone && err2 == KErrNone)

        {

        iFileOpen = ETrue;

        }

    if (iFileOpen && iProperties->iAudioType == EAudAMR)

        {

        iAudioFile.Write(_L8("#!AMR"));

        }

#endif

    }

EXPORT_C CAudSong::~CAudSong() 

    {

    Reset(EFalse);

    delete iProperties;

    iProperties = 0;

    delete iProcessOperation;

    iProcessOperation = 0;

    delete iAddOperation;

    iAddOperation = 0;

    iObserverArray.Reset();

#ifdef _WRITE_OUTPUT_TO_FILE_

    iAudioFile.Close();

    iTextFile.Close();

    iDebFs.Close();

#endif

    }

EXPORT_C TInt CAudSong::GetSizeEstimateL() const

    {

    // if there are no clips added yet

    if (iClipArray.Count() == 0)

        {

        return 0;

        }

    TInt durationMilli = ProcTools::MilliSeconds(iClipArray[iClipArray.Count()-1]->EndTime());

    TInt silenceDuration = ProcTools::MilliSeconds(iSongDuration) - durationMilli;

    if (silenceDuration < 0)

        {

        silenceDuration = 0;

        }

    TInt sizeInBytes = 0;

    const TInt KBitrate = iProperties->iBitrate;

    const TInt KBitsInByte = 8;

    TInt KByterate = KBitrate/KBitsInByte;

    // make sure we round up

    sizeInBytes = (durationMilli/1000+1)*KByterate;

    TInt frameDurationMilli = 20; // AMR

    TInt silentFrameLen = 13; // AMR

    if (iProperties->iAudioType == EAudAAC_MPEG4)

        {

        frameDurationMilli = ((1024*1000)/(iProperties->iSamplingRate));

        if (iProperties->iChannelMode == EAudSingleChannel)

            {

            silentFrameLen = KSilentMonoAACFrameLenght;

            }

        else

            {

            silentFrameLen = KSilentStereoAACFrameLenght;

            }

        }

    if (frameDurationMilli > 0)

        {

        TInt silentFrames = silenceDuration/frameDurationMilli;

        TInt silenceSize = silentFrames*silentFrameLen;

        sizeInBytes += silenceSize;

        }

    return sizeInBytes;

    }

EXPORT_C TInt CAudSong::GetFrameSizeEstimateL(TTimeIntervalMicroSeconds aStartTime, 

                                              TTimeIntervalMicroSeconds aEndTime) const

	{

	// if there are no clips added yet

    if (iClipArray.Count() == 0)

        {

        return 0;

        }

	TInt frameDurationMicro = 20000; // AMR

    if (iProperties->iAudioType == EAudAAC_MPEG4)

        {

        frameDurationMicro = ((1024*1000)/(iProperties->iSamplingRate))*1000;

        }

    // just in case to prevent infinite loop    

    if (frameDurationMicro <= 0)

        {

        return 0;

        }

    TInt size = 0;

    // Calculate the time of the first frame included in the time interval

    TInt64 firstFrameIndex = aStartTime.Int64() / frameDurationMicro;

    TInt64 currentTime = firstFrameIndex * frameDurationMicro;

    while (currentTime + frameDurationMicro <= aEndTime.Int64())        // Make sure the whole frame fits inside the time interval

        {

        TBool silence = ETrue;

    	TInt clipIndex = 0;

    	TInt overLappingClips = 0;

    	for (TInt a = 0 ; a < iClipArray.Count() ; a++)

    	    {

    	    if (!iClipArray[a]->Muting())

    	        {

        	    if ((currentTime >= iClipArray[a]->iStartTime.Int64() + iClipArray[a]->iCutInTime.Int64()) &&

        	       (currentTime < iClipArray[a]->iStartTime.Int64() + iClipArray[a]->iCutOutTime.Int64()))

        	        {

        	        silence = EFalse;

        	        clipIndex = a;

                    overLappingClips++;

        	        }

    	        }

    	    }

    	TInt frameSize = 0;

    	if (silence)

    	    {

    	    // if there is no audio around "aTime", just return a silent frame length

    	    if (iProperties->iAudioType == EAudAAC_MPEG4)

                {

                if (iProperties->iChannelMode == EAudSingleChannel)

                    {

                    frameSize = KSilentMonoAACFrameLenght;

                    }

                else

                    {

                    frameSize = KSilentStereoAACFrameLenght;

                    }

                }

    	    else if (iProperties->iAudioType == EAudAMR)

    	        {

    	        TInt KSilentFrameLen = 13; // AMR

    	        frameSize = KSilentFrameLen;

    	        }

    	    size +=frameSize;

    	    currentTime += frameDurationMicro;

    	    continue;

    	    }

    	// if not silent, estimate according to bitrate if transcoding

    	// if no transcoding is necessary, return the frame length of the original

    	// input clip

    	// input clip is not transcoded if the original clip has the same

    	// audio properties as the output clip and no mixing is needed

    	TAudFileProperties clipProp = iClipArray[clipIndex]->Info()->Properties();

    	TBool clipTranscoded = EFalse;

    	if (clipProp.iAudioType != 

            iProperties->iAudioType ||

            clipProp.iSamplingRate != 

            iProperties->iSamplingRate ||

            clipProp.iChannelMode != 

            iProperties->iChannelMode)

                {

                clipTranscoded = ETrue;

                }

    	if (overLappingClips > 1)

    	    {

    	    clipTranscoded = ETrue;

    	    }

    	if (clipTranscoded)

    	    {

    	    const TInt KBitrate = iProperties->iBitrate;

            const TInt KBitsInByte = 8;

            TInt KByterate = KBitrate/KBitsInByte;    

        	TInt frameDurationMilli = 20; // AMR

            if (iProperties->iAudioType == EAudAAC_MPEG4)

                {

                frameDurationMilli = ((1024*1000)/(iProperties->iSamplingRate));

        		}

        	frameSize = (KByterate/(1000/frameDurationMilli)+1);

    	    }

    	else

    	    {

    	    frameSize = clipProp.iFrameLen;

    	    }    

    	size +=frameSize;

    	currentTime += frameDurationMicro;

    	continue;

        }

    return size;

	}

EXPORT_C TAudFileProperties CAudSong::OutputFileProperties() const 

    {

    return *iProperties;

    }

EXPORT_C TBool CAudSong::GetMP4DecoderSpecificInfoLC(HBufC8*& aDecSpecInfo, TInt aMaxSize) const

    {

    if (iClipArray.Count() == 0)

        {

        return EFalse;

        }

    if (iProperties->iAudioType == EAudAAC_MPEG4)

        {

        int16 frameLen = 1024;

        int32 sampleRate = iProperties->iSamplingRate;

        uint8 profile = LC_OBJECT;

        uint8 nChannels = 1;

        uint8 decSpecInfo[16];

        int16 nConfigBytes;

        if (iProperties->iChannelMode == EAudStereo)

            {

            nChannels = 2;

            }

        //nConfigBytes = AACGetMP4ConfigInfo(&aacInfo, decSpecInfo, 16);

        nConfigBytes = AACGetMP4ConfigInfo(sampleRate, profile, 

            nChannels, frameLen, decSpecInfo, aMaxSize);

        if (nConfigBytes > 0)

            {

            aDecSpecInfo = HBufC8::NewLC(nConfigBytes);

            aDecSpecInfo->Des().Append(decSpecInfo, nConfigBytes);

            }

        return ETrue;

        }

    else if (iProperties->iAudioType == EAudAMR)

        {

        aDecSpecInfo = HBufC8::NewLC(aMaxSize);

        const TUint8 frameDecSpecInfo[] = {0x14,0x08};    //the decoder specific 

        const TInt frameSize = 2;  //constant as maximum size of decoderspecific info is 2

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

            {

            aDecSpecInfo->Des().Append(frameDecSpecInfo[a]);

            }

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

EXPORT_C TBool CAudSong::GetTimeEstimateL(MAudTimeEstimateObserver& aObserver,

                                            TAudType aAudType,

                                            TInt aSamplingRate,

                                            TChannelMode aChannelMode,

                                            TInt aBitRate)

    {

    if (iClipArray.Count() == 0)

        {

        return EFalse;

        }

    if (SetOutputFileFormat(aAudType, aSamplingRate, aChannelMode, aBitRate))

        {

        return iProcessOperation->GetTimeEstimateL(aObserver);

        }

    else

        {

        return EFalse;

        }

    }

EXPORT_C TTimeIntervalMicroSeconds CAudSong::GetTimeEstimateL()

    {

    TAudFileProperties prop;

    TInt64 estimatedTime = TInt64(0);

    TReal complexityFactor = 0.0;

    TInt a;

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

		{		

		complexityFactor = 0.0;

		prop = iClipArray[a]->Info()->Properties();

		if ( iClipArray[a]->Muting() )

		    {

		    // the clip is muted

		    complexityFactor = KAEDMutingComplFactor;

		    }

		else if ( (prop.iAudioType != iProperties->iAudioType )

		    || (prop.iChannelMode != iProperties->iChannelMode )

		    || (prop.iSamplingRate != iProperties->iSamplingRate ) )

		    {

		    // need transcoding

		    // decoding

		    switch (prop.iAudioType)

		        {

	            case EAudAMR :

	                {

    		        // AMR decoding

    		        complexityFactor = KAEDAMRDecComplFactor;

	                }

	                break;

	            case EAudAAC_MPEG4 :

	                {

    		        // AAC decoding

    		        complexityFactor = KAEDAACDecComplFactor;

	                }

	                break;

	            case EAudAMRWB :

	                {

    		        // AMR-WB decoding

    		        complexityFactor = KAEDAMRWBDecComplFactor;

	                }

	                break;

	            case EAudMP3 :

	                {

    		        // MP3 decoding

    		        complexityFactor = KAEDMP3DecComplFactor;

	                }

	                break;

                default:

                    {

	                //EAudWAV

    		        complexityFactor = KAEDWavDecComplFactor;

                    }

		        }

	        if ( prop.iChannelMode == EAudStereo )

	            {

	            complexityFactor += KAEDAACStereoDecAddComplFactor;

	            }

	        if ( prop.iSamplingRate > 8000 )

	            {

	            complexityFactor *= prop.iSamplingRate/16000;

	            }

		    // encoding

		    if (iProperties->iAudioType == EAudAMR)

                {

		        // AMR encoding

		        complexityFactor += KAEDAMREncComplFactor;