rtp_session.h

Go to the documentation of this file.

/*
 * rtp_session.h
 *
 * RTP protocol session
 *
 * Open H323 Library
 *
 * Copyright (c) 1998-2012 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): ______________________________________.
 */

#ifndef OPAL_RTP_RTP_SESSION_H
#define OPAL_RTP_RTP_SESSION_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif

#include <opal_config.h>

#include <rtp/rtp.h>
#include <rtp/jitter.h>
#include <opal/mediasession.h>
#include <opal/mediafmt.h>
#include <ptlib/sockets.h>
#include <ptlib/safecoll.h>
#include <ptlib/notifier_ext.h>
#include <ptclib/pnat.h>
#include <ptclib/url.h>

#include <list>


class OpalRTPEndPoint;
class PNatMethod;
class PSTUNServer;
class PSTUNClient;
class RTCP_XR_Metrics;
class RTP_MetricsReport;


#define OPAL_OPT_RTP_ALLOW_SSRC "RTP-Allow-SSRC"
#define OPAL_OPT_RTP_ALLOW_SSRC_ANY    "any"
#define OPAL_OPT_RTP_ALLOW_SSRC_FIRST  "first"
#define OPAL_OPT_RTP_ALLOW_SSRC_PRESET "preset"

#define OPAL_OPT_RTP_ABS_SEND_TIME "RTP-Abs-Send-Time"

#define OPAL_OPT_TRANSPORT_WIDE_CONGESTION_CONTROL "Transport-Wide-Congestion-Control"



class OpalRTPSession : public OpalMediaSession
{
    PCLASSINFO(OpalRTPSession, OpalMediaSession);
  public:
    static const PCaselessString & RTP_AVP();
    static const PCaselessString & RTP_AVPF();

    OpalRTPSession(const Init & init);

    ~OpalRTPSession();

    virtual const PCaselessString & GetSessionType() const { return RTP_AVP(); }
    virtual bool Open(const PString & localInterface, const OpalTransportAddress & remoteAddress);
    virtual bool Close();
    virtual OpalTransportAddress GetLocalAddress(bool isMediaAddress = true) const;
    virtual OpalTransportAddress GetRemoteAddress(bool isMediaAddress = true) const;
    virtual bool SetRemoteAddress(const OpalTransportAddress & remoteAddress, bool isMediaAddress = true);
    virtual void AttachTransport(const OpalMediaTransportPtr & transport);
    virtual OpalMediaTransportPtr DetachTransport();
    virtual bool AddGroup(const PString & groupId, const PString & mediaId, bool overwrite = true);

    virtual bool UpdateMediaFormat(const OpalMediaFormat & mediaFormat);

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

    enum Direction
    {
      e_Receiver,
      e_Sender
    };
#if PTRACING
    friend ostream & operator<<(ostream & strm, Direction dir);
#endif

    virtual RTP_SyncSourceId AddSyncSource(
      RTP_SyncSourceId id,
      Direction dir,
      const char * cname = NULL
    );

    virtual bool RemoveSyncSource(
      RTP_SyncSourceId id
      PTRACE_PARAM(, const char * reason)
    );

    RTP_SyncSourceArray GetSyncSources(Direction dir) const;

    RTP_SyncSourceId EnableSyncSourceRtx(
      RTP_SyncSourceId primarySSRC,      
      RTP_DataFrame::PayloadTypes rtxPT, 
      RTP_SyncSourceId rtxSSRC           
    );

    void FinaliseSyncSourceRtx(
      RTP_DataFrame::PayloadTypes primaryPT, 
      RTP_DataFrame::PayloadTypes rtxPT,     
      OpalRTPSession::Direction dir          
    );


    enum SendReceiveStatus {
      e_IgnorePacket = -1,
      e_AbortTransport, // Abort is zero so equvalent to false
      e_ProcessPacket
    };

    enum RewriteMode
    {
      e_RewriteHeader,
      e_RewriteSSRC,
      e_RewriteNothing,
      e_RetransmitFirst,
      e_RetransmitAgain
    };

