diff -r 000000000000 -r 79dd3e2336a0 devsound/devsoundpluginsupport/src/CustomInterfaces/sbcencoderci.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/devsound/devsoundpluginsupport/src/CustomInterfaces/sbcencoderci.cpp	Fri Oct 08 19:40:43 2010 +0100
@@ -0,0 +1,1216 @@
+// 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();
+		// Fetch the count
+		TInt count = -1;
+		count = iUtility->SendSlaveSyncCommand(iRemoteHandle,
+												EMMFDevSoundCISbcEncoderGetSupportedBlocksCount,
+												KNullDesC8);
+		if (count < 0)
+			{
+			err = count;
+			}
+		else if (count > 0)
+			{
+			TRAP(err, DoGetTUintArrayL(aNumOfBlocks, count, EMMFDevSoundCISbcEncoderGetSupportedBlocksArray));
+			}
+		else
+			{
+			// count == 0, nothing to do and no error...
+			err = KErrNone;
+			}
+		}
+
+	return err;
+	}
+
+void CMMFSbcEncoderMux::DoGetTUintArrayL(RArray<TUint>& aArray,
+										 TInt aCount,
+										 TMMFDevSoundCISbcEncoderCommands aCommand)
+	{
+	// allocate a temporary buffer to hold the number of blocks
+	HBufC8* buf = HBufC8::NewLC(aCount * sizeof(TInt32));
+	TPtr8 ptr = buf->Des();
+
+	// fetch the array data for the given command - but send over the received count to be sure
+	TPckgBuf<TInt> countBuf(aCount);
+	User::LeaveIfError(iUtility->SendSlaveSyncCommandResult(iRemoteHandle, 
+															aCommand,
+															countBuf, ptr));
+
+	// stream data into the pointer
+	RDesReadStream stream(ptr);
+	CleanupClosePushL(stream);
+	TInt err = KErrNone;
+	for (TInt i = 0; i < aCount; i++)
+		{
+		err = aArray.Append(stream.ReadUint32L());
+		if (err != KErrNone)
+			{
+			// note we don't destroy array because we don't own it
+			// but we do reset it as it is incomplete
+			aArray.Reset();
+			User::Leave(KErrCorrupt);
+			}
+		}
+	
+	CleanupStack::PopAndDestroy(2, buf);// stream, buf		
+	}
+
+	
+// DEMUX //	
+/*****************************************************************************/
+TInt CMMFSbcEncoderDeMux::OpenInterface(TUid /*aInterfaceId*/)
+	{
+	return KErrNone;
+	}
+
+/*****************************************************************************/	
+void CMMFSbcEncoderDeMux::Release()
+	{
+	TUid key = iDestructorKey;
+	
+	delete this;
+	
+	// tell ECom to destroy us
+	REComSession::DestroyedImplementation(key);
+	}
+	
+/*****************************************************************************/	
+void CMMFSbcEncoderDeMux::PassDestructorKey(TUid aDestructorKey)
+	{
+	// store the destructor key
+	iDestructorKey = aDestructorKey;
+	}
+	
+/*****************************************************************************/	
+void CMMFSbcEncoderDeMux::SetInterfaceTarget(MMMFDevSoundCustomInterfaceTarget* aTarget)
+	{
+	iTarget = aTarget;
+	}
+
+/*****************************************************************************/	
+void CMMFSbcEncoderDeMux::CompleteConstructL(MMMFDevSoundCustomInterfaceDeMuxUtility* aCustomUtility)
+	{
+	// store a pointer to the utility
+	iUtility = aCustomUtility;
+	}
+
+/*****************************************************************************/
+void CMMFSbcEncoderDeMux::RefreshL()
+	{
+	// refetch the SBC encoder custom interface if we already have a target
+	if (iTarget)
+		{
+		MSbcEncoderIntfc* ptr = NULL;
+
+		ptr = static_cast <MSbcEncoderIntfc*> (iTarget->CustomInterface(KUidSbcEncoderIntfc));
+	
+		if (!ptr)
+			{
+			iInterfaceSbcEncoder = NULL;
+			User::Leave(KErrNotSupported);
+			}
+		else
+			{
+			iInterfaceSbcEncoder = ptr;
+			}	
+		}
+	}
+
+/*****************************************************************************/
+MMMFDevSoundCustomInterfaceDeMuxPlugin* CMMFSbcEncoderDeMux::NewL()
+	{
+	CMMFSbcEncoderDeMux* self = new (ELeave) CMMFSbcEncoderDeMux;
+	return self;
+	}
+
+/*****************************************************************************/	
+CMMFSbcEncoderDeMux::CMMFSbcEncoderDeMux()
+	{	
+	}
+
+/*****************************************************************************/
+CMMFSbcEncoderDeMux::~CMMFSbcEncoderDeMux()
+	{
+	// Clear up all the arrays.
+	iSamplingFrequencies.Reset();
+	iSamplingFrequencies.Close();
+	iChannelModes.Reset();
+	iChannelModes.Close();
+	iNumOfSubbands.Reset();
+	iNumOfSubbands.Close(); 
+	iAllocationMethods.Reset(); 
+	iAllocationMethods.Close();
+	iNumOfBlocks.Reset();
+	iNumOfBlocks.Close();
+	}
+
+/*****************************************************************************/
+TInt CMMFSbcEncoderDeMux::DoOpenSlaveL(TUid /*aInterface*/, const TDesC8& /*aPackageBuf*/)
+	{
+	// fetch the SBD encoder Hw Device custom interface
+	MSbcEncoderIntfc* ptr = NULL;
+
+	ptr = static_cast<MSbcEncoderIntfc*> (iTarget->CustomInterface(KUidSbcEncoderIntfc)); 
+	
+	if (!ptr)
+		{
+		iInterfaceSbcEncoder = NULL;
+		User::Leave(KErrNotSupported);
+		}
+	else
+		{
+		iInterfaceSbcEncoder = ptr;
+		}
+	return KErrNone;
+	}
+	
+/*****************************************************************************/	
+void CMMFSbcEncoderDeMux::DoCloseSlaveL(TInt /*aHandle*/)
+	{
+	// nothing to do
+	}
+
+/*****************************************************************************/
+// original RMessage is supplied so that remote demux plugin can extract necessary details
+// using DeMux utility
+TInt CMMFSbcEncoderDeMux::DoSendSlaveSyncCommandL(const RMmfIpcMessage& aMessage)
+	{
+	TMMFDevSoundCIMessageData data;
+	
+	// decode message
+	iUtility->GetSyncMessageDataL(aMessage, data);
+
+	TInt retVal = KErrNone;
+	switch (data.iCommand)
+		{
+		case EMMFDevSoundCISbcEncoderGetSupportedSamplingFrequenciesCount:
+			{
+			iSamplingFrequencies.Reset();
+			User::LeaveIfError(DoGetSupportedSamplingFrequencies(iSamplingFrequencies));
+			retVal = iSamplingFrequencies.Count();
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedBlocksCount:
+			{
+			iNumOfBlocks.Reset();
+			User::LeaveIfError(DoGetSupportedNumOfBlocks(iNumOfBlocks));
+			retVal = iNumOfBlocks.Count();
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedSubbandsCount:
+			{
+			iNumOfSubbands.Reset();
+			User::LeaveIfError(DoGetSupportedNumOfSubbands(iNumOfSubbands));
+			retVal = iNumOfSubbands.Count();
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedChannelModesCount:
+			{
+			iChannelModes.Reset();
+			User::LeaveIfError(DoGetSupportedChannelModes(iChannelModes));
+			retVal = iChannelModes.Count();
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedAllocationMethodsCount:
+			{
+			iAllocationMethods.Reset();
+			User::LeaveIfError(DoGetSupportedAllocationMethods(iAllocationMethods));
+			retVal = iAllocationMethods.Count();
+			break;
+			}		
+		case EMMFDevSoundCISbcEncoderSetSamplingFrequency:
+			{
+			TPckgBuf<TUint> freqBuffer;
+			iUtility->ReadFromInputDesL(aMessage, &freqBuffer);
+			DoSetSamplingFrequency(freqBuffer());
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderSetChannelMode:
+			{
+			TPckgBuf<MSbcEncoderIntfc::TSbcChannelMode> channelBuffer;
+			iUtility->ReadFromInputDesL(aMessage, &channelBuffer);
+			DoSetChannelMode(channelBuffer());
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderSetSubbands:
+			{
+			TPckgBuf<TUint> valueBuffer;
+			iUtility->ReadFromInputDesL(aMessage, &valueBuffer);
+			DoSetNumOfSubbands(valueBuffer());
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderSetBlocks:
+			{
+			TPckgBuf<TUint> valueBuffer;
+			iUtility->ReadFromInputDesL(aMessage, &valueBuffer);
+			DoSetNumOfBlocks(valueBuffer());
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderSetBitpoolSize:
+			{
+			TPckgBuf<TUint> valueBuffer;
+			iUtility->ReadFromInputDesL(aMessage, &valueBuffer);
+			DoSetBitpoolSize(valueBuffer());
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderSetAllocationMethod:
+			{
+			TPckgBuf<MSbcEncoderIntfc::TSbcAllocationMethod> allocationMethodBuffer;
+			iUtility->ReadFromInputDesL(aMessage, &allocationMethodBuffer);
+			DoSetAllocationMethod(allocationMethodBuffer());
+			break;
+			}			
+		case EMMFDevSoundCISbcEncoderApplyConfig:
+			{
+			retVal = DoApplyConfig();
+			break;
+			}
+		default:
+			{
+			User::Leave(KErrNotSupported);
+			}		
+		};
+		
+	return retVal;
+	}
+	
+/*****************************************************************************/	
+TInt CMMFSbcEncoderDeMux::DoSendSlaveSyncCommandResultL(const RMmfIpcMessage& aMessage)
+	{
+	TMMFDevSoundCIMessageData data;
+	
+	// decode message
+	iUtility->GetSyncMessageDataL(aMessage, data);
+	
+	TInt retVal = KErrNone;
+	switch (data.iCommand)
+		{
+		case EMMFDevSoundCISbcEncoderGetSupportedSamplingFrequenciesArray:
+			{
+			// The array will already have been populated by the time this is called
+			// but we can check that the count passed in matches that of the array
+			DoWriteArrayToClientL(aMessage, iSamplingFrequencies);
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedSubbandsArray:
+			{
+			// The array will already have been populated by the time this is called
+			// but we can check that the count passed in matches that of the array
+			DoWriteArrayToClientL(aMessage, iNumOfSubbands);
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedBlocksArray:
+			{
+			// The array will already have been populated by the time this is called
+			// but we can check that the count passed in matches that of the array
+			DoWriteArrayToClientL(aMessage, iNumOfBlocks);
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedChannelModesArray:
+			{
+			// The array will already have been populated by the time this is called
+			// but we can check that the count passed in matches that of the array
+			// Pass ETrue to write out the channel modes array
+			DoWriteArrayToClientL(aMessage, ETrue);
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedAllocationMethodsArray:
+			{
+			// The array will already have been populated by the time this is called
+			// but we can check that the count passed in matches that of the array		
+			// Pass EFalse for the alloc method array.
+			DoWriteArrayToClientL(aMessage, EFalse);
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSupportedBitpoolRange:
+			{
+			TPckgBuf<TBitpoolRange> rangeBuf;
+			DoGetSupportedBitpoolRange(rangeBuf().iMin, rangeBuf().iMax);
+			iUtility->WriteToOutputDesL(aMessage, rangeBuf);	
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSamplingFrequency:
+			{
+			TPckgBuf<TUint> valueBuf;
+			DoGetSamplingFrequency(valueBuf());
+			iUtility->WriteToOutputDesL(aMessage, valueBuf);		
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetChannelMode:
+			{
+			TPckgBuf<MSbcEncoderIntfc::TSbcChannelMode> channelBuf;
+			DoGetChannelMode(channelBuf());
+			iUtility->WriteToOutputDesL(aMessage, channelBuf);		
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetSubbands:
+			{
+			TPckgBuf<TUint> valueBuf;
+			DoGetNumOfSubbands(valueBuf());
+			iUtility->WriteToOutputDesL(aMessage, valueBuf);		
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetBlocks:
+			{
+			TPckgBuf<TUint> valueBuf;
+			DoGetNumOfBlocks(valueBuf());
+			iUtility->WriteToOutputDesL(aMessage, valueBuf);		
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetAllocationMethod:
+			{
+			TPckgBuf<MSbcEncoderIntfc::TSbcAllocationMethod> allocationMethodBuf;
+			DoGetAllocationMethod(allocationMethodBuf());
+			iUtility->WriteToOutputDesL(aMessage, allocationMethodBuf);		
+			break;
+			}
+		case EMMFDevSoundCISbcEncoderGetBitpoolSize:
+			{
+			TPckgBuf<TUint> valueBuf;
+			DoGetBitpoolSize(valueBuf());
+			iUtility->WriteToOutputDesL(aMessage, valueBuf);		
+			break;
+			}			
+		default:
+			{
+			User::Leave(KErrNotSupported);
+			}
+		}
+
+	return retVal;
+	}
+
+/*****************************************************************************/	
+void CMMFSbcEncoderDeMux::DoSendSlaveAsyncCommandL(const RMmfIpcMessage& /*aMessage*/)
+	{
+	// not used in this interface
+	}
+	
+/*****************************************************************************/	
+void CMMFSbcEncoderDeMux::DoSendSlaveAsyncCommandResultL(const RMmfIpcMessage& /*aMessage*/)
+	{
+	// not used in this interface
+	}
+
+/*****************************************************************************/
+// SBC Encoder custom interface implementation
+TInt CMMFSbcEncoderDeMux::DoGetSupportedSamplingFrequencies(RArray<TUint>& aSamplingFrequencies)
+	{
+	TInt err = KErrNotReady;
+	if (iInterfaceSbcEncoder)
+		{
+		err = iInterfaceSbcEncoder->GetSupportedSamplingFrequencies(aSamplingFrequencies);
+		}
+	return err;
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetSupportedNumOfSubbands (RArray<TUint>& aNumOfSubbands )
+	{
+	TInt err = KErrNotReady;
+	if (iInterfaceSbcEncoder)
+		{
+		err = iInterfaceSbcEncoder->GetSupportedNumOfSubbands(aNumOfSubbands);
+		}
+	return err;
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetSupportedNumOfBlocks (RArray<TUint>& aNumOfBlocks )
+	{
+	TInt err = KErrNotReady;
+	if (iInterfaceSbcEncoder)
+		{
+		err = iInterfaceSbcEncoder->GetSupportedNumOfBlocks(aNumOfBlocks);
+		}
+	return err;
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetSupportedChannelModes (RArray<MSbcEncoderIntfc::TSbcChannelMode>& aChannelModes )
+	{
+	TInt err = KErrNotReady;
+	if (iInterfaceSbcEncoder)
+		{
+		err = iInterfaceSbcEncoder->GetSupportedChannelModes(aChannelModes);
+		}
+	return err;
+	}
+	
+TInt CMMFSbcEncoderDeMux::DoGetSupportedAllocationMethods (RArray<MSbcEncoderIntfc::TSbcAllocationMethod>& aAllocationMethods )
+	{
+	TInt err = KErrNotReady;
+	if (iInterfaceSbcEncoder)
+		{
+		err = iInterfaceSbcEncoder->GetSupportedAllocationMethods(aAllocationMethods);
+		}
+	return err;
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetSupportedBitpoolRange (TUint& aMinSupportedBitpoolSize, TUint& aMaxSupportedBitpoolSize)
+	{
+	TInt err = KErrNotReady;
+	if (iInterfaceSbcEncoder)
+		{
+		err = iInterfaceSbcEncoder->GetSupportedBitpoolRange(aMinSupportedBitpoolSize, aMaxSupportedBitpoolSize);
+		}
+	return err;	
+	}
+	
+void CMMFSbcEncoderDeMux::DoSetSamplingFrequency (TUint aSamplingFrequency )
+	{
+	if (iInterfaceSbcEncoder)
+		{
+		iInterfaceSbcEncoder->SetSamplingFrequency(aSamplingFrequency);
+		}		
+	}
+	
+void CMMFSbcEncoderDeMux::DoSetChannelMode (MSbcEncoderIntfc::TSbcChannelMode aChannelMode )
+	{
+	if (iInterfaceSbcEncoder)
+		{
+		iInterfaceSbcEncoder->SetChannelMode(aChannelMode);
+		}		
+	}
+
+void CMMFSbcEncoderDeMux::DoSetNumOfSubbands (TUint aNumOfSubbands)
+	{
+	if (iInterfaceSbcEncoder)
+		{
+		iInterfaceSbcEncoder->SetNumOfSubbands(aNumOfSubbands);
+		}		
+	}
+
+void CMMFSbcEncoderDeMux::DoSetNumOfBlocks (TUint aNumOfBlocks)
+	{
+	if (iInterfaceSbcEncoder)
+		{
+		iInterfaceSbcEncoder->SetNumOfBlocks(aNumOfBlocks);
+		}		
+	}
+
+void CMMFSbcEncoderDeMux::DoSetAllocationMethod (MSbcEncoderIntfc::TSbcAllocationMethod aAllocationMethod)
+	{
+	if (iInterfaceSbcEncoder)
+		{
+		iInterfaceSbcEncoder->SetAllocationMethod(aAllocationMethod);
+		}		
+	}
+
+void CMMFSbcEncoderDeMux::DoSetBitpoolSize (TUint aBitpoolSize)
+	{
+	if (iInterfaceSbcEncoder)
+		{
+		iInterfaceSbcEncoder->SetBitpoolSize(aBitpoolSize);
+		}		
+	}
+
+TInt CMMFSbcEncoderDeMux::DoApplyConfig()
+	{
+	TInt retVal = KErrNotReady;
+	if (iInterfaceSbcEncoder)
+		{
+		retVal = iInterfaceSbcEncoder->ApplyConfig();
+		}
+	return retVal;
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetSamplingFrequency(TUint& aSamplingFrequency)
+	{
+	TInt ret = KErrNotReady;
+	if (iInterfaceSbcEncoder)
+		{
+		ret = iInterfaceSbcEncoder->GetSamplingFrequency(aSamplingFrequency);
+		}
+	return ret;
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetChannelMode (MSbcEncoderIntfc::TSbcChannelMode& aChannelMode )
+	{
+	if (!iInterfaceSbcEncoder)
+		{
+		return KErrNotReady;
+		}
+	else
+		{
+		return iInterfaceSbcEncoder->GetChannelMode(aChannelMode);
+		}
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetNumOfSubbands (TUint& aNumOfSubbands )
+	{
+	if (!iInterfaceSbcEncoder)
+		{
+		return KErrNotReady;  
+		}
+	else
+		{
+		return iInterfaceSbcEncoder->GetNumOfSubbands(aNumOfSubbands);
+		}
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetNumOfBlocks (TUint& aNumOfBlocks )
+	{
+	if (!iInterfaceSbcEncoder)
+		{
+		return KErrNotReady;  
+		}
+	else
+		{
+		return iInterfaceSbcEncoder->GetNumOfBlocks(aNumOfBlocks);
+		}		
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetAllocationMethod (MSbcEncoderIntfc::TSbcAllocationMethod& aAllocationMethod )
+	{
+	if (!iInterfaceSbcEncoder)
+		{
+		return KErrNotReady;  
+		}
+	else
+		{
+		return iInterfaceSbcEncoder->GetAllocationMethod(aAllocationMethod);
+		}		
+	}
+
+TInt CMMFSbcEncoderDeMux::DoGetBitpoolSize(TUint& aBitpoolSize)
+	{
+	if (!iInterfaceSbcEncoder)
+		{
+		return KErrNotReady;  
+		}
+	else
+		{
+		return iInterfaceSbcEncoder->GetBitpoolSize(aBitpoolSize);
+		}		
+	}
+
+// This is a utility method used by each of the TUint parametered methods to write their arrays
+// back to the client (using aMessage)
+void CMMFSbcEncoderDeMux::DoWriteArrayToClientL(const RMmfIpcMessage& aMessage, RArray<TUint>& aArray)
+	{
+	// The message already contains the array count so retrieve it
+	// and verify that nothing's awry.
+	TPckgBuf<TInt> countBuf;
+	iUtility->ReadFromInputDesL(aMessage, &countBuf);
+	TInt count = countBuf();
+	if (count != aArray.Count())
+		{
+		User::Leave(KErrCorrupt);
+		}
+	// Create a suitably sized buffer
+	HBufC8* buf = HBufC8::NewLC(count * sizeof(TUint));
+	TPtr8 ptr = buf->Des();
+	RDesWriteStream stream(ptr);
+	CleanupClosePushL(stream);
+	// Stream the array data
+	for (TInt i = 0; i < count; i++)
+		{
+		stream.WriteUint32L(aArray[i]);
+		}
+	// Commit the data to the stream
+	stream.CommitL();
+	// Write the buffer back to the mux
+	iUtility->WriteToOutputDesL(aMessage, *buf);
+	CleanupStack::PopAndDestroy(2, buf); // stream, buf
+	}
+
+void CMMFSbcEncoderDeMux::DoWriteArrayToClientL(const RMmfIpcMessage& aMessage, TBool aWriteChannelModeArray)
+	{
+	// The message already contains the array count so retrieve it
+	// and verify that nothing's awry.
+	TPckgBuf<TInt> countBuf;
+	iUtility->ReadFromInputDesL(aMessage, &countBuf);
+	TInt count = countBuf();
+	TInt arrayCount = 0;
+		
+	if (aWriteChannelModeArray)
+		{
+		arrayCount = iChannelModes.Count();
+		}
+	else
+		{
+		arrayCount = iAllocationMethods.Count();
+		}
+		
+	if (count != arrayCount)
+		{
+		User::Leave(KErrCorrupt);
+		}
+		
+	// Create a suitably sized buffer
+	HBufC8* buf = HBufC8::NewLC(count * sizeof(TUint));
+	TPtr8 ptr = buf->Des();
+	RDesWriteStream stream(ptr);
+	CleanupClosePushL(stream);
+	// Stream the array data
+	if (aWriteChannelModeArray)
+		{
+		for (TInt i = 0; i < count; i++)
+			{
+			stream.WriteUint32L(iChannelModes[i]);
+			}
+		
+		}
+	else
+		{
+		for (TInt i = 0; i < count; i++)
+			{
+			stream.WriteUint32L(iAllocationMethods[i]);
+			}
+		}
+	
+	// Commit the data to the stream
+	stream.CommitL();
+	// Write the buffer back to the mux
+	iUtility->WriteToOutputDesL(aMessage, *buf);
+	CleanupStack::PopAndDestroy(2, buf); // stream, buf
+	}
+
+/*****************************************************************************/
+//
+// ImplementationTable
+//
+
+const TImplementationProxy ImplementationTable[] = 
+	{
+	IMPLEMENTATION_PROXY_ENTRY(KMmfUidCustomInterfaceSbcEncoderMux, CMMFSbcEncoderMux::NewL),
+	IMPLEMENTATION_PROXY_ENTRY(KMmfUidCustomInterfaceSbcEncoderDeMux, CMMFSbcEncoderDeMux::NewL),
+	};
+
+/*****************************************************************************/
+//
+// ImplementationGroupProxy
+//
+//
+
+EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
+	{
+	aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
+
+	return ImplementationTable;
+	}