RTPSession Class Reference

#include <rtp.h>

List of all members.

Public Member Functions
	RTPSession ()
	~RTPSession ()
virtual void	timeout (int)
virtual void	recv (Packet *p, Handler *)
virtual void	recv_ctrl (Packet *p)
int	command (int argc, const char *const *argv)
u_int32_t	srcid ()
int	build_report (int bye)
void	localsrc_update (int)
void	update_rate ()
void	localsrc_update_nbytes (int n)
void	smooth_rate (double rate)
int	build_sdes ()
int	build_bye ()
hdr_rtp *	access_hdr_rtp ()
void	print_rcvs ()
void	print_srcs ()
void	start_timer ()
void	stop_timer ()
Public Attributes
RTPSession *	next
RTPSource *	allsrcs_
RTPSource *	localsrc_
RTPReceiver *	receivers_
SimStream *	stream_
int	last_np_
int	enableFlowControl_
double	rx_recv_
double	jitter_
double	smooth_rate_
SenderTimer	sender_timer_
Protected Member Functions
RTPSource *	lookup (u_int32_t)
RTPReceiver *	lookup_rcv (u_int32_t)
void	enter (RTPSource *)
void	enter_rcv (RTPReceiver *)
void	calculate_RTT ()
void	increase_rate (int a)
void	measure_smooth_loss (double n)
void	calculateR_tcp (int a)
void	initial_rate (double a)
void	remove_receiver (RTPReceiver *)
void	calculate_alpha (double value)
void	evaluate_jitter (double value)
void	remove_sender (RTPSource *)
void	setInst_tx (double newValue)
void	average_tx ()
void	slow_start ()
Protected Attributes
list< double >	lst
double	T_one_way_
hdr_rtp *	rh_
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
double	smooth_factor
list< double >	jitter_lst
double	z_score
double	low_
double	high_
int	level_
double	avg_tx_
list< double >	tx_lst
int	running_

---

Detailed Description

the session class is the heart of the RTP protocol. all main functions can be found here. Any extension to the RTP code should reference this class

Definition at line 300 of file rtp.h.

---

Constructor & Destructor Documentation

RTPSession::RTPSession

(

)

zero argument constructor

Definition at line 83 of file session-rtp.cc.

References alpha, avg_tx_, enableFlowControl_, high_, jitter_, last_time_report_, level_, low_, NOW, RTT_, rx_recv_, smooth_factor, smooth_loss_, smooth_rate_, weight, and z_score.

        : allsrcs_(0), localsrc_(0), receivers_(0),stream_(0),last_np_(0),sender_timer_(this), T_one_way_(0),rh_(0),
        we_sent(0),last_pkts_lost_(0),last_ehsr_(-1),tx_rate_(0), time_elapsed_(0),running_(0)
{
        bind("enableFlowControl_", &enableFlowControl_);
        bind("rx_recv_",&rx_recv_);
        bind("jitter_",&jitter_);
        bind("RTT_",&RTT_);
        bind("z_score",&z_score);
        bind("smooth_loss_",&smooth_loss_);
        bind("level_",&level_);
        smooth_rate_ = 0;
        alpha = 1;
        smooth_factor = 0.9;
        last_time_report_ = NOW;
        low_ = 0;
        high_= 0;
        avg_tx_ = 0;
        
        weight[0] = 1;
        weight[1] = 1;
        weight[2] = 1;
        weight[3] = 1;
        weight[4] = 0.8;
        weight[5] = 0.6;
        weight[6] = 0.4;
        weight[7] = 0.2;
}

RTPSession::~RTPSession

(

)

destructor

Definition at line 115 of file session-rtp.cc.

References allsrcs_, localsrc_, lst, RTPReceiver::next, RTPSource::next, receivers_, and tx_lst.

{
        while (allsrcs_ != 0) {
                RTPSource* p = allsrcs_;
                allsrcs_ = allsrcs_->next;
                delete p;
        }
        delete localsrc_;
        while (receivers_ != 0) {
                RTPReceiver* p = receivers_;
                receivers_ = receivers_->next;
                delete p;
        }
        lst.~list<double>();
        tx_lst.~list<double>();
        
}

---

Member Function Documentation

void RTPSession::timeout

(

int

)

[virtual]

Definition at line 904 of file session-rtp.cc.

References average_tx(), avg_tx_, level_, running_, sender_timer_, SimStream::setAvg_tx(), stream_, and TIMER_TIMEOUT.

Referenced by SenderTimer::expire().

{
        if(running_) { 
                average_tx();
                stream_->setAvg_tx(avg_tx_,level_);
                sender_timer_.resched(TIMER_TIMEOUT);
        } 
}

void RTPSession::recv	(	Packet *	p,
		Handler *
	)			[virtual]

this method accesses the RTP packets it adds a newly heard source, which is the originator of the RTP packet, calculates the one way trip time and calls the calculate_RTT(T_one_way_ , eff_rtt) method for the RTT calculation. It measures also the delay jitter time of the RTP packets. Use this method to update any wished field of the Source class instances

