rtpconn.h

Go to the documentation of this file.

/*
 * rtpconn.h
 *
 * Connection abstraction
 *
 * Open Phone Abstraction Library (OPAL)
 *
 * Copyright (C) 2007 Post Increment
 *
 * 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 Phone Abstraction Library.
 *
 * The Initial Developer of the Original Code is Post Increment
 *
 * Contributor(s): ______________________________________.
 *
 * $Revision: 20393 $
 * $Author: rjongbloed $
 * $Date: 2008-06-05 01:55:57 +0000 (Thu, 05 Jun 2008) $
 */

#ifndef __OPAL_RTPCONN_H
#define __OPAL_RTPCONN_H

#include <opal/buildopts.h>

#ifdef P_USE_PRAGMA
#pragma interface
#endif


#include <opal/connection.h>
#include <opal/mediatype.h>


class OpalRTPEndPoint;

//#ifdef HAS_LIBZRTP
//#ifndef __ZRTP_TYPES_H__
//struct zrtp_conn_ctx_t;
//#endif
//#endif

class OpalMediaSession : public PObject
{
  PCLASSINFO(OpalMediaSession, PObject);
  public:
    OpalMediaSession(const OpalMediaType & _mediaType);
    OpalMediaSession(const OpalMediaSession & _obj);

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

    OpalMediaType mediaType;     // media type for session
    bool autoStartReceive;       // if true, this session should receive data when the call is started
    bool autoStartTransmit;      // if true, this session  should transmit data when the call is started
    unsigned sessionId;          // unique session ID

    RTP_Session * rtpSession;    // RTP session
};

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

  public:
    OpalRTPSessionManager();
    ~OpalRTPSessionManager();

    void CopyFromMaster(const OpalRTPSessionManager & sm);
    void CopyToMaster(OpalRTPSessionManager & sm);

    void Initialise(
      OpalRTPConnection & conn, 
      OpalConnection::StringOptions * stringOptions
    );

    unsigned AutoStartSession(
      unsigned sessionID,        
      const OpalMediaType & mediaType,
      bool autoStartReceive, 
      bool autoStartTransmit
    );

    void AddSession(
      RTP_Session * session,          
      const OpalMediaType & mediaType 
    );

    void ReleaseSession(
      unsigned sessionID,    
      PBoolean clearAll = PFalse  
    );

    RTP_Session * GetSession(
      unsigned sessionID    
    ) const;

    void SetCleanup(bool v) { m_cleanupOnDelete = v; }

    PMutex & GetMutex() { return m_mutex; }

  protected:
    void SetOldOptions(unsigned channelId, const OpalMediaType & mediaType, bool rx, bool tx);

    PMutex m_mutex;
    bool m_initialised;
    bool m_cleanupOnDelete;
    PDICTIONARY(SessionDict, POrdinalKey, OpalMediaSession);
    SessionDict sessions;

  private:
    OpalRTPSessionManager (const OpalRTPSessionManager & other): PObject (other) { }
    OpalRTPSessionManager & operator=(const OpalRTPSessionManager &) { return *this; }

};

typedef OpalRTPSessionManager RTP_SessionManager;

class OpalRTPConnection : public OpalConnection
{
  PCLASSINFO(OpalRTPConnection, OpalConnection);
  public:
    OpalRTPConnection(
      OpalCall & call,                         
      OpalRTPEndPoint & endpoint,              
      const PString & token,                   
      unsigned options = 0,                    
      OpalConnection::StringOptions * stringOptions = NULL     
    );  

    ~OpalRTPConnection();


    virtual RTP_Session * GetSession(
      unsigned sessionID    
    ) const;

    virtual RTP_Session * UseSession(
      const OpalTransport & transport,  
      unsigned sessionID,               
      const OpalMediaType & mediatype,  
      RTP_QOS * rtpqos = NULL           
    );

    virtual void ReleaseSession(
      unsigned sessionID,    
      PBoolean clearAll = PFalse  
    );

    virtual RTP_Session * CreateSession(
      const OpalTransport & transport,
      unsigned sessionID,
      RTP_QOS * rtpqos
    );



    virtual PBoolean RemoteIsNAT() const
    { return remoteIsNAT; }

    virtual PBoolean IsRTPNATEnabled(
      const PIPSocket::Address & localAddr,   
      const PIPSocket::Address & peerAddr,    
      const PIPSocket::Address & signalAddr,  
      PBoolean incoming                       
    );

    virtual void AttachRFC2833HandlerToPatch(PBoolean isSource, OpalMediaPatch & patch);

    virtual PBoolean SendUserInputTone(
      char tone,        
      unsigned duration = 0  
    );

    struct MediaInformation {
      MediaInformation() { 
        rfc2833  = RTP_DataFrame::IllegalPayloadType; 
        ciscoNSE = RTP_DataFrame::IllegalPayloadType; 
      }

      OpalTransportAddress data;           
      OpalTransportAddress control;        
      RTP_DataFrame::PayloadTypes rfc2833; 
      RTP_DataFrame::PayloadTypes ciscoNSE; 
    };

    virtual PBoolean GetMediaInformation(
      unsigned sessionID,     
      MediaInformation & info 
    ) const;

    virtual PBoolean IsMediaBypassPossible(
      unsigned sessionID                  
    ) const;

    virtual OpalMediaStream * CreateMediaStream(
      const OpalMediaFormat & mediaFormat, 
      unsigned sessionID,                  
      PBoolean isSource                        
    );

    virtual void OnPatchMediaStream(PBoolean isSource, OpalMediaPatch & patch);

    virtual void SetSecurityMode(const PString & v)
    { securityMode = v; }

    virtual PString GetSecurityMode() const 
    { return securityMode; }

    virtual void * GetSecurityData();         
    virtual void SetSecurityData(void *data); 

    void OnMediaCommand(OpalMediaCommand & command, INT extra);

    PDECLARE_NOTIFIER(OpalRFC2833Info, OpalRTPConnection, OnUserInputInlineRFC2833);
    PDECLARE_NOTIFIER(OpalRFC2833Info, OpalRTPConnection, OnUserInputInlineCiscoNSE);

  protected:
    PString securityMode;
    void * securityData;
    OpalRTPSessionManager m_rtpSessions;
    OpalRFC2833Proto * rfc2833Handler;
    OpalRFC2833Proto * ciscoNSEHandler;

    PBoolean remoteIsNAT;
    PBoolean useRTPAggregation;
};


class RTP_UDP;

class OpalSecurityMode : public PObject
{
  PCLASSINFO(OpalSecurityMode, PObject);
  public:
    virtual RTP_UDP * CreateRTPSession(
      OpalRTPConnection & connection,    
      const PString & encoding,          
#if OPAL_RTP_AGGREGATE
      PHandleAggregator * _aggregator,   
#endif
      unsigned id,                       
      PBoolean remoteIsNAT               
    ) = 0;
    virtual PBoolean Open() = 0;
};

#endif 

---