// 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 <s32mem.h>

#include "sbcencoderci.h"

class TBitpoolRange

	{

public:

	TUint iMin;

	TUint iMax;

	};

// MUX //

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

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

	{

	// attempt to open the interface link with the

	// remote slave device

	iRemoteHandle = -1;

	TUid slaveId = {KMmfUidCustomInterfaceSbcEncoderDeMux};

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

	if (handle >= 0)

		{

		iRemoteHandle = handle;

		}

	return iRemoteHandle;

	}

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

void CMMFSbcEncoderMux::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 CMMFSbcEncoderMux::PassDestructorKey(TUid aDestructorKey)

	{

	// store the destructor key

	iDestructorKey = aDestructorKey;

	}

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

void CMMFSbcEncoderMux::CompleteConstructL(MMMFDevSoundCustomInterfaceMuxUtility* aCustomUtility)

	{

	// store a pointer to the utility

	iUtility = aCustomUtility;

	}

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

MMMFDevSoundCustomInterfaceMuxPlugin* CMMFSbcEncoderMux::NewL()

	{

	CMMFSbcEncoderMux* self = new (ELeave) CMMFSbcEncoderMux;

	return self;

	}

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

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

	{

	MSbcEncoderIntfc* interface = this;

	return interface;

	}

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

CMMFSbcEncoderMux::CMMFSbcEncoderMux() :

	iRemoteHandle(-1)

	{	

	}

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

CMMFSbcEncoderMux::~CMMFSbcEncoderMux()

	{	

	}

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

// from MSbcEncoderIntfc

TInt CMMFSbcEncoderMux::GetSupportedBitpoolRange(TUint& aMinSupportedBitpoolSize, TUint& aMaxSupportedBitpoolSize)

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TBitpoolRange range;

		range.iMax = 0;

		range.iMin = 0;

		TPckgBuf<TBitpoolRange> rangeBuffer(range);

		err = iUtility->SendSlaveSyncCommandResult( iRemoteHandle,

													EMMFDevSoundCISbcEncoderGetSupportedBitpoolRange,

													KNullDesC8,

													rangeBuffer);

		if (err == KErrNone)	

			{

			aMinSupportedBitpoolSize = rangeBuffer().iMin;

			aMaxSupportedBitpoolSize = rangeBuffer().iMax;

			}

		}

	return err;

	}

void CMMFSbcEncoderMux::SetSamplingFrequency(TUint aSamplingFrequency)

	{

	if (iRemoteHandle > 0)

		{

		// send the frequency in the sync command

		TPckgBuf<TUint> freqBuffer(aSamplingFrequency);

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

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCISbcEncoderSetSamplingFrequency,

										freqBuffer);

		}

	}

void CMMFSbcEncoderMux::SetChannelMode (TSbcChannelMode aChannelMode)

	{

	if (iRemoteHandle > 0)

		{

		// send the channel mode in the sync command

		TPckgBuf<MSbcEncoderIntfc::TSbcChannelMode> channelModeBuffer(aChannelMode);

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

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCISbcEncoderSetChannelMode,

										channelModeBuffer);

		}

	}

void CMMFSbcEncoderMux::SetNumOfSubbands ( TUint aNumOfSubbands )

	{

	if (iRemoteHandle > 0)

		{

		// send the number of subbands in the sync command

		TPckgBuf<TUint> numBuffer(aNumOfSubbands);

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

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCISbcEncoderSetSubbands,

										numBuffer);

		}

	}

void CMMFSbcEncoderMux::SetNumOfBlocks ( TUint aNumOfBlocks )

	{

	if (iRemoteHandle > 0)

		{

		// send the number of blocks in the sync command

		TPckgBuf<TUint> blocksBuffer(aNumOfBlocks);

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

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCISbcEncoderSetBlocks,

										blocksBuffer);

		}

	}

void CMMFSbcEncoderMux::SetAllocationMethod (TSbcAllocationMethod aAllocationMethod )

	{

	if (iRemoteHandle > 0)

		{

		// send the allocation method in the sync command

		TPckgBuf<TSbcAllocationMethod> allocMethodBuffer(aAllocationMethod);

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

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCISbcEncoderSetAllocationMethod,

										allocMethodBuffer);

		}

	}

void CMMFSbcEncoderMux::SetBitpoolSize (TUint aBitpoolSize )

	{

	if (iRemoteHandle > 0)

		{

		// send the bitpool size in the sync command

		TPckgBuf<TUint> sizeBuffer(aBitpoolSize);

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

		iUtility->SendSlaveSyncCommand( iRemoteHandle,

										EMMFDevSoundCISbcEncoderSetBitpoolSize,

										sizeBuffer);

		}

	}

