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

//

#ifndef __SBCFRAMEPARAMETERS_H__

#define __SBCFRAMEPARAMETERS_H__

/**

This class contains 6 SBC frame parameters: sampling frequency, block length, 

channel mode, allocation mode, subbands and bitpool. It can validate all the 

parameters, calculate frame length and bit rate.

@internalComponent

*/

class TSBCFrameParameters

	{

public:

	/**

	This enum list all the possible sampling frequency settings

	*/

	enum TSamplingFrequency

		{

		/**

		sampling frequency is 16000 Hz

		*/

		E16000Hz = 0,

		/**

		sampling frequency is 32000 Hz

		*/

		E32000Hz,

		/**

		sampling frequency is 44100 Hz

		*/

		E44100Hz,

		/**

		sampling frequency is 48000 Hz

		*/

		E48000Hz

		};

	/**

	This enum list all the possible block length settings

	*/

	enum TBlockLength

		{

		/**

		block length is 4, one frame contains 4 blocks of audio samples

		*/

		E4Blocks = 0,

		/**

		block length is 8, one frame contains 8 blocks of audio samples

		*/

		E8Blocks,

		/**

		block length is 12, one frame contains 12 blocks of audio samples

		*/

		E12Blocks,

		/**

		block length is 16, one frame contains 16 blocks of audio samples

		*/

		E16Blocks

		};

	/**

	This enum list all the possible channel mode settings

	*/

	enum TChannelMode

		{

		/**

		channel mode is Mono, in this mode,

		only one channel contains audio samples.

		*/

		EMono = 0,

		/**

		channel mode is Dual Channel, in this mode,

		it contains two seperate mono audio samples.

		*/

		EDualChannel,

		/**

		channel mode is Stereo, in this mode,

		it contains stereo audio samples.

		*/

		EStereo,

		/**

		channel mode is Joint Stereo, in this mode,

		the left channel stores half of sum of both channels, 

		the right channel stores half of difference of both channels. 

		*/

		EJointStereo

		};

	/**

	This enum list all the possible allocation method settings

	*/

	enum TAllocationMethod

		{

		/**

		allocation method is Loudness, in this mode, 

		the bit allocation calculation uses Table offset4 or offset8 as well as scale factors

		*/

		ELoudness = 0,

		/**

		allocation method is SNR, in this mode,

		bit allocation only uses scale factors

		*/

		ESNR

		};

	/**

	This enum list all the possible subbands settings

	*/

	enum TSubbands

		{

		/**

		subbands is 4, each channel contains 4 subbands in each block, 

		each subband contains one sample

		*/

		E4Subbands = 0,

		/**

		subbands is 8, each channel contains 8 subbands in each block, 

		each subband contains one sample

		*/

		E8Subbands

		};

public:

	inline TSBCFrameParameters();

	inline void Reset();

	inline TUint8 	SamplingFrequencyEnum() const;

	inline TUint	SamplingFrequencyHz() const;

	inline void		SetSamplingFrequency(TSamplingFrequency aSamplingFrequency);

	inline TUint8	BlockLength() const;

	inline void		SetBlockLength(TBlockLength aBlockLength);

	inline TUint8 	ChannelMode() const;

	inline TUint8	Channels() const;

	inline void 	SetChannelMode(TChannelMode aChannelMode);

	inline TUint8 	AllocationMethod() const;

	inline void 	SetAllocationMethod(TAllocationMethod aAllocationMethod);

	inline TUint8	SubbandsEnum() const;

	inline TUint8	Subbands() const;

	inline void 	SetSubbands(TSubbands aSubbands);

	inline TUint8	Bitpool() const;

	inline void		SetBitpool(TUint8 aBitpool);

	inline TUint8	Parameters() const;

	inline TInt 	Validate() const;

	inline TUint 	CalcFrameLength() const;

	inline TUint 	CalcBitRate(TUint aFrameLength) const;

private:

	TUint8 	iParameters;

	TUint8 	iBitpool;

	};

