// Copyright (c) 2003-2009 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:
//

#include "mmfwavformat.h"

#include "WavDecodeUtility.h" 


CWavDecodeUtility::CWavDecodeUtility()
	{
	}

void CWavDecodeUtility::ConstructL(TDesC8& aBuffer)
	{
	iBuffer = &aBuffer;
	FindRiffChunksL();
	ProcessFormatHeaderL();
	}

CWavDecodeUtility* CWavDecodeUtility::NewL(TDesC8& aBuffer)
	{
	CWavDecodeUtility* self = new (ELeave) CWavDecodeUtility();
	CleanupStack::PushL(self);
	self->ConstructL(aBuffer);
	CleanupStack::Pop();
	return self;
	}


CWavDecodeUtility::~CWavDecodeUtility()
	{
	}

TUint16 CWavDecodeUtility::Read16(const TUint8* aPtr)

    {
	TUint16 ret = *(REINTERPRET_CAST(const TUint16*, aPtr));
	return ret;
    }

TUint32 CWavDecodeUtility::Read32(const TUint8* aPtr)
    {
    TUint32 x = *aPtr++;
    x |= *aPtr++ << 8;
    x |= *aPtr++ << 16;
    x |= *aPtr++ << 24;
    return x;
    }
void CWavDecodeUtility::AssignChunkTo(TMdaRiffChunk* aAssignedChunk)
	{
	Mem::Copy(REINTERPRET_CAST(TUint8*, aAssignedChunk), REINTERPRET_CAST(TUint8*, &iCurrent),sizeof(TMdaRiffChunk));
	aAssignedChunk->iFound=ETrue;
	}

void CWavDecodeUtility::ReadChunk(TMdaRiffChunk* aChunk)
	{
	Mem::FillZ(REINTERPRET_CAST(TUint8*, aChunk),sizeof(TMdaRiffChunk)); // Zero data
	aChunk->iPosition=iPos + KRiffChunkHeaderLength;
	aChunk->iName = Read32(iStartPtr + iPos - iLastReadPosition);
	aChunk->iLength = Read32(iStartPtr + iPos - iLastReadPosition + KRiffChunkDataLength);
	}
void CWavDecodeUtility::FindRiffChunksL()
	{
	if (!iFoundChunks)
		{
		iFoundChunks=ETrue;
//		iStartPtr=iBuffer->Data().Ptr();
		iStartPtr=iBuffer->Ptr();
		iPos=0;
		iLastReadPosition=0;//Set by CBase, but what the heck
		iDone=EFalse;
		}
	else
		{//We've done another read. If there's < chunk in the buffer then something's wrong
		if (iBuffer->Length() < STATIC_CAST(TInt, KRiffChunkHeaderLength))
			{
			if ((iFormatChunk.iFound) && (iDataChunk.iFound)) 
				{
				iDone = ETrue; //it should be ok to exit loop
				return;
				}
			else
				{
				User::Leave(KErrCorrupt);
				}
			}
		}
	
	while (!iDone)
		{
		TInt advance=0;
		
		ReadChunk(&iCurrent);
		
		if (iCurrent.iName == KRiffChunkNameRiff)//we need to look INSIDE the RIFF chunk
			{
			if(iBuffer->Length() < STATIC_CAST(TInt, KRiffContainerChunkHeaderLength))
				User::Leave(KErrCorrupt);
			iRiffChunkLength=iCurrent.iLength + KRiffChunkHeaderLength;
			advance=KRiffContainerChunkHeaderLength;
			}
		else
			{
			advance=iCurrent.iLength + KRiffChunkHeaderLength;		//... and skip all others
			}
		
		if (iCurrent.iName == KRiffChunkNameFmt_)
			AssignChunkTo(&iFormatChunk);
		
		else if (iCurrent.iName == KRiffChunkNameFact)
			AssignChunkTo(&iFactChunk);
		
		else if (iCurrent.iName == KRiffChunkNameData)
			AssignChunkTo(&iDataChunk);
		
		if (iDataChunk.iFound && iFormatChunk.iFound && iFactChunk.iFound)
			{
			iDone=ETrue;
			}
		else
			{//still have chunks to look for
			iPos+=advance;
			if (iPos & 1)
				iPos++;
			
			if ((TUint)iPos>=(TUint)iRiffChunkLength)
				{
				iDone=ETrue;//end of file
				iClipLength = iRiffChunkLength;
				}
			else
				{//make sure we have at least a chunk's worth left in the buffer
				if ((TUint)(iPos-iLastReadPosition) > 
					(TUint)(iBuffer->Length() -KRiffChunkHeaderLength))
					{
					iLastReadPosition=iPos;
					//DoReadL(iLastReadPosition);
					return;
					}	
				}
			}
		}
	
	iClipLength = iRiffChunkLength;
	if (iClipLength == 0) User::Leave(KErrNotFound);
	else if (!(iDataChunk.iFound && iFormatChunk.iFound))
		User::Leave(KErrCorrupt);

	}

void CWavDecodeUtility::ProcessFormatHeaderL()
	{
	TMdaRiffChunk* chunk = &iFormatChunk;
	
	if (!chunk)
		User::Leave(KErrCorrupt);
	
	iLastReadPosition = chunk->iPosition; // Should be beginning of fmt block
	//DoReadL(iLastReadPosition);
	
	// Set the real format
	const TUint8* rawform = iBuffer->Ptr() + iLastReadPosition;	//skip _fmt & length
	iCodecId = Read16(rawform); rawform+=2;
	iChannels = Read16(rawform); rawform+=2;
	if ((iChannels != 1)&&(iChannels != 2))		//only 1 or 2 channels allowed
		User::Leave(KErrCorrupt); 
	
	iSampleRate = Read32(rawform); rawform+=4; // Skip bytes per second estimate
	if (!iSampleRate) 	User::Leave(KErrCorrupt);
	
	iAverageBytesPerSecond = Read32(rawform); rawform+=4;
	iBlockAlign = Read16(rawform); rawform+=2;
	
	iBitsPerSample = Read16(rawform);
	rawform+=2;
	
	switch (iCodecId)
		{
		case KMMFWavFormatTypePcm:
			{
			}
			break;
		case KMMFWavFormatTypeImaAdpcm:
			{
			}
			break;
		case KMMFWavFormatTypeAlaw:
			{
			}
			break;
		case KMMFWavFormatTypeMulaw:
			{
			}
			break;
		case KMMFWavFormatTypeGSM610:
			{
			}
			break;
		default:
			User::Leave(KErrNotSupported);
		}
	
	if (iCodecId == KMMFWavFormatTypeImaAdpcm)
		{
		TUint16 extraData = Read16(rawform);
		if (extraData == 2)
			{
			rawform+=2;
			iSamplesPerBlock = Read16(rawform);
			rawform+=2;
			}
		}
	
	// Is there a fact chunk?
	if (iFactChunk.iFound)			
		iHasFactChunk = ETrue;
	
	// Find the data block
	chunk=&iDataChunk;
	iStartPosition = chunk->iPosition; 
	iDataLength = chunk->iLength;
	}