// Copyright (c) 2002-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\mmfdatapath.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 <mmf/server/mmfdatapath.h>

#include "mmfclientaudiostreamutils.h"

#include <mmf/common/mmfaudio.h>

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

#include <mmf/server/devsoundstandardcustominterfaces.h>

const TUid KUidCodecAudioConfig = {KUidMmfCodecAudioSettings};

void Panic(TMMFDataPathPanicCode aPanicCode, TInt aSourceLineNumber)

	{

	_LIT(KMMFDataPathPanicCategory, "MMFDataPath");

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

	}

//all functions are exported form the DLL and are virtual to allow plugins to define there own CMMFDataPaths

/**

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 CMMFDataPath* CMMFDataPath::NewL(MAsyncEventHandler& aEventHandler)

	{

	CMMFDataPath* self = new(ELeave) CMMFDataPath(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 CMMFDataPath* CMMFDataPath::NewL(TMediaId aMediaId, MAsyncEventHandler& aEventHandler)

	{

	CMMFDataPath* self = new(ELeave) CMMFDataPath(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 CMMFDataPath* CMMFDataPath::NewL(TUid aCodecUid, MAsyncEventHandler& aEventHandler)

	{

	CMMFDataPath* self = new(ELeave) CMMFDataPath(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 CMMFDataPath* CMMFDataPath::NewL(TUid aCodecUid, TMediaId aMediaId, MAsyncEventHandler& aEventHandler)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aCodecUid);

	CleanupStack::Pop();

	return self;

	}

/**

Standard destructor.

*/

EXPORT_C CMMFDataPath::~CMMFDataPath()

	{

	Cancel();

	delete iCodec;

 	DoCleanupBuffers();

	//log off the source and sink

	if (iDataSource)

		iDataSource->SourceThreadLogoff();

	if (iDataSink)

		iDataSink->SinkThreadLogoff();

	if (iCompleteCallback)

		{

		iCompleteCallback->Cancel();

		delete iCompleteCallback;

		}

	}

/**

Deletes buffers if this datapath's sources and sinks own the buffers returned by PrimeL().

Typically if buffers are created asychronously, the datapath doesn't own the buffer

so leaves cleanup handling to the owner sources/sinks.

Called when source and sink needs to be de-referenced. Sets iDataPathCreated, iSinkCanReceive, 

iSnkBufRef and iSrcBufRef to EFalse; sets iState to EStopped.

*/

EXPORT_C void CMMFDataPath::ResetL()

	{

	delete iCodec;

	iCodec = NULL;

	DoCleanupBuffers(); // Delete buffers

	//logoff and dereference source and sink

	if (iDataSource)

		{ iDataSource->SourceThreadLogoff(); iDataSource = NULL; }

	if (iDataSink)

		{ iDataSink->SinkThreadLogoff(); iDataSink = NULL; }

	// Reset states

	iDataPathCreated = EFalse;

	iState = EStopped;

	iSrcBufRef = EFalse;

	iSnkBufRef = EFalse;

	iPauseCalled = EFalse;

	delete iCompleteCallback; iCompleteCallback = NULL;

	}

/**

Delete source and/or sink buffers that are owned by DataPath.

Ownership indicated by iSrcBufRef and iSnkBufRef.

Ownership is assigned during buffer allocation within the datapath PrimeL().

*/

void CMMFDataPath::DoCleanupBuffers()

	{

	// delete source and/or sink buffer that is owned by DataPath

	if ( !iSrcBufRef && iSourceBuffer )

		{

		delete iSourceBuffer;

		}

	iSourceBuffer = NULL;

	if ( !iSnkBufRef && iSinkBuffer )

		{

		delete iSinkBuffer;

		}

	iSinkBuffer = NULL;

	}

/**

Obtain source and/or sink buffer using the synchronous API CreateSourceBufferL() and CreateSinkBufferL().

*/

