// Copyright (c) 2006-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:

 // This is a re-implementation of CMdfHwDeviceCodecTestAdapter 

 // primarily intended for unit testing codec PUs in PREQ1024.

 // It is NOT a subclass, as CMdfHwDeviceCodecTestAdapter itself has no

 // virtual or protected methods to override.

 // The only difference is that it encodes and decodes from codec

 // to codec, unlike CMdfHwDeviceCodecTestAdapter which encodes from sounddev

 // (mic) to codec and decodes from codec to sounddev (speaker)

 // 

 //

 /**

  @file

  @internalComponent

 */

 #include "audiocodectestadapter.h"

 #include <mdf/codecapiuids.hrh>

 #include <mdf/mdfpuconfig.h>

 // for the bitrate custom interface

 #include <mmf/server/devsoundstandardcustominterfaces.h>

 #include <e32debug.h>

 // #define AUDIOCODECTESTADAPTER_DEBUG	1

 #if defined(AUDIOCODECTESTADAPTER_DEBUG)

 #define DEBUG_PRINT RDebug::Print

 #else

 #define DEBUG_PRINT

 #endif

 // Interface UID for the Processing Unit Loader

 const TUid KUidPuLoader = {KUidPuLoaderImplementation};

 CMdfHwDeviceCodecTestAdapter::~CMdfHwDeviceCodecTestAdapter()

 	{

 	Stop();

 	// Unload the PUs

 	if (iCodecPU)

 		{

 		iPuLoader->UnloadProcessingUnit(iCodecPU);

 		}

 	// The I/O ports should have been deleted at this point

 	delete iInputBuffer;

 	delete iOutputBuffer;		

 	delete iActiveWait;

 	delete iPuLoader;	

 	REComSession::DestroyedImplementation(iPuLoaderDtorKey);

 	}

 CMdfHwDeviceCodecTestAdapter* CMdfHwDeviceCodecTestAdapter::NewL()

 	{

 	CMdfHwDeviceCodecTestAdapter* self = new (ELeave) CMdfHwDeviceCodecTestAdapter;

 	CleanupStack::PushL (self);

 	self->ConstructL();

 	CleanupStack::Pop(self);

 	return self;

 	}

 CMdfHwDeviceCodecTestAdapter::CMdfHwDeviceCodecTestAdapter()

 	{	

 	}

 void CMdfHwDeviceCodecTestAdapter::ConstructL()

 	{		

 	// Load the PU Loader plugin

 	iPuLoader = static_cast<CMdfPuLoader*>

 		(REComSession::CreateImplementationL(KUidPuLoader, iPuLoaderDtorKey));

 	iActiveWait = new (ELeave) CActiveSchedulerWait;

 	iState = EProcessingUnitLoaderLoaded;

 	}	

 TInt CMdfHwDeviceCodecTestAdapter::Start(TDeviceFunc aFuncCmd, TDeviceFlow /*aFlowCmd*/)

 	{		

 	if (!((aFuncCmd == EDevEncode)|(aFuncCmd == EDevDecode)|(aFuncCmd == EDevNullFunc)))

 		{

 		return KErrArgument;	

 		}

 	iFuncCmd = aFuncCmd;

 	// NB: aFlowCmd not used - this is codec-codec processing by default.

 	TInt err = KErrNone;

 	switch(aFuncCmd)

 		{

 		case EDevEncode:

 			{

 			err = StartEncode();

 			}

 			break;

 		case EDevDecode:

 			{

 			err = StartDecode();

 			}

 			break;

 		case EDevNullFunc:

 		default:

 			{

 			err = KErrNotSupported;	

 			}		

 			break;

 		}

 	return err;

 	}

 // encode and decode logic is identical for codec-codec processing

 TInt CMdfHwDeviceCodecTestAdapter::InitializeEncodeDecode()

 	{

 	DEBUG_PRINT(_L("CMdfHwDeviceCodecTestAdapter::InitializeEncodeDecode"));

 	ASSERT(iOutputPort);

 	iInputPortBufferSize = iInputPort->MipBufferSize();	

 	TRAPD(err, iInputBuffer = CMMFDescriptorBuffer::NewL(iInputPortBufferSize));

 	if(err != KErrNone)

 		{

 		return err;

 		}

 	iInputBuffer->SetLastBuffer(EFalse);

 	iInputPort->MipUseBuffer(*iInputBuffer);	

 	iOutputPortBufferSize = iOutputPort->MopBufferSize();			

 	TRAP(err, iOutputBuffer = CMMFDescriptorBuffer::NewL(iOutputPortBufferSize));

 	if(err != KErrNone)

 		{

 		return err;

 		}	

 	iOutputBuffer->SetLastBuffer(EFalse);

 	iOutputPort->MopUseBuffer(*iOutputBuffer);		

 	// VD: should not move the set up of the state after sending the Initialize() calls???

 	iState = EProcessingUnitInitializing;

 	iCodecPU->Initialize();

 	iActiveWait->Start();

 	return KErrNone;

 	}

 TInt CMdfHwDeviceCodecTestAdapter::StartEncode()

 	{

 	DEBUG_PRINT(_L("CMdfHwDeviceCodecTestAdapter::StartEncode"));

 	TInt err = KErrNone;

 	if (iState == EProcessingUnitLoaded)

 		{

 		err = InitializeEncodeDecode();

 		}

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	return StartExecuting();	

 	}

 TInt CMdfHwDeviceCodecTestAdapter::StartDecode()

 	{

 	DEBUG_PRINT(_L("CMdfHwDeviceCodecTestAdapter::StartDecode"));

 	TInt err = KErrNone;

 	if (iState == EProcessingUnitLoaded)

 		{

 		err = InitializeEncodeDecode();

 		}

 	if (err != KErrNone)

 		{

 		return err;

 		}

 	return StartExecuting();	

 	}

 TInt CMdfHwDeviceCodecTestAdapter::StartExecuting()

 	{

 	DEBUG_PRINT(_L("CMdfHwDeviceCodecTestAdapter::StartExecuting"));

 	TInt err = KErrNone;

 	iOutputPort->MopReadData(*iOutputBuffer);	

 	err = iHwDeviceObserver->FillThisHwBuffer(*iInputBuffer);

 	if(err != KErrNone)

 		{

 		return err;

 		}

 	iState = EProcessingUnitExecuting;

 	iCodecPU->Execute();

 	return KErrNone;

 	}

 TInt CMdfHwDeviceCodecTestAdapter::Stop()

 	{	

 	if(iState == EProcessingUnitExecuting || iState == EProcessingUnitPaused)

 		{			

 		iStopping = ETrue; // is used as a guard in ExecuteComplete

 		if(iCodecPU)

 			{

 			iCodecPU->Stop();	

 			}

 		iPCMPUCallbackComplete = EFalse;		

 		iState = EProcessingUnitIdle;

 		iStopping = EFalse;	

 		}

 	return KErrNone;			

 	}

 TInt CMdfHwDeviceCodecTestAdapter::Pause()

 	{

 	return iCodecPU->Pause();

 	}

 TInt CMdfHwDeviceCodecTestAdapter::Init(THwDeviceInitParams& aDevInfo)

 	{

 	if(!iCodecPU)

 		{

 		return KErrNotSupported;

 		}

 	// Not currently using any other members of aDevInfo, except the Observer

 	if(!aDevInfo.iHwDeviceObserver)

 		{

 		return KErrArgument;

 		}

 	iHwDeviceObserver = aDevInfo.iHwDeviceObserver;

 	// Get ports and set observers

 	RPointerArray<MMdfInputPort> inputPorts;

 	TInt err = iCodecPU->GetInputPorts(inputPorts);

 	if(err != KErrNone)

 		{

 		return err;

 		}	

 	if (inputPorts.Count()<1)

 		{

 		return KErrNotFound;

 		}

 	iInputPort = inputPorts[0];

 	inputPorts.Close();

 	iInputPort->MipSetObserver(*this);

 	RPointerArray<MMdfOutputPort> outputPorts;

 	err = iCodecPU->GetOutputPorts(outputPorts);

 	if(err != KErrNone)

 		{

 		return err;

 		}	

 	if (outputPorts.Count()<1)

 		{

 		return KErrNotFound;

 		}

 	iOutputPort = outputPorts[0];

 	outputPorts.Close();

 	iOutputPort->MopSetObserver(*this);

 	iState = EProcessingUnitLoaded;

 	return KErrNone;		

 	}

 TAny* CMdfHwDeviceCodecTestAdapter::CustomInterface(TUid aInterfaceId)

 	{

 	if (aInterfaceId == KUidHwDeviceSetupInterface)

 		{

 		return static_cast<MMdfHwDeviceSetup*>(this);

 		}

 	else if (aInterfaceId.iUid == KMmfPlaySettingsCustomInterface)

 		{

 		return reinterpret_cast<MPlayCustomInterface*>(iInputPort);

 		}

 	else if (aInterfaceId.iUid == KMmfRecordSettingsCustomInterface)

 		{

 		return reinterpret_cast<MRecordCustomInterface*>(iOutputPort);

 		}

 	// if the PU is an encoder it may have a BitRate custom interface	

 	else if (aInterfaceId == KUidCustomInterfaceDevSoundBitRate)

 		{

 		return static_cast<MMMFDevSoundCustomInterfaceBitRate*>(iCodecPU->CustomInterface(aInterfaceId));

 		}

 	else	

 		{

 		return NULL;

 		}

 	}

 TInt CMdfHwDeviceCodecTestAdapter::ThisHwBufferFilled(CMMFBuffer& aFillBufferPtr)

 	{		

 	DEBUG_PRINT(_L("CMdfHwDeviceCodecTestAdapter::ThisHwBufferFilled"));

 	aFillBufferPtr.SetStatus(EFull); 

 	// if the buffer is empty or the last buffer, write it anyway -

 	// the stop / error will be generated elsewhere

 	iInputPort->MipWriteData(aFillBufferPtr);

 	return KErrNone;

 	}

 TInt CMdfHwDeviceCodecTestAdapter::ThisHwBufferEmptied(CMMFBuffer& /*aEmptyBufferPtr*/)

 	{

 	DEBUG_PRINT(_L("CMdfHwDeviceCodecTestAdapter::ThisHwBufferEmptied"));

 	iOutputPort->MopReadData(*iOutputBuffer);

 	return KErrNone;

 	}

 TInt CMdfHwDeviceCodecTestAdapter::SetConfig(TTaskConfig& aConfig)

 	{

 	TInt err = KErrNone;

 	// Call to Configure the Codec PU

 	TPuTaskConfig config(aConfig);

 	err = iInputPort->MipConfigure(config);

 	if(err != KErrNone)

 		{

 		return err;

 		}

 	err = iOutputPort->MopConfigure(config);

 	if(err != KErrNone)

 		{

 		return err;

 		}

 //	iState = EProcessingUnitConfigured;

 	return KErrNone;

 	}

 TInt CMdfHwDeviceCodecTestAdapter::StopAndDeleteCodec()

 	{

 	return KErrNone;

 	}

 TInt CMdfHwDeviceCodecTestAdapter::DeleteCodec()

 	{

 	return KErrNone;

 	}

 void CMdfHwDeviceCodecTestAdapter::MipoWriteDataComplete(const MMdfInputPort* aInputPort,

 	CMMFBuffer* aBuffer, TInt aErrorCode)

 	{

 	DEBUG_PRINT(_L("CMdfHwDeviceCodecTestAdapter::MipoWriteDataComplete"));

 	if (aErrorCode == KErrNone && aInputPort == iInputPort)

 		{

 		if(aBuffer->LastBuffer())

 			{

 			if(iFuncCmd == EDevEncode) 

 				{

 				// we must cancel the PU here if it's an encoder - the decoder

 				// will be done elsewhere

 				iCodecPU->Stop();

 				}

 			}

 		else

 			{

 			iHwDeviceObserver->FillThisHwBuffer(*aBuffer);

 			}

 		}

 	else

 		{

 		StopHwDevice(aErrorCode);

 		}		

 	}

 void CMdfHwDeviceCodecTestAdapter::MipoDisconnectTunnelComplete(const MMdfInputPort* aInputPort, 

 	TInt aErrorCode)

 	{

 	// The Inputport of the PcmCodecPu will no longer receive data.

 	// Set flag to indicate that the sink outputport has been stopped?

 	if(aErrorCode == KErrNone)

 		{

 		if(aInputPort == iInputPort)

 			{

 			iPCMPuMipoStopCompleted = ETrue;

 			}

 		}

 	else

 		{

 		iHwDeviceObserver->Error(aErrorCode);

 		}	

 	}

 void CMdfHwDeviceCodecTestAdapter::MipoRestartTunnelComplete(const MMdfInputPort* /*aInputPort*/,

 	TInt /*aErrorCode*/)

 	{

 	}

 void CMdfHwDeviceCodecTestAdapter::MopoReadDataComplete(const MMdfOutputPort* aOutputPort, 

 	CMMFBuffer* aBuffer, TInt aErrorCode)

 	{

 	DEBUG_PRINT(_L("CMdfHwDeviceCodecTestAdapter::MopoReadDataComplete"));

 	if(aErrorCode == KErrNone && aOutputPort == iOutputPort)

 		{

 		iHwDeviceObserver->EmptyThisHwBuffer(*aBuffer);

 		}

 	else

 		{

 		StopHwDevice(aErrorCode);

 		}

 	}

 void CMdfHwDeviceCodecTestAdapter::MopoDisconnectTunnelComplete(const MMdfOutputPort* aOutputPort,

 	TInt aErrorCode)

 	{

 	if(aErrorCode == KErrNone)

 		{

 		if(aOutputPort == iOutputPort)

 			{

 			iPCMPuMopoStopCompleted = ETrue;			

 			}

 		}

 	else

 		{

 		iHwDeviceObserver->Error(aErrorCode);

 		}

 	if(iPCMPuMipoStopCompleted && iPCMPuMopoStopCompleted)

 		{

 		iState = EProcessingUnitIdle;

 		}		

 	}

 void CMdfHwDeviceCodecTestAdapter::MopoRestartTunnelComplete(const MMdfOutputPort* /* aOutputPort */,

 	TInt /*aErrorCode*/)

 	{

 	}

 void CMdfHwDeviceCodecTestAdapter::InitializeComplete(const CMdfProcessingUnit* aPu, TInt aErrorCode)

 	{

 	if(aErrorCode != KErrNone)

 		{

 		iHwDeviceObserver->Error(aErrorCode);

 		return;

 		}

 	if(aPu == iCodecPU)

 		{

 		iPCMPUCallbackComplete = ETrue;

 		}

 	if(iPCMPUCallbackComplete)

 		{

 		// reset the flags

 		iPCMPUCallbackComplete = EFalse;

 		// PUs initialised OK

 		iActiveWait->AsyncStop();

 		}

 	}

 void CMdfHwDeviceCodecTestAdapter::ExecuteComplete(const CMdfProcessingUnit* aPu, TInt aErrorCode)

 	{

 	if(iStopping)

 		{

 		return;

 		}

 	if (iExecuteError == KErrNone)

 		{

 		iExecuteError = aErrorCode;

 		}

 	if(aPu == iCodecPU)

 		{

 		iPCMPUCallbackComplete = ETrue;

 		}

 	if(iExecuteError != KErrNone || (iPCMPUCallbackComplete) )

 		{

 		if (iState == EProcessingUnitExecuting)

 			{

 			// stop the hardware device if we are still executing

 			StopHwDevice(iExecuteError);		

 			iState = EProcessingUnitIdle;

 			}

 		// reset the flags

 		iPCMPUCallbackComplete = EFalse;

 		}

 	}

 void CMdfHwDeviceCodecTestAdapter::SetDataTypesL(TFourCC aSrcType, TFourCC aDestType)

 	{

 	// Find and load an appropriate Codec

 	iCodecPU = iPuLoader->LoadProcessingUnitL(*this, aSrcType, aDestType);

 	}

 void CMdfHwDeviceCodecTestAdapter::StopHwDevice(TInt error)

 	{

 	iHwDeviceObserver->Stopped();

 	iHwDeviceObserver->Error(error);		

 	}

 void CMdfHwDeviceCodecTestAdapter::GetState(THwDevAdapterState& aState) const

 	{

 	aState = iState;	

 	}