/*
* 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 AMR utility functions.
*
*/


//  INCLUDES
#include "AMRAudioControllerUtility.h"
#include "DebugMacros.h"
#include <mmfdatabuffer.h>

// CONSTANTS
_LIT8(KAmrMagicNumber, "#!AMR\n");

// The size of AMR header, header must include bits for determining frame length
const TInt KAmrFrameHeaderSize = 1;

// Frame length table (number of frame bytes)
const TInt KAmrFrameLength[16] = {13,14,16,18,20,21,27,32,6,0,0,0,0,0,0,1};

// Stuffing length table (number of stuffing bits)
//const TInt KAmrStuffLength[16] = {4, 4, 5, 5, 7, 4, 7, 7, 4,0,0,0,0,0,0,3};

// Maximum number of PCM samples in one AMR frame
const TInt KAmrMaxSamplesPerFrame160 = 160;

// constant time for each frame = 0.020 sec
const TInt KAmrMilliSecondsPerFrame  = 20;

const TInt KAmrSampleRate8K = 8000;
const TInt KAmrBitRate = 12800;
const TInt KAmrChannels1 = 1;

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

// -----------------------------------------------------------------------------
// CAMRAudioControllerUtility::CAMRAudioControllerUtility
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CAMRAudioControllerUtility::CAMRAudioControllerUtility()
    {
	iSamplingRate = KAmrSampleRate8K;
	iBitRate = KAmrBitRate;
	iChannels = KAmrChannels1;
	iHeaderOffset = KAmrMagicNumber().Size(); // only because recorder controller needs this
    iFrameTimeMs = KAmrMilliSecondsPerFrame;
    iLenMetaData = 0;
    iDurationUs = 0;
    iTotalFrameBytes = 0;
    iTotalFrames = 0;
    iFrameDataOffset = 0;    
    }

// -----------------------------------------------------------------------------
// CAMRAudioControllerUtility::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CAMRAudioControllerUtility::ConstructL()
    {
	iPosArr = new(ELeave) CArrayFixSeg<TTimePos>(1024);
	}

