MNRTPList.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef MNRTPLIST_H
#define MNRTPLIST_H

/*
 * Jones Lists for storing data related with rtp/rtcp statistics
 */

#include "mnstream.h"
#include "MNList.h"
#include "MNRTPdefs.h"
#include "MNRTPtime.h"
#include "MNRTPPacket.h"

class SSRCEntry;
class MNRTPList;

typedef SSRCEntry* SSRCEntryPtr;

/***********************************************************************
 * SDESItemList
 ***********************************************************************/

class SDESItemList
    : private MNList<SDESItem*>
{
    int _refCount;
public:
    SDESItemList() {
        _refCount = 0;
    }

    void incRefCount() {
        _refCount += 1;
    }
    void decRefCount() {
        _refCount -= 1;
    }
    int refCount() {
        return _refCount;
    }

    void* first() {
        return MNList<SDESItem*>::first();
    }

    void next( void*& pix ) {
        pix = MNList<SDESItem*>::succ(pix);
    }

    SDESItem* operator()( void* pix ) {
        return MNList<SDESItem*>::inf(pix);
    }

    void append( SDESItem* p ) {
        MNList<SDESItem*>::push_back ( p );
    }

    void clear() {
        MNList<SDESItem*>::clear();
    }

    void del( void* pix ) {
        MNList<SDESItem*>::del_item(pix);
    }
};

/***********************************************************************
 * SSRCEntry
 ***********************************************************************/

class SSRCEntry
{
    /* RTP */
    u_int32            _ssrc;
    rtp_sr_state       _state;
    u_int16            _first_seq;
    u_int16            _max_seq; 
    u_int16            _seq_cycles;    /* times seq wraped around */
    u_int32            _packet_count;
    u_int32            _packet_ts;
    u_int32            _arrive_ts;
    ntp64              _arrive_time;
    ntp64              _first_time;
    float              _jitter;
    struct sockaddr_in _dest;

    /* RTCP SR and SDES*/
    u_int32            _lsr;    
    u_int32            _lsr_time;   
    u_int32            _rtt;    
    u_int32            _sr_packet_count;  
    u_int32            _sr_octet_count;   
    u_int32            _sr_ts;  
    u_int32            _expected_prio;     /* expected seq no of the last report */
    u_int32            _received_prio;     /* received packets at the last report */
    SDESItemList* _sdes_items; 

    /* RTCP RR */
    unsigned int _rr_fraction:8; 
    int          _rr_lost:24;
    u_int32      _rr_last_seq;
    u_int32      _rr_jitter;
    u_int32      _rr_lsr;
    u_int32      _rr_dlsr;

    /* last_heared */
    u_int32     _last_heared;

    typedef struct sockaddr_in Sockaddr;

private:
    void redo( const SSRCEntry& orig );
    /* 
     * Note that this function is not called clone() or copy()
     * because it is insecure. The contents of the list sdes_items
     * are not copied, only the management part is done again.
     */

    void clear( );

    SSRCEntry* set_rr_vals( unsigned int fraction,
                            int          lost,
                            u_int32      last_seq,
                            u_int32      jitter,
                            u_int32      lsr,
                            u_int32      dlsr );
public:
    SSRCEntry()
    {
        clear();
    }

    SSRCEntry( const SSRCEntry& orig )
    {
        redo(orig);
    }

    virtual ~SSRCEntry();

    SSRCEntry& operator=( const SSRCEntry& orig )
    {
        redo(orig);
        return *this;
    }

    void logprint( ostream& ostr );

protected:
    friend class MNRTPList;

    /*
     * Set functions
     */
    SSRCEntry* set_ssrc( u_int32 val );
    SSRCEntry* set_state( rtp_sr_state val );
    SSRCEntry* set_first_seq( u_int16 val );
    SSRCEntry* set_max_seq( u_int16 val );
    SSRCEntry* set_seq_cycles( u_int16 val );
    SSRCEntry* set_packet_count( u_int32 val );
    SSRCEntry* set_packet_ts( u_int32 val );
    SSRCEntry* set_arrive_ts( u_int32 val );
    SSRCEntry* set_arrive_time( const ntp64& val );
    SSRCEntry* set_first_time( const ntp64& val );
    SSRCEntry* set_jitter( float val );
    SSRCEntry* set_dest( const struct sockaddr_in& val );
    SSRCEntry* set_lsr( u_int32 val );
    SSRCEntry* set_lsr_time( u_int32 val );
    SSRCEntry* set_rtt( u_int32 val );
    SSRCEntry* set_sr_packet_count( u_int32 val );
    SSRCEntry* set_sr_octet_count( u_int32 val );
    SSRCEntry* set_sr_ts( u_int32 val );
    SSRCEntry* set_expected_prio( u_int32 val );
    SSRCEntry* set_received_prio( u_int32 val );
    SSRCEntry* set_sdes_items( SDESItemList* val );
    SSRCEntry* set_last_heared( u_int32 val );

