// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include "tonedatapath.h"

 CToneDataPath* CToneDataPath::NewL()

 	{

 	CToneDataPath* self = new(ELeave) CToneDataPath;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 void CToneDataPath::ConstructL()

 	{

 	iAudioPlayer = new (ELeave) CToneDataPathPlayer(*this,CActive::EPriorityUserInput);

 	iSoundDeviceErrorReceiver = new (ELeave) CToneSoundDevPlayErrorReceiver(*this, CActive::EPriorityUserInput);

 	}

 CToneDataPath::~CToneDataPath()

 	{

 	delete iAudioPlayer;

 	delete iSoundDeviceErrorReceiver;

 	iSoundDevice.Close();

 	if (iCodec)

 		{

 		delete iSourceBuffer;

 		if (!iCodec->IsNullCodec()) 

 			{

 			delete iSoundDeviceBuffer;

 			}

 		}

 #ifdef __USE_MMF_TRANSFERBUFFERS__

 	delete iTransferWindow;

 	if(iTransferBuffer)

 		{

 		iTransferBuffer->Close();

 		delete iTransferBuffer;

 		}

 #endif

 #ifdef __USE_MMF_PTRBUFFERS__

 	delete iPtrBufferMemoryBlock;

 #endif

 	}

 TInt CToneDataPath::SetObserver(MMMFHwDeviceObserver& aObserver)

 	{

 	TInt error;

 	if (iHwDeviceObserver)

 		{

 		error =  KErrAlreadyExists;

 		}

 	else

 		{

 		iHwDeviceObserver = &aObserver;

 		error  = KErrNone;

 		}

 	return error;

 	}

 TInt CToneDataPath::AddCodec(CToneCodec& aCodec)

 	{

 	if (iCodec)

 		{

 		return KErrNotSupported; //doesn't support multiple codecs

 		}

 	TInt err = KErrNone;

 	iCodec = &aCodec;

 	// Allocate data buffer

 	iSourceBufferSize = iCodec->SourceBufferSize();

 	iSoundDevBufferSize = iCodec->SinkBufferSize();

 	if ((!iSourceBufferSize)||(!iSoundDevBufferSize))

 		{

 		err = KErrArgument; //codec plugin has not specified buffer size

 		}

 	if (err == KErrNone)

 		{

 #ifdef __USE_MMF_TRANSFERBUFFERS__

 		TRAP(err,iSourceBuffer = CreateTransferBufferL(iSourceBufferSize, static_cast<CMMFTransferBuffer*>(iSourceBuffer)));

 #endif

 #ifdef __USE_MMF_PTRBUFFERS__

 		TRAP(err,iSourceBuffer = CreatePtrBufferL(iSourceBufferSize));

 #else

 		TRAP(err,iSourceBuffer = CMMFDataBuffer::NewL(iSourceBufferSize));

 #endif

 		}

 	if (err == KErrNone)

 		{

 		if (iCodec->IsNullCodec())

 			{//use source buffer for sound device buffer	

 			iSoundDeviceBuffer = NULL;

 			}

 		else

 			{//codec needs separate source and sound device buffers

 			TRAP(err,iSoundDeviceBuffer = CMMFDataBuffer::NewL(iSoundDevBufferSize));

 			}

 		}

 	return err;

 	}

 TInt CToneDataPath::Start()

 	{

 	TInt startError = KErrNone;

 	if (!iCodec) 

 		{//check that a codec has been added

 		startError = KErrNotReady;

 		}

 	if ((!iSoundDevice.Handle())&&(!startError))

     	{//check that the sound drivers can be opened

    		startError = iSoundDevice.Open();

 		}

 	if (iState == EPaused)

 		{//we are paused so need to resume play

 		if (!startError)

 			{

 #ifdef _SCW_DEBUG

 			RDebug::Print(_L("CToneDataPath::Start-Resume"));

 #endif

 			iAudioPlayer->ResumePlaying();

 			iState = EPlaying;

 			}

 		}

 	else if (!startError)

 		{

 #ifdef _SCW_DEBUG

 		RDebug::Print(_L("CToneDataPath::Start-Normal"));

 #endif

 		// get sample rate and channels from RMdaDevSound

 		RMdaDevSound::TCurrentSoundFormatBuf format;

 		iSoundDevice.GetPlayFormat(format);

 		iSampleRate = format().iRate;

 		iChannels = format().iChannels;

 		iNoMoreSourceData = EFalse;

 		iSourceBuffer->SetLastBuffer(EFalse);

 		iState = EPlaying;

 		iSoundDeviceErrorReceiver->Start();

 		TRAP(startError,FillSourceBufferL()); //get initial buffer of audio data

 		if (startError == KErrNone)

 			{

 			// Start the player objects

 			iAudioPlayer->Start();

 			}

 		else

 			{//failed to start up correctly go back to stopped state

 			iState = EStopped;

 			iSoundDeviceErrorReceiver->Stop();

 			}

    		}

 	return startError;

 	}

 // *** Main Play Loop ***

 void CToneDataPath::FillSourceBufferL()

 	{//asks observer to fill the source buffer          

     // Ask immediately for data from the observer

 #ifdef __CYCLE_MMF_DATABUFFERS__

 	// Create a new buffer to replicate INC021405 Play-EOF-Play on HwAccelerated solution Panics

 	// If the creation fails, we carry on regardless as the original buffer will not have been 

 	// destroyed. Must do this as alloc fail tests will not run.

 	if(iSourceBuffer)

 		{

 		iSourceBuffer = CycleAudioBuffer(iSourceBuffer);

 		}

 #endif // __CYCLE_MMF_DATABUFFERS__	

 	User::LeaveIfError(iHwDeviceObserver->FillThisHwBuffer(*iSourceBuffer));

 	}

 void CToneDataPath::BufferFilledL(CMMFDataBuffer& aBuffer)

 	{//call back from observer to indicate buffer has been filled

 	if (iState == EStopped)

 		{

 		User::Leave(KErrNotReady);//ok if paused?

 		}

 	iSourceBuffer = &aBuffer;

 	iSourceBuffer->SetStatus(EFull);

 #ifdef _SCW_DEBUG

 	RDebug::Print(_L("CToneDataPath::BufferFilledL"));

 #endif

 	//need to check that the buffer size is not 0 - if so assume we've reached the end of the data

 	iBuffSize = iSourceBuffer->BufferSize();

 	if (!iBuffSize)

 		{//no buffer  - could be end of source or could be that the source has no data??

 		iNoMoreSourceData = ETrue;

 #ifdef _SCW_DEBUG

 		RDebug::Print(_L("CToneDataPath::BufferFilledL-NoMoreSourceData"));

 #endif

 		}

 	//even if the buffer size is 0 we still 

 	//need to perform the following to get the sound device callback

 	FillSoundDeviceBufferL(); //get buffer in pcm16 format for sound device	

 	iAudioPlayer->PlayData(*iSoundDeviceBuffer); //play data to sound drivers

 	}

 void CToneDataPath::FillSoundDeviceBufferL()

 	{//use CToneCodec to fill the sound device buffer

 	CToneCodec::TCodecProcessResult codecProcessResult;

 	if (iCodec->IsNullCodec())

 		{//no codec so data can be sent direct to sink

 		iSoundDeviceBuffer = iSourceBuffer;

 		iSoundDeviceBuffer->SetStatus(EFull);	//sink buffer is full

 		}

 	else 

 		{

 		//pass buffer to codec for processing

 		codecProcessResult = iCodec->ProcessL(*iSourceBuffer, *iSoundDeviceBuffer);

 		if (iSourceBuffer->LastBuffer()) //if source is last buffer so is sound dev

 			{

 			iSoundDeviceBuffer->SetLastBuffer(ETrue);

 			}

 		if ((!iSoundDeviceBuffer->BufferSize())&&(codecProcessResult.iDstBytesAdded))

 			{//the codec has added data but not set the buffer length

 			iSoundDeviceBuffer->Data().SetLength(codecProcessResult.iDstBytesAdded);

 			}

 		//only supports EProcessComplete

 		switch (codecProcessResult.iCodecProcessStatus)

 			{

 		case CToneCodec::TCodecProcessResult::EProcessComplete:

 		//finished procesing source data - all data in sink buffer

 			{

 			iSoundDeviceBuffer->SetStatus(EFull);	//sink buffer is full	

 			}

 		break;

 #ifdef SYMBIAN_VARIABLE_BITRATE_CODEC

 		case CToneCodec::TCodecProcessResult::EProcessIncomplete:

 		//finished procesing source data - all data in sink buffer

 			{

 			iSoundDeviceBuffer->SetStatus(EFull);	//sink buffer is full	

 			}

 		break;

 #endif

 		case CToneCodec::TCodecProcessResult::EDstNotFilled:

 		//could be the last buffer in which case dst might not get filled

 			{

 			iSoundDeviceBuffer->SetStatus(EFull);	//sink buffer is full	

 			}

 		break;

 		case CToneCodec::TCodecProcessResult::EEndOfData:

 			//no more data - send what we've got to the sink

 			//note we can't always rely on this  - in many cases the codec will not know when

 			//it has reached the end of data.

 			{

 			iSoundDeviceBuffer->SetStatus(EFull);//sink buffer may not really be 'full' but its as full as it going to get

 			iNoMoreSourceData = ETrue;

 			//doesn't matter if sink buffer is not full

 			}

 		break;

 		default:

 			//Panic(EMMFSwCodecWrapperBadCodec); //should never get here - bad codec

 			break;

 			}

 		}

 	}

 void CToneDataPath::BufferEmptiedL(const CMMFDataBuffer& aBuffer)

 	{//call back from CToneDataPathPlayer when the sound device buffer has been emptied

 	if (&aBuffer != iSoundDeviceBuffer) 

 		{

 		Panic(EToneBadBuffer);

 		}

 	if (!iNoMoreSourceData) 

 		{

 		FillSourceBufferL();

 		}

 	}

 //*** End of Main Play Loop ***

 void CToneDataPath::Stop()

 	{

 	iAudioPlayer->Cancel();

 	iSoundDeviceErrorReceiver->Cancel();

     iSoundDevice.Close();

 #ifdef __CYCLE_MMF_DATABUFFERS__

 	// Create a new buffer to replicate INC021405 Play-EOF-Play on HwAccelerated solution Panics

 	// If the creation fails, we carry on regardless as the original buffer will not have been 

 	// destroyed. Must do this as alloc fail tests will not run.

 	if(iSourceBuffer)

 		{

 		iSourceBuffer = CycleAudioBuffer(iSourceBuffer);

 		}

 #endif // __CYCLE_MMF_DATABUFFERS__	

 	iState = EStopped;

 	}

 void CToneDataPath::Pause()

 	{

 	//since a pause can happen anyway in the datatransfer -need to set to a known 

 	//state so that when play is resumed the behaviour is predictable

 	if (iSoundDevice.Handle())

 		{

 		iSoundDevice.PausePlayBuffer(); //needs new LDD

 		iState = EPaused;

 #ifdef _SCW_DEBUG

 		RDebug::Print(_L("Pause"));

 #endif

 		}

 	else

 		{//an error must have occured 

 		iState = EStopped;

 		}

 	}

 TInt CToneDataPath::EmptyBuffers()

 	{

 	TInt error = KErrNone;

 	if (iSoundDevice.Handle() == 0)

 		{

 		error = KErrNotReady;		

 		}

 	else

 		{

 		iSoundDevice.FlushPlayBuffer();

 		}

 	return error;

 	}	

 RMdaDevSound& CToneDataPath::Device()

 	{

 	return iSoundDevice;

 	}

 void CToneDataPath::SoundDeviceException(TInt aError)

 	{

 	if(iIgnoreUnderflow)

 		{

 		if((aError == KErrUnderflow) && (!iNoMoreSourceData))

 			{

 			//ignore underflow

 			return;

 			}

 		}

 	//this sends a request to the hw device observer

 	//to update the bytes played

 	//it is done here so that the sound driver can be closed prior to

 	//updating the policy and sending the error back

 	TUid uidUpdateBytesPlayed;

 	uidUpdateBytesPlayed.iUid = KToneHwDeviceObserverUpdateBytesPlayed;

 	TPtrC8 dummy(0,0);

 	ASSERT(iHwDeviceObserver);

 	iHwDeviceObserver->MsgFromHwDevice(uidUpdateBytesPlayed,dummy);

 	//this closes RMdaDevSound.

 	Stop(); 

 	//inform devsound so it can update policy

 	iHwDeviceObserver->Stopped(); 

 	// Inform the observer of the exception condition

 	// We inform the hw device observer after the policy has been

 	// updated incase the observer relied on the error to assume

 	// the policy has been updated

 	iHwDeviceObserver->Error(aError);

 	RDebug::Print(_L("CToneDataPath::iHwDeviceObserver->Error(%d)"),aError);

 	}

 /**

 Retrieves a custom interface to the device.

 The reference CToneDataPath supports three  custom interfaces,

 MEmptyBuffersCustomInterface, MSetVbrFlagCustomInterface and MIgnoreUnderflowEventsCustomInterface

 @param	aInterface

 		Interface UID, defined with the custom interface.

 		aInterface = KMmfUidEmptyBuffersCustomInterface for MEmptyBuffersCustomInterface,

 					 KSetVbrFlagCustomInterfaceTypeUid for MSetVbrFlagCustomInterface

 @return A pointer to the interface implementation, or NULL if the device can not

 		implement the interface requested. The return value must be cast to the

 		correct type by the user.

 */

 TAny* CToneDataPath::CustomInterface(TUid aInterface)

 	{

 	TAny* ret = NULL;

 	if (aInterface == KIgnoreUnderflowCustomInterfaceTypeUid)

 		{

 		MIgnoreUnderflowEventsCustomInterface* result = static_cast<MIgnoreUnderflowEventsCustomInterface*> (this);

 		ret = static_cast<TAny*>(result);

 		}

 	return ret;

 	}

 void CToneDataPath::IgnoreUnderflowEvents()

 	{

 	iIgnoreUnderflow = ETrue;

 	}

 /************************************************************************

  *				CDataPathPlayer											*

  ************************************************************************/

 CToneDataPathPlayer::CToneDataPathPlayer(CToneDataPath& aParent, TInt aPriority)

 : CActive(aPriority), iParent(aParent)

 	{

 	CActiveScheduler::Add(this);

 	}

 CToneDataPathPlayer::~CToneDataPathPlayer()

 	{

 	Cancel();

 	}

 void CToneDataPathPlayer::Start()

 	{

 	// No implementation

 	}

 void CToneDataPathPlayer::ResumePlaying()

 	{

 	if (iParent.Device().Handle())

 		{

 		//should be ok to call this even if we are active

 		iParent.Device().ResumePlaying(); 

 		iResumePlaying = ETrue;

 		}

 #ifdef _SCW_DEBUG

 	RDebug::Print(_L("Playing Resumed"));

 #endif

 	}

 void CToneDataPathPlayer::PlayData(const CMMFDataBuffer& aData)

 	{

 	iDataFromSource = &aData;

 	if (!IsActive())

 		{

 #ifdef _SCW_DEBUG

 		RDebug::Print(_L("CToneDataPathPlayer::PlayData"));

 #endif

 		iParent.Device().PlayData(iStatus,(static_cast<const CMMFDataBuffer*> (iDataFromSource))->Data());

 		SetActive();

 		}

 	}

 void CToneDataPathPlayer::Stop()

 	{

 	if (!IsActive())

 		{

 		iParent.Device().FlushPlayBuffer(); // Otherwise won't be flushed

 		}

 	Cancel();

 	iParent.SoundDeviceException(KErrCancel);

 	}

 void CToneDataPathPlayer::RunL()

 	{

 #ifdef _SCW_DEBUG

 	RDebug::Print(_L("CToneDataPathPlayer::RunL error[%d]"), iStatus.Int());

 #endif

 	if (iStatus.Int()!=KErrNone)

 		{

 		iParent.SoundDeviceException(iStatus.Int());

 		}

 	else

 		{

 		iParent.BufferEmptiedL(static_cast<const CMMFDataBuffer&>(*iDataFromSource));

 		iResumePlaying = EFalse;

 		}

 	}

 TInt CToneDataPathPlayer::RunError(TInt aError)

 	{

 	Error(aError);

 	return KErrNone;

 	}

 void CToneDataPathPlayer::DoCancel()

 	{

 	if (iParent.Device().Handle())

 		{

 		iParent.Device().CancelPlayData();

 		iParent.Device().FlushPlayBuffer();

 		}

 	}

 void CToneDataPathPlayer::Error(TInt aError)

 	{ 

 	iParent.SoundDeviceException(aError);

 	}

 /************************************************************************

  *				CToneSoundDevPlayErrorReceiver							*

  ************************************************************************/

 CToneSoundDevPlayErrorReceiver::CToneSoundDevPlayErrorReceiver(CToneDataPath& aParent, TInt aPriority)

 : CActive(aPriority), iParent(aParent)

 	{

 	CActiveScheduler::Add(this);

 	}

 CToneSoundDevPlayErrorReceiver::~CToneSoundDevPlayErrorReceiver()

 	{

 	Cancel();

 	}

 void CToneSoundDevPlayErrorReceiver::Start()

 	{

 	iParent.Device().NotifyPlayError(iStatus);

 	SetActive();

 	}

 void CToneSoundDevPlayErrorReceiver::Stop()

 	{

 	Cancel();

 	}

 void CToneSoundDevPlayErrorReceiver::RunL()

 	{

 	TInt reason = iStatus.Int();

 	Start();

 	// An error has been returned

 #ifdef _SCW_DEBUG

 	RDebug::Print(_L("CToneSoundDevPlayErrorReceiver::RunL[%d]"), reason);

 #endif

 	iParent.SoundDeviceException(reason);

 	}

 void CToneSoundDevPlayErrorReceiver::DoCancel()

 	{

 	iParent.Device().CancelNotifyPlayError();

 	}

 /*

  * CycleAudioBufferL

  *

  * Sets up a usable buffer for passing to MMF

  *	

  * This method has been written such that it must allocate a new buffer before

  * replacing the existing one. The purpose of this is to force creation of a 

  * new buffer. Simply deleting and then re-allocing may result in the same 

  * address being used.

  * 

  * Only cycles if there is enough memory

  *

  */

 #ifdef __CYCLE_MMF_DATABUFFERS__

 CMMFDataBuffer* CToneDataPath::CycleAudioBuffer(CMMFDataBuffer* aBuffer)

 	{

 	CMMFDataBuffer* buffer = NULL;

 	TUint bufferSize = aBuffer->Data().MaxLength();

 #ifdef __USE_MMF_TRANSFERBUFFERS__

 	TRAPD(err, buffer = CreateTransferBufferL(bufferSize, static_cast<CMMFTransferBuffer*>(aBuffer)));

 #else

 	TRAPD(err,buffer = CMMFDataBuffer::NewL(bufferSize));

 	if (err == KErrNone)

 		{

 		delete aBuffer;

 		}

 #endif

 	if (err != KErrNone)

 		{//there was a problem creating buffer eg OOM so use same buffer

 		buffer = aBuffer;

 		}

 	return buffer;

 	}

 #endif

 /*

  * DoCleanupRHandleBase

  *

  * This method will initially Close the handle and then delete it.

  *

  */

 #ifdef __USE_MMF_TRANSFERBUFFERS__

 inline static void DoCleanupRHandleBase(TAny* aRHandleBase)

 	{

 	ASSERT(aRHandleBase);

 	RHandleBase* rHandleBase = static_cast<RHandleBase*> (aRHandleBase);

 	TRAPD(error, rHandleBase->Close());

 	delete aRHandleBase;

 	}

 CMMFTransferBuffer* CToneDataPath::CreateTransferBufferL(TUint aBufferSize, CMMFTransferBuffer* aOldBuffer)

 	{

 	CMMFTransferBuffer* buffer = NULL;

 	RTransferBuffer* transBuffer = new  (ELeave) RTransferBuffer;

 	TCleanupItem bufferCleanupItem(DoCleanupRHandleBase, transBuffer); //closes and deletes.

 	CleanupStack::PushL(bufferCleanupItem);

 	RTransferWindow* transWindow = new (ELeave) RTransferWindow;

 	TCleanupItem windowCleanupItem(DoCleanupRHandleBase, transWindow); //closes and deletes.

 	CleanupStack::PushL(windowCleanupItem);

 	User::LeaveIfError(transBuffer->Create(aBufferSize));

 	User::LeaveIfError(transWindow->Create(aBufferSize));

 	User::LeaveIfError(transWindow->MapInBuffer(*transBuffer));

 	buffer = CMMFTransferBuffer::NewL(*transWindow);

 	delete aOldBuffer; //closes RTransferWindow

 	delete iTransferWindow;

 	if(iTransferBuffer)

 		{

 		iTransferBuffer->Close();

 		}

 	delete iTransferBuffer;

 	iTransferBuffer = transBuffer;

 	iTransferWindow = transWindow;

 	CleanupStack::Pop(transWindow); 

 	CleanupStack::Pop(transBuffer); 

 	return buffer;

 	}

 #endif

 #ifdef __USE_MMF_PTRBUFFERS__

 CMMFPtrBuffer* CToneDataPath::CreatePtrBufferL(TUint aBufferSize)

 	{

 	CMMFPtrBuffer* buffer = NULL;

 	if (iPtrBufferMemoryBlock)

 		{

 		delete iPtrBufferMemoryBlock;//incase already exisits

 		}

 	iPtrBufferMemoryBlock = HBufC8::NewL(aBufferSize);

 	TPtr8 ptrMemoryBlock(iPtrBufferMemoryBlock->Des());

 	buffer = CMMFPtrBuffer::NewL(ptrMemoryBlock);

 	return buffer;

 	}

 #endif  // __USE_MMF_PTRBUFFERS__