ns-allinone-2.30/ns-2.30/rtp/rtp.h

#ifndef ns_rtp_h
#define ns_rtp_h

#include "config.h"
#include "object.h"
#include "agent.h"
#include "timer-handler.h"
#include <list> 

#define RTP_M 0x0080 // marker for significant events
class RTPReceiver;
struct sender_report {
        u_int32_t sender_srcid_;
        int pkts_sent_;
        int octets_sent_;
        RTPReceiver* rcvrs_;
        /* per-field member functions */
        u_int32_t& sender_srcid() { return (sender_srcid_); }
        int& pkts_sent() { return (pkts_sent_); }
        int& octets_sent() { return (octets_sent_); }
}; 

struct receiver_report {
        int cum_pkts_lost_;
        double R_tcp_;
        double LSR_;
        double DLSR_;
        double jitter_;
        int  bye_;
        /* per-field member functions */
        int& cum_pkts_lost() { return (cum_pkts_lost_); }
        double& R_tcp() { return (R_tcp_); }
        double& LSR() { return (LSR_); }
        double& DLSR() { return (DLSR_); }
        double& jitter() { return (jitter_); }
        int& bye() { return (bye_); }

}; 

struct hdr_rtp {
        u_int32_t srcid_;
        int seqno_;
        u_int16_t flags_; 
        double timestamp_;
        static int offset_;
        inline static int& offset() { return offset_; }
        inline static hdr_rtp* access(const Packet* p) {
                return (hdr_rtp*) p->access(offset_);
        }
        /* per-field member functions */
        u_int32_t& srcid() { return (srcid_); }
        int& seqno() { return (seqno_); }
        u_int16_t& flags() { return (flags_); }
        double& timestamp() { return (timestamp_); }
        sender_report* sr_;
        receiver_report* rr_;
         
        
};
class RTPSource : public TclObject {
public:
        
        RTPSource* next;
        
        RTPSource(u_int32_t srcid);
        inline u_int32_t srcid() { return (srcid_); }
        inline int np() { return (np_); }
        inline int snp() { return (snp_); }
        inline int ehsr() { return (ehsr_); }
        inline int nbytes() { return (nbytes_); }
        inline int cum_pkts_lost() { return (cum_pkts_lost_);  }
        inline double LSR() { return (LSR_);  }
        inline double SRT() { return (SRT_);  }
        inline bool is_sender() { return (is_sender_);  }
        inline int ps() { return (ps_);  }
        inline double rate() { return (rate_);  }
        inline double transit() { return (transit_);  }
        inline double jitter() { return (jitter_);  }

        inline void np(int n) { np_ += n; }
        inline void snp(int n) { snp_ = n; }
        inline void ehsr(int n) { ehsr_ = n; }
        inline void nbytes(int n) { nbytes_+= n; }
        inline void cum_pkts_lost(int n) { cum_pkts_lost_ += n; }
        inline void LSR(double n) { LSR_= n; }
        inline void SRT(double n) { SRT_= n; }
        inline void is_sender(bool n) { is_sender_= n; }
        inline void ps(int n) { ps_= n; }
        inline void rate(double n) { rate_= n; }
        inline void transit(double n) { transit_= n; }
        inline void jitter(double n) { jitter_= n; }
protected:
        u_int32_t srcid_;
        int np_;
        int snp_;
        int ehsr_;
        int nbytes_;
        int cum_pkts_lost_;
        double LSR_;
        double SRT_;
        bool is_sender_;
        int ps_;
        double rate_;
        double transit_;
        double jitter_;
        
};