// -----------------------------------------------------------------------------
// CAMRAudioControllerUtility::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CAMRAudioControllerUtility* CAMRAudioControllerUtility::NewL()
	{
	DP0(_L("CAMRAudioControllerUtility::NewL"));
    CAMRAudioControllerUtility* self = new(ELeave) CAMRAudioControllerUtility;
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// Destructor
EXPORT_C CAMRAudioControllerUtility::~CAMRAudioControllerUtility()
    {
	iPosArr->Reset();
	delete iPosArr;
    }

// -----------------------------------------------------------------------------
// CAMRAudioControllerUtility::SeekSync
// -----------------------------------------------------------------------------
//
TInt CAMRAudioControllerUtility::SeekSync(
	CMMFDataBuffer* aBuf,
	TInt aBufLen)
    {
    // aBufLen is still the total buffer size.
    // we'll use the buffer position as the starting point of the seek for a frame
    // the endPtr is the ending point of the seek
    
    const TUint8* buf = aBuf->Data().Ptr() + aBuf->Position();
    const TInt KMaxFrames = 3;          // number of frames to check
    const TInt KNotFound = aBufLen;     // sync not found position
    TAudioFrameInfo frameInfo;			// frame parameters
    TInt i = 0;
    TInt syncPos = KNotFound;
    TInt maxSeek = KMaxFrames;
    const TUint8* endPtr = buf + aBufLen - aBuf->Position();
    
    //Check if start position is same as end position
    //If so, the reset the start position to the beginning of the buffer
    //Bug-Id:ESLM-7ZFAHF
    if (buf == endPtr)
        {
        buf = aBuf->Data().Ptr();
        }

    // Seek a valid frame candidate byte by byte until a valid frame
    // is found or all bytes have been checked.
    while (buf < endPtr  &&  syncPos == KNotFound)
    	{
        TInt seekCount = 0;
        const TUint8* framePtr = buf;
        TInt frameBufLen = aBufLen;
        syncPos = i;
        // Check the validity of this frame candidate and the nearest next
        // frames. If they are not OK, syncPos will be set to KNotFound.
        while (framePtr < endPtr  &&  syncPos != KNotFound  &&  seekCount < maxSeek)
        	{
            TInt length = FrameInfo(framePtr, frameBufLen, frameInfo);
            if (frameBufLen >= KAmrFrameHeaderSize  &&  length == 0)
            	{
				syncPos = KNotFound;
				}
            framePtr += length;
            frameBufLen -= length;
            seekCount++;
        	}
        buf++; aBufLen--; i++;
    	}
    return syncPos;
    }

// -----------------------------------------------------------------------------
// CAMRAudioControllerUtility::FrameInfo
// -----------------------------------------------------------------------------
//
TInt CAMRAudioControllerUtility::FrameInfo(
	const TUint8* aBuf,
	TInt aBufLen,
	TAudioFrameInfo& aInfo)
    {
    TInt length = 0;
    aInfo.iBitRate = 0;
    if (aBufLen >= KAmrFrameHeaderSize)
    	{
        // extract mode information
        const TInt mode = (aBuf[0] & 0x78) >> 3; // 1st byte 0b.MODE...
        // get length
        length = KAmrFrameLength[mode];

        // check start stuffing bits
        if ((aBuf[0] & 0x83) != 0)
	        {
            length = 0; // syntax error
	        }

// SKIP CHECKING FOR STUFFING BITS
/*
        // check end stuffing bits
        if (length > 0  &&  aBufLen >= length)
        	{
            TUint32 stuffBits = aBuf[length-1];
            stuffBits <<= (11 - KAmrStuffLength[mode]);
            if ((stuffBits & 0x0000FF) != 0)
            	{
                length = 0; // syntax error
            	}
        	}
*/
        // update frame parameters
        aInfo.iMode = mode;
        aInfo.iBitRate = length * 400;
        aInfo.iSamplingRate = KAmrSampleRate8K;
        aInfo.iChannels = KAmrChannels1;
        aInfo.iFrameSize = length;
        aInfo.iFrameSamples = KAmrMaxSamplesPerFrame160;
        aInfo.iSamplingRateOut = aInfo.iSamplingRate;
        aInfo.iChannelsOut = aInfo.iChannels;
        aInfo.iFrameSamplesOut= aInfo.iFrameSamples;
    	}
    return length;
    }

// -----------------------------------------------------------------------------
// CAMRAudioControllerUtility::FrameHeaderSize
// -----------------------------------------------------------------------------
//
TInt CAMRAudioControllerUtility::FrameHeaderSize()
    {
    return KAmrFrameHeaderSize;
    }


// -----------------------------------------------------------------------------
// CAMRAudioControllerUtility::ScanHeaderL
// Used to scan the header information
// -----------------------------------------------------------------------------
//
void CAMRAudioControllerUtility::ScanHeaderL(
	CMMFDataBuffer* aDataBuf)
	{
	DP0(_L("CAMRAudioControllerUtility::ScanHeaderL"));
	iBitRateFrozen = EFalse; // AMR does not have bitrate in container header, so it will be averaged while playing
    const TUint8* bufferPtr = aDataBuf->Data().Ptr();
    TInt bufferSize = aDataBuf->Data().Size();
	
	TInt scannedBuffer = 0;
	TAudioFrameInfo frameInfo;
	TInt frameLen;
	
	if (!iHdrIsRead)
        {
        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);
                }
            }
    
        aDataBuf->SetPosition(scannedBuffer);
        // should change seeksync to start seek from position and not start of buffer (done)
        // this is a little akward because of the implementation of seeksync and its use by the recoder controller.
        TInt seekOffset = SeekSync(aDataBuf, bufferSize); // seeksync now scans from start of buffer + Position()
        TInt realOffset = seekOffset - scannedBuffer; // we just want offset from where we were
    
        iHeaderOffset = 0;
        if (realOffset >= 6)
            {
            bufferPtr = aDataBuf->Data().Ptr() + seekOffset - 6;
            TUint32* w1p = (TUint32*)bufferPtr;
            TUint16* w2p = (TUint16*)(bufferPtr+4);
            if (((*w1p & 0x4D412123)==0x4D412123) && 
                ((*w2p & 0x0A52)==0x0A52))
                {
                iHeaderOffset = 6;
                realOffset -= 6;
                }
            else if (seekOffset == bufferSize)
                {
                User::Leave(KErrNotReady);
                }	
            }
    
        iSyncOffset += realOffset; // offset to this point from content beginning
        scannedBuffer += realOffset + iHeaderOffset; // offset to this point in this buffer
        bufferPtr = aDataBuf->Data().Ptr();
        aDataBuf->SetPosition(scannedBuffer);
        
        DP0(_L("CAMRAudioControllerUtility::ScanHeaderL - Calling FrameInfo"));
    
        //TAudioFrameInfo frameInfo;
        /*TInt*/ frameLen = FrameInfo(bufferPtr+scannedBuffer, bufferSize-scannedBuffer, frameInfo);
    
        if (frameLen == 0)
            {
            User::Leave(KErrNotReady);
            }
            
    //	scannedBuffer += frameLen;
        iBitRate = 0;
        iDurationUs = 0;
        
        iSamplingRate = frameInfo.iSamplingRate;
        iBitRate = frameInfo.iBitRate;
        iSamplesPerFrame = frameInfo.iFrameSamples;
        iChannels = frameInfo.iChannels;
        iChannelsOut = frameInfo.iChannelsOut;
    //	iSamplingRateOut = frameInfo.iSamplingRateOut;
    
        if (iSamplingRate > 0)
            {
            iFrameTimeMs = (iSamplesPerFrame*1000)/iSamplingRate;
            }
        DP0(_L("CAMRAudioControllerUtility::ScanHeaderL - setting iHdrIsRead"));
        iHdrIsRead = ETrue;
        }
	TInt frameBytes = 0;
	TInt frames = 0;

        scannedBuffer += iFrameDataOffset;
	while (scannedBuffer < bufferSize) // buffersize is not a function of buffer.Position()
		{
		frameLen = FrameInfo(bufferPtr+scannedBuffer, bufferSize-scannedBuffer, frameInfo);
		if (frameLen > 0)
			{
		scannedBuffer += frameLen;
	        frameBytes += frameLen;
	        frames++;                   
			}
		else
			{
		    scannedBuffer++; // since frameLen had to be 0 to come here, go ahead to the next byte
	        aDataBuf->SetPosition(scannedBuffer);
		    TInt i = SeekSync(aDataBuf, bufferSize); // still using bufferSize as total size of buffer
		    scannedBuffer += i;
			}
		}
	
	iFrameDataOffset = scannedBuffer - bufferSize;
	DP3(_L("scannedBuffer[%d] frameBytes[%d] iFrameDataOffset[%d]"), scannedBuffer, frameBytes, iFrameDataOffset);
	
	iTotalFrameBytes = iTotalFrameBytes + frameBytes;
	iTotalFrames = iTotalFrames + frames;
	
	// We only leave if its not the last buffer.
	// we will not leave with the last buffer since
	// the AMR Controller has to populate other configuration
	// variables.
	
	if(!aDataBuf->LastBuffer())
		{ // keep reading data for calculation
		User::Leave(KErrCompletion);  // since we have read the header already
		}
    DP0(_L("CAMRAudioControllerUtility::ScanHeaderL - calculating bitrate"));

    iFrameDataOffset = 0; // reset for next time
    TInt64 num = (TInt64)iTotalFrameBytes * TInt64(8 * 1000);
    TInt64 num1 = iFrameTimeMs * iTotalFrames;
    TInt64 ans = 0;
    if (num1 != 0)
		{
        ans = num/num1;
        ans = num > ((ans + 0.5)*num1) ? (ans + 1):ans;
		}
    iBitRate = TInt(ans);
    iBitRateFrozen = ETrue; // bitrate has been calculated using the whole file, we can use this one now
    DP3(_L("CAMRAudioControllerUtility::ScanHeaderL - iTotalFrameBytes[%d] iTotalFrames[%d] iBitRate[%d]"),
            iTotalFrameBytes, iTotalFrames, iBitRate);
	}

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

// End of File