nodes/common/include/pvmf_node_registry.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.
  * -------------------------------------------------------------------
  */
 // -*- c++ -*-
 // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

 //               P V M F _ N O D E _ R E G I S T R Y

 // = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

 /*! \addtogroup pvmfnoderegistry PVMFNodeRegistry
 *
 * @{
 */


 /*! \file pvmf_node_registry.h
 \brief This file contains the declarations for the node registry.
 */

 #ifndef PVMF_NODE_REGSITRY_H_INCLUDED
 #define PVMF_NODE_REGSITRY_H_INCLUDED

 #include "pv_interface.h"
 #include "pv_uuid.h"
 #include "pvmf_event_handling.h"
 #include "oscl_vector.h"
 #include "pvmf_format_type.h"
 #include "oscl_string_containers.h"

 class PVMFNodeInterface;
 class PvmiMIOControl;


 /*
 ** An abstract interface class containing a function
 ** to do a synchronous interface query.
 ** Each registered component must support this interface.
 */
 typedef PVInterface PVMFSimpleQueryInterface ;


 /*
 ** An abstract interface class containing methods
 ** to create and release a PVMF node.
 */
 class PVMFNodeCreationInterface
 {
     public:
         /** Virtual destructor
         **   need to be defined to avoid compiler warnings
         **/
         virtual ~PVMFNodeCreationInterface() {}

         /**
         ** Create a node instance.  May throw an exception if
         **  node creation fails due to out-of-memory condition or other error.
         **
         ** @param aParam optional opaque data to be passed to node constructor.
         ** @return pointer to the node.
         */
         virtual PVMFNodeInterface* CreateNode(OsclAny* aParam = NULL) = 0;

         /**
         ** Relese a node instance previously created with CreateNode.
         **
         ** @param aNode (input): the node instance.
         */
         virtual void ReleaseNode(PVMFNodeInterface* aNode) = 0;
 };

 /*
 ** An abstract interface class containing methods
 ** to create and release a Media I/O component.
 */
 class PVMFMediaIOCreationInterface
 {
     public:
         /** Virtual destructor
         **   need to be defined to avoid compiler warnings
         **/
         virtual ~PVMFMediaIOCreationInterface() {}
         /**
         ** Create a Media I/O component instance.  May throw an exception if
         **  creation fails due to out-of-memory condition or other error.
         **
         ** @param aParam: optional opaque data to pass the MIO constructor.
         ** @return pointer to the component.
         */
         virtual PvmiMIOControl* CreateMediaIO(OsclAny*aParam = NULL) = 0;

         /**
         ** Relese a Media I/O component instance previously created with CreateMediaIO.
         **
         ** @param aMediaIO (input): the media I/O instance.
         */
         virtual void ReleaseMediaIO(PvmiMIOControl* aMediaIO) = 0;
 };


 /*
 ** A class to encapsulate PVMF media format information.
 ** The media format is a MIME string, such as audio/compressed/amr
 */
 class PVMFComponentFormatType
 {
     public:
         OSCL_IMPORT_REF PVMFComponentFormatType(const char*aFmtStr);

         PVMFComponentFormatType(const PVMFComponentFormatType& s)
         {
             iFormatType = s.iFormatType;
             iFormatString = s.iFormatString;
         }

         OSCL_HeapString<OsclMemAllocator> iFormatString;
         PVMFFormatType iFormatType;

         OSCL_IMPORT_REF bool operator== (const PVMFComponentFormatType& src) const;

 };


 /*
 ** A class to encapsulate PVMF media format pair information.
 ** A format pair consists of an input format and an output format.
 */
 class PVMFComponentFormatPairType
 {
     public:
         PVMFComponentFormatPairType(char* input
                                     , char* output)
                 : iInputFormat(PVMFComponentFormatType(input))
                 , iOutputFormat(PVMFComponentFormatType(output))
         {}
         PVMFComponentFormatPairType(PVMFComponentFormatType& input
                                     , PVMFComponentFormatType& output)
                 : iInputFormat(input)
                 , iOutputFormat(output)
         {}

         PVMFComponentFormatPairType(const PVMFComponentFormatPairType& s)
                 : iInputFormat(s.iInputFormat)
                 , iOutputFormat(s.iOutputFormat)
         {}

         PVMFComponentFormatType iInputFormat;
         PVMFComponentFormatType iOutputFormat;
 };

 /*
 ** Format list types.
 */
 typedef Oscl_Vector<PVMFComponentFormatType, OsclMemAllocator> PVMFComponentFormatListType;
 typedef Oscl_Vector<PVMFComponentFormatPairType, OsclMemAllocator> PVMFComponentFormatPairListType;

 /*
 ** A class containing information about the capability of a component.
 */
 class PVMFComponentCapability
 {
     public:
         PVMFComponentCapability()
         {}

         PVMFComponentCapability(const PVMFComponentCapability& s)
                 : iInputFormatCapability(s.iInputFormatCapability)
                 , iOutputFormatCapability(s.iOutputFormatCapability)
                 , iInputOutputFormatCapability(s.iInputOutputFormatCapability)
         {}

         /**
         ** Supported format information can be specified by lists of input
         ** and/or output format, or a list of input/output format pairs.
         */
         void AddInputFormat(const char* fmt)
         {
             iInputFormatCapability.push_back(PVMFComponentFormatType(fmt));
         }
         void AddOutputFormat(char* fmt)
         {
             iOutputFormatCapability.push_back(PVMFComponentFormatType(fmt));
         }
         void AddFormatPair(char* infmt, char* outfmt)
         {
             iInputOutputFormatCapability.push_back(PVMFComponentFormatPairType(infmt, outfmt));
         }

         Oscl_Vector<PVMFComponentFormatType, OsclMemAllocator> iInputFormatCapability;
         Oscl_Vector<PVMFComponentFormatType, OsclMemAllocator> iOutputFormatCapability;
         Oscl_Vector<PVMFComponentFormatPairType, OsclMemAllocator> iInputOutputFormatCapability;
 };

 /*
 ** Base class for component registration info.
 */
 class PVMFComponentRegistrationInfo
 {
     public:
         PVMFComponentRegistrationInfo()
         {
             iHasHardwareAssist = false;
             iQueryInterface = NULL;
         }

         PVMFComponentRegistrationInfo(const PVMFComponentRegistrationInfo& a)
                 : iUuid(a.iUuid)
                 , iMediaCategory(a.iMediaCategory)
                 , iComponentType(a.iComponentType)
                 , iCapability(a.iCapability)
                 , iHasHardwareAssist(a.iHasHardwareAssist)
                 , iQueryInterface(a.iQueryInterface)
         {
         }

         PVMFComponentRegistrationInfo(PVUuid& aUuid
                                       , char* aMediaCategory
                                       , char* aComponentType
                                       , PVMFComponentCapability& aCapability
                                       , bool aHasHardwareAssist
                                       , PVMFSimpleQueryInterface* aQueryInterface)
                 : iCapability(aCapability)
         {
             OSCL_UNUSED_ARG(aUuid);

             if (aMediaCategory)
                 iMediaCategory = aMediaCategory;
             if (aComponentType)
                 iComponentType = aComponentType;
             iHasHardwareAssist = aHasHardwareAssist;
             iQueryInterface = aQueryInterface;
         }


         /**
         ** Unique identifier
         */
         PVUuid iUuid;

         /**
         ** Media category, e.g. "audio", "video", "text", "image", "multi"
         */
         OSCL_HeapString<OsclMemAllocator> iMediaCategory;

         /**
         ** Hierarchical component type string, e.g. "source/capture", "source/file",
         **   "source/media_io",
         **   "file_parser/mpeg4", "codec/audio/aac", "codec/video/h263",
         **   "sink/file", "sink/render", "sink/media_io"
         */
         OSCL_HeapString<OsclMemAllocator> iComponentType;

         /**
         ** Component capability information
         */
         PVMFComponentCapability iCapability;

         /**
         ** Hardware assist flag.  Set to true if component may have hardware assist;
         **   set to false if component is pure software.
         */
         bool iHasHardwareAssist;

         /**
         ** Optional pointer to a simple query interface implementation for the component.
         */
         PVMFSimpleQueryInterface* iQueryInterface;

 };

 /*
 ** A class containing all data required to register a node.
 ** The node may be registered with either an implemenation instance,
 ** or a creation interface instance.
 */
 class PVMFNodeRegistrationInfo: public PVMFComponentRegistrationInfo
 {
     public:
         PVMFNodeRegistrationInfo()
         {
             iNodeInstance = NULL;
             iNodeCreationInterface = NULL;
         }
         PVMFNodeRegistrationInfo(const PVMFNodeRegistrationInfo& a)
                 : PVMFComponentRegistrationInfo(a)
                 , iNodeCreationInterface(a.iNodeCreationInterface)
                 , iNodeInstance(a.iNodeInstance)
         {}

         PVMFNodeRegistrationInfo(PVUuid& aUuid
                                  , char* aMediaCategory
                                  , char* aNodeType
                                  , PVMFComponentCapability& aCapability
                                  , bool aHasHardwareAssist
                                  , PVMFSimpleQueryInterface* aQueryInterface
                                  , PVMFNodeInterface& aNodeInstance)
                 : PVMFComponentRegistrationInfo(aUuid, aMediaCategory, aNodeType, aCapability, aHasHardwareAssist, aQueryInterface)
                 , iNodeInstance(&aNodeInstance)
         {
             iNodeCreationInterface = NULL;
         }

         PVMFNodeRegistrationInfo(PVUuid& aUuid
                                  , char* aMediaCategory
                                  , char* aNodeType
                                  , PVMFComponentCapability& aCapability
                                  , bool aHasHardwareAssist
                                  , PVMFSimpleQueryInterface* aQueryInterface
                                  , PVMFNodeCreationInterface& aNodeCreation)
                 : PVMFComponentRegistrationInfo(aUuid, aMediaCategory, aNodeType, aCapability, aHasHardwareAssist, aQueryInterface)
                 , iNodeCreationInterface(&aNodeCreation)
         {
             iNodeInstance = NULL;
         }


         /**
         ** Optional pointer to node creation implementation.  Nodes must register
         ** with either an instance pointer, or else a creation interface implementation.
         */
         PVMFNodeCreationInterface* iNodeCreationInterface;
         /**
         ** Optional pointer to node instance.  Nodes must register
         ** with either an instance pointer, or else a creation interface implementation.
         */
         PVMFNodeInterface* iNodeInstance;
 };


 /*
 ** A class containing all data required to register a media I/O component.
 ** The component may be registered with either an implemenation instance,
 ** or a creation interface instance.
 */
 class PVMFMediaIORegistrationInfo: public PVMFComponentRegistrationInfo
 {
     public:
         PVMFMediaIORegistrationInfo()
         {
             iMediaIOCreationInterface = NULL;
             iMediaIOInstance = NULL;
         }
         PVMFMediaIORegistrationInfo(const PVMFMediaIORegistrationInfo& a)
                 : PVMFComponentRegistrationInfo(a)
                 , iMediaIOCreationInterface(a.iMediaIOCreationInterface)
                 , iMediaIOInstance(a.iMediaIOInstance)
         {}

         PVMFMediaIORegistrationInfo(PVUuid& aUuid
                                     , char* aMediaCategory
                                     , char* aMediaIOType
                                     , PVMFComponentCapability& aCapability
                                     , bool aHasHardwareAssist
                                     , PVMFSimpleQueryInterface* aQueryInterface
                                     , PvmiMIOControl& aMediaIOInstance)
                 : PVMFComponentRegistrationInfo(aUuid, aMediaCategory, aMediaIOType, aCapability, aHasHardwareAssist, aQueryInterface)
                 , iMediaIOInstance(&aMediaIOInstance)
         {
             iMediaIOCreationInterface = NULL;
         }

         PVMFMediaIORegistrationInfo(PVUuid& aUuid
                                     , char* aMediaCategory
                                     , char* aMediaIOType
                                     , PVMFComponentCapability& aCapability
                                     , bool aHasHardwareAssist
                                     , PVMFSimpleQueryInterface* aQueryInterface
                                     , PVMFMediaIOCreationInterface& aMediaIOCreation)
                 : PVMFComponentRegistrationInfo(aUuid, aMediaCategory, aMediaIOType, aCapability, aHasHardwareAssist, aQueryInterface)
                 , iMediaIOCreationInterface(&aMediaIOCreation)
         {
             iMediaIOInstance = NULL;
         }


         /**
         ** Optional pointer to Media I/O creation implementation.  Components must register
         ** with either an instance pointer, or else a creation interface implementation.
         */
         PVMFMediaIOCreationInterface* iMediaIOCreationInterface;
         /**
         ** Optional pointer to Media I/O control instance.  Components must register
         ** with either an instance pointer, or else a creation interface implementation.
         */
         PvmiMIOControl* iMediaIOInstance;
 };


 typedef uint32 PVMFRegistryIdType;

 /*
 ** Base class for component registry entries.
 */
 class PVMFComponentRegistryEntry
 {
     public:
         //match category, type, and formats.
         bool Match(char* aMediaCategory = NULL
                                           , char* aComponentType = NULL
                                                                    , char* aInputFormat = NULL
                                                                                           , char* aOutputFormat = NULL);

         //match individual items.
         bool MatchMediaCategory(char* m);
         bool MatchComponentType(char* m);
         bool MatchFormat(char* in, char* out);
         bool MatchUuid(PVUuid&);

     protected:

         PVMFComponentRegistryEntry(PVMFComponentRegistrationInfo &aInfo
                                    , PVMFRegistryIdType aId)
                 : iInfo(aInfo)
                 , iId(aId)
         {}

         ~PVMFComponentRegistryEntry();

         //The component registration info.
         PVMFComponentRegistrationInfo& iInfo;

         //Component ID assigned during registration.
         PVMFRegistryIdType iId;

     private:
         static bool matchFormat(PVMFComponentFormatType&, PVMFComponentFormatListType&);
         static bool matchFormatPair(PVMFComponentFormatType&, PVMFComponentFormatType&, PVMFComponentFormatPairListType&);
         static bool matchInputFormat(PVMFComponentFormatType&, PVMFComponentFormatPairListType&);
         static bool matchOutputFormat(PVMFComponentFormatType&, PVMFComponentFormatPairListType&);

 };


 /*
 ** A class defining the node registry entries.
 */
 class PVMFNodeRegistryEntry: public PVMFComponentRegistryEntry
 {
     public:
         /*
         ** Methods to create and release a node instance
         ** for this entry.
         ** The Get and Release calls must be balanced.
         ** @param aParam: optional param to pass to CreateNode.
         */
         OSCL_IMPORT_REF PVMFNodeInterface* GetNodeInstance(OsclAny*aParam = NULL);
         OSCL_IMPORT_REF void ReleaseNodeInstance(PVMFNodeInterface*);

         /**
         ** For accessing the registration data
         */
         const PVMFNodeRegistrationInfo& Info()const
         {
             return iInfo;
         }

     private:
         friend class PVMFNodeRegistry;

         PVMFNodeRegistryEntry(PVMFNodeRegistrationInfo& aInfo
                               , PVMFRegistryIdType aId)
                 : PVMFComponentRegistryEntry(iInfo, aId)
                 , iInfo(aInfo)
         {}

         PVMFNodeRegistrationInfo iInfo;

 };

 /*
 ** A class defining the Media I/O registry entries.
 */
 class PVMFMediaIORegistryEntry: public PVMFComponentRegistryEntry
 {
     public:
         /*
         ** Methods to create and release a Media I/O instance
         ** for this entry.
         ** The Get and Release calls must be balanced.
         ** @param: optional param to pass to CreateMediaIO
         */
         OSCL_IMPORT_REF PvmiMIOControl* GetMediaIOInstance(OsclAny*aParam = NULL);
         OSCL_IMPORT_REF void ReleaseMediaIOInstance(PvmiMIOControl*);

         /**
         ** For accessing the registration data
         */
         const PVMFMediaIORegistrationInfo& Info()const
         {
             return iInfo;
         }

     private:
         friend class PVMFMediaIORegistry;

         PVMFMediaIORegistryEntry(PVMFMediaIORegistrationInfo& aInfo
                                  , PVMFRegistryIdType aId)
                 : PVMFComponentRegistryEntry(iInfo, aId)
                 , iInfo(aInfo)
         {}

         PVMFMediaIORegistrationInfo iInfo;

 };


 /*
 ** The node registry
 */


 typedef Oscl_Vector<PVMFNodeRegistryEntry*, OsclMemAllocator> PVMFNodeList;

 class PVMFNodeRegistry
 {
     public:
         OSCL_IMPORT_REF PVMFNodeRegistry();
         OSCL_IMPORT_REF ~PVMFNodeRegistry();

         /*
         ** Method to register a node.
         ** @param: the node entry.
         ** @return: the registry ID.
         */
         OSCL_IMPORT_REF PVMFRegistryIdType RegisterNode(PVMFNodeRegistrationInfo &entry);

         /*
         ** Method to unregister a node.
         ** @param: registry ID of the node
         */
         OSCL_IMPORT_REF void UnregisterNode(PVMFRegistryIdType);

         /*
         ** Method to unregister all nodes.
         */
         OSCL_IMPORT_REF void Clear();

         /*
         ** Method to find all entries that match a given criteria.
         ** Input parameters are used to filter the search.  Any
         ** input that is NULL will be ignored.
         ** @param aMatchList(output): list of components that satisfy the query.
         ** @param aMediaCategory(input): media category string
         ** @param aComponentType(input): media component type string
         ** @param aInputFormat(input): input format
         ** @param aOutputFormat(input): output format
         */
         OSCL_IMPORT_REF void Find(PVMFNodeList& aMatchList
                                   , char* aMediaCategory = NULL
                                                            , char* aComponentType = NULL
                                                                                     , char* aInputFormat = NULL
                                                                                                            , char* aOutputFormat = NULL);

         OSCL_IMPORT_REF void Find(PVMFNodeList& aMatchList
                                   , PVUuid& aUuid);

         /*
         ** For direct access to the node list
         */
         PVMFNodeList& NodeList()
         {
             return iNodeList;
         }

     private:
         PVMFRegistryIdType iIdCounter;

         PVMFNodeList iNodeList;

 };

 /*
 ** The media I/O registry
 */

 typedef Oscl_Vector<PVMFMediaIORegistryEntry*, OsclMemAllocator> PVMFMediaIOList;

 class PVMFMediaIORegistry
 {
     public:
         OSCL_IMPORT_REF PVMFMediaIORegistry();
         OSCL_IMPORT_REF ~PVMFMediaIORegistry();

         /*
         ** Method to register a Media I/O component
         ** @param: the media I/O component entry.
         ** @return: the registry ID.
         */
         OSCL_IMPORT_REF PVMFRegistryIdType RegisterMediaIO(PVMFMediaIORegistrationInfo& entry);

         /*
         ** Method to unregister a Media I/O component.
         ** @param: registry ID of the component
         */
         OSCL_IMPORT_REF void UnregisterMediaIO(PVMFRegistryIdType aId);

         /*
         ** Method to unregister all components.
         */
         OSCL_IMPORT_REF void Clear();

         /*
         ** Method to find all entries that match a given criteria.
         ** Input parameters are used to filter the search.  Any
         ** input that is NULL will be ignored.
         ** @param aMatchList(output): list of components that satisfy the query.
         ** @param aMediaCategory(input): media category string
         ** @param aComponentType(input): media component type string
         ** @param aInputFormat(input): input format
         ** @param aOutputFormat(input): output format
         */
         OSCL_IMPORT_REF void Find(PVMFMediaIOList& aMatchList
                                   , char* aMediaCategory = NULL
                                                            , char* aComponentType = NULL
                                                                                     , char* aInputFormat = NULL
                                                                                                            , char* aOutputFormat = NULL);

         OSCL_IMPORT_REF void Find(PVMFMediaIOList& aMatchList
                                   , PVUuid& aUuid);

         /*
         ** For direct access to the component list
         */
         PVMFMediaIOList& MediaIOList()
         {
             return iMediaIOList;
         }

     private:
         PVMFRegistryIdType iIdCounter;

         PVMFMediaIOList iMediaIOList;

 };

 #endif //PVMF_NODE_REGSITRY_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.
	* -------------------------------------------------------------------
	*/
	// -- c++ --
	// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

	// P V M F _ N O D E _ R E G I S T R Y

	// = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =

	/*! \addtogroup pvmfnoderegistry PVMFNodeRegistry
	*
	* @{
	*/


	/*! \file pvmf_node_registry.h
	\brief This file contains the declarations for the node registry.
	*/

	#ifndef PVMF_NODE_REGSITRY_H_INCLUDED
	#define PVMF_NODE_REGSITRY_H_INCLUDED

	#include "pv_interface.h"
	#include "pv_uuid.h"
	#include "pvmf_event_handling.h"
	#include "oscl_vector.h"
	#include "pvmf_format_type.h"
	#include "oscl_string_containers.h"

	class PVMFNodeInterface;
	class PvmiMIOControl;


	/*
	** An abstract interface class containing a function
	** to do a synchronous interface query.
	** Each registered component must support this interface.
	*/
	typedef PVInterface PVMFSimpleQueryInterface ;


	/*
	** An abstract interface class containing methods
	** to create and release a PVMF node.
	*/
	class PVMFNodeCreationInterface
	{
	public:
	/** Virtual destructor
	** need to be defined to avoid compiler warnings
	**/
	virtual ~PVMFNodeCreationInterface() {}

	/**
	** Create a node instance. May throw an exception if
	** node creation fails due to out-of-memory condition or other error.
	**
	** @param aParam optional opaque data to be passed to node constructor.
	** @return pointer to the node.
	*/
	virtual PVMFNodeInterface* CreateNode(OsclAny* aParam = NULL) = 0;

	/**
	** Relese a node instance previously created with CreateNode.
	**
	** @param aNode (input): the node instance.
	*/
	virtual void ReleaseNode(PVMFNodeInterface* aNode) = 0;
	};

	/*
	** An abstract interface class containing methods
	** to create and release a Media I/O component.
	*/
	class PVMFMediaIOCreationInterface
	{
	public:
	/** Virtual destructor
	** need to be defined to avoid compiler warnings
	**/
	virtual ~PVMFMediaIOCreationInterface() {}
	/**
	** Create a Media I/O component instance. May throw an exception if
	** creation fails due to out-of-memory condition or other error.
	**
	** @param aParam: optional opaque data to pass the MIO constructor.
	** @return pointer to the component.
	*/
	virtual PvmiMIOControl* CreateMediaIO(OsclAny*aParam = NULL) = 0;

	/**
	** Relese a Media I/O component instance previously created with CreateMediaIO.
	**
	** @param aMediaIO (input): the media I/O instance.
	*/
	virtual void ReleaseMediaIO(PvmiMIOControl* aMediaIO) = 0;
	};



	/*
	** A class to encapsulate PVMF media format information.
	** The media format is a MIME string, such as audio/compressed/amr
	*/
	class PVMFComponentFormatType
	{
	public:
	OSCL_IMPORT_REF PVMFComponentFormatType(const char*aFmtStr);

	PVMFComponentFormatType(const PVMFComponentFormatType& s)
	{
	iFormatType = s.iFormatType;
	iFormatString = s.iFormatString;
	}

	OSCL_HeapString<OsclMemAllocator> iFormatString;
	PVMFFormatType iFormatType;

	OSCL_IMPORT_REF bool operator== (const PVMFComponentFormatType& src) const;

	};


	/*
	** A class to encapsulate PVMF media format pair information.
	** A format pair consists of an input format and an output format.
	*/
	class PVMFComponentFormatPairType
	{
	public:
	PVMFComponentFormatPairType(char* input
	, char* output)
	: iInputFormat(PVMFComponentFormatType(input))
	, iOutputFormat(PVMFComponentFormatType(output))
	{}
	PVMFComponentFormatPairType(PVMFComponentFormatType& input
	, PVMFComponentFormatType& output)
	: iInputFormat(input)
	, iOutputFormat(output)
	{}

	PVMFComponentFormatPairType(const PVMFComponentFormatPairType& s)
	: iInputFormat(s.iInputFormat)
	, iOutputFormat(s.iOutputFormat)
	{}

	PVMFComponentFormatType iInputFormat;
	PVMFComponentFormatType iOutputFormat;
	};

	/*
	** Format list types.
	*/
	typedef Oscl_Vector<PVMFComponentFormatType, OsclMemAllocator> PVMFComponentFormatListType;
	typedef Oscl_Vector<PVMFComponentFormatPairType, OsclMemAllocator> PVMFComponentFormatPairListType;

	/*
	** A class containing information about the capability of a component.
	*/
	class PVMFComponentCapability
	{
	public:
	PVMFComponentCapability()
	{}

	PVMFComponentCapability(const PVMFComponentCapability& s)
	: iInputFormatCapability(s.iInputFormatCapability)
	, iOutputFormatCapability(s.iOutputFormatCapability)
	, iInputOutputFormatCapability(s.iInputOutputFormatCapability)
	{}

	/**
	** Supported format information can be specified by lists of input
	** and/or output format, or a list of input/output format pairs.
	*/
	void AddInputFormat(const char* fmt)
	{
	iInputFormatCapability.push_back(PVMFComponentFormatType(fmt));
	}
	void AddOutputFormat(char* fmt)
	{
	iOutputFormatCapability.push_back(PVMFComponentFormatType(fmt));
	}
	void AddFormatPair(char* infmt, char* outfmt)
	{
	iInputOutputFormatCapability.push_back(PVMFComponentFormatPairType(infmt, outfmt));
	}

	Oscl_Vector<PVMFComponentFormatType, OsclMemAllocator> iInputFormatCapability;
	Oscl_Vector<PVMFComponentFormatType, OsclMemAllocator> iOutputFormatCapability;
	Oscl_Vector<PVMFComponentFormatPairType, OsclMemAllocator> iInputOutputFormatCapability;
	};

	/*
	** Base class for component registration info.
	*/
	class PVMFComponentRegistrationInfo
	{
	public:
	PVMFComponentRegistrationInfo()
	{
	iHasHardwareAssist = false;
	iQueryInterface = NULL;
	}

	PVMFComponentRegistrationInfo(const PVMFComponentRegistrationInfo& a)
	: iUuid(a.iUuid)
	, iMediaCategory(a.iMediaCategory)
	, iComponentType(a.iComponentType)
	, iCapability(a.iCapability)
	, iHasHardwareAssist(a.iHasHardwareAssist)
	, iQueryInterface(a.iQueryInterface)
	{
	}

	PVMFComponentRegistrationInfo(PVUuid& aUuid
	, char* aMediaCategory
	, char* aComponentType
	, PVMFComponentCapability& aCapability
	, bool aHasHardwareAssist
	, PVMFSimpleQueryInterface* aQueryInterface)
	: iCapability(aCapability)
	{
	OSCL_UNUSED_ARG(aUuid);

	if (aMediaCategory)
	iMediaCategory = aMediaCategory;
	if (aComponentType)
	iComponentType = aComponentType;
	iHasHardwareAssist = aHasHardwareAssist;
	iQueryInterface = aQueryInterface;
	}


	/**
	** Unique identifier
	*/
	PVUuid iUuid;

	/**
	** Media category, e.g. "audio", "video", "text", "image", "multi"
	*/
	OSCL_HeapString<OsclMemAllocator> iMediaCategory;

	/**
	** Hierarchical component type string, e.g. "source/capture", "source/file",
	** "source/media_io",
	** "file_parser/mpeg4", "codec/audio/aac", "codec/video/h263",
	** "sink/file", "sink/render", "sink/media_io"
	*/
	OSCL_HeapString<OsclMemAllocator> iComponentType;

	/**
	** Component capability information
	*/
	PVMFComponentCapability iCapability;

	/**
	** Hardware assist flag. Set to true if component may have hardware assist;
	** set to false if component is pure software.
	*/
	bool iHasHardwareAssist;

	/**
	** Optional pointer to a simple query interface implementation for the component.
	*/
	PVMFSimpleQueryInterface* iQueryInterface;

	};

	/*
	** A class containing all data required to register a node.
	** The node may be registered with either an implemenation instance,
	** or a creation interface instance.
	*/
	class PVMFNodeRegistrationInfo: public PVMFComponentRegistrationInfo
	{
	public:
	PVMFNodeRegistrationInfo()
	{
	iNodeInstance = NULL;
	iNodeCreationInterface = NULL;
	}
	PVMFNodeRegistrationInfo(const PVMFNodeRegistrationInfo& a)
	: PVMFComponentRegistrationInfo(a)
	, iNodeCreationInterface(a.iNodeCreationInterface)
	, iNodeInstance(a.iNodeInstance)
	{}

	PVMFNodeRegistrationInfo(PVUuid& aUuid
	, char* aMediaCategory
	, char* aNodeType
	, PVMFComponentCapability& aCapability
	, bool aHasHardwareAssist
	, PVMFSimpleQueryInterface* aQueryInterface
	, PVMFNodeInterface& aNodeInstance)
	: PVMFComponentRegistrationInfo(aUuid, aMediaCategory, aNodeType, aCapability, aHasHardwareAssist, aQueryInterface)
	, iNodeInstance(&aNodeInstance)
	{
	iNodeCreationInterface = NULL;
	}

	PVMFNodeRegistrationInfo(PVUuid& aUuid
	, char* aMediaCategory
	, char* aNodeType
	, PVMFComponentCapability& aCapability
	, bool aHasHardwareAssist
	, PVMFSimpleQueryInterface* aQueryInterface
	, PVMFNodeCreationInterface& aNodeCreation)
	: PVMFComponentRegistrationInfo(aUuid, aMediaCategory, aNodeType, aCapability, aHasHardwareAssist, aQueryInterface)
	, iNodeCreationInterface(&aNodeCreation)
	{
	iNodeInstance = NULL;
	}


	/**
	** Optional pointer to node creation implementation. Nodes must register
	** with either an instance pointer, or else a creation interface implementation.
	*/
	PVMFNodeCreationInterface* iNodeCreationInterface;
	/**
	** Optional pointer to node instance. Nodes must register
	** with either an instance pointer, or else a creation interface implementation.
	*/
	PVMFNodeInterface* iNodeInstance;
	};


	/*
	** A class containing all data required to register a media I/O component.
	** The component may be registered with either an implemenation instance,
	** or a creation interface instance.
	*/
	class PVMFMediaIORegistrationInfo: public PVMFComponentRegistrationInfo
	{
	public:
	PVMFMediaIORegistrationInfo()
	{
	iMediaIOCreationInterface = NULL;
	iMediaIOInstance = NULL;
	}
	PVMFMediaIORegistrationInfo(const PVMFMediaIORegistrationInfo& a)
	: PVMFComponentRegistrationInfo(a)
	, iMediaIOCreationInterface(a.iMediaIOCreationInterface)
	, iMediaIOInstance(a.iMediaIOInstance)
	{}

	PVMFMediaIORegistrationInfo(PVUuid& aUuid
	, char* aMediaCategory
	, char* aMediaIOType
	, PVMFComponentCapability& aCapability
	, bool aHasHardwareAssist
	, PVMFSimpleQueryInterface* aQueryInterface
	, PvmiMIOControl& aMediaIOInstance)
	: PVMFComponentRegistrationInfo(aUuid, aMediaCategory, aMediaIOType, aCapability, aHasHardwareAssist, aQueryInterface)
	, iMediaIOInstance(&aMediaIOInstance)
	{
	iMediaIOCreationInterface = NULL;
	}

	PVMFMediaIORegistrationInfo(PVUuid& aUuid
	, char* aMediaCategory
	, char* aMediaIOType
	, PVMFComponentCapability& aCapability
	, bool aHasHardwareAssist
	, PVMFSimpleQueryInterface* aQueryInterface
	, PVMFMediaIOCreationInterface& aMediaIOCreation)
	: PVMFComponentRegistrationInfo(aUuid, aMediaCategory, aMediaIOType, aCapability, aHasHardwareAssist, aQueryInterface)
	, iMediaIOCreationInterface(&aMediaIOCreation)
	{
	iMediaIOInstance = NULL;
	}


	/**
	** Optional pointer to Media I/O creation implementation. Components must register
	** with either an instance pointer, or else a creation interface implementation.
	*/
	PVMFMediaIOCreationInterface* iMediaIOCreationInterface;
	/**
	** Optional pointer to Media I/O control instance. Components must register
	** with either an instance pointer, or else a creation interface implementation.
	*/
	PvmiMIOControl* iMediaIOInstance;
	};


	typedef uint32 PVMFRegistryIdType;

	/*
	** Base class for component registry entries.
	*/
	class PVMFComponentRegistryEntry
	{
	public:
	//match category, type, and formats.
	bool Match(char* aMediaCategory = NULL
	, char* aComponentType = NULL
	, char* aInputFormat = NULL
	, char* aOutputFormat = NULL);

	//match individual items.
	bool MatchMediaCategory(char* m);
	bool MatchComponentType(char* m);
	bool MatchFormat(char* in, char* out);
	bool MatchUuid(PVUuid&);

	protected:

	PVMFComponentRegistryEntry(PVMFComponentRegistrationInfo &aInfo
	, PVMFRegistryIdType aId)
	: iInfo(aInfo)
	, iId(aId)
	{}

	~PVMFComponentRegistryEntry();

	//The component registration info.
	PVMFComponentRegistrationInfo& iInfo;

	//Component ID assigned during registration.
	PVMFRegistryIdType iId;

	private:
	static bool matchFormat(PVMFComponentFormatType&, PVMFComponentFormatListType&);
	static bool matchFormatPair(PVMFComponentFormatType&, PVMFComponentFormatType&, PVMFComponentFormatPairListType&);
	static bool matchInputFormat(PVMFComponentFormatType&, PVMFComponentFormatPairListType&);
	static bool matchOutputFormat(PVMFComponentFormatType&, PVMFComponentFormatPairListType&);

	};


	/*
	** A class defining the node registry entries.
	*/
	class PVMFNodeRegistryEntry: public PVMFComponentRegistryEntry
	{
	public:
	/*
	** Methods to create and release a node instance
	** for this entry.
	** The Get and Release calls must be balanced.
	** @param aParam: optional param to pass to CreateNode.
	*/
	OSCL_IMPORT_REF PVMFNodeInterface* GetNodeInstance(OsclAny*aParam = NULL);
	OSCL_IMPORT_REF void ReleaseNodeInstance(PVMFNodeInterface*);

	/**
	** For accessing the registration data
	*/
	const PVMFNodeRegistrationInfo& Info()const
	{
	return iInfo;
	}

	private:
	friend class PVMFNodeRegistry;

	PVMFNodeRegistryEntry(PVMFNodeRegistrationInfo& aInfo
	, PVMFRegistryIdType aId)
	: PVMFComponentRegistryEntry(iInfo, aId)
	, iInfo(aInfo)
	{}

	PVMFNodeRegistrationInfo iInfo;

	};

	/*
	** A class defining the Media I/O registry entries.
	*/
	class PVMFMediaIORegistryEntry: public PVMFComponentRegistryEntry
	{
	public:
	/*
	** Methods to create and release a Media I/O instance
	** for this entry.
	** The Get and Release calls must be balanced.
	** @param: optional param to pass to CreateMediaIO
	*/
	OSCL_IMPORT_REF PvmiMIOControl* GetMediaIOInstance(OsclAny*aParam = NULL);
	OSCL_IMPORT_REF void ReleaseMediaIOInstance(PvmiMIOControl*);

	/**
	** For accessing the registration data
	*/
	const PVMFMediaIORegistrationInfo& Info()const
	{
	return iInfo;
	}

	private:
	friend class PVMFMediaIORegistry;

	PVMFMediaIORegistryEntry(PVMFMediaIORegistrationInfo& aInfo
	, PVMFRegistryIdType aId)
	: PVMFComponentRegistryEntry(iInfo, aId)
	, iInfo(aInfo)
	{}

	PVMFMediaIORegistrationInfo iInfo;

	};


	/*
	** The node registry
	*/


	typedef Oscl_Vector<PVMFNodeRegistryEntry*, OsclMemAllocator> PVMFNodeList;

	class PVMFNodeRegistry
	{
	public:
	OSCL_IMPORT_REF PVMFNodeRegistry();
	OSCL_IMPORT_REF ~PVMFNodeRegistry();

	/*
	** Method to register a node.
	** @param: the node entry.
	** @return: the registry ID.
	*/
	OSCL_IMPORT_REF PVMFRegistryIdType RegisterNode(PVMFNodeRegistrationInfo &entry);

	/*
	** Method to unregister a node.
	** @param: registry ID of the node
	*/
	OSCL_IMPORT_REF void UnregisterNode(PVMFRegistryIdType);

	/*
	** Method to unregister all nodes.
	*/
	OSCL_IMPORT_REF void Clear();

	/*
	** Method to find all entries that match a given criteria.
	** Input parameters are used to filter the search. Any
	** input that is NULL will be ignored.
	** @param aMatchList(output): list of components that satisfy the query.
	** @param aMediaCategory(input): media category string
	** @param aComponentType(input): media component type string
	** @param aInputFormat(input): input format
	** @param aOutputFormat(input): output format
	*/
	OSCL_IMPORT_REF void Find(PVMFNodeList& aMatchList
	, char* aMediaCategory = NULL
	, char* aComponentType = NULL
	, char* aInputFormat = NULL
	, char* aOutputFormat = NULL);

	OSCL_IMPORT_REF void Find(PVMFNodeList& aMatchList
	, PVUuid& aUuid);

	/*
	** For direct access to the node list
	*/
	PVMFNodeList& NodeList()
	{
	return iNodeList;
	}

	private:
	PVMFRegistryIdType iIdCounter;

	PVMFNodeList iNodeList;

	};

	/*
	** The media I/O registry
	*/

	typedef Oscl_Vector<PVMFMediaIORegistryEntry*, OsclMemAllocator> PVMFMediaIOList;

	class PVMFMediaIORegistry
	{
	public:
	OSCL_IMPORT_REF PVMFMediaIORegistry();
	OSCL_IMPORT_REF ~PVMFMediaIORegistry();

	/*
	** Method to register a Media I/O component
	** @param: the media I/O component entry.
	** @return: the registry ID.
	*/
	OSCL_IMPORT_REF PVMFRegistryIdType RegisterMediaIO(PVMFMediaIORegistrationInfo& entry);

	/*
	** Method to unregister a Media I/O component.
	** @param: registry ID of the component
	*/
	OSCL_IMPORT_REF void UnregisterMediaIO(PVMFRegistryIdType aId);

	/*
	** Method to unregister all components.
	*/
	OSCL_IMPORT_REF void Clear();

	/*
	** Method to find all entries that match a given criteria.
	** Input parameters are used to filter the search. Any
	** input that is NULL will be ignored.
	** @param aMatchList(output): list of components that satisfy the query.
	** @param aMediaCategory(input): media category string
	** @param aComponentType(input): media component type string
	** @param aInputFormat(input): input format
	** @param aOutputFormat(input): output format
	*/
	OSCL_IMPORT_REF void Find(PVMFMediaIOList& aMatchList
	, char* aMediaCategory = NULL
	, char* aComponentType = NULL
	, char* aInputFormat = NULL
	, char* aOutputFormat = NULL);

	OSCL_IMPORT_REF void Find(PVMFMediaIOList& aMatchList
	, PVUuid& aUuid);

	/*
	** For direct access to the component list
	*/
	PVMFMediaIOList& MediaIOList()
	{
	return iMediaIOList;
	}

	private:
	PVMFRegistryIdType iIdCounter;

	PVMFMediaIOList iMediaIOList;

	};

	#endif //PVMF_NODE_REGSITRY_H_INCLUDED