// 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\mmfswcodecconvertdatapath.cpp

 // 

 //

 #include "mmfSwCodecConvertDataPath.h"

 #include <mmf/server/mmfswcodecwrapper.h>

 #include <mmf/common/mmfpaniccodes.h>

 CMMFSwCodecConvertDataPath* CMMFSwCodecConvertDataPath::NewL()

 	{

 	CMMFSwCodecConvertDataPath* self = new(ELeave) CMMFSwCodecConvertDataPath;

 	CleanupStack::PushL(self);

 	self->ConstructL();

 	CleanupStack::Pop();

 	return self;

 	}

 void CMMFSwCodecConvertDataPath::ConstructL()

 	{

 	iDataPathConverter = new (ELeave) CDataPathConverter(*this,CActive::EPriorityUserInput);

 	}

 CMMFSwCodecConvertDataPath::~CMMFSwCodecConvertDataPath()

 	{	

 	delete iDataPathConverter;

 	if (iCodec)

 		{

 		delete iSourceBuffer;

 		if (!iCodec->IsNullCodec()) 

 			delete iSinkBuffer;

 		}

 	}

 TInt CMMFSwCodecConvertDataPath::SetObserver(MMMFHwDeviceObserver& aObserver)

 	{

 	TInt error;

 	if (iHwDeviceObserver)

 		{

 		error =  KErrAlreadyExists;

 		}

 	else

 		{

 		iHwDeviceObserver = &aObserver;

 		error  = KErrNone;

 		}

 	return error;

 	}

 TInt CMMFSwCodecConvertDataPath::AddCodec(CMMFSwCodec& aCodec)

 	{

 	if (iCodec)

 		return KErrNotSupported; //doesn't support multiple codecs

 	TInt err = KErrNone;

 	iCodec = &aCodec;

 	iSourceBufferSize = iCodec->SourceBufferSize();

 	iSinkBufferSize = iCodec->SinkBufferSize();

 	if ((!iSourceBufferSize)||(!iSinkBufferSize))

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

 	if (err == KErrNone)

 		{

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

 		}

 	if (err == KErrNone)

 		{

 		// Allocate data buffer

 		if (iCodec->IsNullCodec())

 			{//don't need a separate sink buffer if null codec

 			iSinkBuffer = NULL; //sink buffer is the sound device buffer	

 			}

 		else

 			{//need a separate sink buffer for the codec

 			TRAP(err,iSinkBuffer = CMMFDataBuffer::NewL(iSinkBufferSize));

 			}	

 		}

 	return err;

 	}

 TInt CMMFSwCodecConvertDataPath::Start()

 	{

 	TInt startError = KErrNone;

 	if (!iCodec) 

 		{//check that a codec has been added

 		startError = KErrNotReady;

 		}

 	if (!startError)

 		{

 		// Start the player objects

 		iSourceBuffer->SetLastBuffer(EFalse);

 		iDataPathConverter->Start();

 		iState = EPlaying;

 		iNoMoreSourceData = EFalse;

    		}

 	return startError;

 	}

 void CMMFSwCodecConvertDataPath::Stop()

 	{

 	iDataPathConverter->Cancel();

 	iState = EStopped;

 	}

 void CMMFSwCodecConvertDataPath::Pause()

 	{//pause is equivalent to stop for a data transfer

 	iDataPathConverter->Cancel();

 	iState = EStopped;

 	}

 /*** Main play loop ***/

 void CMMFSwCodecConvertDataPath::FillSourceBufferL()

 	{

 	STATIC_CAST(CMMFDataBuffer*, iSourceBuffer)->SetRequestSizeL(iSourceBufferSize);

     // Ask immediately for data from the observer

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

 	}

  /** 

  *  BufferFilledL.  

  *	(from MDataSink)

  * 

  *	called by the CMMFDataPath's MDataSource when it has filled the buffer

  *  @internalComponent

  *	@param aBuffer

  *	

  */

 void CMMFSwCodecConvertDataPath::BufferFilledL(CMMFDataBuffer& aBuffer)

 	{	

 	iSourceBuffer = &aBuffer;

 	iSourceBuffer->SetStatus(EFull);

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

 		//also need to check the sink buffer is available else there is still some

 		//stuff to do before the sink buffer is freed

 		if (iSinkBuffer->Status()==EAvailable)

 			{

 			iNoMoreSourceData = ETrue;

 			}

 		}

 	else

 		{

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

 			iNoMoreSourceData = ETrue;

 		iDataPathConverter->ChangeConvertState(CDataPathConverter::EFillingSinkBuffer);

 		}

 	}

 /* 

  *  FillSinkBufferL

  * 

  *	Function to take the data from an already full source buffer and by using

  *	a codec if necessary fills the sink buffer

  *  @internalComponent

  */

 void CMMFSwCodecConvertDataPath::FillSinkBufferL()

 	{

 	CMMFSwCodec::TCodecProcessResult codecProcessResult;

 	if (iCodec->IsNullCodec())

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

 		iSinkBuffer = iSourceBuffer;

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

 		}	

 	else 

 		{	

 		//pass buffer to codec for processing

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

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

 			iSinkBuffer->SetLastBuffer(ETrue);

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

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

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

 			}

 		//only supports EProcessComplete

 		switch (codecProcessResult.iCodecProcessStatus)

 			{

 		case CMMFSwCodec::TCodecProcessResult::EProcessComplete:

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

 			{

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

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

 			}

 		break;

 		case CMMFSwCodec::TCodecProcessResult::EDstNotFilled:

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

 			{

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

 			iSinkBuffer->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.

 			{

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

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

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

 			}

 		break;

 		default:

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

 			}

 		}

 	iDataPathConverter->ChangeConvertState(CDataPathConverter::EEmptyingSinkBuffer);

 	}

 void CMMFSwCodecConvertDataPath::EmptySinkBufferL()

 	{

 	User::LeaveIfError(iHwDeviceObserver->EmptyThisHwBuffer(*iSinkBuffer));

 	}

 void CMMFSwCodecConvertDataPath::BufferEmptiedL(const CMMFDataBuffer& aBuffer)

 	{

 	if (&aBuffer != iSinkBuffer)

 		User::Leave(KErrArgument);

 	if (!iNoMoreSourceData) 

 		iDataPathConverter->ChangeConvertState(CDataPathConverter::EFillingSourceBuffer);

 	else //no more source data so signal EOF

 		SoundDeviceException(KErrEof);

 	}

 void CMMFSwCodecConvertDataPath::SoundDeviceException(TInt aError)

 	{

 	// Inform the observer of the exception condition

 	iHwDeviceObserver->Error(aError);

 	Stop();

 	// Let the observer know we're fully stopped

     iHwDeviceObserver->Stopped();	

 	}

 RMdaDevSound& CMMFSwCodecConvertDataPath::Device()

 	{

 	return iDummyDevSound;//convert doesn't have a RMdaDevSound

 	}

 /*** End of main play loop ***/

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

  *				CDataPathConverter	

  * This class performs the main data transfer between the source and the sink

  * This is done in a separate class as opposed to CMMFSwCodecConvertDataPath

  * because the class needs to be an active object to avoid recursive call stacks

  * in cases where the source and sink are not active objects - which is

  * the case with descriptors.  Making CMMFSwCodecConvertDataPath derive

  * from CActive is less desirable as it would involve multiple inheretence

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

 CMMFSwCodecConvertDataPath::CDataPathConverter::CDataPathConverter(CMMFSwCodecConvertDataPath& aParent, TInt aPriority)

 : CActive(aPriority), iParent(aParent)

 	{

 	CActiveScheduler::Add(this);

 	iConvertState = EIdle;

 	}

 CMMFSwCodecConvertDataPath::CDataPathConverter::~CDataPathConverter()

 	{

 	Cancel();

 	}

 /** 

  *  Start

  * 

  *	Starts active scheduler 'play' loop

  *  @internalComponent

  */

 void CMMFSwCodecConvertDataPath::CDataPathConverter::Start()

 	{

 	// If we're not already active, complete a request on ourselves to kick off the state machine

 	if (iConvertState == EIdle)

 		iConvertState = EFillingSourceBuffer;

 	if (!IsActive())

 		{

 		TRequestStatus* stat = &iStatus;

 		User::RequestComplete(stat, KErrNone);

 		SetActive();

 		}

 	}

 void CMMFSwCodecConvertDataPath::CDataPathConverter::ChangeConvertState(TConvertState aNewConvertState)

 	{

 	TRequestStatus* stat = &iStatus;

 	//change state

 	iConvertState = aNewConvertState;

 	if (!IsActive())

 		{

 		User::RequestComplete(stat, KErrNone);

 		SetActive();

 		}

 	}

 /*** Main Convert Loop ***/

 void CMMFSwCodecConvertDataPath::CDataPathConverter::FillSourceBufferL()

 	{

 	iParent.FillSourceBufferL();

 	}

 void CMMFSwCodecConvertDataPath::CDataPathConverter::FillSinkBufferL()

 	{

 	iParent.FillSinkBufferL();

 	}

 void CMMFSwCodecConvertDataPath::CDataPathConverter::EmptySinkBufferL()

 	{

 	iParent.EmptySinkBufferL();

 	}

 /*** End of main convert loop ***/

 void CMMFSwCodecConvertDataPath::CDataPathConverter::RunL()

 	{

 	switch (iConvertState)

 		{

 		case EFillingSourceBuffer:

 			FillSourceBufferL();

 			break;

 		case EFillingSinkBuffer:

 			FillSinkBufferL();

 			break;

 		case EEmptyingSinkBuffer:

 			EmptySinkBufferL();

 			break;

 		case EIdle:

 			break;

 		}

 	}

 void CMMFSwCodecConvertDataPath::CDataPathConverter::DoCancel()

 	{

 	//don't need to do anything as we don't have any async requests to other objects

 	}

 TInt CMMFSwCodecConvertDataPath::CDataPathConverter::RunError(TInt aError)

 	{

 	iParent.SoundDeviceException(aError);

 	return KErrNone;

 	}