Parameters:

	p	the RTP packet that just received by the RTP Agent

Definition at line 308 of file session-rtp.cc.

References hdr_rtp::access(), SimStream::compare(), RTPSource::cum_pkts_lost(), RTPSource::ehsr(), evaluate_jitter(), RTPSource::jitter(), jitter_, last_ehsr_, localsrc_, lookup(), RTPSource::nbytes(), NOW, RTPSource::np(), RTPSource::ps(), hdr_rtp::seqno(), RTPSource::srcid(), hdr_rtp::srcid(), stream_, hdr_rtp::T_epoch(), T_one_way_, hdr_rtp::timestamp(), and RTPSource::transit().

Referenced by RTPAgent::recv().

{

        hdr_cmn* mh = hdr_cmn::access(p);
        hdr_rtp* rh = hdr_rtp::access(p);
        RTPSource* s = lookup(rh->srcid());

        if (s == 0) {
                if(rh->srcid()!=localsrc_->srcid()){
                        Tcl& tcl = Tcl::instance();
                        tcl.evalf("%s new-source %d", name(),rh->srcid());
                        s = (RTPSource*)TclObject::lookup(tcl.result());
                        last_ehsr_ = rh->seqno();
                }
        }
        if(rh->srcid()!=localsrc_->srcid())
        {
                // calculate one way trip time
                T_one_way_ = NOW - rh->timestamp();
                // count packet losses
                int pkts_lost = 0;
                int difference =  rh->seqno() - s->ehsr();  
                if (difference <= 1) { // to deal with the first RTP packet in which s->ehrs() = -1
                        pkts_lost = 0;
                        
                }
                
                if (difference > 1) {
                        pkts_lost = difference -1;
                        
                }
                // calculate delay jitter, see RFC 3550 Appendix A8
                double transit = NOW - rh->timestamp();
                double d = transit - s->transit();
                s->transit(transit);
                if (d < 0) d = -d;
                s->jitter( s->jitter() + (1./16.) * (d - s->jitter()));
                evaluate_jitter(s->jitter());
                jitter_ = s->jitter();
//              printf("jitter %f \n",s->jitter());
                s->np(1); // counts the packets that I have received from sender s
                s->cum_pkts_lost(pkts_lost);// counts the packets that I have lost from sender s
                s->ehsr(rh->seqno());// the first ehsr = -1
                s->nbytes(mh->size()); // counts the number of bytes that I have lost from sender s
                s->ps(mh->size());// the packet size in bytes
                if(rh->T_epoch() == 1) {
                        stream_->compare();
                }
        }
        Packet::free(p);
}

void RTPSession::recv_ctrl

(

Packet *

p

)

[virtual]

the function that accesses and exploits the SR and RR here is where the sender calculates the effective RTT time based on the receiver's RR. The sender also updates its transmission rate based on the receivers' RR. We don't exploit the SR in this implementation but a third party eg a network controller can exploit both SR and RR, witout in fact joining the session

Parameters:

p

the RTCP packet

Definition at line 526 of file session-rtp.cc.

References hdr_rtp::access(), receiver_report::bye(), calculate_alpha(), receiver_report::DLSR(), RTPReceiver::eff_rtt(), sr_extensions::eff_rtt(), enableFlowControl_, enter_rcv(), sender_report::high_tx(), RTPSource::is_sender(), localsrc_, lookup(), lookup_rcv(), sender_report::low_tx(), receiver_report::LSR(), RTPSource::LSR(), sender_report::medium_tx(), RTPReceiver::next, sr_extensions::next, NOW, receiver_report::R_tcp(), RTPReceiver::rate(), receivers_, remove_receiver(), hdr_rtp::rr_, sender_report::s_ext_, sender_report::sender_srcid(), SimStream::setHigh_tx(), SimStream::setLow_tx(), SimStream::setMedium_tx(), slow_start(), hdr_rtp::sr_, RTPReceiver::srcid(), sr_extensions::srcid(), hdr_rtp::srcid(), RTPSource::srcid(), RTPSource::SRT(), stream_, hdr_rtp::timestamp(), and update_rate().

Referenced by RTCPAgent::recv().

