// Copyright (c) 2008-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\mmfdatapath2.cpp

// 

//

#include <e32math.h>

#include <mmf/common/mmffourcc.h>

#include <mmf/common/mmfpaniccodes.h>

#include <mmf/server/mmfaudiooutput.h>

#include <mmf/server/mmfaudioinput.h>

#include "mmfdatapath2.h"

#include "mmfclientaudiostreamutils.h"

#include <mmf/common/mmfaudio.h>

#include <mmf/plugin/mmfcodecimplementationuids.hrh> // KUidMmfCodecAudioSettings

#include <mmf/server/devsoundstandardcustominterfaces.h>

#include <mmf/server/mmffile.h>

#include <mda/client/resource.h>

static void Panic(TMMFDataPathPanicCode aPanicCode, TInt aSourceLineNumber)

	{

	_LIT(KMMFDataPathPanicCategory, "MMFDataPath2");

	User::Panic(KMMFDataPathPanicCategory, STATIC_CAST(TInt,aPanicCode) + aSourceLineNumber);

	}

/**

Allocates and constructs a data path.

Use this function if the codec UID is not already known by CMMFController

and there is no data path ambiguity - ie only one data path is possible.

Will create codec via fourCC.

@param  aEventHandler

        Installs an event handler to provide message passing between clients and sources/sinks.

@return Newly constructed data path object.

*/

