// 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 <mmf/server/sounddevice.h>

#include <a3f/audioprocessingunittypeuids.h>

#include <a3f/maudiocodec.h>

#include <a3f/maudiocontext.h>

#include "audiocontext.h"

// TODO: Remove when the MMRC Extension mechanism is ready

#include "mstreampositioncontrol.h"

#include "mstreampositioncontrol.h"

#include "audioprocessingunit.h"

#include <ecom/implementationproxy.h> // 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<MAudioStream*>(this);

		}

	else if( aType == KUidExtensionInferface)

		{

		interface = static_cast<MCustomInterfaceSupport*>(this);

		}

	else if (aType == KUidAudioStreamAdaptationObserver)

		{

		interface = static_cast<MAudioStreamAdaptationObserver*>(this);

		DP0_RET(interface, "0x%x");

		}

	else if (aType == KUidAudioCodecObserver)

		{

		interface = static_cast<MAudioCodecObserver*>(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");

	}