/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

* Description:  This class provides utility functions such as parsing of header

*				 information for VBR type clips.

*

*/

//  INCLUDES

#include "AdvancedAudioUtility.h"

#include "AdvancedAudioDecoder.h"

#include "DebugMacros.h"

#include <mmffile.h>

#include <mmfcontrollerframeworkbase.h>

#include <stdlib.h> // for abs

#include <mmfclip.h>

// CONSTANTS

const TUint64 KMaxScanDuration = 36000000000U;	// 10 hours

const TUint KSizeOfTagOffset = 6;

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::CAdvancedAudioUtility

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

EXPORT_C CAdvancedAudioUtility::CAdvancedAudioUtility()

	:	iPosArr(NULL),

    	iSamplingRate(0),

    	iBitRate(0),

    	iChannels(0),

    	iSamplesPerFrame(0),

    	iScanDuration(0),

    	iScanByteCount(0),

    	iScanInvByteCount(0),

    	iSavedLength(0),

    	iClipSize(0),

    	iHeaderOffset(0),

    	iSyncOffset(0),

    	iNumFrames(0),

    	iSumBitRate(0),

   	    iLenMetaData(0)

    {

    iObserver = NULL;

    iFrameTimeMs = 0;

    iReferenceBitRate = 0;

    iScannedOnce = EFalse;

    iDecoder = NULL;

    }

// Destructor

EXPORT_C CAdvancedAudioUtility::~CAdvancedAudioUtility()

    {

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::ScanFramesL

// Scan source buffer, frame by frame to update the frame count, byte count and

// duration. Record controller still uses this, but not play controller.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::ScanFramesL(

	CMMFClip* aClip,

	CMMFDataBuffer* aBuf,

	TBool aScanThisBufferOnly,

    TInt /*aSourcePosition*/)

	{

    if (iScanDuration && !aScanThisBufferOnly)

        {

        // Already scanned once!

	    return aBuf->Data().Size();

        }

    iClipSize = aClip->Size();

    if (!aScanThisBufferOnly)

        {

        iHeaderOffset = this->SeekSync(aBuf, aBuf->Data().Size());

        }

    TInt readLen;

    TInt seekLen;

    const TUint8* seekPtr;

    TBool Done = EFalse;

    TInt SeekOffset = this->SeekSync(aBuf, aBuf->Data().Size());

	if (SeekOffset == aBuf->Data().Size())

		return SeekOffset;

    while (!Done)

        {

        readLen = aBuf->Data().Length();

        seekLen = readLen - SeekOffset;

        seekPtr = aBuf->Data().Ptr() + SeekOffset;

        TAudioFrameInfo frameInfo;

        while (seekLen >= this->FrameHeaderSize())

            {

            // Scan frame by frame until free format frame or EOB detected.

            TInt length = this->FrameInfo(seekPtr, seekLen, frameInfo);

            if (length > 0  &&  frameInfo.iBitRate > 0)

                {

                // record time position every time the frame length changes

                RecordTimeStampL(length);

                // update counters

                iScanByteCount += length;

                iScanDuration += (1000000*frameInfo.iFrameSamples) /

                                  frameInfo.iSamplingRateOut;

                iSamplingRate = frameInfo.iSamplingRate;

			    // Ignoring NO_DATA and SID Frames in bitrate calculation

                if (frameInfo.iBitRate != 400 && frameInfo.iBitRate != 2400)

                   	{

                		iSumBitRate += frameInfo.iBitRate;

                		iNumFrames++;

                		iBitRate = iSumBitRate/iNumFrames;

                	}

                iSamplesPerFrame = frameInfo.iFrameSamples;

                iChannels = frameInfo.iChannels;

                seekPtr += length;

                seekLen -= length;

                }

            else if (frameInfo.iBitRate < 0)

                {

                seekLen = readLen = 0;

                }

            else

                {

                iScanInvByteCount++;

                seekPtr++;

                seekLen--;

                iSavedLength = 0;

                }

            }

        // request more data, if eof or max scan duration has not been exceeded

        if ((readLen < this->FrameHeaderSize()) || (iScanDuration > KMaxScanDuration) || aScanThisBufferOnly)

            {

            Done = ETrue;

            }

        else

            {

            // request more data

            SeekOffset = 0;

            aClip->ReadBufferL(aBuf, iHeaderOffset+iScanByteCount+iScanInvByteCount);

            }

        }

	return aBuf->Data().Size();

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::ScanHeaderL

// -----------------------------------------------------------------------------

//

EXPORT_C void CAdvancedAudioUtility::ScanHeaderL(

	CMMFDataBuffer* aDataBuf)

	{

    // currently we are not handling how to search past the metadata

	ScanFramesL(aDataBuf, EFalse, 0);

	// reset iScanDuration because we didn't scan through the whole file,

    // and iScanDuration would not be the Total Duration of the source		

    iScanDuration = 0;

	}

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::ScanFramesL

// Scan source buffer, frame by frame to update the frame count, byte count and

// duration.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::ScanFramesL(

	CMMFDataBuffer* aBuf,

	TBool aScanThisBufferOnly,

    TInt /*aSourcePosition*/)

	{

    if (!aScanThisBufferOnly)

        {

        // Already scanned once!

        if (iScannedOnce)

            return aBuf->Data().Size();

        iHeaderOffset = this->SeekSync(aBuf, aBuf->Data().Size());

        }

    TInt readLen;

    TInt seekLen;

    const TUint8* seekPtr;

    TBool Done = EFalse;

    TInt SeekOffset = this->SeekSync(aBuf, aBuf->Data().Size());

    while (!Done)

        {

        readLen = aBuf->Data().Length();

        seekLen = readLen - SeekOffset;

        seekPtr = aBuf->Data().Ptr() + SeekOffset;

        TAudioFrameInfo frameInfo;

        while (seekLen >= this->FrameHeaderSize())

            {

            // Scan frame by frame until free format frame or EOB detected.

            TInt length = this->FrameInfo(seekPtr, seekLen, frameInfo);

            if (length > 0  &&  frameInfo.iBitRate > 0)

                {

                // record time position every time the frame length changes

                RecordTimeStampL(length);

                // update counters

                iScanByteCount += length;

                iScanDuration += (1000000*frameInfo.iFrameSamples)/frameInfo.iSamplingRateOut;

                iSamplingRate = frameInfo.iSamplingRate;

                if (iScanDuration)

                    iScannedOnce = ETrue;

                // Ignoring NO_DATA and SID Frames in bitrate calculation

                // this logic here is kinda dangerous, because ScanFramesL can be called

                // multiple time when SetPositionL is supported in Streaming/PDL, hence

                // the avg bitrate can be mess up the the repeat of the same frame

                if (frameInfo.iBitRate != 400 && frameInfo.iBitRate != 2400)

                   	{

            		iSumBitRate += frameInfo.iBitRate;

            		iNumFrames++;

            		iBitRate = iSumBitRate/iNumFrames;

                	}

                iSamplesPerFrame = frameInfo.iFrameSamples;

                iChannels = frameInfo.iChannels;

                seekPtr += length;

                seekLen -= length;

                }

            else if (frameInfo.iBitRate < 0)

                {

                seekLen = readLen = 0;

                }

            else

                {

                iScanInvByteCount++;

                seekPtr++;

                seekLen--;

                iSavedLength = 0;

                }

            }

         // request more data how? , if eof or max scan duration has not been exceeded

        if (aScanThisBufferOnly)

            {

            Done = ETrue;

            }

		}

	return aBuf->Data().Size();

    }

