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: 32525 $
 * $Author: rjongbloed $
 * $Date: 2014-08-14 18:25:56 +1000 (Thu, 14 Aug 2014) $
 */

#ifndef OPAL_H323_H323CAPS_H
#define OPAL_H323_H323CAPS_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#if OPAL_H323

#include <opal/mediafmt.h>
#include <h323/channels.h>
#include <opal/mediasession.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_Object;
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;
class H245_EncryptionSync;
class H245_EncryptionAuthenticationAndIntegrity;
class H235SecurityCapability;

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



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

  public:
    H323Capability();
    H323Capability(const H323Capability & other);
    H323Capability & operator=(const H323Capability & other);

    ~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_H235Security,   
      e_FEC,            
      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,
      MasterAllocatedBaseSessionID,
      DeferredSessionID = 1000000
    };

    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;

    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;

    virtual PBoolean OnReceivedPDU(
      const H245_Capability & pdu 
    );

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

    virtual PBoolean IsMatch(
      const PASN_Object & 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 OPAL_H235_6 || OPAL_H235_8

    const OpalMediaCryptoSuite * GetCryptoSuite() const;

    void SetCryptoSuite(const OpalMediaCryptoSuite & cryptoSuite);

    virtual bool OnSendingPDU(
      H245_EncryptionSync & encryptionSync,
      const H323Connection & connection,
      unsigned sessionID,
      bool rx
    );

    virtual bool OnReceivedPDU(
      const H245_EncryptionSync & encryptionSync,
      const H323Connection & connection,
      unsigned sessionID,
      bool rx
    );

    virtual bool PostTCS(
      const H323Connection & connection,
      const H323Capabilities & capabilities
    );
#endif


#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;

#if OPAL_H235_6 || OPAL_H235_8
    H235SecurityCapability * m_cryptoCapability;
#endif

  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;
    OpalBandwidth m_maxBitRate;
    enum {
      e_VariableBitRate,
      e_FixedBitRateStandard,
      e_FixedBitRateG7221,
    } m_bitRateMode;
};

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

  public:
    H323RealTimeCapability();
    H323RealTimeCapability(const H323RealTimeCapability &rtc);
    virtual ~H323RealTimeCapability();

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


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_Object & 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_Object & 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_Object & subTypePDU,     
      const PString & mediaPacketization  
    ) const;
};

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

  public:
    H323GenericVideoCapability(
      const PString & capabilityId,    
      unsigned fixedBitRate = 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_Object & 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_Object & 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 OnReceivedPDU(
      const H245_Capability & pdu  
    );

    virtual PBoolean IsMatch(
      const PASN_Object & subTypePDU,     
      const PString & mediaPacketization  
    ) 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



#if OPAL_H235_6 || OPAL_H235_8

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

  public:
    H235SecurityCapability(
      const H323Capability & mediaCapability
    );

    virtual MainTypes GetMainType() const;

    virtual unsigned  GetSubType()  const;

    virtual PString GetFormatName() const;

    virtual PBoolean OnSendingPDU(
      H245_Capability & pdu  
    ) const;

    virtual PBoolean OnReceivedPDU(
      const H245_Capability & pdu 
    );

    virtual bool OnSendingPDU(
      H245_EncryptionSync & encryptionSync,
      const H323Connection & connection,
      unsigned sessionID,
      bool rx
    );

    virtual bool OnReceivedPDU(
      const H245_EncryptionSync & encryptionSync,
      const H323Connection & connection,
      unsigned sessionID,
      bool rx
    );

    virtual bool PostTCS(
      const H323Connection & connection,
      const H323Capabilities & capabilities
    );

    virtual bool OnSendingPDU(H245_EncryptionAuthenticationAndIntegrity & pdu) const = 0;
    virtual bool OnReceivedPDU(const H245_EncryptionAuthenticationAndIntegrity & pdu) = 0;

    virtual bool OnSendingPDU(H245_EncryptionSync & encryptionSync, const H323Connection & connection, const OpalMediaCryptoKeyList & keys) = 0;
    virtual bool OnReceivedPDU(const H245_EncryptionSync & encryptionSync, const H323Connection & connection, OpalMediaCryptoKeyList & keys) = 0;

    unsigned GetMediaCapabilityNumber() const { return m_mediaCapabilityNumber; }
    const OpalMediaCryptoSuite::List & GetCryptoSuites() const { return m_cryptoSuites; }
    void SetCryptoSuites(const OpalMediaCryptoSuite::List & cryptoSuites) { m_cryptoSuites = cryptoSuites; }

    static void AddAllCapabilities(
      H323Capabilities & capabilities,
      const PStringArray & cryptoSuites,
      const char * prefix
    );

  protected:
    unsigned                   m_mediaCapabilityNumber;
    PString                    m_mediaCapabilityName;
    OpalMediaCryptoSuite::List m_cryptoSuites;
};

#endif // OPAL_H235_6 || OPAL_H235_8



#if OPAL_H235_6