TInt CMMFSbcEncoderMux::ApplyConfig()

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		err = iUtility->SendSlaveSyncCommand(iRemoteHandle,

												EMMFDevSoundCISbcEncoderApplyConfig,

												KNullDesC8);

		}

	return err;

	}

TInt CMMFSbcEncoderMux::GetSamplingFrequency(TUint& aSamplingFrequency)

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TUint> freqBuffer;		

		err = iUtility->SendSlaveSyncCommandResult(	iRemoteHandle, 

													EMMFDevSoundCISbcEncoderGetSamplingFrequency, 

													KNullDesC8,

													freqBuffer);

		if (err == KErrNone)

			{

			aSamplingFrequency = freqBuffer();

			}

		}

	return err;

	}

TInt CMMFSbcEncoderMux::GetNumOfSubbands (TUint& aNumOfSubbands )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TUint> sizeBuffer;

		err = iUtility->SendSlaveSyncCommandResult(	iRemoteHandle, 

													EMMFDevSoundCISbcEncoderGetSubbands, 

													KNullDesC8,

													sizeBuffer);

		if (err == KErrNone)

			{

			aNumOfSubbands = sizeBuffer();

			}

		}

	return err;

	}

TInt CMMFSbcEncoderMux::GetNumOfBlocks (TUint& aNumOfBlocks )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TUint> blocksBuffer;

		err = iUtility->SendSlaveSyncCommandResult(	iRemoteHandle, 

													EMMFDevSoundCISbcEncoderGetBlocks, 

													KNullDesC8,

													blocksBuffer);

		if (err == KErrNone)

			{

			aNumOfBlocks = blocksBuffer();

			}

		}

	return err;

	}

TInt CMMFSbcEncoderMux::GetAllocationMethod (TSbcAllocationMethod& aAllocationMethod )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TSbcAllocationMethod> allocMethodBuffer;

		err = iUtility->SendSlaveSyncCommandResult(	iRemoteHandle, 

													EMMFDevSoundCISbcEncoderGetAllocationMethod, 

													KNullDesC8,

													allocMethodBuffer);

		if (err == KErrNone)

			{

			aAllocationMethod = allocMethodBuffer();

			}

		}

	return err;

	}	

TInt CMMFSbcEncoderMux::GetBitpoolSize (TUint& aBitpoolSize )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TUint> sizeBuffer;

		err = iUtility->SendSlaveSyncCommandResult(	iRemoteHandle, 

													EMMFDevSoundCISbcEncoderGetBitpoolSize, 

													KNullDesC8,

													sizeBuffer);

		if (err == KErrNone)

			{

			aBitpoolSize = sizeBuffer();

			}

		}

	return err;	

	}

TInt CMMFSbcEncoderMux::GetChannelMode(TSbcChannelMode& aChannelMode)

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		TPckgBuf<TSbcChannelMode> channelModeBuffer;

		err = iUtility->SendSlaveSyncCommandResult(	iRemoteHandle, 

													EMMFDevSoundCISbcEncoderGetChannelMode, 

													KNullDesC8,

													channelModeBuffer);

		if (err == KErrNone)

			{

			aChannelMode = channelModeBuffer();

			}

		}

	return err;	

	}

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

TInt CMMFSbcEncoderMux::GetSupportedSamplingFrequencies (RArray<TUint>& aSamplingFrequencies )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		// Clear the array

		aSamplingFrequencies.Reset();

		// Fetch the count

		TInt count = -1;

		count = iUtility->SendSlaveSyncCommand(iRemoteHandle,

												EMMFDevSoundCISbcEncoderGetSupportedSamplingFrequenciesCount,

												KNullDesC8);

		if (count < 0)

			{

			err = count;

			}

		else if (count > 0)

			{

			TRAP(err, DoGetTUintArrayL( aSamplingFrequencies,

										count,

										EMMFDevSoundCISbcEncoderGetSupportedSamplingFrequenciesArray));

			}

		else

			{

			// count == 0, nothing to do and no error...

			err = KErrNone;

			}

		}

	return err;

	}

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

TInt CMMFSbcEncoderMux::GetSupportedChannelModes (RArray<TSbcChannelMode>& aChannelModes )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		// Clear the array

		aChannelModes.Reset();

		// Fetch the count

		TInt count = -1;

		count = iUtility->SendSlaveSyncCommand(iRemoteHandle,

												EMMFDevSoundCISbcEncoderGetSupportedChannelModesCount,

												KNullDesC8);

		if (count < 0)

			{

			err = count;

			}

		else if (count > 0)

			{

			TRAP(err, DoGetChannelModesArrayL(aChannelModes, count));

			}

		else

			{

			// count == 0, nothing to do and no error...

			err = KErrNone;

			}

		}	

	return err;

	}

