/*
* 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:  Class definition for the AAC utility functions.
*
*/


//  INCLUDES
#include "EAACPlusAudioControllerUtility.h"
#include "DebugMacros.h"
#include <e32svr.h>                             //For Debug
#include <mmfdatabuffer.h>

// CONSTANTS
//const TInt KAdtsNumFramesToScan = 500;
//const TInt KAdifNumFramesToScan = 200;
//const TInt KMaxAacFrameSize     = 1536;

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

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::CEAACPlusAudioControllerUtility
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CEAACPlusAudioControllerUtility::CEAACPlusAudioControllerUtility()
    {
    }

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CEAACPlusAudioControllerUtility::ConstructL()
    {
	DP0(_L("CEAACPlusAudioControllerUtility::ConstructL"));

	iAacUtil = CEAacPlusUtil::NewL();
    }

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CEAACPlusAudioControllerUtility* CEAACPlusAudioControllerUtility::NewL()
	{
	DP0(_L("CEAACPlusAudioControllerUtility::NewL"));

    CEAACPlusAudioControllerUtility* self = new(ELeave) CEAACPlusAudioControllerUtility;
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// Destructor
EXPORT_C CEAACPlusAudioControllerUtility::~CEAACPlusAudioControllerUtility()
    {
	delete iAacUtil;
    }

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::PrependHeader
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CEAACPlusAudioControllerUtility::PrependHeader()
    { // not needed
	DP0(_L("CEAACPlusAudioControllerUtility::PrependHeader"));

    return (iFormatType == CEAacPlusUtil::EAacPlusFormatAdif) ? ETrue : EFalse;
    }

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::ScanHeaderL
// Used to scan the header information
// -----------------------------------------------------------------------------
//
void CEAACPlusAudioControllerUtility::ScanHeaderL(
	CMMFDataBuffer* aDataBuf)
	{
	DP0(_L("CEAACPlusAudioControllerUtility::ScanHeaderL"));

    const TUint8* bufferPtr = aDataBuf->Data().Ptr();
    TInt bufferSize = aDataBuf->Data().Size();
	
	TInt scannedBuffer = 0;
	iBitRateFrozen = EFalse;
	
    if (iLenMetaData == 0)
        {
        iSyncOffset = 0;
        iLenMetaData = ID3HeaderLength(aDataBuf);
        }

    TInt bufferRemaining = bufferSize;

    while (iLenMetaData > 0)
        {
	    if (iLenMetaData >= bufferRemaining)
	        {
	        // this buffer contain no frame
	        iSyncOffset += bufferRemaining;
	        iLenMetaData -= bufferRemaining;
	        User::Leave(KErrNotReady);
	        }
	    else
	        {
	        iSyncOffset += iLenMetaData;
	        scannedBuffer += iLenMetaData;
	        // be sure to check for following id3 tags
	        bufferRemaining = bufferSize - scannedBuffer;
	        aDataBuf->SetPosition(scannedBuffer);
	        iLenMetaData = ID3HeaderLength(aDataBuf);
    	    }
        }


    TInt seekOffset = 0;
    aDataBuf->SetPosition(scannedBuffer);
	seekOffset = SeekSync(aDataBuf, aDataBuf->Data().Size());
	
    iSyncOffset += seekOffset; // offset to this point from content beginning
    scannedBuffer += seekOffset; // offset to this point in this buffer
    aDataBuf->SetPosition(scannedBuffer);
    
	if (seekOffset == aDataBuf->Data().Size())
		{
		User::Leave(KErrNotReady);
		}

//    iSyncOffset += seekOffset; // offset to this point from content beginning
//    scannedBuffer += seekOffset; // offset to this point in this buffer
//    aDataBuf->SetPosition(scannedBuffer);
    
	DP0(_L("CEAACPlusAudioControllerUtility::ScanHeaderL - Calling FrameInfo"));

    CEAacPlusUtil::TEAacPlusFrameInfo frameInfo;
    TInt hdrLen = bufferSize-scannedBuffer;
    
    TInt status = iAacUtil->GetAacFrameInfo(bufferPtr+scannedBuffer, hdrLen, frameInfo);

    iOutFrameSize = frameInfo.iOutFrameSize;
    iSamplesPerFrame = frameInfo.iNoOfSamples;
    iSamplingFrequency = frameInfo.iSamplingFrequency;
    iChannels = frameInfo.iNoOfChannels;
    iChannelsOut = frameInfo.iNoOfChannels; // util should set this to 2 if PS is present
    iProfile = frameInfo.iObjectType-1; // convert from object type back to what decoder uses 
    iOutSamplingFrequency = frameInfo.iOutSamplingFrequency;
    iDownSampledMode = frameInfo.iDownSampledMode;

    iExtObjectType = 0;
	if (frameInfo.iSbr)
		{
		iExtObjectType = 5;
// ??????????????? double-check this - if this is done, dsm should also have to be enabled
//        if (iOutSamplingFrequency > 48000)
//        	iSamplingRate = iOutSamplingFrequency/2;
//        else
//        	iSamplingRate = iOutSamplingFrequency;
		}
//	else    // For Regular AAC Files
//    	{
        iSamplingRate = iOutSamplingFrequency;
//    	}
	if (frameInfo.iPs)
	    {
	    iExtObjectType = 6;
	    }

	status = iAacUtil->GetAacFormatType(bufferPtr+scannedBuffer, bufferSize-scannedBuffer, iFormatType);

	iHeaderOffset = 0;
    iBitRate = 0;
    iDurationUs = 0;
    TInt frameLen = 0;
    
	switch (iFormatType)
		{
		case CEAacPlusUtil::EAacPlusFormatAdif:
            iHeaderOffset = hdrLen;
            iBitRate = GetBitrate(aDataBuf);
			if (iBitRate != 0)
				{ // if we can read bitrate from the header, then use it from now on
				DP1(_L("CEAACPlusAudioControllerUtility::ScanHeaderL freezing bitrate [%d]"), iBitRate);
				iBitRateFrozen = ETrue;
				break;
				}
			scannedBuffer += iHeaderOffset;	

		case CEAacPlusUtil::EAacPlusFormatAdts:
		case CEAacPlusUtil::EAacPlusFormatRaw:
			{
//        	status = iAacUtil->GetAacFrameLength(bufferPtr+scannedBuffer, bufferSize-scannedBuffer, frameLen);
//        	// don't use first frame in averaging below, it may be short
//	        if (frameLen <= 0)
//	            { // don't event try to calculate bitrate
//	            frameLen = 0;
//	            break;
//	            }
	
	        TInt frameBytes = 0;
	        TInt avgFrameLen = 0;
	        TInt frames = 0;
//            scannedBuffer += frameLen;
            for (TInt i=1; i<=100; i++)
                {
                if (scannedBuffer > bufferSize)
                    {
                    break;
                    }
    	        status = iAacUtil->GetAacFrameLength(bufferPtr+scannedBuffer, bufferSize-scannedBuffer, frameLen);
                scannedBuffer += frameLen;
    	        if (frameLen <= 0)
    	            {
    	            break;
    	            }
//    	        if (frameLen > (avgFrameLen << 1))
    	        if (i == 10) // ignore the first 10 frames
    	        	{
	    	        frameBytes = frameLen;
					frames = 1;    	        	
    	        	}
    	        else
    	        	{
	    	        frameBytes += frameLen;
					frames++;    	        	
    	        	}	
    	        avgFrameLen = frameBytes / frames; // frames is always non-zero here
                }
            iBitRate = (avgFrameLen * 8 * iSamplingFrequency) / iSamplesPerFrame;
			break;
			}
		default:
			User::Leave(KErrNotSupported);
			break;
		}
    }

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::SeekSync
// -----------------------------------------------------------------------------
//
TInt CEAACPlusAudioControllerUtility::SeekSync(
	CMMFDataBuffer* aBuf, TInt aBufLen)
	{ // should return aBufLen if not found
	DP0(_L("CEAACPlusAudioControllerUtility::SeekSync"));
    const TUint8* buf = aBuf->Data().Ptr() + aBuf->Position();
    TInt bufLen = aBufLen - aBuf->Position();

    const TInt KNotFound = aBufLen;     // sync not found position
    TInt syncPos = KNotFound;
    TInt seekLen = 0;
    
    while (seekLen < bufLen)
        {
        if (IsValidAacFrame(buf + seekLen, bufLen - seekLen))
        	{
        	syncPos = seekLen;
            break;
			}
        seekLen++;
        }
    return syncPos;
    }

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::SetCodecConfigData
// -----------------------------------------------------------------------------
// This is really a get, not a set
void CEAACPlusAudioControllerUtility::SetCodecConfigData(
	RArray<TInt>& aCodecConfig)
    {
    aCodecConfig[0]  = iSamplingRate;
    aCodecConfig[1]  = iChannels;
    aCodecConfig[2]  = iProfile;
    aCodecConfig[3]  = iOutFrameSize;
    aCodecConfig[4]  = iSamplesPerFrame;
    aCodecConfig[5]  = iSamplingFrequency;
    aCodecConfig[7]  = iDownSampledMode;
    aCodecConfig[9]  = iOutSamplingFrequency;
    aCodecConfig[10] = iExtObjectType;
    aCodecConfig[12] = iFormatType; // this is only available after scan header
	}

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::GetBitrate
// -----------------------------------------------------------------------------
//
TInt CEAACPlusAudioControllerUtility::GetBitrate(CMMFDataBuffer* aBuffer)
    {
    const TUint8* ptr = aBuffer->Data().Ptr();
    TInt offset = 4;            // "ADIF"
    TInt bitrate = 0;
    
    offset += aBuffer->Position();
    
    if (ptr[offset] >> 7 == 1)  // copyright
        offset += 9;

    bitrate = ptr[offset] & 0x7;                    // 4 bits
    bitrate = (bitrate << 8) | ptr[offset+1];       // 8 bits
    bitrate = (bitrate << 8) | ptr[offset+2];       // 8 bits
    bitrate = (bitrate << 3) | ptr[offset+3] >> 5;  // 3 bits
    return bitrate;
    }

// -----------------------------------------------------------------------------
// CEAACPlusAudioControllerUtility::IsValidAacFrame
// -----------------------------------------------------------------------------
//
TBool CEAACPlusAudioControllerUtility::IsValidAacFrame(
	const TUint8* aPtr,	TInt aBufLen)
    {
	DP0(_L("CEAACPlusAudioControllerUtility::IsValidAacFrame"));

	if (aBufLen >= 4)
		{
		if ((aPtr[0] == 'A') && (aPtr[1] == 'D') && (aPtr[2] == 'I') && (aPtr[3] == 'F'))
			return ETrue;
		}

	if (aBufLen >= 6)
		{
		if (((aPtr[0] == 0xFF) && ((aPtr[1] >> 4) == 0xF) &&    // Check syncword FFF
    	     ((aPtr[1] >> 1) & 0x3) == 0))                      // Check layer == 0
	        {
    	    TInt frameLen = 0;
	        frameLen = (aPtr[3] & 0x3) << 11;
    	    frameLen |= aPtr[4] << 3;
        	frameLen |= ((aPtr[5] >> 5) & 0x7);

	        if (!frameLen || (frameLen > (aBufLen-4))) // check this for correctness
    	       return EFalse;

	        // Check next frame
	        if (aBufLen - frameLen >= 2)
	        	{
	    	    const TUint8* nextFramePtr = aPtr + frameLen;
		    	if ((((nextFramePtr[0] == 0xFF) && ((nextFramePtr[1] >> 4) == 0xF)) && // Check syncword FFF
	    	         ((nextFramePtr[1] >> 1) & 0x3) == 0)) // Check layer == 0
	    	        {
    	    	    return ETrue;
	    	        }
	        	}
        	}
		}

    return EFalse;
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// End of File