// Copyright (c) 2005-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 "mmfbtswcodecwrapper.h"

 #include "mmfBtSwCodecPlayDataPath.h"

 #include "mmfBtSwCodecRecordDataPath.h"

 #include "mmfBtSwCodecConvertDataPath.h"

 #include <mmfswcodecwrappercustominterfacesuids.hrh>

 #include "mmfBtswcodecwrapperCustomInterfaces.h"

 #include "MMFBtRoutingSoundDevice.h"

 #include <mmfpaniccodes.h>

 /*

  *	AO to handle RSD initialisation

  *

  */

 CRoutingSoundDeviceOpenHandler* CRoutingSoundDeviceOpenHandler::NewL(CMMFSwCodecWrapper* aObserver)

 	{

 	CRoutingSoundDeviceOpenHandler* self = new(ELeave) CRoutingSoundDeviceOpenHandler(aObserver);

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CRoutingSoundDeviceOpenHandler::~CRoutingSoundDeviceOpenHandler()

 	{

 	Cancel();

 	}

 void CRoutingSoundDeviceOpenHandler::RunL()

 	{

 	TInt err = iStatus.Int();

 	if (iObserver)

 		{

 		iObserver->OpenComplete(err);

 		}

 	}

 void CRoutingSoundDeviceOpenHandler::DoCancel()

 	{

 	if (iObserver)

 		{

 		iObserver->OpenComplete(KErrCancel);

 		}

 	}

 CRoutingSoundDeviceOpenHandler::CRoutingSoundDeviceOpenHandler(CMMFSwCodecWrapper* aObserver) :

 															 	CActive(EPriorityStandard),

 															 	iObserver(aObserver)								 	

 	{

 	CActiveScheduler::Add(this);	

 	}

 void CRoutingSoundDeviceOpenHandler::ConstructL()

 	{

 	}

 void CRoutingSoundDeviceOpenHandler::Start()

 	{

 	if (!IsActive())

 		{

 		SetActive();

 		}

 	}

 /**

  * Internal panic

  * @internalComponent

  */

 void Panic(TInt aPanicCode)

 	{

 	_LIT(KMMFSwCodecWrapperPanicCategory, "MMFSwCodecWrapper");

 	User::Panic(KMMFSwCodecWrapperPanicCategory, aPanicCode);

 	}

 /**

  * This method is not be exported as it is only 

  * intended to be called within this DLL.

  * It's purpose is to assign an CRoutingSoundPlayDevice to the play

  * custom interface

  * @internalComponent

  */

 void TPlayCustomInterface::SetDevice(CRoutingSoundPlayDevice* aDevice)

 	{

 	iDevice = aDevice;

 	}

 void TPlayCustomInterface::SetVolume(TUint aVolume)

 	{

 	iVolume = aVolume;

 	if (iDevice && iDevice->Handle())

 		{

 		iDevice->SetVolume(iVolume);

 		}

 	}

 /**

  * Procedure to get the number of bytes played by the device driver

  * If there is no handle available to the device driver then the 

  * procedure returns the last known value

  * @prototype

  * @return number of bytes played

  */

 TUint TPlayCustomInterface::BytesPlayed()

 	{

 	if(iDevice)

 		{

 		if (iDevice->Handle())

 			{

 			iBytesPlayed = iDevice->BytesPlayed();

 			}

 		}

 	return iBytesPlayed;

 	}

 TTaskConfig TPlayCustomInterface::Caps()

 	{

 	TTaskConfig taskConfig;

 	taskConfig.iRate = 0;

 	taskConfig.iStereoMode = 0;

 	taskConfig.iUid = KUidRefDevSoundTaskConfig;

 	if (iDevice && iDevice->Handle())

 		{

 		RArray<TUint> supportedSampleRates;

 		RArray<TRange>supportedRateRanges;

 		iDevice->GetSupportedSampleRates(supportedSampleRates,supportedRateRanges);	

 		for (TUint i=0; i<supportedSampleRates.Count(); i++)

 			{

 			switch(supportedSampleRates[i])

 				{

 				case 8000:

 					taskConfig.iRate |= ETask8000Hz;

 					break;

 				case 11025:

 					taskConfig.iRate |= ETask11025Hz;

   					break;

 				case 12000:

 					taskConfig.iRate |= ETask12000Hz;

 					break;

 				case 16000:

 					taskConfig.iRate |= ETask16000Hz;

 					break;

 				case 22050:

   					taskConfig.iRate |= ETask22050Hz;

   					break;

 				case 24000:

   					taskConfig.iRate |= ETask24000Hz;

   					break;

 				case 32000:

   					taskConfig.iRate |= ETask32000Hz;

   					break;

 				case 44100:

 					taskConfig.iRate |= ETask44100Hz;

   					break;

 				case 48000:

 					taskConfig.iRate |= ETask48000Hz;

 					break;

 				case 88200:

 					taskConfig.iRate |= ETask88200Hz;

 					break;

 				case 96000:

 					taskConfig.iRate |= ETask96000Hz;

 					break;

 				default: //do nothing

 					break;	

 				}//	switch(supportedSampleRates[i])

 			supportedSampleRates.Close();

 			supportedRateRanges.Close();

 			}//for (TUint i=0; i<supportedSampleRates.Count(); i++)

 		RArray<TUint> supportedChannels;

 		TMMFStereoSupport stereoSupport;

 		iDevice->GetSupportedChannels(supportedChannels,stereoSupport);	

 		for (TUint i=0; i<supportedChannels.Count(); i++)

 			{//note we don't have a TaskConfig enum for Joint stereo

 			switch(supportedChannels[i])

 				{

 				case EMMFMono:

 					taskConfig.iStereoMode |= ETaskMono;

 					break;

 				case EMMFStereo:

 					if (stereoSupport == EMMFInterleavedOnly)

 						{

 						taskConfig.iStereoMode |= ETaskInterleaved;

 						}

 					else if (stereoSupport == EMMFNonInterleavedOnly)

 						{

 						taskConfig.iStereoMode |= ETaskNonInterleaved;

 						}

 					else if (stereoSupport == EMMFBothNonAndInterleaved)

 						{

 						taskConfig.iStereoMode |= (ETaskInterleaved|ETaskNonInterleaved);

 						}

 					break;

 				default://do nothing

 					break;

 				}//switch(supportedChannels[i])

 			supportedChannels.Close();

 			}//	for (TUint i=0; i<supportedChannels.Count(); i++)

 		}//if (iDevice && iDevice->Handle())

 	return taskConfig;

 	}

 /**

  * Procedure to get the number of bytes recorded by the device  

  * @prototype

  * @return number of bytes recorded

  */

 TUint TRecordCustomInterface::BytesRecorded()

 	{

 	if(iDataPath)

 		{

 		iBytesRecorded = iDataPath->RecordedBytesCount();

 		}

 	return iBytesRecorded;

 	}

 /**

 Constructor.

 */

 EXPORT_C CMMFSwCodecWrapper::CMMFSwCodecWrapper()

 	{

 	}

 /**

 Destructor.

 The destructor is called by ECom framework allowing derived classes

 to clean up implementation specific resources. The sound

 device drivers are freed.

 */

 EXPORT_C CMMFSwCodecWrapper::~CMMFSwCodecWrapper()

 	{

 	// AO to handle OpenDevice call

 	if (iOpenHandler && iOpenHandler->IsActive())

 		{

 		iOpenHandler->Cancel();	

 		}

 	delete iOpenHandler;

 	delete iRecordDevice;

 	delete iPlayDevice;

 	delete iDataPath;

 	delete iCodec;

 	delete iPlayCustomInterface;

 	delete iRecordCustomInterface;

 	}

 /**

 Initializes the hardware device tasks - in the case of a

 sw codec wrapper 'hardware device' this consists of loading the

 sound device drivers and creating the CMMFSwCodec.

 @param  aDevInfo

         Device initialization parameters.

         Only the iHwDeviceObserver is used for CMFSwCodecWrapper

         derived CMMFHwDevices.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 */

 EXPORT_C TInt CMMFSwCodecWrapper::Init(THwDeviceInitParams& aDevInfo)

 	{

 	TRequestStatus status;

 	Init(aDevInfo,status);

 	User::WaitForRequest(status);

 	return status.Int();

 	}

 /**

 Initializes the hardware device tasks - in the case of a

 sw codec wrapper 'hardware device' this consists of loading the

 sound device drivers and creating the CMMFSwCodec.

 @param  aDevInfo

         Device initialization parameters.

         Only the iHwDeviceObserver is used for CMFSwCodecWrapper

         derived CMMFHwDevices.

 @param	aStatus

 		Status flag belonging to an Active Object that will have its

 		RunL() called when this function completes

 */

 EXPORT_C void CMMFSwCodecWrapper::Init(	THwDeviceInitParams &aDevInfo,

 										TRequestStatus& aStatus)

 	{

 	aStatus = KRequestPending;

 	TRequestStatus* status = &aStatus;

 	if (!aDevInfo.iHwDeviceObserver)

 		{

 		User::RequestComplete(status, KErrArgument);

 		return;

 		}

 	iHwDeviceObserver = aDevInfo.iHwDeviceObserver;

 	TInt err = KErrNone;

 	if (aDevInfo.iOutStream.iConnection.iId)

 		{

 		iDeviceUid = TUid::Uid(aDevInfo.iOutStream.iConnection.iId);

 		// Play device

 		delete iPlayDevice;

 		iPlayDevice  = NULL;

 		TRAP(err, iPlayDevice = CRoutingSoundPlayDevice::NewL());

 		if (err == KErrNone)

 			{

 			iPlayDevice->Initialize(iDeviceUid,

 									aDevInfo.iOutStream.iDeviceName, *status);

 			if (!iPlayCustomInterface)

 				{

 				TRAP(err,iPlayCustomInterface = new(ELeave)TPlayCustomInterface());

 				if (err)

 					{

 					delete iPlayDevice;

 					iPlayDevice = NULL;

 					User::RequestComplete(status, err);

 					return;

 					}

 				}

 			static_cast<TPlayCustomInterface*>(iPlayCustomInterface)->SetDevice(iPlayDevice);	

 			}

 		}

 	if (aDevInfo.iInStream.iConnection.iId)

 		{

 		iDeviceUid = TUid::Uid(aDevInfo.iInStream.iConnection.iId);

 			// Record device

 		TRAP(err, iRecordDevice = CRoutingSoundRecordDevice::NewL());

 		if (err == KErrNone)

 			{

 			iRecordDevice->Initialize(iDeviceUid, KNullDesC8, *status);

 			if (!iRecordCustomInterface)

 				{

 				TRAP(err,iRecordCustomInterface = new(ELeave)TRecordCustomInterface());

 				if (err)

 					{

 					delete iRecordDevice;

 					iRecordDevice = NULL;

 					User::RequestComplete(status, err);

 					return;

 					}

 				}

 			}

 		}

 	iCodec = &(Codec()); //create codec

 	//[ assert the post condition ]

 	if (!iCodec)

 		{

 		err = KErrNotSupported;

 		}

 	if (err != KErrNone)

 		{

 		User::RequestComplete(status, err);

 		// Cancel initialisation too

 		if (aDevInfo.iOutStream.iConnection.iId)

 			{

 			iPlayDevice->CancelInitialize(iDeviceUid);

 			}

 		if (aDevInfo.iInStream.iConnection.iId)

 			{

 			iRecordDevice->CancelInitialize(iDeviceUid);

 			}		

 		}		

 	else if ((!aDevInfo.iOutStream.iConnection.iId)&& (!aDevInfo.iInStream.iConnection.iId))

 		{

 		//could be used for conversion so complete the request status

 		User::RequestComplete(status, KErrNone);

 		}

 	}

 /**

 Starts Encoding or Decoding task(s) based on the parameter specified.

 @param  aFuncCmd

         The device function specifying the requested service i.e. decode or encode

         where EDevEncode = Record, EDevDecode = Play and EDevNullFunc = Convert.

 @param  aFlowCmd

         The device flow directions for requested service.

         This parameter is ignored for CMMFSwCodecWrapper CMMFHwDevicePlugins

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 */

 EXPORT_C TInt CMMFSwCodecWrapper::Start(TDeviceFunc aFuncCmd, TDeviceFlow /*aFlowCmd*/)

 	{

 	TInt error = KErrNone;

 	// [ precondition that aFuncCmd is valid]

 	if (!((aFuncCmd == EDevEncode)|(aFuncCmd == EDevDecode)|(aFuncCmd == EDevNullFunc)))

 		{

 		return KErrArgument;

 		}

 	// [ precondition that iCodec is present]

 	if (!iCodec)

 		{

 		return KErrNotReady; //make sure the codec has been added

 		}

     switch (aFuncCmd)

         {

         case EDevEncode: // Audio record

 			{

 			error = StartEncode();

 			}

             break;

         case EDevDecode: // Audio play

 			{

 			error = StartDecode();

 			}

             break;

 		case EDevNullFunc: //Audio Convert

 			{

 			error = StartConvert();

 			}

 			break;

         default:

             error = KErrNotSupported;

             break;

 		}

 	//[ assert the post conditions ]

 #ifdef DEBUG

 	if (!error)

 		{//only assert if no error otherwise post consitions not valid

 		__ASSERT_DEBUG(iDataPath, Panic(EMMFSwCodecWrapperNoDataPath));

 		if ((aFuncCmd == EDevEncode)||(aFuncCmd == EDevDecode))

 			{

 			__ASSERT_DEBUG(iDataPath->Device().Handle(), Panic(EMMFSwCodecWrapperNoDevice));

 			}

 		}

 #endif

 	return error;

 	}

 // Use AO to OpenDevice

 TInt CMMFSwCodecWrapper::StartDecode()

 	{

 	TInt error = KErrNone;

 	//[ assert precondition that play custom interface is present]

 	//if there is no play custom interface then the user of the CMMFSwCodecWrapper

 	//cannot have set any of the custom settings such as sample rate.

 	if (!iPlayCustomInterface)

 		{

 		return KErrNotReady;

 		}

 	//play

 	if (!iDataPath)

 		{//create a datapath

 		TRAP(error,iDataPath = CMMFSwCodecPlayDataPath::NewL(iPlayDevice, iDeviceUid));

 		if ((iDataPath) && (error == KErrNone))

 			{

 			iDataPath->SetObserver(*iHwDeviceObserver);

 			error = iDataPath->AddCodec(*iCodec);

 			iDeviceBufferSize = iCodec->SinkBufferSize();

 			static_cast<CMMFSwCodecPlayDataPath*>(iDataPath)->SetPlayCustomInterface(*iPlayCustomInterface);

 			static_cast<CMMFSwCodecPlayDataPath*>(iDataPath)->SetConfigForAudioRamp(iSampleRate, iChannels);

 			}

 		}

 	if ((error == KErrNone) &&

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

 		{

 		TBool asynchOpen = EFalse;	// Ensure we only call OpenPlayComplete once

 		//datapath was created ok and we are not playing

 		if (iDataPath->State() == CMMFSwCodecDataPath::EStopped)

 			{

 			//starting from 'fresh so set sound device settings

 			// Create the AO OpenDevice handler

 			if (!iOpenHandler)

 				{

 				TRAP(error, iOpenHandler = CRoutingSoundDeviceOpenHandler::NewL(this));				

 				}

 			if (!error)

 				{

  				asynchOpen = ETrue;

  				iPlayDevice->SetBufferSize(iDeviceBufferSize);

 				iOpenHandler->Start();

 	 			static_cast<CMMFSwCodecPlayDataPath*>(iDataPath)->Device()->

  										OpenDevice(iDeviceUid, iOpenHandler->iStatus);

 				}

 			}

 		if (!asynchOpen)

 			{

 			error = OpenPlayComplete(error);

 			}

 		}//status == KErrNone

 	return error;

 	}

 TInt CMMFSwCodecWrapper::StartEncode()

 	{//record

 	//[ assert precondition that record custom interface is present]

 	//if there is no record custom interface then the user of the CMMFSwCodecWrapper

 	//cannot have set any of the custom settings such as sample rate.

 	if (!iRecordCustomInterface)

 		{

 		return KErrNotReady;

 		}

 	TInt error = KErrNone;

 	if (!iDataPath)

 		{

 		TRAP(error,iDataPath = CMMFSwCodecRecordDataPath::NewL(iRecordDevice));

 		if ((iDataPath)&&(error == KErrNone))

 			{

 			iDataPath->SetObserver(*iHwDeviceObserver);

 			error = iDataPath->AddCodec(*iCodec);

 			iDeviceBufferSize = (iCodec->SourceBufferSize());

 			static_cast<TRecordCustomInterface*>(iRecordCustomInterface)->SetDataPath(static_cast<CMMFSwCodecRecordDataPath*>(iDataPath));

 			}

 		}

 	if ((error == KErrNone)&&

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

 		{

 		TBool asynchOpen = EFalse;	// Ensure we only call OpenPlayComplete once

 		if (!(static_cast<CMMFSwCodecRecordDataPath*>(iDataPath))->Device()->Handle())

   			{

 			// Create the AO OpenDevice handler

 			if (!iOpenHandler)

 				{

 				TRAP(error, iOpenHandler = CRoutingSoundDeviceOpenHandler::NewL(this));				

 				}

 			if (!error)

 				{

 				asynchOpen = ETrue;

 				iRecordDevice->SetBufferSize(iDeviceBufferSize);

 				iOpenHandler->Start();

  				static_cast<CMMFSwCodecRecordDataPath*>(iDataPath)->Device()->

 									OpenDevice(iDeviceUid, iOpenHandler->iStatus);

 				}

 			}

 		if (!asynchOpen)

 			{

 			error = OpenRecordComplete(error);

 			}			

 		}

 	return error;

 	}

 TInt CMMFSwCodecWrapper::StartConvert()

 	{//convert

 	TInt error = KErrNone;

 	if (!iDataPath)

 		{

 		TRAP(error,iDataPath = CMMFSwCodecConvertDataPath::NewL());

 		if ((iDataPath)&&(error == KErrNone))

 			{

 			iDataPath->SetObserver(*iHwDeviceObserver);

 			error = iDataPath->AddCodec(*iCodec);

 			}

 		}

     if (error == KErrNone)

     	{

 		error = iDataPath->Start();

     	}

 	return error;

 	}

 /**

 Temporarily suspends the current task of decoding or encoding.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 */

 EXPORT_C TInt CMMFSwCodecWrapper::Pause()

 	{

 	// [ precondition that datapath exists ]

 	if (!iDataPath)

 		{

 		return KErrNotReady;

 		}

 	iDataPath->Pause();

 	return KErrNone;

 	}

 /**

 Stops the current on-going task.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 */

 EXPORT_C TInt CMMFSwCodecWrapper::Stop()

 	{

 	// [ precondition that datapath exists ]

 	if (!iDataPath)

 		{

 		return KErrNotReady;

 		}

 	iDataPath->Stop();

 	return KErrNone;

 	}

 /**

 Stops and deletes the codec.

 This default implementation simply calls DeleteCodec() and then Stop()

 but real hardware devices might use this method to free up resources.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 */

 EXPORT_C TInt CMMFSwCodecWrapper::StopAndDeleteCodec()

 	{

 	TInt stopError = Stop();

 	TInt deleteError = DeleteCodec();

 	if (stopError != KErrNone)

 		{

 		return stopError;

 		}

 	else

 		{

 		return deleteError;

 		}

 	}

 /**

 Deletes the codec

 This default implementation does nothing

 but real hardware devices might use this method to free up resources.

 @return		Error code. KErrNone if successful

 */

 EXPORT_C TInt CMMFSwCodecWrapper::DeleteCodec()

 	{

 	return KErrNone;

 	}

 /**

 Call this function to notify hardware device implementation that

 data is available in aFillBufferPtr for decoding.

 @param aFillBufferPtr

        The data buffer filled by the observer.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 */

 EXPORT_C TInt CMMFSwCodecWrapper::ThisHwBufferFilled(CMMFBuffer& aFillBufferPtr)

 	{

 	TRAPD(err,iDataPath->BufferFilledL(STATIC_CAST(CMMFDataBuffer&, aFillBufferPtr)));

 	return err;

 	}

 /**

 Call this function to notify hardware device implementation that

 data in aEmptyBufferPtr from encoding is processed.

 @param  aBuffer

         The data buffer processed by observer.

 @return An error code indicating if the function call was successful. KErrNone on success, otherwise

         another of the system-wide error codes.

 */

 EXPORT_C TInt CMMFSwCodecWrapper::ThisHwBufferEmptied(CMMFBuffer& aBuffer)

 	{

 	TRAPD(err,iDataPath->BufferEmptiedL(STATIC_CAST(CMMFDataBuffer&, aBuffer)));

 	return err;

 	}

 /**

 Retrieves a custom interface to the device.

 The reference CMMFSwCodecWrapper supports two standard custom interfaces,

 TPlayCustomInterface and TRecordCustomInterface.

 @param	aInterface

 		Interface UID, defined with the custom interface.

 		aInterface = KMmfPlayCustomInterface for TPlayCustomInterface,

 		aInterface = KMmfRecordCustomInterface for TRecordCustomInterface.

 		Actual device implementations of CMMFSwCodecWrapper may do this differently however.

 @return A pointer to the interface implementation, or NULL if the device can not

 		implement the interface requested. The return value must be cast to the

 		correct type by the user.

 */

 EXPORT_C TAny* CMMFSwCodecWrapper::CustomInterface(TUid aInterface)

 	{

 	TAny* ret = NULL;

 	TInt err = KErrNone;

 	if (aInterface.iUid == KMmfPlaySettingsCustomInterface)

 		{

 		if (!iPlayCustomInterface)

 			{

 			TRAP(err,iPlayCustomInterface = new(ELeave)TPlayCustomInterface());

 			}

 		if (err)

 			{

 			ret = NULL;

 			}

 		else

 			{

 			ret = static_cast<TAny*>(iPlayCustomInterface);

 			}

 		}

 	else if (aInterface.iUid == KMmfRecordSettingsCustomInterface)

 		{

 		if (!iRecordCustomInterface)

 			{

 			TRAP(err,iRecordCustomInterface = new(ELeave)TRecordCustomInterface());

 			}

 		if (err)

 			{

 			ret = NULL;

 			}

 		else

 			{

 			ret = static_cast<TAny*>(iRecordCustomInterface);

 			}

 		}

 	return ret;

 	}

 /**

 Used to configure the sample rate and stereo mode of a CMMFHwDevice plugin.

 The configuration of HwDevices is device specific and is not used in any of the reference

 devices that return KErrNotSupported.

 @param  aConfig

         The device configuration.

 */

 EXPORT_C TInt CMMFSwCodecWrapper::SetConfig(TTaskConfig& aConfig)

 	{

 	TInt err = KErrNone;

 	if (aConfig.iUid != KUidRefDevSoundTaskConfig)

 		return KErrArgument;

 	iSampleRate = aConfig.iRate;//note we're cheating a bit

 	//iRate is actually a bit map enum but an actual value

 	//is more useful here

 	TMMFStereoSupport stereoSupport = EMMFNone;

 	if (aConfig.iStereoMode == ETaskMono)

 		{

 		iChannels = 1;

 		}

 	else if (aConfig.iStereoMode == ETaskInterleaved) 

 		{

 		iChannels = 2;

 		stereoSupport = EMMFInterleavedOnly;

 		}

 	else //don't support non interleaved

 		{

 		return KErrNotSupported;

 		}

 	//set values on routing sound device

 	if (iPlayDevice)

 		{

 		err = iPlayDevice->SetChannels(iChannels, stereoSupport);

 		if (!err)

 			{

 			err = iPlayDevice->SetSampleRate(iSampleRate);

 			}

 		if (!err)

 			{//we'll set the data type while were at it for now pcm16 only

 			TFourCC fourCC = KMMFFourCCCodePCM16;

 			err = iPlayDevice->SetDataType(fourCC);

 			}

 		}

 	if ((iRecordDevice) && (!err))

 		{

 		err = iRecordDevice->SetChannels(iChannels, stereoSupport);

 		if (!err)

 			{

 			err = iRecordDevice->SetSampleRate(iSampleRate);

 			}

 		}

 	return err;

 	}

 /**

 Callback once CRoutingSoundPlayDevice or CRoutingSoundRecordDevice::Open has completed or continuation from

 call to StartDecode / StartEncode, depending on the state.

 @internalTechnology

 @param	aError

 		The status of the device.

 @return A standard Symbian wide error code.

  */

 TInt CMMFSwCodecWrapper::OpenComplete(TInt aError)

 	{

 	TInt err = KErrNotSupported;	//

 	if (iPlayDevice)

 		{

 		err = OpenPlayComplete(aError);

 		}

 	else if (iRecordDevice)

 		{

 		err = OpenRecordComplete(aError);

 		}

 	return err;

 	}

 /**

 Callback once CRoutingSoundPlayDevice::Open has completed or continuation from

 call to StartDecode, depending on the state.

 @param	aError

 		The status of the device.

 @return A standard Symbian wide error code.

  */

 TInt CMMFSwCodecWrapper::OpenPlayComplete(TInt aError)

 	{

 	TInt error = aError;

 	//datapath was created ok and we are not playing

 	if (error == KErrNone && iDataPath->State() == CMMFSwCodecDataPath::EStopped)

 		{

 		//starting from fresh so set sound device settings

 //		static_cast<TPlayCustomInterface*>(iPlayCustomInterface)->SetDevice(

 //					static_cast<CMMFSwCodecPlayDataPath*>(iDataPath)->Device() );

 		static_cast<CMMFSwCodecPlayDataPath*>(iDataPath)->Device()->SetVolume(iPlayCustomInterface->Volume());

 		}

 	// resuming from pause or ready to play

 	if ((error == KErrNone) || (error == KErrInUse))

 		{

 		error = iDataPath->Start();

 		}		

 	return error;

 	}

 /**

 Callback once CRoutingSoundRecordDevice::Open has completed or continuation from

 call to StartDecode, depending on the state.

 @param	aError

 		The status of the device.

 @return A standard Symbian wide error code.

  */

 TInt CMMFSwCodecWrapper::OpenRecordComplete(TInt aError)

 	{

 	TInt error = aError;

 	//datapath was created ok and we are not playing

 	if (error == KErrNone && iDataPath->State() == CMMFSwCodecDataPath::EStopped)

 		{

 		//set sound driver settings

 		static_cast<CMMFSwCodecRecordDataPath*>(iDataPath)->Device()

 												->SetGain(iRecordCustomInterface->Gain());

 		/*

 		// Sample rate

 		(static_cast<CMMFSwCodecRecordDataPath*>(iDataPath))->Device()->SetSampleRate(iSampleRate);

 		// Channels

 		TMMFStereoSupport stereoSupport = EMMFNone;	// assume mono

 		if (iChannels == 2)

 			{

 			// Assume interleaved only

 			stereoSupport = EMMFInterleavedOnly;

 			}

 		error = (static_cast<CMMFSwCodecRecordDataPath*>(iDataPath))->Device()->SetChannels(iChannels, stereoSupport);

 		*/

 		}

 	// resuming from pause or ready to play

 	if ((error == KErrNone) || (error == KErrInUse))

 		{

 		error = iDataPath->Start();

 		}		

 	return error;

 	}