// Copyright (c) 2007-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 <ecom/implementationproxy.h>

#include <ecom/implementationproxy.h>

#include <ecom/ecom.h>

#include "eaacplusdecoderci.h"

// MUX //

/*****************************************************************************/

TInt CMMFEAacPlusDecoderMux::OpenInterface(TUid /*aInterfaceId*/)

	{

	// attempt to open the interface link with the

	// remote slave device

	iRemoteHandle = -1;

	TUid slaveId = {KMmfUidCustomInterfaceEAacPlusDecoderDeMux};

	TInt handle = iUtility->OpenSlave(slaveId, KNullDesC8);

	if (handle >= 0)

		{

		iRemoteHandle = handle;

		}

	return iRemoteHandle;

	}

/*****************************************************************************/

void CMMFEAacPlusDecoderMux::Release()

	{

	// close the slave device if it exists

	if (iRemoteHandle > 0)

		{

		// we assume the slave is closed correctly

		iUtility->CloseSlave(iRemoteHandle);

		}

	TUid key = iDestructorKey;

	delete this;

	// tell ECom to destroy us

	REComSession::DestroyedImplementation(key);

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderMux::PassDestructorKey(TUid aDestructorKey)

	{

	// store the destructor key

	iDestructorKey = aDestructorKey;

	}

/*****************************************************************************/

void CMMFEAacPlusDecoderMux::CompleteConstructL(MMMFDevSoundCustomInterfaceMuxUtility* aCustomUtility)

	{

	// store a pointer to the utility

	iUtility = aCustomUtility;

	}

/*****************************************************************************/	

MMMFDevSoundCustomInterfaceMuxPlugin* CMMFEAacPlusDecoderMux::NewL()

	{

	CMMFEAacPlusDecoderMux* self = new (ELeave) CMMFEAacPlusDecoderMux;

	return self;

	}

/*****************************************************************************/	

TAny* CMMFEAacPlusDecoderMux::CustomInterface(TUid /*aInterfaceId*/)

	{

	MEAacPlusDecoderIntfc* interface = this;

	return interface;

	}

/*****************************************************************************/

CMMFEAacPlusDecoderMux::CMMFEAacPlusDecoderMux() :

	iRemoteHandle(-1)

	{	

	}

/*****************************************************************************/

CMMFEAacPlusDecoderMux::~CMMFEAacPlusDecoderMux()

	{	

	}

/*****************************************************************************/

// from MEAacPlusDecoderIntfc

void CMMFEAacPlusDecoderMux::SetInputSamplingFrequency(TUint aInputSamplingFrequency)

	{

	if (iRemoteHandle > 0)

		{

		// send the frequency in the sync command

		TPckgBuf<TUint> freqBuffer(aInputSamplingFrequency);

		// No way of reporting an error message so ignore the return value from SendSlaveSyncCommand

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCIEAacPlusDecoderSetInputSamplingFrequency,

										freqBuffer);

		}

	}

void CMMFEAacPlusDecoderMux::SetAudioObjectType(MEAacPlusDecoderIntfc::TAudioObjectType aAudioObjectType)

	{

	if (iRemoteHandle > 0)

		{

		// send the object type in the sync command

		TPckgBuf<MEAacPlusDecoderIntfc::TAudioObjectType> objTypeBuffer(aAudioObjectType);

		// No way of reporting an error message so ignore the return value from SendSlaveSyncCommand

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCIEAacPlusDecoderSetAudioObjectType,

										objTypeBuffer);

		}

	}

void CMMFEAacPlusDecoderMux::SetNumOfChannels(TUint aNumOfChannels)

	{

	if (iRemoteHandle > 0)

		{

		// send the number of channels in the sync command

		TPckgBuf<TUint> numBuffer(aNumOfChannels);

		// No way of reporting an error message so ignore the return value from SendSlaveSyncCommand

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCIEAacPlusDecoderSetNumOfChannels,

										numBuffer);

		}

	}

