ns-allinone-2.30/ns-2.30/rtp/rtp.cc

#include <stdlib.h>
#include "config.h"
#include "agent.h"
#include "random.h"
#include "rtp.h"


int hdr_rtp::offset_;
class RTPHeaderClass : public PacketHeaderClass {
public: 
        RTPHeaderClass() : PacketHeaderClass("PacketHeader/RTP",
                                             sizeof(hdr_rtp)) {
                bind_offset(&hdr_rtp::offset_);
        }
} class_rtphdr;
static class RTPAgentClass : public TclClass {
public:
        RTPAgentClass() : TclClass("Agent/RTP") {}
        TclObject* create(int, const char*const*) {
                return (new RTPAgent());

        }
} class_rtp_agent;

RTPAgent::RTPAgent() : Agent(PT_RTP), session_(0), lastpkttime_(-1e6),
    running_(0),  rtp_timer_(this)
{
        bind("seqno_", &seqno_);
        bind_time("interval_", &interval_);
        bind("packetSize_", &size_);
        bind("maxpkts_", &maxpkts_);
        bind("random_", &random_);
        timestamp_ = 0;
        
}
void RTPAgent::start()
{
        running_ = 1;
        sendpkt();
        rtp_timer_.resched(interval_);
}

void RTPAgent::stop()
{
//      printf("inside stop localsrc_ %d\n", session_->localsrc_->srcid());
        rtp_timer_.force_cancel();
        finish();
}

void RTPAgent::sendmsg(int nbytes, const char* )
{
        Packet *p;
        int n;

        assert (size_ > 0);

        if (++seqno_ < maxpkts_) {
                n = nbytes / size_;
        
                if (nbytes == -1) {
                        start();
                        return;
                }
                while (n-- > 0) {
                        p = allocpkt();
                        hdr_rtp* rh = hdr_rtp::access(p);
                        rh->seqno() = seqno_;
                        target_->recv(p);
                }
                n = nbytes % size_;
                if (n > 0) {
                        p = allocpkt();
                        hdr_rtp* rh = hdr_rtp::access(p);
                        rh->seqno() = seqno_;
                        target_->recv(p);
                }
                idle();
        } else {
                finish();
                // xxx: should we deschedule the timer here? */
        };
}

void RTPAgent::timeout(int)
{
        if (running_) {
                sendpkt();
                if (session_)
                        session_->localsrc_update(size_);
                        session_->localsrc_update_nbytes(size_);
                        
                double t = interval_;
                if (random_)
                        /* add some zero-mean white noise */
                        t += interval_ * Random::uniform(-0.5, 0.5);
                rtp_timer_.resched(t);
        }
}

void RTPAgent::finish()
{
        running_ = 0;
        Tcl::instance().evalf("%s done", this->name());
}

void RTPAgent::advanceby(int delta)
{
        maxpkts_ += delta;
        if (seqno_ < maxpkts_ && !running_)
                start();
}               

void RTPAgent::recv(Packet* p, Handler*)
{
        if (session_)
                session_->recv(p, 0);
        else
                Packet::free(p);
}
/* to handle events from the TCL classes or the TCL scripts */
int RTPAgent::command(int argc, const char*const* argv)
{
        if (argc == 2) {
                if (strcmp(argv[1], "rate-change") == 0) {
                        rate_change();
                        return (TCL_OK);
                } else if (strcmp(argv[1], "start") == 0) {
                        start();
                        return (TCL_OK);
                } else if (strcmp(argv[1], "stop") == 0) {
                        stop();
                        return (TCL_OK);
                }
        } else if (argc == 3) {
                if (strcmp(argv[1], "session") == 0) {
                        session_ = (RTPSession*)TclObject::lookup(argv[2]);
                        return (TCL_OK);
                } else if (strcmp(argv[1], "advance") == 0) {
                        int newseq = atoi(argv[2]);
                        advanceby(newseq - seqno_);
                        return (TCL_OK); 
                } else if (strcmp(argv[1], "advanceby") == 0) {
                        advanceby(atoi(argv[2]));
                        return (TCL_OK);
                }       
        }
        return (Agent::command(argc, argv));
}

void RTPAgent::rate_change()
{
        rtp_timer_.force_cancel();
        
        double t = lastpkttime_ + interval_;
        
        double now = Scheduler::instance().clock();
        if ( t > now)
                rtp_timer_.resched(t - now);
        else {
                sendpkt();
                rtp_timer_.resched(interval_);
        }
}
void RTPAgent::sendpkt()
{
        Packet* p = allocpkt();
        lastpkttime_ = Scheduler::instance().clock();
        timestamp_ = lastpkttime_;
        makepkt(p);
        target_->recv(p, (Handler*)0);
}
void RTPAgent::makepkt(Packet* p)
{
        
        hdr_rtp *rh = hdr_rtp::access(p);
        /* Fill in srcid_ and seqno */
        rh->seqno() = seqno_++;
        rh->srcid() = session_ ? session_->srcid() : 0;
        rh->timestamp()= timestamp_;
        
        
}

void RTPTimer::expire(Event* /*e*/) {
        a_->timeout(0);
}

---