    enum ReceiveType {
      e_RxFromNetwork,
      e_RxOutOfOrder,
      e_RxRetransmit,
      e_RxFromRTX
    };

    virtual SendReceiveStatus WriteData(
      RTP_DataFrame & frame,                          
      RewriteMode rewrite = e_RewriteHeader,          
      const PIPSocketAddressAndPort * remote = NULL,  
      const PTime & now = PTime()
    );

    virtual SendReceiveStatus SendReport(
      RTP_SyncSourceId ssrc,    
      bool force,               
      const PTime & now = PTime()
    );

    virtual SendReceiveStatus WriteControl(
      RTP_ControlFrame & frame,                      
      const PIPSocketAddressAndPort * remote = NULL  
    );

    virtual PString GetLocalHostName();

#if OPAL_STATISTICS
    virtual void GetStatistics(OpalMediaStatistics & statistics, Direction dir) const;
#endif


    struct Data
    {
      Data(const RTP_DataFrame & frame)
        : m_frame(frame)
        , m_status(e_ProcessPacket)
        { }
      RTP_DataFrame     m_frame;
      SendReceiveStatus m_status;
    };
    typedef PNotifierTemplate<Data &> DataNotifier;
    #define PDECLARE_RTPDataNotifier(cls, fn) PDECLARE_NOTIFIER2(OpalRTPSession, cls, fn, OpalRTPSession::Data &)
    #define PCREATE_RTPDataNotifier(fn)       PCREATE_NOTIFIER2(fn, OpalRTPSession::Data &)

    void AddDataNotifier(
      unsigned priority,
      const DataNotifier & notifier,
      RTP_SyncSourceId ssrc = 0
    );

    void RemoveDataNotifier(
      const DataNotifier & notifier,
      RTP_SyncSourceId ssrc = 0
    );

    virtual SendReceiveStatus OnSendData(RewriteMode & rewrite, RTP_DataFrame & frame, const PTime & now);
    virtual SendReceiveStatus OnSendControl(RTP_ControlFrame & frame, const PTime & now);
    virtual SendReceiveStatus OnPreReceiveData(RTP_DataFrame & frame, const PTime & now);
    virtual SendReceiveStatus OnReceiveData(RTP_DataFrame & frame, ReceiveType rxType, const PTime & now);
    virtual SendReceiveStatus OnReceiveControl(RTP_ControlFrame & frame, const PTime & now);
    virtual bool IsEncrypted() const { return false; }

    virtual void OnRxSenderReport(const RTP_SenderReport & sender, const PTime & now);
    virtual void OnRxReceiverReports(RTP_SyncSourceId src, const RTP_ControlFrame::ReceiverReport * rr, unsigned count, const PTime & now);
    virtual void OnRxReceiverReports(RTP_SyncSourceId src, const std::vector<RTP_ReceiverReport> & reports);
    virtual void OnRxReceiverReport(RTP_SyncSourceId src, const RTP_ControlFrame::ReceiverReport & rr);
    virtual void OnRxReceiverReport(RTP_SyncSourceId src, const RTP_ReceiverReport & report);
    virtual void OnRxSourceDescription(const RTP_SourceDescriptionArray & descriptions);
    virtual void OnRxGoodbye(const RTP_SyncSourceArray & sources, const PString & reason);
    virtual void OnRxNACK(RTP_SyncSourceId ssrc, const RTP_ControlFrame::LostPacketMask & lostPackets, const PTime & now);
    virtual void OnRxTWCC(const RTP_TransportWideCongestionControl & twcc);
    virtual void OnRxApplDefined(const RTP_ControlFrame::ApplDefinedInfo & info);
    virtual bool OnReceiveExtendedReports(const RTP_ControlFrame & frame, const PTime & now);
    virtual void OnRxReceiverReferenceTimeReport(RTP_SyncSourceId ssrc, const PTime & ntp, const PTime & now);
    virtual void OnRxDelayLastReceiverReport(const RTP_DelayLastReceiverReport & dlrr, const PTime & now);