{
        hdr_cmn* mh = hdr_cmn::access(p);
        hdr_rtp* rh = hdr_rtp::access(p);
        u_int32_t local_src = localsrc_->srcid();
        
        if(rh->srcid() != local_src) {
        
                if (rh->sr_ != 0) { // get the Sender report
                        RTPSource* source = lookup(rh->sr_->sender_srcid());
                        if (source != 0 && source->srcid()!= local_src) {
                                source->LSR(rh->timestamp());
                                source->SRT(NOW);
                                stream_->setLow_tx(rh->sr_->low_tx());
                                stream_->setMedium_tx(rh->sr_->medium_tx());
                                stream_->setHigh_tx(rh->sr_->high_tx());
                                if(rh->sr_->s_ext_ != 0) {
                                sr_extensions* se = new sr_extensions;
                                for (se = rh->sr_->s_ext_; se != 0; se = se->next) {

                                        if(se->srcid()==localsrc_->srcid()) {
                                        
                                                if(se->eff_rtt() == 0) {
                                                        calculate_alpha(0);
                                                } else calculate_alpha(se->eff_rtt());
                                        }
                                                
                                }// end for
                                }
                                
                        }
                }

                if(localsrc_->is_sender()){ // get the Receiver report

                                if(rh->rr_ != 0){
                                        RTPReceiver* s = lookup_rcv(rh->srcid());
                                                
                                                if (s != 0) {
                                                        for (s = receivers_; s!= 0; s = s->next) {
                
                                                                if(rh->srcid() == s->srcid()) {
                                                                        
                                                                        double eff_rtt = 0.0;
                                                                
                                                                        if(rh->rr_->LSR()!=0) {
                                                                        eff_rtt = NOW - rh->rr_->LSR() - rh->rr_->DLSR();
                                                                        }
                                                                        s->eff_rtt(eff_rtt);
                                                                        s->rate(rh->rr_->R_tcp());
                                                                        if(rh->rr_->bye() == 1) {
                                                                                remove_receiver(s);
                                                                        }
                                                                        
                                                                }       

                                                        } // end for loop
                                                        if(enableFlowControl_ == 1 && receivers_) {
                                                                update_rate();
                                                                } else {
                                                                        printf("TIME: %f Sender %d NOT HAVING RECEIVERS \n", NOW,localsrc_->srcid());
                                                                        slow_start();
                                                                        
                                                                        }
                                                } //end if
                                                else {
                                                        s = new RTPReceiver(rh->srcid());
                                                        enter_rcv(s);
                                                }
                                                
                                        }
                                }
        }

        Tcl::instance().evalf("%s sample-size %d", name(), mh->size());
        Packet::free(p);
}

int RTPSession::command	(	int	argc,
		const char *const *	argv
	)

the command function that handles TCL commands

Definition at line 826 of file session-rtp.cc.

References enter(), high_, initial_rate(), localsrc_, low_, and stream_.

{
        if (argc == 3) {
                if (strcmp(argv[1], "enter") == 0) {
                        RTPSource* s = (RTPSource*)TclObject::lookup(argv[2]);
                        enter(s);
                        return (TCL_OK);
                }
                if (strcmp(argv[1], "localsrc") == 0) {
                        localsrc_ = (RTPSource*)TclObject::lookup(argv[2]);
                        enter(localsrc_);
                        return (TCL_OK);
                }
                if (strcmp(argv[1], "rate") == 0) {
                        initial_rate(atoi(argv[2]));
                        return(TCL_OK);
                }
                if (strcmp(argv[1], "stream") == 0) {
                        stream_ = (SimStream*)TclObject::lookup(argv[2]);
                        return (TCL_OK);
                }
        }
        if (argc == 4) {
                if (strcmp(argv[1], "bw-limits") == 0) {
                        low_ = atoi(argv[2])/8;
                        high_ = atoi(argv[3])/8;
                        return(TCL_OK);
                }
        }

        return (TclObject::command(argc, argv));
}

u_int32_t RTPSession::srcid

(

)

[inline]

Definition at line 313 of file rtp.h.

References localsrc_, and RTPSource::srcid().

Referenced by SimStream::enter(), RTPAgent::makepkt(), and RTCPAgent::sendpkt().

{ return (localsrc_->srcid()); }

int RTPSession::build_report

(

int

bye

)

the method for creating the SR and RR reports the "heart" of the RTCP protocol

Parameters:

bye

if there is a bye event

Returns:

the length of this report in bytes

Definition at line 167 of file session-rtp.cc.

References allsrcs_, build_bye(), build_sdes(), receiver_report::bye(), calculate_RTT(), calculateR_tcp(), receiver_report::cum_pkts_lost(), receiver_report::DLSR(), RTPReceiver::eff_rtt(), sr_extensions::eff_rtt(), SimStream::getAvg_rx(), SimStream::getHigh_tx(), SimStream::getLow_tx(), SimStream::getMedium_tx(), sender_report::high_tx(), increase_rate(), receiver_report::jitter(), last_ehsr_, last_np_, last_time_report_, localsrc_, sender_report::low_tx(), receiver_report::LSR(), measure_smooth_loss(), sender_report::medium_tx(), RTPSource::nbytes(), RTPSource::next, sr_extensions::next, RTPReceiver::next, NOW, RTPSource::np(), sender_report::octets_sent(), sender_report::pkts_sent(), receiver_report::R_tcp(), receivers_, remove_sender(), rh_, hdr_rtp::rr_, RTCP_HDRSIZE, RTCP_RR_SIZE, RTCP_SR_SIZE, receiver_report::rx(), rx_recv_, sender_report::s_ext_, sender_report::sender_srcid(), SimStream::setRcv_rate(), smooth_rate_, hdr_rtp::sr_, RTPReceiver::srcid(), sr_extensions::srcid(), RTPSource::srcid(), stream_, time_elapsed_, and we_sent.

Referenced by RTCPAgent::command(), and RTCPAgent::timeout().