/**

The minimum SBC bitpool value is 2 

*/	

const TUint8 KSBCMinBitpoolValue = 2;

/**

The maximum SBC bitpool value is 250 

*/	

const TUint8 KSBCMaxBitpoolValue = 250;

/**

The sampling frequency bits mask is 0b11, 2 bits

*/	

const TUint8 KSBCSampFreqBitsMask  = 0x3;

/**

The bit offset of sampling frequency field in TSBCFrameParameters::iParameters is 6

*/

const TUint8 KSBCSampFreqBitOffset = 6;

/**

The block length bits mask is 0b11, 2 bits

*/	

const TUint8 KSBCBlckLengBitsMask  = 0x3;

/**

The bit offset of block length field in TSBCFrameParameters::iParameters is 4

*/

const TUint8 KSBCBlckLengBitOffset = 4;

/**

The block length bits mask is 0b11, 2 bits

*/	

const TUint8 KSBCChnlModeBitsMask  = 0x3;

/**

The bit offset of block length field in TSBCFrameParameters::iParameters is 2

*/

const TUint8 KSBCChnlModeBitOffset = 2;

/**

The block length bits mask is 0b01, 1 bit

*/	

const TUint8 KSBCAllcMthdBitsMask  = 0x1;

/**

The bit offset of block length field in TSBCFrameParameters::iParameters is 1

*/

const TUint8 KSBCAllcMthdBitOffset = 1;

/**

The block length bits mask is 0b01, 1 bit

*/	

const TUint8 KSBCSubbandsBitsMask  = 0x1;

/**

The bit offset of block length field in TSBCFrameParameters::iParameters is 0

*/

const TUint8 KSBCSubbandsBitOffset = 0;

/**

Constructor

@internalComponent

*/

inline TSBCFrameParameters::TSBCFrameParameters() : iParameters(0), iBitpool(0)

	{

	}

/**

This function reset all the parameters

@internalComponent

*/

inline void TSBCFrameParameters::Reset()

	{

	iParameters = 0;

	iBitpool = 0;

	}

/**

This function gets the sampling frequency enum value

@internalComponent

@return enum value of sampling frequency

*/

inline TUint8 TSBCFrameParameters::SamplingFrequencyEnum() const

	{

	return static_cast<TUint8>( (iParameters >> KSBCSampFreqBitOffset) & KSBCSampFreqBitsMask);

	}

/**

This function gets the sampling frequency value in Hz

@internalComponent

@return samplinng frequency value in Hz

*/

inline TUint TSBCFrameParameters::SamplingFrequencyHz() const

	{

	switch (SamplingFrequencyEnum() )

		{

		case E16000Hz:

			return 16000;

		case E32000Hz:

			return 32000;

		case E44100Hz:

			return 44100;

		case E48000Hz:

			return 48000;

		}

	return 0;

	}

/**

This function sets the sampling frequency value

@internalComponent

@param aSampFreq

New sampling frequency enum value to set

*/

inline void TSBCFrameParameters::SetSamplingFrequency(TSamplingFrequency aSampFreq)

	{

	// clear sampling frequency bits

	iParameters &= ~(KSBCSampFreqBitsMask << KSBCSampFreqBitOffset);

	// set new sampling frequency bits

	iParameters |= ( (aSampFreq & KSBCSampFreqBitsMask) << KSBCSampFreqBitOffset);

	}

/**

This function gets the block length value

@internalComponent

@return number of blocks in one frame

*/

inline TUint8 TSBCFrameParameters::BlockLength() const

	{

	switch ( (iParameters >> KSBCBlckLengBitOffset) & KSBCBlckLengBitsMask)

		{

		case E4Blocks:

			return 4;

		case E8Blocks:

			return 8;

		case E12Blocks:

			return 12;

		case E16Blocks:

			return 16;

		}

	return 0;

	}