    typedef PNotifierListTemplate<const RTP_ControlFrame::ApplDefinedInfo &> ApplDefinedNotifierList;
    typedef PNotifierTemplate<const RTP_ControlFrame::ApplDefinedInfo &> ApplDefinedNotifier;

    void AddApplDefinedNotifier(const ApplDefinedNotifier & notifier)
    {
      m_applDefinedNotifiers.Add(notifier);
    }

    void RemoveApplDefinedNotifier(const ApplDefinedNotifier & notifier)
    {
      m_applDefinedNotifiers.Remove(notifier);
    }

#if OPAL_RTCP_XR
    virtual void OnRxMetricsReport(
      RTP_SyncSourceId src,
      const RTP_MetricsReport & report
    );
#endif // OPAL_RTCP_XR


    void SetSinglePortRx(bool v = true);

    bool IsSinglePortRx() { return m_singlePortRx; }

    void SetSinglePortTx(bool v = true);

    bool IsSinglePortTx() { return m_singlePortTx; }

    void SetReducedSizeRTCP(bool v = true) { m_reducedSizeRTCP = v; }

    bool UseReducedSizeRTCP() const { return m_reducedSizeRTCP; }

    bool IsAudio() const { return m_isAudio; }

    void SetAudio(
      bool aud    
    ) { m_isAudio = aud; }

#if OPAL_RTP_FEC
    struct FecLevel
    {
      PBYTEArray m_mask; // Points to 16 or 48 bits
      PBYTEArray m_data;
    };
    struct FecData
    {
      RTP_Timestamp    m_timestamp;
      bool             m_pRecovery;
      bool             m_xRecovery;
      unsigned         m_ccRecovery;
      bool             m_mRecovery;
      unsigned         m_ptRecovery;
      unsigned         m_snBase;
      unsigned         m_tsRecovery;
      unsigned         m_lenRecovery;
      vector<FecLevel> m_level;
    };

    RTP_DataFrame::PayloadTypes GetRedundencyPayloadType() const { return m_redundencyPayloadType; }

    void SetRedundencyPayloadType(RTP_DataFrame::PayloadTypes pt) { m_redundencyPayloadType = pt; }

    RTP_DataFrame::PayloadTypes GetUlpFecPayloadType() const { return m_ulpFecPayloadType; }

    void SetUlpFecPayloadType(RTP_DataFrame::PayloadTypes pt) { m_ulpFecPayloadType = pt; }

    unsigned GetUlpFecSendLevel() const { return m_ulpFecSendLevel; }

    void SetUlpFecSendLevel(unsigned level) { m_ulpFecSendLevel = level; }
#endif // OPAL_RTP_FEC

    PString GetLabel() const;

    void SetLabel(const PString & name);

    PString GetCanonicalName(RTP_SyncSourceId ssrc = 0, Direction dir = e_Sender) const;

    void SetCanonicalName(const PString & name, RTP_SyncSourceId ssrc = 0, Direction dir = e_Sender);

    PString GetMediaStreamId(RTP_SyncSourceId ssrc, Direction dir) const;

    void SetMediaStreamId(const PString & id, RTP_SyncSourceId ssrc, Direction dir);

    PString GetMediaTrackId(RTP_SyncSourceId ssrc, Direction dir) const;

    void SetMediaTrackId(const PString & id, RTP_SyncSourceId ssrc, Direction dir);

    RTP_SyncSourceId GetRtxSyncSource(
      RTP_SyncSourceId ssrc,    
      Direction dir,            
      bool isPrimary            
  ) const;

    PString GetToolName() const;

    void SetToolName(const PString & name);

    RTPHeaderExtensions GetHeaderExtensions() const;

    void SetHeaderExtensions(const RTPHeaderExtensions & ext);

    bool AddHeaderExtension(const RTPHeaderExtensionInfo & ext);

    static const PString & GetAbsSendTimeHdrExtURI();
    static const PString & GetTransportWideSeqNumHdrExtURI();

    RTP_SyncSourceId GetSyncSourceIn() const { return GetSyncSource(0, e_Receiver).m_sourceIdentifier; }

    RTP_SyncSourceId GetSyncSourceOut() const { return GetSyncSource(0, e_Sender).m_sourceIdentifier; }