// -----------------------------------------------------------------------------

//  CAdvancedAudioUtility::FindFramePos

//  Finds the byte position of the frame at given time position.

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::FindFramePos(

	const TInt64& aTimePos,

	CMMFClip* /*aClip*/)

    {

    TInt ret = KErrNotFound;

    // calculate frame duration

    TInt64 frmTime((iSamplesPerFrame*1000000) / iSamplingRate);

    // find the closest larger time stamp corresponding to time position

    TInt pos = 0;

    TTimePos timeStamp((aTimePos), 0, 0);

    TKeyArrayFix timeKey(_FOFF(TTimePos,iTimePos),ECmpTInt64);

    iPosArr->FindIsq(timeStamp, timeKey, pos);

    // calculate byte position based on the closest smaller time stamp

    if (iPosArr->Count() > 0)

        {

        // get the closest smaller

        if (pos > 0)

        	{

			pos--;

			}

        TTimePos& ts = iPosArr->At(pos);

        // offset from the closest smaller time stamp

        TInt64 dTime = aTimePos - ts.iTimePos;

        // time stamp position plus byte offset within this segment

        ret = ts.iBytePos + ((dTime / frmTime) * ts.iFrameLen);

        }

    // limit check

    if (ret < 0)

    	{

		ret = 0;

		}

    if ((ret > iClipSize) && (iClipSize != 0))

    	{

		ret = iClipSize;

		}

	DP3(_L("CAdvancedAudioUtility::FindFramePos high[%d], low[%d], ret[%d]"), I64HIGH(aTimePos), I64LOW(aTimePos), ret);

    return ret;

    }

