// 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 "mmfpcm16ToImaAdpcm.h"

/**

*

* NewL

*

*/

CMMFPcm16ToImaAdpcmHwDevice* CMMFPcm16ToImaAdpcmHwDevice::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

*

* ~CMMFPcm16ToAlawHwDevice

*

*/

CMMFPcm16ToImaAdpcmHwDevice::~CMMFPcm16ToImaAdpcmHwDevice()

	{

	}

/**

*

* ConstructL

*

*/

void CMMFPcm16ToImaAdpcmHwDevice::ConstructL()

	{

	iCodec = new (ELeave) CMMFPcm16ToImaAdpcmCodec();

	}

/**

*

* Codec

*

*/

CMMFSwCodec &CMMFPcm16ToImaAdpcmHwDevice::Codec()

	{

	return *iCodec;

	}

/**

*

* ResetL

*

*/

void CMMFPcm16ToImaAdpcmCodec::ResetL()

	{

	//Reset the actual codec

	TMMFImaAdpcmCodecState state;

	state.iIndex = 0;

	state.iPredicted = 0;

	iPcm16ToImaAdpcm.SetState(state);

	}

/**

*

* ProcessL

* @param aSrc src buffer

* @param aDst destination buffer

* @return CMMFSwCodec::TCodecProcessResult

*  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.

* @pre if last buffer and src contains < 1010 bytes discard input

* This function throws away the last buffer if it contains < 1010 bytes

* (ie we must have sufficient data to process an entire frame )

* All other src buffers must contain

* All destination buffer must contain

*

**/

CMMFSwCodec::TCodecProcessResult CMMFPcm16ToImaAdpcmCodec::ProcessL(const CMMFBuffer& aSrc, CMMFBuffer& aDst)

	{

	CMMFSwCodec::TCodecProcessResult result;

	result.iCodecProcessStatus = TCodecProcessResult::EProcessComplete;

	//convert from generic CMMFBuffer to CMMFDataBuffer

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

	CMMFDataBuffer* destination  = STATIC_CAST(CMMFDataBuffer*, &aDst);

	//[ source and destination must not be null ]

	if( !source || !destination )

		User::Leave( KErrArgument );

	//[ check preconditions ]

	if( !BuffersStatus( source, destination ))

		{

		User::Leave( KErrArgument );

		}

	//[ code the buffers ]

	ProcessBuffers( *source, *destination, result );

	return result;	

	}

/**

*

* ProcessBuffers

* @param aSource

* @param aDestination

* @param aResult 

* all we have to do is find out how many source frames there 

* are to process and process them

* finally returning process complete and fillin the status of the result

*

**/

void CMMFPcm16ToImaAdpcmCodec::ProcessBuffers(const CMMFDataBuffer& aSource, CMMFDataBuffer& aDestination, CMMFSwCodec::TCodecProcessResult& aResult )

	{

	//[ calculate how many full buffers are to be processed ]

    const TUint srcLen    = aSource.Data().Length();

    TInt numFullSrcFrames = srcLen/KSourceFrameSize;

	TUint8* pSrc = const_cast<TUint8*>(aSource.Data().Ptr());

	TUint8* pDst = const_cast<TUint8*>(aDestination.Data().Ptr());

    TInt dstBytesAdded = 0;

	// calculate number of pcm samples per source frame

	const TInt KSamplesPerFrame = KSourceFrameSize/(sizeof(TInt16)); 

	//[ convert all the buffers ]

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

		{

		i16PcmToImaAdpcm.Convert(pSrc, pDst, KSamplesPerFrame );				

		pSrc          += KSourceFrameSize;

		pDst          += KCodedFrameSize;

		dstBytesAdded += KCodedFrameSize;

		}

	aResult.iSrcBytesProcessed = numFullSrcFrames*KSourceFrameSize;

	aResult.iDstBytesAdded = dstBytesAdded;		

	aDestination.Data().SetLength( aResult.iDstBytesAdded);

	}

/**

*

* BuffersStatus

* @param source buffer containing the data to be coded

* @param destination buffer containing the coded data

* @return TBool EFalse indicates bad buffers

*

**/

TBool CMMFPcm16ToImaAdpcmCodec::BuffersStatus( const CMMFDataBuffer* source, const CMMFDataBuffer* destination )

	{

	TBool status = EFalse;

	//[ demand source and destination positions are zero ]

    CMMFDataBuffer* pDst = const_cast<CMMFDataBuffer*>( destination );

	if( source->Position() || destination->Position() )

		{

		return status;

		}

	//[ Have we got full buffers ]

	TInt sourceBuffers = source->Data().Length()/KSourceFrameSize;

	TInt destBuffers   = (pDst->Data().MaxLength())/KCodedFrameSize;

	if( sourceBuffers <= destBuffers )  // the sink can process the source

		{

		return ETrue;                       // note this precondition has been weakened in line with other codecs

		}                                   // such that it can process partially full buffers

	                                        // ie you can if you wish use larger buffers than needed and only partially

	                                        // fill them. We do however expect all the input to be processed.

	return status;

	}