h323caps.h

Go to the documentation of this file.

/*
 * h323caps.h
 *
 * H.323 protocol handler
 *
 * Open H323 Library
 *
 * Copyright (c) 1998-2001 Equivalence Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open H323 Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Portions of this code were written with the assisance of funding from
 * Vovida Networks, Inc. http://www.vovida.com.
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 30205 $
 * $Author: rjongbloed $
 * $Date: 2013-07-31 10:33:53 +1000 (Wed, 31 Jul 2013) $
 */

#ifndef OPAL_H323_H323CAPS_H
#define OPAL_H323_H323CAPS_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal/buildopts.h>

#if OPAL_H323

#include <opal/mediafmt.h>
#include <h323/channels.h>


/* The following classes have forward references to avoid including the VERY
   large header files for H225 and H245. If an application requires access
   to the protocol classes they can include them, but for simple usage their
   inclusion can be avoided.
 */
class PASN_Choice;
class H245_Capability;
class H245_DataType;
class H245_ModeElement;
class H245_AudioCapability;
class H245_AudioMode;
class H245_VideoCapability;
class H245_VideoMode;
class H245_DataApplicationCapability;
class H245_DataMode;
class H245_DataProtocolCapability;
class H245_H2250LogicalChannelParameters;
class H245_TerminalCapabilitySet;
class H245_NonStandardParameter;
class H323Connection;
class H323Capabilities;
class H245_CapabilityIdentifier;
class H245_GenericCapability;
class H245_GenericParameter;


#if OPAL_H239
  const OpalMediaFormat & GetH239VideoMediaFormat();
#endif



class H323Capability : public PObject
{
  PCLASSINFO(H323Capability, PObject);

  public:
    H323Capability();

    Comparison Compare(const PObject & obj) const;

    void PrintOn(ostream & strm) const;

    enum MainTypes {
      e_Audio,
      e_Video,
      e_Data,
      e_UserInput,
      e_GenericControl,
      e_NumMainTypes
    };

    virtual MainTypes GetMainType() const = 0;

    virtual unsigned  GetSubType()  const = 0;

    virtual PString GetFormatName() const = 0;

    static H323Capability * Create(
      const PString & name     
    );

    enum {
      DefaultAudioSessionID = 1,
      DefaultVideoSessionID = 2,
      DefaultDataSessionID  = 3,
      DefaultH224SessionID  = 4
    };

    virtual unsigned GetDefaultSessionID() const;

    virtual void SetTxFramesInPacket(
      unsigned frames   
    );

    virtual unsigned GetTxFramesInPacket() const;

    virtual unsigned GetRxFramesInPacket() const;

    virtual H323Channel * CreateChannel(
      H323Connection & connection,    
      H323Channel::Directions dir,    
      unsigned sessionID,             
      const H245_H2250LogicalChannelParameters * param
    ) const = 0;

    enum CommandType {
      e_TCS,
      e_OLC,
      e_ReqMode
    };

    virtual PBoolean OnSendingPDU(
      H245_Capability & pdu  
    ) const = 0;

    virtual PBoolean OnSendingPDU(
      H245_DataType & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_ModeElement & pdu  
    ) const = 0;

    virtual PBoolean OnReceivedPDU(
      const H245_Capability & pdu 
    );

    virtual PBoolean OnReceivedPDU(
      const H245_DataType & pdu,  
      PBoolean receiver               
    );

    virtual PBoolean IsMatch(
      const PASN_Choice & subTypePDU,     
      const PString & mediaPacketization  
    ) const;

    virtual PBoolean IsUsable(
      const H323Connection & connection
    ) const;

    enum CapabilityDirection {
      e_Unknown,
      e_Receive,            
      e_Transmit,           
      e_ReceiveAndTransmit, 
      e_NoDirection,        
      NumCapabilityDirections
    };

    CapabilityDirection GetCapabilityDirection() const { return capabilityDirection; }

