/*

 * Copyright (c) 1997-2002 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 "MMFPcm16ToImaAdPcmCodec.h"

 // __________________________________________________________________________

 // Implementation

 CMMFCodec* CMMFPcm16ImaAdPcmCodec::NewL(TAny* aInitParams)

 	{

 	CMMFPcm16ImaAdPcmCodec* self=new(ELeave) CMMFPcm16ImaAdPcmCodec();

 	CleanupStack::PushL(self);

 	self->ConstructL(aInitParams);

 	CleanupStack::Pop(self);

 	return STATIC_CAST( CMMFCodec*, self );

 	}

 CMMFPcm16ImaAdPcmCodec::~CMMFPcm16ImaAdPcmCodec()

 	{

 	}

 CMMFPcm16ImaAdPcmCodec::CMMFPcm16ImaAdPcmCodec() : i16PcmToImaAdpcm(1)

 	{

 	}

 void CMMFPcm16ImaAdPcmCodec::ConstructL(TAny*  /*aInitParams*/)

 	{

 	iTempSrcBufferPtr = iTempSrcBuffer;

 	iTempSrcBufferCount = 0;

 	}

 void CMMFPcm16ImaAdPcmCodec::ResetL()

 	{

 	//Reset the actual codec

 	TMMFImaAdpcmCodecStateOld state;

 	state.iIndex = 0;

 	state.iPredicted = 0;

 	i16PcmToImaAdpcm.SetState(state);

 	iTempSrcBufferPtr = iTempSrcBuffer;

 	iTempSrcBufferCount = 0;

 	}

 /*************************************************************

 CMMFPcm16ImaAdPcmCodec::ProcessL

 This function converts PCM samples to IMA ADPCM samples in

 blocks of KImaAdpcmBlockAlign (256) bytes. 1010 source 

 bytes are required to fill a 256 byte block.

 **************************************************************/

 TCodecProcessResult CMMFPcm16ImaAdPcmCodec::ProcessL(const CMMFBuffer& aSrc, CMMFBuffer& aDst)

 	{

 	TCodecProcessResult result;

 	result.iStatus = TCodecProcessResult::EProcessIncomplete;

 	//convert from generic CMMFBuffer to CMMFDataBuffer

 	iSrc = STATIC_CAST(const CMMFDataBuffer*, &aSrc);

 	iDst = STATIC_CAST(CMMFDataBuffer*, &aDst);

 	// If the Destination is set to zero, ensure the Codec is fully reset,

 	// as this may be a reposition

 	if ((iSrc->FrameNumber() == 0) && (iDst->Position() == 0))

 		{

 		ResetL();

 		}

 	const TUint srcLen = iSrc->Data().Length();

 	const TUint dstMaxLen = iDst->Data().MaxLength();

 	const TUint sourceRemain = srcLen - iSrc->Position();

 	if (dstMaxLen < KImaAdpcmBlockAlign)

 		User::Leave(KErrArgument);

 	//reset data if not a consecutive frame number

 	if ((iSrc->FrameNumber() != iLastFrameNumber) && (iSrc->FrameNumber() != (iLastFrameNumber+1)))

 		{

 		iTempSrcBufferPtr = iTempSrcBuffer;

 		iTempSrcBufferCount = 0;

 		}

 	iLastFrameNumber = iSrc->FrameNumber();

 	TUint dstRemain = (dstMaxLen - iDst->Position());	

 	TUint srcToFillTempBuffer = 0;

 	//take account of src to be added to temporary buffer

 	if (iTempSrcBufferCount > 0)

 		{

 		srcToFillTempBuffer = KImaAdpcmTempBufferSize - iTempSrcBufferCount;

 		if (srcToFillTempBuffer<sourceRemain) //enough source to fill temporary buffer

 			dstRemain -= KImaAdpcmBlockAlign;

 		else //not enough source to fill the temporary buffer

 			srcToFillTempBuffer = sourceRemain;

 		}

 	//calculate how much source is required to fill the destination buffer

 	TUint blocksRemaining = dstRemain/KImaAdpcmBlockAlign;

 	TUint maxUsableDst = blocksRemaining * KImaAdpcmBlockAlign;

 	TUint srcToUse = blocksRemaining * KImaAdpcmSamplesPerBlock * 2;

 	srcToUse += srcToFillTempBuffer;

 	srcToUse = (srcToUse<sourceRemain ? srcToUse : sourceRemain);

 	//we need to cast away CONST even on the source, as the TClass needs a TUint8*

 	TUint8* pSrc = CONST_CAST(TUint8*,iSrc->Data().Ptr());

 	pSrc += iSrc->Position();

 	TUint8* pDst = CONST_CAST(TUint8*,iDst->Data().Ptr());

 	pDst += iDst->Position();

 	TUint dstBytesAdded = 0;

 	TUint srcLeft = srcToUse;

 	//convert remaining source from previous call to ProcessL

 	if (iTempSrcBufferCount > 0)

 		{

 		//Fill temp buffer from source buffer

 		while((iTempSrcBufferCount < KImaAdpcmTempBufferSize) && (srcLeft))

 			{

 			*iTempSrcBufferPtr++ = *pSrc++;

 			iTempSrcBufferCount++;

 			srcLeft--;

 			}

 		if (iTempSrcBufferCount == KImaAdpcmTempBufferSize)

 			{

 			//reset

 			iTempSrcBufferCount = 0;

 			iTempSrcBufferPtr = iTempSrcBuffer;

 			i16PcmToImaAdpcm.Convert(iTempSrcBufferPtr, pDst, KImaAdpcmSamplesPerBlock);

 			pDst += KImaAdpcmBlockAlign;

 			dstBytesAdded += KImaAdpcmBlockAlign;

 			}

 		}

 	//convert full blocks

 	while (srcLeft >= (KImaAdpcmSamplesPerBlock*2)) 

 		{

 		i16PcmToImaAdpcm.Convert(pSrc, pDst, KImaAdpcmSamplesPerBlock);

 		pSrc += KImaAdpcmSamplesPerBlock*2;

 		pDst += KImaAdpcmBlockAlign;

 		dstBytesAdded += KImaAdpcmBlockAlign;	

 		srcLeft -= KImaAdpcmSamplesPerBlock*2;	

 		}

 	//save remaining source in iTempSrcBuffer

 	while (srcLeft)

 		{

 		*iTempSrcBufferPtr++ = *pSrc++;

 		iTempSrcBufferCount++;

 		srcLeft--;

 		}

 	//if the source buffer is consumed

 	if ((srcLen == srcToUse + iSrc->Position()))

 		{

 		if (dstBytesAdded < maxUsableDst)

 			result.iStatus = TCodecProcessResult::EDstNotFilled;

 		else

 			result.iStatus = TCodecProcessResult::EProcessComplete;

 		}

 	result.iSrcBytesProcessed = srcToUse;

 	result.iDstBytesAdded = dstBytesAdded;

 	iDst->Data().SetLength(iDst->Position() + result.iDstBytesAdded);

 	return result;	

 	}