void CMMFSbcEncoderMux::DoGetChannelModesArrayL(RArray<TSbcChannelMode>& aChannelModes, TInt aCount)

	{

	// allocate a temporary buffer to hold the channel modes

	HBufC8* buf = HBufC8::NewLC(aCount * sizeof(TSbcChannelMode));

	TPtr8 ptr = buf->Des();

	// fetch the channel modes - but send over the received count to be sure

	TPckgBuf<TInt> countBuf(aCount);

	User::LeaveIfError(iUtility->SendSlaveSyncCommandResult(iRemoteHandle, 

															EMMFDevSoundCISbcEncoderGetSupportedChannelModesArray,

															countBuf, ptr));

	// stream data into the pointer

	RDesReadStream stream(ptr);

	CleanupClosePushL(stream);

	TInt err = KErrNone;

	TSbcChannelMode mode;

	for (TInt i = 0; i < aCount; i++)

		{

		// note we don't destroy array because we don't own it

		// but we do reset it as it is incomplete

		mode = static_cast<TSbcChannelMode>(stream.ReadInt32L());

		err = aChannelModes.Append(mode);

		if (err != KErrNone)

			{

			aChannelModes.Reset();

			User::Leave(KErrCorrupt);

			}

		}

	CleanupStack::PopAndDestroy(2, buf);// stream, buf

	}

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

TInt CMMFSbcEncoderMux::GetSupportedNumOfSubbands (RArray<TUint>& aNumOfSubbands )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		// Clear the array

		aNumOfSubbands.Reset();

		// Fetch the count

		TInt count = -1;

		count = iUtility->SendSlaveSyncCommand(iRemoteHandle,

												EMMFDevSoundCISbcEncoderGetSupportedSubbandsCount,

												KNullDesC8);

		if (count < 0)

			{

			err = count;

			}

		else if (count > 0)

			{

			TRAP(err, DoGetTUintArrayL(aNumOfSubbands, count, EMMFDevSoundCISbcEncoderGetSupportedSubbandsArray));

			}

		else

			{

			// count == 0, nothing to do and no error...

			err = KErrNone;

			}

		}

	return err;	

	}

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

TInt CMMFSbcEncoderMux::GetSupportedAllocationMethods (RArray<TSbcAllocationMethod>& aAllocationMethods )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		// Clear the array

		aAllocationMethods.Reset();

		// Fetch the count

		TInt count = -1;

		count = iUtility->SendSlaveSyncCommand(iRemoteHandle,

												EMMFDevSoundCISbcEncoderGetSupportedAllocationMethodsCount,

												KNullDesC8);

		if (count < 0)

			{

			err = count;

			}

		else if (count > 0)

			{

			TRAP(err, DoGetAllocMethodsArrayL(aAllocationMethods, count));

			}

		else

			{

			// count == 0, nothing to do and no error...

			err = KErrNone;

			}

		}

	return err;

	}

void CMMFSbcEncoderMux::DoGetAllocMethodsArrayL(RArray<TSbcAllocationMethod>& aAllocationMethods, TInt aCount)

	{

	// allocate a temporary buffer to hold the allocation methods

	HBufC8* buf = HBufC8::NewLC(aCount * sizeof(TSbcAllocationMethod));

	TPtr8 ptr = buf->Des();

	// fetch the allocation methods - but send over the received count to be sure

	TPckgBuf<TInt> countBuf(aCount);

	User::LeaveIfError(iUtility->SendSlaveSyncCommandResult(iRemoteHandle, 

															EMMFDevSoundCISbcEncoderGetSupportedAllocationMethodsArray,

															countBuf, ptr));

	// stream data into the pointer

	RDesReadStream stream(ptr);

	CleanupClosePushL(stream);

	TInt err = KErrNone;

	TSbcAllocationMethod mode;

	for (TInt i = 0; i < aCount; i++)

		{

		// note we don't destroy array because we don't own it

		// but we do reset it as it is incomplete

		mode = static_cast<TSbcAllocationMethod>(stream.ReadInt32L());

		err = aAllocationMethods.Append(mode);

		if (err != KErrNone)

			{

			aAllocationMethods.Reset();

			User::Leave(KErrCorrupt);

			}

		}

	CleanupStack::PopAndDestroy(2, buf);// stream, buf	

	}

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

TInt CMMFSbcEncoderMux::GetSupportedNumOfBlocks (RArray<TUint>& aNumOfBlocks )

	{

	TInt err = KErrNotReady;

	if (iRemoteHandle > 0)

		{

		// Clear the array

		aNumOfBlocks.Reset();