EXPORT_C CMMFDataPath2* CMMFDataPath2::NewL(MAsyncEventHandler& aEventHandler)

	{

	CMMFDataPath2* self = new(ELeave) CMMFDataPath2(TMediaId(), aEventHandler);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

Allocates and constructs a data path according to the specified media ID.

Use this function if the codec UID is not already known by CMMFController

and there is ambiguity with the data path ie. there is more than one possible data path.

@param  aMediaId

        Optional media ID parameter when there are multiple media types.

@param  aEventHandler

        Installs an event handler to provide message passing between clients and sources/sinks.

@return A newly constructed data path object.

*/

EXPORT_C CMMFDataPath2* CMMFDataPath2::NewL(TMediaId aMediaId, MAsyncEventHandler& aEventHandler)

	{

	CMMFDataPath2* self = new(ELeave) CMMFDataPath2(aMediaId, aEventHandler);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

/**

Allocates and constructs a data path according to the specified codec UID.

Use this function if the codec UID is already known by CMMFController

and there is no data path ambiguity ie. only one data path is possible

will create codec explicitly using the supplied codec Uid

@param  aCodecUid

        Optional mediaID parameter when there are multiple media types

@param  aEventHandler

        Installs an event handler to provide message passing between clients and sources/sinks.

@return A newly constructed data path object.

*/

EXPORT_C CMMFDataPath2* CMMFDataPath2::NewL(TUid aCodecUid, MAsyncEventHandler& aEventHandler)

	{

	CMMFDataPath2* self = new(ELeave) CMMFDataPath2(TMediaId(), aEventHandler);

	CleanupStack::PushL(self);

	self->ConstructL(aCodecUid);

	CleanupStack::Pop();

	return self;

	}

/**

Allocates and constructs a data path according to the specified codec UID.

Use this function if the codec UID is already known by CMMFController

and there is ambiguity ie. more than one possible data path.

TMediaId used to select the path.

@param  aCodecUid

		The codec UID.

@param  aMediaId

        Optional mediaID parameter when there are multiple media types.

@param  aEventHandler

        Installs an event handler to provide message passing between clients and sources/sinks.

@return A newly constructed data path object.

*/

EXPORT_C CMMFDataPath2* CMMFDataPath2::NewL(TUid aCodecUid, TMediaId aMediaId, MAsyncEventHandler& aEventHandler)

	{

	CMMFDataPath2* self = new(ELeave) CMMFDataPath2(aMediaId, aEventHandler);

	CleanupStack::PushL(self);

	self->ConstructL(aCodecUid);

	CleanupStack::Pop();

	return self;

	}

CMMFDataPath2::CMMFDataPath2(TMediaId aMediaId, MAsyncEventHandler& aEventHandler) 

	: CMMFDataPath(aMediaId, aEventHandler), iTimeLeftToPlayComplete(-1)

	{

	}

void CMMFDataPath2::ConstructL(TUid aCodecUid)

	{

	CMMFDataPath::ConstructL(aCodecUid);

	iRepeatTrailingSilenceTimer = CPeriodic::NewL(CActive::EPriorityStandard); 

	}

/**

Standard destructor.

*/

CMMFDataPath2::~CMMFDataPath2()

	{

	if(iRepeatTrailingSilenceTimer)

		{

		iRepeatTrailingSilenceTimer->Cancel();

		delete iRepeatTrailingSilenceTimer;

		}

	}

TInt CMMFDataPath2::RepeatTrailingSilenceTimerComplete(TAny* aDataPath)

	{

	CMMFDataPath2* dataPath = static_cast<CMMFDataPath2*>(aDataPath);

	TRAPD(err, dataPath->DoRepeatTrailingSilenceTimerCompleteL());

	if (err != KErrNone)

		{

		dataPath->DoSendEventToClient(KMMFEventCategoryPlaybackComplete, err);

		}	

	return KErrNone;

	}

TInt CMMFDataPath2::DoRepeatTrailingSilenceTimerCompleteL()

	{

	//cancel this periodic timer

	iRepeatTrailingSilenceTimer->Cancel();

	if(iTimeLeftToPlayComplete.Int64()>0)

		{

		iTimeLeftToPlayComplete=0;

		}

	if (iTrailingSilenceLeftToPlay.Int64() > 0)

		{

		PlaySilence();

		}

	else

		{

		SetPositionL(iPlayWindowStartPosition);

		iTimeLeftToPlayComplete=-1;

		FillSourceBufferL();		

		}

	return KErrNone;

	}

void CMMFDataPath2::PlaySilence()

	{		

	// iRepeatTrailingSilenceTimer->After() takes a TTimeIntervalMicroSeconds32

	// so for longer periods of silence call it repeatedly with KMaxTInt lengths

	TTimeIntervalMicroSeconds32 silence;

	if(iTimeLeftToPlayComplete.Int64() > 0)

		{

		silence = I64INT(iTimeLeftToPlayComplete.Int64());

		}

	else if (iTrailingSilenceLeftToPlay.Int64() > KMaxTInt)

		{

		silence = KMaxTInt;

		iTrailingSilenceLeftToPlay = iTrailingSilenceLeftToPlay.Int64() - KMaxTInt;

		}

	else

		{

		silence = I64INT(iTrailingSilenceLeftToPlay.Int64());

		iTrailingSilenceLeftToPlay = 0;

		}

	iRepeatTrailingSilenceTimer->Start(silence, silence , TCallBack(RepeatTrailingSilenceTimerComplete, this));

	}

/* 

 *  FillSourceBufferL

 * 

 *	Function to get data from the datapath's iDataSource

 */

void CMMFDataPath2::DoFillSourceBufferL()

	{

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP::FillSourceBufferL tick-%d   (this 0x%x)\n"),User::TickCount(),this);

#endif

	__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording || (iState == EPrimed && iPauseCalled && iIsUsingResumeSupport)), Panic(EMMFDataPathPanicBadState,__LINE__)); 

	// clear the no-more-source flag here (as well as in PlayL()) because 

	// there may have been a re-position since the last call to BufferFilledL()

	iNoMoreSourceData = EFalse;

	if(!iObtainingAsyncSourceBuffer) 

		{//this is a normal request for data. 

		//If we are getting asynchronous buffers, then can't do this as iSourceBuffer == NULL

		iSourceBuffer->SetFrameNumber(++iCurrentSourceFrameNumber); //so source knows which data to load buffer with

		iSourceBuffer->SetStatus(EBeingFilled);

		iSourceBuffer->SetLastBuffer(EFalse);

		}

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP asking for buffer %d  - ptr=0x%x   (this 0x%x)\n"), iCurrentSourceFrameNumber, iSourceBuffer,this);	

#endif

	iSourceBufferWithSource = ETrue;

	// wait for BufferFilled callback from source. Do this here as some sources cause

	//re-entrancy into data path via BufferFilledL

	ChangeDataPathTransferState(EWaitSource);  

	iDataSource->FillBufferL(iSourceBuffer, this, iMediaId);

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP::FillSourceBufferL - DONE tick-%d   (this 0x%x)\n"),User::TickCount(),this);

#endif

	}

/**

Runs the clip depending on the current data path and transfer state.

For example, fills the sink buffer if TDataPathState is EPlaying and TTransferState is ENeedSinkData.

*/

void CMMFDataPath2::RunL()

	{

#ifdef _DP_DEBUG 

	RDebug::Print(_L("DP::RunL transfer state %d, iPausedCalled %d, tick-%d   (this 0x%x)\n"),iTransferState, iPauseCalled, User::TickCount(),this);

#endif

	switch (iState)

		{

	case EStopped:

		break;

	case EPrimed: // In the paused state we still continue to feed buffers to the sink. The sink (DevSound) handles the logic of whether the buffers should be emptied

	    {

	    if (!iPauseCalled || !iIsUsingResumeSupport)

	        break;

	    }	    

	    // fall-through

	case EPlaying:

	case ERecording:

	case EConverting:

		switch (iTransferState)

			{

		case EWaitSink:

		case EWaitSource:

			break;

		case EInitializeSink:

			InitializeSinkL();

			break;

		case EInitializeSource:

			InitializeSourceL();

			break;

		case ENeedSourceData:

			FillSourceBufferL();

			break;

		case ENeedSinkData:

			FillSinkBufferL();

			break;

		case ENeedToMatchSourceToSink:

			FillSinkBufferL();

			break;

		case ESendDataToSink:

			EmptySinkBufferL();

			break;

		case EEndOfData:

			EndOfData();

			break;

			}

		break;

	default:

		break;

		}

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP::RunL DONE\n"));

#endif

	}

