// 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 <mmf/server/mmfswcodecwrapper.h>

#include "mmfSwCodecPlayDataPath.h"

#include "mmfSwCodecRecordDataPath.h"

#include "mmfSwCodecConvertDataPath.h"

#include <mmf/server/mmfswcodecwrappercustominterfacesuids.hrh>

#include "mmfswcodecwrapperCustomInterfaces.h"

#include <mmf/common/mmfpaniccodes.h>

/**

 * 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 RMdaDevSound to the play

 * custom interface

 * @internalComponent

 */

void TPlayCustomInterface::SetDevice(RMdaDevSound* aDevice)

	{

	iDevice = aDevice;

	}

void TPlayCustomInterface::SetVolume(TUint aVolume)

	{

	iVolume = aVolume;

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

		iDevice->SetPlayVolume(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

 * @released

 * @return number of bytes played

 */

TUint TPlayCustomInterface::BytesPlayed()

	{

	if(iDevice)

		{

		if (iDevice->Handle())

			iBytesPlayed = iDevice->BytesPlayed();

		}

	return iBytesPlayed;

	}

/**

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

 * @released

 * @return The number of bytes recorded by an existing datapath.  If there

 * is no datapath, then the last known number of bytes recorded will be returned.

 */

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()

	{

	delete iDataPath;

	delete iCodec;

	delete iPlayCustomInterface;

	delete iRecordCustomInterface;

	}

/**

Initializes the hardware device tasks - in the case of a

sw codec wrapper 'hardware device' this consits 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)

	{

	// [ precondition that aDevInfo has a valid observer ]

	if (!aDevInfo.iHwDeviceObserver) 

		return KErrArgument;

	iHwDeviceObserver = aDevInfo.iHwDeviceObserver;

#ifndef SYMBIAN_MDF_SHAREDCHUNK_SOUNDDRIVER //Adapter loads the drivers

	// Try to load the audio physical driver

    TInt ret = User::LoadPhysicalDevice(KPddFileName);

	if ((ret!=KErrNone) && (ret!=KErrAlreadyExists))

        return ret;

    // Try to load the audio logical driver

	ret = User::LoadLogicalDevice(KLddFileName);

    if ((ret!=KErrNone) && (ret!=KErrAlreadyExists))

        return ret;

#endif

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

	//[ assert the post condition ]

	if (!iCodec) 

		return KErrNotSupported;

	return 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

	if(error != KErrNone && iDataPath && aFuncCmd!=EDevEncode)

		{//if error happens after opening LDD close it

		if (iDataPath->Device().Handle()!= KNullHandle)

			{

			iDataPath->Device().Close();

			}

		}

	return error;

	}

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());

		//if datapath could not be created, return error code

		if (error != KErrNone)

			{

			return error;

			}

		//here we are sure iDataPath has been correctly allocated		

		iDataPath->SetObserver(*iHwDeviceObserver);

		error = iDataPath->AddCodec(*iCodec);

		if (error == KErrNone)

			{

			iDeviceBufferSize = (iCodec->SinkBufferSize());

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

			}

		else

			{

			// if could not add codec to datapath, return error code

			return error;

			}

		}

	//Here we know that error is KerrNone, now we can check the state of the datapath	

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

		{//datapath was created ok and we are not playing

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

			{//starting from 'fresh so set sound device settings

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

  				{//if Device() is called then we need a valid sound device handle

  				error = iDataPath->Device().Open();

				if (error != KErrNone)

					return error;

				}

			static_cast<TPlayCustomInterface*>(iPlayCustomInterface)->SetDevice(&(iDataPath->Device()));

			iDataPath->Device().SetPlayVolume(iPlayCustomInterface->Volume());

			RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

			soundDeviceSettings().iRate = iSampleRate;

			//this would normally be pcm16

			soundDeviceSettings().iEncoding = RMdaDevSound::EMdaSoundEncoding16BitPCM;

			//1 = mono 2 = stereo

			soundDeviceSettings().iChannels = iChannels;

			//tell sound driver what buffer size to expect

			//it is up the the implementor to make use the device can support

			//the required buffer size

			soundDeviceSettings().iBufferSize = iDeviceBufferSize;

			error = iDataPath->Device().SetPlayFormat(soundDeviceSettings);	

			}//iDataPath->State() == CMMFSwCodecDataPath::EStopped

		//else resuming from pause	

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

			error = iDataPath->Start();

		}//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());

		//if datapath could not be created, return error code

		if (error != KErrNone)

			{

			return error;

			}

		//here we are sure iDataPath has been correctly allocated

		iDataPath->SetObserver(*iHwDeviceObserver);

		error = iDataPath->AddCodec(*iCodec);

		if (error == KErrNone)

			{

			iDeviceBufferSize = (iCodec->SourceBufferSize());

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

			}

		else

			{

			// if could not add codec to datapath, return error code

			return error;

			}

		}

	//Here we know that error is KerrNone, now we can check the state of the datapath

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

		{

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

			{

			MSwSetParamInterface* setParams = 

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

			ASSERT(!error); // should not get here if error set

			error = setParams->SetGain(iRecordCustomInterface->Gain());

			if (!error)

				{

				error = setParams->SetNumChannels(iChannels);

				}

			if (!error)

				{

				error = setParams->SetSampleRate(iSampleRate);

				}

			}

		if (error == KErrNone)

			{

			error = iDataPath->Start();

			}

		}

	return error;

	}

TInt CMMFSwCodecWrapper::StartConvert()

	{//convert

	TInt error = KErrNone;

	if (!iDataPath)

		{

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

		if (error != KErrNone)

			{

			return error;

			}

		}

	//Here we know we are not dereferencing a null pointer as iDataPath has been correctly initialised

	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,

MPlayCustomInterface and MRecordCustomInterface.

@param	aInterface

		Interface UID, defined with the custom interface.

		aInterface = KMmfPlaySettingsCustomInterface for MPlayCustomInterface,

		aInterface = KMmfRecordSettingsCustomInterface for MRecordCustomInterface.

		aInterface = KMmfUidEmptyBuffersCustomInterface for MEmptyBuffersCustomInterface

		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);

		}

	else if (aInterface.iUid == KMmfUidEmptyBuffersCustomInterface || aInterface == KTimePlayedCustomInterfaceTypeUid || aInterface == KIgnoreUnderflowCustomInterfaceTypeUid)

		{

		if (!iDataPath)

			{

			ret = NULL;			

			}

		else

			{

			ret = static_cast<CMMFSwCodecDataPath*>(iDataPath)->CustomInterface(aInterface);	

			}	

		}

	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)

	{

	if (aConfig.iUid != KUidRefDevSoundTaskConfig)

		return KErrArgument;

	iSampleRate = aConfig.iRate;

	if (aConfig.iStereoMode == ETaskMono)

		{

		iChannels = 1;

		}

	else if (aConfig.iStereoMode == ETaskInterleaved || aConfig.iStereoMode == ETaskNonInterleaved)

		{

		iChannels = 2;

		}

	else

		{

		return KErrArgument;

		}

	return KErrNone;

	}

/**

Used to set iVbrFlag on the datapath.

This method is used to set the iVbrFlag in datapath. This flag is added to datapath to avail the 

alternative dataflow wherein datapath makes sure that destinationbuffer is filled to its maximum length

before sending it to the sound driver. Sending the buffer directly to the device causes underflow incase of VBR codecs.

*/

EXPORT_C void CMMFSwCodecWrapper::SetVbrFlag()

	{

	if(iDataPath)

		{

		TUid cUid = TUid::Uid(KSetVbrFlagCustomInterfaceTypeUid);

		iDataPath->CustomInterface(cUid);

		}

	}