{
//printf("INSIDE BUILD REPORT TIME: %f Local %d  \n", NOW,localsrc_->srcid());

        rh_ = new hdr_rtp;
        rh_->rr_ = 0;
        rh_->sr_ = 0;
        
        int nsrc = 0;
        int nrr = 0;
        int len = RTCP_HDRSIZE;
        we_sent = 0;
        double fraction = 0.0;
        time_elapsed_ = NOW - last_time_report_;
        last_time_report_ = NOW;
        if (localsrc_->np() != last_np_) {
                last_np_ = localsrc_->np();
                we_sent = 1;
                len += RTCP_SR_SIZE;
                //add sender report
                sender_report* sr;
                //fill the report
                sr = new sender_report;
                sr->s_ext_ = 0;
                sr->sender_srcid()= localsrc_->srcid();
                sr->pkts_sent() = localsrc_->np();
                sr->octets_sent() = localsrc_->nbytes();
                sr->low_tx()=stream_->getLow_tx();
                sr->medium_tx()=stream_->getMedium_tx();
                sr->high_tx()=stream_->getHigh_tx();
                RTPReceiver *p;
                for (p = receivers_; p != 0; p = p->next) {
                        sr_extensions* se = new sr_extensions;
                        se->srcid()=p->srcid();
                        se->eff_rtt()=p->eff_rtt();
                        se->next = sr->s_ext_;
                        sr->s_ext_ = se;
                }
                //store the report
                rh_->sr_ = sr;
        }
        for (RTPSource* sp = allsrcs_; sp != 0; sp = sp->next) {
                ++nsrc;
                int received = sp->np() - sp->snp();

                if (received == 0) {

                        continue;
                }
                if(localsrc_->srcid() != sp->srcid()) {

                int bytes = received * (sp->ps());
                rx_recv_ = ( 8 * (double)bytes)/time_elapsed_;
                stream_->setRcv_rate(rx_recv_);
                sp->snp(sp->np());
                len += RTCP_RR_SIZE;
                // calculate loss fraction since previous report
                int expected_interval  = sp->ehsr() - last_ehsr_;
                last_ehsr_ = sp->ehsr();
                int lost_interval = expected_interval -  received;


                if (lost_interval <= 0 || expected_interval == 0 ) {
                         fraction = 0;

                } else fraction = ((double)lost_interval  / (double)expected_interval);
                calculate_RTT();
                // Update the R_tcp according to fraction value
                if( sp->np() >= 1) {// I have already received RTP packets from the source
                        if(fraction == 0) {
                                increase_rate(sp->ps());

                        }       else /*if(fraction != 0)*/ {
                                        measure_smooth_loss(fraction);
                                        calculateR_tcp(sp->ps());
                                }
                }
                //add receiver report
                receiver_report* rr;
                rr = new receiver_report;
                //fill the report
                rr->cum_pkts_lost() = sp->cum_pkts_lost();
                rr->LSR() = sp->LSR();
                rr->DLSR()= Scheduler::instance().clock() - sp->SRT();
                rr->R_tcp() = smooth_rate_;
                rr->jitter() = sp->jitter();
                rr->rx()=stream_->getAvg_rx();
                if(bye) {
                rr->bye()= 1;
                remove_sender(sp);
                } else rr->bye() = 0;
                
                rh_->rr_ = rr;

                if (++nrr >= 31)
                        break;
                } // end if

        }// end for loop


        if (bye) {
                len += build_bye();
                }
        else
                len += build_sdes();

        Tcl::instance().evalf("%s adapt-timer %d %d %d", name(),
                              nsrc, nrr, we_sent);
        Tcl::instance().evalf("%s sample-size %d", name(), len);

        return (len);
}

void RTPSession::localsrc_update

(

int

)

it is called when the RTPAgent sends a RTP packet and updates the number of packets (np) field of the originator of the RTP packet

Parameters:

int

the packet to be added

Definition at line 139 of file session-rtp.cc.

References RTPSource::is_sender(), localsrc_, and RTPSource::np().

Referenced by RTPAgent::timeout().

{
        localsrc_->np(1);
        localsrc_->is_sender(true);
}

void RTPSession::update_rate

(

)

this method compares the reported TCP friendly bandwidth by the receivers and calls the session_bw and transmit methods in session-rtp.tcl class to adjust the sender's transmission rate The adjustment in the transmission rate occures after the sender receives reports from all the receivers. r_tcp, is the receiver estimation of the TCP friendly bandwidth

Definition at line 612 of file session-rtp.cc.

References high_, low_, lst, RTPReceiver::next, RTPReceiver::rate(), receivers_, setInst_tx(), and tx_rate_.

Referenced by recv_ctrl().

{
        RTPReceiver* s;
        for (s = receivers_; s!= 0; s = s->next) {
                if(s->rate() > 0) {
                        lst.push_front(s->rate());
                }
        }
        lst.sort();
        double inst_tx =lst.front();
        lst.clear();
        if(inst_tx != tx_rate_) {
                tx_rate_ = inst_tx;
                if(tx_rate_ <=  low_) {
                        tx_rate_ = low_;
                }
                if(tx_rate_ > high_) {
                        tx_rate_ =  high_;
                }
        setInst_tx(tx_rate_);   
        Tcl::instance().evalf("%s session_bw %fb/s",name(),8*tx_rate_);
        Tcl::instance().evalf("%s transmit %fb/s",name(),8*tx_rate_);
        }
}

