/*

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

#include "ProcMP4InFileHandler.h"

#include "mp4aud.h"

#include "ProcAACFrameHandler.h"

#include "ProcAMRFrameHandler.h"

#include "ProcAWBFrameHandler.h"

#include "audconstants.h"

#include "ProcTools.h"

//#include "aacenc_interface.h"

// Debug print macro

#if defined _DEBUG 

#include <e32svr.h>

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

#else

#define PRINT(x)

#endif

// Max coded AAC frame size (768 bytes per channel)

const TUint KMaxAACFrameSize(1536);

CProcMP4InFileHandler* CProcMP4InFileHandler::NewL(const TDesC& aFileName, 

                                                   RFile* aFileHandle,

                                                   CAudClip* aClip, TInt aReadBufferSize,

                                                   TInt aTargetSampleRate, 

                                                   TChannelMode aChannelMode)

    {

    CProcMP4InFileHandler* self = NewLC(aFileName, aFileHandle, aClip, aReadBufferSize, 

                                        aTargetSampleRate, aChannelMode);

    CleanupStack::Pop(self);

    return self;

    }

CProcMP4InFileHandler* CProcMP4InFileHandler::NewLC(const TDesC& aFileName, 

                                                    RFile* aFileHandle,

                                                    CAudClip* aClip, TInt aReadBufferSize,

                                                    TInt aTargetSampleRate, 

                                                    TChannelMode aChannelMode)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL(aFileName, aFileHandle, aClip, aReadBufferSize,

                        aTargetSampleRate, aChannelMode);

    return self;

    }

void CProcMP4InFileHandler::GetPropertiesL(TAudFileProperties* aProperties)

    {

    PRINT((_L("CProcMP4InFileHandler::GetPropertiesL in") ));

    if (iProperties != 0)

    {

        *aProperties = *iProperties;

        PRINT((_L("CProcMP4InFileHandler::GetPropertiesL use cached properties, out") ));

        return;

    }

    if (iProperties == 0)

    {

        iProperties = new (ELeave) TAudFileProperties;

    }

    mp4_u32 audiolength = 0; 

    mp4_u32 audiotype = 0; 

    mp4_u8 framespersample = 0; 

    mp4_u32 timescale = 0; 

    mp4_u32 averagebitrate = 0;

    aProperties->iFileFormat = EAudFormatUnrecognized;

    aProperties->iAudioType = EAudTypeUnrecognized;

    aProperties->iDuration = 0;

    aProperties->iSamplingRate = 0;

    aProperties->iBitrate = 0;

    aProperties->iChannelMode = EAudChannelModeNotRecognized;

    aProperties->iBitrateMode = EAudBitrateModeNotRecognized;

    aProperties->iAudioTypeExtension = EAudExtensionTypeNoExtension;

    aProperties->iFrameLen = 0;

    aProperties->iFrameDuration = 0;

    aProperties->iFrameCount = 0;

    aProperties->iNumFramesPerSample = 1;

    aProperties->iAACObjectType = EAudAACObjectTypeNone;

    MP4Err err = MP4ParseRequestAudioDescription(iParser, 

        &audiolength, 

        &audiotype, 

        &framespersample, 

        &timescale, 

        &averagebitrate);

    if (err == MP4_OK)

        {

        if (audiotype == MP4_TYPE_MPEG4_AUDIO)

            {

            aProperties->iAudioType = EAudAAC_MPEG4;

            aProperties->iBitrateMode = EAudVariable;

            }

        else if (audiotype == MP4_TYPE_AMR_NB)

            {

            aProperties->iAudioType = EAudAMR;

            aProperties->iBitrateMode = EAudVariable;

            }

        else if (audiotype == MP4_TYPE_AMR_WB)

            {

            aProperties->iAudioType = EAudAMRWB;

            aProperties->iBitrateMode = EAudVariable;

            }

        aProperties->iBitrate = averagebitrate;

        // casting for PC-Lint

        TInt64 ti = (TInt64)(TInt)(audiolength*1000);

        TTimeIntervalMicroSeconds TTaudiolength(ti);

        aProperties->iDuration = TTaudiolength;

        aProperties->iFileFormat = EAudFormatMP4;

        //aProperties->iFrameLen = framespersample;

        }

    else if (err == MP4_NO_AUDIO)

        {

        aProperties->iAudioType = EAudNoAudio;

        *iProperties = *aProperties;

        return; 

        //User::Leave(KErrGeneral);

        }

    else

        {

        // a special case: there may be audio track but it is empty; if type was recognized, mark as no audio

        if ( (audiotype == MP4_TYPE_MPEG4_AUDIO) || (audiotype == MP4_TYPE_AMR_NB) || (audiotype == MP4_TYPE_AMR_WB))

            {

            PRINT((_L("CProcMP4InFileHandler::GetPropertiesL problems with getting audio description, mark no audio since audio type was recognized")));

            aProperties->iAudioType = EAudNoAudio;

            *iProperties = *aProperties;

            }

        PRINT((_L("CProcMP4InFileHandler::GetPropertiesL out with MP4Err %d"), err ));

        return;

        }

    const TInt KMaxBufferSize = 128;

    mp4_u8 *buffer = new (ELeave) mp4_u8[KMaxBufferSize];

    CleanupStack::PushL(buffer);

    mp4_u32 decspecinfosize = 0;

    err = MP4ParseReadAudioDecoderSpecificInfo(

        iParser, 

        buffer, 

        KMaxBufferSize, 

        &decspecinfosize);

    mp4AACTransportHandle mp4AAC_ff;

    if (err == MP4_OK && aProperties->iAudioType == EAudAAC_MPEG4)

        {

        PRINT((_L("CProcMP4InFileHandler::GetPropertiesL AAC found") ));

        TInt ret = ReadMP4AudioConfig(buffer, 

            decspecinfosize, 

            &mp4AAC_ff);

        if (ret != TRUE)

            {

            aProperties->iFileFormat = EAudFormatUnrecognized;

            aProperties->iAudioType = EAudTypeUnrecognized;

            User::Leave(KErrNotSupported);

            }

        //        ProgConfig progCfg = mp4AAC_ff.progCfg;

        AudioSpecificInfo audioInfo = mp4AAC_ff.audioInfo;

        aProperties->iSamplingRate = audioInfo.samplingFrequency;

        //        TInt tmp = mp4AAC_ff.progCfg.coupling.num_ele;

        // Check that the sample rate is supported    

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

            (aProperties->iSamplingRate != KAedSampleRate11kHz) &&

            (aProperties->iSamplingRate != KAedSampleRate16kHz) &&

            (aProperties->iSamplingRate != KAedSampleRate22kHz) &&

            (aProperties->iSamplingRate != KAedSampleRate24kHz) &&

            (aProperties->iSamplingRate != KAedSampleRate32kHz) &&

            (aProperties->iSamplingRate != KAedSampleRate44kHz) &&

            (aProperties->iSamplingRate != KAedSampleRate48kHz) )

            {

            User::Leave(KErrNotSupported);

            }

        if (audioInfo.channelConfiguration == 2)

            {

            aProperties->iChannelMode = EAudStereo;

            }

        else if (audioInfo.channelConfiguration == 1)

            {

            aProperties->iChannelMode = EAudSingleChannel;

            }

        else

            {

            aProperties->iChannelMode = EAudChannelModeNotRecognized; 

            }

        if (mp4AAC_ff.audioInfo.samplingFreqIdx !=

            mp4AAC_ff.progCfg.sample_rate_idx)

            {

            aProperties->iFileFormat = EAudFormatUnrecognized;

            aProperties->iAudioType = EAudTypeUnrecognized;

            aProperties->iDuration = 0;

            aProperties->iSamplingRate = 0;

            aProperties->iBitrate = 0;

            aProperties->iChannelMode = EAudChannelModeNotRecognized;

            aProperties->iBitrateMode = EAudBitrateModeNotRecognized;

            aProperties->iFrameLen = 0;

            aProperties->iFrameDuration = 0;

            aProperties->iFrameCount = 0;

            aProperties->iNumFramesPerSample = 1;

            CleanupStack::PopAndDestroy(buffer);

            PRINT((_L("CProcMP4InFileHandler::GetPropertiesL audio not recognized, out") ));

            User::Leave(KErrNotSupported);

            return;

            }

        iFrameInfo->iSampleRateID = static_cast<TUint8>(mp4AAC_ff.progCfg.sample_rate_idx);

        iFrameInfo->iSampleRateID = static_cast<TUint8>(mp4AAC_ff.audioInfo.samplingFreqIdx);

        iFrameInfo->iProfileID = static_cast<TUint8>(mp4AAC_ff.progCfg.profile);

        aProperties->iAACObjectType = TAudAACObjectType(iFrameInfo->iProfileID);    

        if (aProperties->iChannelMode == EAudStereo)

            {

            iFrameInfo->iNumChannels = 2;

            }

        else if (aProperties->iChannelMode == EAudSingleChannel)

            {

            iFrameInfo->iNumChannels = 1;

            }

        else

            {

            iFrameInfo->iNumChannels = 0;

            }

        iFrameInfo->iIs960 = mp4AAC_ff.audioInfo.gaInfo.FrameLengthFlag;

        iFrameInfo->iNumCouplingChannels = 0;

        iFrameInfo->isSBR = 0;

        iFrameInfo->iIsParametricStereo = 0;

        /*

        * Get frame parameters for eAAC+ codec. It is possible that the bitstream

        * is plain AAC but we don't know it before the 1st frame is parsed!

        */

        HBufC8* frame = 0;

        TInt size = 0;

        TInt32 time = 0;

        // Set the iProperties as GetEncAudioFrameL is using it!! 

        *iProperties = *aProperties;

        if(GetEncAudioFrameL(frame, size, time))

            {

            PRINT((_L("CProcMP4InFileHandler::GetPropertiesL check AAC+ parameters") ));

            TUint8* buf = const_cast<TUint8*>(frame->Right(frame->Size()).Ptr());

            CProcAACFrameHandler::GetEnhancedAACPlusParametersL(buf, frame->Size(), aProperties, iFrameInfo);

            delete frame;

            frame = 0;

          }

    }

    else if (err == MP4_OK && aProperties->iAudioType == EAudAMR)

        {

        aProperties->iChannelMode = EAudSingleChannel;

        aProperties->iSamplingRate = 8000;

        }

    else if (err == MP4_OK && aProperties->iAudioType == EAudAMRWB)

        {

        aProperties->iChannelMode = EAudSingleChannel;

        aProperties->iSamplingRate = 16000;

        }

    TInt frameAmount = 0;

    TInt frameSize = 0;

    TInt frameDuration = 0;

    TInt rv = ETrue;

    *iProperties = *aProperties;

    rv = GetAudioFrameInfoL(frameAmount, frameDuration, frameSize, aProperties);

    if (rv)

        {

        aProperties->iFrameCount = frameAmount;

        aProperties->iFrameLen = frameSize;

        // casting for PC-Lint

        TInt64 durMicro = (TInt64) (TInt) frameDuration*1000;

        aProperties->iFrameDuration = durMicro;

        }    

    *iProperties = *aProperties;

    CleanupStack::PopAndDestroy(buffer);

    PRINT((_L("CProcMP4InFileHandler::GetPropertiesL out") ));

    }