/* 

 *  FillSourceBufferL

 * 

 *	Function to get data from the datapath's iDataSource

 */

void CMMFDataPath2::FillSourceBufferL()

	{

	__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording || (iState == EPrimed && iPauseCalled && iIsUsingResumeSupport) ), Panic(EMMFDataPathPanicBadState,__LINE__)); 

	//if the silence timer is active then dont propagate the request

	if(iRepeatTrailingSilenceTimer->IsActive())

		{

		return;

		}

	//play the silence period and dont propagate the request

	if(iTrailingSilenceLeftToPlay>0 || iVerifyPlayComplete)

		{

		if(iVerifyPlayComplete)//case when the trailing silence is zero

			{

			if (!*iDisableAutoIntent && iDrmSource)

				{

				CMMFFile* file = static_cast<CMMFFile*>(iDrmSource);

				TInt err = file->ExecuteIntent(ContentAccess::EPlay);

				if (err != KErrNone)

					{

					DoSendEventToClient(KMMFEventCategoryPlaybackComplete, err);

					return;

					}

				}

			//Retrieve the current play time and add "duration-currentplaytime" to the silence period

			//This is to ensure that silence timer is not started before the previous play is actually completed by the devsound

			TTimeIntervalMicroSeconds currentTime = CalculateAudioOutputPosition();

			if(currentTime.Int64()>iPlayWindowStartPosition.Int64())

				{

				iTimeLeftToPlayComplete = iPlayWindowEndPosition.Int64()-currentTime.Int64();

				}

			else

				{

				iTimeLeftToPlayComplete = 0;

				}

			iVerifyPlayComplete = EFalse;

			}

		if(iTrailingSilenceLeftToPlay==0 && iTimeLeftToPlayComplete==0)

			{

			SetPositionL(iPlayWindowStartPosition);

			iTimeLeftToPlayComplete=-1;

			}

		else

			{

			PlaySilence();

			return;

			}

		}

	DoFillSourceBufferL();

	}

/** 

Indicates the data source has filled the specified buffer.

Called by the CMMFDataPath2's MDataSource when it has filled the buffer.

@param aBuffer

       A pointer to the filled buffer.

*/