void RTPSession::localsrc_update_nbytes

(

int

n

)

it is called when the RTPAgent sends a RTP packet and updates the number of number of bytes (nbytes) field of the originator of the RTP packet

Parameters:

n

the bytes to be added

Definition at line 151 of file session-rtp.cc.

References localsrc_, and RTPSource::nbytes().

Referenced by RTPAgent::timeout().

{
        localsrc_->nbytes(n);
        
}

void RTPSession::smooth_rate

(

double

inst_tx

)

this is the filter function for the smooth transmission rate measurement

Parameters:

inst_tx

the current transmission rate estimation by the RTP receiver

Definition at line 509 of file session-rtp.cc.

References SimStream::setInst_rx_rate(), smooth_factor, smooth_rate_, and stream_.

Referenced by calculateR_tcp(), and increase_rate().

{
        smooth_rate_ = smooth_factor * inst_tx + smooth_rate_ * (1 - smooth_factor);
        stream_->setInst_rx_rate(smooth_rate_);
}

int RTPSession::build_sdes

(

)

not implemented yet. It only returns 20 bytes that are to be added to the RTCP report

Definition at line 292 of file session-rtp.cc.

Referenced by build_report().

{

        /* XXX We'll get to this later... */
        return (20);
}

int RTPSession::build_bye

(

)

it is called upon a bye event returns 8 bytes length

Definition at line 284 of file session-rtp.cc.

Referenced by build_report().

{
        
        return (8);
}

hdr_rtp * RTPSession::access_hdr_rtp

(

)

accesses the RTP packet header

Returns:

, the

Definition at line 655 of file session-rtp.cc.

References rh_.

Referenced by RTCPAgent::sendpkt().

{
        return rh_;
}

void RTPSession::print_rcvs

(

)

for debugging, prints all the receivers that a source serves

Definition at line 698 of file session-rtp.cc.

References RTPReceiver::next, receivers_, and RTPReceiver::srcid().

{

        RTPReceiver *p;
        for (p = receivers_; p != 0; p = p->next)
        {
            printf("Receiver:%d\n", p->srcid());
        }
}

void RTPSession::print_srcs

(

)

for debugging, prints all the sources that a receiver listens

Definition at line 711 of file session-rtp.cc.

References allsrcs_, RTPSource::next, and RTPSource::srcid().

{

        RTPSource* s;
        for (s = allsrcs_; s != 0; s = s->next)
        {
            printf("Source:%d\n", s->srcid());
        }
}

void RTPSession::start_timer

(

)

Definition at line 888 of file session-rtp.cc.

References INITIAL_TIMEOUT, running_, and sender_timer_.

Referenced by RTPAgent::start().

{
        running_ = 1;
        sender_timer_.resched(INITIAL_TIMEOUT);

}

void RTPSession::stop_timer

(

)

Definition at line 895 of file session-rtp.cc.

References running_, and sender_timer_.

Referenced by RTPAgent::stop().

{
        running_ = 0;
        sender_timer_.force_cancel();
        
}

RTPSource * RTPSession::lookup

(

u_int32_t

srcid

)

[protected]

it checks if the source has heard

Parameters:

srcid

the source id of this source

Returns:

the source of the RTP packet if it exists, zero otherwise

Definition at line 666 of file session-rtp.cc.

References allsrcs_, RTPSource::next, and RTPSource::srcid().

Referenced by recv(), and recv_ctrl().

{
        RTPSource *p;
        for (p = allsrcs_; p != 0; p = p->next)
        {       
                if (p->srcid() == srcid)
                        return (p);
        }
        return (0);
}

RTPReceiver * RTPSession::lookup_rcv

(

u_int32_t

srcid

)

[protected]

Check if the receiver exists in the sender's list

Parameters:

srcid

the source id of this receiver

Returns:

the receiver if it exists, zero otherwise

Definition at line 683 of file session-rtp.cc.

References RTPReceiver::next, receivers_, and RTPReceiver::srcid().

Referenced by recv_ctrl().

{

        RTPReceiver *p;
        for (p = receivers_; p != 0; p = p->next)
        {
                if (p->srcid() == srcid)
                        return (p);
        }
        return (0);
}

void RTPSession::enter

(

RTPSource *

s

)

[protected]

enter a new source

Parameters:

s

the new RTPSource

Definition at line 726 of file session-rtp.cc.

References allsrcs_, and RTPSource::next.

Referenced by command().

{
        
        s->next = allsrcs_;
        allsrcs_ = s;
}

void RTPSession::enter_rcv

(

RTPReceiver *

s

)

[protected]

enter a new receiver

Parameters:

s

the new RTPReceiver

Definition at line 737 of file session-rtp.cc.

References localsrc_, RTPReceiver::next, NOW, receivers_, RTPReceiver::srcid(), and RTPSource::srcid().

