MNRTCP.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 MNRTCP_H
#define MNRTCP_H

#include "MNRTPbase.h"
#include "MNRTPList.h"
#include "MNTimer.h"
#include "MNTimerCall.h"
#include "MNMutex.h"
#include "GCPtr.h"
#include "MNSocketQueue.h"
#include "sdp/PayloadTypes.h"
#include "sdp/TransportTypes.h"

class MNRTPPacket;
class MNRTCPPacket;
class MNRTCPPacket_APP;

/***********************************************************************
 * Class: MNRTCPTimer
 * Desc: This class encapsulates extracts timer handling from MNRTCP to
 *       change from one timer thread per RTCP object to one timer for
 *       all RTCP objects.
 *
 *       Right now, this implementation is extremely simple and maps
 *       all calls directly to an included timer object. It requires
 *       the same number of threads as before as well.
 *       When a central RTCP timer is introduced, the sequence number
 *       will have to be requested from the central timer, and calls
 *       will be redirected to that object, but otherwise, the structure
 *       should remain simple.
 ***********************************************************************/

class MNRTCPTimer
{
    /* Timer */
    MNTimer        _rtcp_packet_timer;
    TimerCallBase* _ptr;

public:
    MNRTCPTimer( MNSelector& selector );
    ~MNRTCPTimer( );

    void insert( TimerCallBase*        target,
                 const struct timeval& timeout,
                 bool                  inCallback );
    void reschedule( TimerCallBase*        target,
                     const struct timeval& timeout,
                     bool                  inCallback );
    void cancel( );
};

/***********************************************************************
 * Class: MNRTCPSSrc
 * Desc: The list of synchronization sources can perhaps be extracted
 *       from the core RTCP class.
 ***********************************************************************/

class MNRTCPSSrc
{
    /* stats */
    MNRTPList _list;
    MNMutex   _mutex;

public:
    MNRTCPSSrc( u_int32 initial_ssrc )
    {
        _list.set_my_ssrc( initial_ssrc );
    }

    void set_my_ssrc( u_int32 ssrc, bool lck = false )
    {
        if ( lck ) _mutex.lock();
        _list.set_my_ssrc(ssrc);
        if ( lck ) _mutex.unlock();
    }

    /*
     * returns the number of SSRCs in the list
     */
    int count( )
    {
        return _list.get_sr_count();
    }

    /*
     * returns the number of SSRCs in the list that
     * are labelled RTP_SR_ACTIVE
     */
    int active_count( )
    {
        return _list.get_active_number();
    }

    void lock( )
    {
        _mutex.lock();
    }

    void unlock( )
    {
        _mutex.unlock();
    }

    SSRCEntry* entryptr_for_ssrc( u_int32 ssrc )
    {
        return _list.get_ssrc_info_ptr( ssrc );
    }

    SSRCEntry entry_for_ssrc( u_int32 ssrc )
    {
        return _list.get_ssrc_info( ssrc );
    }

    u_int32 get_first_ssrc( bool lck )
    {
        if ( lck ) {
            u_int32 ret;
            _mutex.lock();
            ret = _list.get_first_ssrc();
            _mutex.unlock();
            return ret;
        } else {
            return _list.get_first_ssrc();
        }
    }

    u_int32 get_first_ssrc()
    {
        return _list.get_first_ssrc();
    }

    u_int32 get_next_ssrc( u_int32 ssrc, bool lck )
    {
        if ( lck ) {
            u_int32 ret;
            _mutex.lock();
            ret = _list.get_next_ssrc( ssrc );
            _mutex.unlock();
            return ret;
        } else {
            return _list.get_next_ssrc( ssrc );
        }
    }

    u_int32 get_next_ssrc(u_int32 ssrc)
    {
        return _list.get_next_ssrc( ssrc );
    }

    void make_inactive( )
    {
        _list.make_inactive();
    }

    void increment_heared_and_check_old( bool lck = false )
    {
        if ( lck ) _mutex.lock();
        _list.increment_heared_and_check_old();
        if ( lck ) _mutex.unlock();
    }

    bool find_ssrc( u_int32 ssrc, bool lck = false )
    {
        if ( lck ) {
            bool ret;
            _mutex.lock();
            ret = _list.find_ssrc( ssrc );
            _mutex.unlock();
            return ret;
        } else {
            return _list.find_ssrc( ssrc );
        }
    }

    struct sockaddr_in get_addr( u_int32 ssrc, bool lck = false )
    {
        if ( lck ) {
            struct sockaddr_in ret;
            _mutex.lock();
            ret = _list.get_addr( ssrc );
            _mutex.unlock();
            return ret;
        } else {
            return _list.get_addr( ssrc );
        }
    }

    void update_sr( rtcp_t*                   sr,
                    const struct sockaddr_in& dest_,
                    bool                      lck = false )
    {
        if ( lck ) _mutex.lock();
        _list.update_sr( sr, dest_ );
        if ( lck ) _mutex.unlock();
    }

    void update_rr( rtcp_t*                   rr,
                    const struct sockaddr_in& dest_,
                    int&                      count,
                    bool                      lck = false )
    {
        if ( lck ) _mutex.lock();
        _list.update_rr( rr, dest_, count );
        if ( lck ) _mutex.unlock();
    }