    void SetCapabilityDirection(
      CapabilityDirection dir   
    ) { capabilityDirection = dir; }

    unsigned GetCapabilityNumber() const { return assignedCapabilityNumber; }

    void SetCapabilityNumber(unsigned num) { assignedCapabilityNumber = num; }

    OpalMediaFormat GetMediaFormat() const;

    bool UpdateMediaFormat(
      const OpalMediaFormat & format
    );

    RTP_DataFrame::PayloadTypes GetPayloadType() const { return GetMediaFormat().GetPayloadType(); }

    void SetPayloadType(RTP_DataFrame::PayloadTypes pt) { GetWritableMediaFormat().SetPayloadType(pt); }

#if PTRACING
    friend ostream & operator<<(ostream & o , MainTypes t);
    friend ostream & operator<<(ostream & o , CapabilityDirection d);
#endif

  protected:
    OpalMediaFormat & GetWritableMediaFormat() const;

    unsigned            assignedCapabilityNumber;  
    CapabilityDirection capabilityDirection;

    mutable OpalMediaFormat m_mediaFormat;

  private:
    P_REMOVE_VIRTUAL(PBoolean, IsMatch(const PASN_Choice &) const, false);

  friend class H323Capabilities;
};



class H323NonStandardCapabilityInfo
{
  public:
    typedef PObject::Comparison (*CompareFuncType)(struct PluginCodec_H323NonStandardCodecData *);

    H323NonStandardCapabilityInfo(
      CompareFuncType compareFunc,
      const BYTE * dataBlock,         
      PINDEX dataSize                 
    );