Referenced by recv_ctrl().

{
        printf("Time:%f Sender:%d ...I add receiver %d \n", NOW,localsrc_->srcid(), s->srcid());
        s->next = receivers_;
        receivers_ = s;
        
}

void RTPSession::calculate_RTT

(

)

[protected]

calculates the RTT time one_way is the one way trip time eff is the effective RTT time measured and reported by the sender of the RTP packets

Parameters:

eff,the

effective RTT time measured by the sender

Definition at line 427 of file session-rtp.cc.

References alpha, RTT_, and T_one_way_.

Referenced by build_report().

{
        double temp = (1+alpha) * T_one_way_;
 //     RTT_ = temp * 0.5 + 0.5 * RTT_;
        RTT_ = temp * 0.1 + 0.9 * RTT_;   //taken from RFC 3448
}

void RTPSession::increase_rate

(

int

ps

)

[protected]

the estimation made by the receiver of the transmission rate when fraction loss is zero. The increase is not higher than 1 RTP packet/current rate in bytes/sec sample_tx is the current estimation of the RTP receiver. We pass this value from the filter

Parameters:

ps,the

packet size of the RTP packet

Definition at line 442 of file session-rtp.cc.

References RTT_, smooth_rate(), and smooth_rate_.

Referenced by build_report().

{
        double sample_tx = smooth_rate_ +  (double)ps/RTT_;
        // pass sample_tx from the filter
        smooth_rate(sample_tx);
}

void RTPSession::measure_smooth_loss

(

double

fraction

)

[protected]

measure_smooth_loss is called when the last measured by the receiver loss fraction is not zero.

Parameters:

fraction

the fraction of lost RTP packets/expected RTP packets since last RR

Definition at line 455 of file session-rtp.cc.

References pkt_loss_history, smooth_loss_, and weight.

Referenced by build_report().

{
        
        double I_tot0 = 0;
        double I_tot1 = 0;
        double W_tot = 0;
        for (int i=0; i<7; i++) {
        pkt_loss_history[i+1]= pkt_loss_history[i];
        }
        pkt_loss_history[0] = fraction;

        for (int i=0; i<7; i++) {
        I_tot0 = I_tot0+ (pkt_loss_history[i] * weight[i]);
        W_tot = W_tot +  weight[i];
        }

        for (int i=1; i<8; i++) {
        I_tot1 = I_tot1 + (pkt_loss_history[i] * weight[i-1]);
        }
        double I_tot =0;
        if( I_tot0 > I_tot1) {
        I_tot = I_tot0;
        } else {
        I_tot = I_tot1;
        }
        double  I_mean = I_tot/W_tot;

        smooth_loss_= I_mean;
}

void RTPSession::calculateR_tcp

(

int

ps

)

[protected]

calculates the TCP friendly bandwidth share

Parameters:

ps

is the size of the RTP packet

Definition at line 489 of file session-rtp.cc.

References RTT_, smooth_loss_, and smooth_rate().

Referenced by build_report().

{

        double min =0;
        double fraction = 3 * sqrt((3 * smooth_loss_) / 8);
        if(fraction <  1 ){
                min = fraction;
        }       else min =1;
        // TCP friendly BW share equation
        double sample_tx = (double)ps / (RTT_ *  (sqrt(2 * smooth_loss_ /3)) + 4 * (RTT_ * min * smooth_loss_) * (1 + (32 * pow(smooth_loss_,2))));
        // pass sample_tx from the filter
        smooth_rate(sample_tx);
}

void RTPSession::initial_rate

(

double

a

)

[protected]

it's good for the receiver to have a rough knowledge of the session rate

Parameters:

a

the initial session rate

Definition at line 814 of file session-rtp.cc.

References smooth_rate_, and tx_rate_.

Referenced by command().

{
        tx_rate_ =(double)a/8;
        smooth_rate_ = tx_rate_;
        
        
}

void RTPSession::remove_receiver

(

RTPReceiver *

p

)

[protected]

remove a receiver from a sender's list

Parameters:

p

the RTPReceiver to be removed

Definition at line 749 of file session-rtp.cc.

References localsrc_, RTPReceiver::next, NOW, receivers_, RTPReceiver::srcid(), and RTPSource::srcid().

Referenced by recv_ctrl().

{

        printf("Time:%f Sender:%d ...I remove receiver %d \n", NOW,localsrc_->srcid(),p->srcid());
        
        RTPReceiver* s;
        RTPReceiver* q;
        if (receivers_== p)
        {
                q = receivers_;
                receivers_= receivers_->next;
                delete q;
        }
        else
        {
                for (s = receivers_; s!=0; s=s->next)
                {
                        if (s->next==p)
                        {
                                q = s->next;
                                s->next=q->next;
                                delete q; 
                        }       
                }
        }

}

void RTPSession::calculate_alpha

(

double

value

)

[protected]

the function that calculate the A value

Parameters:

value

the effective RTT that is measured by the RTP sender

Definition at line 410 of file session-rtp.cc.

References alpha, and T_one_way_.