// CAdvancedAudioUtility::FrameInfo

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::FrameInfo(

	const TUint8* /*aBuf*/,

	TInt /*aBufLen*/,

	TAudioFrameInfo& /*aInfo*/)

	{

	return 0;

	}

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::SampleRate

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::SampleRate()

    {

    return iSamplingRate;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::Channels

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::Channels()

    {

    return iChannels;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::ChannelsOut

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::ChannelsOut()

    {

    return iChannelsOut;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::ScanDuration

// -----------------------------------------------------------------------------

// get rid of this

EXPORT_C TInt64 CAdvancedAudioUtility::ScanDuration()

    {

    return iScanDuration;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::Duration

// -----------------------------------------------------------------------------

// default impl

EXPORT_C TInt64 CAdvancedAudioUtility::Duration()

    {

    DP0(_L("CAdvancedAudioUtility::Duration()"));

    TInt64 bitRate = BitRate(); // update bitrate

   	TInt64 size = iClipSize;

   	size -= (iSyncOffset+iHeaderOffset);

    if (size >= 0)

       	{

    	if (bitRate > 0)

    		{

    		iDurationUs = size*8000000/bitRate;

    		}

    	}

    DP3(_L("CAdvancedAudioUtility::Duration() iDuration(ms)[%d] bitRate[%d] size[%d]"), iDurationUs/1000, bitRate, iClipSize-iSyncOffset-iHeaderOffset);

    return iDurationUs;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::BitRate

// -----------------------------------------------------------------------------

// default impl - BitRate() would be called by user and updates reference

EXPORT_C TInt CAdvancedAudioUtility::BitRate()

    {

    if (iDecoder && !iBitRateFrozen)

        {

        TInt bitrate = iDecoder->BitRate();

        if (bitrate > 0)

        	{

            iBitRate = bitrate;

        	}

        }

    return iBitRate;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::HeaderOffset

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::HeaderOffset()

    {

    return iHeaderOffset;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::SyncOffset

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::SyncOffset()

    {

    return iSyncOffset;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::SetCodecConfigData

// -----------------------------------------------------------------------------

//

EXPORT_C void CAdvancedAudioUtility::SetCodecConfigData(

	RArray<TInt>& /*aCodecConfig*/)

    {

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::SetObserver

// -----------------------------------------------------------------------------

//

EXPORT_C void CAdvancedAudioUtility::SetObserver(MAdvancedAudioUtilityObserver& aObserver)

    {

    iObserver = &aObserver;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::SetDecoder

// -----------------------------------------------------------------------------

//

EXPORT_C void CAdvancedAudioUtility::SetDecoder(CAdvancedAudioDecoder& aDecoder)

    {

    iDecoder = &aDecoder;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::DeReferenceDecoder

// -----------------------------------------------------------------------------

//

EXPORT_C void CAdvancedAudioUtility::DeReferenceDecoder()

    {

    iDecoder = NULL;

    }

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::FrameHeaderSize

// -----------------------------------------------------------------------------

//

EXPORT_C TInt CAdvancedAudioUtility::FrameHeaderSize()

	{

	return 0;

	}

// -----------------------------------------------------------------------------

// CAdvancedAudioUtility::GetDriveNumber

// -----------------------------------------------------------------------------

// is this needed?

EXPORT_C TDriveNumber CAdvancedAudioUtility::GetDriveNumber(

	const TDesC& aDriveName)

    {

    TDriveNumber driveNumber = EDriveC;

    if (!aDriveName.Length())

        {

        return driveNumber;

        }

    else

        {

        switch (aDriveName[0])

            {

            case 'a':

            case 'A':

                driveNumber = EDriveA;

                break;

            case 'b':

            case 'B':

                driveNumber = EDriveB;

                break;

            case 'c':

            case 'C':

                driveNumber = EDriveC;

                break;

            case 'd':

            case 'D':

                driveNumber = EDriveD;

                break;

            case 'e':

            case 'E':

                driveNumber = EDriveE;

                break;

            case 'f':

            case 'F':

                driveNumber = EDriveF;

                break;

            case 'g':

            case 'G':

                driveNumber = EDriveG;

                break;

            case 'h':

            case 'H':

                driveNumber = EDriveH;

                break;

            case 'i':

            case 'I':

                driveNumber = EDriveI;

                break;

            case 'j':

            case 'J':

                driveNumber = EDriveJ;

                break;