    void SetAnySyncSource(
      bool allow    
    );


    PINDEX GetMaxOutOfOrderPackets() { return m_maxOutOfOrderPackets; }

    void SetMaxOutOfOrderPackets(
      PINDEX packets 
    );

    const PTimeInterval & GetOutOfOrderWaitTime() { return m_waitOutOfOrderTime; }

    void SetOutOfOrderWaitTime(
      const PTimeInterval & interval 
    )  { m_waitOutOfOrderTime = interval; }

    PTimeInterval GetReportTimeInterval() { return m_reportTimer.GetResetTime(); }

    void SetReportTimeInterval(
      const PTimeInterval & interval 
    )  { m_reportTimer.RunContinuous(interval); }

    unsigned GetTxStatisticsInterval() { return m_txStatisticsInterval; }

    void SetTxStatisticsInterval(
      unsigned packets   
    ) { m_txStatisticsInterval = packets; }

    unsigned GetRxStatisticsInterval() { return m_rxStatisticsInterval; }

    void SetRxStatisticsInterval(
      unsigned packets   
    ) { m_rxStatisticsInterval = packets; }

    virtual WORD GetLocalDataPort() const;

    virtual WORD GetLocalControlPort() const;

    unsigned GetPacketsSent(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_packets; }

    uint64_t GetOctetsSent(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_octets; }

    unsigned GetPacketsReceived(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_packets; }

    uint64_t GetOctetsReceived(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_octets; }

    unsigned GetPacketsLost(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_packetsUnrecovered; }

    int GetPacketsLostByRemote(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_packetsMissing; }

    unsigned GetPacketsOutOfOrder(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_packetsOutOfOrder; }

    int GetAverageSendTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_averagePacketTime; }

    unsigned GetMarkerRecvCount(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_markerCount; }

    unsigned GetMarkerSendCount(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_markerCount; }

    int GetMaximumSendTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_maximumPacketTime; }

    int GetMinimumSendTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_minimumPacketTime; }

    int GetAverageReceiveTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_averagePacketTime; }

    int GetMaximumReceiveTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_maximumPacketTime; }

    int GetMinimumReceiveTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_minimumPacketTime; }

    int GetAvgJitterTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_currentJitter; }

    int GetMaxJitterTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Receiver).m_maximumJitter; }

    int GetJitterTimeOnRemote(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_currentJitter; }

    int GetRoundTripTime() const;

    virtual SendReceiveStatus SendBYE(RTP_SyncSourceId ssrc = 0);

    virtual SendReceiveStatus SendNACK(const RTP_ControlFrame::LostPacketMask & lostPackets, RTP_SyncSourceId ssrc = 0);

    virtual SendReceiveStatus SendTWCC(const RTP_TransportWideCongestionControl & twcc);

    virtual SendReceiveStatus SendFlowControl(
      unsigned maxBitRate,    
      unsigned overhead = 0,  
      bool notify = false,    
      RTP_SyncSourceId ssrc = 0
    );

#if OPAL_VIDEO

    virtual SendReceiveStatus SendIntraFrameRequest(
      unsigned options,
      RTP_SyncSourceId ssrc = 0,
      const PTime & now = PTime()
    );

    virtual SendReceiveStatus SendTemporalSpatialTradeOff(unsigned tradeOff, RTP_SyncSourceId ssrc = 0);
