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

// source\server\mmfswcodecplaydatapath.cpp

// 

//

#include "mmfSwCodecPlayDataPath.h"

#include <mmf/server/mmfswcodecwrapper.h>

#include <mmf/server/mmfswcodecwrappercustominterfacesuids.hrh>

#include <mmf/common/mmfpaniccodes.h>

#include "mmfSwCodecUtility.h"

const TInt KBytesPerSample = 2;

const TInt KMaxBytesInSec = 192000; //considering maximum samplerate 96KHz

CMMFSwCodecPlayDataPath* CMMFSwCodecPlayDataPath::NewL()

	{

	CMMFSwCodecPlayDataPath* self = new(ELeave) CMMFSwCodecPlayDataPath;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

void CMMFSwCodecPlayDataPath::ConstructL()

	{

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

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

	iUtility = CMMFSwCodecUtility::NewL();

	iVbrFlag = EFalse;

	}

CMMFSwCodecPlayDataPath::~CMMFSwCodecPlayDataPath()

	{

	delete iAudioPlayer;

	delete iSoundDeviceErrorReceiver;

	delete iUtility;

	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 CMMFSwCodecPlayDataPath::SetObserver(MMMFHwDeviceObserver& aObserver)

	{

	TInt error;

	if (iHwDeviceObserver)

		{

		error =  KErrAlreadyExists;

		}

	else

		{

		iHwDeviceObserver = &aObserver;

		error  = KErrNone;

		}

	return error;

	}

TInt CMMFSwCodecPlayDataPath::AddCodec(CMMFSwCodec& 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 CMMFSwCodecPlayDataPath::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("CMMFSwCodecPlayDataPath::Start-Resume"));

#endif

			iAudioPlayer->ResumePlaying();

			iState = EPlaying;

			}

		}

	else if (!startError)

		{

#ifdef _SCW_DEBUG

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

#endif

		// get sample rate and channels from RMdaDevSound

		RMdaDevSound::TCurrentSoundFormatBuf format;

		iSoundDevice.GetPlayFormat(format);

		iSampleRate = format().iRate;

		iChannels = format().iChannels;

		iNoMoreSourceData = EFalse;

		iNoMoreSoundDeviceData = EFalse;

		iSourceBuffer->SetLastBuffer(EFalse);

		iBytesPlayed = 0;

		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 CMMFSwCodecPlayDataPath::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 CMMFSwCodecPlayDataPath::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("CMMFSwCodecPlayDataPath::BufferFilledL"));

#endif

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

	if (!iSourceBuffer->BufferSize())

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

		iNoMoreSourceData = ETrue;

#ifdef _SCW_DEBUG

		RDebug::Print(_L("CMMFSwCodecPlayDataPath::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	

    /* iVbrFlag is added to datapath to avail the alternative dataflow wherein datapath makes sure that 

    destinationbuffer is filled to its maximum length before sending it to the sound driver. 

    Sending the buffer directly to the device causes underflow incase of Vorbis codecs.*/

    if (iVbrFlag)

    	{

    	/*There are two cases we need to deal here

      	1. When the output of the codec is 0 for header data.

           in that case, repeat till actual decoding of ogg packets and pages.

        2. When destination buffer is not filled even to its half length, get next source buffer

           and decode it. This is to avoid underflows when ever we receive little pcm for a 

           a given source buffer.

           */

	    if (iSoundDeviceBuffer->Data().Length() < iSoundDeviceBuffer->Data().MaxLength()/2 && !(iSoundDeviceBuffer->LastBuffer()))

			{

	    	iSourceBuffer->SetStatus(EAvailable); //source buffer is now available

	    	iSoundDeviceBuffer->SetPosition(iSoundDeviceBuffer->Data().Length());//this indicates the available space in the buffer to the codec

	    	FillSourceBufferL();	

	    	return;

	    	}

		else //data is sufficient to avoid underflows

			{

			iSoundDeviceBuffer->SetPosition(0);

			if(iSoundDeviceBuffer->Data().Length()==0 && iSoundDeviceBuffer->LastBuffer())

				{

				iNoMoreSoundDeviceData = ETrue;

				}

			}	

    	}

    // attenuate the amplitude of the samples if volume ramping has been changed

	// and is non-zero

	if (iCustomInterface)

		{

		TTimeIntervalMicroSeconds volumeRamp = iCustomInterface->VolumeRamp();

		if (volumeRamp != iVolumeRamp)

			{

			iVolumeRamp = volumeRamp;

			if (iVolumeRamp.Int64() != 0)

				{

				iUtility->ConfigAudioRamper(

					iVolumeRamp.Int64(), 

					iSampleRate, 

					iChannels);

				iRampAudioSample = ETrue;

				}

			else

				{

				iRampAudioSample = EFalse;

				}

			}

			if (iRampAudioSample)

				iRampAudioSample = iUtility->RampAudio(iSoundDeviceBuffer);

		}

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

	if (iSourceBuffer->LastBuffer())//check last buffer flag

		{

		iNoMoreSourceData = ETrue;

#ifdef _SCW_DEBUG

		RDebug::Print(_L("CMMFSwCodecPlayDataPath::BufferFilledL-LBNoMoreSourceData"));

#endif

		}

	}

void CMMFSwCodecPlayDataPath::FillSoundDeviceBufferL()

	{//use CMMFSwCodec to fill the sound device buffer

	CMMFSwCodec::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 CMMFSwCodec::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 CMMFSwCodec::TCodecProcessResult::EProcessIncomplete:

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

			{

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

			}

		break;

#endif

		case CMMFSwCodec::TCodecProcessResult::EDstNotFilled:

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

			{

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

			}

		break;

		case CMMFSwCodec::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

			}

		}

	}