/**

This function sets the block length value

@internalComponent

@param aBlockLen

New block length value to set

*/

inline void TSBCFrameParameters::SetBlockLength(TBlockLength aBlockLen)

	{

	// clear block length bits

	iParameters &= ~(KSBCBlckLengBitsMask << KSBCBlckLengBitOffset);

	// set new block length bits

	iParameters |= ( (aBlockLen & KSBCBlckLengBitsMask) << KSBCBlckLengBitOffset);

	}

/**

This function gets the channel mode enum value

@internalComponent

@return channel mode enum value

*/

inline TUint8 TSBCFrameParameters::ChannelMode() const

	{

	return static_cast<TUint8>( (iParameters >> KSBCChnlModeBitOffset) & KSBCChnlModeBitsMask);

	}

/**

This function gets number of channels

@internalComponent

@return number of channels

*/

inline TUint8 TSBCFrameParameters::Channels() const

	{

	switch (ChannelMode() )

		{

		case EMono:

			return 1;

		case EDualChannel:

		case EStereo:

		case EJointStereo:

			return 2;

		}

	return 0;

	}

/**

This function sets the channel mode enum value

@internalComponent

@param aChnlMode

New channel mode enum value to set

*/

inline void TSBCFrameParameters::SetChannelMode(TChannelMode aChnlMode)

	{

	// clear channel mode bits

	iParameters &= ~(KSBCChnlModeBitsMask << KSBCChnlModeBitOffset);

	// set new channel mode bits

	iParameters |= ( (aChnlMode & KSBCChnlModeBitsMask) << KSBCChnlModeBitOffset);

	}

/**

This function gets the allocation method enum value

@internalComponent

@return allocation method enum value

*/

inline TUint8 TSBCFrameParameters::AllocationMethod() const

	{

	return static_cast<TUint8>( (iParameters >> KSBCAllcMthdBitOffset) & KSBCAllcMthdBitsMask);

	}

/**

This function sets the channel mode enum value

@internalComponent

@param aAllocMethod

New channel mode enum value to set

*/

inline void TSBCFrameParameters::SetAllocationMethod(TAllocationMethod aAllocMethod)

	{

	// clear allocation method bits

	iParameters &= ~(KSBCAllcMthdBitsMask << KSBCAllcMthdBitOffset);

	// set new allocation method bits

	iParameters |= ( (aAllocMethod & KSBCAllcMthdBitsMask) << KSBCAllcMthdBitOffset);

	}		

/**

This function gets the subbands enum value

@internalComponent

@return subbands enum value

*/

inline TUint8 TSBCFrameParameters::SubbandsEnum() const

	{

	return static_cast<TUint8>( (iParameters >> KSBCSubbandsBitOffset) & KSBCSubbandsBitsMask);

	}

/**

This function gets the subbands value

@internalComponent

@return subbands value, i.e 4, 8

*/

inline TUint8 TSBCFrameParameters::Subbands() const

	{

	switch (SubbandsEnum() )

		{

		case E4Subbands:

			return 4;

		case E8Subbands:

			return 8;

		}

	return 0;

	}

/**

This function sets the subbands enum value

@internalComponent

@param aSubbands

New subbands enum value to set

*/

inline void TSBCFrameParameters::SetSubbands(TSubbands aSubbands)

	{

	// clear subbands bits

	iParameters &= ~(KSBCSubbandsBitsMask << KSBCSubbandsBitOffset);

	// set new subbands bits

	iParameters |= ( (aSubbands & KSBCSubbandsBitsMask) << KSBCSubbandsBitOffset);

	}		

/**

This function gets the bitpool value

@internalComponent

@return bitpool value

*/

inline TUint8 TSBCFrameParameters::Bitpool() const

	{

	return iBitpool;

	}

/**

This function sets the bitpool enum value

@internalComponent

@param aSubbands

New bitpool enum value to set

*/