#endif

    RTP_Timestamp GetLastSentTimestamp(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_lastPacketTimestamp; }
    const PTime & GetLastSentNetTime(RTP_SyncSourceId ssrc = 0) const { return GetSyncSource(ssrc, e_Sender).m_lastPacketNetTime; }

    void SetJitterBuffer(OpalJitterBuffer * jitterBuffer, RTP_SyncSourceId ssrc = 0);

    bool HasFeedback(OpalMediaFormat::RTCPFeedback feature) const { return m_feedback&feature; }

  protected:
    virtual OpalMediaTransport * CreateMediaTransport(const PString & name);
    void InternalAttachTransport(const OpalMediaTransportPtr & transport PTRACE_PARAM(, const char * from));

    bool InternalSetQoS(const PIPSocket::QoS & qos);

    PDECLARE_MediaReadNotifier(OpalRTPSession, OnRxDataPacket);
    PDECLARE_MediaReadNotifier(OpalRTPSession, OnRxControlPacket);
    void SessionFailed(SubChannels subchannel PTRACE_PARAM(, const char * reason));

    OpalRTPEndPoint   & m_endpoint;
    OpalManager       & m_manager;
    bool                m_singlePortRx;
    bool                m_singlePortTx;
    bool                m_reducedSizeRTCP;
    bool                m_isAudio;
    unsigned            m_timeUnits;
    PString             m_toolName;
    PString             m_label;
    RTPHeaderExtensions m_headerExtensions;
    unsigned            m_absSendTimeHdrExtId;
    unsigned            m_transportWideSeqNumHdrExtId;
    PTimeInterval       m_staleReceiverTimeout;
    PINDEX              m_maxOutOfOrderPackets; // Number of packets before we give up waiting for an out of order packet
    PTimeInterval       m_waitOutOfOrderTime;   // Milliseconds before we give up on an out of order packet
    unsigned            m_txStatisticsInterval;
    unsigned            m_rxStatisticsInterval;
    OpalMediaFormat::RTCPFeedback m_feedback;

    OpalJitterBuffer  * m_jitterBuffer;

#if OPAL_RTP_FEC
    RTP_DataFrame::PayloadTypes m_redundencyPayloadType;
    RTP_DataFrame::PayloadTypes m_ulpFecPayloadType;
    unsigned                    m_ulpFecSendLevel;