void CMMFSwCodecPlayDataPath::BufferEmptiedL(const CMMFDataBuffer& aBuffer)

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

	if (&aBuffer != iSoundDeviceBuffer) 

		Panic(EMMFSwCodecWrapperBadBuffer);

	if(iVbrFlag && (iSourceBuffer->Status() == EUnAvailable || iNoMoreSourceData))

		{//No more source data. Play rest of the decoded data.Inform codec not to consider the source buffer

		if(iSourceBuffer->Status()!=EUnAvailable)

			{

			iSourceBuffer->SetStatus(EUnAvailable);

			}

		FillSoundDeviceBufferL();

		if(iSoundDeviceBuffer->BufferSize() > 0)

			{

			// attenuate the amplitude of the samples if volume ramping has been changed

			// and is non-zero

			if (iCustomInterface)

				{

				TTimeIntervalMicroSeconds volumeRamp = iCustomInterface->VolumeRamp();

				if (volumeRamp != iVolumeRamp)

					{

					iVolumeRamp = volumeRamp;

					if (iVolumeRamp.Int64() != 0)

						{

						iUtility->ConfigAudioRamper(iVolumeRamp.Int64(), iSampleRate, iChannels);

						iRampAudioSample = ETrue;

						}

					else

						{

						iRampAudioSample = EFalse;

						}

					}

				if (iRampAudioSample)

					{

					iRampAudioSample = iUtility->RampAudio(iSoundDeviceBuffer);

					}

				}

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

			return;

			}

		else

			{

			if(iNoMoreSourceData)

				{

				iNoMoreSoundDeviceData = ETrue;

				}

			iSourceBuffer->SetStatus(EAvailable);

			}

		}

	if (!iNoMoreSourceData) 

		FillSourceBufferL();

	}

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

void CMMFSwCodecPlayDataPath::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 CMMFSwCodecPlayDataPath::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 CMMFSwCodecPlayDataPath::EmptyBuffers()

	{

	TInt error = KErrNone;

	if (iSoundDevice.Handle() == 0)

		{

		error = KErrNotReady;

		}

	else

		{ 

		iAudioPlayer->Cancel();

		iSoundDevice.CancelPlayData();

		iSoundDeviceErrorReceiver->Stop();

		iState = EStopped;

		}

	return error;

	}	

RMdaDevSound& CMMFSwCodecPlayDataPath::Device()

	{

	return iSoundDevice;

	}

void CMMFSwCodecPlayDataPath::SoundDeviceException(TInt aError)

	{

	if(iIgnoreUnderflow)

		{

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

			{

			//ignore underflow

			return;

			}

		//for VBR codec data,no more source does not mean that no more sounddevice data

		//so ignore underflows till the last buffer is played from the codec

		else if(iVbrFlag && aError==KErrUnderflow && !iNoMoreSoundDeviceData)

			{

			//ignore underflow

			return;

			}	

		}

	//this sends a request to the hw device observer usually Devsound

	//to update the bytes played

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

	//updating the plicy and sending the error back

	TUid uidUpdateBytesPlayed;

	uidUpdateBytesPlayed.iUid = KMmfHwDeviceObserverUpdateBytesPlayed;

	TPtrC8 dummy(0,0);

	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);

	}

void CMMFSwCodecPlayDataPath::SetPlayCustomInterface(MPlayCustomInterface& aCustomInterface)

	{

	iCustomInterface = &aCustomInterface;

	}