    /*
     * Get functions, note that sdes_items() is not const!
     */
public:
    inline u_int32         ssrc()            const { return _ssrc; }
    inline rtp_sr_state    state()           const { return _state; }
    inline u_int16         first_seq()       const { return _first_seq; }
    inline u_int16         max_seq()         const { return _max_seq; }
    inline u_int16         seq_cycles()      const { return _seq_cycles; }
    inline u_int32         packet_count()    const { return _packet_count; }
    inline u_int32         packet_ts()       const { return _packet_ts; }
    inline u_int32         arrive_ts()       const { return _arrive_ts; }
    inline const ntp64&    arrive_time()     const { return _arrive_time; }
    inline const ntp64&    first_time()      const { return _first_time; }
    inline float           jitter()          const { return _jitter; }
    inline const Sockaddr& dest()            const { return _dest; }
    inline u_int32         lsr()             const { return _lsr; }
    inline u_int32         lsr_time()        const { return _lsr_time; }
    inline u_int32         rtt()             const { return _rtt; }
    inline u_int32         sr_packet_count() const { return _sr_packet_count; }
    inline u_int32         sr_octet_count()  const { return _sr_octet_count; }
    inline u_int32         sr_ts()           const { return _sr_ts; }
    inline u_int32         expected_prio()   const { return _expected_prio; }
    inline u_int32         received_prio()   const { return _received_prio; }
protected:
    inline SDESItemList*   sdes_items()            { return _sdes_items; }
    inline u_int32         last_heared()     const { return _last_heared; }

    /*
     * Functions that execute several set-functions at a time, or
     * functions that performs dedicated operations on a single
     * member variable.
     */

    SSRCEntry* set_lsr_time_now( );

    void compute_rtt( );

    SSRCEntry* set_arrive_times( u_int32      packet_ts,
                                 u_int32      arrive_ts,
                                 const ntp64& arrive_time );

    SSRCEntry* set_rr_vals( const rtcp_rr_t& report );

    void               delete_sdes_items( );
    SDESItem* find_by_type( u_int8 type );

    SSRCEntry* inc_seq_cycles( );
    SSRCEntry* inc_packet_count( );
    SSRCEntry* inc_last_heared( );

public:
    void write_rr_block_to_buffer( void*        buffer,
                                   size_t       len,
                                   const ntp64& now );
};

/***********************************************************************
 * MNRTPList
 ***********************************************************************/

class MNRTPList
{
    /*******************************************************************
     * SSRCEntryList
     *******************************************************************/
public:
    class SSRCEntryList
        : private MNList<SSRCEntry*>
    {
    public:
        void* first() {
            return MNList<SSRCEntry*>::first();
        }
    
        void next( void*& pix ) {
            pix = MNList<SSRCEntry*>::succ(pix);
        }
    
        SSRCEntry* inf( void* pix ) {
            return MNList<SSRCEntry*>::inf(pix);
        }
    
        void append( SSRCEntry* p ) {
            MNList<SSRCEntry*>::push_back ( p );
        }
    
        void clear() {
            MNList<SSRCEntry*>::clear();
        }
    
        void del( void* pix ) {
            MNList<SSRCEntry*>::del_item(pix);
        }
    
        size_t length( ) {
            return MNList<SSRCEntry*>::length();
        }
    
    private:
        SSRCEntry* operator()( void* pix ) {
            return MNList<SSRCEntry*>::inf(pix);
        }
    };

    /*******************************************************************
     * SSRCEntriesAll
     *******************************************************************/
private:    
    class SSRCEntriesAll
    {
        SSRCEntry** _array;
        size_t      _size;
    
        SSRCEntriesAll& operator=( const SSRCEntriesAll& );
    
        SSRCEntriesAll( const SSRCEntriesAll& );
    
    public:
        SSRCEntriesAll( SSRCEntryList& entries );
    
        ~SSRCEntriesAll();
    
        inline size_t size() const {
            return _size;
        }
    
        SSRCEntry* inf( size_t idx );
    };

private:
   SSRCEntryList      daten;
   int                sr_count;
   u_int32            my_ssrc;

   void clr();  /* clear all Data */
   void update_sdes_item( SSRCEntry*              ssrc_entry,
                          const rtcp_sdes_item_t* item);

public:
   MNRTPList();
   ~MNRTPList();                                   /* clear all Data */
   void               update_ssrc( rtp_hdr_t*         rtp,
                                   ntp64              arr_time,
                                   struct sockaddr_in dest_ ); 
   void               update_ssrc( MNRTPPacketPtr     rtp,
                                   ntp64              arr_time,
                                   struct sockaddr_in dest_ ); 
   /* insert or update a ssrc, validity of rtp header is not checked */
   void               update_sr(rtcp_t* sr, struct sockaddr_in dest_);
   void               update_rr(rtcp_t* rr, struct sockaddr_in dest_, int& count);
   void               update_sdes(rtcp_t* sdes);
   void               update_bye(rtcp_t* bye);
   void               delete_ssrc(u_int32);                    /* delete ssrc (as made by bye packet) */
   
   void               set_my_ssrc(u_int32 ssrc);

   u_int32            get_first_ssrc();
   u_int32            get_next_ssrc(u_int32 ssrc);
   bool               find_ssrc(u_int32); 
   SSRCEntry*         get_ssrc_info_ptr(u_int32); 
   SSRCEntry          get_ssrc_info(u_int32);
   void               make_inactive();                         /* make all sources inactive -> after each report (dont change states like old..)*/
   void               increment_heared_and_check_old();        /* increment all last_heared */
   struct sockaddr_in get_addr(u_int32 ssrc);                  /* get address data of ssrc, used for detecting ssrc collissions */

   int                get_sr_count();
   int                get_active_number();
   void               delete_all();
};
#endif

---