// 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 <mmf/server/mmfswcodecwrappercustominterfacesuids.hrh>

#include "sbcencodertestdevice.h"


/*****************************************************************************/
// Implementation

CMMFHwDevice* CSbcEncoderTestDevice::NewL()
	{
	CSbcEncoderTestDevice* self = new(ELeave) CSbcEncoderTestDevice();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/*****************************************************************************/
CSbcEncoderTestDevice::~CSbcEncoderTestDevice()
	{
	}

/*****************************************************************************/
CSbcEncoderTestDevice::CSbcEncoderTestDevice()
	{
	}

/*****************************************************************************/
void CSbcEncoderTestDevice::ConstructL()
	{
	}
	
/*****************************************************************************/
TInt CSbcEncoderTestDevice::Start(TDeviceFunc /*aFuncCmd*/, TDeviceFlow /*aFlowCmd*/) 
	{
	return 0;
	}

/*****************************************************************************/
TInt CSbcEncoderTestDevice::Stop()
	{
	return 0;
	}
	
/*****************************************************************************/
TInt CSbcEncoderTestDevice::Pause()
	{
	return 0;
	}

/*****************************************************************************/		
TInt CSbcEncoderTestDevice::Init(THwDeviceInitParams& /*aDevInfo*/)
	{
	return 0;
	}
	
/*****************************************************************************/	
TAny* CSbcEncoderTestDevice::CustomInterface(TUid aInterfaceId)
	{
	MSbcEncoderIntfc* interface = NULL;
	
	// DevSound initialisation requires something to be returned for both of
	// these two uids: KMmfPlaySettingsCustomInterface, KMmfRecordSettingsCustomInterface
	if ((aInterfaceId == KUidSbcEncoderIntfc) || // This interface
		(aInterfaceId.iUid == KMmfPlaySettingsCustomInterface) ||
		(aInterfaceId.iUid == KMmfRecordSettingsCustomInterface))
		{
		interface = this;
		}
	
	return interface;
	}

/*****************************************************************************/
TInt CSbcEncoderTestDevice::ThisHwBufferFilled(CMMFBuffer& /*aFillBufferPtr*/)
	{
	return 0;
	}
	
/*****************************************************************************/	
TInt CSbcEncoderTestDevice::ThisHwBufferEmptied(CMMFBuffer& /*aEmptyBufferPtr*/)
	{
	return 0;
	}
	
/*****************************************************************************/	
TInt CSbcEncoderTestDevice::SetConfig(TTaskConfig& /*aConfig*/)
	{
	return 0;
	}
	
/*****************************************************************************/	
TInt CSbcEncoderTestDevice::StopAndDeleteCodec()
	{
	return 0;
	}
	
/*****************************************************************************/	
TInt CSbcEncoderTestDevice::DeleteCodec()
	{
	return 0;
	}

/*****************************************************************************/
CMMFSwCodec& CSbcEncoderTestDevice::Codec()
	{
	return *iCodec;
	}

/*****************************************************************************/
TInt CSbcEncoderTestDevice::GetSupportedSamplingFrequencies ( RArray<TUint>& aSamplingFrequencies )
	{
	TInt retVal = KErrNone;
	// Assume the strategy is to hard code a set of frequencies...
	//
	// Reset the input array
	aSamplingFrequencies.Reset();
	// Populate the array
	TUint value = 0;
	for (TInt i = 0; i < 10; i++)
		{
		retVal = aSamplingFrequencies.Append(value);
		if (retVal != KErrNone)
			{
			break;
			}
		value += 1000;
		}

	return retVal;
	}

TInt CSbcEncoderTestDevice::GetSupportedChannelModes ( RArray<TSbcChannelMode>& aChannelModes )
	{
	TInt retVal = KErrNone;
	aChannelModes.Reset();
	retVal = aChannelModes.Append(ESbcChannelMono);
	if (retVal == KErrNone)
		{
		retVal = aChannelModes.Append(ESbcChannelDual);
		if (retVal == KErrNone)
			{
			retVal = aChannelModes.Append(ESbcChannelStereo);
			if (retVal == KErrNone)
				{
				retVal = aChannelModes.Append(ESbcChannelJointStereo);
				}
			}				
		}
	return retVal;
	}

TInt CSbcEncoderTestDevice::GetSupportedNumOfSubbands ( RArray<TUint>& aNumOfSubbands )
	{
	TInt retVal = KErrNone;
	aNumOfSubbands.Reset();
	TUint val = 100;
	for (TInt i = 0; i < 5; i++)
		{
		retVal = aNumOfSubbands.Append(val);
		if (retVal != KErrNone)
			{
			break;
			}
		val += 100;
		}
	return retVal;
	}
 
TInt CSbcEncoderTestDevice::GetSupportedAllocationMethods ( RArray<TSbcAllocationMethod>& aAllocationMethods )
	{
	TInt retVal = KErrNone;
	aAllocationMethods.Reset();
	retVal = aAllocationMethods.Append(ESbcAllocationSNR);
	if (retVal == KErrNone)
		{
		retVal = aAllocationMethods.Append(ESbcAllocationLoudness);
		}
	return retVal;
	}

TInt CSbcEncoderTestDevice::GetSupportedNumOfBlocks ( RArray<TUint>& aNumOfBlocks )
	{
	TInt retVal = KErrNone;
	aNumOfBlocks.Reset();
	TUint val = 1;
	for (TInt i = 0; i < 10; i++, val++)
		{
		retVal = aNumOfBlocks.Append(val);
		if (retVal != KErrNone)
			{
			break;
			}
		}
	return retVal;
	}

TInt CSbcEncoderTestDevice::GetSupportedBitpoolRange (TUint& aMinSupportedBitpoolSize, TUint& aMaxSupportedBitpoolSize)
	{
	// Arbitrary values
	aMinSupportedBitpoolSize = 1;
	aMaxSupportedBitpoolSize = 2;
	
	return KErrNone;
	}

void CSbcEncoderTestDevice::SetSamplingFrequency ( TUint aSamplingFrequency )
	{
	iSamplingFrequency = aSamplingFrequency;
	}

void CSbcEncoderTestDevice::SetChannelMode (TSbcChannelMode aChannelMode )
	{
	iChannelMode = aChannelMode;
	}

void CSbcEncoderTestDevice::SetNumOfSubbands ( TUint aNumOfSubbands )
	{
	iNumOfSubbands = aNumOfSubbands;
	}

void CSbcEncoderTestDevice::SetAllocationMethod (TSbcAllocationMethod aAllocationMethod )
	{
	iAllocMethod = aAllocationMethod;
	}

void CSbcEncoderTestDevice::SetBitpoolSize (TUint aBitpoolSize )
	{
	iBitpoolSize = aBitpoolSize;
	}

TInt CSbcEncoderTestDevice::ApplyConfig()
	{
	iApplyConfig = ETrue;
	return KErrNone;
	}

TInt CSbcEncoderTestDevice::GetSamplingFrequency ( TUint& aSamplingFrequency )
	{
	TInt retVal = KErrNone;
	aSamplingFrequency = iSamplingFrequency;
	return retVal;
	}

TInt CSbcEncoderTestDevice::GetChannelMode (TSbcChannelMode& aChannelMode )
	{
	TInt retVal = KErrNone;
	aChannelMode = iChannelMode;	
	return retVal;
	}

TInt CSbcEncoderTestDevice::GetNumOfSubbands ( TUint& aNumOfSubbands )
	{
	TInt retVal = KErrNone;
	aNumOfSubbands = iNumOfSubbands;

	return retVal;
	}

TInt CSbcEncoderTestDevice::GetAllocationMethod (TSbcAllocationMethod& aAllocationMethod )
	{
	TInt retVal = KErrNone;
	aAllocationMethod = iAllocMethod;
	return retVal;
	}

TInt CSbcEncoderTestDevice::GetBitpoolSize (TUint& aBitpoolSize )
	{
	TInt retVal = KErrNone;
	aBitpoolSize = iBitpoolSize;
	return retVal;
	}

void CSbcEncoderTestDevice::SetNumOfBlocks ( TUint aNumOfBlocks )
	{
	iNumOfBlocks = aNumOfBlocks;
	}

TInt CSbcEncoderTestDevice::GetNumOfBlocks ( TUint& aNumOfBlocks )
	{
	TInt retVal = KErrNone;
	aNumOfBlocks = iNumOfBlocks;
	return retVal;
	}