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