/*

* 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 <e32base.h>

#include <f32file.h>

#include "AudCommon.h"

#include "ProcConstants.h"

#include "ProcADTSInFileHandler.h"

//#include "mp4aud.h"

#include "mp4config.h"

#include "audconstants.h"

#include "ProcTools.h"

#include "ProcAACFrameHandler.h"

CProcADTSInFileHandler* CProcADTSInFileHandler::NewL(const TDesC& aFileName, RFile* aFileHandle,

                                                     CAudClip* aClip, TInt aReadBufferSize, 

                                                     TInt aTargetSampleRate, TChannelMode aChannelMode)

    {

  CProcADTSInFileHandler* self = NewLC(aFileName, aFileHandle, aClip, aReadBufferSize, aTargetSampleRate, aChannelMode);

  CleanupStack::Pop(self);

  return self;

    }

CProcADTSInFileHandler* CProcADTSInFileHandler::NewLC(const TDesC& aFileName, RFile* aFileHandle,

                                                      CAudClip* aClip, TInt aReadBufferSize, TInt aTargetSampleRate,

                                                      TChannelMode aChannelMode)

    {

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

  CleanupStack::PushL(self);

  self->ConstructL(aFileName, aFileHandle, aClip, aReadBufferSize, aTargetSampleRate, aChannelMode);

  return self;

    }

void CProcADTSInFileHandler::GetPropertiesL(TAudFileProperties* aProperties)

    {

    if (iProperties != 0)

        {

        *aProperties = *iProperties;

        return;

        }

    aProperties->iDuration = 0;

    aProperties->iSamplingRate = 0;

    aProperties->iBitrate = 0;

    aProperties->iChannelMode = EAudChannelModeNotRecognized;

    aProperties->iFrameLen = 0;

    aProperties->iFrameCount = 0;

    aProperties->iAudioType = EAudTypeUnrecognized;

    aProperties->iAudioTypeExtension = EAudExtensionTypeNoExtension;

    aProperties->iFileFormat = EAudFormatUnrecognized;

    aProperties->iBitrateMode = EAudBitrateModeNotRecognized;

    aProperties->iFrameDuration = 0;

    aProperties->iNumFramesPerSample = 1;

    aProperties->iChannelModeExtension = EAudChannelModeNotRecognized;

    aProperties->iAACObjectType = EAudAACObjectTypeNone;

    if (!iSupportedFile)

        {

        User::Leave(KErrNotSupported);

        return;

        }

    ReadHeaderInformation(aProperties);

    ReadOtherInformationL(aProperties);

    aProperties->iBitrateMode = EAudConstant;

    if (iProperties == 0)

        {

        iProperties = new (ELeave) TAudFileProperties;

        *iProperties = *aProperties;

        }

    }

TBool CProcADTSInFileHandler::SeekAudioFrame(TInt32 aTime)

    {

    if (!iSupportedFile)

        {

        return EFalse;

        }

    if (aTime == 0) 

        {

        FindFirstAACFrame();

        iCurrentTimeMilliseconds = aTime;

        return ETrue;

        }

    else FindFirstAACFrame();

    TBuf8<6> header;

    if(BufferedFileRead(header, 6) != 6)

        {

        return EFalse;

        }

    if (header.Length() != 6)

        {

        return EFalse;

        }

    TUint8 byte2 = header[1];

    TBuf8<8> byte2b;

    ProcTools::Dec2Bin(byte2, byte2b);

    // lets confirm that we have found a legal AAC header

    if (header[0] == 0xFF &&

        byte2b[0] == '1' &&

        byte2b[1] == '1' &&

        byte2b[2] == '1' &&

        byte2b[3] == '1' &&

        //byte2b[4] == '1' &&

        byte2b[5] == '0' &&

        byte2b[6] == '0')

        {

        }    

    else

        {

        return EFalse;

        }

    TUint8 byte4 = header[3];

    TUint8 byte5 = header[4];

    TUint8 byte6 = header[5];

    TUint frameLen = CalculateAACFrameLength(byte4, byte5, byte6);    

    //aFrame = HBufC8::NewL(frameLen);

    TInt dur = 0;

    while (BufferedFileSetFilePos(iFilePos-6+frameLen))

        {

        dur = dur + ProcTools::MilliSeconds(iProperties->iFrameDuration);

        if (dur > aTime)

            {

            break;

            }

        if(BufferedFileRead(header, 6) != 6)

            {

            break;

            }

        if (header.Length() != 6)

            {

            break;

            }

        if (header[0] != 0xFF) break;

        byte4 = header[3];

        byte5 = header[4];

        byte6 = header[5];

        frameLen = CalculateAACFrameLength(byte4, byte5, byte6);    

        }

    aTime = dur;

    iCurrentTimeMilliseconds = aTime;

    return ETrue;

    }

TBool CProcADTSInFileHandler::SeekCutInFrame()

    {

    iCurrentTimeMilliseconds = iCutInTime;

    return SeekAudioFrame(iCutInTime);

    }

TBool CProcADTSInFileHandler::SetNormalizingGainL(const CProcFrameHandler* aFrameHandler)

    {

    HBufC8* point = 0;

    TInt siz;

    TInt32 tim = 0;

    TInt maxGain = 0;

    RArray<TInt> gains;

    TInt maxAverage = 0;

    TInt tmpGain = 0;

    TInt gainCounter = 0;

    TInt timeNow = 0;

    while(GetEncAudioFrameL(point, siz, tim)) 

    {

        CleanupStack::PushL(point);

        aFrameHandler->GetGainL(point, gains, maxGain);

        timeNow += tim;

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

        {

            tmpGain += gains[a];

            gainCounter++;

        }

        gains.Reset();

        if (timeNow > 1000)

        {

            if (tmpGain/gainCounter > maxAverage)

            {

                maxAverage = tmpGain/gainCounter;

            }

            timeNow = 0;

            tmpGain = 0;

            gainCounter = 0;

        }

        CleanupStack::PopAndDestroy(point);

    }

    // bigger value makes normalizing more efficient, but makes

    // dynamic compression more likely to occur

    TInt NormalizingFactor = 175;

    if (iProperties->iBitrate > 20000 && iProperties->iBitrate < 40000)

    {

        // 32 kBit/s

        NormalizingFactor = 170;

    }

    else if (iProperties->iBitrate > 80000 && iProperties->iBitrate < 110000)

    {

        // 96 kBit/s

        NormalizingFactor = 170;

    }

    else if (iProperties->iBitrate > 110000 && iProperties->iBitrate < 140000)

    {

        // 128 kBit/s

        if (iProperties->iChannelMode == EAudSingleChannel)

            NormalizingFactor = 160;

        else

            NormalizingFactor = 170;

    }

    else if (iProperties->iBitrate > 150000)

    {

        // 256 kBit/s

        if (iProperties->iChannelMode == EAudSingleChannel)

            NormalizingFactor = 150;

        else

            NormalizingFactor = 165;

    }

    else

    {

        if (iProperties->iChannelMode == EAudSingleChannel)

            NormalizingFactor = 170;

    }

    TInt gainBoost = (NormalizingFactor-maxAverage)*3;

    if (gainBoost < 0) gainBoost = 0;

    iNormalizingMargin = static_cast<TInt8>(gainBoost);

    return ETrue;

    }

TBool CProcADTSInFileHandler::ReadAudioDecoderSpecificInfoL(HBufC8*& aBytes, TInt aBufferSize)

    {

    if (aBufferSize < iMP4DecSpecInfo->Size()) return EFalse;

    if (iMP4DecSpecInfo != 0)

        {    

        aBytes = HBufC8::NewL(iMP4DecSpecInfo->Size());    

        aBytes->Des().Append(iMP4DecSpecInfo->Des());

        return ETrue;

        }

    else 

        {

        aBytes = 0;

        return EFalse;

        }    

    }

CProcADTSInFileHandler::~CProcADTSInFileHandler()

    {

    ResetAndCloseFile();

    if (iSilentFrame != 0)

        {

        delete iSilentFrame;

        }

    if (iMP4DecSpecInfo != 0)

        {

        delete iMP4DecSpecInfo;

        }

    if (iFrameInfo != 0)

        {

        delete iFrameInfo;

        }

    delete iFrameHandler;

    delete iDecoder;

    }

void CProcADTSInFileHandler::ConstructL(const TDesC& aFileName, 

                                        RFile* aFileHandle,

                                        CAudClip* aClip, 

                                        TInt aReadBufferSize,

                                        TInt aTargetSampleRate,

                                        TChannelMode aChannelMode)

    {

    iTargetSampleRate = aTargetSampleRate;

    iChannelMode = aChannelMode;

    InitAndOpenFileL(aFileName, aFileHandle, aReadBufferSize);

    if (aClip != 0)

        {

        iCutInTime = ProcTools::MilliSeconds(aClip->CutInTime());

        }

    TBool frameFound = FindFirstAACFrame();

    if (!frameFound)

        {

        iSupportedFile = EFalse;

        return;

        }

    iClip = aClip;

    TAudFileProperties prop;

    iFrameInfo = new (ELeave) TAACFrameHandlerInfo;

    GetPropertiesL(&prop);

    if (prop.iAudioTypeExtension != EAudExtensionTypeNoExtension)

        {

        // AACPlus frame duration is calculated from sampling rate

        // the actual sampling rate of AAC plus is twice as high as

        // the AAC part

        iProperties->iFrameDuration = iProperties->iFrameDuration.Int64()/2;

        }

    // fill in aacInfo for retrieving decoder specific information

    //AACStreamInfo aacInfo;

    int16 frameLen = 0;

    int32 sampleRate = 0;

    uint8 profile = 0;

    uint8 nChannels = 0;

    // generate a silent frame ------------------>

    if (iProperties->iChannelMode == EAudSingleChannel)

        {

        iSilentFrame = HBufC8::NewL(KSilentMonoAACFrameLenght);    

        iSilentFrame->Des().Append(KSilentMonoAACFrame, KSilentMonoAACFrameLenght);

        nChannels = 1;

        }

    else if (iProperties->iChannelMode == EAudStereo)

        {

        iSilentFrame = HBufC8::NewL(KSilentStereoAACFrameLenght);    

        iSilentFrame->Des().Append(KSilentStereoAACFrame, KSilentStereoAACFrameLenght);

        nChannels = 2;

        }

    else

        {

        User::Leave(KErrNotSupported);

        }

    // Check that the sample rate is supported    

    if( (iProperties->iSamplingRate != KAedSampleRate8kHz) &&

        (iProperties->iSamplingRate != KAedSampleRate11kHz) &&

        (iProperties->iSamplingRate != KAedSampleRate16kHz) &&

        (iProperties->iSamplingRate != KAedSampleRate22kHz) &&

        (iProperties->iSamplingRate != KAedSampleRate24kHz) &&

        (iProperties->iSamplingRate != KAedSampleRate32kHz) &&

        (iProperties->iSamplingRate != KAedSampleRate44kHz) &&

        (iProperties->iSamplingRate != KAedSampleRate48kHz) )

        {

        User::Leave(KErrNotSupported);

        }

    uint8 decSpecInfo[16];

    int16 nConfigBytes;

    frameLen = 1024;

    sampleRate = iProperties->iSamplingRate;

    if (iFrameInfo->iProfileID == 3)

        {

        profile = LTP_OBJECT;

        }

    else if (iFrameInfo->iProfileID == 1)

        {

        profile = LC_OBJECT;

        }

    else

        {

        User::Leave(KErrNotSupported);

        }

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

    nConfigBytes = AACGetMP4ConfigInfo(sampleRate, profile, 

        nChannels, frameLen, decSpecInfo, 16);

    if (nConfigBytes > 0)

        {

        iMP4DecSpecInfo = HBufC8::NewL(nConfigBytes);

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

        }

    mp4_u32 frameDurationMilli = ProcTools::MilliSeconds(iProperties->iFrameDuration);

    iSilentFrameDuration = frameDurationMilli;

    // <------------------generate a silent frame

    // Generate a decoder ----------------------->

    iDecoder = CProcDecoder::NewL();

    iDecodingPossible = iDecoder->InitL(*iProperties, aTargetSampleRate, aChannelMode);

    // <----------------------- Generate a decoder 

    // Create a frame handler --------------------->

    iFrameHandler = CProcAACFrameHandler::NewL(*iFrameInfo);

    if (iClip != 0 && iClip->Normalizing())

        {

        SetNormalizingGainL(iFrameHandler);    

        }

    }

TBool CProcADTSInFileHandler::GetEncAudioFrameL(HBufC8*& aFrame, TInt& aSize, TInt32& aTime)

    {

    if (!iSupportedFile)

        {

        return EFalse;

        }

    TBuf8<7> header;

    if(BufferedFileRead(header, 7) != 7)

        {

        return EFalse;

        }

    if (header.Length() != 7)

        {

        return EFalse;

        }

    if (header[0] != 0xFF) return EFalse;

    TUint8 byte4 = header[3];

    TUint8 byte5 = header[4];

    TUint8 byte6 = header[5];