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