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

 /**

  *

  *	Returns the created hw device for passing audio through audio.

  *  for the wins implementation this would always be pcm16 although

  *  this is effectively a null hw device that will pass any datatype through

  *	@return	"CMMFPcm16ToPcm16HwDevice"

  *

  */

 CMMFPcm16ToPcm16HwDevice* CMMFPcm16ToPcm16HwDevice::NewL()

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 /**

  *

  *	Second phase constructor.

  *

  */

 void CMMFPcm16ToPcm16HwDevice::ConstructL()

 	{

     iCodec = new (ELeave) CMMFPcm16ToPcm16Codec();

 	static_cast<CMMFPcm16ToPcm16Codec*>(iCodec)->SetHwDevice(this);

 	}

 /**

 *

 * ~CMMFPcm16ToPcm16HwDevice

 *

 **/

 CMMFPcm16ToPcm16HwDevice::~CMMFPcm16ToPcm16HwDevice()

 	{

 	}

 /**

 *

 * Codec

 * @return CMMFSwCodec&

 **/

 CMMFSwCodec& CMMFPcm16ToPcm16HwDevice::Codec()

 	{

 	return *iCodec;

 	}

 /**

 *

 * ProcessL

 * @param aSrc Source Buffer

 * @param sDest Destintion Buffer

 * @return CMMFSwCodec::TCodecProcessResult

 *

 **/

 CMMFSwCodec::TCodecProcessResult CMMFPcm16ToPcm16Codec::ProcessL(const CMMFBuffer& /*aSource*/, CMMFBuffer& /*aDest*/)

 	{//no processing required for null codec

 	User::Leave(KErrNotSupported); 

 	//to keep compiler happy

 	TCodecProcessResult result;

 	result.iCodecProcessStatus = TCodecProcessResult::EEndOfData;

 	result.iSrcBytesProcessed = 0;

 	result.iDstBytesAdded = 0;

 	return result;

 	};

 TUint CMMFPcm16ToPcm16Codec::SourceBufferSize()

 	{

 	if (!iBufferSize) 

 		iBufferSize = iHwDevice->CalculateBufferSize();

 	return iBufferSize;

 	}

 TUint CMMFPcm16ToPcm16Codec::SinkBufferSize()

 	{

 	if (!iBufferSize) 

 		iBufferSize = iHwDevice->CalculateBufferSize();

 	return iBufferSize;

 	}

 void CMMFPcm16ToPcm16Codec::SetHwDevice(CMMFPcm16ToPcm16HwDevice* aHwDevice)

 	{

 	iHwDevice = aHwDevice;

 	}

 TUint CMMFPcm16ToPcm16HwDevice::CalculateBufferSize()

 	{

 	TUint sampleRate = 0;

 	TUint channels = 0;

 	TInt useBufferOfSize = 0;

 	TInt minBufferSize = 0;

 	TInt maxBufferSize = 0;

 	if (iPlayCustomInterface)

 		{

 		sampleRate = iSampleRate;

 		channels = iChannels;	

 		if ((sampleRate) && (channels))

 			{

 			RMdaDevSound::TSoundFormatsSupportedBuf playFormatsSupported;

 			if (iDataPath->Device().Handle())

 				{

 				iDataPath->Device().PlayFormatsSupported(playFormatsSupported);

 				minBufferSize = playFormatsSupported().iMinBufferSize;

 				maxBufferSize = playFormatsSupported().iMaxBufferSize;

 				}

 			else

 				{//try to get handle

 				TInt err = iDataPath->Device().Open();

 				if (err == KErrNone)

 					{

 					iDataPath->Device().PlayFormatsSupported(playFormatsSupported);

 					minBufferSize = playFormatsSupported().iMinBufferSize;

 					maxBufferSize = playFormatsSupported().iMaxBufferSize;

 					iDataPath->Device().Close();

 					}

 				}

 			}

 		}

 	if ((iRecordCustomInterface) && (!sampleRate) && (!channels))

 		{ //must be record

 		sampleRate = iSampleRate;

 		channels = iChannels;

 		if ((sampleRate) && (channels))

 			{//get max and min supported buffer sizes supported by hw

 			MSwSetParamInterface* interface = 

 				static_cast<MSwSetParamInterface*>(iDataPath->CustomInterface(KUidSwSetParamInterface));

 			if (interface)

 				{

 				interface->GetBufferSizes(minBufferSize, maxBufferSize);

 				}

 			}

 		}

 //	else convert so not applicable

 	if ((sampleRate) && (channels))

 		{

 		// Buffer size = (SampleRate * BytesPerSample * Channels) / 4

 		useBufferOfSize = ((sampleRate * 2 * channels)/KDevSoundFramesPerSecond + (KDevSoundDeltaFrameSize-1)) &~ (KDevSoundDeltaFrameSize-1);

 		//clamp buffer to desired limits

 		if(useBufferOfSize < KDevSoundMinFrameSize) 

 			useBufferOfSize = KDevSoundMinFrameSize;

 		else if(useBufferOfSize > KDevSoundMaxFrameSize) 

 			useBufferOfSize = KDevSoundMaxFrameSize;

 		//clamp buffer to limits of hardware

 		if (maxBufferSize)

 			{//buffer size limits have been set by sound driver

 			 //check we are within the limits

 			if(useBufferOfSize < minBufferSize)

 				useBufferOfSize = minBufferSize;

 			else if(useBufferOfSize > maxBufferSize)

 				useBufferOfSize = maxBufferSize;

 			}

 		}

 	else

 		{

 		useBufferOfSize = KPCM16ToPCM16BufferSize;

 		}

 	return useBufferOfSize;

 	}

 TAny* CMMFPcm16ToPcm16HwDevice::CustomInterface(TUid aInterfaceId)

 	{

 	// if this is the bitrate interface then

 	// we support this natively

 	if (aInterfaceId == KUidCustomInterfaceDevSoundBitRate)

 		{

 		return static_cast<MMMFDevSoundCustomInterfaceBitRate*> (this);

 		}

 	else

 		{

 		// otherwise pass the interface call onto the base class

 		return CMMFSwCodecWrapper::CustomInterface(aInterfaceId);

 		}

 	}

 void CMMFPcm16ToPcm16HwDevice::GetSupportedBitRatesL(RArray<TInt>& aSupportedBitRates)

 	{

 	// precondition of needing the datapath

 	if (!iDataPath)

 		{

 		User::Leave(KErrNotReady);

 		}

 	// we only use this interface on the record interface

 	if (iRecordCustomInterface)

 		{

 		MSwInfoInterface* interface = 

               static_cast<MSwInfoInterface*>(iDataPath->CustomInterface(KUidSwInfoInterface));

         if (interface)

               {

               RArray<TInt> supportedSampleRates;

               CleanupClosePushL(supportedSampleRates);

               User::LeaveIfError(interface->GetSupportedSampleRates(supportedSampleRates));

               BitRatesFromSampleRatesL(aSupportedBitRates, supportedSampleRates);

               CleanupStack::PopAndDestroy(&supportedSampleRates);

               }

         else

             {

             User::Leave(KErrNotSupported);

             }

 		}

 	}

 void CMMFPcm16ToPcm16HwDevice::BitRatesFromSampleRatesL(RArray<TInt>& aSupportedBitRates, 

                                                         const RArray<TInt>& aSupportedSampleRates)

     {

     for (TInt index=0; index<aSupportedSampleRates.Count(); index++)

         {

         TInt sampleRate = aSupportedSampleRates[index];

         TInt bitRate = sampleRate * iChannels * 16;

         aSupportedBitRates.AppendL(bitRate);

         }

     }

 TInt CMMFPcm16ToPcm16HwDevice::BitRateL()

 	{

 	/*

 	inline void GetRecordFormat(TCurrentSoundFormatBuf& aFormat);

 	inline TInt SetRecordFormat(const TCurrentSoundFormatBuf& aFormat);

 	*/

 	TInt bitRate = 0;

 	// need a number of channels and sample rate

 	if (!iSampleRate || !iChannels)

 		{

 		User::Leave(KErrNotReady);

 		}

 	// should be able to just return sample rate * channels * 16 

 	if (iRecordCustomInterface)

 		{

 		bitRate = iSampleRate * iChannels * 16;	

 		}

 	return bitRate;

 	}

 void CMMFPcm16ToPcm16HwDevice::SetBitRateL(TInt aBitRate)

 	{

 	// need a datapath and number of channels

 	if (!iDataPath || (!iChannels))

 		{

 		User::Leave(KErrNotReady);

 		}

 	// calculate the correct sample rate but don't set it yet

 	TInt sampleRate = aBitRate / 16 / iChannels;

 	// if the datapath is not playing try and make change immediately

 	if (iDataPath->State() != CMMFSwCodecDataPath::EPlaying)

 		{

 		// update the member variable, assume it is picked up on next record.

 		iSampleRate = sampleRate;

 		}

 	}