--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/src/Client/Audio/mmfclientaudiostreamutils.cpp Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,244 @@
+// Copyright (c) 2002-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 "mmfclientaudiostreamutils.h"
+#include <mmf/common/mmfstandardcustomcommands.h>
+#include <mda/common/audio.h>
+
+const TInt KSampleRate8000 = 8000;
+const TInt KSampleRate11025 = 11025;
+const TInt KSampleRate12000 = 12000;
+const TInt KSampleRate16000 = 16000;
+const TInt KSampleRate22050 = 22050;
+const TInt KSampleRate24000 = 24000;
+const TInt KSampleRate32000 = 32000;
+const TInt KSampleRate44100 = 44100;
+const TInt KSampleRate48000 = 48000;
+const TInt KSampleRate64000 = 64000;
+const TInt KSampleRate88200 = 88200;
+const TInt KSampleRate96000 = 96000;
+
+
+_LIT(KStreamUtilsPanicCategory, "MMFStreamUtils");
+
+enum TStreamUtilsPanic
+ {
+ EPanicBadArgument,
+ EPanicPostConditionViolation,
+ EPanicUnknownSampleRate,
+ EPanicUnknownChannelSetting,
+ EPanicUnknownEncoding
+ };
+
+LOCAL_C void Panic(const TStreamUtilsPanic aReason)
+ {
+ User::Panic(KStreamUtilsPanicCategory, aReason);
+ }
+
+/**
+ *
+ * Function to map the channels enum defined in Mda to the one
+ * defined in MMF
+ *
+ */
+TUint StreamUtils::MapChannelsMdaToMMFL(TInt aMdaChannels)
+ {
+ if (aMdaChannels >= 0)
+ {
+ if (aMdaChannels & TMdaAudioDataSettings::EChannelsStereo)
+ {
+ return EMMFStereo;
+ }
+ else if ((aMdaChannels == 0) || // zeroed settings (it's valid.) return a default value
+ (aMdaChannels & TMdaAudioDataSettings::EChannelsMono))
+ {
+ return EMMFMono;
+ }
+ }
+ // Invalid value
+ User::Leave(KErrNotSupported);
+ return 0;
+ }
+
+/**
+ *
+ * Function to map the sample rate enum defined in Mda to the one
+ * defined in MMF
+ *
+ */
+TUint StreamUtils::MapSampleRateMdaToMMFL(TInt aMdaSampleRate)
+ {
+ switch (aMdaSampleRate)
+ {
+ case TMdaAudioDataSettings::ESampleRate8000Hz:
+ return EMMFSampleRate8000Hz;
+ case TMdaAudioDataSettings::ESampleRate11025Hz:
+ return EMMFSampleRate11025Hz;
+ case TMdaAudioDataSettings::ESampleRate12000Hz:
+ return EMMFSampleRate12000Hz;
+ case TMdaAudioDataSettings::ESampleRate16000Hz:
+ return EMMFSampleRate16000Hz;
+ case TMdaAudioDataSettings::ESampleRate22050Hz:
+ return EMMFSampleRate22050Hz;
+ case TMdaAudioDataSettings::ESampleRate24000Hz:
+ return EMMFSampleRate24000Hz;
+ case TMdaAudioDataSettings::ESampleRate32000Hz:
+ return EMMFSampleRate32000Hz;
+ case TMdaAudioDataSettings::ESampleRate44100Hz:
+ return EMMFSampleRate44100Hz;
+ case TMdaAudioDataSettings::ESampleRate48000Hz:
+ return EMMFSampleRate48000Hz;
+ case TMdaAudioDataSettings::ESampleRate64000Hz:
+ return EMMFSampleRate64000Hz;
+ case TMdaAudioDataSettings::ESampleRate96000Hz:
+ return EMMFSampleRate96000Hz;
+ case TMdaAudioDataSettings::ESampleRateFixed:
+ case TMdaAudioDataSettings::ESampleRateAnyInRange:
+ User::Leave(KErrNotSupported);
+ return 0;
+ case 0: // zeroed settings (it's valid.) return a default value
+ return EMMFSampleRate8000Hz;
+ default:
+ User::Leave(KErrNotSupported);
+ return 0;
+ }
+ }
+
+/**
+ * Function to convert the mmf sample rate enum to an actual sample rate value
+ */
+TInt StreamUtils::SampleRateAsValue(const TMMFCapabilities& aCaps)
+ {
+ switch (aCaps.iRate)
+ {
+ case EMMFSampleRate8000Hz:
+ return KSampleRate8000;
+ case EMMFSampleRate11025Hz:
+ return KSampleRate11025;
+ case EMMFSampleRate12000Hz:
+ return KSampleRate12000;
+ case EMMFSampleRate16000Hz:
+ return KSampleRate16000;
+ case EMMFSampleRate22050Hz:
+ return KSampleRate22050;
+ case EMMFSampleRate24000Hz:
+ return KSampleRate24000;
+ case EMMFSampleRate32000Hz:
+ return KSampleRate32000;
+ case EMMFSampleRate44100Hz:
+ return KSampleRate44100;
+ case EMMFSampleRate48000Hz:
+ return KSampleRate48000;
+ case EMMFSampleRate64000Hz:
+ return KSampleRate64000;
+ case EMMFSampleRate88200Hz:
+ return KSampleRate88200;
+ case EMMFSampleRate96000Hz:
+ return KSampleRate96000;
+ default:
+ Panic(EPanicUnknownSampleRate);
+ return 0;
+ }
+ }
+
+/**
+ * Return the current number of bytes required to render each sample, based
+ * on the given capabilities. This depends on the current encoding and
+ * whether the sample is mono or stereo
+ */
+TInt StreamUtils::BytesPerSample(const TMMFCapabilities& aCaps)
+ {
+ TInt noOfChannels = (aCaps.iChannels == EMMFStereo) ? 2 : 1;
+ switch (aCaps.iEncoding)
+ {
+ case EMMFSoundEncoding8BitPCM:
+ case EMMFSoundEncoding8BitALaw:
+ case EMMFSoundEncoding8BitMuLaw:
+ return (1 * noOfChannels);
+ case EMMFSoundEncoding16BitPCM:
+ return (2 * noOfChannels);
+ default:
+ Panic(EPanicUnknownEncoding);
+ return 0;
+ }
+ }
+/**
+* CalculateLeftRightBalance
+* @param aLeft
+* @param aRight
+* @param aBalance
+* Preconditions:
+* !(aBalance < KMMFBalanceMaxLeft || aBalance > KMMFBalanceMaxRight)
+* y = m x + c
+* aLeft = m ( aBalance ) + c
+* when aBalance = KMMFBalanceMaxLeft aLeft = 100
+* when aBalance = KMMFBalanceMaxRight aLeft = 0
+* 100 = m( KMMFBalanceMaxLeft ) + c
+* 0 = m( KMMFBalanceMaxRight ) + c
+* c = -(KMMFBalanceMaxRight) m
+* 100 = m(KMMFBalanceMaxLeft ) - m(KMMFBalanceMaxRight)
+* m = 100/(KMMFBalanceMaxLeft - KMMFBalanceMaxRight )
+* c = -(KMMFBalanceMaxRight) * 100 /(KMMFBalanceMaxLeft - KMMFBalanceMaxRight )
+* aLeft = ( aBalance - KMMFBalanceMaxRight ) * 100 /( KMMFBalanceMaxLeft - KMMFBalanceMaxRight )
+*/
+void StreamUtils::CalculateLeftRightBalance( TInt& aLeft, TInt& aRight, TInt aBalance )
+ {
+ // [ assert precondition that aBalance is within limits ]
+ __ASSERT_DEBUG( !(aBalance < KMMFBalanceMaxLeft || aBalance > KMMFBalanceMaxRight), Panic(EPanicBadArgument));
+
+ //[ Now separate percentage balances out from aBalance ]
+ aLeft = (100 * (aBalance-KMMFBalanceMaxRight)) / (KMMFBalanceMaxLeft-KMMFBalanceMaxRight);
+ aRight = 100 - aLeft;
+
+ //[ assert post condition that left and right are within range ]
+ __ASSERT_DEBUG( ( (aLeft <= 100) && (aLeft >= 0) ), Panic(EPanicPostConditionViolation));
+ __ASSERT_DEBUG( ( (aRight <= 100) && (aRight >= 0) ), Panic(EPanicPostConditionViolation));
+ }
+
+/**
+* CalculateBalance
+* @param aBalance
+* @param aLeft
+* @param aRight
+*
+* follows a simple straight line transformation
+* y = m x + c
+* m = (KMMFBalanceMaxLeft-KMMFBalanceMaxRight)/ 100
+* c = KMMFBalanceMaxRight
+* by substitution
+* when aLeft = 0
+* KMMFBalanceMaxRight = m * 0 + c
+* c = KMMFBalanceMaxRight
+* when aLeft = 100
+* KMMFBalanceMaxLeft = m * 100 + KMMFBalanceMaxRight
+* m = ( KMMFBalanceMaxLeft - KMMFBalanceMaxRight ) /100
+*/
+#ifdef _DEBUG
+void StreamUtils::CalculateBalance( TInt& aBalance, TInt aLeft, TInt aRight )
+#else
+void StreamUtils::CalculateBalance( TInt& aBalance, TInt aLeft, TInt /*aRight*/ )
+#endif // _DEBUG
+ {
+ //[ assert pre conditions ]
+ __ASSERT_DEBUG( (( aLeft + aRight ) == 100 ), Panic( EPanicBadArgument ));
+ __ASSERT_DEBUG( (( 0 <= aLeft) && ( 100 >= aLeft)), Panic( EPanicBadArgument) );
+ __ASSERT_DEBUG( (( 0 <= aRight) && ( 100 >= aRight)), Panic( EPanicBadArgument) );
+
+ aBalance = (aLeft * (KMMFBalanceMaxLeft-KMMFBalanceMaxRight))/100 + KMMFBalanceMaxRight;
+
+ //[ assert post condition that aBalance is within limits ]
+ __ASSERT_DEBUG( !(aBalance < KMMFBalanceMaxLeft || aBalance > KMMFBalanceMaxRight), Panic(EPanicPostConditionViolation));
+
+ }