// 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__