void CMMFDataPath2::BufferFilledL(CMMFBuffer* aBuffer)

	{	

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP::BufferFilledL src has filled buffer %d (ptr=0x%x) with %d bytes EoF = %d  tick-%d    (this 0x%x)\n"),aBuffer->FrameNumber(),aBuffer, aBuffer->BufferSize(),aBuffer->LastBuffer(), User::TickCount(),this);

#endif

	TBool isInTruePause = (iState == EPrimed  && iPauseCalled && iIsUsingResumeSupport);

	//state only used if we are passing data

	__ASSERT_DEBUG((iState == EPlaying || iState == EConverting || iState == ERecording || isInTruePause), Panic(EMMFDataPathPanicBadState,__LINE__));

	__ASSERT_DEBUG((!iNoMoreSourceData), Panic(EMMFDataPathPanicBadState,__LINE__)); 

	//if we have been asked to repeat and this is the last buffer, reset last buffer flag and send to the device

	if(aBuffer!= NULL && aBuffer->LastBuffer())

		{

		iNumberOfTimesPlayed++;

		if ((iNumberOfTimesPlayed <= iNumberOfTimesToRepeat) || iNumberOfTimesToRepeat == KMdaRepeatForever)

			{

			aBuffer->SetLastBuffer(EFalse);

			//this will trigger the trailing silence timer next time a buffer is requested.

			iTrailingSilenceLeftToPlay = iTrailingSilence;

			iVerifyPlayComplete = ETrue;

			}

		}		

	iSourceBufferWithSource = EFalse;

	//Has the datapath stopped running, if so were not interested in any callbacks.

	if(iState == EStopped || (iState == EPrimed  && !isInTruePause))

		{

#ifdef _DP_DEBUG

		RDebug::Print(_L("DP::BufferFilledL called while not expecting callback iState=%d  iPauseCalled=%d  (this 0x%x)\n"),iState, iPauseCalled,this);

#endif

		return;

		}

#ifdef REPOSITION_SPEEDUP

	// if the source has been re-positioned, then go & get some more source data now

	if (!iObtainingAsyncSourceBuffer && iSourceBuffer->FrameNumber() != iCurrentSourceFrameNumber)

		{

#ifdef _DP_DEBUG

		RDebug::Print(_L("DP::BufferFilledL source was re-positioned re-requesting source data (this 0x%x)\n"),this);

#endif

		ChangeDataPathTransferState(ENeedSourceData);

		return;

		}

#endif //REPOSITION_SPEEDUP

	//bufer is NULL, indicating no more source data.

	if (!aBuffer)

		{

		//If we only hold a reference to the source buffer, set that to NULL

		if(iSnkBufRef)

			{

			iSourceBuffer = NULL;

			}

		iNoMoreSourceData = ETrue;

		if(!iCodec || //there's only one buffer and that has been returned as NULL, so must be end of data

		  iSinkBufferWithSink) //buffer is with sink, we don't have any more data to put in it, so must be end of data

			{

			ChangeDataPathTransferState(EEndOfData);

			}

		else //sink buffer is with datapath, see if there is anything to send to sink

			{

			ChangeDataPathTransferState(ENeedToMatchSourceToSink);

			}

#ifdef _DP_DEBUG

		RDebug::Print(_L("DP::BufferFilledL DONE aBuffer==NULL tick-%d (this 0x%x)\n"),User::TickCount(),this);

#endif

		return;

		} 

	//We were waiting for a response from the source to get an asynchronous buffer.

	//We now have it, and we proceed to transfer this data to the sink.

	if	(iObtainingAsyncSourceBuffer)

		{

		iObtainingAsyncSourceBuffer = EFalse;

		}

	aBuffer->SetStatus(EFull);

	if(iSourceBuffer != aBuffer)

		{//buffer has been changed by the source

		iSourceBuffer = aBuffer;

		if (!(iBuffersToUse & ENeedSinkBuffer))

			{//we only need one buffer and use source

			iSinkBuffer = iSourceBuffer;

			iSnkBufRef = ETrue;

			}

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP::BufferFilledL - iSourceBuffer=0x%x ref=%d   iSinkBuffer=0x%x ref=%d (this 0x%x)\n"),iSourceBuffer,iSrcBufRef,iSinkBuffer,iSnkBufRef, this);

#endif	

		}

	//Is this the last buffer from the source (0 length or LastBuffer flag set)

	//or have reached the end of the play window; we only look at the play window here

	//if we are converting. For conversion we look at the data we have read. This is then passed onto 

	//the source

	if (!iSourceBuffer->BufferSize() || iSourceBuffer->LastBuffer() ||

		(((iState == EConverting) || (iState == EPlaying)) && (iPlayWindowEndPosition < iCachedSourceDuration) && ( InputPosition() >= iPlayWindowEndPosition ))) 

		{

		iNumberOfTimesPlayed++;

		if ((iNumberOfTimesPlayed <= iNumberOfTimesToRepeat) || iNumberOfTimesToRepeat == KMdaRepeatForever)

			{

			iSourceBuffer->SetLastBuffer(EFalse);

			//this will trigger the trailing silence timer next time a buffer is requested.

			iTrailingSilenceLeftToPlay = iTrailingSilence;

			iVerifyPlayComplete = ETrue;

			}

		else

			{		

	#ifdef _DP_DEBUG

			RDebug::Print(_L("DP::BufferFilledL end of input data  tick-%d   (this 0x%x)\n"),User::TickCount(),this);

			RDebug::Print(_L("iSourceBuffer->BufferSize()=%d\n"),iSourceBuffer->BufferSize());

			RDebug::Print(_L("iSourceBuffer->LastBuffer()=%d\n"),iSourceBuffer->LastBuffer());

			RDebug::Print(_L("InputPosition()=%d  >= iPlayWindowEndPosition=%d\n"),I64INT(InputPosition().Int64()),I64INT(iPlayWindowEndPosition.Int64()));

	#endif

			iNoMoreSourceData = ETrue;

			iSourceBuffer->SetLastBuffer(ETrue); //just in-case we are terminating on BufferSize == 0 or play window

			}

		}

	if (!iCodec)

		{

		ChangeDataPathTransferState(ESendDataToSink);

		}

	else if(!iSinkBufferWithSink) //sink buffer is with data path, can try to fill it

		{

		ChangeDataPathTransferState(ENeedToMatchSourceToSink);	

		}

	//else wait for sink to return buffer BufferEmptied will send us into ENeedToMatchSourceToSink state

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP::BufferFilledL - DONE tick-%d   (this 0x%x)\n"),User::TickCount(),this);

#endif

	}