void CMMFDataPath::ObtainSyncBuffersL()

	{

	//Try to create source and sink buffers. If we can't create them synchronously via

	//CreateSourceBufferL and CreateSinkBufferL we will need to obtain them by 

	//asynchronous buffer creation when playing starts.

	if (iBuffersToUse & ENeedSourceBuffer)

		{

		if (!iSourceBuffer) //we may already have a buffer from a previous initialization

			{

			TRAPD(err, iSourceBuffer = iDataSource->CreateSourceBufferL(iMediaId,*iSinkBuffer, iSrcBufRef));

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

				{

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP::ObtainSyncBuffersL - Leaving %d  (this 0x%x)\n"),err, this);

#endif

				User::Leave(err);

				}

			}

		}

	if (iBuffersToUse & ENeedSinkBuffer)

		{

		if (!iSinkBuffer) //we may already have a buffer from a previous initialization

			{

			TRAPD(err, iSinkBuffer = iDataSink->CreateSinkBufferL(iMediaId, iSnkBufRef));

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

				{

#ifdef _DP_DEBUG

	RDebug::Print(_L("DP::ObtainSyncBuffersL - Leaving %d  (this 0x%x)\n"),err, this);

#endif

				User::Leave(err);

				}

			}

		}

	if (iSourceBuffer && !(iBuffersToUse & ENeedSinkBuffer))

		{//only need one buffer, use source

		iSinkBuffer =iSourceBuffer;

		iSnkBufRef = ETrue; //the sink buffer is not to be deleted

		}

	else if (iSinkBuffer && !(iBuffersToUse & ENeedSourceBuffer))

		{//only need one buffer, use sink

		iSourceBuffer =iSinkBuffer;

		iSrcBufRef = ETrue; //the sink buffer is not to be deleted

		}	

#ifdef _DP_DEBUG

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

#endif

	}

/**

Constructs a source.

The default implementation leaves with KErrNotSupported.

@param  aInitData

        The initialisation data.

*/

EXPORT_C void CMMFDataPath::ConstructSourceL( const TDesC8& /*aInitData*/ )

	{

	User::Leave(KErrNotSupported);

	}

/**

Constructs a sink.

Overridable constuction specific to this datasource.

The default implementation leaves with KErrNotSupported.

@param  aInitData

        The initialisation data.

*/

EXPORT_C void CMMFDataPath::ConstructSinkL( const TDesC8& /*aInitData*/ )

	{

	User::Leave(KErrNotSupported);

	}

/**

Takes UID of codec on construction, and if not an NULL codec sets the datapath up for codec instantiation.

@param  aCodecUid

        The UID of the codec.

*/

EXPORT_C void CMMFDataPath::ConstructL(TUid aCodecUid)

	{

	iUseSuppliedCodecUid = EFalse; //initially assume no supplied codec uid

	if (aCodecUid != KNullUid)

		{//the data path NewL has specified a specific codec

		//create CMMFCodec here

		iCodec = CMMFCodec::NewL(aCodecUid);

		if (iCodec)

			iUseSuppliedCodecUid = ETrue;

		}

	iSrcBufRef = EFalse;

	iSnkBufRef = EFalse;

	iObtainingAsyncSourceBuffer = EFalse;

	iObtainingAsyncSinkBuffer = EFalse;

	iSourceBufferWithSource = EFalse;

	iSinkBufferWithSink = EFalse;

	}

/** 

Adds a data source to the datapath and, if the sink already exists, tries to establish a connection

between the source and sink.

@param  aSource

        The data source to add to the data path.

*/

EXPORT_C void CMMFDataPath::AddDataSourceL(MDataSource* aSource)

	{

	if (!iDataSink) iDataSource=aSource; //can't create a data path without the MDataSink as well

	else if (!iUseSuppliedCodecUid) //no supplied uid need to see if we can create codec to establish a data path

		{//we have a data sink as well so check a data path can be established between source&sink

		CreateDataPathL(aSource, iDataSink);

		iDataSource = aSource;

		}

	else //the CMMFController specified the codec uid so must use existing codec

		{//note we are assuming here that the CMMFController knows what it is doing ie the supplied codec uid 

		//can make the appropriate data conversion

		iDataPathCreated = ETrue;

		iDataSource = aSource;

		}

	ClearPlayWindowL() ;

	User::LeaveIfError(iDataSource->SourceThreadLogon(*this));

	}

/** 

Adds a data sink to the datapath and, if the source already exists, tries to establish a connection

between the source and sink.

@param  aSink

        The data sink to add to the data path.

*/

EXPORT_C void CMMFDataPath::AddDataSinkL(MDataSink* aSink)

	{

	if (!iDataSource) iDataSink=aSink; //can't create a data path without the MDataSource as well

	else if (!iUseSuppliedCodecUid) //no supplied uid need to see if we can create codec to establish a data path

		{//we have a data source as well so check a media path can be established between source&sink

		CreateDataPathL(iDataSource, aSink);

		iDataSink = aSink;

		}

	else //the CMMFController specified the codec uid so must use existing codec

		{//note we are assuming here that the CMMFController knows what it is doing ie the supplied codec uid 

		//can make the appropriate data conversion

		iDataPathCreated = ETrue;

		iDataSink = aSink;	

		//set 4CCs

		iSourceFourCC  = iDataSink->SinkDataTypeCode(iMediaId);//sink because CMMFDataPath is an MDataSink to its MDataSource!

		iSinkFourCC = iDataSource->SourceDataTypeCode(iMediaId);//source because CMMFDataPath is an MDataSource to its MDataSink!

		}

	User::LeaveIfError(iDataSink->SinkThreadLogon(*this));

	}