#endif // OPAL_RTP_FEC

    class NotifierMap : public std::multimap<unsigned, DataNotifier>
    {
    public:
      void Add(unsigned priority, const DataNotifier & notifier);
      void Remove(const DataNotifier & notifier);
    };
    NotifierMap m_notifiers;

    friend struct SyncSource;
    struct SyncSource
    {
      SyncSource(OpalRTPSession & session, RTP_SyncSourceId id, Direction dir, const char * cname);
      virtual ~SyncSource();

#if PTRACING
      friend ostream & operator<<(ostream & strm, const SyncSource & ssrc)
      { return strm << ssrc.m_session << "SSRC=" << RTP_TRACE_SRC(ssrc.m_sourceIdentifier) << ", "; }
#endif

      virtual SendReceiveStatus OnSendData(RTP_DataFrame & frame, RewriteMode rewrite, const PTime & now);
      virtual SendReceiveStatus OnReceiveData(RTP_DataFrame & frame, ReceiveType rxType, const PTime & now);
      virtual SendReceiveStatus OnReceiveRetransmit(RTP_DataFrame & frame, const PTime & now);
      virtual void SetLastSequenceNumber(RTP_SequenceNumber sequenceNumber);
      virtual void SaveSentData(const RTP_DataFrame & frame, const PTime & now);
      virtual void OnRxNACK(const RTP_ControlFrame::LostPacketMask & lostPackets, const PTime & now);
      virtual bool IsExpectingRetransmit(RTP_SequenceNumber sequenceNumber);
      virtual SendReceiveStatus OnOutOfOrderPacket(RTP_DataFrame & frame, ReceiveType & rxType, const PTime & now);
      virtual bool HasPendingFrames() const;
      virtual bool HandlePendingFrames(const PTime & now);
#if OPAL_RTP_FEC
      virtual SendReceiveStatus OnSendRedundantFrame(RTP_DataFrame & frame);
      virtual SendReceiveStatus OnSendRedundantData(RTP_DataFrame & primary, RTP_DataFrameList & redundancies);
      virtual SendReceiveStatus OnReceiveRedundantFrame(RTP_DataFrame & frame);
      virtual SendReceiveStatus OnReceiveRedundantData(RTP_DataFrame & primary, RTP_DataFrame::PayloadTypes payloadType, unsigned timestamp, const BYTE * data, PINDEX size);
      virtual SendReceiveStatus OnSendFEC(RTP_DataFrame & primary, FecData & fec);
      virtual SendReceiveStatus OnReceiveFEC(RTP_DataFrame & primary, const FecData & fec);
#endif // OPAL_RTP_FEC


      void CalculateRTT(const PTime & reportTime, const PTimeInterval & reportDelay, const PTime & now);
      virtual void CalculateStatistics(const RTP_DataFrame & frame, const PTime & now);
#if OPAL_STATISTICS
      virtual void GetStatistics(OpalMediaStatistics & statistics) const;
#endif

      virtual bool OnSendReceiverReport(RTP_ControlFrame::ReceiverReport * report, const PTime & now PTRACE_PARAM(, unsigned logLevel));
      virtual bool OnSendDelayLastReceiverReport(RTP_ControlFrame::DelayLastReceiverReport::Receiver * report, const PTime & now);
      virtual void OnRxSenderReport(const RTP_SenderReport & report, const PTime & now);
      virtual void OnRxReceiverReport(const RTP_ReceiverReport & report, const PTime & now);
      virtual void OnRxDelayLastReceiverReport(const RTP_DelayLastReceiverReport & dlrr, const PTime & now);
      virtual SendReceiveStatus SendBYE();

      bool IsStaleReceiver(const PTime & now) const;
      bool IsRtx() const { return m_rtxPT != RTP_DataFrame::IllegalPayloadType; }
      bool IsNackEnabled() const { return !IsRtx() && m_session.HasFeedback(OpalMediaFormat::e_NACK); }
      uint32_t ExtendSequenceNumber(RTP_SequenceNumber sequenceNumber) const;

      OpalRTPSession  & m_session;
      Direction         m_direction;
      RTP_SyncSourceId  m_sourceIdentifier;
      RTP_SyncSourceId  m_loopbackIdentifier;
      PString           m_canonicalName;
      PString           m_mediaStreamId;
      PString           m_mediaTrackId;

      RTP_SyncSourceId            m_rtxSSRC; // Bidirectional link between primary and secondary
      RTP_DataFrame::PayloadTypes m_rtxPT;   // Sending rtx payload type, or receiving rtx primary payload type, only set in seconday SSRC
      int                         m_rtxPackets;
      int                         m_rtxDuplicates;

      NotifierMap m_notifiers;

      // Sequence handling
      RTP_SequenceNumber m_lastSequenceNumber;
      uint32_t           m_firstSequenceNumber;
      uint32_t           m_extendedSequenceNumber;
      unsigned           m_lastFIRSequenceNumber;
      unsigned           m_lastTSTOSequenceNumber;
      unsigned           m_consecutiveOutOfOrderPackets;
      PTime              m_consecutiveOutOfOrderEndTime;
      RTP_SequenceNumber m_nextOutOfOrderPacket;
      PTime              m_endWaitOutOfOrderTime;
      PTime              m_lateOutOfOrderAdaptTime;
      unsigned           m_lateOutOfOrderAdaptCount;
      unsigned           m_lateOutOfOrderAdaptMax;
      PTimeInterval      m_lateOutOfOrderAdaptBoost;
      PTimeInterval      m_lateOutOfOrderAdaptPeriod;

      struct RxPacket : RTP_DataFrame {
        PTime m_lastNackTime; // If lost, this is valid
        explicit RxPacket(const RTP_DataFrame & pkt) : RTP_DataFrame(pkt), m_lastNackTime(0) { }
        explicit RxPacket(const PTime & when) : RTP_DataFrame(0), m_lastNackTime(when) { }
      };
      typedef std::map<uint32_t, RxPacket> RxPacketMap;
      RxPacketMap m_pendingRxPackets;

      struct TxPacket : RTP_DataFrame {
        RewriteMode m_rewriteMode;
        explicit TxPacket(const RTP_DataFrame & pkt) : RTP_DataFrame(pkt), m_rewriteMode(e_RetransmitFirst) { }
      };
      typedef std::map<RTP_SequenceNumber, TxPacket> TxPacketMap;
      typedef std::map<PTime, RTP_SequenceNumber> TxPacketTimes;
      TxPacketMap   m_pendingTxPackets;
      TxPacketTimes m_pendingTxPacketTime;
      PTimeInterval m_pendingTxPacketAgeLimit;

      // Generating real time stamping in RTP packets
      // For e_Receive, times are from last received Sender Report, or Receiver Reference Time Report
      // For e_Sender, times are from RTP_DataFrame, or synthesized from local real time.
      RTP_Timestamp      m_reportTimestamp;
      PTime              m_reportAbsoluteTime;
      bool               m_synthesizeAbsTime;

      // Handling Abs-Send-Time header extension
      uint64_t m_absSendTimeNTP;
      uint32_t m_absSendTimeLowBits;
#if PTRACING
      unsigned m_absSendTimeLoglevel;
#endif

      // Statistics gathered
      RTP_DataFrame::PayloadTypes m_payloadType;
      PTime    m_firstPacketTime;
      unsigned m_packets;  // Note, does not include retransmits via NACK
      uint64_t m_octets;
      unsigned m_senderReports;
      atomic<unsigned> m_NACKs;
      int      m_packetsMissing;  // As per RFC
      int      m_packetsUnrecovered; // After possible recovery via NACK (only on rx)
      int      m_maxConsecutiveLost;
      unsigned m_packetsOutOfOrder;
      int      m_lateOutOfOrder;

      int      m_averagePacketTime; // Milliseconds
      int      m_maximumPacketTime; // Milliseconds
      int      m_minimumPacketTime; // Milliseconds
      int      m_currentJitter;     // Milliseconds
      int      m_maximumJitter;     // Milliseconds
      unsigned m_markerCount;

      // Working for calculating statistics
      RTP_Timestamp      m_lastPacketTimestamp;
      PTime              m_lastPacketAbsTime;
      PTime              m_lastPacketNetTime;

      unsigned           m_averageTimeAccum;
      unsigned           m_maximumTimeAccum;
      unsigned           m_minimumTimeAccum;
      unsigned           m_jitterAccum;

      // Things to remember for filling in fields of sent SR/RR/DLRR
      unsigned           m_lastRRPacketsReceived;
      uint32_t           m_lastRRSequenceNumber;
      float              m_rtcpDiscardRate;       // from extended RR
      int                m_rtcpJitterBufferDelay; // from extended RR
      uint64_t           m_ntpPassThrough;       // The NTP time from SR
      PTime              m_lastSenderReportTime; // Local time that SR was sent/received
      PTime              m_lastReferencedTime;   // Local time SSRC was referenced to prevent going stale
      PTime              m_referenceReportTime;
      PTime              m_referenceReportNTP;

      unsigned           m_statisticsCount;

#if OPAL_RTCP_XR
      RTCP_XR_Metrics  * m_metrics; // Calculate the VoIP Metrics for RTCP-XR
#endif

      OpalJitterBuffer * m_jitterBuffer;
      OpalJitterBuffer * GetJitterBuffer() const;

      PTRACE_THROTTLE(m_throttleSendData,3,20000);
      PTRACE_THROTTLE(m_throttleReceiveData,3,20000);
      PTRACE_THROTTLE(m_throttleRxSR,3,60000,5);
      PTRACE_THROTTLE(m_throttleRxRR,3,60000, 5);
      PTRACE_THROTTLE(m_throttleTxRED,3,60000);
      PTRACE_THROTTLE(m_throttleRxRED,3,60000);
      PTRACE_THROTTLE(m_throttleRxUnknownFEC,3,10000);
      PTRACE_THROTTLE(m_throttleInvalidLost,2,60000);

      P_REMOVE_VIRTUAL(SendReceiveStatus, OnSendData(RTP_DataFrame &, bool), e_AbortTransport);
      P_REMOVE_VIRTUAL(SendReceiveStatus, OnSendData(RTP_DataFrame &, RewriteMode), e_AbortTransport);
      P_REMOVE_VIRTUAL(SendReceiveStatus, OnOutOfOrderPacket(RTP_DataFrame &), e_AbortTransport);
      P_REMOVE_VIRTUAL(SendReceiveStatus, OnReceiveData(RTP_DataFrame &, ReceiveType), e_AbortTransport);
   };

    typedef std::map<RTP_SyncSourceId, SyncSource *> SyncSourceMap;
    SyncSourceMap    m_SSRC;
    SyncSource       m_dummySyncSource;
    atomic<RTP_SyncSourceId> m_defaultSSRC[2]; // For e_Sender and e_Receiver

    const SyncSource & GetSyncSource(RTP_SyncSourceId ssrc, Direction dir) const;
    virtual bool GetSyncSource(RTP_SyncSourceId ssrc, Direction dir, SyncSource * & info);
    virtual SyncSource * UseSyncSource(RTP_SyncSourceId ssrc, Direction dir, bool force);
    virtual SyncSource * CreateSyncSource(RTP_SyncSourceId id, Direction dir, const char * cname);
    virtual bool CheckControlSSRC(RTP_SyncSourceId senderSSRC, RTP_SyncSourceId targetSSRC, SyncSource * & info PTRACE_PARAM(, const char * pduName));
    virtual bool ResequenceOutOfOrderPackets(SyncSource & ssrc) const;

    virtual bool InternalSendReport(RTP_ControlFrame & report, SyncSource & sender, bool includeReceivers, bool forced, const PTime & now);
    virtual void InitialiseControlFrame(RTP_ControlFrame & frame, SyncSource & sender);

    // Some statitsics not SSRC related
    unsigned m_rtcpPacketsSent;
    unsigned m_rtcpPacketsReceived;
    int      m_roundTripTime;

    PTimer m_reportTimer;
    PDECLARE_NOTIFIER(PTimer, OpalRTPSession, TimedSendReport);

    // Congestion control
    OpalMediaTransport::CongestionControl * GetCongestionControl();

    // Quality of service support
    PIPSocket::QoS m_qos;
    unsigned       m_packetOverhead;
    WORD           m_remoteControlPort;
    bool           m_sendEstablished;

    // Call backs for transport data
    OpalMediaTransport::ReadNotifier m_dataNotifier;
    OpalMediaTransport::ReadNotifier m_controlNotifier;

    ApplDefinedNotifierList m_applDefinedNotifiers;

    PTRACE_THROTTLE(m_throttleTxReport,3,60000,5);
    PTRACE_THROTTLE(m_throttleRxEmptyRR,3,60000);
    PTRACE_THROTTLE(m_throttleRxSDES,4,60000);
