MNRTPbase.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 MNRTPBASE_H
#define MNRTPBASE_H

#include <assert.h>
#include "MNList.h"
#include "RefCountingSocket.h"
#include "GCPtr.h"
#include "MNMutex.h"
#include "MNTimer.h"      // for the custom timeval operators
#include "MNRTPrandom.h"  // for random32()
#include "MNRTPdefs.h"
#include "MNRTPtime.h"
#include "MNRTPcallback.h"
#include "MNShared_RTP_RTCP.h"
#include "MNValid.h"

class MNRTP;
class MNRTCP;
class MNRTPbase;
class MNRope;

/**************************************************************
 * Klasse: MNRTPbase
 * Beschreibung: enthaelt die gemeinsame funktionalitaet von RTP und RTCP
 * September 99
 **************************************************************/

class MNRTPbase : public RefCountingSocket
{
    class AlloverStats
    {
        /* custom send stats */
        ProtectedU_int64 bytessent;
        struct timeval   firsttimesent;
        MNMutex          send_mutex;
  
        /* custom recv stats */
        ProtectedU_int64 bytesreceived;
        struct timeval   firsttimerecv;
        struct timeval   lasttimerecv;
        struct timeval   mindelta;
        struct timeval   maxdelta;
        struct timeval   averdelta;
        MNMutex          recv_mutex;

    public:
        AlloverStats();

        void add_bytes_sent( int len );
        void add_bytes_received( int len );

        void collect_recvtime();

        u_int64 get_bytes_sent( );
        u_int64 get_bytes_recv( );

        void get_send_time( struct timeval& outvar );
        void get_recv_time( struct timeval& outvar );

        u_int64 get_send_bandwidth( );
        u_int64 get_recv_bandwidth( );

        void get_recv_max_delta( struct timeval& outvar );
        void get_recv_min_delta( struct timeval& outvar );
        void get_recv_aver_delta( struct timeval& outvar );
    };

    class RTPSendStats
    {
        ProtectedU_int32 rtp_packet_count;

        ProtectedU_int32 rtp_octet_count;

        ntp64 first_time_sent;

        MNMutex send_stat_mutex;

        ProtectedU_int32 rtp_init_ts;

        ProtectedU_int32 rtp_last_ts;

    public:
        /*
         * Send statistics
         */
        RTPSendStats()
        {
            rtp_packet_count = 0;
            rtp_octet_count  = 0;
            rtp_init_ts      = 0;
            rtp_last_ts      = 0;
        }

        void rtp_reset()
        {
            send_stat_mutex.lock();
            first_time_sent.upper = 0;
            first_time_sent.lower = 0;
            rtp_packet_count = 0;
            rtp_octet_count  = 0;
            rtp_init_ts      = random32();
            rtp_last_ts      = rtp_init_ts;
            send_stat_mutex.unlock();
        }

        void rtcp_reset()
        {
            send_stat_mutex.lock();
            first_time_sent.upper = 0;
            first_time_sent.lower = 0;
            rtp_packet_count = 0;
            rtp_octet_count  = 0;
            rtp_init_ts      = 0;
            rtp_last_ts      = 0;
            send_stat_mutex.unlock();
        }

        void rtcp_update( u_int32 packets, u_int32 octets, u_int32 ts )
        {
            send_stat_mutex.lock();
            if (first_time_sent.upper == 0)
            {
                first_time_sent = getntptime();
            }
            send_stat_mutex.unlock();
            rtp_packet_count = packets;
            rtp_octet_count = octets;
            if ( (int)rtp_init_ts == 0 )
            {
                rtp_init_ts = ts;
            }
        }

        u_int32 get_rtp_packet_count()
        {
            return rtp_packet_count;
        }

        u_int32 get_rtp_octet_count()
        {
            return rtp_octet_count;
        }

        ntp64 get_first_time_sent()
        {
            send_stat_mutex.lock();
            ntp64 ret = first_time_sent;
            send_stat_mutex.unlock();
            return ret;
        }

        u_int32 get_rtp_init_ts()
        {
            return rtp_init_ts;
        }

        u_int32 get_rtp_last_ts()
        {
            return rtp_last_ts;
        }