class H235SecurityAlgorithmCapability : public H235SecurityCapability
{
  PCLASSINFO(H235SecurityAlgorithmCapability, H235SecurityCapability);

  public:
    H235SecurityAlgorithmCapability(
      const H323Capability & mediaCapability
    );

    virtual PObject * Clone() const;

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

    virtual bool OnSendingPDU(H245_EncryptionAuthenticationAndIntegrity & pdu) const;
    virtual bool OnReceivedPDU(const H245_EncryptionAuthenticationAndIntegrity & pdu);

    virtual bool OnSendingPDU(H245_EncryptionSync & encryptionSync, const H323Connection & connection, const OpalMediaCryptoKeyList & keys);
    virtual bool OnReceivedPDU(const H245_EncryptionSync & encryptionSync, const H323Connection & connection, OpalMediaCryptoKeyList & keys);
};

#endif // OPAL_H235_6



#if OPAL_H235_8

class H235SecurityGenericCapability : public H235SecurityCapability,
                                      public H323GenericCapabilityInfo
{
  PCLASSINFO(H235SecurityGenericCapability, H235SecurityCapability);

  public:
    H235SecurityGenericCapability(
      const H323Capability & mediaCapability
    );

    virtual PObject * Clone() const;

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

    virtual bool OnSendingPDU(H245_EncryptionAuthenticationAndIntegrity & pdu) const;
    virtual bool OnReceivedPDU(const H245_EncryptionAuthenticationAndIntegrity & pdu);

    virtual bool OnSendingPDU(H245_EncryptionSync & encryptionSync, const H323Connection & connection, const OpalMediaCryptoKeyList & keys);
    virtual bool OnReceivedPDU(const H245_EncryptionSync & encryptionSync, const H323Connection & connection, OpalMediaCryptoKeyList & keys);
};

#endif // OPAL_H235_8



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

  public:
    H323DataCapability(
      unsigned maxBitRate  
    );

    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:
    OpalBandwidth m_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_Object & subTypePDU,     
      const PString & mediaPacketization  
    ) const;
};


class H323GenericDataCapability : public H323DataCapability,
                                  public H323GenericCapabilityInfo
{
  PCLASSINFO(H323GenericDataCapability, H323DataCapability);

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

    Comparison Compare(const PObject & obj) const;

    virtual unsigned GetSubType() const;

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

    virtual PBoolean OnSendingPDU(
      H245_DataMode & pdu  
    ) const;

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

    virtual PBoolean IsMatch(
      const PASN_Object & 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 PBoolean OnSendingPDU(
      H245_Capability & pdu  
    ) const;

    virtual PBoolean OnSendingPDU(
      H245_DataType & 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,              
      H323Capability * rfc2833 = NULL
    );

  protected:
    SubTypes subType;
};



#if OPAL_RTP_FEC

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

public:
  H323FECCapability(
    const OpalMediaFormat & mediaFormat,
    unsigned protectedCapability
  );

  virtual MainTypes GetMainType() const;

  virtual unsigned  GetSubType()  const;

  virtual PString GetFormatName() const;

  virtual PBoolean OnSendingPDU(
    H245_Capability & pdu  
    ) const;

  virtual PBoolean OnReceivedPDU(
    const H245_Capability & pdu 
    );

  unsigned GetProtectedCapability() const
  {
    return m_protectedCapability;
  }

  static void AddAllCapabilities(
    H323Capabilities & capabilities,
    const OpalMediaFormatList & localFormats
  );

protected:
  PString  m_scheme;
  unsigned m_protectedCapability;
};

#endif // OPAL_RTP_FEC



PARRAY(H323CapabilitiesList, H323Capability);

PARRAY(H323CapabilitiesListArray, H323CapabilitiesList);

class H323SimultaneousCapabilities : public H323CapabilitiesListArray
{
  PCLASSINFO(H323SimultaneousCapabilities, H323CapabilitiesListArray);
  public:
    H323SimultaneousCapabilities() : m_capabilityDescriptorNumber(0) { }

    PBoolean SetSize(PINDEX newSize);

    unsigned m_capabilityDescriptorNumber;
};


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(
      H323Connection & connection,            
      const H245_TerminalCapabilitySet & pdu  
    );

    H323Capabilities(
      const H323Capabilities & original 
    );

    H323Capabilities & operator=(
      const H323Capabilities & original 
    );

    void PrintOn(
      ostream & strm    
    ) const;

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

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

    PINDEX SetCapability(
      PINDEX descriptorNum, 
      PINDEX simultaneous,  
      H323Capability * cap, 
      H323Capability * before = NULL 
    );

    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; }

    const H323CapabilitiesSet & GetSet() const { return m_set; }

  protected:
    H323CapabilitiesList m_table;
    H323CapabilitiesSet  m_set;
    PStringSet           m_mediaPacketizations;
};



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

#define H323_REGISTER_CAPABILITY(cls, capName) PFACTORY_CREATE(H323CapabilityFactory, cls, capName, true)


#endif // OPAL_H323

#endif // OPAL_H323_H323CAPS_H