// 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 "cdevaudio.h"

#include "cdevaudiocontrol.h"

#include "cdevplaycontrol.h"

#include "cdevrecordcontrol.h"

#include "cdevtonecontrol.h"

#include "cdevgencontrol.h"

#include <a3f/audioprocessingunittypeuids.h>

#include <a3f/devsoundadaptationinfo.h>

#include <a3f/a3ffourcclookup.h>

#include <a3f/audiocontextfactory.h>

#include <a3f/maudioprocessingunit.h>

#include <a3f/maudiocontext.h>

#include <a3f/mcontexteffectiveclient.h>

#include <a3f/maudiostream.h>

#include <a3f/maudiocodec.h>

#include <a3f/maudiogaincontrol.h>

#include <a3f/mbuffersource.h>

#include <a3f/mbuffersink.h>

#include "mglobalproperties.h"

const TInt KMidWayBalance = 50; // 50%

const TInt KMaxBalance = 100; // 100%

const TInt KLeftChannel = 0;

const TInt KRightChannel = 1;

// ======== LOCAL FUNCTIONS ========

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// Default constructor

// ---------------------------------------------------------------------------

//

CDevAudio::CDevAudio(MDevSoundAdaptationObserver& aAdaptationObserver)

	: iAdaptationObserver(aAdaptationObserver), iMode(EMMFStateIdle), 

	iActiveState(EDevSoundAdaptorCreated_Uninitialised),

	iActiveStreamState(EUninitialized)

	{

	TRACE_CREATE();

	DP_CONTEXT(CDevAudio::CDevAudio *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iDevSoundPlayBalance[KLeftChannel] = iDevSoundPlayBalance[KRightChannel] = KMidWayBalance;

	iDevSoundRecordBalance[KLeftChannel] = iDevSoundRecordBalance[KRightChannel] = KMidWayBalance;

	DP_OUT();

	}

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CDevAudio::~CDevAudio()

	{

	DP_CONTEXT(CDevAudio::~CDevAudio *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	delete iAdaptationInfo;

	iSupportedInputFormats.Close();

	iSupportedOutputFormats.Close();

	// This part is fine at the destructor

	// All this is syncronous

	if ( iAudioContext )

		{

		if ( iGainControl )

			{

			iAudioContext->DeleteAudioProcessingUnit(iGainControl);

			}

		if ( iAudioSink )

			{

			iAudioContext->DeleteAudioProcessingUnit(iAudioSink);

			}

		if ( iAudioCodec )

			{

			iAudioContext->DeleteAudioProcessingUnit(iAudioCodec);

			}

		if ( iAudioSource )

			{

			iAudioContext->DeleteAudioProcessingUnit(iAudioSource);

			}

		if ( iAudioStream )

			{

			iAudioContext->DeleteAudioStream(iAudioStream);

			}

		}

	iAudioContextFactory->DeleteAudioContext(iAudioContext);

	if ( iAudioContextFactory )

		{

		delete iAudioContextFactory;

		}

	if ( iDevPlayControl )

		{

		delete iDevPlayControl;

		}

	if ( iDevRecordControl )

		{

		delete iDevRecordControl;

		}

	if ( iDevToneControl )

		{

		delete iDevToneControl;

		}

	if ( iDevGenControl )

		{

		delete iDevGenControl;

		}

	DP_OUT();

	}

// -----------------------------------------------------------------------------

// CDevAudio::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CDevAudio* CDevAudio::NewL(MDevSoundAdaptationObserver& aAdaptationObserver, 

									MGlobalProperties& aGlobalProperties)

	{

	DP_STATIC_CONTEXT(CDevAudio::NewL *CD0*, CtxDevSound, DPLOCAL);

	DP_IN();

	CDevAudio* self = new (ELeave) CDevAudio(aAdaptationObserver);

	CleanupStack::PushL(self);

	self->ConstructL(aGlobalProperties);

	CleanupStack::Pop(self);

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

	}

// -----------------------------------------------------------------------------

// CDevAudio::ConstructL

// -----------------------------------------------------------------------------

//

void CDevAudio::ConstructL(MGlobalProperties& aGlobalProperties)

	{

	DP_CONTEXT(CDevAudio::ConstructL *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	iGlobalProperties = &aGlobalProperties;

	iAudioContextFactory = CAudioContextFactory::NewL();

	User::LeaveIfError(iAudioContextFactory->CreateAudioContext(iAudioContext));

	User::LeaveIfError(iAudioContext->CreateAudioStream(iAudioStream));

	User::LeaveIfError(iAudioContext->CreateAudioProcessingUnit(KUidAudioGainControl, iGainControl));

	User::LeaveIfError(iAudioStream->AddGainControl(iGainControl));

	iDevPlayControl = CDevPlayControl::NewL(this, iAdaptationObserver);

	iDevRecordControl = CDevRecordControl::NewL(this, iAdaptationObserver);

	iDevToneControl = CDevToneControl::NewL(this, iAdaptationObserver);

	iDevGenControl = CDevGenControl::NewL(this, iAdaptationObserver);

	iAdaptationInfo = CA3FDevSoundAdaptationInfo::NewL(*this, const_cast<CFourCCConvertor&>(iGlobalProperties->GetFourCCConvertor()));

	// The generic audio control is the only one receiving the callbacks at this moment

	iCurrentAudioControl = static_cast<CDevAudioControl*>(iDevGenControl);

	TInt err = iAudioContext->RegisterAudioContextObserver(*iCurrentAudioControl);

	if ((err != KErrNone) && (err != KErrAlreadyExists))

		{

		User::Leave(err);

		}

	DP_OUT();

	}

// -----------------------------------------------------------------------------

// CDevAudio::PostOpen

// -----------------------------------------------------------------------------

//

TInt CDevAudio::PostOpen()

	{

	DP_CONTEXT(CDevAudio::PostOpen *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(iPreOpenState==EPreOpenStateIdle);

	TInt err = KErrNone;

	if(iPreOpenState == EPreOpenStateIdle)

		{

		err = iAdaptationInfo->RequestMaxGain(KUidAudioDecoder);

		if (err == KErrNone)

			{

			iPreOpenState = EPreOpenStateRequestingMaxVolume;

			}

		}

	DP0_RET(err, "%d");

	}

TBool CDevAudio::IsResumeSupported()

	{

	DP_CONTEXT(CDevAudio::IsResumeSupported *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TUid codecType(KNullUid);

	if(iMode == EMMFStatePlaying || iMode == EMMFStateTonePlaying)

		{

		codecType = KUidAudioDecoder;

		}

	else if (iMode == EMMFStateRecording)

		{

		codecType = KUidAudioEncoder;

		}

	TBool supported = iAdaptationInfo->IsResumeSupported(codecType, iFormat);

	DP0_RET(supported, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudio::RequestMaxGainComplete

// -----------------------------------------------------------------------------

//

void CDevAudio::RequestMaxGainComplete (TUid __DEBUG_ONLY(aCodecType), TInt aError, TInt aResult)

	{

	DP_CONTEXT(CDevAudio::RequestMaxGainComplete *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(iPreOpenState==EPreOpenStateRequestingMaxVolume && aCodecType==KUidAudioDecoder||

			iPreOpenState==EPreOpenStateRequestingMaxGain && aCodecType==KUidAudioEncoder);

	TInt err = aError;

	TBool asyncComplete = EFalse;

	if (err == KErrNone)

		{

		if (iPreOpenState==EPreOpenStateRequestingMaxVolume)

			{

			iDevSoundMaxVolume = aResult;

			err = SetDevSoundVolume((iDevSoundMaxVolume+1)/2, asyncComplete);

			__ASSERT_DEBUG(asyncComplete==EFalse, User::Invariant());

			if(err == KErrNone)

				{

				// first request - so request max gain

				err = iAdaptationInfo->RequestMaxGain(KUidAudioEncoder);

				if (err == KErrNone)

					{

					iPreOpenState = EPreOpenStateRequestingMaxGain;

					}

				}

			}

		else if(iPreOpenState==EPreOpenStateRequestingMaxGain)

			{

			iDevSoundMaxGain = aResult;

			err = SetDevSoundGain((iDevSoundMaxGain+1)/2, asyncComplete);

			__ASSERT_DEBUG(asyncComplete==EFalse, User::Invariant());

			if(err == KErrNone)

				{

				// second request - complete whatever - Ready for Formats

				err = iAdaptationInfo->RequestSupportedFormats(KUidAudioDecoder, iSupportedInputFormats);

				if (err == KErrNone)

					{

					iPreOpenState = EPreOpenStateRequestingInputFormats;

					}

				}

			}

		}

	if (err!=KErrNone)

		{

		iPreOpenState = EPreOpenStateIdle;

		iAdaptationObserver.AsynchronousOperationComplete(err, ETrue);

		}

	DP_OUT();

	}

// -----------------------------------------------------------------------------

// CDevAudio::RequestSupportedFormatsComplete

// -----------------------------------------------------------------------------

//

void CDevAudio::RequestSupportedFormatsComplete(TUid __DEBUG_ONLY(aCodecType), TInt aError)

	{

	DP_CONTEXT(CDevAudio::RequestSupportedFormatsComplete *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	ASSERT(iPreOpenState==EPreOpenStateRequestingInputFormats && aCodecType==KUidAudioDecoder||

			iPreOpenState==EPreOpenStateRequestingOutputFormats && aCodecType==KUidAudioEncoder);

	TInt err = aError;

	if (err == KErrNone)

		{

		if (iPreOpenState==EPreOpenStateRequestingInputFormats)

			{

			// first request - so request output formats

			err = iAdaptationInfo->RequestSupportedFormats(KUidAudioEncoder, iSupportedOutputFormats);

			if (err == KErrNone)

				{

				iPreOpenState = EPreOpenStateRequestingOutputFormats;

				}

			}

		else

			{

			ASSERT(iPreOpenState==EPreOpenStateRequestingOutputFormats);

			// second request - complete whatever

			iPreOpenState = EPreOpenStateIdle;

			iAdaptationObserver.AsynchronousOperationComplete(aError, ETrue);

			}

		}

	if (err!=KErrNone)

		{

		iPreOpenState = EPreOpenStateIdle;

		iAdaptationObserver.AsynchronousOperationComplete(err, ETrue);

		}

	DP_OUT();

	}

// -----------------------------------------------------------------------------

// CDevAudio::Initialize

// -----------------------------------------------------------------------------

//

TInt CDevAudio::Initialize(TUid aFormat, TMMFState aMode)

	{

	DP_CONTEXT(CDevAudio::Initialize*CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	if(iActiveState != EDevSoundAdaptorCreated_Uninitialised &&

		iActiveState != EDevSoundAdaptorInitialised_Initialised && 

		iActiveState != EDevSoundAdaptorInitialised_Idle &&

		iActiveState != EDevSoundAdaptorUnitialised_Uninitialised )

		{

		DP0_RET(KErrNotReady, "%d");

		}

	// Reinitialization 

	if (iActiveState == EDevSoundAdaptorInitialised_Initialised || 

		iActiveState == EDevSoundAdaptorInitialised_Idle)

		{

		iReinitializing = ETrue;

		iTargetFormat = aFormat;

		iTargetMode = aMode;

		if(iActiveState == EDevSoundAdaptorInitialised_Idle)

			{

			err = iAudioStream->Unload();

			if(err == KErrNone)

				{

				err = CommitAudioContext();

				}

			if(err == KErrNone)

				{

				iActiveState = EDevSoundAdaptorUnloading;

				}

			}

		else

			{

			err = iCurrentAudioControl->Uninitialize();

			}

		DP0_RET(err, "%d");

		}

	// Redo partial initialization after pre-emption clash event in

	// EDevSoundAdaptorRemovingProcessingUnits state

	if (iActiveState == EDevSoundAdaptorUnitialised_Uninitialised &&

			iPreviousState == EDevSoundAdaptorRemovingProcessingUnits)

		{

		err = iCurrentAudioControl->RemoveProcessingUnits();

		DP0_RET(err, "%d");

		}

	// Delete pUnits if already created

	if (iAudioSource)

		{

		iAudioContext->DeleteAudioProcessingUnit(iAudioSource);

		iAudioSource = NULL;

		}

	if (iAudioSink)

		{

		iAudioContext->DeleteAudioProcessingUnit(iAudioSink);

		iAudioSink = NULL;

		}

	if (iAudioCodec)

		{

		iAudioContext->DeleteAudioProcessingUnit(iAudioCodec);

		iAudioCodec = NULL;

		}

	//	Create pUnits and select proper DevSound Adaptor Helper

	if (aMode == EMMFStatePlaying)

		{

		// create correct type sink&source&codec

		err = CreateAudioProcessingUnits(KUidMmfBufferSource, KUidAudioDeviceSink, KUidAudioDecoder);

		if (err == KErrNone)

			{

			// Now just the playcontrol should receive the only one receiving events from 

			// AudioContext

			iAudioContext->UnregisterAudioContextObserver(*iCurrentAudioControl);

			iCurrentAudioControl = static_cast<CDevAudioControl*>(iDevPlayControl);

			err = iAudioContext->RegisterAudioContextObserver(*iCurrentAudioControl);

			}

		if ((err != KErrNone) && (err != KErrAlreadyExists))

			{

			DeleteAudioProcessingUnits();

			}

		}

	else if (aMode == EMMFStateRecording)

		{

		// create correct type sink&source&codec

		err = CreateAudioProcessingUnits(KUidAudioDeviceSource, KUidMmfBufferSink, KUidAudioEncoder);

		if (err == KErrNone)

			{

			iAudioContext->UnregisterAudioContextObserver(*iCurrentAudioControl);

			iCurrentAudioControl = static_cast<CDevAudioControl*>(iDevRecordControl);

			err = iAudioContext->RegisterAudioContextObserver(*iCurrentAudioControl);

			}

		if ((err != KErrNone) && (err != KErrAlreadyExists))

			{

			DeleteAudioProcessingUnits();

			}

		}

	else if (aMode == EMMFStateTonePlaying)

		{

		// create correct type sink&source&codec

		err = CreateAudioProcessingUnits(KUidMmfBufferSource, KUidAudioDeviceSink, KUidAudioDecoder);

		if (err == KErrNone)

			{

			iAudioContext->UnregisterAudioContextObserver(*iCurrentAudioControl);

			iCurrentAudioControl =  static_cast<CDevAudioControl*>(iDevToneControl);

			err = iAudioContext->RegisterAudioContextObserver(*iCurrentAudioControl);

			}

	if ((err != KErrNone) && (err != KErrAlreadyExists))

			{

			DeleteAudioProcessingUnits();

			}

		}

	else if (aMode == EMMFStateIdle)

		{

		// Unsure about this

		iAudioContext->UnregisterAudioContextObserver(*iCurrentAudioControl);

		iCurrentAudioControl =  static_cast<CDevAudioControl*>(iDevGenControl);

		err = iAudioContext->RegisterAudioContextObserver(*iCurrentAudioControl);

		}

	else

		{

		iCurrentAudioControl = static_cast<CDevAudioControl*>(iDevGenControl);

		err = KErrNotSupported;

		}

	if (err == KErrNone)

		{

		err = iCurrentAudioControl->Initialize(aFormat);	

		}

	if(err == KErrNone)

		{

		iMode = aMode;

		iFormat = aFormat;

		}

	DP0_RET(err, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudio::CancelInitialize

// -----------------------------------------------------------------------------

//

TInt CDevAudio::CancelInitialize()

	{

	DP_CONTEXT(CDevAudio::CancelInitialize *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	TInt err(KErrNone);

	// Redo partial cancelling of initialization after pre-emption clash event in

	// EDevSoundAdaptorRemovingProcessingUnits state.

	if (iActiveState == EDevSoundAdaptorUnitialised_Uninitialised &&

			iPreviousState == EDevSoundAdaptorRemovingProcessingUnits)

		{

		err = iCurrentAudioControl->RemoveProcessingUnits();

		DP0_RET(err, "%d");

		}

	else if(iActiveState != EDevSoundAdaptorInitialised_Initialised)

		{

		DP0_RET(KErrNotReady, "%d");

		}

	err = iCurrentAudioControl->Uninitialize();

	DP0_RET(err, "%d");

	}

// -----------------------------------------------------------------------------

// CDevAudio::GetAudioControl

// -----------------------------------------------------------------------------

//

CDevAudioControl* CDevAudio::GetAudioControl()

	{

	DP_CONTEXT(CDevAudio::GetAudioControl *CD1*, CtxDevSound, DPLOCAL);

	DP_IN();

	DP_OUT();

	return iCurrentAudioControl;