TBool CProcMP4InFileHandler::SeekAudioFrame(TInt32 aTime)

    {

    mp4_u32 position = static_cast<TUint32>(aTime);

    mp4_u32 audioPosition = 0;

    mp4_u32 videoPosition = 0;

    mp4_bool keyframe = EFalse;

    if (iMP4ReadBuffer != 0)

        {

        delete[] iMP4ReadBuffer;

        iMP4ReadBuffer = 0;

        iMP4ReadBufferPos = 0;

        iMP4ReadBufferSize = 0;    

        }

    MP4Err err = MP4ParseSeek(iParser,

                        position,

                        &audioPosition,

                        &videoPosition,

                        keyframe);

    if (err == MP4_OK)

        {

        iCurrentTimeMilliseconds = audioPosition;

        iLastTimeStamp = audioPosition - I64INT(iProperties->iFrameDuration.Int64()/1000);

        aTime = audioPosition;

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

TBool CProcMP4InFileHandler::SeekCutInFrame()

    {

    iCurrentTimeMilliseconds = iCutInTime;

    return SeekAudioFrame(iCutInTime);

    }

TBool CProcMP4InFileHandler::SetNormalizingGainL(const CProcFrameHandler* aFrameHandler)

{

    if (iProperties->iAudioType == EAudAAC_MPEG4)

    {

        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)) 

        {

            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;

            }

            delete 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);

    }

    else if (iProperties->iAudioType == EAudAMR)

        {

        HBufC8* point = 0;

        TInt siz;

        TInt32 tim = 0;

        TInt8 margin = 0;

        TInt minMargin = KMaxTInt;

        TInt tmpGain = 0;

        TInt frameCounter = 0;

        while(GetEncAudioFrameL(point, siz, tim)) 

            {

            aFrameHandler->GetNormalizingMargin(point, margin);

            tmpGain += margin;

            delete point;

            point = 0;

            frameCounter++;

            if (frameCounter > 1) 

                {

                tmpGain = tmpGain/3;

                if (tmpGain < minMargin)