// 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__