RTPSession Class Reference

#include <rtp.h>

List of all members.

Public Member Functions
	RTPSession ()
	~RTPSession ()
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	pass_sr (sender_report *)
void	localsrc_update_nbytes (int n)
void	smooth_rate (double rate)
int	build_sdes ()
int	build_bye ()
hdr_rtp *	access_hdr_rtp ()
void	print_rcv ()
Public Attributes
RTPSource *	allsrcs_
RTPSource *	localsrc_
RTPReceiver *	receivers_
int	last_np_
int	enableFlowControl_
double	rx_recv_
double	jitter_
double	smooth_rate_
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 *)
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

---

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 271 of file rtp.h.

---

Constructor & Destructor Documentation

RTPSession::RTPSession

(

)

zero argument constructor

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

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

        : allsrcs_(0), localsrc_(0), receivers_(0),last_np_(0), T_one_way_(0),rh_(0),
        we_sent(0),last_pkts_lost_(0),last_ehsr_(-1),tx_rate_(0), time_elapsed_(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_);
        smooth_rate_ = 0;
        alpha = 1;
        smooth_factor = 0.1;
        last_time_report_ = NOW;
        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 104 of file session-rtp.cc.

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

{
        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>();
        
}

---

Member Function Documentation

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 288 of file session-rtp.cc.

References hdr_rtp::access(), RTPSource::cum_pkts_lost(), RTPSource::ehsr(), evaluate_jitter(), RTPSource::jitter(), jitter_, localsrc_, lookup(), RTPSource::nbytes(), NOW, RTPSource::np(), RTPSource::ps(), hdr_rtp::seqno(), RTPSource::srcid(), hdr_rtp::srcid(), 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());
                }
        }
        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
        }
        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 497 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(), RTPSource::is_sender(), localsrc_, lookup(), lookup_rcv(), receiver_report::LSR(), RTPSource::LSR(), 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(), hdr_rtp::sr_, RTPReceiver::srcid(), sr_extensions::srcid(), hdr_rtp::srcid(), RTPSource::srcid(), RTPSource::SRT(), 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);
                                
                                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 767 of file session-rtp.cc.

References enter(), initial_rate(), and localsrc_.

{
        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);
                }
        }

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

u_int32_t RTPSession::srcid

(

)

[inline]

Definition at line 282 of file rtp.h.

References localsrc_, and RTPSource::srcid().

Referenced by 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 155 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(), increase_rate(), receiver_report::jitter(), last_ehsr_, last_np_, last_time_report_, localsrc_, receiver_report::LSR(), measure_smooth_loss(), 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, rx_recv_, sender_report::s_ext_, sender_report::sender_srcid(), smooth_rate_, hdr_rtp::sr_, RTPReceiver::srcid(), sr_extensions::srcid(), RTPSource::srcid(), time_elapsed_, and we_sent.

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

{
        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();
                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_;
                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();
                if(bye) {
                printf ("TIME for BYE %f \n", NOW);
                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 127 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 581 of file session-rtp.cc.

References localsrc_, lst, RTPReceiver::next, NOW, RTPReceiver::rate(), receivers_, RTPSource::srcid(), 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_) {
                // we do not let the transmission rate to drop below tx_rate_/2
                if(inst_tx < (tx_rate_/2)) {
                        tx_rate_ = tx_rate_/2;
                } else tx_rate_ = inst_tx;
        printf("Time:%f Sender:%d ...Rate change to:%f \n", NOW,localsrc_->srcid(),8*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::pass_sr

(

sender_report *

)

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 139 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 481 of file session-rtp.cc.

References smooth_factor, and smooth_rate_.

Referenced by calculateR_tcp(), and increase_rate().

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

int RTPSession::build_sdes

(

)

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

Definition at line 272 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 264 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 608 of file session-rtp.cc.

References rh_.

Referenced by RTCPAgent::sendpkt().

{
        return rh_;
}

void RTPSession::print_rcv

(

)

for debugging, prints all the receivers that a source serves

Definition at line 651 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());
        }
}

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 619 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 636 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 665 of file session-rtp.cc.

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

Referenced by command().

{
        if(s->srcid() != localsrc_->srcid() ) {
        printf("Time:%f Receiver:%d ...I add sender %d \n", NOW,localsrc_->srcid(), s->srcid());
        s->next = allsrcs_;
        allsrcs_ = s;
        }
}

void RTPSession::enter_rcv

(

RTPReceiver *

s

)

[protected]

enter a new receiver

Parameters:

s

the new RTPReceiver

Definition at line 678 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 398 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 413 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 426 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 460 of file session-rtp.cc.

References localsrc_, NOW, RTT_, smooth_loss_, smooth_rate(), and RTPSource::srcid().

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))));
        printf("Time:%f Receiver:%d smooth_loss_:%f \n", NOW,localsrc_->srcid(),smooth_loss_);
        // 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 756 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 689 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 382 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 341 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 720 of file session-rtp.cc.

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

Referenced by build_report().

{
        printf("Time:%f Receiver:%d ...I remove sender %d \n", NOW,localsrc_->srcid(), p->srcid());
        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; 
                        }       
                }
        }       
        
        }
        rx_recv_= 0;
        jitter_=0;
}

---

Member Data Documentation

RTPSource* RTPSession::allsrcs_

Definition at line 295 of file rtp.h.

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

RTPSource* RTPSession::localsrc_

Definition at line 296 of file rtp.h.

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

RTPReceiver* RTPSession::receivers_

Definition at line 297 of file rtp.h.

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

int RTPSession::last_np_

the last packet number

Definition at line 299 of file rtp.h.

Referenced by build_report().

int RTPSession::enableFlowControl_

zero by default

Definition at line 309 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 311 of file rtp.h.

Referenced by build_report(), remove_sender(), and RTPSession().

double RTPSession::jitter_

the jitter delay as is it measured by the RTP receiver

Definition at line 313 of file rtp.h.

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

double RTPSession::smooth_rate_

the smooth transmission rate

Definition at line 315 of file rtp.h.

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

list<double> RTPSession::lst [protected]

a list to store values

Definition at line 324 of file rtp.h.

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

double RTPSession::T_one_way_ [protected]

the one-way trip time

Definition at line 340 of file rtp.h.

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

hdr_rtp* RTPSession::rh_ [protected]

the rtp header

Definition at line 342 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 346 of file rtp.h.

Referenced by build_report().

double RTPSession::RTT_ [protected]

the RTT time

Definition at line 348 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 350 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 352 of file rtp.h.

Referenced by measure_smooth_loss().

double RTPSession::smooth_loss_ [protected]

the smooth loss ratio

Definition at line 354 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 356 of file rtp.h.

int RTPSession::last_ehsr_ [protected]

keeps the highest expected RTP sequence number

Definition at line 358 of file rtp.h.

Referenced by build_report().

double RTPSession::tx_rate_ [protected]

the transmission rate that is measured by the receiver

Definition at line 360 of file rtp.h.

Referenced by initial_rate(), and update_rate().

double RTPSession::time_elapsed_ [protected]

time elapsed since the last RR (receiver report)

Definition at line 362 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 364 of file rtp.h.

Referenced by build_report(), and RTPSession().

double RTPSession::alpha [protected]

the value A

Definition at line 366 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 372 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 374 of file rtp.h.

Referenced by evaluate_jitter().

double RTPSession::z_score [protected]

z score for statistical measurements

Definition at line 376 of file rtp.h.

Referenced by evaluate_jitter(), and RTPSession().

---

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