// Copyright (c) 2002-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 FILES:

 // 

 //

 // Standard includes

 #include <e32std.h>

 // Private Generic Library includes

 #include <ecom/implementationproxy.h>

 #include "GSM610.H"

 #include "gsm610fr.h"

 #include <mmf/plugin/mmfcodecimplementationuids.hrh>

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

 //*  GSM Codec to 16 bit PCM Class:

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

 // __________________________________________________________________________

 // Implementation

 CMMFCodec* CMMFGsmTo16PcmCodec::NewL(TAny* aInitParams)

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL(aInitParams);

 	CleanupStack::Pop(self);

 	return STATIC_CAST( CMMFCodec*, self );

 	}

 CMMFGsmTo16PcmCodec::~CMMFGsmTo16PcmCodec()

 	{

 	delete iCodecPtr;

 	}

 CMMFGsmTo16PcmCodec::CMMFGsmTo16PcmCodec()

 	{

 	}

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

 	{

 	iCodecPtr = new (ELeave) CGsmTo16PcmWavCodec();

 	iCodecPtr->ConstructL();

 	iLastFrameNumber = 0;

 	}

 //handy porting stuff from old MS

 //to convert from a CMMFBuffer to a TUint8*

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

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

 //to convert from a CMMFBuffer to a TMMFPtr8 (TMMFPtr8)

 //---	TMMFPtr8 codecSrc;

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

 //---	codecSrc.Set(iSrc->Data());

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

 	{

 	TMMFPtr8 codecSrc;

 	TMMFPtr8 codecDst;

 	TCodecProcessResult result;

 	result.iStatus = TCodecProcessResult::EProcessIncomplete;

 	//convert from generic CMMFBuffer to CMMFDataBuffer

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

 	iDst = STATIC_CAST(CMMFDataBuffer*, &aDst);

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

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

 	// This is checked only on the first frame.

 	if ((dstMaxLen < KPcmInputFrameSize) && (iSrc->FrameNumber() <= 1))

 		User::Leave(KErrArgument);

 	TUint dstAccumulator = 0;

 	TUint srcAccumulator = 0;

 	TUint dstAdded = KPcmInputFrameSize;

 	TUint srcAdded = 0;

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

 		{

 		iCodecPtr->ResetAllL();

 		}

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

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

 		{

 		iCodecPtr->ResetAllL();

 		}

 	iLastFrameNumber = iSrc->FrameNumber();

 	TInt srcShift = iSrc->Position();

 	TInt dstShift = iDst->Position(); // Add offset for Dst Buffer

 	while ((dstAccumulator < dstMaxLen) && (dstAdded))

 		{

 		//this code chops the data buffer into 65 (or less) byte chunks

 		codecSrc.Set(iSrc->Data());

 		codecDst.Set(iDst->Data());

 		codecDst.SetLength(iDst->Data().MaxLength());

 		//move the data to the end of the last bit of the buffer processed

 		codecSrc.Shift(srcAccumulator + srcShift);

 		//codecDst.Shift(dstAccumulator);

 		codecDst.Shift(dstAccumulator + dstShift); // Add offset for Dst Buffer

 		iCodecPtr->ProcessL(&codecSrc, &codecDst);

 		dstAdded = codecDst.Length();

 		srcAdded = codecSrc.Length();

 		//rules to trigger a codec reset

 		if (dstAdded == KPcmInputFrameSize)

 			iCodecPtr->Reset();

 		if (srcAdded == 0)

 			iCodecPtr->Reset();

 		dstAccumulator += codecDst.Length();

 		srcAccumulator += codecSrc.Length();

 		}

 	//iDst->Data().SetLength(dstAccumulator);

 	iDst->Data().SetLength(dstAccumulator + dstShift); // Add offset for Dst Buffer

 	result.iSrcBytesProcessed = srcAccumulator;

 	result.iDstBytesAdded = dstAccumulator;

 	if (!srcAdded)

 		{

 		srcAdded = srcAdded;

 		}

 	if (result.iSrcBytesProcessed + iSrc->Position() >= srcLen)

 		result.iStatus = TCodecProcessResult::EProcessComplete;

 	if (result.iDstBytesAdded < dstMaxLen)

 		result.iStatus = TCodecProcessResult::EDstNotFilled;

 	return result;

 	}

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

 //* 16 bit PCM to GSM Codec Class:

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

 // __________________________________________________________________________

 // Implementation

 CMMFCodec* CMMF16PcmToGsmCodec::NewL(TAny* aInitParams)

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL(aInitParams);

 	CleanupStack::Pop(self);

 	return STATIC_CAST( CMMFCodec*, self );

 	}

 CMMF16PcmToGsmCodec::~CMMF16PcmToGsmCodec()

 	{

 	delete iCodecPtr;

 	}

 CMMF16PcmToGsmCodec::CMMF16PcmToGsmCodec()

 	{

 	}

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

 	{

 	iCodecPtr = new (ELeave) C16PcmToGsmWavCodec();

 	iCodecPtr->ConstructL();

 	iLastFrameNumber = 0;

 	}

 //handy porting stuff from old MS

 //to convert from a CMMFBuffer to a TUint8*

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

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

 //to convert from a CMMFBuffer to a TMMFPtr8 (TMMFPtr8)

 //---	TMMFPtr8 codecSrc;

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

 //---	codecSrc.Set(iSrc->Data());

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

 	{

 	TMMFPtr8 codecSrc;

 	TMMFPtr8 codecDst;

 	TCodecProcessResult result;

 	result.iStatus = TCodecProcessResult::EProcessIncomplete;

 	//convert from generic CMMFBuffer to CMMFDataBuffer

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

 	iDst = STATIC_CAST(CMMFDataBuffer*, &aDst);

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

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

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

 	// This is checked only on the first frame.

 	if ((dstMaxLen < KGsmEncodedFrameSize) && (iSrc->FrameNumber() <= 1))

 		User::Leave(KErrArgument);

 	TUint dstAccumulator = 0;

 	TUint srcAccumulator = iSrc->Position();

 	TUint dstAdded = 0;

 	TUint srcAdded = 0;

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

 		{

 		iCodecPtr->ResetAllL();

 		}

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

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

 		{

 		iCodecPtr->ResetAllL();

 		}

 	iLastFrameNumber = iSrc->FrameNumber();

 //	TInt dstShift = iSrc->Position();

 	TInt dstShift = iDst->Position();

 	while (srcAccumulator < srcLen)

 		{

 		// Create a copy of iSrc and pass that to the Codec as the Codec, 

 		// for some reason, alters the source(iSrc).

 		// Easier (& quicker) to make copy than to fix the actual Codec as the code is 

 		// old and the GSM610 Codec is already quite slow.

 		HBufC* copySrc = HBufC::NewLC(srcLen);

 		TPtr8 copySrcPtr((TUint8*)copySrc->Ptr(), srcLen, srcLen);

 		copySrcPtr.Copy((TUint8*)iSrc->Data().Ptr(), srcLen); 

 		//this code chops the data buffer into 640 (or less) byte chunks

 		codecSrc.Set(copySrcPtr/*iSrc->Data()*/);

 		//codecSrc.Set(iSrc->Data());

 		codecDst.Set(iDst->Data());

 		codecDst.SetLength(iDst->Data().MaxLength());

 		//move the data to the end of the last bit of the buffer processed

 		codecSrc.Shift(srcAccumulator);

 		codecDst.Shift(dstAccumulator + dstShift);

 		iCodecPtr->ProcessL(&codecSrc, &codecDst);

 		dstAdded = codecDst.Length();

 		srcAdded = codecSrc.Length();

 		//rules to trigger a codec reset

 		if ((dstAdded == KGsmEncodedFrameSize) && (srcAdded == KPcmInputFrameSize))

 			iCodecPtr->Reset();

 		if (srcAdded == 0)

 			iCodecPtr->Reset();

 		dstAccumulator += codecDst.Length();

 		srcAccumulator += codecSrc.Length();

 		CleanupStack::PopAndDestroy(copySrc);

 		//need to check that we don't process too much of the destination such that it won't fit in the dst buf

 		if ((dstAccumulator + KGsmEncodedFrameSize) > dstMaxLen)

 			break;

 		}

 	iDst->Data().SetLength(dstAccumulator + iDst->Position());

 	result.iSrcBytesProcessed = srcAccumulator;

 	result.iDstBytesAdded = dstAccumulator;

 	if (!srcAdded)

 		{

 		srcAdded = srcAdded;

 		}

 	if (result.iSrcBytesProcessed + iSrc->Position() >= srcLen)

 		result.iStatus = TCodecProcessResult::EProcessComplete; 

 	if (result.iDstBytesAdded < dstMaxLen)

 		{ //need to check that there is space remaining in the destination buffer to process more

 		//need at least KGsmEncodeFrameSize bytes

 		if ((dstMaxLen - result.iDstBytesAdded) >= KGsmEncodedFrameSize)

 				result.iStatus = TCodecProcessResult::EDstNotFilled; //still space for more frames

 //		else result.iStatus = TCodecProcessResult::EProcessComplete; //can't do anything more with src or dest

 		}

 	return result;

 	}

 // __________________________________________________________________________

 // Exported proxy for instantiation method resolution

 // Define the interface UIDs

 const TImplementationProxy ImplementationTable[] = 

 	{

 		IMPLEMENTATION_PROXY_ENTRY(KMmfUidCodecGSM610ToPCM16,	CMMFGsmTo16PcmCodec::NewL),

 		IMPLEMENTATION_PROXY_ENTRY(KMmfUidCodecPCM16ToGSM610,	CMMF16PcmToGsmCodec::NewL)

 	};

 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)

 	{

 	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

 	return ImplementationTable;

 	}

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

 //* FUNCTION:  CGsmTo16PcmWavCodec::CGsmTo16PcmWavCodec

 //*   Constructor for GSM to 16 bit PCM Codec.

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

 CGsmTo16PcmWavCodec::CGsmTo16PcmWavCodec()

 	{

 	Reset();

 	}

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

 //* FUNCTION:  CGsmTo16PcmWavCodec::~CGsmTo16PcmWavCodec

 //*   Destructor for GSM to 16 bit PCM Codec.

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

 CGsmTo16PcmWavCodec::~CGsmTo16PcmWavCodec()

 	{

 	delete iGsmDecoder;

 	}

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

 //* FUNCTION:  CGsmTo16PcmWavCodec::ConstructL

 //*   Perform 2nd pass of object construction (allocating data on heap).

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

 void CGsmTo16PcmWavCodec::ConstructL()

 	{

 	iGsmDecoder = new (ELeave) CGSM610FR_Decoder;

 	iGsmDecoder->ConstructL();

 	iGsmDecoder->StartL();

 	iInBufferCount  = 0;

 	iOutBufferCount = 0;

 	}

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

 //* FUNCTION:  CGsmTo16PcmWavCodec::Reset

 //*   Reset the input/output buffer states.

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

 void CGsmTo16PcmWavCodec::Reset()

 	{

 	iInBufferPtr    = iInBuffer;

 	iOutBufferPtr   = iOutBuffer;

 	}

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

 //* FUNCTION:  CGsmTo16PcmWavCodec::Reset

 //*   Reset the input/output buffer states.

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

 void CGsmTo16PcmWavCodec::ResetAllL()

 	{

 	Reset();

 	iInBufferCount  = 0;

 	iOutBufferCount = 0;

 	iGsmDecoder->StartL();

 	}

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

 //* FUNCTION:  CGsmTo16PcmWavCodec::ProcessL

 //*   Read GSM data (contained in aSrc) and convert it to raw 16 bit

 //*   PCM data (contained in aDst).

 //*

 //*   NOTE that amount of data contained in input/output buffers

 //*   varies, so if there is not enough input data or not enough

 //*   room for the output data, then this function must buffer

 //*   the data until enough data is received (or removed).

 //*

 //*   NOTE that this function only buffers input (or output) data

 //*   if there is not enough data (or room for output) available

 //*   in the input (output) stream.  Otherwise, the data is accessed

 //*   directly from the input (output) stream which saves unnecessary

 //*   copying of data.

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

 void CGsmTo16PcmWavCodec::ProcessL(TMMFPtr8* aSrc, TMMFPtr8* aDst)

 	{

 	TUint8* srcPtr  = NULL;

 	TUint8* dstPtr  = NULL;

 	const TUint    srcLen  = aSrc->Length();

 	const TUint    dstLen  = aDst->Length();

 	TInt	srcUsed = 0;

 	TInt	dstUsed = 0;

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

 	//* Get Input Data:  Only want to process more input

 	//* data if the output buffer is empty.

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

 	if ( iOutBufferCount == 0 )

 		{

 		srcPtr = CONST_CAST(TUint8*, aSrc->Ptr());

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

 		//* If the input buffer is empty, and there is

 		//* enough data in the input stream, then use the

 		//* data from the input stream.  Else must append

 		//* available input data to the input buffer.

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

 		if ( (iInBufferCount == 0) && (srcLen >= KGsmEncodedFrameSize) )

 			{

 			srcUsed = KGsmEncodedFrameSize;

 			}

 		else

 			{

 			TInt canCache = KGsmEncodedFrameSize - iInBufferCount;

 			srcUsed = Min (canCache, srcLen);

 			for (TInt count = 0; count < srcUsed; count++)

 				{

 				//not worth use a mem copy

 				*iInBufferPtr++ = *srcPtr++;

 				}

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

 			//* If the input buffer is now full, then we can

 			//* process this data. Otherwise, we don't have

 			//* enough data so set srcPtr to NULL to indicate

 			//* that there's no data to process yet.

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

 			srcPtr = NULL;

 			iInBufferCount += srcUsed;

 			if ( iInBufferCount == KGsmEncodedFrameSize )

 				{

 				srcPtr         = iInBuffer;

 				iInBufferPtr   = iInBuffer;

 				iInBufferCount = 0;

 				}

 			}

 		}

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

 	//* If there is enough input data, then determine

 	//* where the output should go (output stream or

 	//* output buffer if output stream doesn't have

 	//* enough room).  Then decode the data.

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

 	if ( srcPtr != NULL )

 		{

 		// Determine where to put output data

 		dstPtr = CONST_CAST(TUint8*, aDst->Ptr());

 		dstUsed = KPcmInputFrameSize;

 		if ( dstLen < KPcmInputFrameSize )

 			{

 			dstPtr = iOutBuffer;

 			iOutBufferCount = KPcmInputFrameSize;

 			}

 		// Decode the data

 		iGsmDecoder->ExecuteL (srcPtr, dstPtr);

 		}

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

 	//* If any data is stored in the output buffer,

 	//* then output as much of it as well fit in the

 	//* output stream.

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

 	if ( iOutBufferCount > 0 )

 		{

 		dstUsed = Min ((TInt)iOutBufferCount, (TInt)dstLen);

 		TPtrC8 outPtr (iOutBufferPtr, dstUsed);

 		aDst->SetLength(0);

 		aDst->Append (outPtr);

 		iOutBufferCount -= dstUsed;

 		iOutBufferPtr   += dstUsed;

 		if ( iOutBufferCount == 0 )

 			{

 			iOutBufferPtr = iOutBuffer;

 			}

 		}

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

 	//* Modify the length attributes of the source and

 	//* destination data streams to inform the caller

 	//* of how much data was used in each buffer.

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

 	aSrc->SetLength(srcUsed); 

 	aDst->SetLength(dstUsed); 

 	}

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

 //* FUNCTION:  C16PcmToGsmWavCodec::C16PcmToGsmWavCodec

 //*   Constructor for 16 bit PCM to GSM Codec.

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

 C16PcmToGsmWavCodec::C16PcmToGsmWavCodec()

 	{

 	Reset();

 	}

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

 //* FUNCTION:  C16PcmToGsmWavCodec::~C16PcmToGsmWavCodec

 //*   Destructor for 16 bit PCM to GSM Codec.

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

 C16PcmToGsmWavCodec::~C16PcmToGsmWavCodec()

 	{

 	delete iGsmEncoder;

 	}

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

 //* FUNCTION:  C16PcmToGsmWavCodec::ConstructL

 //*   Perform 2nd pass of object construction (allocating data on heap).

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

 void C16PcmToGsmWavCodec::ConstructL()

 	{

 	iGsmEncoder = new (ELeave) CGSM610FR_Encoder;

 	iGsmEncoder->ConstructL();

 	iGsmEncoder->StartL();

 	iInBufferCount  = 0;

 	iOutBufferCount = 0;

 	}

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

 //* FUNCTION:  C16PcmToGsmWavCodec::Reset

 //*   Reset the input/output buffer states.

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

 void C16PcmToGsmWavCodec::Reset()

 	{

 	iInBufferPtr    = iInBuffer;

 	iOutBufferPtr   = iOutBuffer;

 	}

 void C16PcmToGsmWavCodec::ResetAllL()

 	{

 	Reset();

 	iInBufferCount  = 0;

 	iOutBufferCount = 0;

 	iGsmEncoder->StartL();

 	}

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

 //* FUNCTION:  C16PcmToGsmWavCodec::ProcessL

 //*   Read raw 16 bit PCM data (contained in aSrc) and convert to

 //*   GSM data and return to caller (in aDst).

 //*

 //*   NOTE that amount of data contained in input/output buffers

 //*   varies, so if there is not enough input data or not enough

 //*   room for the output data, then this function must buffer

 //*   the data until enough data is received (or removed).

 //*

 //*   NOTE that this function only buffers input (or output) data

 //*   if there is not enough data (or room for output) available

 //*   in the input (output) stream.  Otherwise, the data is accessed

 //*   directly from the input (output) stream which saves unnecessary

 //*   copying of data.

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

 void C16PcmToGsmWavCodec::ProcessL(TMMFPtr8* aSrc, TMMFPtr8* aDst)

 	{

 	TUint8* srcPtr  = NULL;

 	TUint8* dstPtr  = NULL;

 	const TUint    srcLen  = aSrc->Length();

 	const TUint    dstLen  = aDst->Length();

 	TInt	srcUsed = 0;

 	TInt	dstUsed = 0;

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

 	//* Get Input Data:  Only want to process more input

 	//* data if the output buffer is empty.

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

 	if ( iOutBufferCount == 0 )

 		{

 		srcPtr = CONST_CAST(TUint8*, aSrc->Ptr());

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

 		//* If the input buffer is empty, and there is

 		//* enough data in the input stream, then use the

 		//* data from the input stream.  Else must append

 		//* available input data to the input buffer.

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

 		if ( (iInBufferCount == 0) && (srcLen >= KPcmInputFrameSize) )

 			{

 			srcUsed = KPcmInputFrameSize;

 			}

 		else

 			{

 			TInt canCache = KPcmInputFrameSize - iInBufferCount;

 			srcUsed = Min (canCache, srcLen);

 			for (TInt count = 0; count < srcUsed; count++)

 				{

 				*iInBufferPtr++ = *srcPtr++;

 				}

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

 			//* If the input buffer is now full, then we can

 			//* process this data. Otherwise, we don't have

 			//* enough data so set srcPtr to NULL to indicate

 			//* that there's no data to process yet.

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

 			srcPtr = NULL;

 			iInBufferCount += srcUsed;

 			if ( iInBufferCount == KPcmInputFrameSize )

 				{

 				srcPtr         = iInBuffer;

 				iInBufferPtr   = iInBuffer;

 				iInBufferCount = 0;

 				}

 			}

 		}

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

 	//* If there is enough input data, then determine

 	//* where the output should go (output stream or

 	//* output buffer if output stream doesn't have

 	//* enough room).  Then encode the data.

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

 	if ( srcPtr != NULL )

 		{

 		// Determine where to put output data

 		dstPtr = CONST_CAST(TUint8*, aDst->Ptr());

 		dstUsed = KGsmEncodedFrameSize;

 		if ( dstLen < KGsmEncodedFrameSize )

 			{

 			dstPtr = iOutBuffer;

 			iOutBufferCount = KGsmEncodedFrameSize;

 			}

 		// Encode the data

 		iGsmEncoder->ExecuteL (srcPtr, dstPtr);

 		}

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

 	//* If any data is stored in the output buffer,

 	//* then output as much of it as well fit in the

 	//* output stream.

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

 	if ( iOutBufferCount > 0 )

 		{

 		dstUsed = Min ((TInt)iOutBufferCount, (TInt)dstLen);

 		TPtrC8 outPtr (iOutBufferPtr, dstUsed);

 		aDst->SetLength(0);

 		aDst->Append (outPtr);

 		iOutBufferCount -= dstUsed;

 		iOutBufferPtr   += dstUsed;

 		if ( iOutBufferCount == 0 )

 			{

 			iOutBufferPtr = iOutBuffer;

 			}

 		}

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

 	//* Modify the length attributes of the source and

 	//* destination data streams to inform the caller

 	//* of how much data was used in each buffer.

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

 	aSrc->SetLength(srcUsed); 

 	aDst->SetLength(dstUsed); 

 	}