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

		}