/* 

 *  CreateDataPathL 

 * 

 *  internal function to establish a datapath between the source and sink

 *	the data supplied by the sink adn expected by the source are checked and 

 *	a codec is instantiated if necessary

 *

 *	@param	aSource

 *	@param	aSink

 */

void CMMFDataPath::CreateDataPathL(MDataSource* aSource, MDataSink* aSink)

	{ //procedure to attempt to match the source to the sink creating a codec if necessary

	// returns ETrue if the datapath could be constructed else false

	//sets iCodec to the appropriate codec.& sets its own iSink/iSource FourCC datatype codes

	iDataPathCreated = EFalse;

	if (aSource && aSink) //have a source and sink

		{ //we have a data source & sink but no codec so try and find one - if required

		TFourCC sourceFourCCCode = aSource->SourceDataTypeCode(iMediaId); //get MDataSource data type fourCC code

		TFourCC sinkFourCCCode = aSink->SinkDataTypeCode(iMediaId); //get MDataSink data type fourCC code

		if ((sourceFourCCCode != sinkFourCCCode) && //MDataSource & MDataSink datatypes are not compatible

			(sourceFourCCCode != KMMFFourCCCodeNULL) && (sinkFourCCCode != KMMFFourCCCodeNULL)) 

			{//we need a codec to make the conversion between the source and the sink

			CMMFCodec* codec = CMMFCodec::NewL(sourceFourCCCode, sinkFourCCCode);

			if (codec)

				{

				delete iCodec;

				iCodec = codec;

				//data path created ie have source/sink and can match their datatypes

				iDataPathCreated = ETrue;

				//now we have an source attached we need to configure the codec for sample rate

				//and number of channels

				//prepare a package to send to a codec

				TMMFAudioConfig audioSettings;

				//test for decoder

				if (aSource->DataSourceType() == KUidMmfFormatDecode)

					{

					audioSettings.iSampleRate = static_cast<CMMFFormatDecode*>(aSource)->SampleRate();

					audioSettings.iChannels = static_cast<CMMFFormatDecode*>(aSource)->NumChannels();

					}

				//package up to send to codec

				TPckgBuf<TMMFAudioConfig> configPackage(audioSettings);

				//we need to catch User::Leave(KErrNotSupported) as by default most codecs

				//do not support the ConfigureL method.

				TRAPD(err,iCodec->ConfigureL(KUidCodecAudioConfig, configPackage));

				// need to check other error here

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

					{

					User::Leave(err);

					}

				}

			else

				{

				User::Leave( KErrNotSupported ) ; //couldn't find suitable codec

				}

			} //if (sourceFourCCCode != sinkFourCCCode)

		else 

			{ //source & sink fourCC datatypes are the same so no codec is required

			__ASSERT_DEBUG(iCodec == NULL,  Panic(EMMFDataPathPanicProgrammingError,__LINE__)); 			

			iDataPathCreated = ETrue;

			}

		//can assign FourCC codes for the CMMFDataPath

		iSinkFourCC = sourceFourCCCode; //sink because CMMFDataPath is an MDataSink to its MDataSource!

		iSourceFourCC = sinkFourCCCode; //source because CMMFDataPath is an MDataSource to its MDataSink!

		//If sink & source need its own Prime() done in controller	

		} 

	}

/**

Clears the specified buffer.

Pure virtual dummy implementation, not needed by datapath

comes from MDataSink - CMMFData path is a sink to its MDataSource.

This is only required for an active push MDataSource requesting a buffer empty.

@param  aBuffer

        The buffer to empty.

@param  aSupplier

        The MDataSource supplying this buffer.

@param  aMediaId

        An optional mediaID parameter when there are multiple buffers arriving of different media types.

*/

EXPORT_C void CMMFDataPath::EmptyBufferL(CMMFBuffer* /* aBuffer */, MDataSource* /*aSupplier*/, TMediaId /*aMediaId*/)

	{

	//not implemented

	}

/* 

 *  FillSourceBufferL

 * 

 *	Function to get data from the datapath's iDataSource

 */

void CMMFDataPath::FillSourceBufferL()

	{

#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), 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

	}

/** 

Indicates the data source has filled the specified buffer.