//audiostream.cpp
// Copyright (c) 2006-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 <a3f/a3fbase.h>
#include <a3f/audioprocessingunittypeuids.h>
#include <a3f/a3ffourcclookup.h>
#include "audiostream.h"
// PHYSICAL COMPONENTS
#include "audiocodec.h"
#include "audiostream.h"
#include "buffersource.h"
#include "buffersink.h"
#include "audiodevicesource.h"
#include "audiodevicesink.h"
#include "audiogaincontrol.h"
#include "maudiostreamadaptationobserver.h"
#include <a3f/maudiodatasupplier.h>
#include <a3f/maudiodataconsumer.h>
#include "minputport.h"
#include "moutputport.h"
#include "audiocontext.h"
#include <ecom/implementationproxy.h>
const TInt KSampleRate8000Hz = 8000;
// Map the interface implementation UIDs to implementation factory functions
const TImplementationProxy ImplementationTable[] =
{
IMPLEMENTATION_PROXY_ENTRY(0x10283461, CAudioStream::NewL),
};
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
{
aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
return ImplementationTable;
}
// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CAudioStream::CAudioStream()
: iCurrentStreamState(EUninitialized),
iDesiredStreamState(EUninitialized)
{
TRACE_CREATE();
DP_CONTEXT(CAudioStream::CAudioStream *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
// Some init config values
iSampleRateConfig = KSampleRate8000Hz;
iModeConfig = KA3FModeMono;
DP_OUT();
}
// ---------------------------------------------------------------------------
// Factory method
// ---------------------------------------------------------------------------
//
CAudioStream* CAudioStream::NewL()
{
DP_STATIC_CONTEXT(CAudioStream::NewL *CD0*, CtxDevSound, DPLOCAL);
DP_IN();
CAudioStream* self = new(ELeave)CAudioStream();
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
DP0_RET(self, "0x%x");
}
// ---------------------------------------------------------------------------
// Second phase constructor
// ---------------------------------------------------------------------------
//
void CAudioStream::ConstructL()
{
DP_CONTEXT(CAudioStream::ConstructL *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
DP_OUT();
}
// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CAudioStream::~CAudioStream()
{
DP_CONTEXT(CAudioStream::~CAudioStream *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
iAudioStreamObservers.Close();
iAudioCodecObservers.Close();
// Just for now
DeletePhysicalComponents();
REComSession::FinalClose();
DP_OUT();
}
// ---------------------------------------------------------------------------
// CAudioStream::RegisterAudioStreamObserver
// ---------------------------------------------------------------------------
//
TInt CAudioStream::RegisterAudioStreamObserver(MAudioStreamAdaptationObserver& aObserver)
{
DP_CONTEXT(CAudioStream::RegisterAudioStreamObserver *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TInt err = iAudioStreamObservers.Find(&aObserver);
if(err == KErrNotFound)
{
err = iAudioStreamObservers.Append(&aObserver);
}
else
{
err = KErrAlreadyExists;
}
DP0_RET(err, "%d");
}
// ---------------------------------------------------------------------------
// CAudioStream::UnregisterAudioStreamObserver
// ---------------------------------------------------------------------------
//
void CAudioStream::UnregisterAudioStreamObserver(MAudioStreamAdaptationObserver& aObserver)
{
DP_CONTEXT(CAudioStream::UnregisterAudioStreamObserver *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TInt idxOrErr = iAudioStreamObservers.Find(&aObserver);
if( idxOrErr != KErrNotFound )
{
iAudioStreamObservers.Remove(idxOrErr);
}
DP_OUT();
}
// ---------------------------------------------------------------------------
// CAudioStream::SetFourCC
// ---------------------------------------------------------------------------
//
void CAudioStream::SetFourCC(const CFourCCConvertor& aFourCCConvertor)
{
DP_CONTEXT(CAudioStream::SetFourCC *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
CFourCCConvertor& ref = const_cast<CFourCCConvertor&>(aFourCCConvertor);
iFourCCConvertor = static_cast<CFourCCConvertor*>(static_cast<TAny*>(&ref));
DP_OUT();
}
// ---------------------------------------------------------------------------
// CAudioStream::UnregisterAudioStreamObserver
// ---------------------------------------------------------------------------
//
void CAudioStream::UnregisterAllAudioStreamObserver()
{
DP_CONTEXT(CAudioStream::UnregisterAudioStreamObserver *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
iAudioStreamObservers.Reset();
DP_OUT();
}
// ---------------------------------------------------------------------------
// MMRC extension mechanism
// ---------------------------------------------------------------------------
TAny* CAudioStream::GetComponent(TUid aType)
{
TAny* ptr = NULL;
MLogicalChain* clientDesiredChain = NULL;
CAudioContext* context = static_cast<CAudioContext*>(iAudioContext);
if(context)
{
clientDesiredChain = context->GetLogicalChain(0);
}
if (clientDesiredChain)
{
ptr = clientDesiredChain->GetComponent(aType);
}
return ptr;
}
// ---------------------------------------------------------------------------
// CAudioStream::Message
// ---------------------------------------------------------------------------
TInt CAudioStream::Message(MLogicalChain& aCurrentChain, MLogicalChain& aDesiredChain, MAudioContext& aContext, TInt aFlags)
{
DP_CONTEXT(CAudioStream::Message *CD0*, CtxDevSound, DPLOCAL);
DP_IN();
TInt err = KErrNone;
iCurrentChain = &aCurrentChain;
iDesiredChain = &aDesiredChain;
TUint messageType = aDesiredChain.MessageType();
iAudioContext = &aContext;
CAudioContext* audioContext = static_cast<CAudioContext*> (iAudioContext);
// TO NOTIFY DIRECTLY CONTEXT
MMultimediaResourceControlObserver* mmrcObserver = static_cast<MMultimediaResourceControlObserver*>(audioContext);
// Register stream observer
if (messageType & ERegisterStreamObserver != 0)
{
// Use MMRC extension mechanism
TAny* ptr = GetComponent(KUidAudioStreamAdaptationObserver);
MAudioStreamAdaptationObserver* observer = static_cast<MAudioStreamAdaptationObserver*>(ptr);
if(observer)
{
err = RegisterAudioStreamObserver(*observer);
}
}
// Register codec observer
if (messageType & ERegisterCodecObserver != 0)
{
// Use MMRC extension mechanism
TAny* ptr = GetComponent(KUidAudioCodecObserver);
MAudioCodecObserver* observer = static_cast<MAudioCodecObserver*>(ptr);
if (observer)
{
err = RegisterAudioCodecObserver(*observer);
}
}
// Component creation
TUint bit = messageType & EComponentCreation;
if( (err == KErrNone) && (bit != 0) )
{
CAudioContext* context = static_cast<CAudioContext*>(iAudioContext);
MLogicalChain* clientDesiredChain = context->GetLogicalChain(0);
err = CreatePhysicalComponents(*clientDesiredChain);
// For Configuration
if (err==KErrNone)
{
clientDesiredChain->SetAdaptationStream(*this);
clientDesiredChain->SetStreamBufferControl(*this);
}
}
// Component alteration
// Changes that must be applied before stream state transition
TBool configCodec = EFalse;
bit = messageType & EComponentAlterationCodec;
if( (err == KErrNone) && (bit != 0) )
{
// Set Format
if(iCodec)
{
TUid desiredCodecFormat = iDesiredChain->CodecFormat();
err = iCodec->SetFormat( desiredCodecFormat );
}
if(err == KErrNone)
{
//if samplerate or mode has changed, update value and trigger callbacks at appropriate point
if ((iDesiredChain->GetSampleRate() > 0) && (iDesiredChain->GetSampleRate() != iSampleRateConfig))
{
iSampleRateConfig = iDesiredChain->GetSampleRate();
configCodec = ETrue;
}
if ((iDesiredChain->GetMode() != KNullUid) && (iDesiredChain->GetMode() != iModeConfig))
{
iModeConfig = iDesiredChain->GetMode();
configCodec = ETrue;
}
}
}
bit = messageType & EComponentAlterationGain;
if( (err == KErrNone) && (bit != 0) )
{
// Apply volume ramp
// Note that ramp operation and gain now are applied separately because current tone arquitecture
// need the volume ramp to be set before start the tonehwdevice
TTimeIntervalMicroSeconds currentRampTimeValue = 0;
TUid currentRampTimeOperation(KNullUid);
TTimeIntervalMicroSeconds desiredRampTimeValue = 0;
TUid desiredRampTimeOperation(KNullUid);
iCurrentChain->GetVolumeRampParameters(currentRampTimeOperation, currentRampTimeValue);
iDesiredChain->GetVolumeRampParameters(desiredRampTimeOperation, desiredRampTimeValue);
if(currentRampTimeOperation != desiredRampTimeOperation ||
currentRampTimeValue.Int64() != desiredRampTimeValue.Int64() )
{
if (iGainControl)
{
err = iGainControl->ConfigureRamp(desiredRampTimeOperation, desiredRampTimeValue);
}
}
}
//Configuration request
// Stream state
TBool invokeStateEventCallback = EFalse;
iDesiredStreamState = iDesiredChain->StreamState();
if( (err == KErrNone) && (iCurrentStreamState != iDesiredStreamState) )
{
err = ChangeState(iCurrentStreamState, iDesiredStreamState);
if (err == KErrNone)
{
iCurrentStreamState = iDesiredStreamState;
}
invokeStateEventCallback = ETrue;
}
// Component alteration
// Changes that must be applied after stream state transition
TBool gainUpdated = EFalse;
bit = messageType & EComponentAlterationGain;
if( (err == KErrNone) && (bit != 0) )
{
TAny* ptr = GetComponent(KUidAudioGainControl);
MAudioGainControl* gaincontrol = static_cast<MAudioGainControl*>(ptr);
if (iGainControl && gaincontrol)
{
RArray<TAudioChannelGain> channels;
TInt err = gaincontrol->GetGain(channels);
if (channels.Count() != 0 )
{
err = iGainControl->SetGain(channels);
gainUpdated = ETrue;
}
channels.Close();
}
}
TBool invokeCodecCallbacks = EFalse;
bit = messageType & EComponentAlterationCodec;
if ( (err == KErrNone) && (bit != 0) && configCodec && (iCurrentStreamState == EInitialized) )
{
//codec loading actually configures sample rate and mode
ASSERT(iCodec);
err = iCodec->Load(iSampleRateConfig, iModeConfig);
iIsCodecConfig = (err == KErrNone);
invokeCodecCallbacks = ETrue;
if ( err != KErrNone )
{
//get back to previous values in case of error
iSampleRateConfig = iCurrentChain->GetSampleRate();
iModeConfig = iCurrentChain->GetMode();
}
}
// Component destruction
bit = messageType & EComponentDestruction;
if( (err == KErrNone) && (bit != 0) )
{
DeletePhysicalComponents();
}
TUint isStopping = aFlags & KServerStopping;
TUint preemptionRequest = aFlags & KPreemptionRequest;
// HERE WE CAN GUARANTEE THAT THE REQUEST IS SUCCESFUL
// Notify context
// 1ST CALLBACK
if(!preemptionRequest)
{
mmrcObserver->ReceiveResourceUpdate(&aDesiredChain, KErrNone);
}
else
{
mmrcObserver->ReceivePreemptionUpdate(&aDesiredChain, err);
}
// Processing unit callbacks
// Gain control
// Note that due to error checking before applying any change
// this callback always returned the error obtained by calling SetGain
// or KErrNone
if(gainUpdated)
{
if (iGainControl)
{
iGainControl->IssueGainChangedCallBack(err);
}
}
// Stream
if(invokeStateEventCallback)
{
invokeStateEventCallback = EFalse;
for ( TUint idx(0); idx < iAudioStreamObservers.Count(); idx++ )
{
if ( !isStopping )
{
iAudioStreamObservers[idx]->StateEvent(err, iCurrentStreamState);
}
}
}
if( invokeCodecCallbacks && (iCurrentStreamState == EInitialized) )
{
TInt count = iAudioCodecObservers.Count();
for ( TInt idx = 0; idx < count; idx++ )
{
//TODO replace this functionality with the new mmrc
iAudioCodecObservers[idx]->SampleRateSet(err);
iAudioCodecObservers[idx]->ModeSet(err);
}
}
// Now has no effect on context
// But it's needed to let the MMRC know about the operation being completed
// and in such way let it to know that
for ( TUint idx(0); idx < iAudioStreamObservers.Count(); idx++ )
{
if ( !isStopping )
{
iAudioStreamObservers[idx]->PhysicalAdaptationEvent(EOperationComplete, err);
}
}
// Don't need to send last callback sync
// Let MMRC do it
DP0_RET(err, "%d");
}
// ---------------------------------------------------------------------------
// CAudioStream::DeletePhysicalComponents
// ---------------------------------------------------------------------------
void CAudioStream::DeletePhysicalComponents()
{
DP_CONTEXT(CAudioStream::DeletePhysicalComponents *CD0*, CtxDevSound, DPLOCAL);
DP_IN();
if(iBufferSource)
{
delete iBufferSource;
iBufferSource = NULL;
}
if(iBufferSink)
{
delete iBufferSink;
iBufferSink = NULL;
}
if(iCodec)
{
delete iCodec;
iCodec = NULL;
iIsCodecConfig = EFalse;
}
if(iGainControl)
{
delete iGainControl;
iGainControl = NULL;
}
if(iDeviceSource)
{
delete iDeviceSource;
iDeviceSource = NULL;
}
if(iDeviceSink)
{
delete iDeviceSink;
iDeviceSink= NULL;
}
DP_OUT();
}
// ---------------------------------------------------------------------------
// CAudioStream::CreatePhysicalComponents
// ---------------------------------------------------------------------------
TInt CAudioStream::CreatePhysicalComponents(MLogicalChain& aDesiredChain)
{
DP_CONTEXT(CAudioStream::CreatePhysicalComponents *CD0*, CtxDevSound, DPLOCAL);
DP_IN();
TInt err = KErrNone;
TInt units = aDesiredChain.AudioProcessingUnitsCount();
TInt index=0;
TUid typeId;
for (index=0; index < units ; index++)
{
typeId = aDesiredChain.AudioProcessingUnitUid(index);
// By the moment all components
if (err == KErrNone)
{
if (typeId == KUidAudioDecoder || typeId == KUidAudioEncoder )
{
if(!iCodec)
{
TRAP(err, iCodec = CAudioCodec::NewL(typeId, *iFourCCConvertor ));
iIsCodecConfig = EFalse;
iCodec->RegisterAudioCodecObserver(*this);
TAny* ptr = GetComponent(KUidAudioCodecAdaptationObserver);
MAudioCodecAdaptationObserver* observer = static_cast<MAudioCodecAdaptationObserver*>(ptr);
if(observer)
{
iCodec->RegisterAudioCodecObserver(*observer);
}
// For HW custom interface
aDesiredChain.SetCustomInterfaceProvider(*iCodec);
}
if(iGainControl)
{
iGainControl->SetHelper(*iCodec);
}
// This mechanism is temporary and must be replaced
// with the Extension mechanism when the MMRC server
aDesiredChain.SetStreamPositionControl(*iCodec);
}
else if (typeId == KUidMmfBufferSource)
{
if(!iBufferSource)
{
TRAP(err,iBufferSource = CBufferSource::NewL());
// This mechanism is temporary and must be replaced
// with the Extension mechanism when the MMRC server
aDesiredChain.SetAdaptationSource(*iBufferSource);
/*
TAny* ptr = aDesiredChain.GetComponent(KUidMmfBufferSource);
MMMFAudioDataSupplier* supplier = static_cast<MMMFAudioDataSupplier*>(ptr);
if(supplier)
{
iBufferSource->SetDataSupplier(*supplier);
}
*/
}
}
else if (typeId == KUidMmfBufferSink)
{
if(!iBufferSink)
{
TRAP(err, iBufferSink = CBufferSink::NewL());
// This mechanism is temporary and must be replaced
// with the Extension mechanism when the MMRC server
aDesiredChain.SetAdaptationSink(*iBufferSink);
}
}
else if (typeId == KUidAudioGainControl)
{
if(!iGainControl)
{
// This mechanism is temporary and must be replaced
// with the Extension mechanism when the MMRC server
TRAP(err, iGainControl = CAudioGainControl::NewL());
aDesiredChain.SetAdaptationGainControl(*iGainControl);
}
}
else if (typeId == KUidAudioDeviceSink)
{
if(!iDeviceSink)
{
TRAP(err, iDeviceSink = CAudioDeviceSink::NewL());
}
}
else if (typeId == KUidAudioDeviceSource)
{
if(!iDeviceSource)
{
TRAP(err, iDeviceSource = CAudioDeviceSource::NewL());
}
}
else
{
err = KErrNotSupported;
}
}
// Notify the observers
for ( TUint idx(0); idx < iAudioStreamObservers.Count(); idx++ )
{
iAudioStreamObservers[idx]->AddProcessingUnitComplete(typeId, err);
}
}
DP0_RET(err, "%d");
}
// ---------------------------------------------------------------------------
// CAudioStream::CreateDataPath
// ---------------------------------------------------------------------------
TInt CAudioStream::CreateDataPath()
{
DP_CONTEXT(CAudioStream::CreateDataPath *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TInt err(KErrNotReady);
if(iBufferSource && iCodec) // && iSink && iGain)
{
// TMode == Decode
if(KErrNone == iBufferSource->GetOutputPort(iOutputport) && KErrNone == iCodec->GetInputPort(iInputport))
{
iOutputport->SetInput(iInputport);
iInputport->SetOutput(iOutputport);
err = KErrNone;
}
}
else if(iBufferSink && iCodec) // && iSink && iGain)
{
//TMode == Encode
if(KErrNone == iCodec->GetOutputPort(iOutputport) && KErrNone == iBufferSink->GetInputPort(iInputport))
{
iOutputport->SetInput(iInputport);
iInputport->SetOutput(iOutputport);
err = KErrNone;
}
}
DP0_RET(err, "%d");
}
// ---------------------------------------------------------------------------
// CAudioStream::DemolishDataPath
// ---------------------------------------------------------------------------
//
TInt CAudioStream::DemolishDataPath()
{
DP_CONTEXT(CAudioStream::DemolishDataPath *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
iOutputport->RemoveInput(iInputport);
iInputport->RemoveOutput(iOutputport);
DP0_RET(KErrNone, "%d");
}
// ---------------------------------------------------------------------------
// CAudioStream::ChangeState
// ---------------------------------------------------------------------------
TInt CAudioStream::ChangeState(TAudioState aPreviousState, TAudioState aDesiredState)
{
DP_CONTEXT(CAudioStream::ChangeState *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TInt err(KErrNone);
iCurrentStreamState = aPreviousState;
iDesiredStreamState = aDesiredState;
// Ensure that there is no dereference of a NULL pointer
ASSERT(iDesiredStreamState < EInitialized || iDesiredStreamState > EActive || iCodec);
switch (iDesiredStreamState)
{
case EInitialized:
{
if (iCurrentStreamState == EUninitialized) //Initialize
{
err = CreateDataPath();
if(err == KErrNone)
{
err = iCodec->Initialize();
}
}
else if( iCurrentStreamState == EIdle ) //codec unload (actually, unconfig)
{
iIsCodecConfig = EFalse;
err = KErrNone;
}
// Preemption
// This A3F adaptation allows going from Active/Primed directly to initialised
// otherwise reference MMRC would need to handle those transitions separately
else if(iCurrentStreamState == EActive || iCurrentStreamState == EPrimed)
{
// To Idle
err = iCodec->Stop();
// To Initilised
iIsCodecConfig = EFalse;
}
if(err == KErrNone)
{
iCurrentStreamState = EInitialized;
}
break;
}
case EIdle:
{
if ( (iCurrentStreamState == EInitialized) && !iIsCodecConfig )
{
//codec loading actually configures sample rate and mode
err = iCodec->Load(iSampleRateConfig, iModeConfig);
iIsCodecConfig = (err == KErrNone);
}
else if (iCurrentStreamState == EActive)
{
err = iCodec->Stop();
}
else if (iCurrentStreamState == EPrimed)
{
err = iCodec->Stop();
}
if(err == KErrNone)
{
iTimeProcessed = 0;
iCurrentStreamState = EIdle;
}
break;
}
case EPrimed:
{
if (iCurrentStreamState == EIdle)
{
DP0(DLINFO,"============== Stream is going from EIdle -> PRIMED");
DP0(DLINFO,"Nothing to be done");
}
else if (iCurrentStreamState == EActive)
{
DP0(DLINFO,"============== Stream is going from EActive -> PRIMED");
err = iCodec->Pause();
}
if(err == KErrNone)
{
iCurrentStreamState = EPrimed;
}
break;
}
case EActive:
{
if (iCurrentStreamState == EPrimed) //Activate from Primed
{
// Reusing AudioCodec::Start for resuming
DP0(DLINFO,"============== Stream is going from EPrimed -> ACTIVE");
err = iCodec->Start();
}
else if(iCurrentStreamState == EIdle) //Activate from Idle
{
DP0(DLINFO,"============== Stream is going from EIdle -> ACTIVATE");
err = iCodec->Start();
}
if(err == KErrNone)
{
iCurrentStreamState = EActive;
}
break;
}
case EUninitialized:
{
err = DemolishDataPath();
if(err == KErrNone)
{
iCurrentStreamState = EUninitialized;
}
break;
}
case EDead:
{
err = DemolishDataPath();
if(err == KErrNone)
{
iCurrentStreamState = EDead;
}
break;
}
default:
err = KErrNotSupported;
DP1(DLINFO,"CAudioStream::ChangeState Unknown state! %d", iDesiredStreamState);
break;
}
DP0_RET(err, "%d");
}
TInt CAudioStream::FlushBuffers()
{
DP_CONTEXT(CAudioStream::FlushBuffers *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TInt err = KErrNone;
MOutputPort* outPort= static_cast<MOutputPort*>(iCodec);
if(outPort)
{
outPort->FlushBuffer(this);
}
else
{
err = KErrNotReady;
}
err = KErrNone;
DP0_RET(err, "%d");
}
void CAudioStream::FlushComplete(TInt aError)
{
DP_CONTEXT(CAudioStream::FlushComplete *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TUint count = iAudioStreamObservers.Count();
for ( TUint i(0); i < count; i++ )
{
iAudioStreamObservers[i]->FlushComplete(aError);
}
DP_OUT();
}
void CAudioStream::AllBuffersProcessed()
{
DP_CONTEXT(CAudioStream::AllBuffersProcessed *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TUint count = iAudioStreamObservers.Count();
for ( TUint i(0); i < count; i++ )
{
iAudioStreamObservers[i]->ProcessingFinished();
}
DP_OUT();
}
void CAudioStream::ProcessingUnitError(TInt /*aError*/)
{
DP_CONTEXT(CAudioStream::ProcessingUnitError *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
DP_OUT();
}
// ---------------------------------------------------------------------------
// CAudioStream::RegisterAudioCodecObserver
// ---------------------------------------------------------------------------
TInt CAudioStream::RegisterAudioCodecObserver(MAudioCodecObserver& aObserver)
{
DP_CONTEXT(CAudioStream::RegisterAudioCodecObserver *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TInt err = iAudioCodecObservers.Find(&aObserver);
if(err == KErrNotFound)
{
err = iAudioCodecObservers.Append(&aObserver);
}
else
{
err = KErrAlreadyExists;
}
DP0_RET(err, "%d");
}
// ---------------------------------------------------------------------------
// CAudioStream::UnregisterAudioCodecObserver
// ---------------------------------------------------------------------------
void CAudioStream::UnregisterAudioCodecObserver(MAudioCodecObserver& aObserver)
{
DP_CONTEXT(CAudioStream::UnregisterAudioCodecObserver *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
TInt idxOrErr = iAudioCodecObservers.Find(&aObserver);
if( idxOrErr != KErrNotFound )
{
iAudioCodecObservers.Remove(idxOrErr);
}
DP_OUT();
}
void CAudioStream::GetSupportedAModesComplete(TInt /*aError*/)
{
DP_CONTEXT(CAudioStream::GetSupportedAModesComplete *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
DP_OUT();
}
void CAudioStream::GetSupportedARatesComplete(TInt /*aError*/)
{
DP_CONTEXT(CAudioStream::GetSupportedARatesComplete *CD1*, CtxDevSound, DPLOCAL);
DP_IN();
DP_OUT();
}
// ---------------------------------------------------------------------------
// CAudioStream::GetSupportedSampleRates
// ---------------------------------------------------------------------------
TInt CAudioStream::GetSupportedSampleRates(RArray<TInt>& aSupportedRates)
{
TInt err = (KErrNotReady);
err = iCodec->SupportedRates(aSupportedRates);
return err;
}
// ---------------------------------------------------------------------------
// CAudioStream::GetSupportedModes
// ---------------------------------------------------------------------------
TInt CAudioStream::GetSupportedModes(RArray<TUid>& aSupportedModes)
{
TInt err = (KErrNotReady);
err = iCodec->SupportedModes(aSupportedModes);
return err;
}
// end of file