    void update_sdes( rtcp_t *sdes, bool lck = false )
    {
        if ( lck ) _mutex.lock();
        _list.update_sdes( sdes );
        if ( lck ) _mutex.unlock();
    }

    void update_bye( rtcp_t *bye, bool lck = false )
    {
        if ( lck ) _mutex.lock();
        _list.update_bye( bye );
        if ( lck ) _mutex.unlock();
    }

    void update_ssrc( rtp_hdr_t*         rtp,
                      ntp64              arr_time,
                      struct sockaddr_in dest_,
                      bool               lck = false )
    {
        if ( lck ) _mutex.lock();
        _list.update_ssrc( rtp, arr_time, dest_ );
        if ( lck ) _mutex.unlock();
    }

    void update_ssrc( MNRTPPacketPtr     packet,
                      ntp64              arr_time,
                      struct sockaddr_in dest_,
                      bool               lck = false )
    {
        if ( lck ) _mutex.lock();
        _list.update_ssrc( packet, arr_time, dest_ );
        if ( lck ) _mutex.unlock();
    }
};

/**************************************************************
 * Class: MNRTCP
 * Desc: Implementation of RTCP, inherits MNRTPbase for basic
 *       RTP socket handling and connection to an MNRTP class.
 *       Inherits MNTimerCall for RTCP timer callbacks.
 **************************************************************/

class MNRTCP: public MNRTPbase
{
private:
  /* vars */
  char                *rtcp_send_buffer;
  size_t              rtcp_send_buffer_size;
  MNMutex             rtcp_send_buffer_mutex;
  TimerCall<MNRTCP>   _timer_call;
 
  char                 rtcp_app_name[5];  /* with terminating 0 */

  SDESSchedule         _sdes_schedule;
  
  ProtectedInt32       rtcp_last_packet_size;
  ProtectedVar<double> rtcp_average_packet_size;

  MNMutex              rtcp_initialized;

  /* stats */
  // MNRTPList            ssrc_list;
  // MNMutex              ssrc_list_mutex;
  MNRTCPSSrc           _ssrc_list;

  /* flags */  
  ProtectedBool        rtcp_sender_report;               /* if true send a sr, else rr */

  MNRTCPTimer          _timer;

  /* Contains a queue of iovec pointers referring to not sent RTP/TCP data */
  MNSocketQueue* _data_queue;

  /* functions */

    int rtcp_send_packet(const char* app, int len, int subtype, bool bye); 

    struct timeval Timer_sched_cb();

    void rtcp_lock();
    void rtcp_unlock();

    /* call backs */

    virtual void timer_callback( void* ref_data, TimerCallBase* ptr );

    RTSP::TransportTypes _requested_transport;

protected:
    friend class MNRTP;

    MNRTCP( MNSelector&                  sel,
            u_int32                      ssrc,
            int                          port,
            int                          remote_port,
            OS::GCPtr<MNShared_RTP_RTCP> shared_data,
            RTSP::TransportTypes         requested_transport = RTSP::RTP_AVP_UDP );

    MNRTCP( MNSelector&                  sel,
            u_int32                      ssrc,
            MNSocket&                    port,
            int                          remote_port,
            OS::GCPtr<MNShared_RTP_RTCP> shared_data,
            RTSP::TransportTypes         requested_transport = RTSP::RTP_AVP_UDP );

public:
    virtual ~MNRTCP();

    /* Standard functions */

    RTP_RC rtcp_start( );

    virtual void rt_set_ssrc(u_int32 ssrc);        /* changes the own ssrc */
  
    virtual RTP_RC process_data( MNRope* rope, struct sockaddr_in *dest);

    virtual void notify_write_enabled( );

    int rtcp_send_app( char* app, int len, int subtype );

    int rtcp_send_app( MNRTCPPacket_APP* packet );

    void set_send_buffer( size_t size );

    void rtcp_set_app_name( const char* name );

    void set_send_sdes(rtcp_sdes_type_t type, char* text, int prio);

    const sdes_list_item* rtcp_get_sdes_text(rtcp_sdes_type_t type);

    virtual MNRTCP* rt_get_rtcp_ptr();

    bool         rtcp_find(u_int32 ssrc);

    struct sockaddr_in rtcp_get_ssrc_addr(u_int32 ssrc);

    void rtcp_reset(u_int32 ssrc);

    SSRCEntry*   rtcp_get_info_ptr(u_int32 ssrc);

    SSRCEntry    rtcp_get_info(u_int32 ssrc);

    u_int32      rtcp_get_first_ssrc();
    u_int32      rtcp_get_next_ssrc( u_int32 ssrc );
    void         rtcp_update_recv( rtp_hdr_t*         rtp,
                                   ntp64              time_,
                                   struct sockaddr_in dest );
    void         rtcp_update_recv( MNRTPPacketPtr     packet,
                                   ntp64              time_,
                                   struct sockaddr_in dest );
    void rtcp_update_send( u_int32 packet_count,
                           u_int32 octet_count,
                           u_int32 ts );
};

#endif

---