Referenced by recv_ctrl().

{

        if( value == 0) {
                alpha = 1;
        } else
        alpha = (value/T_one_way_) -1;
}

void RTPSession::evaluate_jitter

(

double

value

)

[protected]

This is a core function. It tunes our congestion controller based on network statistical information. We evaluate upcoming congestion by checking how far the new jitter value falls from the jitter stab=ndard deviation

Parameters:

value

the newly measured jitter value

Definition at line 366 of file session-rtp.cc.

References CONGESTED, DELTA, jitter_, jitter_lst, LOADED, smooth_factor, UNLOADED, and z_score.

Referenced by recv().

{
        jitter_ = 0.8 * value - 0.2 * jitter_;
        jitter_lst.push_front(jitter_);
        list<double> temp_lst;
        temp_lst = jitter_lst;
        int size = jitter_lst.size();
        double temp_array[size];
        double dev_array[size];
        double mean =0;
        double count =0;
        double std_dev =0;
        
        if (size >1) {
                for (int i=0; i<size; i++) {
                        temp_array[i]=jitter_lst.front();
                        count += temp_array[i];
                        jitter_lst.pop_front();
                }
                mean = count/size;
                count =0;
                for (int j =0; j<size; j++) {
                        dev_array[j]=temp_array[j]-mean;
                        count+=pow(dev_array[j],2);
                }
                std_dev = sqrt(count/(size-1));
                double temp = temp_lst.front();
                z_score = (temp - mean)/std_dev;
                
                jitter_lst = temp_lst;
                if(-DELTA < z_score < DELTA) {
                         smooth_factor = LOADED;
                } else if ( z_score <= -DELTA) {
                         smooth_factor = UNLOADED;
                } else smooth_factor = CONGESTED;
        }
}

void RTPSession::remove_sender

(

RTPSource *

p

)

[protected]

we remove this sender from the list upon a bye event

Parameters:

p

the sender that has to be removed from our sources' list

Definition at line 781 of file session-rtp.cc.

References allsrcs_, localsrc_, RTPSource::next, and RTPSource::srcid().

Referenced by build_report().

{
        
        if(p->srcid() != localsrc_->srcid()) {
        RTPSource* s;
        RTPSource* q;
        if (allsrcs_==p)
        {
                q = allsrcs_;
                allsrcs_= allsrcs_->next;
                delete q;
        }
        else
        {
                for (s = allsrcs_; s!=0; s=s->next)
                {
                        if (s->next==p)
                        {
                                q = s->next;
                                s->next=q->next;
                                delete q; 
                        }       
                }
        }       
        
        }
}

void RTPSession::setInst_tx

(

double

newValue

)

[protected]

add the current transmission rate in the list

Parameters:

newValue

the new instantaneous transmission rate

Definition at line 917 of file session-rtp.cc.

References tx_lst.

Referenced by slow_start(), and update_rate().

{
        tx_lst.push_front(newValue);
}

void RTPSession::average_tx

(

)

[protected]

it averages the transmission rate over a period Δt (TIMER_TIMEOUT)

Definition at line 927 of file session-rtp.cc.

References avg_tx_, and tx_lst.

Referenced by timeout().

{
        int size = tx_lst.size();
        double sum = 0;
        if(size > 1) {
        for(int i = 0; i<size; i++) {
                sum += tx_lst.front();
                tx_lst.pop_front();
        }
        avg_tx_ = sum/size;
        }       
}

void RTPSession::slow_start

(

)

[protected]

we start a slow start when all receivers have left the session

Definition at line 641 of file session-rtp.cc.

References low_, setInst_tx(), and tx_rate_.

Referenced by recv_ctrl().

{       
        tx_rate_ = low_;
        setInst_tx(tx_rate_);   
        printf("Starting Slow start at ...%f\n", tx_rate_ * 8);
        Tcl::instance().evalf("%s session_bw %fb/s",name(),8*tx_rate_);
        Tcl::instance().evalf("%s transmit %fb/s",name(),8*tx_rate_);
}

---

Member Data Documentation

RTPSession* RTPSession::next

Definition at line 304 of file rtp.h.

Referenced by SimStream::enter(), and SimStream::~SimStream().

RTPSource* RTPSession::allsrcs_

Definition at line 324 of file rtp.h.

Referenced by build_report(), enter(), lookup(), print_srcs(), remove_sender(), and ~RTPSession().

RTPSource* RTPSession::localsrc_

Definition at line 325 of file rtp.h.

Referenced by build_report(), command(), enter_rcv(), localsrc_update(), localsrc_update_nbytes(), recv(), recv_ctrl(), remove_receiver(), remove_sender(), srcid(), and ~RTPSession().

RTPReceiver* RTPSession::receivers_

Definition at line 326 of file rtp.h.

Referenced by build_report(), enter_rcv(), lookup_rcv(), print_rcvs(), recv_ctrl(), remove_receiver(), update_rate(), and ~RTPSession().

SimStream* RTPSession::stream_

Definition at line 327 of file rtp.h.