void CMMFEAacPlusDecoderMux::SetSbr(TBool aSbrEnabled)

	{

	if (iRemoteHandle > 0)

		{

		// send the SBR enabled flag in the sync command

		TPckgBuf<TBool> flagBuffer(aSbrEnabled);

		// No way of reporting an error message so ignore the return value from SendSlaveSyncCommand

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCIEAacPlusDecoderSetSbr,

										flagBuffer);

		}

	}

void CMMFEAacPlusDecoderMux::SetDownSampledMode(TBool aDsmEnabled)

	{

	if (iRemoteHandle > 0)

		{

		// send the DSM enabled flag in the sync command

		TPckgBuf<TBool> flagBuffer(aDsmEnabled);

		// No way of reporting an error message so ignore the return value from SendSlaveSyncCommand

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCIEAacPlusDecoderSetDownSampledMode,

										flagBuffer);

		}

	}

TInt CMMFEAacPlusDecoderMux::ApplyConfig()

	{

	TInt retVal = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		retVal = iUtility->SendSlaveSyncCommand(iRemoteHandle,

												EMMFDevSoundCIEAacPlusDecoderApplyConfig,

												KNullDesC8);

		}

	return retVal;

	}

TInt CMMFEAacPlusDecoderMux::GetInputSamplingFrequency(TUint& aInputSamplingFrequency)

	{

	TInt result = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TUint> freqBuffer;

		result = iUtility->SendSlaveSyncCommandResult(iRemoteHandle,

													  EMMFDevSoundCIEAacPlusDecoderGetInputSamplingFrequency,

													  KNullDesC8,

													  freqBuffer);

		aInputSamplingFrequency = freqBuffer();

		}

	return result;

	}

TInt CMMFEAacPlusDecoderMux::GetAudioObjectType(MEAacPlusDecoderIntfc::TAudioObjectType& aAudioObjectType)

	{

	TInt result = KErrNotReady;

	if (iRemoteHandle > 0) 

		{

		TPckgBuf<MEAacPlusDecoderIntfc::TAudioObjectType> objTypeBuffer;

		result = iUtility->SendSlaveSyncCommandResult(iRemoteHandle,

													  EMMFDevSoundCIEAacPlusDecoderGetAudioObjectType,

													  KNullDesC8,

													  objTypeBuffer);

		aAudioObjectType = objTypeBuffer();

		}

	return result;

	}

TInt CMMFEAacPlusDecoderMux::GetNumOfChannels(TUint& aNumOfChannels)

	{

	TInt result = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TUint> channelsBuffer;

		result = iUtility->SendSlaveSyncCommandResult(iRemoteHandle,

													  EMMFDevSoundCIEAacPlusDecoderGetNumOfChannels,

													  KNullDesC8,

													  channelsBuffer);

		aNumOfChannels = channelsBuffer();

		}

	return result;

	}

TInt CMMFEAacPlusDecoderMux::GetSbr(TBool& aSbrEnabled)

	{

	TInt result = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TBool> flagBuffer;

		result = iUtility->SendSlaveSyncCommandResult(iRemoteHandle,

													  EMMFDevSoundCIEAacPlusDecoderGetSbr,

													  KNullDesC8,

													  flagBuffer);

		aSbrEnabled = flagBuffer();

		}

	return result;

	}

TInt CMMFEAacPlusDecoderMux::GetDownSampledMode(TBool& aDsmEnabled)

	{

	TInt result = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TBool> flagBuffer;

		result = iUtility->SendSlaveSyncCommandResult(iRemoteHandle,

													  EMMFDevSoundCIEAacPlusDecoderGetDownSampledMode,

													  KNullDesC8,

													  flagBuffer);

		aDsmEnabled = flagBuffer();

		}

	return result;

	}

// DEMUX //	

/*****************************************************************************/