    H323NonStandardCapabilityInfo(
      const BYTE * dataBlock,         
      PINDEX dataSize,                
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    H323NonStandardCapabilityInfo(
      const PString & oid,
      const BYTE * dataBlock,         
      PINDEX dataSize,                
      PINDEX comparisonOffset = 0,
      PINDEX comparisonLength = P_MAX_INDEX
    );

    H323NonStandardCapabilityInfo(
      BYTE country,                  
      BYTE extension,                
      WORD maufacturer,              
      const BYTE * dataBlock,         
      PINDEX dataSize,                
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    virtual ~H323NonStandardCapabilityInfo();

    virtual PBoolean OnSendingPDU(
      PBYTEArray & data  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const PBYTEArray & data  
    );

    PBoolean IsMatch(const H245_NonStandardParameter & param) const;

    PObject::Comparison CompareParam(
      const H245_NonStandardParameter & param
    ) const;

  protected:
    PBoolean OnSendingNonStandardPDU(
      PASN_Choice & pdu,
      unsigned nonStandardTag
    ) const;
    PBoolean OnReceivedNonStandardPDU(
      const PASN_Choice & pdu,
      unsigned nonStandardTag
    );

    PObject::Comparison CompareInfo(
      const H323NonStandardCapabilityInfo & obj
    ) const;
    PObject::Comparison CompareData(
      const PBYTEArray & data  
    ) const;

    PString    oid;
    BYTE       t35CountryCode;
    BYTE       t35Extension;
    WORD       manufacturerCode;
    PBYTEArray nonStandardData;
    PINDEX     comparisonOffset;
    PINDEX     comparisonLength;
    CompareFuncType compareFunc;
};

class H323GenericCapabilityInfo
{
  public:
    H323GenericCapabilityInfo(
      const PString & id,     
      unsigned maxBitRate,    
      bool fixedBitRate
    );

    virtual ~H323GenericCapabilityInfo() { }

  protected:
    virtual PBoolean OnSendingGenericPDU(
      H245_GenericCapability & pdu,
      const OpalMediaFormat & mediaFormat,
      H323Capability::CommandType type
    ) const;
    virtual PBoolean OnReceivedGenericPDU(
      OpalMediaFormat & mediaFormat,
      const H245_GenericCapability & pdu,
      H323Capability::CommandType type
    );

    PBoolean IsMatch(
      const OpalMediaFormat & mediaFormat,
      const H245_GenericCapability & param  
    ) const;
    PObject::Comparison CompareInfo(
      const H323GenericCapabilityInfo & obj
    ) const;


    PString  m_identifier;
    unsigned m_maxBitRate;
    bool     m_fixedBitRate;
};

class H323RealTimeCapability : public H323Capability
{
  PCLASSINFO(H323RealTimeCapability, H323Capability);

  public:
    virtual H323Channel * CreateChannel(
      H323Connection & connection,    
      H323Channel::Directions dir,    
      unsigned sessionID,             
      const H245_H2250LogicalChannelParameters * param
    ) const;

    H323RealTimeCapability();
    H323RealTimeCapability(const H323RealTimeCapability &rtc);
    virtual ~H323RealTimeCapability();
};


class H323AudioCapability : public H323RealTimeCapability
{
  PCLASSINFO(H323AudioCapability, H323RealTimeCapability);

  public:
    H323AudioCapability();

    virtual MainTypes GetMainType() const;

    virtual unsigned GetDefaultSessionID() const;

    virtual void SetTxFramesInPacket(
      unsigned frames   
    );

    virtual unsigned GetTxFramesInPacket() const;

    virtual unsigned GetRxFramesInPacket() const;

    virtual PBoolean OnSendingPDU(
      H245_Capability & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_DataType & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_ModeElement & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_AudioCapability & pdu,  
      unsigned packetSize          
    ) const;
    virtual PBoolean OnSendingPDU(
      H245_AudioCapability & pdu,  
      unsigned packetSize,         
      CommandType type             
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_AudioMode & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_Capability & pdu  
    );

    virtual PBoolean OnReceivedPDU(
      const H245_DataType & pdu,  
      PBoolean receiver               
    );

    virtual PBoolean OnReceivedPDU(
      const H245_AudioCapability & pdu,  
      unsigned & packetSize              
    );
    virtual PBoolean OnReceivedPDU(
      const H245_AudioCapability & pdu,  
      unsigned & packetSize,             
      CommandType type                   
    );
};


class H323NonStandardAudioCapability : public H323AudioCapability,
                                       public H323NonStandardCapabilityInfo
{
  PCLASSINFO(H323NonStandardAudioCapability, H323AudioCapability);

  public:
    H323NonStandardAudioCapability(
      H323NonStandardCapabilityInfo::CompareFuncType compareFunc,
      const BYTE * dataBlock,         
      PINDEX dataSize                 
    );
    H323NonStandardAudioCapability(
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
     );

    H323NonStandardAudioCapability(
      const PString & oid,            
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    H323NonStandardAudioCapability(
      BYTE country,                   
      BYTE extension,                 
      WORD maufacturer,               
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    Comparison Compare(const PObject & obj) const;

    virtual unsigned GetSubType() const;

    virtual PBoolean OnSendingPDU(
      H245_AudioCapability & pdu,  
      unsigned packetSize          
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_AudioMode & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_AudioCapability & pdu,  
      unsigned & packetSize              
    );

    virtual PBoolean IsMatch(
      const PASN_Choice & subTypePDU,     
      const PString & mediaPacketization  
    ) const;
};

class H323GenericAudioCapability : public H323AudioCapability,
                                   public H323GenericCapabilityInfo
{
  PCLASSINFO(H323NonStandardAudioCapability, H323AudioCapability);

  public:
    H323GenericAudioCapability(
      const PString & capabilityId,    
      unsigned fixedBitRate            
    );

    Comparison Compare(const PObject & obj) const;

    virtual unsigned GetSubType() const;

    virtual PBoolean OnSendingPDU(
      H245_AudioCapability & pdu,  
      unsigned packetSize,         
      CommandType type             
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_AudioMode & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_AudioCapability & pdu,  
      unsigned & packetSize,             
      CommandType type                   
    );

    virtual PBoolean IsMatch(
      const PASN_Choice & subTypePDU,     
      const PString & mediaPacketization  
    ) const;
};


template <const char * oid, const OpalAudioFormat & fmtFunc(), unsigned fixedBitRate = 0>
class H323GenericAudioCapabilityTemplate : public H323GenericAudioCapability
{
  public:
    H323GenericAudioCapabilityTemplate()
      : H323GenericAudioCapability(oid, fixedBitRate)
    {
    }

    virtual PObject * Clone() const
    {
      return new H323GenericAudioCapabilityTemplate(*this);
    }

    virtual PString GetFormatName() const
    {
      return fmtFunc();
    }
};


#if OPAL_VIDEO

class H323VideoCapability : public H323RealTimeCapability
{
  PCLASSINFO(H323VideoCapability, H323RealTimeCapability);

  public:
    virtual MainTypes GetMainType() const;

    virtual unsigned GetDefaultSessionID() const;

    virtual PBoolean OnSendingPDU(
      H245_Capability & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_DataType & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_ModeElement & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_VideoCapability & pdu  
    ) const;
    virtual PBoolean OnSendingPDU(
      H245_VideoCapability & pdu,  
      CommandType type             
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_VideoMode & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_Capability & pdu  
    );

    virtual PBoolean OnReceivedPDU(
      const H245_DataType & pdu,  
      PBoolean receiver               
    );

    virtual PBoolean OnReceivedPDU(
      const H245_VideoCapability & pdu  
    );
    virtual PBoolean OnReceivedPDU(
      const H245_VideoCapability & pdu,  
      CommandType type                   
    );
};


class H323NonStandardVideoCapability : public H323VideoCapability,
                                       public H323NonStandardCapabilityInfo
{
  PCLASSINFO(H323NonStandardVideoCapability, H323VideoCapability);

  public:
    H323NonStandardVideoCapability(
      H323NonStandardCapabilityInfo::CompareFuncType compareFunc,
      const BYTE * dataBlock,         
      PINDEX dataSize                 
    );
    H323NonStandardVideoCapability(
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    H323NonStandardVideoCapability(
      const PString & oid,            
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    H323NonStandardVideoCapability(
      BYTE country,                   
      BYTE extension,                 
      WORD maufacturer,               
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    Comparison Compare(const PObject & obj) const;

    virtual unsigned GetSubType() const;

    virtual PBoolean OnSendingPDU(
      H245_VideoCapability & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_VideoMode & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_VideoCapability & pdu  
    );

    virtual PBoolean IsMatch(
      const PASN_Choice & subTypePDU,     
      const PString & mediaPacketization  
    ) const;
};

class H323GenericVideoCapability : public H323VideoCapability,
                                   public H323GenericCapabilityInfo
{
  PCLASSINFO(H323GenericVideoCapability, H323VideoCapability);

  public:
    H323GenericVideoCapability(
      const PString & capabilityId,    
      PINDEX maxBitRate = 0           
    );

    Comparison Compare(const PObject & obj) const;

    virtual unsigned GetSubType() const;

    virtual PBoolean OnSendingPDU(
      H245_VideoCapability & pdu,  
      CommandType type             
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_VideoMode & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_VideoCapability & pdu,  
      CommandType type                   
    );

    virtual PBoolean IsMatch(
      const PASN_Choice & subTypePDU,     
      const PString & mediaPacketization  
    ) const;
};


template <const char * oid, const OpalVideoFormat & fmtFunc()>
class H323GenericVideoCapabilityTemplate : public H323GenericVideoCapability
{
  public:
    H323GenericVideoCapabilityTemplate()
      : H323GenericVideoCapability(oid)
    {
    }

    virtual PObject * Clone() const
    {
      return new H323GenericVideoCapabilityTemplate(*this);
    }

    virtual PString GetFormatName() const
    {
      return fmtFunc();
    }
};


#if OPAL_H239

class H323ExtendedVideoCapability : public H323GenericVideoCapability
{
  PCLASSINFO(H323ExtendedVideoCapability, H323GenericVideoCapability);

  public:
    H323ExtendedVideoCapability(
      const PString & identifier   
    );

    virtual unsigned GetSubType() const;
    
    virtual PBoolean OnSendingPDU(
      H245_VideoCapability & pdu,  
      CommandType type             
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_VideoMode & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_VideoCapability & pdu,  
      CommandType type                   
    );

    virtual PBoolean IsMatch(
      const PASN_Choice & subTypePDU,     
      const PString & mediaPacketization  
    ) const;

  protected:
    OpalMediaFormatList m_videoFormats;
};



class H323GenericControlCapability : public H323Capability,
                                     public H323GenericCapabilityInfo
{
  PCLASSINFO(H323GenericControlCapability, H323Capability);

  public:
    H323GenericControlCapability(
      const PString & identifier  
    );

    virtual MainTypes GetMainType() const;

    virtual unsigned GetSubType() const;

    virtual PBoolean OnSendingPDU(
      H245_Capability & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_ModeElement & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_Capability & pdu  
    );

    virtual PBoolean IsMatch(
      const PASN_Choice & subTypePDU,     
      const PString & mediaPacketization  
    ) const;

    virtual H323Channel * CreateChannel(
      H323Connection & connection,    
      H323Channel::Directions dir,    
      unsigned sessionID,             
      const H245_H2250LogicalChannelParameters * param
    ) const;
};



class H323H239VideoCapability : public H323ExtendedVideoCapability
{
  PCLASSINFO(H323H239VideoCapability, H323ExtendedVideoCapability);

  public:
    H323H239VideoCapability(
      const OpalMediaFormat & videoFormat
    );

    Comparison Compare(const PObject & obj) const;

    virtual PObject * Clone() const;

    virtual PString GetFormatName() const;

    virtual PBoolean OnSendingPDU(
      H245_VideoCapability & pdu,  
      CommandType type             
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_VideoCapability & pdu,  
      CommandType type                   
    );
};



class H323H239ControlCapability : public H323GenericControlCapability
{
  PCLASSINFO(H323H239ControlCapability, H323GenericControlCapability);

  public:
    H323H239ControlCapability();

    virtual PObject * Clone() const;

    virtual PString GetFormatName() const;
};


#endif  // OPAL_H239

#endif  // OPAL_VIDEO


class H323DataCapability : public H323Capability
{
  PCLASSINFO(H323DataCapability, H323Capability);

  public:
    H323DataCapability(
      unsigned maxBitRate = 0  
    );

    virtual MainTypes GetMainType() const;

    virtual unsigned GetDefaultSessionID() const;

    virtual PBoolean OnSendingPDU(
      H245_Capability & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_DataType & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_ModeElement & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_DataApplicationCapability & pdu  
    ) const;
    virtual PBoolean OnSendingPDU(
      H245_DataApplicationCapability & pdu, 
      CommandType type                      
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_DataMode & pdu  
    ) const = 0;

    virtual PBoolean OnReceivedPDU(
      const H245_Capability & pdu  
    );

    virtual PBoolean OnReceivedPDU(
      const H245_DataType & pdu,  
      PBoolean receiver               
    );

    virtual PBoolean OnReceivedPDU(
      const H245_DataApplicationCapability & pdu  
    );
    virtual PBoolean OnReceivedPDU(
      const H245_DataApplicationCapability & pdu, 
      CommandType type                            
    );

  protected:
    unsigned maxBitRate;
};


class H323NonStandardDataCapability : public H323DataCapability,
                                      public H323NonStandardCapabilityInfo
{
  PCLASSINFO(H323NonStandardDataCapability, H323DataCapability);

  public:
    H323NonStandardDataCapability(
      unsigned maxBitRate,            
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    H323NonStandardDataCapability(
      unsigned maxBitRate,            
      const PString & oid,            
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    H323NonStandardDataCapability(
      unsigned maxBitRate,            
      BYTE country,                   
      BYTE extension,                 
      WORD maufacturer,               
      const BYTE * dataBlock = NULL,  
      PINDEX dataSize = 0,            
      PINDEX comparisonOffset = 0,    
      PINDEX comparisonLength = P_MAX_INDEX  
    );

    Comparison Compare(const PObject & obj) const;

    virtual unsigned GetSubType() const;

    virtual PBoolean OnSendingPDU(
      H245_DataApplicationCapability & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_DataMode & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_DataApplicationCapability & pdu  
    );

    virtual PBoolean IsMatch(
      const PASN_Choice & subTypePDU,     
      const PString & mediaPacketization  
    ) const;
};


// Known audio codecs

class H323_G711Capability : public H323AudioCapability
{
  PCLASSINFO(H323_G711Capability, H323AudioCapability)

  public:
    enum Mode {
      ALaw,
      muLaw
    };
    enum Speed {
      At64k,
      At56k
    };

    H323_G711Capability(
      Mode mode = muLaw,    
      Speed speed = At64k   
    );

    virtual PObject * Clone() const;

    virtual unsigned GetSubType() const;

    virtual PString GetFormatName() const;

  protected:
    Mode     mode;
    Speed    speed;
};


class H323_UserInputCapability : public H323Capability
{
  PCLASSINFO(H323_UserInputCapability, H323Capability);

  public:
    enum SubTypes {
      BasicString,
      IA5String,
      GeneralString,
      SignalToneH245,
      HookFlashH245,
      SignalToneRFC2833,
      NumSubTypes
    };
    static const char * GetSubTypeName(SubTypes subType);
    friend ostream & operator<<(ostream & strm, SubTypes subType) { return strm << GetSubTypeName(subType); }

    H323_UserInputCapability(
      SubTypes subType
    );

    virtual PObject * Clone() const;

    virtual MainTypes GetMainType() const;

    virtual unsigned  GetSubType()  const;

    virtual PString GetFormatName() const;

    virtual H323Channel * CreateChannel(
      H323Connection & connection,    
      H323Channel::Directions dir,    
      unsigned sessionID,             
      const H245_H2250LogicalChannelParameters * param
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_Capability & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_DataType & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_ModeElement & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_Capability & pdu  
    );

    virtual PBoolean OnReceivedPDU(
      const H245_DataType & pdu,  
      PBoolean receiver               
    );

    virtual PBoolean IsUsable(
      const H323Connection & connection
    ) const;

    static void AddAllCapabilities(
      H323Capabilities & capabilities,  
      PINDEX descriptorNum,             
      PINDEX simultaneous,              
      bool includeRFC2833 = true
    );

  protected:
    SubTypes subType;
};




PARRAY(H323CapabilitiesList, H323Capability);

PARRAY(H323CapabilitiesListArray, H323CapabilitiesList);

class H323SimultaneousCapabilities : public H323CapabilitiesListArray
{
  PCLASSINFO(H323SimultaneousCapabilities, H323CapabilitiesListArray);
  public:
    PBoolean SetSize(PINDEX newSize);
};


PARRAY(H323CapabilitiesSetArray, H323SimultaneousCapabilities);


class H323CapabilitiesSet : public H323CapabilitiesSetArray
{
  PCLASSINFO(H323CapabilitiesSet, H323CapabilitiesSetArray);
  public:
    PBoolean SetSize(PINDEX newSize);
};


class H323Capabilities : public PObject
{
    PCLASSINFO(H323Capabilities, PObject);
  public:
    H323Capabilities();

    H323Capabilities(
      const H323Connection & connection,      
      const H245_TerminalCapabilitySet & pdu  
    );

    H323Capabilities(
      const H323Capabilities & original 
    );

    H323Capabilities & operator=(
      const H323Capabilities & original 
    );

    void PrintOn(
      ostream & strm    
    ) const;

    PINDEX GetSize() const { return table.GetSize(); }

    H323Capability & operator[](PINDEX i) const { return table[i]; }

    PINDEX SetCapability(
      PINDEX descriptorNum, 
      PINDEX simultaneous,  
      H323Capability * cap  
    );

    PINDEX AddMediaFormat(
      PINDEX descriptorNum,    
      PINDEX simultaneous,     
      const OpalMediaFormat & mediaFormat, 
      H323Capability::CapabilityDirection direction =
                H323Capability::e_Receive 
    );

    PINDEX AddAllCapabilities(
      PINDEX descriptorNum,    
      PINDEX simultaneous,     
      const PString & name,    
      PBoolean exact = false       
    );

    // this function is retained for backwards compatibility
    PINDEX AddAllCapabilities(
      const H323EndPoint &,    
      PINDEX descriptorNum,    
      PINDEX simultaneous,     
      const PString & name,    
      PBoolean exact = false       
    )
    { return AddAllCapabilities(descriptorNum, simultaneous, name, exact); }

    void Add(
      H323Capability * capability   
    );

    H323Capability * Copy(
      const H323Capability & capability   
    );

    void Remove(
      H323Capability * capability   
    );

    void Remove(
      const PString & formatName   
    );

    void Remove(
      const PStringArray & formatNames  
    );

    void RemoveAll();

    H323Capability * FindCapability(
      unsigned capabilityNumber
    ) const;

    H323Capability * FindCapability(
      const PString & formatName, 
      H323Capability::CapabilityDirection direction = H323Capability::e_Unknown,
      PBoolean exact = false       
    ) const;

    H323Capability * FindCapability(
      H323Capability::CapabilityDirection direction 
    ) const;

    H323Capability * FindCapability(
      const H323Capability & capability 
    ) const;

    H323Capability * FindCapability(
      const H245_Capability & cap  
    ) const;

    H323Capability * FindCapability(
      const H245_DataType & dataType,  
      const PString & mediaPacketization = PString::Empty()  
    ) const;

    H323Capability * FindCapability(
      const H245_ModeElement & modeElement,  
      const PString & mediaPacketization = PString::Empty()  
    ) const;

    H323Capability * FindCapability(
      H323Capability::MainTypes mainType, 
      unsigned subType = UINT_MAX         
    ) const;

    void BuildPDU(
      const H323Connection & connection,  
      H245_TerminalCapabilitySet & pdu    
    ) const;

    PBoolean Merge(
      const H323Capabilities & newCaps
    );

    void Reorder(
      const PStringArray & preferenceOrder  
    );

    PBoolean IsAllowed(
      const H323Capability & capability
    );

    PBoolean IsAllowed(
      unsigned capabilityNumber
    );

    PBoolean IsAllowed(
      const H323Capability & capability1,
      const H323Capability & capability2
    );

    PBoolean IsAllowed(
      unsigned capabilityNumber1,
      unsigned capabilityNumber2
    );

    OpalMediaFormatList GetMediaFormats() const;

    const PStringSet & GetMediaPacketizations() const { return m_mediaPacketizations; }

  protected:    
    H323CapabilitiesList table;
    H323CapabilitiesSet  set;
    PStringSet           m_mediaPacketizations;
};



/* New capability registration macros based on abstract factories
 */
typedef PFactory<H323Capability, std::string> H323CapabilityFactory;

#define H323_REGISTER_CAPABILITY(cls, capName)   static H323CapabilityFactory::Worker<cls> cls##Factory(capName, true); \


#endif // OPAL_H323

#endif // OPAL_H323_H323CAPS_H