#if PTRACING
    std::set<RTP_SyncSourceId> m_loggedBadSSRC;
#endif

  private:
    OpalRTPSession(const OpalRTPSession &);
    void operator=(const OpalRTPSession &) { }

    P_REMOVE_VIRTUAL(int,WaitForPDU(PUDPSocket&,PUDPSocket&,const PTimeInterval&),0);
    P_REMOVE_VIRTUAL(SendReceiveStatus,ReadDataOrControlPDU(BYTE *,PINDEX,bool),e_AbortTransport);
    P_REMOVE_VIRTUAL(bool,WriteDataOrControlPDU(const BYTE *,PINDEX,bool),false);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnSendData(RTP_DataFrame &),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnSendData(RTP_DataFrame&,bool),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnSendData(RTP_DataFrame&,RewriteMode),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnSendData(RTP_DataFrame&,RewriteMode,const PTime&),e_AbortTransport);
    P_REMOVE_VIRTUAL(bool,WriteData(RTP_DataFrame &,const PIPSocketAddressAndPort*,bool),false);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnReadTimeout(RTP_DataFrame&),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,InternalReadData(RTP_DataFrame &),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,SendReport(bool),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnReceiveData(RTP_DataFrame&, PINDEX),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnReceiveData(RTP_DataFrame&),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnOutOfOrderPacket(RTP_DataFrame&),e_AbortTransport);
    P_REMOVE_VIRTUAL(SendReceiveStatus,OnPreReceiveData(RTP_DataFrame &),e_AbortTransport);

  friend class RTCP_XR_Metrics;
};


#endif // OPAL_RTP_RTP_H