class RTPReceiver : public TclObject {
public:
        RTPReceiver* next;
        RTPReceiver(u_int32_t srcid);
        inline u_int32_t srcid() { return (srcid_); }
        inline int cum_pkts_lost() { return (cum_pkts_lost_); }
        inline double eff_rtt() { return (eff_rtt_); }
        inline double rate() { return (rate_); }
        inline void cum_pkts_lost(int n) { cum_pkts_lost_ += n; }
        inline void eff_rtt(double n) { eff_rtt_ = n; }
        inline void rate(double n) { rate_ = n; }
        void receive_report(receiver_report*);
            
protected:
        u_int32_t srcid_;
        int cum_pkts_lost_;
        double eff_rtt_;
        double rate_;
};


class RTPSession : public NsObject {
public:
        RTPSession();
        ~RTPSession();
        /* the receive packet function */
        virtual void recv(Packet* p, Handler*);
        /* the receive control packet function */
        virtual void recv_ctrl(Packet* p);
        /* connection with TCL commands */
        int command(int argc, const char*const* argv);
        /* returns the srcid of the local source */
        inline u_int32_t srcid() { return (localsrc_->srcid()); }
        /* builds the RTCP SR and RR */
        int build_report(int bye);
        /* icrements by one each time when a RTP packet is sent */
        void localsrc_update(int);
        /* updates the trasnmission rate of the RTP sender */
        void update_rate();
        /* passes the Sender Report */
        void pass_sr(sender_report*);
        /*  increments by packet size (in bytes) each time when a RTP packet is sent */
        void localsrc_update_nbytes(int n);
        /* calculates a smooth TCP-friendly rate */
        void smooth_rate(double rate);
        RTPSource* allsrcs_;
        RTPSource* localsrc_;
        RTPReceiver* receivers_;
        int last_np_;
        /* we do not implement this function */
        int build_sdes();
        /* future work */
        int build_bye();
        /* access the RTP header */
        hdr_rtp* access_hdr_rtp();
        /* for debugging */
        void print_rcv();
        int enableFlowControl_;
        double rx_recv_;
        double jitter_;


protected:
        
        RTPSource* lookup(u_int32_t);
        RTPReceiver* lookup_rcv(u_int32_t);
        list<double> lst;
        /* add this source */
        void enter(RTPSource*);
        /* add this receiver */
        void enter_rcv(RTPReceiver*);
        /* calculate RTT */
        void calculate_RTT();
        /* increase rate if packet losses have been not detected since last RR */
        void increase_rate(int a);
        /* measure smooth packet loss ratio */
        void measure_smooth_loss (double n);
        /* calculates TCP-friendly bandwidth share */
        void calculateR_tcp(int a);
        /* the initial session rate */
        void initial_rate(double a);
        double T_one_way_;
        hdr_rtp* rh_;
        /* removes the RTP receiver from the list */
        void remove_receiver(RTPReceiver*);
        int we_sent;
        double RTT_;
        double weight[8];
        double pkt_loss_history[8];
        double smooth_loss_;
        int last_pkts_lost_;
        int last_ehsr_;
        double tx_rate_;
        double time_elapsed_;
        double last_time_report_;
        double alpha;
        /* calculates A */
        void calculate_alpha(double value);


        
};

class RTPAgent;
class RTPTimer : public TimerHandler {
public: 
        RTPTimer(RTPAgent *a) : TimerHandler() { a_ = a; }
protected:
        virtual void expire(Event *e);
        RTPAgent *a_;
};
class RTPAgent : public Agent {
 public:
        RTPAgent();
        virtual void timeout(int);
        virtual void recv(Packet* p, Handler*);
        virtual int command(int argc, const char*const* argv);
        void advanceby(int delta);
        virtual void sendmsg(int nbytes, const char *flags = 0);
 protected:
        virtual void sendpkt();
        virtual void makepkt(Packet*);
        void rate_change();
        virtual void start();
        virtual void stop();
        virtual void finish();
        RTPSession* session_;
        double lastpkttime_;
        int seqno_;
        int running_;
        int random_;
        int maxpkts_;
        double interval_;
        RTPTimer rtp_timer_;
        double timestamp_;
};

#endif

---