MNRTP.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 MNRTP_H
#define MNRTP_H

#include "MNArrayList.h"
#include "MNRTPbase.h"
#include "MNRTCP.h"
#include "MNRTPSendCsrcList.h"
#include "MNRTPSsrcCollisionList.h"
#include "MNSocketQueue.h"
#include "sdp/PayloadTypes.h"
#include "sdp/TransportTypes.h"


struct addr_list_item;

/***********************************************************************
 * MNRTP
 * Beschreibung: enthaelt die basis funktionalitaet von RTP
 * September 99
 ***********************************************************************/

class MNRTP : public MNRTPbase
            , public MNRTP_RTCPbye_callback
            , public MNRTP_Collision_callback
{
    /* Constructor and destructor section */

    MNRTP& operator=( const MNRTP& );

    MNRTP( const MNRTP& );

public:
    MNRTP( MNSelector&          sel,
           MNSocket*            rtpsock,
           MNSocket*            rtcpsock,
           int                  remote_port,
           const char*          targetaddr_,
           int                  payload_t,
           u_int32              bw,
           RTSP::TransportTypes requested_transport = RTSP::RTP_AVP_UDP,
           int                  dpt_ts_rate = -1);

    virtual ~MNRTP();

protected:
    /******vars******/

    SendCsrcList _send_csrcs;

    SsrcCollisionList ssrc_coll_list;

    struct sockaddr_in* _target_save;

  ProtectedU_int32 ssrc_collission_counter;

  ProtectedInt32   rtcp_port;

  struct           sockaddr_in rtp_my_addr;

  // ProtectedU_int32 rtp_last_ts;                     /* last timestamp */

  ProtectedU_int16 rtp_seq;

  // MNRTCP*          RTCPslave_ptr;

  MNMutex          rtp_initialized;
  MNMutex          send_mutex;

  /****** functions ******/

private:
  int              make_even(int port);

  void             rtp_resolve_ssrc_col(struct sockaddr_in *dest); /* resolves a ssrc collision */

  virtual RTP_RC process_data( MNRope* rope, struct sockaddr_in *dest);

  void             notify_write_enabled();
  void             rtp_timeout_check();             /* checks the ssrc_coll list for timed out items */
  void             rtp_lock();
  void             rtp_unlock();

  /****** call back ******/
  virtual void     RTPcollission_cb(struct sockaddr_in *dest);

  RTSP::TransportTypes _requested_transport;

  /****** The queue of not sent RTP data during a RTP/TCP transfer ******/
  MNSocketQueue*  _data_queue;

  /****** RTCP ******/
  /* starts if rtcp_allowed is true*/
  MNRTCP*          _rtcp_server;
  MNMutex          rtcp_mutex;
  // ProtectedBool    rtcp_ok;
  virtual void     RTCPbye_cb(u_int32 ssrc, text_item_t *bye_text);
 
public:
  /****** Standard functions ******/

    RTP_RC rtp_start( bool sender = false);

    int rtp_send( MNRope*  buf,
                  int      marker,
                  int      ts_in_value,
                  rtp_math tstamp );

    int rtp_send_ext( MNRope*  buf,
                      char*    ext_buf,
                      int      ext_len,
                      u_int16  ext_type,
                      int      marker,
                      int      ts_inc_value,
                      rtp_math tstamp);

  /* times a collision occurred */
  u_int32      get_collision_counter();

  /* sets the time to live (ttl) size */
  virtual void set_mc_ttl(int val);

    SendCsrcList& rtp_csrcs() {
        return _send_csrcs;
    }
    // void         rtp_csrc_add(u_int32 csrc);
    // void         rtp_csrc_del(u_int32 csrc);
    // bool         rtp_csrc_find(u_int32 csrc);
    // void         rtp_csrc_clear();
    // u_int16      rtp_csrc_get_count();
    // u_int32      rtp_csrc_get_first();
    // u_int32      rtp_csrc_get_next(u_int32 csrc);

  /****** non standard functions ******/

  /* set ssrc to a defined value, if a collission is detected (and
   * ssrc_collision == true) a random ssrc is reset!!*/
  virtual void rt_set_ssrc(u_int32 ssrc);

    void disable_collision_detection();

    void enable_collision_detection();

    void rt_set_bandwidth(u_int32 bw);

    u_int32 rt_get_bandwidth();

  /****** RTCP ******/

  /* get the rtcp base pointer, needed for init slaves */
  virtual MNRTCP* rt_get_rtcp_ptr();

    void         rtcp_stop( bool bye, const char* reason );

  /* new RTCPServer is created (if no one is active) */
  bool         rtcp_start( MNSocket* rtcpsock );

    void enable_rtcp();

    void disable_rtcp();

  /* send app defined packet, app must be multiple of u_int32, len is in u_int32 words*/
  int          rtcp_send_app(char* app, int len, int subtype);

  void         rtcp_set_app_name( const char* name );

  void         stopRTPUdpServer( );

  /* register the app reader call back*/
  void         rtcp_register_RTCPreader_cb(MNRTP_RTCPreader_callback* p);

  /* prio gives the messages priority - after prio packets the message is sent */
  void         rtcp_set_sdes(rtcp_sdes_type_t type, char* text, int prio);

  /* returns the text of a stored sdes message, NULL if not in the list */
  const sdes_list_item* rtcp_get_sdes_text(rtcp_sdes_type_t type);

  u_int32      rtcp_get_first_ssrc();
  u_int32      rtcp_get_next_ssrc(u_int32 ssrc);
private:
  SSRCEntry*   rtcp_get_ssrc_info_ptr(u_int32 ssrc);
public:
  SSRCEntry    rtcp_get_ssrc_info(u_int32 ssrc);
  
  /****** custom bandwidth methods ******/
  virtual u_int64 GetBytesSent();
  virtual u_int64 GetBytesRecv();

private:
    bool is_rtcp_running() const;
};

#endif

---