// 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 "HwDeviceAdapter/mdfhwdeviceadapter.h"
#include <mdf/codecapiuids.hrh>
#include <mdf/mdfpuconfig.h>
#include <mmf/server/devsoundstandardcustominterfaces.h>

// Interface UID for the Sink Processing Unit
const TUid KUidSourceSinkPu = {0x102730BB};
const TInt KZerothPort = 0;

/*
The destructor.  Unloads the Processing Units, deletes the 
Processing Unit Loader and frees any owned buffers.
@see CMMFHwDevice::~CMMFHwDevice()
*/
CMdfHwDeviceAdapter::~CMdfHwDeviceAdapter()
	{
	Stop();
	// Unload the PUs
	if (iCodecPU)
		{
		iPuLoader->UnloadProcessingUnit(iCodecPU);
		}
	if (iAudioDevicePU)
		{
		iPuLoader->UnloadProcessingUnit(iAudioDevicePU);
		}
	
	delete iInputBuffer;
	delete iOutputBuffer;		
	delete iActiveWait;
	delete iPuLoader;	
	REComSession::DestroyedImplementation(iPuLoaderDtorKey);
	}

/*
Creates a new CMdfHwDeviceAdapter object.  The Processing Unit Loader plugin
is also loaded, and so the CMdfHwDeviceAdapter state is set to EProcessingUnitLoaderLoaded.
Will leave with KErrNotFound if it, or the Processing Unit Loader plugin is not found.
@see THwDevAdapterState
*/
CMdfHwDeviceAdapter* CMdfHwDeviceAdapter::NewL()
	{
	CMdfHwDeviceAdapter* self = new (ELeave) CMdfHwDeviceAdapter;
	CleanupStack::PushL (self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/*
Default constructor.
*/	
CMdfHwDeviceAdapter::CMdfHwDeviceAdapter()
	{	
	}

/*
Loads the Processing Unit Loader plugin.
*/	
void CMdfHwDeviceAdapter::ConstructL()
	{		
	// Load the PU Loader plugin
	iPuLoader = static_cast<CMdfPuLoader*>
		(REComSession::CreateImplementationL(TUid::Uid(KUidPuLoaderImplementation), iPuLoaderDtorKey));
	iActiveWait = new (ELeave) CActiveSchedulerWait;
	iState = EProcessingUnitLoaderLoaded;
	}	

/*
@see CMMFHwDevice::Start()
@see TDeviceFunc
*/
TInt CMdfHwDeviceAdapter::Start(TDeviceFunc aFuncCmd, TDeviceFlow /*aFlowCmd*/)
	{		
	if (!((aFuncCmd == EDevEncode)|(aFuncCmd == EDevDecode)|(aFuncCmd == EDevNullFunc)))
		{
		return KErrArgument;	
		}
		
	iFuncCmd = aFuncCmd;
			
	TInt err = KErrNone;
	switch(aFuncCmd)
		{
		case EDevEncode:
			{
			err = StartEncode();
			}
			break;
		case EDevDecode:
			{
			err = StartDecode();
			}
			break;
		case EDevNullFunc:
			{
			// nothing at the moment, so fall through
			}
			//break;
		default:
			{
			err = KErrNotSupported;	
			}		
			break;
		}

	
	return err;
	}
	
/*
Initialises the encode operation, and set the state of the CMdfHwDeviceAdapter
to EProcessingUnitInitializing.
@return  An error code indicating if the function call was successful.
KErrNone on success, otherwise another of the system-wide error codes.
*/	
TInt CMdfHwDeviceAdapter::InitializeEncode()
	{
	ASSERT(iCodecOutputPort && iSourceOutputPort);
	// Create input buffer that passes data from Source -> Codec PU	
	TRAPD(err, iInputBuffer = CMMFDescriptorBuffer::NewL(iSourceOutputPort->MopBufferSize()));
	if(err != KErrNone)
		{
		return err;
		}
	
	// Create output buffer that passes decoded data from Codec PU -> Out to file	
	TRAP(err, iOutputBuffer = CMMFDescriptorBuffer::NewL(iCodecOutputPort->MopBufferSize()));
	if(err != KErrNone)
		{
		return err;
		}
	
	err = iSourceOutputPort->MopUseBuffer(*iInputBuffer);
	if(err != KErrNone)
		{
		return err;
		}		
	err = iCodecInputPort->MipUseBuffer(*iInputBuffer);
	if(err != KErrNone)
		{
		return err;
		}		
	err = iCodecOutputPort->MopUseBuffer(*iOutputBuffer);
	if(err != KErrNone)
		{
		return err;
		}
			
	// async calls, that callback to InitializeComplete()
	iCodecPU->Initialize();
	iAudioDevicePU->Initialize();
	if (iState == EProcessingUnitLoaded)
		{
		// only wait for the callbacks if we haven't already received them
		iState = EProcessingUnitInitializing;
		iActiveWait->Start();
		}
	return iInitError;
	}
	
/*
Starts the encode operation, providing that the intial state of the
CMdfHwDeviceAdapter is EProcessingUnitLoaded.
@return  An error code indicating if the function call was successful.
KErrNone on success, otherwise another of the system-wide error codes.
*/
TInt CMdfHwDeviceAdapter::StartEncode()
	{
	TInt err = KErrNone;
	if (iState == EProcessingUnitLoaded)
		{
		err = InitializeEncode();
		}
	if (err != KErrNone)
		{
		return err;
		}	
	if (iState == EProcessingUnitPaused)
		{
		// Ensure that the LastBuffer flags are reset.
		iInputBuffer->SetLastBuffer(EFalse);
		iOutputBuffer->SetLastBuffer(EFalse);
		}
					
	return StartExecuting();
	}

/*
Starts the execution of the encode or decode operation, and sets the state
of the CMdfHwDeviceAdapter to EProcessingUnitExecuting.
@return  An error code indicating if the function call was successful.
KErrNone on success, otherwise another of the system-wide error codes.
*/	
TInt CMdfHwDeviceAdapter::StartExecuting()
	{
	TInt err = KErrNone;
	if(iFuncCmd == EDevDecode)
		{
		iCodecOutputPort->MopReadData(*iOutputBuffer);		
		err = iHwDeviceObserver->FillThisHwBuffer(*iInputBuffer);
		if(err != KErrNone)
			{
			return err;
			}
		}
	else // encode
		{
		iSourceOutputPort->MopReadData(*iInputBuffer);
		iCodecOutputPort->MopReadData(*iOutputBuffer);	
		}		
		
	iState = EProcessingUnitExecuting;
		
	iCodecPU->Execute();
	iAudioDevicePU->Execute();
	
	return err;
	}
	
/*
Initialises the decode operation, and set the state of the CMdfHwDeviceAdapter
to EProcessingUnitInitializing.
@return  An error code indicating if the function call was successful.
KErrNone on success, otherwise another of the system-wide error codes.
*/	
TInt CMdfHwDeviceAdapter::InitializeDecode()
	{
	ASSERT(iCodecOutputPort && iSinkInputPort);
	
	TRAPD(err, iInputBuffer = CMMFDescriptorBuffer::NewL(iCodecInputPort->MipBufferSize()));
	if(err != KErrNone)
		{
		return err;
		}
		
	iCodecInputPort->MipUseBuffer(*iInputBuffer);	
	TRAP(err, iOutputBuffer = CMMFDescriptorBuffer::NewL(iCodecOutputPort->MopBufferSize()));
	if(err != KErrNone)
		{
		return err;
		}	

	// Try to set up a tunnelbetween the output port of the PCM Pu 
	// and the input port of the Sink Pu	
	if (iPuLoader->TunnelSetup(*iCodecOutputPort, *iSinkInputPort) != KErrNone)
		{
		iSinkInputPort->MipUseBuffer(*iOutputBuffer);
		}
	iCodecOutputPort->MopUseBuffer(*iOutputBuffer);		
	
	// async calls, that callback to InitializeComplete()
	iCodecPU->Initialize();
	iAudioDevicePU->Initialize();
	iState = EProcessingUnitInitializing;
	iActiveWait->Start();
	return KErrNone;
	}

/*
Starts the decode operation, providing that the intial state of the
CMdfHwDeviceAdapter is EProcessingUnitLoaded.
@return  An error code indicating if the function call was successful.
KErrNone on success, otherwise another of the system-wide error codes.
*/
TInt CMdfHwDeviceAdapter::StartDecode()
	{	
	TInt err = KErrNone;
	if (iState == EProcessingUnitLoaded)
		{
		err = InitializeDecode();
		}
	if (err != KErrNone)
		{
		return err;
		}
	if (iState == EProcessingUnitIdle)
		{
		// Ensure that the LastBuffer flags are reset.
		iInputBuffer->SetLastBuffer(EFalse);
		iOutputBuffer->SetLastBuffer(EFalse);
		}
	return StartExecuting();	
	}

/*
@see CMMFHwDevice::Stop()
*/
TInt CMdfHwDeviceAdapter::Stop()
	{	
	if(iState == EProcessingUnitExecuting || iState == EProcessingUnitPaused)
		{			
		iStopping = ETrue; // is used as a guard in ExecuteComplete
		if(iAudioDevicePU)
			{
			iAudioDevicePU->Stop();	
			}
		if(iCodecPU)
			{
			iCodecPU->Stop();	
			}
				
		iPCMPUCallbackComplete = EFalse;
		iSourceSinkPUCallbackComplete = EFalse;
				
		iState = EProcessingUnitIdle;
		iStopping = EFalse;	
		}
	return KErrNone;		
	}

/*
@see CMMFHwDevice::Pause()
*/
TInt CMdfHwDeviceAdapter::Pause()
	{
	TInt err = KErrNone;
	if(iState != EProcessingUnitPaused)
		{
		if(iAudioDevicePU)
			{	
			err = iAudioDevicePU->Pause();	
			}
		iState = EProcessingUnitPaused;
		}	
	return err;	
	}

/*
@see CMMFHwDevice::Init()
*/
TInt CMdfHwDeviceAdapter::Init(THwDeviceInitParams& aDevInfo)
	{	
	if(!iCodecPU)
		{
		return KErrNotSupported;
		}
		
	// Not currently using any other members of aDevInfo, except the Observer
	// Set observer	
	if(!aDevInfo.iHwDeviceObserver)
		{
		return KErrArgument;
		}
	iHwDeviceObserver = aDevInfo.iHwDeviceObserver;
	
	RPointerArray<MMdfInputPort> inputPorts;
	// Get ports and set observers
	TInt err = iCodecPU->GetInputPorts(inputPorts);		
	if (err == KErrNone && inputPorts.Count() > 0)
		{
		iCodecInputPort = inputPorts[KZerothPort];
		iCodecInputPort->MipSetObserver(*this);
		}		
	inputPorts.Close();	
	if (err != KErrNone)
		{
		return err;
		}		
	if (!iCodecInputPort)
		{
		return KErrNotFound;
		}

	RPointerArray<MMdfOutputPort> outputPorts;
	// Get ports and set observers
	err = iCodecPU->GetOutputPorts(outputPorts);	
	if (err == KErrNone && outputPorts.Count() > 0)
		{
		iCodecOutputPort = outputPorts[KZerothPort];
		iCodecOutputPort->MopSetObserver(*this);
		}		
	outputPorts.Close();	
	if (err != KErrNone)
		{
		return err;
		}
	if (!iCodecOutputPort)
		{
		return KErrNotFound;
		}
	
	// Load SourceSink Pu	
	TRAP(err, iAudioDevicePU = iPuLoader->LoadProcessingUnitL(*this, KUidSourceSinkPu));
	if(err!=KErrNone)
		{
		return err;
		}		

	err = iAudioDevicePU->GetInputPorts(inputPorts);	
	if (err == KErrNone && inputPorts.Count() > 0)
		{
		iSinkInputPort = inputPorts[KZerothPort];
		iSinkInputPort->MipSetObserver(*this);
		}		
	inputPorts.Close();
	if (err != KErrNone)
		{
		return err;
		}
	if (!iSinkInputPort)
		{
		return KErrNotFound;
		}

	
	err = iAudioDevicePU->GetOutputPorts(outputPorts);	
	if (err == KErrNone && outputPorts.Count() > 0)
		{
		iSourceOutputPort = outputPorts[KZerothPort];
		iSourceOutputPort->MopSetObserver(*this);
		}		
	outputPorts.Close();
	if (err != KErrNone)
		{
		return err;
		}
	if (!iCodecOutputPort)
		{
		return KErrNotFound;
		}
	
	iState = EProcessingUnitLoaded;
	return KErrNone;		
	}

/*
@see CMMFHwDevice::CustomInterface()
*/
TAny* CMdfHwDeviceAdapter::CustomInterface(TUid aInterfaceId)
	{
	if (aInterfaceId == KUidHwDeviceSetupInterface)
		{
		MMdfHwDeviceSetup* hwDeviceSetup = this;
		return hwDeviceSetup;
		}
	else if (aInterfaceId.iUid == KMmfPlaySettingsCustomInterface)
		{
		return iSinkInputPort->MipCustomInterface(aInterfaceId);
		}
	else if (aInterfaceId.iUid == KMmfRecordSettingsCustomInterface)
		{
		return iSourceOutputPort->MopCustomInterface(aInterfaceId);
		}
	else if (aInterfaceId == KUidCustomInterfaceDevSoundBitRate)
		{
		return iCodecPU->CustomInterface(aInterfaceId);
		}
	else		
		{
		return NULL;
		}
	}

/*
@see CMMFHwDevice::ThisHwBufferFilled()
*/
TInt CMdfHwDeviceAdapter::ThisHwBufferFilled(CMMFBuffer& aFillBufferPtr)
	{
	aFillBufferPtr.SetStatus(EFull);	
	iCodecInputPort->MipWriteData(aFillBufferPtr);
	return KErrNone;
	}

/*
@see CMMFHwDevice::ThisHwBufferEmptied()
*/
TInt CMdfHwDeviceAdapter::ThisHwBufferEmptied(CMMFBuffer& /*aEmptyBufferPtr*/)
	{
	if (iOutputBuffer->LastBuffer())
		{
		CMMFDataBuffer* buffer = static_cast <CMMFDataBuffer*> (iOutputBuffer);
		buffer->Data().SetLength(0);
		iHwDeviceObserver->EmptyThisHwBuffer(*iOutputBuffer);
		}
	else	
		{
		iCodecOutputPort->MopReadData(*iOutputBuffer);
		}
	return KErrNone;
	}

/*
@see CMMFHwDevice::SetConfig()
*/
TInt CMdfHwDeviceAdapter::SetConfig(TTaskConfig& aConfig)
	{
	TInt err = KErrNone;
	// Call to Configure the Codec PU
	TPuTaskConfig config(aConfig);
	err = iCodecInputPort->MipConfigure(config);
	if(err != KErrNone)
		{
		return err;
		}
	err = iCodecOutputPort->MopConfigure(config);
	if(err != KErrNone)
		{
		return err;
		}

	// configure the audio device
	err = iSinkInputPort->MipConfigure(config);
	if(err != KErrNone)
		{
		return err;
		}
	err = iSourceOutputPort->MopConfigure(config);
	if(err != KErrNone)
		{
		return err;
		}

	return KErrNone;
	}

/*
@see CMMFHwDevice::StopAndDeleteCodec()
*/
TInt CMdfHwDeviceAdapter::StopAndDeleteCodec()
	{	
	TInt stopError = Stop();
	TInt deleteError = DeleteCodec();

	if (stopError != KErrNone)
		{
		return stopError;
		}		
	else
		{
		return deleteError;
		}		
	}

/*
Unloads all Processing Units, and deletes any locally owned buffers.
State is set to EProcessingUnitLoaderLoaded.

@see CMMFHwDevice::DeleteCodec()
*/
TInt CMdfHwDeviceAdapter::DeleteCodec()
	{
	Stop();	
	if (iCodecPU)
		{
		iPuLoader->UnloadProcessingUnit(iCodecPU);		
		}		
	if (iAudioDevicePU)	
		{
		iPuLoader->UnloadProcessingUnit(iAudioDevicePU);		
		}	
	
	// CMdfHwDeviceAdapter does not own the I/O ports, which 
	// have been deleted at this point by UnloadProcessingUnit()
	iCodecInputPort = NULL;
	iCodecOutputPort = NULL;
	iSinkInputPort = NULL;
	iSourceOutputPort = NULL;	
		
	delete iInputBuffer;
	iInputBuffer = NULL;
	delete iOutputBuffer;
	iOutputBuffer = NULL;
	
	iState = EProcessingUnitLoaderLoaded;
	
	return KErrNone;
	}

/*
@see MMdfInputPortObserver::MipoWriteDataComplete()
*/
void CMdfHwDeviceAdapter::MipoWriteDataComplete(const MMdfInputPort* aInputPort,
	CMMFBuffer* aBuffer, TInt aErrorCode)
	{
	if(aErrorCode != KErrNone)
		{
		StopHwDevice(aErrorCode);
		}
	else
		{
		switch(iFuncCmd)
			{
			case EDevEncode:
				{				
				if(aInputPort == iCodecInputPort)
					{
					if(aBuffer->LastBuffer())
						{
						iCodecPU->Stop();
						}
					else
						{
						// if not the last buffer, then pass buffer back to source to get more data				
						iSourceOutputPort->MopReadData(*iInputBuffer);
						}
					}
				}
				break;
			case EDevDecode:
				{
				if(aInputPort == iCodecInputPort)
					{				
					if (!aBuffer->LastBuffer())
						{	
						// JW 22-05-06
						// if the PU is idle (having been Stopped) then
						// FillThisHwBuffer will cause a kern-exec,
						// as the DevSoundSession no longer has a buffer
						if(iState == EProcessingUnitExecuting) 
							{
							TInt err = iHwDeviceObserver->FillThisHwBuffer(*aBuffer);
							if(err != KErrNone)
								{
								StopHwDevice(err);
								}						
							}
						}
					}
				else // aInputPort == iSinkInputPort
					{
					if (!aBuffer->LastBuffer())
						{				
						if(iSinkInputPort->MipIsTunnelled())
							{
							// This callback shouldn't occur since it should be tunnelled with the sink input port
							StopHwDevice(KErrArgument);
							}
						else
							{
							iCodecOutputPort->MopReadData(*iOutputBuffer);
							}
						}
					}
				}
				break;
			case EDevNullFunc:
				// nothing at the moment, so fall through
			default:
				StopHwDevice(KErrNotSupported);	
			}
		}
	}

/*
@see MMdfInputPortObserver::MipoDisconnectTunnelComplete()
*/	
void CMdfHwDeviceAdapter::MipoDisconnectTunnelComplete(const MMdfInputPort* aInputPort, 
	TInt aErrorCode)
	{
	// The Inputport of the PcmCodecPu will no longer receive data.	
	if(aErrorCode == KErrNone)
		{
		if(aInputPort == iCodecInputPort)
			{
			iPCMPuMipoStopCompleted = ETrue;
			}
		else if(aInputPort == iSinkInputPort)
			{
			// This shouldn't be called!
			iHwDeviceObserver->Error(KErrNotFound);		
			}
		}
	else
		{
		iHwDeviceObserver->Error(aErrorCode);
		}	
	}

/*
@see MMdfInputPortObserver::MipoRestartTunnelComplete()
*/
void CMdfHwDeviceAdapter::MipoRestartTunnelComplete(const MMdfInputPort* /*aInputPort*/,
	TInt /*aErrorCode*/)
	{
	
	}
	
/*
@see MMdfOutputPortObserver::MopoReadDataComplete()
*/
void CMdfHwDeviceAdapter::MopoReadDataComplete(const MMdfOutputPort* aOutputPort, 
	CMMFBuffer* aBuffer, TInt aErrorCode)
	{
	if(aErrorCode != KErrNone)
		{
		StopHwDevice(aErrorCode);
		}
	else
		{
		switch(iFuncCmd)
			{
			case EDevEncode:
				{
				if(aOutputPort == iSourceOutputPort)
					{
					iCodecInputPort->MipWriteData(*aBuffer);
					}
				else // aPu == iCodecPU
					{
					TInt err = iHwDeviceObserver->EmptyThisHwBuffer(*aBuffer);
					if(err !=KErrNone)
						{
						StopHwDevice(err);
						}
					}
				}
				break;
			case EDevDecode:
				{
				if(aOutputPort == iCodecOutputPort)
					{
					if(iCodecOutputPort->MopIsTunnelled())
						{
						// This callback shouldn't occur since it should be tunnelled with the sink input port
						StopHwDevice(KErrArgument);
						}
					else
						{
						iSinkInputPort->MipWriteData(*aBuffer);
						}
					}
				}
				break;
			case EDevNullFunc:
				// nothing at the moment, so fall through
			default:
				StopHwDevice(KErrNotSupported);
			}		
		}
	}

/*
@see MMdfOutputPortObserver::MopoDisconnectTunnelComplete()
*/	
void CMdfHwDeviceAdapter::MopoDisconnectTunnelComplete(const MMdfOutputPort* aOutputPort,
	TInt aErrorCode)
	{
	if(!aOutputPort)
		{
		iHwDeviceObserver->Error(KErrArgument);
		return;
		}		
		
	// The last buffer has been set, and called back to MopoReadDataComplete
	if(aErrorCode != KErrNone)
		{
		iHwDeviceObserver->Error(aErrorCode);
		return;
		}	

	if(aOutputPort == iCodecOutputPort)
		{		
		iPCMPuMopoStopCompleted = ETrue;	
		}
	else if(aOutputPort == iSourceOutputPort)
		{
		iSourceSinkPuMopoStopCompleted = ETrue;
		}
	else
		{
		iHwDeviceObserver->Error(KErrArgument);
		return;
		}
			
	if(iPCMPuMipoStopCompleted && iPCMPuMopoStopCompleted && iSourceSinkPuMopoStopCompleted)
		{
		iHwDeviceObserver->Error(KErrNone);
		iState = EProcessingUnitIdle;
		}		
	}

/*
@see MMdfOutputPortObserver::MopoRestartTunnelComplete()
*/	
void CMdfHwDeviceAdapter::MopoRestartTunnelComplete(const MMdfOutputPort* /*aOutputPort*/,
	TInt /*aErrorCode*/)
	{
	
	}

/*
@see MMdfProcessingUnitObserver::InitializeComplete()
*/
void CMdfHwDeviceAdapter::InitializeComplete(const CMdfProcessingUnit* aPu, TInt aErrorCode)
	{
	iInitError = aErrorCode;
	if(aErrorCode != KErrNone)
		{
		// stop waiting on the active scheduler if we were doing so
		if (iState == EProcessingUnitInitializing)
			{
			// change state back to processing unit loaded
			iState = EProcessingUnitLoaded;
			iActiveWait->AsyncStop();
			}
		return;
		}
			
	if(aPu == iCodecPU)
		{
		iPCMPUCallbackComplete = ETrue;
		}
	else if(aPu == iAudioDevicePU)
		{
		iSourceSinkPUCallbackComplete = ETrue;
		}	

	if(iPCMPUCallbackComplete && iSourceSinkPUCallbackComplete)
		{
		// reset the flags
		iPCMPUCallbackComplete = EFalse;
		iSourceSinkPUCallbackComplete = EFalse;
		
		// Both PUs initialised OK
		if (iState == EProcessingUnitInitializing)
			{
			iActiveWait->AsyncStop();
			}
		iState = EProcessingUnitIdle;
		}
	}

/*
@see MMdfProcessingUnitObserver::ExecuteComplete()
*/
void CMdfHwDeviceAdapter::ExecuteComplete(const CMdfProcessingUnit* aPu, TInt aErrorCode)
	{
	if(iStopping)
		{
		return;
		}
		
	if (iExecuteError == KErrNone)
		{
		iExecuteError = aErrorCode;
		}
	 		
	if(aPu == iCodecPU)
		{
		iPCMPUCallbackComplete = ETrue;
		}
	else if(aPu == iAudioDevicePU)
		{
		iSourceSinkPUCallbackComplete = ETrue;
		}	

	if(iExecuteError != KErrNone || (iPCMPUCallbackComplete && iSourceSinkPUCallbackComplete))
		{
		if (iState == EProcessingUnitExecuting)
			{
			// stop the hardware device if we are still executing
			StopHwDevice(iExecuteError);		
			iState = EProcessingUnitIdle;
			}
		// reset the flags
		iPCMPUCallbackComplete = EFalse;
		iSourceSinkPUCallbackComplete = EFalse;					
		}
	}

/*
@see MMdfHwDeviceSetup::::SetDataTypesL()
*/
void CMdfHwDeviceAdapter::SetDataTypesL(TFourCC aSrcType, TFourCC aDestType)
	{
	// Find and load an appropriate Codec
	iCodecPU = iPuLoader->LoadProcessingUnitL(*this, aSrcType, aDestType);
	}

/*
Called to indicate that the Hardware Device has been stopped, leading
to callbacks to the observer. 
@see MMMFHwDeviceObserver::Stopped()
@see MMMFHwDeviceObserver::Error()
*/
void CMdfHwDeviceAdapter::StopHwDevice(TInt error)
	{
	iHwDeviceObserver->Stopped();
	iHwDeviceObserver->Error(error);		
	}

/*
Returns the state of the Hardware Device Adapter object.
*/
void CMdfHwDeviceAdapter::GetState(THwDevAdapterState& aState) const
	{
	aState = iState;	
	}