/*

* Copyright (c) 2009 Aricent and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

* Aricent - initial contribution.

*

* Contributors:

*

* Description:

* Implementation of  Base process engine

*

*/

#include "ariprocessengine.h"

#include <e32def.h>

//---------------------------------------------------------------------------

//  Default constructor

//----------------------------------------------------------------------------

//

CBaseProcessEngine::CBaseProcessEngine ()

						: CActive( CActive::EPriorityStandard )

	{

	PRINT_ENTRY;

	iState = EStop;

	iCurInputBuf = NULL;

	iCurOutputBuf = NULL;

	iCmdArray.SetOffset( _FOFF( CCmdPckg,iPriorityLink ) );

	iProcEngineObserver = NULL;

	iCodec = NULL;

	iCurInputBuf = NULL;

	iCurOutputBuf = NULL;

	iCurCmd = NULL;

	iIsProcessing = EFalse;

	iInputBufsAddedSoFar = 0;

	iOutputBufsAddedSoFar = 0;

	iOutputBufferReadyCallBackPending =	EFalse;

	CActiveScheduler::Add( this );

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

//   2 - phase construtor of CBaseEngine

//----------------------------------------------------------------------------

//

EXPORT_C CBaseEngine* CBaseEngine::NewL ( MProcessEngineObserver* aObserver,

		MBaseCodec* aCodec,

		TBool aInPlaceProcessing,

		TBool aProcessingAutomatic )

	{

	PRINT_ENTRY;

	PRINT_EXIT;

	return CBaseProcessEngine::NewL ( aObserver, aCodec, aInPlaceProcessing,

									aProcessingAutomatic );

	}

//---------------------------------------------------------------------------

//   2 - phase construtor of CBaseProcessEngine

//----------------------------------------------------------------------------

//

CBaseProcessEngine* CBaseProcessEngine::NewL (

		MProcessEngineObserver* aObserver,

		MBaseCodec* aCodec,

		TBool aInPlaceProcessing,

		TBool aProcessingAutomatic )

	{

	PRINT_ENTRY;

	CBaseProcessEngine* uSelf = new ( ELeave ) CBaseProcessEngine;

	CleanupStack::PushL( uSelf );

	uSelf->ConstructL( aObserver, aCodec, aInPlaceProcessing,

			aProcessingAutomatic);

	CleanupStack::Pop();

	PRINT_EXIT;

	return uSelf;

	}

//---------------------------------------------------------------------------

//  Destructor

//-----------------------------------------------------------------------------

//

CBaseProcessEngine::~CBaseProcessEngine ()

	{

	PRINT_ENTRY;

	Cancel();

	//Flushes out all buffers.

	Reset();

	iInputArray.Close();

	iOutputArray.Close();

	iCmdArray.Reset();

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

// Second phase constructor

//----------------------------------------------------------------------------

//

void CBaseProcessEngine::ConstructL ( MProcessEngineObserver* aObserver,

		MBaseCodec* aCodec,

		TBool aInPlaceProcessing,

		TBool aProcessingAutomatic )

	{

	PRINT_ENTRY;

	iProcEngineObserver = aObserver;

	iCodec = aCodec;

	iInPlaceProc = aInPlaceProcessing;

	iAutomaticProc = aProcessingAutomatic;

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

// Starts the engine

//----------------------------------------------------------------------------

//

TInt CBaseProcessEngine::Start ()

	{

	PRINT_ENTRY;

	iState = EStart;

	IssueRequest();

	return KErrNone;

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

//  Stops the engine

//----------------------------------------------------------------------------

//

TInt CBaseProcessEngine::Stop ()

	{

	PRINT_ENTRY;

	Cancel();

	iState = EStop;

	PRINT_EXIT;

	return KErrNone;

	}

//---------------------------------------------------------------------------

//  Adds an input buffer to the input q

//----------------------------------------------------------------------------

//

TInt CBaseProcessEngine::AddInput ( TAny* aInput )

	{

	PRINT_ENTRY;

	if( !aInput )

		{

		return KErrArgument;

		}

	TInt lError = KErrNone;

	lError = iInputArray.Append( aInput );

	if ( lError )

		{

		return lError;

		}

	iInputBufsAddedSoFar++;

	if( iAutomaticProc ) // true

		{

		CCmdPckg* lCmd = NULL;

		TRAP( lError,lCmd = new ( ELeave ) CCmdPckg( CCmdPckg::EDoProcess,

				ENormalPriority ) );

		if( lError )

			{

			return lError;

			}

		iCmdArray.Add( *lCmd );

		}

	// RunL should be scheduled in Start state. Also, if it is already

	// processing i.e iIsProcessing is ETrue,RunL should not be scheduled

	if ( ( iState == EStart ) && !iIsProcessing )

		{

		IssueRequest();

		}

	PRINT_EXIT;

	return KErrNone;

	}

//---------------------------------------------------------------------------

//  Adds a buffer to the output q

//----------------------------------------------------------------------------

//

TInt CBaseProcessEngine::AddOutput ( TAny* aOutput )

	{

	PRINT_ENTRY;

	if( !aOutput )

		{

		return KErrArgument;

		}

	else if( iInPlaceProc )

		{

		return KErrNotSupported;

		}

	TInt lError = KErrNone;

	lError = iOutputArray.Append( aOutput );

	if ( lError )

		{

		return lError;

		}

	iOutputBufsAddedSoFar++;

	// RunL should be scheduled in Start state. Also, if it is already

	// processing i.e iIsProcessing is ETrue,RunL should not be scheduled

	if ( ( iState == EStart ) && !iIsProcessing )

		{

		IssueRequest();

		}

	PRINT_EXIT;

	return KErrNone;

	}

//---------------------------------------------------------------------------

//  Resets the processing engine and flushes all the pending input

//  and output buffers.Calls InputBufferConsumed and OutputBufferReady

//  to give pending input & output buffers with aError = KErrCancel.

//----------------------------------------------------------------------------

//

void CBaseProcessEngine::Reset ()

	{

	PRINT_ENTRY;

	Stop();

	iCodec->Reset();

	iIsProcessing	=	EFalse;

	if ( iCurInputBuf )

		{

		TAny* lTempBuf	= iCurInputBuf;

		iCurInputBuf	= NULL;

		delete iCurCmd;

		iCurCmd = NULL;

		iProcEngineObserver->InputBufferConsumed( lTempBuf, KErrCancel );

		}

	while ( iInputArray.Count() )

		{

		TAny* lTempBuf	= iInputArray[0];

		iInputArray.Remove( 0 );

		delete iCurCmd;

		iCurCmd = NULL;

		iProcEngineObserver->InputBufferConsumed( lTempBuf, KErrCancel );

		}

	if ( iCurOutputBuf )

		{

		TAny* lTempBuf	= iCurOutputBuf;

		iCurOutputBuf	= NULL;

		iProcEngineObserver->OutputBufferReady (lTempBuf, KErrCancel);

		}

	while ( iOutputArray.Count() )

		{

		TAny* lTempBuf	= iOutputArray[0];

		iOutputArray.Remove( 0 );

		iProcEngineObserver->OutputBufferReady( lTempBuf, KErrCancel );

		}

	if ( iCurCmd )

		{

		if ( iCurCmd->iCmdType != CCmdPckg::EDoProcess )

			{

			iProcEngineObserver->CommandProcessed( iCurCmd->iCmd,

					iCurCmd->iCmdData, KErrCancel );

			}

		delete iCurCmd;

		}

	while ( !iCmdArray.IsEmpty() )

		{

		CCmdPckg* lCurCmd = iCmdArray.First();

		lCurCmd->iPriorityLink.Deque();

		if ( lCurCmd->iCmdType != CCmdPckg::EDoProcess )

			{

			iProcEngineObserver->CommandProcessed( lCurCmd->iCmd,

					lCurCmd->iCmdData, KErrCancel );

			}

		delete lCurCmd;

		}

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

//  Returns output buffers.

//----------------------------------------------------------------------------

//

void CBaseProcessEngine::ReturnOutputBuffers ()

	{

	PRINT_ENTRY;

	while ( iOutputArray.Count() )

		{

		iProcEngineObserver->OutputBufferReady( iOutputArray[0], KErrCancel );

		iOutputArray.Remove( 0 );

		}

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

// Returns input buffers

//----------------------------------------------------------------------------

//

void CBaseProcessEngine::ReturnInputBuffers ()

	{

	PRINT_ENTRY;

	//Cancel any on-going processing

	if( iIsProcessing )

		{

		iCodec->Reset();

		iIsProcessing = EFalse;

		}

	// return the current input buffer and delete the corresponding doprocessL

	// command

	if ( iCurInputBuf )

		{

		TAny* lTempBuf	= iCurInputBuf;

		iCurInputBuf	= NULL;

		delete iCurCmd;

		iCurCmd = NULL;

		iProcEngineObserver->InputBufferConsumed( lTempBuf, KErrCancel );

		}

	//Since processing is canceled, output is not valid.

	//So add the output buffer back to the queue for reuse

	if( iCurOutputBuf )

		{

		iOutputArray.Append ( iCurOutputBuf );

		iCurOutputBuf = NULL;

		}

	RPointerArray<CCmdPckg> lTempCmdArray;

	//Since all the input buffers are going to be returned, delete all

	// DoProcess commands from the command array.

	// Other commands should be put into the queue as it is.

	while( !iCmdArray.IsEmpty() )

		{

		CCmdPckg* lCurCmd = iCmdArray.First();

		lCurCmd->iPriorityLink.Deque();

		if ( lCurCmd->iCmdType == CCmdPckg::EDoProcess )

			{

			delete lCurCmd;

			}

		else

			{

			// Store non-DoProcess commands in temporary array. And put them

			// back in the iCmdArray after all the DoProcess commands are

			// removed.Appending to the array to keep the order of commands

			//	intact.

			lTempCmdArray.Append( lCurCmd );

			}

		}

	while ( lTempCmdArray.Count() )

		{

		iCmdArray.Add ( *( lTempCmdArray[0] ) );

		lTempCmdArray.Remove( 0 );

		}

	lTempCmdArray.Close();

	//return all the input buffers

	while ( iInputArray.Count() )

		{

		TAny* lTempBuf = iInputArray[0];

		iInputArray.Remove( 0 );

		iProcEngineObserver->InputBufferConsumed( lTempBuf, KErrCancel );

		}

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

// Processes the commands

//----------------------------------------------------------------------------

//

void CBaseProcessEngine::DoProcessL( TInt aPriority )

	{

	PRINT_ENTRY;

	CCmdPckg* lCmd = new ( ELeave ) CCmdPckg( CCmdPckg::EDoProcess,

			aPriority );

	iCmdArray.Add ( *lCmd );

	// RunL should be scheduled in Start state. Also, if it is already

	// processing i.e iIsProcessing is ETrue,RunL should not be scheduled

	if ( iState == EStart || !iIsProcessing )

		{

		IssueRequest();

		}

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

// Adds a new command to the priority queue of commands

//----------------------------------------------------------------------------

//

void CBaseProcessEngine::AddCommandL(TInt aPriority, TInt aCmd,

		TAny* aCmdData )

	{

	PRINT_ENTRY;

	CCmdPckg* lCmd = new ( ELeave ) CCmdPckg( CCmdPckg::EOther, aPriority,

			aCmd, aCmdData );

	iCmdArray.Add (*lCmd);

	// RunL should be scheduled in Start state. Also, if it is already

	// processing i.e iIsProcessing is ETrue,RunL should not be scheduled

	if ( iState == EStart || !iIsProcessing )

		{

		IssueRequest();

		}

	PRINT_EXIT;

	}

//---------------------------------------------------------------------------

// Called by MBaseCodec when processing is complete

//----------------------------------------------------------------------------

//

void CBaseProcessEngine::ProcessingComplete( TAny *aInpBuf, TAny* aOutBuf,

		MBaseCodec::TCodecState aState, TInt aError )

	{

	PRINT_ENTRY;

	TAny* lTempBuf	=	NULL;

	iError	=	aError;

	if ( iCurInputBuf != aInpBuf )

		{

		/*This should never happen*/

		User::Panic( _L ( "iCurInputBuf != aInpBuf" ) , 0 );

		}

	if ( iCurOutputBuf != aOutBuf )

		{

		/*This should never happen*/

		User::Panic (_L("iCurOutputBuf != aOutBuf" ) , 1 );

		}

	if ( !iIsProcessing )

		{

		/*This should never happen*/

		User::Panic (_L("!iIsProcessing " ) , 2 );

		}

	// error returned by the DoProcessL must be handled here

	if( aError )

		{

		// call fatal error on hw device

		iProcEngineObserver->FatalErrorFromProcessEngine( aError );

		return;

		}

	if ( iState == EStart )

		{

		IssueRequest();

		}

	if ( iInPlaceProc )

		{

		switch ( aState )

			{

			case MBaseCodec::EInputConsumed :

			case MBaseCodec::EConsumed :

				/*Callback should be the last statement*/

				iIsProcessing = EFalse;

				lTempBuf		=	iCurInputBuf;

				iCurInputBuf	=	NULL;

				delete iCurCmd;

				iCurCmd = NULL;

				iProcEngineObserver->InputBufferConsumed( lTempBuf, iError );

				return;

			case MBaseCodec::EOutputConsumed :

			case MBaseCodec::ENotConsumed :

			default:

				return;

			}

		}

	else

		{

		switch ( aState )

			{

			case MBaseCodec::EInputConsumed :

				/*CallBack should be the last statement*/

				iIsProcessing	=	EFalse;

				lTempBuf		=	iCurInputBuf;

				iCurInputBuf	=	NULL;

				delete iCurCmd;

				iCurCmd = NULL;

				iProcEngineObserver->InputBufferConsumed( lTempBuf, iError );

				return;

			case MBaseCodec::EConsumed :

				/*CallBack should be the last statement*/

				lTempBuf		=	iCurInputBuf;

				iCurInputBuf	=	NULL;

				delete iCurCmd;

				iCurCmd = NULL;

				iProcEngineObserver->InputBufferConsumed( lTempBuf, iError );

				lTempBuf		=	iCurOutputBuf;

				iCurOutputBuf	=	NULL;

				iProcEngineObserver->OutputBufferReady( lTempBuf, iError );

				return;

			case MBaseCodec::EOutputConsumed :

				/*CallBack should be the last statement*/

				iIsProcessing	=	EFalse;