inline void TSBCFrameParameters::SetBitpool(TUint8 aBitpool)

	{

	iBitpool = aBitpool;

	}

/**

This function gets the 5 parameters (except bitpool) byte value

@internalComponent

@return 5 parameters byte value

*/

inline TUint8 TSBCFrameParameters::Parameters() const

	{

	return iParameters;

	}

/**

This function checks the bitpool value according to:

1. bitpool >= 2 and bitpool <= 250

2. bitpool <= 16 * subbands for Mono and Dual Channel,

   bitpool <= 32 * subbands for Stereo and Joint Stereo 

3. results in bit_rate <= 320 kbps for Mono

   results in bit_rate <= 512 kpbs for two-channel modes

@internalComponent

@return -1 if invalid; 0 if valid

*/

inline TInt TSBCFrameParameters::Validate() const

	{

	if (iBitpool < KSBCMinBitpoolValue || iBitpool > KSBCMaxBitpoolValue)

		{

		return -1;

		}

	const TUint16 numSubbands = Subbands(); // use 16 bits to avoid overflow

	const TUint8 channelMode = ChannelMode();

	if (channelMode == EMono || channelMode == EDualChannel)

		{

		// bitpool <= 16 * subbands, for Mono and Dual_Channel modes

		if (iBitpool > (numSubbands << 4) )

			{

			return -1;

			}

		}

	else

		{

		// bitpool <= 32 * subbands, for Stereo and Joint_Stereo modes

		if (iBitpool > (numSubbands << 5) )

			{

			return -1;

			}

		}

	if (channelMode == EMono)

		{

		// bit rate <= 320kbps for Mono mode

		if (CalcBitRate(CalcFrameLength() ) > 320)

			{

			return -1;

			}

		}

	else

		{

		// bit rate <= 512kpbs for two-channels modes

		if (CalcBitRate(CalcFrameLength() ) > 512)

			{

			return -1;

			}

		}

	return 0;

	}

/**

This function calculates the frame length value according to:

1. for MONO or DUAL_CHANNEL

   frame_len = 4 + (4 * subbands * channels) / 8 + ceil(blocks * channels * bitpool / 8)

2. for STEREO

   frame_len = 4 + (4 * subbands * channels) / 8 + ceil(blocks * bitpool / 8)

3. for JOINT_STEREO

   frame_len = 4 + (4 * subbands * channels) / 8 + ceil((subbands + blocks * bitpool) / 8)

ceil(), taking the upper integer value

@internalComponent

@return frame length value

*/

inline TUint TSBCFrameParameters::CalcFrameLength() const

	{

	TUint temp = 0;

	switch (ChannelMode() )

		{

		case EMono:

			temp = BlockLength() * Bitpool(); // blocks * bitpool

			break;

		case EDualChannel:

			temp = (BlockLength() * Bitpool() ) << 1; // blocks * bitpool * 2

			break;

		case EStereo:

			temp = BlockLength() * Bitpool(); // blocks * bitpool

			break;

		case EJointStereo:

			temp = Subbands() + BlockLength() * Bitpool(); // subbands + blocks * bitpool

			break;

		default:

			User::Panic(_L("Invalid channel mode"), KErrNotSupported);

			break;

		}

	TUint frameLen = 4 + ( (Subbands() * Channels() ) >> 1) + (temp >> 3);

	if (temp & 0x7)

		{

		frameLen++;

		}

	return frameLen;

	}

/**

This function calculates the bit rate value according to:

	bit_rate = 8 * frame_len * sampling_freq / subbands / blocks

@internalComponent

@return bit rate value in kHz

*/

inline TUint TSBCFrameParameters::CalcBitRate(TUint aFrameLen) const

	{

	return (aFrameLen << 3) * SamplingFrequencyHz() / (Subbands() * BlockLength() * 1000);

	}

#endif // __SBCFRAMEPARAMETERS_H__