/*

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

* Header file of process engine. Declares class CBaseProcessEngine

* which derives from CBaseEngine and provides implementation for

* all pure virtual functions

*

*/

#ifndef ARIPROCESSENGINE_H

#define ARIPROCESSENGINE_H

#include <E32base.h>

#include "aribaseengine.h"

#include "ariprint.h"

NONSHARABLE_CLASS (CCmdPckg): public CBase

	{

	public:

		/**

		 * Enumeration to be used to specify command type. All commands should

		 *  be of one of the 2 types given in this enumeration.

		 */

		enum TCmdType

			{

			/**

			 *  All commands for encoding a buffer should be of this type

			 *  @see CCmdPckg::CCmdPckg

			 *

			 */

			EDoProcess,

			/**

			 *  Rest of the commands will be of this type

			 */

			EOther

			};

		/**

		 * Default constructor.Assigns the parameteres to corresponding

		 * member variables.

		 * @param aCmdType

		 *    The type of command (EDoProcess/EOther)

		 * @param aPriority

		 *    The priority assigned to this command

		 * @param aCmd

		 * 	  The command

		 * @param aCmdData

		 * 	  Command specific data

		 */

		CCmdPckg ( TCmdType aCmdType, TInt aPriority, TInt aCmd = -1,

				TAny* aCmdData = NULL );

		/**> Destructor */

		~CCmdPckg();

	public:

		/**

		 * Command type which will be either one of - EDoProcess/EOther

		 */

		TCmdType 	iCmdType;

		/**

		 * The command. Any command which is not of type EDoProcess will be

		 * processed in the wrapper.

		 */

		TInt		iCmd;

		/**

		 * Command specific data.

		 */

		TAny* 		iCmdData;

		/**

		 * The priority link to store the commands in a priority based doubly

		 * linked list.

		 */

		TPriQueLink iPriorityLink;

	};

NONSHARABLE_CLASS ( CBaseProcessEngine ) :  public CBaseEngine,

								public CActive

{

	public:

		/**

		 * Enumeration to be used to specify the state of the process engine

		 */

		enum TState

		{

			EStart,

			EStop

		};

	public:

		/**

		 * Two-phased constructor.

		 * @param aObserver

		 *    Pointer to observer to the process engine - HwDevice

		 * @param aCodec

		 *    Pointer to wrapper

		 * @param aInPlaceProcessing

		 *

		 * @param aProcessingAutomatic

		 *

		 * @return pointer to an instance of CBaseProcessEngine

		 */

		static CBaseProcessEngine* NewL ( MProcessEngineObserver* aObserver,

										  MBaseCodec* aCodec,

										  TBool aInPlaceProcessing,

										 TBool aProcessingAutomatic = ETrue );

		/**> Destructor */

		virtual ~CBaseProcessEngine ();

		/**

		 *  Default constructor

		 */

		CBaseProcessEngine();

	public:

		/**

		 * From CBaseEngine

		 * To add the input buffer to the Q

		 * @param aBuffer

		 * 	  Pointer to an input buffer.

		 * @return symbian wide error code

		 */

		TInt AddInput( TAny* aBuffer);

		/**

		 * From CBaseEngine

		 * To add the output buffer to the Q

		 * @param aBuffer

		 * 	  Pointer to an output buffer.

		 * @return symbian wide error code, KErrNone on success

		 */

		TInt AddOutput( TAny* aBuffer);

		/**

		 * From CBaseEngine

		 * Starts the processing

		 * @return symbian wide error code, KErrNone on success

		 */

		TInt Start();

		/**

		 * From CBaseEngine

		 * Stops the processing

		 * @return symbian wide error code, KErrNone on success

		 */

		TInt Stop();

		/**

		 * From CBaseEngine

		 * Processes the commands

		 * @param aPriority

		 * 	  Priority of the encode command object

		 */

		void DoProcessL( TInt aPriority);

		/**

		 * From CBaseEngine

		 * Adds a new command to the priority queue of commands

		 * @param aPriority

		 * 	  Priority of the command object

		 * @param aCmd

		 * 	  The command

		 * @param aCmdData

		 * 	  Command specific data

		 */

		void AddCommandL( TInt aPriority, TInt aCmd, TAny* aCmdData );

		/**

		 * From CBaseEngine

		 * 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 Reset();

		/**

		 * From CBaseEngine

		 * Returns a output buffer back to the HwDevice

		 */

        void ReturnOutputBuffers();

        /**

         * From CBaseEngine

		 * Gets the number of input buffers

		 * @return returns the number of input buffers in process engine q

		 */

		TInt NumInputBuffers();

        /**

         * From CBaseEngine

		 * Gets the number of output buffers

		 * @return returns the number of output buffers in process engine q

		 */

		TInt NumOutputBuffers();

		/**

		 * From CBaseEngine

		 * Returns whether processing of an input buffer is going on or else

		 * @return ETrue if processing in on going, else EFalse

		 */

		TBool IsProcessing();

		/**

		 * From CBaseEngine

		 * Returns input buffer back to the HwDevice through callback

		 */

		void ReturnInputBuffers();

		/**

		 * From CBaseEngine

		 * Returns all the input pictures added previously through callback

		 */

		void ReturnInput();

		/**

		 * From CBaseEngine

		 * Returns the 1st buffer from the output buffer queue

		 * @return returns pointer to the fetched output buffer

		 */

		virtual TAny* FetchOutputBuffer();

	public:

		/**

		 * From CBaseEngine

		 * Called by MBaseCodec when processing is complete

		 * @param aInpBuf

		 * 	  The input buffer sent for processing

		 * @param aOutBuf

		 *    The output buffer

		 * @param aState

		 *    The result of processing

		 * @param aError

		 *    Error value returned from DoProcessL

		 */

		void ProcessingComplete( TAny *aInpBuf, TAny* aOutBuf,

									MBaseCodec::TCodecState aState,

									TInt aError );

		/**

		 * From CBaseEngine

		 * Called by MBaseCodec when processing of commmands is complete

		 * @param aCommand

		 * 	  The command which has been processed

		 * @param aCmdData

		 *    Command specific data

		 * @param aState

		 *    The result of processing

		 * @param aError

		 * 	  Result of processing command

		 */

		void ProcessingCommandComplete( TInt aCommand, TAny* aCmdData,

															TInt aError );

	private:

		void RunL ();

		void DoCancel ();

		TInt RunError( TInt aError );

	private:

		void IssueRequest ();

		void ConstructL( MProcessEngineObserver* aObserver,

						 MBaseCodec* aCodec,

						 TBool aInPlaceProcessing,

						 TBool aProcessingAutomatic );

		TBool IsReadyForProcessing ();

		void ProcessNextCommand ();

	private:

		TPriQue<CCmdPckg> 				iCmdArray;

		RArray<TAny*> 					iInputArray;

		RArray<TAny*> 					iOutputArray;

		TState 							iState;

		MProcessEngineObserver* 		iProcEngineObserver;

		MBaseCodec* 				    iCodec;

		TBool 							iInPlaceProc;

		TBool 							iAutomaticProc;

		TAny* 							iCurInputBuf;

		TAny* 							iCurOutputBuf;

		CCmdPckg*						iCurCmd;

		TBool							iIsProcessing;

		TBool							iOutputBufferReadyCallBackPending;

		TInt							iError;

        TInt iInputBufsAddedSoFar;

        TInt iOutputBufsAddedSoFar;

};

#endif //ARIPROCESSENGINE_H