engines/author/src/pvaenodeutility.h - platform/external/opencore - Git at Google

 /* ------------------------------------------------------------------
  * Copyright (C) 1998-2009 PacketVideo
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  * express or implied.
  * See the License for the specific language governing permissions
  * and limitations under the License.
  * -------------------------------------------------------------------
  */
 #ifndef PVAE_NODE_UTILITY_H_INCLUDED
 #define PVAE_NODE_UTILTIY_H_INCLUDED

 #ifndef OSCL_BASE_H_INCLUDED
 #include "oscl_base.h"
 #endif
 #ifndef OSCL_SCHEDULER_AO_H_INCLUDED
 #include "oscl_scheduler_ao.h"
 #endif
 #ifndef OSCL_VECTOR_H_INCLUDED
 #include "oscl_vector.h"
 #endif
 #ifndef PVLOGGER_H_INCLUDED
 #include "pvlogger.h"
 #endif
 #ifndef PV_ENGINE_TYPES_H_INCLUDED
 #include "pv_engine_types.h"
 #endif
 #ifndef PVMF_NODE_INTERFACE_H_INCLUDED
 #include "pvmf_node_interface.h"
 #endif

 #define LOG_STACK_TRACE(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, m)
 #define LOG_DEBUG(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, m)
 #define LOG_ERR(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_REL,iLogger,PVLOGMSG_ERR,m)

 /** Structure to contain a node and all ports and extensions associated to it */
 class PVAENodeContainer
 {
     public:
         PVAENodeContainer()
         {
             iNode = NULL;
             iSessionId = 0;
             iNodeCapConfigIF = NULL;
         };

         PVMFNodeInterface* iNode;
         PVMFSessionId iSessionId;
         PVUuid iUuid;
         Oscl_Vector<PVMFPortInterface*, OsclMemAllocator> iInputPorts;
         Oscl_Vector<PVMFPortInterface*, OsclMemAllocator> iOutputPorts;
         Oscl_Vector<PVInterface*, OsclMemAllocator> iExtensions;
         Oscl_Vector<PVUuid, OsclMemAllocator> iExtensionUuids;
         PVInterface* iNodeCapConfigIF;
 };

 /** A vector of node container structures */
 typedef Oscl_Vector<PVAENodeContainer*, OsclMemAllocator> PVAENodeContainerVector;

 /** Enumerated list of node commands */
 typedef enum
 {
     PVAENU_CMD_NONE,
     PVAENU_CMD_CONNECT,
     PVAENU_CMD_DISCONNECT,
     PVAENU_CMD_QUERY_UUID,
     PVAENU_CMD_QUERY_INTERFACE,
     PVAENU_CMD_INIT,
     PVAENU_CMD_PREPARE,
     PVAENU_CMD_START,
     PVAENU_CMD_STOP,
     PVAENU_CMD_FLUSH,
     PVAENU_CMD_PAUSE,
     PVAENU_CMD_RESET,
 } PVAENodeUtilCmdType;

 /** Node utility command class */
 class PVAENodeUtilCmd
 {
     public:

         PVAENodeUtilCmd() : iType(PVAENU_CMD_NONE), iParam1(NULL), iParam2(NULL), iContext(NULL) {}
         PVAENodeUtilCmd(const PVAENodeUtilCmd& aCmd)
         {
             Copy(aCmd);
         }

         PVAENodeUtilCmd& operator=(const PVAENodeUtilCmd& aCmd)
         {
             Copy(aCmd);
             return (*this);
         }

         // For most commands
         PVMFStatus Construct(PVAENodeUtilCmdType aType, const PVAENodeContainerVector& aNodes, OsclAny* aContext)
         {
             iType = aType;
             iNodes = aNodes;
             iContext = aContext;
             return PVMFSuccess;
         }

         // For Connect
         PVMFStatus ConstructConnect(PVAENodeContainer* aMasterNode, int32 aTag1,
                                     PVAENodeContainer* aSlaveNode, int32 aTag2,
                                     const PvmfMimeString& aMimeType, OsclAny* aContext)
         {
             iType = PVAENU_CMD_CONNECT;
             iContext = aContext;
             iParam1 = (OsclAny*)aTag1;
             iParam2 = (OsclAny*)aTag2;

             int32 err = 0;
             OSCL_TRY(err,
                      iNodes.push_back(aMasterNode);
                      iNodes.push_back(aSlaveNode);
                      iMimeType = aMimeType;
                     );
             OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

             return PVMFSuccess;
         }

         PVMFStatus ParseConnect(int32& aTag1, int32& aTag2, PvmfMimeString& aMimeType)
         {
             if (iType != PVAENU_CMD_CONNECT)
                 return PVMFFailure;

             aTag1 = (int32)iParam1;
             aTag2 = (int32)iParam2;
             aMimeType = iMimeType;
             return PVMFSuccess;
         }

         PVMFStatus ConstructDisconnect(PVAENodeContainer* aNodeContainer, OsclAny* aContext)
         {
             iType = PVAENU_CMD_DISCONNECT;
             iContext = aContext;

             int32 err = 0;
             OSCL_TRY(err,
                      iNodes.push_back(aNodeContainer);
                     );
             OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

             return PVMFSuccess;
         }

         PVMFStatus ConstructQueryUUID(PVAENodeContainer* aNodeContainer, const PvmfMimeString& aMimeType,
                                       Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
                                       bool aExactUuidsOnly, OsclAny* aContext)
         {
             iType = PVAENU_CMD_QUERY_UUID;
             iContext = aContext;
             iParam1 = (OsclAny*) & aUuids;
             iParam2 = (OsclAny*)aExactUuidsOnly;

             int32 err = 0;
             OSCL_TRY(err,
                      iNodes.push_back(aNodeContainer);
                      iMimeType = aMimeType;
                     );
             OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

             return PVMFSuccess;
         }

         PVMFStatus ParseQueryUUID(Oscl_Vector<PVUuid, OsclMemAllocator>* aUuids, bool& aExactUuidsOnly)
         {
             if (iType != PVAENU_CMD_QUERY_UUID)
                 return PVMFFailure;

             aUuids = (Oscl_Vector<PVUuid, OsclMemAllocator>*)iParam1;
             aExactUuidsOnly = (iParam2 != NULL); // iParam2 is a bool
             return PVMFSuccess;
         }

         PVMFStatus ConstructQueryInterface(PVAENodeContainer* aNodeContainer,
                                            const PVUuid& aUuid,
                                            PVInterface*& aInterfacePtr,
                                            OsclAny* aContext)
         {
             iType = PVAENU_CMD_QUERY_INTERFACE;
             iContext = aContext;
             iParam1 = (OsclAny*) & aInterfacePtr;
             iUuid = aUuid;

             int32 err = 0;
             OSCL_TRY(err,
                      iNodes.push_back(aNodeContainer);
                     );
             OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

             return PVMFSuccess;
         }

         PVMFStatus ParseQueryInterface(PVInterface**& aInterfacePtr)
         {
             if (iType != PVAENU_CMD_QUERY_INTERFACE)
                 return PVMFFailure;

             aInterfacePtr = (PVInterface**)iParam1;
             return PVMFSuccess;
         }

         PVMFStatus ConstructInit(PVAENodeContainer* aNodeContainer, OsclAny* aContext)
         {
             iType = PVAENU_CMD_INIT;
             iContext = aContext;

             int32 err = 0;
             OSCL_TRY(err,
                      iNodes.push_back(aNodeContainer);
                     );
             OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

             return PVMFSuccess;
         }

         PVAENodeUtilCmdType iType;
         PVAENodeContainerVector iNodes;
         OSCL_HeapString<OsclMemAllocator> iMimeType;
         PVUuid iUuid; // For QueryInterface
         OsclAny* iParam1;
         OsclAny* iParam2;
         OsclAny* iContext;

     private:
         void Copy(const PVAENodeUtilCmd& aCmd)
         {
             iType = aCmd.iType;
             iNodes = aCmd.iNodes;
             iMimeType = aCmd.iMimeType;
             iUuid = aCmd.iUuid;
             iParam1 = aCmd.iParam1;
             iParam2 = aCmd.iParam2;
             iContext = aCmd.iContext;
         }
 };

 /** Observer class to listen for utility command completion events */
 class PVAENodeUtilObserver
 {
     public:
         virtual void NodeUtilCommandCompleted(const PVMFCmdResp& aResponse) = 0;
         virtual void NodeUtilErrorEvent(const PVMFAsyncEvent& aEvent) = 0;
         virtual ~PVAENodeUtilObserver() {}
 };

 /**
  * Utility class to connect two nodes and handle node commands to multiple
  * nodes. Users of this utility must provide PVMFNodeCmdStatusObserver,
  * PVMFNodeErrorEventObserver and PVMFNodeInfoEventObserver in order to
  * receive callbacks for results of command issued to this utility.
  *
  * While this utility is processing a command, it will change the nodes'
  * observers to this utility. Therefore there must be no pending commands
  * in the node before this method is called. Other users of the node must not
  * change the observers until this command is completed.  Also, no additional commands
  * should be made to these nodes until the command is completed. When the
  * command is complete, the observers of the node will be set to the observers
  * of this utility.
  */
 class PVAuthorEngineNodeUtility : public OsclTimerObject,
         public PVMFNodeCmdStatusObserver
 {
     public:
         PVAuthorEngineNodeUtility();
         virtual ~PVAuthorEngineNodeUtility();

         /**
          * Sets command status observer. After a utility
          * command is completed, the command status observer for the nodes
          * will be sent to the observer set here.
          *
          * @param aObserver Command status observer
          */
         void SetObserver(const PVAENodeUtilObserver& aObserver)
         {
             iObserver = (PVAENodeUtilObserver*) & aObserver;
         }

         /**
          * Connect two nodes. An output port will be requested from the specified
          * input node, and an input port will be requested from the specified output
          * node.  The two ports will then be connected to establish a connection
          * between the two nodes. This utility will callback to report status of
          * the command after the connection is complete and will return the newly
          * requested and connected ports will be added to the iInPorts or iOutPorts
          * vector in the PVAENodeContainer objects passed in.
          *
          * @param aInputNode Container of input node of the connection. The newly requested
          * port will be added to the iOutPorts vector of the node container.
          * @param aOutputNode Container of output node of the connection.  The newly requested
          * port will be added to the iInPorts vector of the node container.
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Connect(PVAENodeContainer* aMasterNode, int32 aTag1,
                            PVAENodeContainer* aSlaveNode, int32 aTag2,
                            const PvmfMimeString& aMimeType,
                            OsclAny* aContext = NULL);

         /**
          * Disconnect and release all ports of a node.
          *
          * @param aNodeContainer Container for node which ports will be disonnected and released
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Disconnect(PVAENodeContainer* aNodeContainer, OsclAny* aContext = NULL);

         /**
          * Query UUIDs supported by the specified node.
          *
          * @param aNodeContainer Container for node to which this query is made
          * @param aMimeType The MIME type of the desired interfaces
          * @param aUuids A vector to hold the discovered UUIDs
          * @param aExactUuidsOnly Turns on/off the retrival of UUIDs with aMimeType as a base type
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus QueryUUID(PVAENodeContainer* aNodeContainer,
                              const PvmfMimeString& aMimeType,
                              Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
                              bool aExactUuidsOnly = false,
                              OsclAny* aContext = NULL);

         /**
          * Query for interface of specified Uuid from the specified node. The queried interface
          * object will be added to the iExtensions vector and stored in the interface pointer
          * provided by user.  Also, Uuid of the queried interface will be added to the
          * iExtensionsUuid vector.
          *
          * @param aNodeContainer Container for node to which this query is made
          * @param aUuid The UUID of the desired interface
          * @param aInterfacePtr Optional interface pointer to store the requested interface
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus QueryInterface(PVAENodeContainer* aNodeContainer,
                                   const PVUuid& aUuid,
                                   PVInterface*& aInterfacePtr,
                                   OsclAny* aContext = NULL);

         /**
          * Initialize a node
          *
          * @param aNode Node container containing the node to be initialized.
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Init(const PVAENodeContainer* aNode, OsclAny* aContext = NULL);

         /**
          * Initialize all nodes in the vector.
          *
          * @param aNodes Vector of nodes to be initialized
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Init(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

         /**
          * Prepare all nodes in the vector.
          *
          * @param aNodes Vector of nodes to be prepared
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Prepare(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

         /**
          * Start all ports of all nodes in the vector.
          *
          * @param aNodes Vector of nodes to be started
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Start(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

         /**
          * Pause all ports of all nodes in the vector.
          *
          * @param aNodes Vector of nodes to be paused
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Pause(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

         /**
          * Stop all ports of all nodes in the vector.
          *
          * @param aNodes Vector of nodes to be stopped
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Stop(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

         /**
          * Flush all ports of all nodes in the vector.
          *
          * @param aNodes Vector of nodes to be flushed
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Flush(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

         /**
          * Start all ports of all nodes in the vector.
          *
          * @param aNodes Vector of nodes to be reset
          * @param aContext Optional opaque data to be passed back to user with the command response
          * @returns Completion status
          */
         PVMFStatus Reset(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

         /**
          * Provides the size of command queue
          *
          * @returns Number of pending commands in command queue
          */
         uint32 GetCommandQueueSize();

         // Implement pure virtual method of PVMFNodeCmdStatusObserver
         void NodeCommandCompleted(const PVMFCmdResp& aResponse);

     private:
         void Run();

         // Command queue routines
         PVMFStatus AddCmdToQueue(PVAENodeUtilCmd& aCmd);
         void CompleteUtilityCmd(const PVAENodeUtilCmd& aCmd, PVMFStatus aStatus);

         // Command processing routines
         PVMFStatus DoConnect(const PVAENodeUtilCmd& aCmd);
         PVMFStatus CompleteConnect(const PVAENodeUtilCmd& aCmd, const PVMFCmdResp& aResponse);
         PVMFStatus DoDisconnect(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoQueryUuid(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoQueryInterface(const PVAENodeUtilCmd& aCmd);
         PVMFStatus CompleteQueryInterface(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoInit(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoPrepare(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoStart(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoPause(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoStop(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoFlush(const PVAENodeUtilCmd& aCmd);
         PVMFStatus DoReset(const PVAENodeUtilCmd& aCmd);
         PVMFStatus CompleteStateTransition(const PVAENodeUtilCmd& aCmd, TPVMFNodeInterfaceState aState);
         PVMFStatus ReleasePort(PVAENodeContainer*&, PVMFPortInterface*&);
         // Observer
         PVAENodeUtilObserver* iObserver;

         // Command queue
         Oscl_Vector<PVAENodeUtilCmd, OsclMemAllocator> iCmdQueue;

         PVLogger* iLogger;
 };

 #endif // PVAE_NODE_UTILTIY_H_INCLUDED
	/* ------------------------------------------------------------------
	* Copyright (C) 1998-2009 PacketVideo
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
	* express or implied.
	* See the License for the specific language governing permissions
	* and limitations under the License.
	* -------------------------------------------------------------------
	*/
	#ifndef PVAE_NODE_UTILITY_H_INCLUDED
	#define PVAE_NODE_UTILTIY_H_INCLUDED

	#ifndef OSCL_BASE_H_INCLUDED
	#include "oscl_base.h"
	#endif
	#ifndef OSCL_SCHEDULER_AO_H_INCLUDED
	#include "oscl_scheduler_ao.h"
	#endif
	#ifndef OSCL_VECTOR_H_INCLUDED
	#include "oscl_vector.h"
	#endif
	#ifndef PVLOGGER_H_INCLUDED
	#include "pvlogger.h"
	#endif
	#ifndef PV_ENGINE_TYPES_H_INCLUDED
	#include "pv_engine_types.h"
	#endif
	#ifndef PVMF_NODE_INTERFACE_H_INCLUDED
	#include "pvmf_node_interface.h"
	#endif

	#define LOG_STACK_TRACE(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, m)
	#define LOG_DEBUG(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, m)
	#define LOG_ERR(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_REL,iLogger,PVLOGMSG_ERR,m)

	/** Structure to contain a node and all ports and extensions associated to it */
	class PVAENodeContainer
	{
	public:
	PVAENodeContainer()
	{
	iNode = NULL;
	iSessionId = 0;
	iNodeCapConfigIF = NULL;
	};

	PVMFNodeInterface* iNode;
	PVMFSessionId iSessionId;
	PVUuid iUuid;
	Oscl_Vector<PVMFPortInterface*, OsclMemAllocator> iInputPorts;
	Oscl_Vector<PVMFPortInterface*, OsclMemAllocator> iOutputPorts;
	Oscl_Vector<PVInterface*, OsclMemAllocator> iExtensions;
	Oscl_Vector<PVUuid, OsclMemAllocator> iExtensionUuids;
	PVInterface* iNodeCapConfigIF;
	};

	/** A vector of node container structures */
	typedef Oscl_Vector<PVAENodeContainer*, OsclMemAllocator> PVAENodeContainerVector;

	/** Enumerated list of node commands */
	typedef enum
	{
	PVAENU_CMD_NONE,
	PVAENU_CMD_CONNECT,
	PVAENU_CMD_DISCONNECT,
	PVAENU_CMD_QUERY_UUID,
	PVAENU_CMD_QUERY_INTERFACE,
	PVAENU_CMD_INIT,
	PVAENU_CMD_PREPARE,
	PVAENU_CMD_START,
	PVAENU_CMD_STOP,
	PVAENU_CMD_FLUSH,
	PVAENU_CMD_PAUSE,
	PVAENU_CMD_RESET,
	} PVAENodeUtilCmdType;

	/** Node utility command class */
	class PVAENodeUtilCmd
	{
	public:

	PVAENodeUtilCmd() : iType(PVAENU_CMD_NONE), iParam1(NULL), iParam2(NULL), iContext(NULL) {}
	PVAENodeUtilCmd(const PVAENodeUtilCmd& aCmd)
	{
	Copy(aCmd);
	}

	PVAENodeUtilCmd& operator=(const PVAENodeUtilCmd& aCmd)
	{
	Copy(aCmd);
	return (*this);
	}

	// For most commands
	PVMFStatus Construct(PVAENodeUtilCmdType aType, const PVAENodeContainerVector& aNodes, OsclAny* aContext)
	{
	iType = aType;
	iNodes = aNodes;
	iContext = aContext;
	return PVMFSuccess;
	}

	// For Connect
	PVMFStatus ConstructConnect(PVAENodeContainer* aMasterNode, int32 aTag1,
	PVAENodeContainer* aSlaveNode, int32 aTag2,
	const PvmfMimeString& aMimeType, OsclAny* aContext)
	{
	iType = PVAENU_CMD_CONNECT;
	iContext = aContext;
	iParam1 = (OsclAny*)aTag1;
	iParam2 = (OsclAny*)aTag2;

	int32 err = 0;
	OSCL_TRY(err,
	iNodes.push_back(aMasterNode);
	iNodes.push_back(aSlaveNode);
	iMimeType = aMimeType;
	);
	OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

	return PVMFSuccess;
	}

	PVMFStatus ParseConnect(int32& aTag1, int32& aTag2, PvmfMimeString& aMimeType)
	{
	if (iType != PVAENU_CMD_CONNECT)
	return PVMFFailure;

	aTag1 = (int32)iParam1;
	aTag2 = (int32)iParam2;
	aMimeType = iMimeType;
	return PVMFSuccess;
	}

	PVMFStatus ConstructDisconnect(PVAENodeContainer* aNodeContainer, OsclAny* aContext)
	{
	iType = PVAENU_CMD_DISCONNECT;
	iContext = aContext;

	int32 err = 0;
	OSCL_TRY(err,
	iNodes.push_back(aNodeContainer);
	);
	OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

	return PVMFSuccess;
	}

	PVMFStatus ConstructQueryUUID(PVAENodeContainer* aNodeContainer, const PvmfMimeString& aMimeType,
	Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
	bool aExactUuidsOnly, OsclAny* aContext)
	{
	iType = PVAENU_CMD_QUERY_UUID;
	iContext = aContext;
	iParam1 = (OsclAny*) & aUuids;
	iParam2 = (OsclAny*)aExactUuidsOnly;

	int32 err = 0;
	OSCL_TRY(err,
	iNodes.push_back(aNodeContainer);
	iMimeType = aMimeType;
	);
	OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

	return PVMFSuccess;
	}

	PVMFStatus ParseQueryUUID(Oscl_Vector<PVUuid, OsclMemAllocator>* aUuids, bool& aExactUuidsOnly)
	{
	if (iType != PVAENU_CMD_QUERY_UUID)
	return PVMFFailure;

	aUuids = (Oscl_Vector<PVUuid, OsclMemAllocator>*)iParam1;
	aExactUuidsOnly = (iParam2 != NULL); // iParam2 is a bool
	return PVMFSuccess;
	}

	PVMFStatus ConstructQueryInterface(PVAENodeContainer* aNodeContainer,
	const PVUuid& aUuid,
	PVInterface*& aInterfacePtr,
	OsclAny* aContext)
	{
	iType = PVAENU_CMD_QUERY_INTERFACE;
	iContext = aContext;
	iParam1 = (OsclAny*) & aInterfacePtr;
	iUuid = aUuid;

	int32 err = 0;
	OSCL_TRY(err,
	iNodes.push_back(aNodeContainer);
	);
	OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

	return PVMFSuccess;
	}

	PVMFStatus ParseQueryInterface(PVInterface**& aInterfacePtr)
	{
	if (iType != PVAENU_CMD_QUERY_INTERFACE)
	return PVMFFailure;

	aInterfacePtr = (PVInterface**)iParam1;
	return PVMFSuccess;
	}

	PVMFStatus ConstructInit(PVAENodeContainer* aNodeContainer, OsclAny* aContext)
	{
	iType = PVAENU_CMD_INIT;
	iContext = aContext;

	int32 err = 0;
	OSCL_TRY(err,
	iNodes.push_back(aNodeContainer);
	);
	OSCL_FIRST_CATCH_ANY(err, return PVMFErrNoMemory;);

	return PVMFSuccess;
	}

	PVAENodeUtilCmdType iType;
	PVAENodeContainerVector iNodes;
	OSCL_HeapString<OsclMemAllocator> iMimeType;
	PVUuid iUuid; // For QueryInterface
	OsclAny* iParam1;
	OsclAny* iParam2;
	OsclAny* iContext;

	private:
	void Copy(const PVAENodeUtilCmd& aCmd)
	{
	iType = aCmd.iType;
	iNodes = aCmd.iNodes;
	iMimeType = aCmd.iMimeType;
	iUuid = aCmd.iUuid;
	iParam1 = aCmd.iParam1;
	iParam2 = aCmd.iParam2;
	iContext = aCmd.iContext;
	}
	};

	/** Observer class to listen for utility command completion events */
	class PVAENodeUtilObserver
	{
	public:
	virtual void NodeUtilCommandCompleted(const PVMFCmdResp& aResponse) = 0;
	virtual void NodeUtilErrorEvent(const PVMFAsyncEvent& aEvent) = 0;
	virtual ~PVAENodeUtilObserver() {}
	};

	/**
	* Utility class to connect two nodes and handle node commands to multiple
	* nodes. Users of this utility must provide PVMFNodeCmdStatusObserver,
	* PVMFNodeErrorEventObserver and PVMFNodeInfoEventObserver in order to
	* receive callbacks for results of command issued to this utility.
	*
	* While this utility is processing a command, it will change the nodes'
	* observers to this utility. Therefore there must be no pending commands
	* in the node before this method is called. Other users of the node must not
	* change the observers until this command is completed. Also, no additional commands
	* should be made to these nodes until the command is completed. When the
	* command is complete, the observers of the node will be set to the observers
	* of this utility.
	*/
	class PVAuthorEngineNodeUtility : public OsclTimerObject,
	public PVMFNodeCmdStatusObserver
	{
	public:
	PVAuthorEngineNodeUtility();
	virtual ~PVAuthorEngineNodeUtility();

	/**
	* Sets command status observer. After a utility
	* command is completed, the command status observer for the nodes
	* will be sent to the observer set here.
	*
	* @param aObserver Command status observer
	*/
	void SetObserver(const PVAENodeUtilObserver& aObserver)
	{
	iObserver = (PVAENodeUtilObserver*) & aObserver;
	}

	/**
	* Connect two nodes. An output port will be requested from the specified
	* input node, and an input port will be requested from the specified output
	* node. The two ports will then be connected to establish a connection
	* between the two nodes. This utility will callback to report status of
	* the command after the connection is complete and will return the newly
	* requested and connected ports will be added to the iInPorts or iOutPorts
	* vector in the PVAENodeContainer objects passed in.
	*
	* @param aInputNode Container of input node of the connection. The newly requested
	* port will be added to the iOutPorts vector of the node container.
	* @param aOutputNode Container of output node of the connection. The newly requested
	* port will be added to the iInPorts vector of the node container.
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Connect(PVAENodeContainer* aMasterNode, int32 aTag1,
	PVAENodeContainer* aSlaveNode, int32 aTag2,
	const PvmfMimeString& aMimeType,
	OsclAny* aContext = NULL);

	/**
	* Disconnect and release all ports of a node.
	*
	* @param aNodeContainer Container for node which ports will be disonnected and released
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Disconnect(PVAENodeContainer* aNodeContainer, OsclAny* aContext = NULL);

	/**
	* Query UUIDs supported by the specified node.
	*
	* @param aNodeContainer Container for node to which this query is made
	* @param aMimeType The MIME type of the desired interfaces
	* @param aUuids A vector to hold the discovered UUIDs
	* @param aExactUuidsOnly Turns on/off the retrival of UUIDs with aMimeType as a base type
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus QueryUUID(PVAENodeContainer* aNodeContainer,
	const PvmfMimeString& aMimeType,
	Oscl_Vector<PVUuid, OsclMemAllocator>& aUuids,
	bool aExactUuidsOnly = false,
	OsclAny* aContext = NULL);

	/**
	* Query for interface of specified Uuid from the specified node. The queried interface
	* object will be added to the iExtensions vector and stored in the interface pointer
	* provided by user. Also, Uuid of the queried interface will be added to the
	* iExtensionsUuid vector.
	*
	* @param aNodeContainer Container for node to which this query is made
	* @param aUuid The UUID of the desired interface
	* @param aInterfacePtr Optional interface pointer to store the requested interface
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus QueryInterface(PVAENodeContainer* aNodeContainer,
	const PVUuid& aUuid,
	PVInterface*& aInterfacePtr,
	OsclAny* aContext = NULL);

	/**
	* Initialize a node
	*
	* @param aNode Node container containing the node to be initialized.
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Init(const PVAENodeContainer* aNode, OsclAny* aContext = NULL);

	/**
	* Initialize all nodes in the vector.
	*
	* @param aNodes Vector of nodes to be initialized
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Init(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

	/**
	* Prepare all nodes in the vector.
	*
	* @param aNodes Vector of nodes to be prepared
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Prepare(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

	/**
	* Start all ports of all nodes in the vector.
	*
	* @param aNodes Vector of nodes to be started
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Start(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

	/**
	* Pause all ports of all nodes in the vector.
	*
	* @param aNodes Vector of nodes to be paused
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Pause(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

	/**
	* Stop all ports of all nodes in the vector.
	*
	* @param aNodes Vector of nodes to be stopped
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Stop(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

	/**
	* Flush all ports of all nodes in the vector.
	*
	* @param aNodes Vector of nodes to be flushed
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Flush(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

	/**
	* Start all ports of all nodes in the vector.
	*
	* @param aNodes Vector of nodes to be reset
	* @param aContext Optional opaque data to be passed back to user with the command response
	* @returns Completion status
	*/
	PVMFStatus Reset(const PVAENodeContainerVector& aNodes, OsclAny* aContext = NULL);

	/**
	* Provides the size of command queue
	*
	* @returns Number of pending commands in command queue
	*/
	uint32 GetCommandQueueSize();

	// Implement pure virtual method of PVMFNodeCmdStatusObserver
	void NodeCommandCompleted(const PVMFCmdResp& aResponse);

	private:
	void Run();

	// Command queue routines
	PVMFStatus AddCmdToQueue(PVAENodeUtilCmd& aCmd);
	void CompleteUtilityCmd(const PVAENodeUtilCmd& aCmd, PVMFStatus aStatus);

	// Command processing routines
	PVMFStatus DoConnect(const PVAENodeUtilCmd& aCmd);
	PVMFStatus CompleteConnect(const PVAENodeUtilCmd& aCmd, const PVMFCmdResp& aResponse);
	PVMFStatus DoDisconnect(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoQueryUuid(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoQueryInterface(const PVAENodeUtilCmd& aCmd);
	PVMFStatus CompleteQueryInterface(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoInit(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoPrepare(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoStart(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoPause(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoStop(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoFlush(const PVAENodeUtilCmd& aCmd);
	PVMFStatus DoReset(const PVAENodeUtilCmd& aCmd);
	PVMFStatus CompleteStateTransition(const PVAENodeUtilCmd& aCmd, TPVMFNodeInterfaceState aState);
	PVMFStatus ReleasePort(PVAENodeContainer&, PVMFPortInterface&);
	// Observer
	PVAENodeUtilObserver* iObserver;

	// Command queue
	Oscl_Vector<PVAENodeUtilCmd, OsclMemAllocator> iCmdQueue;

	PVLogger* iLogger;
	};

	#endif // PVAE_NODE_UTILTIY_H_INCLUDED