// 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;

 	}