--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfintegrationtest/ACLNT/UseOldCodecAudioController/TestUseOldCodecAudioController.cpp Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,2834 @@
+// Copyright (c) 2003-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 <mmf/server/mmfformat.h>
+#include <mmf/server/mmfclip.h>
+#include <mdaaudiosampleeditor.h>
+#include <mmf/plugin/mmfcontrollerimplementationuids.hrh>
+#include <mmf/common/mmffourcc.h>
+#include <mmf/common/mmfpaniccodes.h>
+#include "TestUseOldCodecAudioController.h"
+
+const TUint KSampleRate8000Hz = 8000;
+const TUint KSampleRate11025Hz = 11025;
+const TUint KSampleRate16000Hz = 16000;
+const TUint KSampleRate22050Hz = 22050;
+const TUint KSampleRate32000Hz = 32000;
+const TUint KSampleRate44100Hz = 44100;
+const TUint KSampleRate48000Hz = 48000;
+const TUint KSampleRate88200Hz = 88200;
+const TUint KSampleRate96000Hz = 96000;
+const TUint KNumChannelsMono = 1;
+const TUint KNumChannelsStereo = 2;
+
+/*
+ TMmfAudioControllerPanics is an enumeration with the following entries:
+ EBadArgument indicates a bad argument
+ EBadState indicates a state viaolation
+ EBadInvariant indicates an invariant violation
+ EBadReset indicates failed reset
+ EPostConditionViolation indicates a post condition violation
+*/
+enum TMmfAudioControllerPanics
+ {
+ EBadArgument,
+ EBadState,
+ EBadInvariant,
+ EBadReset,
+ EPostConditionViolation
+ };
+
+/**
+* Panic
+* This method generates a panic
+* @param "TInt"
+* @xxxx
+*/
+void Panic(TInt aPanicCode)
+ {
+ _LIT(KMMFAudioControllerPanicCategory, "MMFAudioController");
+ User::Panic(KMMFAudioControllerPanicCategory, aPanicCode);
+ }
+
+/**
+ * Static NewL
+ *
+ * @return CMMFTestUseOldCodecAudioController*
+ */
+CMMFController* CMMFTestUseOldCodecAudioController::NewL()
+ {
+ CMMFTestUseOldCodecAudioController* self = new(ELeave) CMMFTestUseOldCodecAudioController;
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return STATIC_CAST( CMMFController*, self );
+ }
+
+/**
+* ConstructL
+*
+* @xxxx
+*/
+void CMMFTestUseOldCodecAudioController::ConstructL()
+ {
+ iDataSource = NULL;
+ iDataSink = NULL;
+ iDataPath = CMMFDataPath::NewL(iMediaId, *this);
+ iSourceFormat = NULL;
+ iSinkFormat = NULL;
+ iSourceAndSinkAdded = EFalse;
+ iStoppingRecording = EFalse;
+
+
+ //iMediaId has already been set up
+ SetState( EStopped );
+ //iPrioritySettings not initialised because they are held by the controller framework
+
+ // Construct custom command parsers
+ CMMFAudioPlayDeviceCustomCommandParser* audPlayDevParser = CMMFAudioPlayDeviceCustomCommandParser::NewL(*this);
+ CleanupStack::PushL(audPlayDevParser);
+ AddCustomCommandParserL(*audPlayDevParser);
+ CleanupStack::Pop( audPlayDevParser );//audPlayDevParser
+
+ CMMFAudioRecordDeviceCustomCommandParser* audRecDevParser = CMMFAudioRecordDeviceCustomCommandParser::NewL(*this);
+ CleanupStack::PushL(audRecDevParser);
+ AddCustomCommandParserL(*audRecDevParser);
+ CleanupStack::Pop(audRecDevParser);//audRecDevParser
+
+ CMMFAudioPlayControllerCustomCommandParser* audPlayConParser = CMMFAudioPlayControllerCustomCommandParser::NewL(*this);
+ CleanupStack::PushL(audPlayConParser);
+ AddCustomCommandParserL(*audPlayConParser);
+ CleanupStack::Pop(audPlayConParser);//audPlayConParser
+
+ CMMFAudioRecordControllerCustomCommandParser* audRecConParser = CMMFAudioRecordControllerCustomCommandParser::NewL(*this);
+ CleanupStack::PushL(audRecConParser);
+ AddCustomCommandParserL(*audRecConParser);
+ CleanupStack::Pop(audRecConParser);//audRecParser
+
+ CMMFAudioControllerCustomCommandParser* audConParser = CMMFAudioControllerCustomCommandParser::NewL(*this);
+ CleanupStack::PushL(audConParser);
+ AddCustomCommandParserL(*audConParser);
+ CleanupStack::Pop(audConParser);//audConParser
+
+ iWaitForAsyncService = new (ELeave) CActiveSchedulerWait;
+
+ // [ assert the invariant now that we are constructed ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+ }
+
+/**
+*
+* CMMFTestUseOldCodecAudioController
+*
+*/
+
+CMMFTestUseOldCodecAudioController::CMMFTestUseOldCodecAudioController() : iMediaId(KUidMediaTypeAudio), iState(EStopped)
+ {
+ }
+
+/**
+*
+* ~CMMFTestUseOldCodecAudioController
+*
+*/
+
+CMMFTestUseOldCodecAudioController::~CMMFTestUseOldCodecAudioController()
+ {
+ // [ ensure we have logged off the thread ]
+ if( iDataPath )
+ {
+ iDataPath->ResetL(); // this does not leave
+ }
+ delete iDataPath;
+ delete iSourceFormat;
+ delete iSinkFormat;
+ delete iStoppingMessage;
+ delete iWaitForAsyncService;
+ }
+
+/**
+ * AddDataSourceL
+ *
+ * Adds a data source to the controller
+ *
+ * @param aSource
+ * Preconditions:
+ * We are stopped
+ * Source does not already exist
+ * Postconditions:
+ * iDataSource != NULL
+ * iDataSourceAdded == ETrue
+ */
+void CMMFTestUseOldCodecAudioController::AddDataSourceL(MDataSource& aSource)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ precondition that the controller is stopped ]
+ if( State() != EStopped )
+ User::Leave( KErrNotReady );
+
+ //[ precondition iData source is not already configured ]
+ if (iDataSource)
+ User::Leave(KErrAlreadyExists);
+
+ // Note that this code is not generic for sources
+ // It it only checks for file, des clips and audio inputs
+ // If a new source type eg a Url Clip then this needs to be added to the supported source Uids
+ if ( SourceFormatRequired( aSource) )
+ {
+ // Get the format from the Source if possible from no specific supplier
+ TRAPD(err, iSourceFormat = CMMFFormatDecode::NewL(&aSource, KNullDesC));
+ //[ we want to complete silently for KErrNotSupported
+ // because there is a possibility that the client
+ // wants to add the data format later, see audio api for
+ // a description of this feature]
+ if ((err != KErrNotSupported) && (err != KErrNone))
+ {
+ User::Leave(err);
+ }
+ }
+ else if (aSource.DataSourceType()==KUidMmfAudioInput)
+ {
+ //[ ensure that the audio input has a pointer to dev sound ]
+ CMMFAudioInput* audioInput = STATIC_CAST(CMMFAudioInput*, &aSource);
+ __ASSERT_ALWAYS( audioInput, Panic(EBadInvariant));
+ // [ lets load dev sound ]
+ User::LeaveIfError(audioInput->SourceThreadLogon( *this ));
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+ //[ its now safe to set the source ]
+ iDataSource = &aSource ;
+ iDataSource->SetSourcePrioritySettings(iPrioritySettings);
+
+ //[ assert the post condition ]
+ __ASSERT_ALWAYS(iDataSource, Panic(EMMFAudioControllerPanicDataSourceDoesNotExist));
+
+ }
+
+
+/**
+ * AddDataSinkL
+ *
+ * Adds a data sink to the controller
+ *
+ * @param aSink
+ *
+ */
+void CMMFTestUseOldCodecAudioController::AddDataSinkL(MDataSink& aSink)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ precondition that the controller is stopped ]
+ if( State() != EStopped )
+ User::Leave( KErrNotReady );
+
+ // [ assert precondition that sink does not exist ]
+ if (iDataSink)
+ User::Leave(KErrAlreadyExists);
+
+
+ // Note that this code is not generic for sinks
+ // It it only checks for file,des clips and audio outputs
+ // If a new sink type eg a Url Clip then this needs to be added to the supported source Uids
+ if ( SinkFormatRequired( aSink ) )
+ {//the sink is a clip
+
+ // Get the format from the Sink if possible from no specific supplier
+ TRAPD(err, iSinkFormat = CMMFFormatEncode::NewL(&aSink, KNullDesC));
+ //[ we want to complete silently for KErrNotSupported
+ // because there is a possibility that the client
+ // wants to add the data format later, see audio api for
+ // a description of this feature]
+ if ((err != KErrNotSupported) && (err != KErrNone))
+ {
+ User::Leave(err);
+ }
+ }
+ else if (aSink.DataSinkType()==KUidMmfAudioOutput)
+ {
+
+ //[ ensure that the audio output has a pointer to dev sound ]
+ CMMFAudioOutput* audioOutput = STATIC_CAST(CMMFAudioOutput*, &aSink);
+ __ASSERT_ALWAYS( audioOutput, Panic(EBadInvariant));
+ // [ lets load dev sound ]
+ User::LeaveIfError(audioOutput->SinkThreadLogon( *this ));
+ }
+ else
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+ //[ now that we are sure we have not left we can update the sink
+ // transactionally ]
+ iDataSink = &aSink;
+ iDataSink->SetSinkPrioritySettings(iPrioritySettings);
+
+ // [ assert post conditions that a sink has been added ]
+ __ASSERT_ALWAYS(iDataSink, Panic(EMMFAudioControllerPanicDataSinkDoesNotExist));
+
+ }
+
+/**
+ * PrimeL
+ *
+ * If Prime fails the client should reset the controller
+ * because as noted below this code is not transactional.
+ *
+ */
+void CMMFTestUseOldCodecAudioController::PrimeL()
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ //[ assert the precondition ( in a friendly way for this api
+ // that we are either stopped or primed already ]
+ if(!(( State() == EStopped ) || (State() == EPrimed )))
+ User::Leave( KErrNotReady );
+
+ // [ precondition we have a data source & sink ]
+ __ASSERT_ALWAYS( iDataSource, Panic( EBadInvariant));
+ __ASSERT_ALWAYS( iDataSink, Panic( EBadInvariant));
+
+
+ //[ precondition that we need a source format ]
+ if ( SourceFormatRequired(*iDataSource) && !(iSourceFormat))
+ User::Leave( KErrNotSupported );
+
+ // [ check the precondition if we need a data sink format ]
+ if ( SinkFormatRequired(*iDataSink) && !( iSinkFormat ))
+ User::Leave( KErrNotSupported );
+
+
+ // [ ideally this code should be transaction based and
+ // if failure occurs we roll back to the previous state
+ // in the code below this is not the case and the controller
+ // can be left in an unstable state should any part of prime fail]
+ if (iState == EStopped)
+ { //datapath propagates prime to sink & source
+
+ TFourCC sinkFormatDataType;
+ if ((iSinkFormat)&&(iDataSource))
+ {//audio input so recording
+ //need to assign the sink format 4CC to pcm16
+ //even though it isn't pcm16 , this will cause the audio input
+ //in negotiation to instantiate the null CMMFHwDevice plugin
+ //after the negotiation set it back to the correct datatype
+ //forcing the datapath to use a CMMFCodec
+ sinkFormatDataType = iSinkFormat->SinkDataTypeCode(KUidMediaTypeAudio); //reset this after negotiation
+ iSinkFormat->SetSinkDataTypeCode(KMMFFourCCCodePCM16, KUidMediaTypeAudio);
+ }
+
+ NegotiateL();
+
+ if (!iSourceAndSinkAdded)
+ {
+ //add data source and sinks to datapath - Note cant do this in AddDataSource/Sink
+ //because the sources and sinks aren't configured at this point
+ if (iSourceFormat)
+ iDataPath->AddDataSourceL(iSourceFormat);
+ else if (iDataSource)
+ {//record
+ iDataPath->AddDataSourceL(iDataSource);
+ if (iSinkFormat) //restore the format data type
+ { //this will force datapth to use CMMFCodec
+ iSinkFormat->SetSinkDataTypeCode(sinkFormatDataType,KUidMediaTypeAudio);
+ }
+ }
+ if (iSinkFormat)
+ iDataPath->AddDataSinkL(iSinkFormat);
+ else if (iDataSink)
+ {//play
+ //need to set the audio output fourCC code to pcm16
+ //in order to force the data path to use a CMMFCodec
+ CMMFAudioOutput* ao = static_cast<CMMFAudioOutput*>(iDataSink);
+ CMMFDevSound* devSound = &(ao->SoundDevice());
+
+ //PrimeL() needs to run synchronously but DevSound initialisation is
+ //asynchronous. iWaitForAsyncService halts execution until
+ //iDevSoundEventHandler informs us this process has completed.
+ iDevSoundEventHandler.SetInterceptedDevSoundObserver(ao);
+ iDevSoundEventHandler.SetEventObserver(this);
+ //need to reinitialize the devsound to load up a null pcm16->16
+ //hw device - note this will delete the previous
+ //non pcm16 hw device
+ //note can't set this on the audio output as this won't update
+ //the hw device
+ devSound->InitializeL(iDevSoundEventHandler,KMMFFourCCCodePCM16,EMMFStatePlaying);
+ iWaitForAsyncService->Start();
+
+ //now tell audio output were pcm16
+ iDataSink->SetSinkDataTypeCode(KMMFFourCCCodePCM16, KUidMediaTypeAudio);
+ iDataPath->AddDataSinkL(iDataSink);
+ }
+ iSourceAndSinkAdded = ETrue ;
+ }
+
+ iDataPath->PrimeL();
+ if ((iSinkFormat) && (!iSourceFormat))
+ {//we are recording to a clip so the data path position is the sink
+ //need to set datapath position to end of format pos (incase sink clip already exists
+ TTimeIntervalMicroSeconds duration = iSinkFormat->Duration(iMediaId);
+ if (duration != TTimeIntervalMicroSeconds(0))
+ {//the file already exists and has a duration so set data path position to the end of the file
+ iDataPath->SetPositionL(duration);
+ }
+ }
+ //[ it is now safe to make the transition to primed ]
+ SetState( EPrimed );
+ }
+ else if (State() == EPrimed)
+ { //controller is already primed so just pass prime onto DP
+ iDataPath->PrimeL();
+ }
+
+ //[ assert the post condition that we are in the state primed]
+ __ASSERT_ALWAYS( SetState( EPrimed ), Panic( EPostConditionViolation ));
+ // [ assert the invariant]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ) );
+ }
+
+/**
+ * ResetL
+ * This method resets the controller
+ *
+ */
+void CMMFTestUseOldCodecAudioController::ResetL()
+ {
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ) );
+
+ // Stop recording if it's not stopped,
+ if (State() != EStopped)
+ {
+ iDataPath->Stop();
+ SetState(EStopped);
+ }
+
+ // Remove references to source and sink
+ iDataPath->ResetL();
+
+ delete iSourceFormat; iSourceFormat = NULL ;
+ delete iSinkFormat; iSinkFormat = NULL ;
+
+ //[ ensure loggoff of source and sink ]
+ iDataSource = NULL ;
+ iDataSink = NULL ;
+ iSourceAndSinkAdded = EFalse;
+
+ // [ assert the invariant]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ) );
+
+ // [ assert the post condition
+ // state == stopped
+ // iDataSource is NULL
+ // iSourceFormat is NULL
+ // iSinkFormat is NULL ]
+ __ASSERT_ALWAYS( ResetPostCondition(), Panic( EBadReset ));
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadState));
+ }
+
+/**
+* ResetPostCondition
+* This function determnines if the reset post condition is valid
+* @xxxx
+*/
+TBool CMMFTestUseOldCodecAudioController::ResetPostCondition() const
+ {
+
+ TBool result = EFalse ;
+ if((iSourceFormat == NULL) &&
+ (iDataSink == NULL) &&
+ (iDataSource == NULL) &&
+ (iSinkFormat == NULL) &&
+ (State() == EStopped))
+ {
+ result = ETrue;
+ }
+
+ return result;
+ }
+
+
+/**
+ *
+ * PlayL
+ *
+ */
+void CMMFTestUseOldCodecAudioController::PlayL()
+ {
+ // [ assert the precondition that the
+ // play command is only activated in the primed state]
+ if ( State() != EPrimed)
+ User::Leave(KErrNotReady);
+
+ // [ assert the Invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[datapath propogates play to sink & source]
+ iDataPath->PlayL();
+ SetState( EPlaying );
+
+ //[ assert the post condition we are playing ]
+ //No - this assumption is not always true if an error occurs eg OOM
+ //the state could be EStopped
+ // __ASSERT_ALWAYS( (State() == EPlaying ), Panic( EBadState));
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+ * PauseL
+ *
+ */
+void CMMFTestUseOldCodecAudioController::PauseL()
+ {
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ assert the precondition that we are playing ]
+ if ( State() != EPlaying)
+ User::Leave(KErrNotReady);
+
+ //[ datapath propogates pause to sink & source ]
+ iDataPath->Pause();
+ SetState(EPrimed);
+
+ //[ assert the post condition we are primed ]
+ __ASSERT_ALWAYS( (State() == EPrimed ), Panic( EBadState));
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+ * StopL
+ *
+ */
+void CMMFTestUseOldCodecAudioController::StopL(TMMFMessage& aMessage)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ // [ precondition that we are not already stopped
+ // && if we are stopped do nothing.
+ //If we are stopping a recording, we need to give the datapath chance to
+ //process that data which has already been captured. We therefore stay in the EPlaying
+ //state, but use iStoppingRecording to indicate that we are stopping.
+
+ if ((State() != EStopped) && !iStoppingRecording)
+ {
+ if((State() == EPlaying) && (iDataSource->DataSourceType()==KUidMmfAudioInput)) //we are recording
+ {
+ // datapath is requested to stop recording but process any alreay captured buffers,
+ // the pause method is used for this purpose and as such, the data path must
+ // determine that it is recording to be able to act accordingly.
+ // aMessgae is not completed until datapath advises that it has completed.
+ iDataPath->Pause();
+ iStoppingMessage = CMMFMessageHolder::NewL(aMessage);
+ iStoppingRecording = ETrue;
+ }
+ else
+ {
+ // datapath propogates stop to sink & source
+ iDataPath->Stop();
+ SetState(EStopped);
+ }
+ }
+
+ //complete message as request is complete.
+ if(State() == EStopped && !IsUnderTest())
+ {
+ aMessage.Complete(KErrNone);
+ }
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+ * PositionL
+ * Preconditions:
+ * The Controller is in the state EPrimed
+ * @return TTimeIntervalMicroSeconds
+ *
+ */
+TTimeIntervalMicroSeconds CMMFTestUseOldCodecAudioController::PositionL() const
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ // [ precondition that we are playing or primed ]
+ if( !((State() == EPrimed) || (State() == EPlaying)))
+ User::Leave(KErrNotReady);
+
+ TTimeIntervalMicroSeconds position = iDataPath->Position();
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ return position;
+ }
+
+/**
+* SetPositionL
+*
+* @param aPosition
+*
+*/
+void CMMFTestUseOldCodecAudioController::SetPositionL(const TTimeIntervalMicroSeconds& aPosition)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ // [ precondition that we are not already stopped ]
+ if (iState == EStopped)
+ User::Leave(KErrNotReady);
+
+ //[ precondition that the position is >= 0 && <= Duration ]
+ {
+ TTimeIntervalMicroSeconds theDuration(0);
+ if (iSourceFormat)
+ { //if the source is a clip then the duration always refers to the source - even if the sink is a clip
+ theDuration = iSourceFormat->Duration(iMediaId);
+ }
+ else if (iSinkFormat)
+ { //duration of recorded clip
+ theDuration = iSinkFormat->Duration(iMediaId);
+ }
+ TTimeIntervalMicroSeconds theStart(0);
+ if( ( aPosition < theStart) || ( aPosition > theDuration) )
+ //[ invalid position before start and after end]
+ User::Leave(KErrArgument);
+ }
+
+ //[ set the position on the data path ]
+ iDataPath->SetPositionL(aPosition);
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ // [ post condition not checked ]
+ //[ we do not compare the set position with get postion
+ // because the interface to do so is poor ]
+ }
+
+/**
+*
+* DurationL
+*
+* @returns TTimeIntervalMicroSeconds
+*
+*/
+TTimeIntervalMicroSeconds CMMFTestUseOldCodecAudioController::DurationL() const
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+
+ // [ assert we have a format that supports duration ]
+ if( !( iSourceFormat || iSinkFormat ) )
+ User::Leave(KErrNotSupported);
+
+ //[ now do the real work of getting the duration ]
+ // ------------------------------------------------
+ TTimeIntervalMicroSeconds theDuration(0);
+ if (iSourceFormat)
+ { //if the source is a clip then the duration always refers to the source - even if the sink is a clip
+ theDuration = iSourceFormat->Duration(iMediaId);
+ }
+ else if (iSinkFormat)
+ { //duration of recorded clip
+ theDuration = iSinkFormat->Duration(iMediaId);
+ }
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ return theDuration;
+ }
+
+/**
+*
+* GetNumberOfMetaDataEntriesL
+*
+* @param "TInt"
+*
+*/
+void CMMFTestUseOldCodecAudioController::GetNumberOfMetaDataEntriesL(TInt& aNumberOfEntries )
+ {
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition that we are in the primed state or stopped ]
+ if( !((State() == EPrimed) || ( State() == EStopped)))
+ User::Leave(KErrNotReady);
+
+ // [ precondition there is a sink format ]
+ if (!iDataSink)
+ User::Leave(KErrNotSupported);
+
+ // [ precondition the sink format is an encode format ]
+ if ((iDataSink->DataSinkType()!=KUidMmfAudioOutput) &&
+ (iDataSource->DataSourceType()!= KUidMmfAudioInput) )
+ User::Leave(KErrNotSupported);
+
+ if (iDataSink->DataSinkType()==KUidMmfAudioOutput)
+ {
+
+ //[ precondition the format exists ]
+ if( !iSourceFormat )
+ User::Leave(KErrNotSupported);
+
+ //[ Get the Number of meta data entries from the sink format ]
+ iSourceFormat->GetNumberOfMetaDataEntriesL( aNumberOfEntries );
+ }
+ else if (iDataSource->DataSourceType()==KUidMmfAudioInput)
+ {
+ if( !iSinkFormat )
+ User::Leave(KErrNotSupported);
+
+ iSinkFormat->GetNumberOfMetaDataEntriesL( aNumberOfEntries );
+ }
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+* GetMetaDataEntryL
+* @param aIndex
+* @returns "CMMFMetaDataEntry*"
+*/
+CMMFMetaDataEntry* CMMFTestUseOldCodecAudioController::GetMetaDataEntryL(TInt aIndex )
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition that we are in the primed state or stopped ]
+ if( !((State() == EPrimed) || ( State() == EStopped)))
+ User::Leave(KErrNotReady);
+
+ // [ precondition there is a sink format ]
+ if (!iDataSink)
+ User::Leave(KErrNotSupported);
+
+ iDataSink->DataSinkType();
+ iDataSource->DataSourceType();
+
+ // [ precondition the sink or source is either an audio output or input ]
+ if ((iDataSink->DataSinkType()!= KUidMmfAudioOutput) &&
+ (iDataSource->DataSourceType()!= KUidMmfAudioInput ))
+ User::Leave(KErrNotSupported);
+
+ //[ Get the meta data entry from the sink format ]
+ CMMFMetaDataEntry* theEntry = NULL;
+
+ if (iDataSink->DataSinkType()==KUidMmfAudioOutput)
+ {
+ //[ precondition the format exists ]
+ if( !iSourceFormat )
+ User::Leave(KErrNotSupported);
+
+ //[ Get the Number of meta data entries from the sink format ]
+ theEntry = iSourceFormat->MetaDataEntryL(aIndex);
+ }
+ else if (iDataSource->DataSourceType()==KUidMmfAudioInput)
+ {
+ //[ precondition the format exits ]
+ if( !iSinkFormat )
+ User::Leave(KErrNotSupported);
+ theEntry = iSinkFormat->MetaDataEntryL(aIndex);
+ }
+
+ //[ assert the post condition that the entry is not null ]
+ __ASSERT_ALWAYS( theEntry, Panic(EBadInvariant));
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ return theEntry;
+ }
+
+/**
+* RemoveDataSourceL
+* @param aDataSource
+*
+*/
+void CMMFTestUseOldCodecAudioController::RemoveDataSourceL(MDataSource& aDataSource )
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant) );
+
+ //[ precondition is that we have a data source ]
+ if( !iDataSource )
+ User::Leave(KErrNotReady);
+
+ //[precondition the data source is the data source we have]
+ if( iDataSource != &aDataSource )
+ User::Leave(KErrArgument);
+
+ //[ the controller is in the stopped state ]
+ if(State() != EStopped)
+ User::Leave(KErrNotReady);
+
+ //[ remove the data sink from the controller and delete the format]
+ if( iSourceAndSinkAdded )
+ {
+ __ASSERT_ALWAYS( iDataPath, Panic( EBadState ));
+ //[ Remove references to source and sink ]
+ iDataPath->ResetL();
+ iSourceAndSinkAdded = EFalse ;
+ }
+
+ // [ delete the data sink and format ]
+ iDataSource = NULL ;
+ delete iSourceFormat;
+ iSourceFormat = NULL;
+
+ // [ assert postcondition we are stopped ]
+ __ASSERT_ALWAYS( (State() == EStopped), Panic(EPostConditionViolation) );
+
+ //[ assert postcondition the SourceAndSinkAdded is false ]
+ __ASSERT_ALWAYS( !iSourceAndSinkAdded, Panic( EPostConditionViolation ));
+
+ //[ assert postcondition the data sinkformat is null ]
+ __ASSERT_ALWAYS( (iSourceFormat == NULL ), Panic( EPostConditionViolation ));
+
+ //[ assert postcondition the data sink is null ]
+ __ASSERT_ALWAYS( (iDataSource == NULL ), Panic( EPostConditionViolation ));
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+* RemoveDataSinkL
+*
+* @param aDataSink
+*
+*/
+void CMMFTestUseOldCodecAudioController::RemoveDataSinkL(MDataSink& aDataSink )
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant) );
+
+ //[ precondition is that we have a data sink ]
+ if( !iDataSink )
+ User::Leave(KErrNotSupported);
+
+ //[precondition the data sink is the data sink we have]
+ if( iDataSink != &aDataSink )
+ User::Leave(KErrNotSupported);
+
+ //[ the controller is in the stopped state ]
+ if(State() != EStopped)
+ User::Leave(KErrNotReady);
+
+ //[ remove the data sink from the controller and delete the format]
+ if( iSourceAndSinkAdded )
+ {
+ __ASSERT_ALWAYS( iDataPath, Panic( EBadState ));
+ //[ Remove references to source and sink ]
+ iDataPath->ResetL();
+ iSourceAndSinkAdded = EFalse ;
+ }
+
+ // [ reset data sink referenece and remove the format ]
+ iDataSink = NULL ;
+ delete iSinkFormat;
+ iSinkFormat = NULL;
+
+ // [ assert postcondition we are stopped ]
+ __ASSERT_ALWAYS( (State() == EStopped), Panic(EPostConditionViolation) );
+
+ //[ assert postcondition the SourceAndSinkAdded is false ]
+ __ASSERT_ALWAYS( !iSourceAndSinkAdded, Panic( EPostConditionViolation ));
+
+ //[ assert postcondition the data sinkformat is null ]
+ __ASSERT_ALWAYS( (iSinkFormat == NULL ), Panic( EPostConditionViolation ));
+
+ //[ assert postcondition the data sink is null ]
+ __ASSERT_ALWAYS( (iDataSink == NULL ), Panic( EPostConditionViolation ));
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+ * CustomCommand
+ * @param aMessage
+ */
+void CMMFTestUseOldCodecAudioController::CustomCommand(TMMFMessage& aMessage)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ // [ We do not have any custom commands ]
+ aMessage.Complete(KErrNotSupported);
+ }
+
+/**
+* NegotiateL
+*
+*/
+void CMMFTestUseOldCodecAudioController::NegotiateL()
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //utility function used by custom to negotiate source sink settings after a change
+ if ((iSourceFormat)&&(iSinkFormat)) //convert
+ {
+ iSinkFormat->NegotiateL(*iSourceFormat);
+ iSourceFormat->NegotiateSourceL(*iSinkFormat);
+ iSinkFormat->NegotiateL(*iSourceFormat);
+
+ // check for upsampling attempts
+ if (iSinkFormat->SampleRate() > iSourceFormat->SampleRate())
+ {
+ // we don't support upsampling
+ User::Leave( KErrNotSupported );
+ }
+ }
+ else if ((iDataSource)&&(iSinkFormat)) //record
+ {
+ // need two step negotiation for record
+ // first try to set the audio input settings to match the required settings for recording
+ iDataSource->NegotiateSourceL(*iSinkFormat);
+ // now call negotiateL on the sink in order to tell it what the audio input was set to.
+ iSinkFormat->NegotiateL(*iDataSource);
+ }
+ else if ((iSourceFormat)&&(iDataSink)) //play
+ iDataSink->NegotiateL(*iSourceFormat);
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+ * SetPrioritySettings
+ *
+ * @param aPrioritySettings
+ */
+void CMMFTestUseOldCodecAudioController::SetPrioritySettings(const TMMFPrioritySettings& aPrioritySettings)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ assert the precondition ]
+ if(State() != EStopped)
+ {
+ ASSERT(EFalse); // used to leave here with KErrNotReady
+ return;
+ }
+
+ //[ update the priority settings of the controller]
+ iPrioritySettings = aPrioritySettings;
+
+ //pass settings on to source and sink
+ if (iDataSource)
+ {
+ iDataSource->SetSourcePrioritySettings(iPrioritySettings);
+ }
+ if (iDataSink)
+ {
+ iDataSink->SetSinkPrioritySettings(iPrioritySettings);
+ }
+
+ // assert the post condition
+ //__ASSERT_ALWAYS( (iPrioritySettings == aPrioritySettings), Panic( ));
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+ * SendEventToClient
+ *
+ * @param aEvent
+ */
+TInt CMMFTestUseOldCodecAudioController::SendEventToClient(const TMMFEvent& aEvent)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ TMMFEvent controllerEvent;
+ //Were going to stop playing, force event type to be the correct type
+ controllerEvent.iEventType = KMMFEventCategoryPlaybackComplete;
+ controllerEvent.iErrorCode = aEvent.iErrorCode;
+
+
+
+ //If we receive KErrNone from the DataPath, it indicates that it has
+ //successfully completed playing/converting/recording.
+ if ((aEvent.iEventType == KMMFEventCategoryPlaybackComplete) &&
+ (aEvent.iErrorCode == KErrNone))
+ {
+ if(iStoppingRecording)
+ {
+ iStoppingRecording = EFalse;
+ iDataPath->Stop();
+ SetState( EStopped );
+
+ //complete the clients stop request
+ iStoppingMessage->Complete(KErrNone);
+ delete iStoppingMessage; iStoppingMessage=NULL;
+
+ //we don't want to send an event to the client
+ return KErrNone;
+ }
+ else
+ {//datapath has reached end of file so set internal state to primed
+ SetState( EPrimed );
+ }
+ }
+ else
+ {
+ if ( State()!= EStopped)
+ {
+ //datapath propogates stop to sink & source
+ iDataPath->Stop();
+ SetState( EStopped );
+
+ if(iStoppingRecording)
+ {// an error has occurred while we were waiting for recording to stop,
+ //must complete clients request
+ iStoppingRecording = EFalse;
+ iStoppingMessage->Complete(aEvent.iErrorCode);
+ delete iStoppingMessage; iStoppingMessage=NULL;
+ }
+ }
+ }
+
+ //now send event to client...
+ TInt result = DoSendEventToClient(controllerEvent);
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ return result;
+ }
+
+
+/**
+* MapdSetVolumeL
+*
+* @param aVolume
+*
+*/
+void CMMFTestUseOldCodecAudioController::MapdSetVolumeL(TInt aVolume)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ // [ precondition is true for state
+ // we can set the volume in any state ]
+
+ //[ precondition we have a data sink ]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ // [ precondition that the data sink is an audio output ]
+ // Make sure that iDataSink is an Audio Output
+ if (iDataSink->DataSinkType() != KUidMmfAudioOutput)
+ User::Leave(KErrNotSupported);
+
+ MMMFAudioOutput* audioOutput = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+
+ // [ assert the precondition that aVolume is in range ]
+ TInt maxVolume = audioOutput->SoundDevice().MaxVolume();
+ if( ( aVolume < 0 ) || ( aVolume > maxVolume ))
+ User::Leave(KErrArgument);
+
+ //[ set the volume on the device ]
+ audioOutput->SoundDevice().SetVolume(aVolume);
+
+ //[ assert the post condition volume is equal to a volume]
+ TInt soundVolume = 0;
+ soundVolume = audioOutput->SoundDevice().Volume();
+
+ __ASSERT_ALWAYS( ( soundVolume == aVolume), Panic(EPostConditionViolation));
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+*
+* MapdGetMaxVolumeL
+*
+* @param aMaxVolume
+*
+*/
+void CMMFTestUseOldCodecAudioController::MapdGetMaxVolumeL(TInt& aMaxVolume)
+ {
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ we can get max volume in any state ]
+
+ // [ precondition we must have a data sink ]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ //[ precondition the sink must be an audio output]
+ // Make sure that iDataSink is an Audio Output
+ if (iDataSink->DataSinkType() != KUidMmfAudioOutput)
+ User::Leave(KErrNotSupported);
+
+ //[ get the volume from the device ]
+ MMMFAudioOutput* audioOutput = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ aMaxVolume = audioOutput->SoundDevice().MaxVolume();
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+
+/**
+*
+* MapdGetVolumeL
+*
+* @param aVolume
+*
+*/
+void CMMFTestUseOldCodecAudioController::MapdGetVolumeL(TInt& aVolume)
+ {
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition that we have a data sink ]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ //[ precondition iDataSink is an Audio Output ]
+ if (iDataSink->DataSinkType() != KUidMmfAudioOutput)
+ User::Leave(KErrNotSupported);
+
+ // [ get the volume ]
+ MMMFAudioOutput* audioOutput = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ aVolume = audioOutput->SoundDevice().Volume();
+
+ // [ assert precondition that the volume is in range
+ // 0.. aMaxVolume ]
+ TInt aMaxVolume = audioOutput->SoundDevice().MaxVolume();
+ __ASSERT_ALWAYS( (aVolume <= aMaxVolume), Panic(EBadState));
+ __ASSERT_ALWAYS( (aVolume >= 0), Panic(EBadState));
+
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+*
+* MapdSetVolumeRampL
+*
+* @param aRampDuration
+*
+*/
+void CMMFTestUseOldCodecAudioController::MapdSetVolumeRampL(const TTimeIntervalMicroSeconds& aRampDuration)
+ {
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition that we have a data sink ]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ // [ precondition iDataSink is an Audio Output ]
+ if (iDataSink->DataSinkType() != KUidMmfAudioOutput)
+ User::Leave(KErrNotSupported);
+
+ //[ set the volume ramp ]
+ MMMFAudioOutput* audioOutput = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ audioOutput->SoundDevice().SetVolumeRamp(aRampDuration);
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+
+/**
+*
+* MapdSetBalanceL
+*
+* @param aBalance
+*
+*/
+void CMMFTestUseOldCodecAudioController::MapdSetBalanceL(TInt aBalance)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ precondition is that we have a data sink ]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ // [ precondition is that the data sink is an audio output]
+ if (iDataSink->DataSinkType() != KUidMmfAudioOutput)
+ User::Leave(KErrNotSupported);
+
+ //[ get the audio output ]
+ MMMFAudioOutput* audioOutput = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+
+ // [ separate out left and right balance ]
+ TInt left = 0;
+ TInt right = 0;
+ CalculateLeftRightBalance( left, right, aBalance );
+
+ //[ set the balance ]
+ audioOutput->SoundDevice().SetPlayBalanceL(left, right);
+
+ // [assert the post condition that the balance is set correctly]
+ TInt rightBalance = 0;
+ TInt leftBalance = 0;
+ audioOutput->SoundDevice().GetPlayBalanceL(leftBalance, rightBalance);
+
+ //[ assert post condition holds]
+ TBool postCondition = (( rightBalance == right) && ( leftBalance == left));
+ __ASSERT_ALWAYS( postCondition, Panic( EPostConditionViolation ) );
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+ }
+
+/**
+* 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 )
+* @xxxx
+*/
+void CMMFTestUseOldCodecAudioController::CalculateLeftRightBalance( TInt& aLeft, TInt& aRight, TInt aBalance ) const
+ {
+ // Check the balance is within limits & modify to min or max values if necessary
+ if (aBalance < KMMFBalanceMaxLeft)
+ aBalance = KMMFBalanceMaxLeft;
+ if (aBalance > KMMFBalanceMaxRight)
+ aBalance = KMMFBalanceMaxRight;
+
+ // [ assert precondition that aBalance is within limits ]
+ __ASSERT_ALWAYS( !(aBalance < KMMFBalanceMaxLeft || aBalance > KMMFBalanceMaxRight), Panic(EBadArgument));
+
+ //[ 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_ALWAYS( ( (aLeft <= 100) && (aLeft >= 0) ), Panic(EPostConditionViolation));
+ __ASSERT_ALWAYS( ( (aRight <= 100) && (aRight >= 0) ), Panic(EPostConditionViolation));
+ }
+
+
+/**
+* MapdGetBalanceL
+* @param aBalance
+*
+*/
+void CMMFTestUseOldCodecAudioController::MapdGetBalanceL(TInt& aBalance)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition that we have a sink]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ // [ iDataSink is an Audio Output ]
+ if (iDataSink->DataSinkType() != KUidMmfAudioOutput)
+ User::Leave(KErrNotSupported);
+
+ // [ get the play balance ]
+ MMMFAudioOutput* audioOutput = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ TInt left = 50; // arbitrary values
+ TInt right = 50;
+ audioOutput->SoundDevice().GetPlayBalanceL(left, right);
+ CalculateBalance( aBalance, left, right );
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+* 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
+*/
+void CMMFTestUseOldCodecAudioController::CalculateBalance( TInt& aBalance, TInt aLeft, TInt aRight ) const
+ {
+ //[ assert pre conditions ]
+ __ASSERT_ALWAYS( (( 0 <= aLeft) && ( 100 >= aLeft)), Panic( EBadArgument) );
+ __ASSERT_ALWAYS( (( 0 <= aRight) && ( 100 >= aRight)), Panic( EBadArgument) );
+
+ if ((aLeft > 0) && (aRight > 0))
+ {
+ __ASSERT_ALWAYS( (( aLeft + aRight ) == 100 ), Panic( EBadArgument ));
+ aBalance = (aLeft * (KMMFBalanceMaxLeft-KMMFBalanceMaxRight))/100 + KMMFBalanceMaxRight;
+ }
+ else if ((aLeft == 0) && (aRight == 0))
+ {
+ aBalance = 0;
+ }
+ else if ((aLeft == 0) && (aRight > 0))
+ {
+ aBalance = 100;
+ }
+ else if ((aLeft > 0) && (aRight == 0))
+ {
+ aBalance = -100;
+ }
+
+ //[ assert post condition that aBalance is within limits ]
+ __ASSERT_ALWAYS( !(aBalance < KMMFBalanceMaxLeft || aBalance > KMMFBalanceMaxRight), Panic(EBadArgument));
+
+ }
+
+/**
+* MardSetGainL
+* @param aGain
+*
+*/
+void CMMFTestUseOldCodecAudioController::MardSetGainL(TInt aGain)
+ {
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition we are in the state stopped ]
+ if(State() != EStopped)
+ User::Leave(KErrNotReady);
+
+ // [ assert the precondition that we have a data sink ]
+ if (!iDataSource)
+ User::Leave(KErrNotSupported);
+
+ //[ assert the precondition that the data sink is an audio input ]
+ if (iDataSource->DataSourceType() != KUidMmfAudioInput)
+ User::Leave(KErrNotReady);
+
+ // Set gain of sound device
+ MMMFAudioInput* audioInput = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ audioInput->SoundDevice().SetGain(aGain);
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+* MardGetMaxGainL
+* @param aMaxGain
+*
+*/
+void CMMFTestUseOldCodecAudioController::MardGetMaxGainL(TInt& aMaxGain)
+ {
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ // [ assert the precondition that we have a source ]
+ if (!iDataSource)
+ User::Leave(KErrNotReady);
+
+ //[ assert the precondition that iDataSink is an Audio Input]
+ if (iDataSource->DataSourceType() != KUidMmfAudioInput)
+ User::Leave(KErrNotSupported);
+
+ MMMFAudioInput* audioInput = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ aMaxGain = audioInput->SoundDevice().MaxGain();
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+* MardGetGainL
+* @param aGain
+*
+*/
+void CMMFTestUseOldCodecAudioController::MardGetGainL(TInt& aGain)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ // [ assert the precondition that we have a sink ]
+ if (!iDataSource)
+ User::Leave(KErrNotReady);
+
+ // [ assert the precondition that we have an audio input sink]
+ if (iDataSource->DataSourceType() != KUidMmfAudioInput)
+ User::Leave(KErrNotSupported);
+
+ MMMFAudioInput* audioInput = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ aGain = audioInput->SoundDevice().Gain();
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+
+/**
+ *
+ * MardSetBalanceL
+ * @param aBalance
+ */
+void CMMFTestUseOldCodecAudioController::MardSetBalanceL(TInt aBalance)
+ {
+ // [ assert the invaraiant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ // [ precondition is that we have a data sink ]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ // [ precondition is that the balance is in range ]
+ // Make sure aBalance is in the range -100 <-> 100
+ if (aBalance < KMMFBalanceMaxLeft || aBalance > KMMFBalanceMaxRight)
+ User::Leave(KErrArgument);
+
+ // [ precondition is that the data sink is an audio output]
+ if (iDataSource->DataSourceType() != KUidMmfAudioInput)
+ User::Leave(KErrNotSupported);
+
+
+ //[ get the audio output ]
+ MMMFAudioInput* audioInput = STATIC_CAST(MMMFAudioInput*, iDataSource);
+
+ // [ separate out left and right balance ]
+ TInt left = 0;
+ TInt right = 0;
+ CalculateLeftRightBalance( left, right, aBalance );
+
+ //[ set the balance ]
+ audioInput->SoundDevice().SetRecordBalanceL(left, right);
+
+ // [assert the post condition that the balance is set correctly]
+ TInt rightBalance = 0;
+ TInt leftBalance = 0;
+ audioInput->SoundDevice().GetRecordBalanceL(leftBalance, rightBalance);
+
+ //[ assert post condition holds]
+ TBool postCondition = (( rightBalance == right) && ( leftBalance == left));
+ __ASSERT_ALWAYS( postCondition, Panic( EPostConditionViolation ) );
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ }
+
+/**
+*
+* MardGetBalanceL
+* @param aBalance
+*
+*/
+void CMMFTestUseOldCodecAudioController::MardGetBalanceL(TInt& aBalance)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition that we have a sink]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ // [ iDataSink is an Audio Output ]
+ if (iDataSource->DataSourceType() != KUidMmfAudioInput)
+ User::Leave(KErrNotSupported);
+
+ // [ get the play balance ]
+ MMMFAudioInput* audioInput = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ TInt left = 50; // arbitrary values
+ TInt right = 50;
+ audioInput->SoundDevice().GetRecordBalanceL(left, right);
+ CalculateBalance( aBalance, left, right );
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+* MapcSetPlaybackWindowL
+* @param aStart
+* @param aEnd
+*
+*/
+void CMMFTestUseOldCodecAudioController::MapcSetPlaybackWindowL(const TTimeIntervalMicroSeconds& aStart, const TTimeIntervalMicroSeconds& aEnd)
+ {
+ iDataPath->SetPlayWindowL(aStart, aEnd);
+ }
+
+/**
+* MapcDeletePlaybackWindowL
+*/
+void CMMFTestUseOldCodecAudioController::MapcDeletePlaybackWindowL()
+ {
+ iDataPath->ClearPlayWindowL();
+ }
+
+/**
+* MapcGetLoadingProgressL
+*/
+void CMMFTestUseOldCodecAudioController::MapcGetLoadingProgressL(TInt& /*aPercentageComplete*/)
+ {
+ User::Leave(KErrNotSupported);
+ }
+
+
+/**
+* MarcGetRecordTimeAvailableL
+* @param aTime
+*
+*/
+void CMMFTestUseOldCodecAudioController::MarcGetRecordTimeAvailableL(TTimeIntervalMicroSeconds& aTime)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ assert the precondition ( in a friendly way for this api
+ // that we minimally have a data sink ]
+ if( !iDataSink )
+ User::Leave( KErrNotReady );
+
+ // Use the FormatEncode to get the bytes per second and the sink (clip) to get the bytes available
+ // return the calculated value.
+ if ((iDataSink->DataSinkType() != KUidMmfFileSink) && (iDataSink->DataSinkType() != KUidMmfDescriptorSink))
+ User::Leave(KErrNotSupported) ;
+
+ // [ max file size ]
+ //[ pre condition is that we have a sink ]
+
+ // In order to get the record time available we need to take into consideration
+ // that there may be a max file size ]
+ TInt64 bytesFree = STATIC_CAST(CMMFClip*, iDataSink)->BytesFree() ;
+ TInt64 bytesPerSecond = TInt64(0);
+ //[ set default time available ]
+ aTime = TTimeIntervalMicroSeconds( 0 ) ; // just return zero
+
+ if( iSinkFormat )
+ {
+ TInt maxFileSize = STATIC_CAST(CMMFFormatEncode*, iSinkFormat)->MaximumClipSize();
+ //[ if maxFileSize > 0 we need to limit the bytes free to this value - size ]
+ if( maxFileSize > 0 )
+ {
+ // [ strangely the size of data written is a TInt ]
+ TInt fileSize = STATIC_CAST(CMMFClip*, iDataSink)->Size();
+ bytesFree = maxFileSize - fileSize;
+ // [ note it can occur that the fileSize id greater than the MaxFileSize
+ // due to someone setting the max file size on an existing file ]
+ if( bytesFree < 0 ) bytesFree = 0;
+ __ASSERT_DEBUG( ( bytesFree <= maxFileSize), Panic( EBadInvariant) );
+ }
+ bytesPerSecond = STATIC_CAST(CMMFFormatEncode*, iSinkFormat)->BytesPerSecond() ;
+ }
+
+ //[ now lets perform the calculation of time available ]
+ if ( bytesPerSecond != TInt64(0) )
+ {
+ aTime = TTimeIntervalMicroSeconds( bytesFree * KOneSecondInMicroSeconds / bytesPerSecond ) ;
+ }
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+* MarcSetMaxDurationL
+* @param aMaxDuration
+*/
+void CMMFTestUseOldCodecAudioController::MarcSetMaxDurationL(const TTimeIntervalMicroSeconds& )
+ {
+ //[ this method is deprecated and no longer supported ]
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+* MarcSetMaxFileSizeL
+* @param aFileSize
+* @precondition
+* The argument aFileSize must be greater than -1
+* zero is used as a sentinel value which means that the file
+* can grow without limit
+*/
+void CMMFTestUseOldCodecAudioController::MarcSetMaxFileSizeL(TInt aFileSize )
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ assert the state is not playing since this opens open
+ // nefarious posibilities
+ if(State() == EPlaying )
+ User::Leave( KErrNotReady );
+
+ //[ assert we have a sink format ]
+ if( !iSinkFormat )
+ User::Leave( KErrNotReady );
+
+ //[ assert file size > -1, as a basic sanity filter
+ // 0 is the sentinel value which allows a file to grow
+ // as needed ]
+ if( aFileSize < 0 )
+ User::Leave( KErrArgument );
+
+ //[ pre condition is that we have a sink ]
+ STATIC_CAST(CMMFFormatEncode*, iSinkFormat)->SetMaximumClipSizeL( aFileSize );
+
+ // [ assert the post condition ]
+ // [since we have no means of querying the value
+ // we have to assume all went well for now or we left]
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+* MarcCropL
+* @param aToEnd
+*/
+void CMMFTestUseOldCodecAudioController::MarcCropL(TBool aToEnd)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition there is a sink format]
+ if (!iSinkFormat)
+ User::Leave(KErrNotSupported);
+
+ iSinkFormat->CropL( PositionL(), aToEnd );
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+* MarcAddMetaDataEntryL
+* @param aNewEntry
+*/
+void CMMFTestUseOldCodecAudioController::MarcAddMetaDataEntryL(const CMMFMetaDataEntry& aNewEntry )
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition the format exists ]
+ if( !iSinkFormat )
+ User::Leave(KErrNotSupported);
+
+ //[ Add the meta data entry ]
+ iSinkFormat->AddMetaDataEntryL( aNewEntry );
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+* MarcRemoveMetaDataEntryL
+* @param aIndex
+*/
+void CMMFTestUseOldCodecAudioController::MarcRemoveMetaDataEntryL(TInt aIndex)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition that we are in the primed state ]
+ if( State() != EPrimed)
+ User::Leave(KErrNotReady);
+
+ //[ precondition the format exists ]
+ if( !iSinkFormat )
+ User::Leave(KErrNotSupported);
+
+ //[ remove the meta data entry ]
+ iSinkFormat->RemoveMetaDataEntry( aIndex );
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+* MarcReplaceMetaDataEntryL
+* @param aIndex
+* @param aNewEntry
+*/
+void CMMFTestUseOldCodecAudioController::MarcReplaceMetaDataEntryL(TInt aIndex, const CMMFMetaDataEntry& aNewEntry)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ precondition that we are in the primed state ]
+ if( State() != EPrimed)
+ User::Leave(KErrNotReady);
+
+ //[ precondition the format exists ]
+ if( !iSinkFormat )
+ User::Leave(KErrNotSupported);
+
+ //[ replace meta data entry ]
+ iSinkFormat->ReplaceMetaDataEntryL( aIndex, aNewEntry );
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ }
+
+/**
+* MacSetSourceSampleRateL
+* @param aSampleRate
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSourceSampleRateL(TUint aSampleRate)
+ {
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ assert the precondition we are stopped ]
+ if( State() != EStopped )
+ User::Leave(KErrNotReady);
+
+
+ if (iSourceFormat)
+ {//only applicable to formats
+ // don't throw an error if the clip already exists with a different sample rate
+ TInt error = iSourceFormat->SetSampleRate(aSampleRate);
+ if (error != KErrNone && error != KErrAlreadyExists)
+ User::Leave(error);
+ }
+ else if (iDataSource && (iDataSource->DataSourceType()==KUidMmfAudioInput))
+ {
+ // cast iDataSource to audio input and set sample rate
+ MMMFAudioInput* ai = STATIC_CAST(MMMFAudioInput*, iDataSource);
+
+ //note that it is safe to call SoundDevice()
+ //as the controller logs onto the iDataSource when it is added
+ TMMFCapabilities devSoundConfig = ai->SoundDevice().Config();
+
+ ConvertFromSampleRateToDevSoundCapsL(aSampleRate, devSoundConfig);
+ ai->SoundDevice().SetConfigL(devSoundConfig);
+ //ReNegotiateL();
+ }
+ else
+ User::Leave(KErrNotSupported);
+
+ // [assert the post condition ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ }
+
+/**
+* MacSetSourceNumChannelsL
+* @param aNumChannels
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSourceNumChannelsL(TUint aNumChannels)
+ {
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [assert the precondition that we are stopped ]
+ if( State() != EStopped )
+ User::Leave(KErrNotReady);
+
+ if (iSourceFormat)
+ {//only applicable to formats
+ // don't throw an error if the clip already exists with a different number of channels
+ TInt error = iSourceFormat->SetNumChannels(aNumChannels);
+ if (error != KErrNone && error != KErrAlreadyExists)
+ User::Leave(error);
+ }
+ else if (iDataSource && (iDataSource->DataSourceType()==KUidMmfAudioInput))
+ {
+ // cast iDataSource to audio input and set num channels
+ MMMFAudioInput* ai = STATIC_CAST(MMMFAudioInput*, iDataSource);
+
+ //note that it is safe to call SoundDevice()
+ //as the controller logs onto the iDataSource when it is added
+ TMMFCapabilities devSoundConfig = ai->SoundDevice().Config();
+
+ ConvertFromNumChannelsToDevSoundCapsL(aNumChannels, devSoundConfig);
+ ai->SoundDevice().SetConfigL(devSoundConfig);
+ //ReNegotiateL();
+ }
+ else
+ User::Leave(KErrNotSupported);
+
+ // [ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ }
+
+/**
+* MacSetSourceFormatL
+* @param aFormatUid
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSourceFormatL(TUid aFormatUid)
+ {
+ //[ assert the invaraint ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ precondition that the controller is stopped ]
+ if( State() != EStopped )
+ User::Leave( KErrNotReady );
+
+ //[ precondition that the data source exists]
+ if (!iDataSource)
+ User::Leave(KErrNotReady);
+
+ //[ precondition that we need a format ]
+ if( !SourceFormatRequired( *iDataSource ) )
+ User::Leave(KErrNotSupported); //cant set source format if source isn't a clip
+
+ //[ if the format exists and the uid of the requested
+ // format is the same as the existing format then simply
+ // return otherwise create a new format ]
+ if( !((iSourceFormat) && ( iSourceFormat->ImplementationUid() == aFormatUid)))
+ {
+ // [ delete the old format regardless ]
+ delete iSourceFormat;
+ iSourceFormat = NULL;
+ iSourceFormat = CMMFFormatDecode::NewL(aFormatUid, iDataSource);
+ }
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ //[ assert the post condition that a source format has been constructed ]
+ __ASSERT_ALWAYS( (iSourceFormat != NULL), Panic( EPostConditionViolation ));
+ }
+
+/**
+* MacSetSinkSampleRateL
+* @param aSampleRate
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSinkSampleRateL(TUint aSampleRate)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ assert the precondition that we are stopped ]
+ if (State() != EStopped )
+ User::Leave(KErrNotReady);
+
+ if (iSinkFormat)
+ {//only applicable to formats
+ // don't throw an error if the clip already exists with a different sample rate
+ TInt error = iSinkFormat->SetSampleRate(aSampleRate);
+ if (error != KErrNone && error != KErrAlreadyExists)
+ User::Leave(error);
+ }
+ else if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ // cast iDataSink to audio output and set sample rate
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+
+
+
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Config();
+ ConvertFromSampleRateToDevSoundCapsL(aSampleRate, devSoundConfig);
+ ao->SoundDevice().SetConfigL(devSoundConfig);
+ }
+ else
+ User::Leave(KErrNotSupported);
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+ }
+
+/**
+* MacSetSinkNumChannelsL
+* @param aNumChannels
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSinkNumChannelsL(TUint aNumChannels)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ assert the precondition that we are stopped ]
+ if (State() != EStopped )
+ User::Leave(KErrNotReady);
+
+ if (iSinkFormat)
+ {//only applicable to formats
+ // don't throw an error if the clip already exists with a different number of channels
+ TInt error = iSinkFormat->SetNumChannels(aNumChannels);
+ if (error != KErrNone && error != KErrAlreadyExists)
+ User::Leave(error);
+ }
+ else if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ // cast iDataSink to audio output and set num channels
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+
+ //note that it is safe to call SoundDevice()
+ //as the controller logs onto the iDataSource when it is added
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Config();
+ ConvertFromNumChannelsToDevSoundCapsL(aNumChannels, devSoundConfig);
+ ao->SoundDevice().SetConfigL(devSoundConfig);
+ }
+ else
+ User::Leave(KErrNotSupported);
+
+ // [assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ }
+
+/**
+* MacSetSinkFormatL
+* @param aFormatUid
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSinkFormatL(TUid aFormatUid)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ precondition that the controller is stopped ]
+ if( State() != EStopped )
+ User::Leave( KErrNotReady );
+
+ //[ precondition that the data sink exists]
+ if (!iDataSink)
+ User::Leave(KErrNotReady);
+
+ //[ precondition that we need a format ]
+ if (!SinkFormatRequired( *iDataSink))
+ User::Leave(KErrNotSupported);
+
+ //[ if the format exists and the uid of the requested
+ // format is the same as the existing format then simply
+ // return ]
+ if( !((iSinkFormat) && ( iSinkFormat->ImplementationUid() == aFormatUid)))
+ {
+ // [ delete the old format regardless ]
+ delete iSinkFormat;
+ iSinkFormat = NULL;
+ iSinkFormat = CMMFFormatEncode::NewL(aFormatUid, iDataSink);
+ }
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ //[ assert the post condition that a sink format has been constructed ]
+ __ASSERT_ALWAYS( (iSinkFormat != NULL), Panic( EPostConditionViolation ));
+ }
+
+
+/**
+* MacSetCodecL
+* @param aSourceDataType
+* @param aSinkDataType
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacSetCodecL(TFourCC aSourceDataType, TFourCC aSinkDataType)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ assert the precondition ]
+ if(State() != EStopped)
+ User::Leave(KErrNotReady);
+
+ //don't set codec directly -just set source & sink fourCC codes
+ //[ ]
+ TInt error(KErrNone);
+ if ((iSinkFormat)&&(aSinkDataType != KMMFFourCCCodeNULL))
+ {
+ error = iSinkFormat->SetSinkDataTypeCode(aSinkDataType,iMediaId);
+ }
+ else if((iDataSink) && (aSinkDataType != KMMFFourCCCodeNULL))
+ {
+ error = iDataSink->SetSinkDataTypeCode(aSinkDataType,iMediaId);
+ }
+ if ((iSourceFormat)&&(!error)&&(aSourceDataType != KMMFFourCCCodeNULL))
+ {
+ error = iSourceFormat->SetSourceDataTypeCode(aSourceDataType,iMediaId);
+ }
+ else if ((iDataSource) && (aSourceDataType != KMMFFourCCCodeNULL))
+ {
+ error = iDataSource->SetSourceDataTypeCode(aSourceDataType,iMediaId);
+ }
+
+ //[ leave if we are not ready or there was an error ]
+ User::LeaveIfError(error);
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+ }
+
+/**
+* MacSetSourceBitRateL
+* @param "TUint"
+* Sets the source bit rate
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSourceBitRateL(TUint aBitRate)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic(EBadInvariant));
+
+ //[ assert the precondition ]
+ if(State() != EStopped)
+ User::Leave(KErrNotReady);
+
+ //[ pre condition that we have a source format]
+ if (!iSourceFormat)
+ User::Leave(KErrNotSupported);
+
+ //only applicable to formats
+ User::LeaveIfError(iSourceFormat->SetBitRate(aBitRate));
+
+ //[ assert the set bit rate is the bit rate ]
+ __ASSERT_ALWAYS( (aBitRate == iSourceFormat->BitRate()), Panic( EPostConditionViolation ));
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+ }
+
+
+/**
+*
+* MacSetSourceDataTypeL
+* @param "TFourCC"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSourceDataTypeL(TFourCC aDataType)
+ {
+ MacSetCodecL(aDataType, KMMFFourCCCodeNULL);
+ }
+
+/**
+*
+* MacSetSinkBitRateL
+* @param "TUint"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSinkBitRateL(TUint aRate)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // [ assert we are stopped ]
+ if( State() != EStopped)
+ User::Leave( KErrNotReady );
+
+ //[ pre condition we have a sink format ]
+ if (!iSinkFormat)
+ User::Leave(KErrNotSupported);
+
+ //only applicable to formats
+ User::LeaveIfError(iSinkFormat->SetBitRate(aRate));
+
+ //[ assert the set bit rate is the bit rate ]
+ __ASSERT_ALWAYS( (aRate == iSinkFormat->BitRate()), Panic( EBadInvariant));
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+ }
+
+/**
+*
+* MacSetSinkDataTypeL
+* @param "TFourCC"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacSetSinkDataTypeL(TFourCC aDataType)
+ {
+ MacSetCodecL(KMMFFourCCCodeNULL, aDataType);
+
+ if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Config();
+ RArray<TFourCC> dataTypes;
+ CleanupClosePushL(dataTypes);
+
+ //[ set dev sound data type here ]
+ ConvertFromDataTypeToDevSoundCapsL(aDataType, devSoundConfig);
+ ao->SoundDevice().SetConfigL(devSoundConfig);
+ CleanupStack::PopAndDestroy();//dataTypes
+ }
+ }
+
+/**
+*
+* MacGetSourceSampleRateL
+* @param "TUint"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSourceSampleRateL(TUint& aRate)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ //[ precondition is that we have a source format ||
+ // we have a data source and its an audio input ]
+ if( !((iDataSource && (iDataSource->DataSourceType()==KUidMmfAudioInput)) ||
+ ( iSourceFormat )))
+ User::Leave(KErrNotSupported);
+
+ if (iSourceFormat)
+ {
+ aRate = iSourceFormat->SampleRate();
+ }
+ else
+ {
+ // cast iDataSource to audio input and query sample rate
+ MMMFAudioInput* ai = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ TMMFCapabilities devSoundConfig = ai->SoundDevice().Config();
+ RArray<TUint> rates;
+ CleanupClosePushL(rates);
+ ConvertFromDevSoundCapsToSampleRatesL(devSoundConfig, rates);
+ ASSERT(rates.Count()==1);//make sure we've been given the correct config by devsound
+ aRate = rates[0];
+ CleanupStack::PopAndDestroy();//rates
+ }
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+ }
+
+/**
+*
+* MacGetSourceBitRateL
+* @param "TUint"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSourceBitRateL(TUint& aRate)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ // Can only query formats for bit rate - devsound doesn't do bit rates.
+ if (!iSourceFormat)
+ User::Leave(KErrNotSupported);
+
+ aRate = iSourceFormat->BitRate();
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ }
+
+/**
+*
+* MacGetSourceNumChannelsL
+* @param "TUint&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSourceNumChannelsL(TUint& aNumChannels)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ //[ assert the precondition ]
+ if( !((iSourceFormat) ||
+ (iDataSource && (iDataSource->DataSourceType()==KUidMmfAudioInput))))
+ User::Leave(KErrNotSupported);
+
+ if (iSourceFormat)
+ {
+ aNumChannels = iSourceFormat->NumChannels();
+ }
+ else
+ {
+ // cast iDataSource to audio input and query num channels
+ MMMFAudioInput* ai = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ TMMFCapabilities devSoundConfig = ai->SoundDevice().Config();
+ RArray<TUint> numChannels;
+ CleanupClosePushL(numChannels);
+ ConvertFromDevSoundCapsToNumChannelsL(devSoundConfig, numChannels);
+ ASSERT(numChannels.Count()==1);
+ aNumChannels = numChannels[0];
+ CleanupStack::PopAndDestroy();//numChannels
+ }
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ }
+
+/**
+*
+* MacGetSourceFormatL
+* @param "TUid"
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSourceFormatL(TUid& aFormat)
+ {
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ //[ precondition we have a format ]
+ if (!iSourceFormat)
+ User::Leave(KErrNotSupported);
+
+ // [ get the source format uid ]
+ aFormat = iSourceFormat->ImplementationUid();
+
+ //[ assert the invariant ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant));
+
+ }
+
+/**
+*
+* MacGetSourceDataTypeL
+* @param "TFourCC&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSourceDataTypeL(TFourCC& aDataType)
+ {
+ if (iSourceFormat)
+ aDataType = iSourceFormat->SourceDataTypeCode(TMediaId(KUidMediaTypeAudio));
+ else if (iDataSource && (iDataSource->DataSourceType()==KUidMmfAudioInput))
+ {
+ // cast iDataSource to audio input and query num channels
+ MMMFAudioInput* ai = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ TMMFCapabilities devSoundConfig = ai->SoundDevice().Config();
+ RArray<TFourCC> dataTypes;
+ CleanupClosePushL(dataTypes);
+ ConvertFromDevSoundCapsToDataTypesL(devSoundConfig, dataTypes);
+ ASSERT(dataTypes.Count()==1);
+ aDataType = dataTypes[0];
+ CleanupStack::PopAndDestroy();//dataTypes
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* MacGetSinkSampleRateL
+* @param "TUint&"
+*
+*/
+
+void CMMFTestUseOldCodecAudioController::MacGetSinkSampleRateL(TUint& aRate)
+ {
+ if (iSinkFormat)
+ aRate = iSinkFormat->SampleRate();
+ else if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ // cast iDataSink to audio output and query sample rate
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Config();
+ RArray<TUint> rates;
+ CleanupClosePushL(rates);
+ ConvertFromDevSoundCapsToSampleRatesL(devSoundConfig, rates);
+ ASSERT(rates.Count()==1);//make sure we've been given the correct config by devsound
+ aRate = rates[0];
+ CleanupStack::PopAndDestroy();//rates
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* MacGetSinkBitRateL
+* @param "TUint&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSinkBitRateL(TUint& aRate)
+ {
+ if (iSinkFormat)
+ aRate = iSinkFormat->BitRate();
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* MacGetSinkNumChannelsL
+* @param "TUint&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSinkNumChannelsL(TUint& aNumChannels)
+ {
+ if (iSinkFormat)
+ aNumChannels = iSinkFormat->NumChannels();
+ else if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ // cast iDataSink to audio output and query num channels
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Config();
+ RArray<TUint> numChannels;
+ CleanupClosePushL(numChannels);
+ ConvertFromDevSoundCapsToNumChannelsL(devSoundConfig, numChannels);
+ ASSERT(numChannels.Count()==1);
+ aNumChannels = numChannels[0];
+ CleanupStack::PopAndDestroy();//numChannels
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* MacGetSinkFormatL
+* @param "TUid&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSinkFormatL(TUid& aFormat)
+ {
+ if (iSinkFormat)
+ aFormat = iSinkFormat->ImplementationUid();
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* MacGetSinkDataTypeL
+* @param "TFourCC&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSinkDataTypeL(TFourCC& aDataType)
+ {
+ if (iSinkFormat)
+ aDataType = iSinkFormat->SinkDataTypeCode(TMediaId(KUidMediaTypeAudio));
+ else if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ // cast iDataSink to audio output and query data type
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Config();
+ RArray<TFourCC> dataTypes;
+ CleanupClosePushL(dataTypes);
+ ConvertFromDevSoundCapsToDataTypesL(devSoundConfig, dataTypes);
+ ASSERT(dataTypes.Count()==1);
+ aDataType = dataTypes[0];
+ CleanupStack::PopAndDestroy();//dataTypes
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* MacGetSupportedSourceSampleRatesL
+* @param "RArray<TUint>&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSupportedSourceSampleRatesL(RArray<TUint>& aSupportedRates)
+ {
+ aSupportedRates.Reset();
+ if (iSourceFormat)
+ iSourceFormat->GetSupportedSampleRatesL(aSupportedRates);
+ else if (iDataSource && (iDataSource->DataSourceType()==KUidMmfAudioInput))
+ {
+ // cast iDataSource to audio input and query supported sample rates
+ MMMFAudioInput* ai = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ TMMFCapabilities devSoundConfig = ai->SoundDevice().Capabilities();
+ ConvertFromDevSoundCapsToSampleRatesL(devSoundConfig, aSupportedRates);
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* MacGetSupportedSourceBitRatesL
+* @param "RArray<TUint>&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSupportedSourceBitRatesL(RArray<TUint>& aSupportedRates)
+ {
+ aSupportedRates.Reset();
+ if (iSourceFormat)
+ iSourceFormat->GetSupportedBitRatesL(aSupportedRates);
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/***
+*
+* MacGetSupportedSourceNumChannelsL
+* @param "RArray<TUint>&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSupportedSourceNumChannelsL(RArray<TUint>& aSupportedChannels)
+ {
+ aSupportedChannels.Reset();
+ if (iSourceFormat)
+ iSourceFormat->GetSupportedNumChannelsL(aSupportedChannels);
+ else if (iDataSource && (iDataSource->DataSourceType()==KUidMmfAudioInput))
+ {
+ // cast iDataSource to audio input and query supported num channels
+ MMMFAudioInput* ai = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ TMMFCapabilities devSoundConfig = ai->SoundDevice().Capabilities();
+ ConvertFromDevSoundCapsToNumChannelsL(devSoundConfig, aSupportedChannels);
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/***
+*
+* MacGetSupportedSourceDataTypesL
+* @param "RArray<TFourCC>&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSupportedSourceDataTypesL(RArray<TFourCC>& aSupportedDataTypes)
+ {
+ aSupportedDataTypes.Reset();
+ if (iSourceFormat)
+ iSourceFormat->GetSupportedDataTypesL(TMediaId(KUidMediaTypeAudio), aSupportedDataTypes);
+ else if (iDataSource && (iDataSource->DataSourceType()==KUidMmfAudioInput))
+ {
+ // cast iDataSource to audio input and query supported data types
+ MMMFAudioInput* ai = STATIC_CAST(MMMFAudioInput*, iDataSource);
+ TMMFCapabilities devSoundConfig = ai->SoundDevice().Capabilities();
+ ConvertFromDevSoundCapsToDataTypesL(devSoundConfig, aSupportedDataTypes);
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/***
+*
+* MacGetSupportedSinkSampleRatesL
+* @param "RArray<TUint>& "
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSupportedSinkSampleRatesL(RArray<TUint>& aSupportedRates)
+ {
+ aSupportedRates.Reset();
+ if (iSinkFormat)
+ iSinkFormat->GetSupportedSampleRatesL(aSupportedRates);
+ else if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ // cast iDataSink to audio output and query supported sample rates
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Capabilities();
+ ConvertFromDevSoundCapsToSampleRatesL(devSoundConfig, aSupportedRates);
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/***
+*
+* MacGetSupportedSinkBitRatesL
+* @param RArray<TUint>&
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSupportedSinkBitRatesL(RArray<TUint>& aSupportedRates)
+ {
+ if (iSinkFormat)
+ iSinkFormat->GetSupportedBitRatesL(aSupportedRates);
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/***
+*
+* MacGetSupportedSinkNumChannelsL
+* @param RArray<TUint>&
+*
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSupportedSinkNumChannelsL(RArray<TUint>& aSupportedChannels)
+ {
+ aSupportedChannels.Reset();
+ if (iSinkFormat)
+ iSinkFormat->GetSupportedNumChannelsL(aSupportedChannels);
+ else if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ // cast iDataSink to audio output and query supported channels
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Capabilities();
+ ConvertFromDevSoundCapsToNumChannelsL(devSoundConfig, aSupportedChannels);
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/***
+*
+* MacGetSupportedSinkDataTypesL
+* @param "RArray<TFourCC>&"
+*/
+void CMMFTestUseOldCodecAudioController::MacGetSupportedSinkDataTypesL(RArray<TFourCC>& aSupportedDataTypes)
+ {
+ aSupportedDataTypes.Reset();
+ if (iSinkFormat)
+ iSinkFormat->GetSupportedDataTypesL(TMediaId(KUidMediaTypeAudio), aSupportedDataTypes);
+ else if (iDataSink && (iDataSink->DataSinkType()==KUidMmfAudioOutput))
+ {
+ // cast iDataSink to audio output and query supported data types
+ MMMFAudioOutput* ao = STATIC_CAST(MMMFAudioOutput*, iDataSink);
+ TMMFCapabilities devSoundConfig = ao->SoundDevice().Capabilities();
+ ConvertFromDevSoundCapsToDataTypesL(devSoundConfig, aSupportedDataTypes);
+ }
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* ConvertFromDevSoundCapsToSampleRatesL
+* @param "const TMMFCapabilities& "
+* @param "RArray<TUint>&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::ConvertFromDevSoundCapsToSampleRatesL(const TMMFCapabilities& aDevSoundCaps, RArray<TUint>& aSampleRates)
+ {
+ if (aDevSoundCaps.iRate & EMMFSampleRate8000Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate8000Hz));
+ if (aDevSoundCaps.iRate & EMMFSampleRate11025Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate11025Hz));
+ if (aDevSoundCaps.iRate & EMMFSampleRate16000Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate16000Hz));
+ if (aDevSoundCaps.iRate & EMMFSampleRate22050Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate22050Hz));
+ if (aDevSoundCaps.iRate & EMMFSampleRate32000Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate32000Hz));
+ if (aDevSoundCaps.iRate & EMMFSampleRate44100Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate44100Hz));
+ if (aDevSoundCaps.iRate & EMMFSampleRate48000Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate48000Hz));
+ if (aDevSoundCaps.iRate & EMMFSampleRate88200Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate88200Hz));
+ if (aDevSoundCaps.iRate & EMMFSampleRate96000Hz)
+ User::LeaveIfError(aSampleRates.Append(KSampleRate96000Hz));
+ }
+
+/**
+*
+* ConvertFromDevSoundCapsToNumChannelsL
+* @param "const TMMFCapabilities&"
+* @param "RArray<TUint>&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::ConvertFromDevSoundCapsToNumChannelsL(const TMMFCapabilities& aDevSoundCaps, RArray<TUint>& aNumChannels)
+ {
+ if (aDevSoundCaps.iChannels & EMMFMono)
+ User::LeaveIfError(aNumChannels.Append(KNumChannelsMono));
+ if (aDevSoundCaps.iChannels & EMMFStereo)
+ User::LeaveIfError(aNumChannels.Append(KNumChannelsStereo));
+ }
+
+/**
+*
+* ConvertFromDevSoundCapsToDataTypesL
+* @param "const TMMFCapabilities&"
+* @param "TMMFCapabilities& aDevSoundCaps, RArray<TFourCC>&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::ConvertFromDevSoundCapsToDataTypesL(const TMMFCapabilities& aDevSoundCaps, RArray<TFourCC>& aDataTypes)
+ {
+ if (aDevSoundCaps.iEncoding & EMMFSoundEncoding8BitPCM)
+ User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCM8));
+ if (aDevSoundCaps.iEncoding & EMMFSoundEncoding16BitPCM)
+ User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCM16));
+ if (aDevSoundCaps.iEncoding & EMMFSoundEncoding8BitALaw)
+ User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodeALAW));
+ if (aDevSoundCaps.iEncoding & EMMFSoundEncoding8BitMuLaw)
+ User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodeMuLAW));
+ }
+
+/**
+*
+* ConvertFromSampleRateToDevSoundCapsL
+* @param "TUint"
+* @param "TMMFCapabilities&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::ConvertFromSampleRateToDevSoundCapsL(TUint aSampleRate, TMMFCapabilities& aDevSoundCaps)
+ {
+ if (aSampleRate == KSampleRate8000Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate8000Hz;
+ else if (aSampleRate == KSampleRate11025Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate11025Hz;
+ else if (aSampleRate == KSampleRate16000Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate16000Hz;
+ else if (aSampleRate == KSampleRate22050Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate22050Hz;
+ else if (aSampleRate == KSampleRate32000Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate32000Hz;
+ else if (aSampleRate == KSampleRate44100Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate44100Hz;
+ else if (aSampleRate == KSampleRate48000Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate48000Hz;
+ else if (aSampleRate == KSampleRate88200Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate88200Hz;
+ else if (aSampleRate == KSampleRate96000Hz)
+ aDevSoundCaps.iRate = EMMFSampleRate96000Hz;
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* ConvertFromNumChannelsToDevSoundCapsL
+* @param "TUint"
+* @param "TMMFCapabilities&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::ConvertFromNumChannelsToDevSoundCapsL(TUint aNumChannels, TMMFCapabilities& aDevSoundCaps)
+ {
+ if (aNumChannels == KNumChannelsMono)
+ aDevSoundCaps.iChannels = EMMFMono;
+ else if (aNumChannels == KNumChannelsStereo)
+ aDevSoundCaps.iChannels = EMMFStereo;
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+*
+* ConvertFromDataTypeToDevSoundCapsL
+* @param "TFourCC"
+* @param "TMMFCapabilities&"
+*
+*/
+void CMMFTestUseOldCodecAudioController::ConvertFromDataTypeToDevSoundCapsL(TFourCC aDataType, TMMFCapabilities& aDevSoundCaps)
+ {
+ if (aDataType == KMMFFourCCCodePCM8)
+ aDevSoundCaps.iEncoding = EMMFSoundEncoding8BitPCM;
+ else if (aDataType == KMMFFourCCCodePCM16)
+ aDevSoundCaps.iEncoding = EMMFSoundEncoding16BitPCM;
+ else if (aDataType == KMMFFourCCCodeALAW)
+ aDevSoundCaps.iEncoding = EMMFSoundEncoding8BitALaw;
+ else if (aDataType == KMMFFourCCCodeMuLAW)
+ aDevSoundCaps.iEncoding = EMMFSoundEncoding8BitMuLaw;
+ else
+ User::Leave(KErrNotSupported);
+ }
+
+/**
+* IsValidStateTransition
+* The function validates a state transition from iState to aState
+* and returns ETrue if the transition is allowed.
+* @param TControllerState
+* @returns "TBool"
+* @xxxx
+*/
+TBool CMMFTestUseOldCodecAudioController::IsValidStateTransition( TControllerState aState ) const
+ {
+ TBool result = ETrue ;
+ //[ assert the precondition that aState is a valid State ]
+ __ASSERT_ALWAYS( IsValidState(aState), Panic( EBadArgument ) );
+ //[ assert the invariant that iState is a valid State ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ));
+
+ // [ check the valid state transitions ]
+ // the only invalid transition is
+ // stopped to playing
+ if( ( iState == EStopped ) && ( aState == EPlaying ))
+ {
+ result = EFalse ;
+ }
+
+ //[ assert the invariant that iState is a valid State ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ));
+
+ return result ;
+ }
+
+/*
+* Invariant
+* @returns "TBool"
+* This function returns whether the invariant is valid
+* @xxxx
+*/
+TBool CMMFTestUseOldCodecAudioController::Invariant() const
+ {
+ //[ The invariant is for now defined
+ // as simply being in the correct state and
+ // having iDataPath defined ]
+ return ( iDataPath )&& IsValidState( iState);
+ }
+
+/*
+* SetState
+* This function sets the state of the controller.
+* @returns "TBool"
+* @xxxx
+*/
+TBool CMMFTestUseOldCodecAudioController::SetState(TControllerState aState)
+ {
+ TBool result = ETrue;
+ //[ assert the precondition that the state is a valid state ]
+ __ASSERT_ALWAYS( IsValidState( aState), Panic( EBadArgument ) );
+ //[ assert the invariant the current state is valid ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ) );
+ //[ only allow valid state transitions ]
+ if( IsValidStateTransition( aState ) )
+ {
+ //[ valid state transition set the state]
+ iState = aState ;
+ }
+ else
+ {
+ //[ invalid state transition return EFalse ]
+ result = EFalse;
+ }
+ // [ assert the invariant on the state ]
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadState ));
+
+ return result ;
+ }
+
+/*
+* IsValidState
+* checks whether a state is a valid
+* @returns "TBool"
+* @param TControllerState
+* @xxxx
+*/
+TBool CMMFTestUseOldCodecAudioController::IsValidState( TControllerState aState ) const
+ {
+ TBool result = EFalse;
+ if(( aState >= EStopped ) && ( aState <= EPlaying ))
+ {
+ result = ETrue;
+ }
+ return result;
+ }
+
+/**
+* State
+* The function State returns the current state of the audio controller
+* @returns "TControllerState"
+* @xxxx
+*/
+CMMFTestUseOldCodecAudioController::TControllerState CMMFTestUseOldCodecAudioController::State() const
+ {
+ __ASSERT_ALWAYS( Invariant(), Panic( EBadInvariant ) );
+ return iState;
+ }
+
+/**
+*
+* SinkFormatRequired
+*
+*/
+TBool CMMFTestUseOldCodecAudioController::SinkFormatRequired( MDataSink& aDataSink ) const
+ {
+ return (aDataSink.DataSinkType()==KUidMmfFileSink ||
+ aDataSink.DataSinkType()==KUidMmfDescriptorSink);
+ }
+
+/**
+*
+* SourceFormatRequired
+*
+*/
+
+TBool CMMFTestUseOldCodecAudioController::SourceFormatRequired(MDataSource& aDataSource) const
+ {
+ return (aDataSource.DataSourceType()==KUidMmfFileSource ||
+ aDataSource.DataSourceType()==KUidMmfDescriptorSource);
+ }
+/**
+*
+* DevSoundInitialised
+* Used in certain configurations to resume completion of PrimeL() when it is pending DevSound initialisation.
+*
+*/
+void CMMFTestUseOldCodecAudioController::DevSoundInitialised(TInt /*aError*/)
+ {
+ iWaitForAsyncService->AsyncStop();
+ }
+
+CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::TDevSoundEventHandler()
+: iInterceptedDevSoundObserver(NULL), iEventObserver(NULL)
+ {
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::SetInterceptedDevSoundObserver(MDevSoundObserver* aObserver)
+ {
+ iInterceptedDevSoundObserver = aObserver;
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::SetEventObserver(CMMFTestUseOldCodecAudioController* aObserver)
+ {
+ iEventObserver = aObserver;
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::InitializeComplete(TInt aError)
+ {
+ iInterceptedDevSoundObserver->InitializeComplete(aError);
+ iEventObserver->DevSoundInitialised(aError);
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::ToneFinished(TInt aError)
+ {
+ iInterceptedDevSoundObserver->ToneFinished(aError);
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::BufferToBeFilled(CMMFBuffer* aBuffer)
+ {
+ iInterceptedDevSoundObserver->BufferToBeFilled(aBuffer);
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::PlayError(TInt aError)
+ {
+ iInterceptedDevSoundObserver->PlayError(aError);
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::BufferToBeEmptied(CMMFBuffer* aBuffer)
+ {
+ iInterceptedDevSoundObserver->BufferToBeEmptied(aBuffer);
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::RecordError(TInt aError)
+ {
+ iInterceptedDevSoundObserver->RecordError(aError);
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::ConvertError(TInt aError)
+ {
+ iInterceptedDevSoundObserver->ConvertError(aError);
+ }
+
+void CMMFTestUseOldCodecAudioController::TDevSoundEventHandler::DeviceMessage(TUid aMessageType, const TDesC8& aMsg)
+ {
+ iInterceptedDevSoundObserver->DeviceMessage(aMessageType, aMsg);
+ }
+
+