diff -r 000000000000 -r 40261b775718 devsound/devsoundrefplugin/src/codec/sbcencoder/SBCFrameParameters.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/devsound/devsoundrefplugin/src/codec/sbcencoder/SBCFrameParameters.h	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,588 @@
+// 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__
+