TInt CMMFEAacPlusDecoderDeMux::OpenInterface(TUid /*aInterfaceId*/)

	{

	return KErrNone;

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::Release()

	{

	TUid key = iDestructorKey;

	delete this;

	// tell ECom to destroy us

	REComSession::DestroyedImplementation(key);

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::PassDestructorKey(TUid aDestructorKey)

	{

	// store the destructor key

	iDestructorKey = aDestructorKey;

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::SetInterfaceTarget(MMMFDevSoundCustomInterfaceTarget* aTarget)

	{

	iTarget = aTarget;

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::CompleteConstructL(MMMFDevSoundCustomInterfaceDeMuxUtility* aCustomUtility)

	{

	// store a pointer to the utility

	iUtility = aCustomUtility;

	}

/*****************************************************************************/

void CMMFEAacPlusDecoderDeMux::RefreshL()

	{

	// refetch the EAAC+ decoder custom interface if we already have a target

	if (iTarget)

		{

		iInterfaceEAacPlusDecoder = static_cast <MEAacPlusDecoderIntfc*> (iTarget->CustomInterface(KUidEAacPlusDecoderIntfc));

		if (!iInterfaceEAacPlusDecoder)

			{

			User::Leave(KErrNotSupported);

			}

		}

	}

/*****************************************************************************/

MMMFDevSoundCustomInterfaceDeMuxPlugin* CMMFEAacPlusDecoderDeMux::NewL()

	{

	CMMFEAacPlusDecoderDeMux* self = new (ELeave) CMMFEAacPlusDecoderDeMux;

	return self;

	}

/*****************************************************************************/	

CMMFEAacPlusDecoderDeMux::CMMFEAacPlusDecoderDeMux()

	{	

	}

/*****************************************************************************/

CMMFEAacPlusDecoderDeMux::~CMMFEAacPlusDecoderDeMux()

	{

	}

/*****************************************************************************/

TInt CMMFEAacPlusDecoderDeMux::DoOpenSlaveL(TUid /*aInterface*/, const TDesC8& /*aPackageBuf*/)

	{

	// fetch the EAAC+ decoder Hw Device custom interface

	iInterfaceEAacPlusDecoder = static_cast<MEAacPlusDecoderIntfc*> (iTarget->CustomInterface(KUidEAacPlusDecoderIntfc)); 

	if (!iInterfaceEAacPlusDecoder)

		{

		User::Leave(KErrNotSupported);

		}

	return KErrNone;

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::DoCloseSlaveL(TInt /*aHandle*/)

	{

	// nothing to do

	}

/*****************************************************************************/

// original RMessage is supplied so that remote demux plugin can extract necessary details

// using DeMux utility

TInt CMMFEAacPlusDecoderDeMux::DoSendSlaveSyncCommandL(const RMmfIpcMessage& aMessage)

	{

	TMMFDevSoundCIMessageData data;

	// decode message

	iUtility->GetSyncMessageDataL(aMessage, data);

	TInt retVal = -1;

	switch (data.iCommand)

		{

		case EMMFDevSoundCIEAacPlusDecoderSetInputSamplingFrequency:

			{

			TPckgBuf<TUint> freqBuffer;

			iUtility->ReadFromInputDesL(aMessage, &freqBuffer);

			DoSetInputSamplingFrequency(freqBuffer());

			retVal = KErrNone;

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderSetAudioObjectType:

			{

			TPckgBuf<MEAacPlusDecoderIntfc::TAudioObjectType> audioObjectTypeBuffer;

			iUtility->ReadFromInputDesL(aMessage, &audioObjectTypeBuffer);

			DoSetAudioObjectType(audioObjectTypeBuffer());

			retVal = KErrNone;

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderSetNumOfChannels:

			{

			TPckgBuf<TUint> numChannelsBuffer;

			iUtility->ReadFromInputDesL(aMessage, &numChannelsBuffer);

			DoSetNumOfChannels(numChannelsBuffer());

			retVal = KErrNone;

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderSetSbr:

			{

			TPckgBuf<TBool> flagBuffer;

			iUtility->ReadFromInputDesL(aMessage, &flagBuffer);

			DoSetSbr(flagBuffer());

			retVal = KErrNone;

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderSetDownSampledMode:

			{

			TPckgBuf<TBool> flagBuffer;

			iUtility->ReadFromInputDesL(aMessage, &flagBuffer);

			DoSetDownSampledMode(flagBuffer());

			retVal = KErrNone;

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderApplyConfig:

			{

			retVal = DoApplyConfig();

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			}		

		};

	return retVal;

	}

/*****************************************************************************/	

TInt CMMFEAacPlusDecoderDeMux::DoSendSlaveSyncCommandResultL(const RMmfIpcMessage& aMessage)

	{

	TMMFDevSoundCIMessageData data;

	// decode message

	iUtility->GetSyncMessageDataL(aMessage, data);

	TInt retVal = -1;

	switch (data.iCommand)

		{

		case EMMFDevSoundCIEAacPlusDecoderGetInputSamplingFrequency:

			{

			TPckgBuf<TUint> freqBuf;

			retVal = DoGetInputSamplingFrequency(freqBuf());

			iUtility->WriteToOutputDesL(aMessage, freqBuf);		

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderGetAudioObjectType:

			{

			TPckgBuf<MEAacPlusDecoderIntfc::TAudioObjectType> objTypeBuf;

			retVal = DoGetAudioObjectType(objTypeBuf());

			iUtility->WriteToOutputDesL(aMessage, objTypeBuf);		

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderGetNumOfChannels:

			{

			TPckgBuf<TUint> channelsBuf;

			retVal = DoGetNumOfChannels(channelsBuf());

			iUtility->WriteToOutputDesL(aMessage, channelsBuf);		

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderGetSbr:

			{

			TPckgBuf<TBool> flagBuf;

			retVal = DoGetSbr(flagBuf());

			iUtility->WriteToOutputDesL(aMessage, flagBuf);		

			break;

			}

		case EMMFDevSoundCIEAacPlusDecoderGetDownSampledMode:

			{

			TPckgBuf<TBool> flagBuf;

			retVal = DoGetDownSampledMode(flagBuf());

			iUtility->WriteToOutputDesL(aMessage, flagBuf);		

			break;

			}

		default:

			{

			User::Leave(KErrNotSupported);

			}

		}

	return retVal;

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::DoSendSlaveAsyncCommandL(const RMmfIpcMessage& /*aMessage*/)

	{

	// not used in this interface

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::DoSendSlaveAsyncCommandResultL(const RMmfIpcMessage& /*aMessage*/)

	{

	// not used in this interface

	}

/*****************************************************************************/

// EAAC+ Decoder custom interface implementation

void CMMFEAacPlusDecoderDeMux::DoSetInputSamplingFrequency(TUint aInputSamplingFrequency)

	{

	if (iInterfaceEAacPlusDecoder)

		{

		iInterfaceEAacPlusDecoder->SetInputSamplingFrequency(aInputSamplingFrequency);

		}

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::DoSetAudioObjectType(MEAacPlusDecoderIntfc::TAudioObjectType aAudioObjectType)

	{

	if (iInterfaceEAacPlusDecoder)

		{

		iInterfaceEAacPlusDecoder->SetAudioObjectType(aAudioObjectType);

		}		

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::DoSetNumOfChannels(TUint aNumOfChannels)

	{

	if (iInterfaceEAacPlusDecoder)

		{

		iInterfaceEAacPlusDecoder->SetNumOfChannels(aNumOfChannels);

		}		

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::DoSetSbr(TBool aSbrEnabled)

	{

	if (iInterfaceEAacPlusDecoder)

		{

		iInterfaceEAacPlusDecoder->SetSbr(aSbrEnabled);

		}		

	}

/*****************************************************************************/	

void CMMFEAacPlusDecoderDeMux::DoSetDownSampledMode(TBool aDsmEnabled)

	{

	if (iInterfaceEAacPlusDecoder)

		{

		iInterfaceEAacPlusDecoder->SetDownSampledMode(aDsmEnabled);

		}		

	}

/*****************************************************************************/