diff -r 000000000000 -r bde4ae8d615e os/mm/mmhais/a3facl/src/audiostream/logicalaudiostream.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/mm/mmhais/a3facl/src/audiostream/logicalaudiostream.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1327 @@ +// 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: +// + + + +#include "logicalaudiogaincontrol.h" +#include "logicalaudiocodec.h" +#include "logicalbuffersource.h" +#include "logicalbuffersink.h" +#include "logicalaudiodevicesink.h" +#include "logicalaudiodevicesource.h" +#include "logicalaudiostream.h" + +#include +#include +#include +#include +#include "audiocontext.h" + +// TODO: Remove when the MMRC Extension mechanism is ready +#include "mstreampositioncontrol.h" +#include "mstreampositioncontrol.h" +#include "audioprocessingunit.h" + +#include // For making it ECom plugin + + +// Exported proxy for instantiation method resolution +// Define the interface UIDs +const TImplementationProxy ImplementationTable[] = + { + IMPLEMENTATION_PROXY_ENTRY(KAudioStreamUid, CLogicalAudioStream::NewL) + }; + +EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount) + { + aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy); + return ImplementationTable; + } + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +CLogicalAudioStream::CLogicalAudioStream() + : CAudioStreamManager(), + iCurrentState(EUninitialized), + iMessageType(ERegisterStreamObserver) + { + TRACE_CREATE(); + DP_CONTEXT(CLogicalAudioStream::CLogicalAudioStream *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::NewL +// --------------------------------------------------------------------------- +CLogicalAudioStream* CLogicalAudioStream::NewL(TUid /*aTypeId*/) + { + DP_STATIC_CONTEXT(CLogicalAudioStream::NewL *CD0*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioStream* self = new(ELeave)CLogicalAudioStream(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + DP0_RET(self, "0x%x"); + } + +// --------------------------------------------------------------------------- +// Second phase constructor +// --------------------------------------------------------------------------- +void CLogicalAudioStream::ConstructL() + { + DP_CONTEXT(CLogicalAudioStream::ConstructL *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// + CLogicalAudioStream::~CLogicalAudioStream() + { + DP_CONTEXT(CLogicalAudioStream::~CLogicalAudioStream *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + iAudioProcessingUnits.Close(); + iCISupportObservers.Close(); + DP_OUT(); + } + + +// From MAudioStream +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Uninitialize +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Uninitialize() + { + DP_CONTEXT(CLogicalAudioStream::Uninitialize *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + if (iCurrentState != EInitialized) + { + DP0_RET(KErrNotReady, "%d"); + } + + iCurrentState = EUninitialized; + DP0_RET(KErrNone, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Initialize +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Initialize() + { + DP_CONTEXT(CLogicalAudioStream::Initialize *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + if (iCurrentState != EUninitialized) + { + DP0_RET(KErrNotReady, "%d"); + } + + //calling commit?? + iCurrentState = EInitialized; + DP0_RET(KErrNone, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Load +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Load() + { + DP_CONTEXT(CLogicalAudioStream::Load *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + if (iCurrentState != EInitialized) + { + DP0_RET(KErrNotReady, "%d"); + } + + iCurrentState = EIdle; + ResetStreamTime(); + DP0_RET(KErrNone, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Stop +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Stop() + { + DP_CONTEXT(CLogicalAudioStream::Stop *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + if (iCurrentState != EActive && iCurrentState != EPrimed) + { + DP0_RET(KErrNotReady, "%d"); + } + iCurrentState = EIdle; + DP0_RET(KErrNone, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Unload +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Unload() + { + DP_CONTEXT(CLogicalAudioStream::Unload *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + if (iCurrentState != EIdle) + { + DP0_RET(KErrNotReady, "%d"); + } + + iCurrentState = EInitialized; + DP0_RET(KErrNone, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Prime +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Prime() + { + DP_CONTEXT(CLogicalAudioStream::Prime *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + if (iCurrentState != EActive && iCurrentState != EIdle) + { + DP0_RET(KErrNotReady, "%d"); + } + + iCurrentState = EPrimed; + DP0_RET(KErrNone, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Flush +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Flush() + { + DP_CONTEXT(CLogicalAudioStream::Flush *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + if (iCurrentState != EIdle && iCurrentState != EPrimed) + { + DP0_RET(KErrNotReady, "%d"); + } + + if(!iStreamBufferControl) + { + DP0_RET(KErrNotReady, "%d"); + } + //Empty any buffers that have been filled + iStreamBufferControl->FlushBuffers(); + + DP0_RET(KErrNone, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Activate +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Activate() + { + DP_CONTEXT(CLogicalAudioStream::Activate *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + if (iCurrentState != EIdle && iCurrentState != EPrimed) + { + DP0_RET(KErrNotReady, "%d"); + } + + //The start-up procedures include requesting permission for audio processing + //from audio policy. If permission to start is denied by audio policy, a state + //change callback to the current state will occur. + iCurrentState = EActive; + DP0_RET(KErrNone, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::AddSource +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::AddSource(MAudioProcessingUnit* aSource) + { + DP_CONTEXT(CLogicalAudioStream::AddSource *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err; + if (aSource->IsTypeOf(KUidMmfBufferSource) || aSource->IsTypeOf(KUidAudioDeviceSource)) + { + if (iCurrentState == EUninitialized) + { + err = DoAddProcessingUnit(aSource); + } + else + { + err = KErrNotReady; + } + } + else + { + err = KErrNotSupported; + } + DP0_RET(err, "%d"); + } + + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::AddSink +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::AddSink(MAudioProcessingUnit* aSink) + { + DP_CONTEXT(CLogicalAudioStream::AddSink *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err; + if (aSink->IsTypeOf(KUidMmfBufferSink) || aSink->IsTypeOf(KUidAudioDeviceSink) ) + { + if (iCurrentState == EUninitialized) + { + err = DoAddProcessingUnit(aSink); + } + else + { + err = KErrNotReady; + } + } + else + { + err = KErrNotSupported; + } + DP0_RET(err, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::AddCodec +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::AddAudioCodec(MAudioProcessingUnit* aCodec) + { + DP_CONTEXT(CLogicalAudioStream::AddAudioCodec *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err; + if (iCodec != NULL) + { + DP0_RET(KErrInUse, "%d"); + } + + if (aCodec->IsTypeOf(KUidAudioCodec)) + { + if (iCurrentState == EUninitialized) + { + err = DoAddProcessingUnit(aCodec); + } + else + { + err = KErrNotReady; + } + } + else + { + err = KErrNotSupported; + } + DP0_RET(err, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::AddGainControl +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::AddGainControl(MAudioProcessingUnit* aGainControl) + { + DP_CONTEXT(CLogicalAudioStream::AddGainControl *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err(KErrNone); + + if (iGain != NULL) + { + DP0_RET(KErrInUse, "%d"); + } + + if (aGainControl->IsTypeOf(KUidAudioGainControl)) + { + if (iCurrentState == EUninitialized) + { + err = DoAddProcessingUnit(aGainControl); + } + else + { + err = KErrNotReady; + } + } + else + { + err = KErrNotSupported; + } + DP0_RET(err, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::RemoveProcessigUnit +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::RemoveProcessingUnit(MAudioProcessingUnit* aProcessingUnit) + { + DP_CONTEXT(CLogicalAudioStream::RemoveProcessingUnit *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + + if(iCurrentState != EUninitialized) + { + DP0_RET(KErrNotReady, "%d"); + } + + TInt err(KErrNotFound); + if (aProcessingUnit != NULL) + { + TAudioComponentId param = aProcessingUnit->InstanceId(); + TUint count= iAudioProcessingUnits.Count(); + + if (aProcessingUnit->IsTypeOf(KUidAudioCodec)) + { + iCodec = NULL; + } + else if (aProcessingUnit->IsTypeOf(KUidAudioGainControl)) + { + iGain = NULL; + } + + for ( TUint i(0); i < count; i++ ) + { + // find and remove component + if( iAudioProcessingUnits[i]->InstanceId() == param) + { + iAudioProcessingUnits.Remove(i); + break; + } + } + SetMessageType(EComponentDestruction); + err = KErrNone; + } + DP0_RET(err, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::ResetStreamTime +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::ResetStreamTime() + { + DP_CONTEXT(CLogicalAudioStream::ResetStreamTime *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err(KErrNone); + if (iCurrentState != EIdle) + { + DP0_RET(KErrNotReady, "%d"); + } + if(iPositionControl) + { + iPositionControl->ResetControlPosition(); + } + iTimeProcessed = 0; + DP0_RET(err, "%d"); + } + + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::GetStreamTime +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::GetStreamTime(TTimeIntervalMicroSeconds& aStreamTime) + { + DP_CONTEXT(CLogicalAudioStream::GetStreamTime *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err(KErrNone); + + if(iPositionControl) + { + err = iPositionControl->GetControlPosition(aStreamTime); + if(err == KErrNone) + { + iTimeProcessed = aStreamTime; + } + } + else + { + aStreamTime = iTimeProcessed; + } + DP0_RET(err, "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::Interface +// --------------------------------------------------------------------------- +TAny* CLogicalAudioStream::Interface(TUid aType) + { + DP_CONTEXT(CLogicalAudioStream::Interface *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TAny* interface(NULL); + if( aType == KUidAudioStream) + { + interface = static_cast(this); + } + else if( aType == KUidExtensionInferface) + { + interface = static_cast(this); + } + else if (aType == KUidAudioStreamAdaptationObserver) + { + interface = static_cast(this); + DP0_RET(interface, "0x%x"); + } + else if (aType == KUidAudioCodecObserver) + { + interface = static_cast(this); + DP0_RET(interface, "0x%x"); + } + + DP_OUT(); + return interface; + } + +// --------------------------------------------------------------------------- +// From MCustomInterfaceSupport +// CAudioStream::RequestCustomInterface +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::RequestCustomInterface(TUid aUid, TAny*& aPtr) + { + DP_CONTEXT(CLogicalAudioStream::RequestCustomInterface *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err = KErrNone; + if (aUid == KA3FBackdoorAccessIfUid) + { + MA3FBackdoorAccessIf* self = this; + aPtr = self; + } + else if(iInterfaceProvider) + { + err = iInterfaceProvider->RequestCustomInterface(aUid, aPtr); + if (err != KErrNone) + { + aPtr = NULL; + } + } + else + { + err = KErrNotReady; + } + DP0_RET(err, "%d"); + } + +// --------------------------------------------------------------------------- +// From MCustomInterfaceSupport +// CAudioStream::RegisterObserver +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::RegisterObserver(MCustomInterfaceSupportObserver& aObserver) + { + DP_CONTEXT(CLogicalAudioStream::RegisterObserver *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err = KErrNone; + err = iCISupportObservers.Find(&aObserver); + if( err != KErrNotFound ) + { + err = KErrAlreadyExists; + } + else + { + err = iCISupportObservers.Append(&aObserver); + } + DP0_RET(err, "%d"); + } + +// --------------------------------------------------------------------------- +// From MCustomInterfaceSupport +// CAudioStream::UnRegisterObserver +// --------------------------------------------------------------------------- +void CLogicalAudioStream::UnRegisterObserver(MCustomInterfaceSupportObserver& aObserver) + { + DP_CONTEXT(CLogicalAudioStream::UnRegisterObserver *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt idxOrErr = iCISupportObservers.Find(&aObserver); + if( idxOrErr != KErrNotFound ) + { + iCISupportObservers.Remove(idxOrErr); + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// From MCustomInterfaceSupport +// CAudioStream::CustomInterfaceRemoval +// --------------------------------------------------------------------------- +void CLogicalAudioStream::CustomInterfaceRemoval(TUid aInterfaceUid, TAny* aPtr) + { + DP_CONTEXT(CLogicalAudioStream::CustomInterfaceRemoval *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TUint count = iCISupportObservers.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + iCISupportObservers[idx]->CustomInterfaceRemoval(aInterfaceUid, aPtr); + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// From MAudioStreamAdaptationObserver +// CAudioStream::PhysicalAdaptationEvent +// --------------------------------------------------------------------------- +void CLogicalAudioStream::PhysicalAdaptationEvent(TPhysicalEvent /*aEvent*/, TInt /*aError*/) + { + DP_CONTEXT(CLogicalAudioStream::PhysicalAdaptationEvent *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CAudioStream::StateEvent +// --------------------------------------------------------------------------- +void CLogicalAudioStream::StateEvent(TInt aReason, TAudioState aNewState) + { + DP_CONTEXT(CLogicalAudioStream::StateEvent *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); +#ifdef _DEBUG + RDebug::Print(_L("CLogicalAudioStream::StateEvent Error %d Stay %d"), aReason, aNewState); +#endif + TUint count = iAudioStreamObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + iAudioStreamObserver[idx]->StateEvent(*this, aReason, aNewState); + } + iCurrentState = aNewState; + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::AddProcessingUnitComplete +// --------------------------------------------------------------------------- +void CLogicalAudioStream::AddProcessingUnitComplete(TUid aType, TInt aError) + { + DP_CONTEXT(CLogicalAudioStream::AddProcessingUnitComplete *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + MAudioProcessingUnit* instance = NULL; + MapUidToProcessingUnit(aType, instance); + TUint count = iAudioStreamObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + iAudioStreamObserver[idx]->AddProcessingUnitComplete(*this, instance, aError); + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::RemoveProcessingUnitComplete +// --------------------------------------------------------------------------- +void CLogicalAudioStream::RemoveProcessingUnitComplete(TUid aType, TInt aError) + { + DP_CONTEXT(CLogicalAudioStream::RemoveProcessingUnitComplete *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + MAudioProcessingUnit* instance = NULL; + MapUidToProcessingUnit(aType, instance); + TUint count = iAudioStreamObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + iAudioStreamObserver[idx]->RemoveProcessingUnitComplete(*this, instance, aError); + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// From MAudioStreamAdaptationObserver +// CLogicalAudioStream::ProcessingFinished +// --------------------------------------------------------------------------- +void CLogicalAudioStream::ProcessingFinished() + { + DP_CONTEXT(CLogicalAudioStream::ProcessingFinished *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TUint count = iAudioStreamObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + iAudioStreamObserver[idx]->ProcessingFinished(*this); + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::FlushComplete +// --------------------------------------------------------------------------- +void CLogicalAudioStream::FlushComplete(TInt aError) + { + DP_CONTEXT(CLogicalAudioStream::FlushComplete *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TUint count = iAudioStreamObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + iAudioStreamObserver[idx]->FlushComplete(*this, aError); + } + DP_OUT(); + } + + +// --------------------------------------------------------------------------- +// Internal +// CLogicalAudioStream::DoAddProcessingUnit +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::DoAddProcessingUnit(MAudioProcessingUnit* aProcessingUnit) + { + DP_CONTEXT(CLogicalAudioStream::DoAddProcessingUnit *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err(KErrNone); + + if (aProcessingUnit->IsTypeOf(KUidAudioCodec) ) + { + // Need for tone handling error + CAudioProcessingUnit* pUnit = static_cast(aProcessingUnit); + iCodec = static_cast(pUnit); + } + else if (aProcessingUnit->IsTypeOf(KUidAudioGainControl) ) + { + CAudioProcessingUnit* pUnit = static_cast(aProcessingUnit); + iGain = static_cast(pUnit); + } + + err = iAudioProcessingUnits.Append(aProcessingUnit); + SetMessageType(EComponentCreation); + + DP0_RET(err, "%d"); + } + +// --------------------------------------------------------------------------- +// Internal +// CLogicalAudioStream::MapUidToProcessingUnit +// --------------------------------------------------------------------------- +void CLogicalAudioStream::MapUidToProcessingUnit(TUid aType, MAudioProcessingUnit*& aInstance) + { + DP_CONTEXT(CLogicalAudioStream::MapUidToProcessingUnit *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TUint count = iAudioProcessingUnits.Count(); + for(TUint i=0; i(iAudioProcessingUnits[i]); + if ( aInstance->IsTypeOf(aType) ) + { + break; + } + aInstance = NULL; + } + DP_OUT(); + } + +// From MLogicalChain +// --------------------------------------------------------------------------- +// CLogicalAudioStream::SetMessageType +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetMessageType(TMMRCMessageType aMessageType) + { + DP_CONTEXT(CLogicalAudioStream::SetMessageType *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + iMessageType |= aMessageType; + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::ResetMessage +// --------------------------------------------------------------------------- +void CLogicalAudioStream::ResetMessage() + { + DP_CONTEXT(CLogicalAudioStream::SetMessageType *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + iMessageType = ENoMessage; + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::MessageType +// --------------------------------------------------------------------------- +TUint CLogicalAudioStream::MessageType() + { + DP_CONTEXT(CLogicalAudioStream::MessageType *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + DP0_RET(iMessageType, "Message type %d"); + } + + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::AudioProcessingUnitUid +// --------------------------------------------------------------------------- +TUid CLogicalAudioStream::AudioProcessingUnitUid(TInt aIndex) + { + DP_CONTEXT(CLogicalAudioStream::AudioProcessingUnitUid *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TUid uid = {0}; + MAudioProcessingUnit* pUnit(NULL); + if (aIndex >= 0) + { + pUnit = static_cast(iAudioProcessingUnits[aIndex]); + } + + if (pUnit != NULL) + { + if (pUnit->IsTypeOf(KUidAudioDecoder)) + { + uid = KUidAudioDecoder; + } + else if (pUnit->IsTypeOf(KUidAudioEncoder)) + { + uid = KUidAudioEncoder; + } + else if (pUnit->IsTypeOf(KUidMmfBufferSource)) + { + uid = KUidMmfBufferSource; + } + else if (pUnit->IsTypeOf(KUidAudioGainControl)) + { + uid = KUidAudioGainControl; + } + else if (pUnit->IsTypeOf(KUidAudioDeviceSink)) + { + uid = KUidAudioDeviceSink; + } + else if (pUnit->IsTypeOf(KUidMmfBufferSink)) + { + uid = KUidMmfBufferSink; + } + else if (pUnit->IsTypeOf(KUidAudioDeviceSource)) + { + uid = KUidAudioDeviceSource; + } + else if (pUnit->IsTypeOf(KUidAudioCodec)) + { + uid = KUidAudioCodec; + } + } + DP_OUT(); + return uid; + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::AudioProcessingUnitsCount +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::AudioProcessingUnitsCount() + { + DP_CONTEXT(CLogicalAudioStream::AudioProcessingUnitsCount *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + DP0_RET(iAudioProcessingUnits.Count(), "%d"); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::StreamState +// --------------------------------------------------------------------------- +TAudioState CLogicalAudioStream::StreamState() + { + DP_CONTEXT(CLogicalAudioStream::StreamState *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + DP0_RET(iCurrentState, "Stream state %d"); + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::SetStreamState +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetStreamState(TAudioState aAudioState) + { + DP_CONTEXT(CLogicalAudioStream::StreamState *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + iCurrentState = aAudioState; + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::CodecFormat +// --------------------------------------------------------------------------- +TUid CLogicalAudioStream::CodecFormat() + { + DP_CONTEXT(CLogicalAudioStream::CodecFormat *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioCodec* codec = static_cast(iCodec); + DP_OUT(); + TUid tuidnull = {0}; + if(codec) + { + return codec->iFormat; + } + else + { + return tuidnull; + } + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::GetSampleRate +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::GetSampleRate() + { + DP_CONTEXT(CLogicalAudioStream::GetSampleRate *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + const TUint KDefaultSampleRate = 8000; // Default sample rate + CLogicalAudioCodec* codec = static_cast(iCodec); + DP_OUT(); + TInt sampleRateValue = KDefaultSampleRate; + if(codec) + { + sampleRateValue = codec->iSampleRateConfig; + } + return sampleRateValue; + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::GetMode +// --------------------------------------------------------------------------- +TUid CLogicalAudioStream::GetMode() + { + DP_CONTEXT(CLogicalAudioStream::GetMode *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioCodec* codec = static_cast(iCodec); + TUid tuidnull = {0}; + DP_OUT(); + if(codec) + { + return codec->iModeConfig; + } + else + { + return tuidnull; + } + } + + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::Priority +// --------------------------------------------------------------------------- +TInt CLogicalAudioStream::Priority() + { + DP_CONTEXT(CLogicalAudioStream::Priority*CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + DP0_RET(iAudioTypeSettings.iPriority, "Priority %d"); + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::GetVolumeRampParameters +// --------------------------------------------------------------------------- +void CLogicalAudioStream::GetVolumeRampParameters(TUid& aRampOperation, TTimeIntervalMicroSeconds& aRampDuration) + { + DP_CONTEXT(CLogicalAudioStream::GetVolumeRampParameters*CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioGainControl* gain = static_cast(iGain); + if(gain) + { + aRampOperation = gain->iDesiredRampOperation; + aRampDuration = gain->iDesiredRampTime; + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::CopySettings +// @param the logical chain from where the parameter will be copied +// --------------------------------------------------------------------------- +void CLogicalAudioStream::CopySettings(const MLogicalChain& aChain) + { + DP_CONTEXT(CLogicalAudioStream::CopySettings *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CopyStreamSettings(aChain); + CopyCodecSettings(aChain); + CopyGainSettings(aChain); + DP_OUT(); + } + +void CLogicalAudioStream::CopyStreamSettings(const MLogicalChain& aChain) + { + DP_CONTEXT(CLogicalAudioStream::CopyStreamSettings *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + // LogicalAudioStream settings + CLogicalAudioStream& srcChain = static_cast(const_cast(aChain)); + + iAudioTypeSettings = srcChain.iAudioTypeSettings; + iCurrentState = srcChain.iCurrentState; + iRequestState = srcChain.iRequestState; + iMessageType = srcChain.iMessageType; + iTimeProcessed = srcChain.iTimeProcessed; + DP_OUT(); + } + +void CLogicalAudioStream::CopyCodecSettings(const MLogicalChain& aChain) + { + DP_CONTEXT(CLogicalAudioStream::CopyCodecSettings *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + + CLogicalAudioStream& srcChain = static_cast(const_cast(aChain)); + // Copy codec settings + CLogicalAudioCodec* srcCodec = static_cast(srcChain.iCodec); + if(iCodec && srcCodec) + { + CLogicalAudioCodec* logicalCodec = static_cast(iCodec); + logicalCodec->iFormat = srcCodec->iFormat; + logicalCodec->iSampleRateConfig = srcCodec->iSampleRateConfig; + logicalCodec->iModeConfig = srcCodec->iModeConfig; + } + DP_OUT(); + } + + +void CLogicalAudioStream::CopyGainSettings(const MLogicalChain& aChain) + { + DP_CONTEXT(CLogicalAudioStream::CopyGainSettings *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + + CLogicalAudioStream& srcChain = static_cast(const_cast(aChain)); + // Copy gain settings + CLogicalAudioGainControl* srcGain = static_cast(srcChain.iGain); + if (iGain && srcGain ) + { + if(srcGain->iDesiredChannels.Count() > 0) + { + CLogicalAudioGainControl* logicalGain = static_cast(iGain); + TUint count = srcGain->iDesiredChannels.Count(); + for (TUint i(0); i < count; i++) + { + logicalGain->iDesiredChannels[i] = srcGain->iDesiredChannels[i]; + } + logicalGain->iDesiredRampOperation = srcGain->iDesiredRampOperation; + logicalGain->iDesiredRampTime = srcGain->iDesiredRampTime; + } + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::CloneL +// --------------------------------------------------------------------------- +MLogicalChain* CLogicalAudioStream::CloneL() + { + DP_CONTEXT(CLogicalAudioStream::CloneL *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TInt err = KErrNone; + MLogicalChain* newLogicalChain = NULL; + + // Create another audiostream + CAudioStreamManager *manager = NULL; + manager = CAudioStreamManager::NewL(KUidAudioStream); + // Copy stream settings + CLogicalAudioStream* logicalAudioStream = static_cast(manager); + + MAudioProcessingUnit* pUnit=NULL; + TInt count = iAudioProcessingUnits.Count(); + for(TInt i = 0; i < count ; i++) + { + // Create processing unit + TUid type = AudioProcessingUnitUid(i); + TComponentParameters cParameters; + cParameters.iTypeUid = type; + cParameters.iInstanceId = 0; + cParameters.iContextId = 0; + cParameters.iSettingsObserver = NULL; + pUnit = CAudioProcessingUnit::NewL(cParameters); + + // If no error then add to the stream + if ( (type == KUidAudioDecoder) || (type == KUidAudioEncoder) ) + { + err = logicalAudioStream->AddAudioCodec(pUnit); + } + else if (type == KUidMmfBufferSource || (type == KUidAudioDeviceSource) ) + { + err = logicalAudioStream->AddSource(pUnit); + } + else if (type == KUidAudioGainControl) + { + err = logicalAudioStream->AddGainControl(pUnit); + } + else if (type == KUidAudioDeviceSink || ( type == KUidMmfBufferSink) ) + { + err = logicalAudioStream->AddSink(pUnit); + } + // TODO: + // Check this couldn't be added + if(err != KErrNone) + { + logicalAudioStream->iAudioProcessingUnits.Remove(iAudioProcessingUnits.Count()-1); + delete pUnit; + } + } + // Cast to MLogicalChain + newLogicalChain = static_cast(logicalAudioStream); + newLogicalChain->CopySettings(*this); + + DP0_RET(newLogicalChain, "0x%x"); + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::Release +// --------------------------------------------------------------------------- +void CLogicalAudioStream::Release() + { + DP_CONTEXT(CLogicalAudioStream::Release *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + // ResetAndDestroy + TInt count = iAudioProcessingUnits.Count(); + TInt i; + for (i=0; i(iAudioProcessingUnits[i]); + delete pUnit; + } + iAudioProcessingUnits.Reset(); + DP_OUT(); + delete this; + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::GetComponent +// --------------------------------------------------------------------------- +TAny* CLogicalAudioStream::GetComponent(TUid aType) + { + DP_CONTEXT(CLogicalAudioStream::GetComponent *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + TAny* interface = NULL; + + // go through this or our subcomponents to see if somebody knows about the interface + interface = Interface(aType); + if (interface==NULL) + { + TUint count = iAudioProcessingUnits.Count(); + // go through components looking for valid interface + for ( TInt i=0; i < count; i++ ) + { + interface = iAudioProcessingUnits[i]->Interface(aType); + if (interface!=NULL) + { + break; + }; + } + }; + + + DP0_RET(interface, "0x%x"); + } + + + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::SetAdaptationSource +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetAdaptationSource(MMMFBufferSource& aSource) + { + DP_CONTEXT(CLogicalAudioStream::SetAdaptationSource *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + MapUidToProcessingUnit(KUidMmfBufferSource, iAudioProcessingUnit); + ASSERT(iAudioProcessingUnit); + + CAudioProcessingUnit* cUnit = static_cast(iAudioProcessingUnit); + CLogicalBufferSource* bufferSource = (static_cast(cUnit)); + + bufferSource->iAdaptationBufferSource = &aSource; + aSource.SetDataSupplier(*bufferSource); + + iAudioProcessingUnit = NULL; + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::SetAdaptationSink +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetAdaptationSink(MMMFBufferSink& aSink) + { + DP_CONTEXT(CLogicalAudioStream::SetAdaptationSink *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + MapUidToProcessingUnit(KUidMmfBufferSink, iAudioProcessingUnit); + ASSERT(iAudioProcessingUnit); + + CAudioProcessingUnit* cUnit = static_cast(iAudioProcessingUnit); + CLogicalBufferSink* bufferSink = (static_cast(cUnit)); + + bufferSink->iAdaptationBufferSink = &aSink; + aSink.SetDataConsumer(*bufferSink); + + iAudioProcessingUnit = NULL; + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::SetAdaptationGainControl +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetAdaptationGainControl(MAudioGainControl& aGain) + { + DP_CONTEXT(CLogicalAudioStream::SetAdaptationGainControl *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + ASSERT(iGain); + CLogicalAudioGainControl* gain = static_cast(iGain); + gain->iAdaptationGain = &aGain; + aGain.RegisterAudioGainControlObserver(*gain); + DP_OUT(); + } + + + +// --------------------------------------------------------------------------- +// From MLogicalChain +// CLogicalAudioStream::SetPositionControl +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetStreamPositionControl(MStreamPositionControl& aPositionControl) + { + DP_CONTEXT(CLogicalAudioStream::SetStreamPositionControl *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + iPositionControl = &aPositionControl; + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::SetAdaptationStream +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetAdaptationStream(MConfigurationHelper& aStream) + { + DP_CONTEXT(CLogicalAudioStream::SetAdaptationStream *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioCodec* codec = static_cast(iCodec); + if (codec != NULL) + { + if (codec->iAdaptationStream == NULL) + { + codec->iAdaptationStream = &aStream; + } + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::SetStreamBufferControl +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetStreamBufferControl(MStreamBufferControl& aStreamBufferControl) + { + DP_CONTEXT(CLogicalAudioStream::SetAdaptationStream *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + iStreamBufferControl = &aStreamBufferControl; + DP_OUT(); + } + + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::SetCustomInterfaceProvider +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetCustomInterfaceProvider(MCustomInterfaceSupport& aInterfaceProvider) + { + DP_CONTEXT(CLogicalAudioStream::SetCustomInterfaceProvider *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + iInterfaceProvider = &aInterfaceProvider; + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::SampleRateSet +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SampleRateSet(TInt aError) + { + DP_CONTEXT(CLogicalAudioStream::SampleRateSet *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioCodec* codec = static_cast(iCodec); + if(codec) + { + TUint count = codec->iAudioCodecObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + codec->iAudioCodecObserver[idx]->SampleRateSet(aError); + } + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::ModeSet +// --------------------------------------------------------------------------- +void CLogicalAudioStream::ModeSet(TInt aError) + { + DP_CONTEXT(CLogicalAudioStream::SampleRateSet *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioCodec* codec = static_cast(iCodec); + if(codec) + { + TUint count = codec->iAudioCodecObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + codec->iAudioCodecObserver[idx]->ModeSet(aError); + } + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::GetSupportedSampleRatesComplete +// --------------------------------------------------------------------------- +void CLogicalAudioStream::GetSupportedSampleRatesComplete (TInt aError) + { + DP_CONTEXT(CLogicalAudioStream::SampleRateSet *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioCodec* codec = static_cast(iCodec); + if(codec) + { + TUint count = codec->iAudioCodecObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + codec->iAudioCodecObserver[idx]->GetSupportedSampleRatesComplete(aError); + } + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::GetSupportedModesComplete +// --------------------------------------------------------------------------- +void CLogicalAudioStream::GetSupportedModesComplete (TInt aError) + { + DP_CONTEXT(CLogicalAudioStream::SampleRateSet *CD1*, CtxDevSound, DPLOCAL); + DP_IN(); + CLogicalAudioCodec* codec = static_cast(iCodec); + if(codec) + { + TUint count = codec->iAudioCodecObserver.Count(); + for ( TUint idx(0); idx < count; idx++ ) + { + codec->iAudioCodecObserver[idx]->GetSupportedModesComplete(aError); + } + } + DP_OUT(); + } + +// --------------------------------------------------------------------------- +// CLogicalAudioStream::SetParentContext +// --------------------------------------------------------------------------- +void CLogicalAudioStream::SetParentContext(const CAudioContext& aContext) + { + iParentContext = const_cast(&aContext); + } + + +// from MA3FBackdoorAccessIf + +MAudioContext* CLogicalAudioStream::AudioContext() + { + return iParentContext; + } + +MAudioStream* CLogicalAudioStream::AudioStream() + { + return this; + } + +MAudioProcessingUnit* CLogicalAudioStream::ProcessingUnit(TUid aType) + { + // look through our processing units for something of the correct type + TInt numProcessingUnits = iAudioProcessingUnits.Count(); + for (TInt index=0; index < numProcessingUnits; index++) + { + MAudioProcessingUnit* ptr = iAudioProcessingUnits[index]; + if (ptr->IsTypeOf(aType)) + { + return ptr; + } + } + return NULL; + }