        void inc_last_ts( u_int32 increment, rtp_math inc_how )
        {
            assert( (inc_how == RTP_ABSOLUTE_INC) ||
                    (inc_how == RTP_INC) );
            if ( inc_how == RTP_ABSOLUTE_INC )
            {
                rtp_last_ts = increment;
                // No rtp_init_ts to start with time 0
                //rtp_last_ts = rtp_init_ts + increment;
            }
            else
            {
                rtp_last_ts += increment;
            }
        }

        void count_packet( int bytes )
        {
            rtp_packet_count += 1;
            rtp_octet_count  += bytes;
        }
    };

    class RTPRecvStats
    {
    public:
        ProtectedU_int64 bytes_received;

        ProtectedU_int64 packets_received;

        RTPRecvStats()
        {
            bytes_received   = 0;
            packets_received = 0;
        }

        void count_packet( int bytes )
        {
            bytes_received += bytes;
            packets_received += 1;
        }
    };

protected:
    OS::GCPtr<MNShared_RTP_RTCP> _shared;

    MNRTPcallback _cb;

    AlloverStats allover;

    RTPSendStats sstats;

    RTPRecvStats rstats;

    /*vars*/
    ProtectedU_int32 rt_ssrc;
    MNDebugMutex     var_mutex;
    MNDebugMutex     initialized;

    bool _running;

    bool _connected;

    ProtectedBool    _shutting_down;

    ProtectedBool    _force_no_header_check;

    RTP_RC _use_mc;

    u_int32 _recv_port;

    u_int32 _remote_port;

  /* functions */
  void lock();
  void unlock();

  /* Callbacks */

public:
  MNRTPbase( MNSelector&                  sel,
             int                          port,
             int                          remote_port,
             int                          recv_buf_size,
             u_int32                      ssrc,
             OS::GCPtr<MNShared_RTP_RTCP> shared_data );
  MNRTPbase( MNSelector&                  sel,
             MNSocket&                    sock,
             int                          remote_port,
             int                          recv_buf_size,
             u_int32                      ssrc,
             OS::GCPtr<MNShared_RTP_RTCP> shared_data );
  virtual ~MNRTPbase();

    /* Standard functions */

    RTP_RC rt_start( bool sender = false );

  RTP_RC rt_connect();

  RTP_RC rt_bind();

  const char*  rtp_str_err(int err);

  virtual int  reader ( MNRope*& rope, struct sockaddr_in*& dest );
  
  virtual void writer ( );
  
  virtual RTP_RC process_data( MNRope* rope, struct sockaddr_in *dest) = 0;
  virtual void notify_write_enabled( ) = 0;
  
#if 0
  virtual void set_mc_ttl(int val);              /* sets the time to live (ttl) size */
  int          get_mc_ttl();                     /* gets the ttl */
#endif

  const char*  rt_get_targetaddr() const;

  u_int32      rt_get_octet_count();

  u_int64      rt_get_packets_received();

  u_int64      rt_get_bytes_received();

  MNRTPbase*   rt_get_MNRTPbasep();

  virtual MNRTCP* rt_get_rtcp_ptr() {return NULL;}

  int          get_remote_port();

   /* non standard functions */

    int  rt_get_payload_type();

    void rt_change_pt(int payload_t);

    virtual void rt_set_ssrc(u_int32 /*ssrc*/) {}

  u_int32      rt_get_ssrc();

  void         disable_headercheck();
  void         enable_headercheck();
  bool         is_header_check_active();

  virtual void enable_rtcp() {};
  virtual void disable_rtcp() {};

private:
  virtual void do_react_on_bye();

  virtual void do_not_react_on_bye();

  virtual bool is_react_on_bye_on( ) const;

public:
    /* custom recv and send bandwidth stat */
    virtual u_int64 GetBytesSent();
    virtual u_int64 GetBytesRecv();
    struct timeval  GetSentTime();
    struct timeval  GetRecvTime();
    u_int64         GetSendBandwidth();
    u_int64         GetRecvBandwidth();
    struct timeval  GetRecvMaxDelta();
    struct timeval  GetRecvMinDelta();
    struct timeval  GetRecvAverDelta(); 

protected:
    bool is_multicast() const;

    bool is_rtcp_allowed() const;

public:
    bool is_running() const;

    MNRTPcallback& cb() { return _cb; }

private:
    static RTP_RC is_mc(const char* hname);
};

#endif /* MNRTPBASE_H */

---