Referenced by build_report(), command(), recv(), recv_ctrl(), smooth_rate(), and timeout().

int RTPSession::last_np_

the last packet number

Definition at line 329 of file rtp.h.

Referenced by build_report().

int RTPSession::enableFlowControl_

zero by default

Definition at line 339 of file rtp.h.

Referenced by recv_ctrl(), and RTPSession().

double RTPSession::rx_recv_

the receiveing rate as it measured by the RTP receiver

Definition at line 341 of file rtp.h.

Referenced by build_report(), and RTPSession().

double RTPSession::jitter_

the jitter delay as is it measured by the RTP receiver

Definition at line 343 of file rtp.h.

Referenced by evaluate_jitter(), recv(), and RTPSession().

double RTPSession::smooth_rate_

the smooth transmission rate

Definition at line 345 of file rtp.h.

Referenced by build_report(), increase_rate(), initial_rate(), RTPSession(), and smooth_rate().

SenderTimer RTPSession::sender_timer_

Definition at line 347 of file rtp.h.

Referenced by start_timer(), stop_timer(), and timeout().

list<double> RTPSession::lst [protected]

a list to store values

Definition at line 359 of file rtp.h.

Referenced by update_rate(), and ~RTPSession().

double RTPSession::T_one_way_ [protected]

the one-way trip time

Definition at line 375 of file rtp.h.

Referenced by calculate_alpha(), calculate_RTT(), and recv().

hdr_rtp* RTPSession::rh_ [protected]

the rtp header

Definition at line 377 of file rtp.h.

Referenced by access_hdr_rtp(), and build_report().

int RTPSession::we_sent [protected]

true if the RTP sender sent packets since the last RTP SR

Definition at line 381 of file rtp.h.

Referenced by build_report().

double RTPSession::RTT_ [protected]

the RTT time

Definition at line 383 of file rtp.h.

Referenced by calculate_RTT(), calculateR_tcp(), increase_rate(), and RTPSession().

double RTPSession::weight[8] [protected]

weights for the smooth loss raton calculation

Definition at line 385 of file rtp.h.

Referenced by measure_smooth_loss(), and RTPSession().

double RTPSession::pkt_loss_history[8] [protected]

the array to keep the packet loss history

Definition at line 387 of file rtp.h.

Referenced by measure_smooth_loss().

double RTPSession::smooth_loss_ [protected]

the smooth loss ratio

Definition at line 389 of file rtp.h.

Referenced by calculateR_tcp(), measure_smooth_loss(), and RTPSession().

int RTPSession::last_pkts_lost_ [protected]

keeps the number of the last packets losts since the beginning of the session

Definition at line 391 of file rtp.h.

int RTPSession::last_ehsr_ [protected]

keeps the highest expected RTP sequence number

Definition at line 393 of file rtp.h.

Referenced by build_report(), and recv().

double RTPSession::tx_rate_ [protected]

the transmission rate that is measured by the receiver

Definition at line 395 of file rtp.h.

Referenced by initial_rate(), slow_start(), and update_rate().

double RTPSession::time_elapsed_ [protected]

time elapsed since the last RR (receiver report)

Definition at line 397 of file rtp.h.

Referenced by build_report().

double RTPSession::last_time_report_ [protected]

the time when the last RR was sent

Definition at line 399 of file rtp.h.

Referenced by build_report(), and RTPSession().

double RTPSession::alpha [protected]

the value A

Definition at line 401 of file rtp.h.

Referenced by calculate_alpha(), calculate_RTT(), and RTPSession().

double RTPSession::smooth_factor [protected]

defines the responsiveness of the protocol

Definition at line 407 of file rtp.h.

Referenced by evaluate_jitter(), RTPSession(), and smooth_rate().

list<double> RTPSession::jitter_lst [protected]

list to keep all jitter delay measurements

Definition at line 409 of file rtp.h.

Referenced by evaluate_jitter().

double RTPSession::z_score [protected]

z score for statistical measurements

Definition at line 411 of file rtp.h.

Referenced by evaluate_jitter(), and RTPSession().

double RTPSession::low_ [protected]

Definition at line 412 of file rtp.h.

Referenced by command(), RTPSession(), slow_start(), and update_rate().

double RTPSession::high_ [protected]

Definition at line 413 of file rtp.h.

Referenced by command(), RTPSession(), and update_rate().

int RTPSession::level_ [protected]

Definition at line 415 of file rtp.h.

Referenced by RTPSession(), and timeout().

double RTPSession::avg_tx_ [protected]

Definition at line 416 of file rtp.h.

Referenced by average_tx(), RTPSession(), and timeout().

list<double> RTPSession::tx_lst [protected]

Definition at line 418 of file rtp.h.

Referenced by average_tx(), setInst_tx(), and ~RTPSession().

int RTPSession::running_ [protected]

Definition at line 420 of file rtp.h.

Referenced by start_timer(), stop_timer(), and timeout().

---

The documentation for this class was generated from the following files:

• ns-allinone-2.30/ns-2.30/rtp/rtp.h
• ns-allinone-2.30/ns-2.30/rtp/session-rtp.cc