/**

Retrieves a custom interface to the device.

The reference CMMFSwCodecWrapper supports two  custom interfaces,

MEmptyBuffersCustomInterface and MSetVbrFlagCustomInterface

@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* CMMFSwCodecPlayDataPath::CustomInterface(TUid aInterface)

	{

	TAny* ret = NULL;

	if (aInterface.iUid == KMmfUidEmptyBuffersCustomInterface)

		{

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

		ret = static_cast<TAny*>(result);

		}

	else if(aInterface.iUid == KSetVbrFlagCustomInterfaceTypeUid)

		{

		SetVbrFlag();

		}

	if (aInterface == KTimePlayedCustomInterfaceTypeUid)

		{

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

		ret = static_cast<TAny*>(result);

		}

	if (aInterface == KIgnoreUnderflowCustomInterfaceTypeUid)

		{

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

		ret = static_cast<TAny*>(result);

		}

	return ret;

	}

/**

Used to set iVbrFlag on the datapath.

This method is used to set the iVbrFlag in datapath. This flag is added to datapath to avail the 

alternative dataflow wherein datapath makes sure that destinationbuffer is filled to its maximum length

before sending it to the sound driver. Sending the buffer directly to the device causes underflow incase of VBR codecs.

*/		

void CMMFSwCodecPlayDataPath::SetVbrFlag()

	{

	iVbrFlag = ETrue;

	}

TInt CMMFSwCodecPlayDataPath::GetTimePlayed(TTimeIntervalMicroSeconds& aTime)

	{

	if(iSoundDevice.Handle())

		{

		TInt bytes = iSoundDevice.BytesPlayed();

		//Work around for overflow of bytes played from driver.

		//This code will be removed when Base provides the TimePlayed() API which returns the play time

		//Assuming GetTimePlayed() gets called in an interval not more than 3 secs, reset driver's bytes played when it is near KMaxInt

		if(bytes > (KMaxTInt - 3*KMaxBytesInSec))

			{

			iBytesPlayed = iBytesPlayed+bytes;

			iSoundDevice.ResetBytesPlayed();

			bytes = 0;

			}

		TInt64 samplesPlayed = (iBytesPlayed+bytes)/(KBytesPerSample*iChannels);

		aTime = (samplesPlayed*1000000)/iSampleRate;

		}

	else

		{

		aTime = 0;

		}

	return KErrNone;

	}

void CMMFSwCodecPlayDataPath::IgnoreUnderflowEvents()

	{

	iIgnoreUnderflow = ETrue;

	}

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

 *				CDataPathPlayer											*

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

CDataPathPlayer::CDataPathPlayer(CMMFSwCodecPlayDataPath& aParent, TInt aPriority)

: CActive(aPriority), iParent(aParent)

	{

	CActiveScheduler::Add(this);

	}

CDataPathPlayer::~CDataPathPlayer()

	{

	Cancel();

	}

void CDataPathPlayer::Start()

	{

	// No implementation

	}

void CDataPathPlayer::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 CDataPathPlayer::PlayData(const CMMFDataBuffer& aData)

	{

	iDataFromSource = &aData;

	if (!IsActive())

		{

#ifdef _SCW_DEBUG

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

#endif

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

		SetActive();

		}

	}

void CDataPathPlayer::Stop()

	{

	if (!IsActive())	

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

	Cancel();

	iParent.SoundDeviceException(KErrCancel);

	}

void CDataPathPlayer::RunL()

	{

#ifdef _SCW_DEBUG

	RDebug::Print(_L("CDataPathPlayer::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 CDataPathPlayer::RunError(TInt aError)

	{

	Error(aError);

	return KErrNone;

	}

void CDataPathPlayer::DoCancel()

	{

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

		{

		iParent.Device().CancelPlayData();

		iParent.Device().FlushPlayBuffer();

		}

	}

void CDataPathPlayer::Error(TInt aError)

	{ 

	iParent.SoundDeviceException(aError);

	}

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

 *				CSoundDevPlayErrorReceiver											*

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

CSoundDevPlayErrorReceiver::CSoundDevPlayErrorReceiver(CMMFSwCodecPlayDataPath& aParent, TInt aPriority)

: CActive(aPriority), iParent(aParent)

	{

	CActiveScheduler::Add(this);

	}

CSoundDevPlayErrorReceiver::~CSoundDevPlayErrorReceiver()

	{

	Cancel();

	}

void CSoundDevPlayErrorReceiver::Start()

	{

	iParent.Device().NotifyPlayError(iStatus);

	SetActive();

	}

void CSoundDevPlayErrorReceiver::Stop()

	{

	Cancel();

	}

void CSoundDevPlayErrorReceiver::RunL()

	{

	TInt reason = iStatus.Int();

	Start();

	// An error has been returned

#ifdef _SCW_DEBUG

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

#endif

	iParent.SoundDeviceException(reason);

	}

void CSoundDevPlayErrorReceiver::DoCancel()

	{

	iParent.Device().CancelNotifyPlayError();

	}