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