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

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

class RTCPAgent;
class RTCP_Timer : public TimerHandler {
public: 
        RTCP_Timer(RTCPAgent *a) : TimerHandler() { a_ = a; }
protected:
        virtual void expire(Event *e);
        RTCPAgent *a_;
};
class RTCPAgent : public Agent {
public:
        RTCPAgent();
        virtual void timeout(int);
        virtual void recv(Packet* p, Handler* h);
        int command(int argc, const char*const* argv);
protected:
        void start();
        void stop();
        void sendpkt();
        int running_;
        int random_;
        int seqno_;
        double interval_;
        RTPSession* session_;
        RTCP_Timer rtcpup_timer_;
        
};
static class RTCPAgentClass : public TclClass {
public:
        RTCPAgentClass() : TclClass("Agent/RTCP") {}
        TclObject* create(int, const char*const*) {
                return (new RTCPAgent());
        }
} class_rtcpup_agent;

RTCPAgent::RTCPAgent()
        : Agent(PT_RTCP), session_(0), rtcpup_timer_(this)
{
        size_ = 128;
        bind_time("interval_", &interval_);
        bind("random_", &random_);
        bind("seqno_", &seqno_);
        running_ = 0;

}
void RTCPAgent::start()
{
        running_ = 1;
        
        rtcpup_timer_.resched(interval_);
        
}
void RTCPAgent::stop()
{
        rtcpup_timer_.cancel();
        running_ = 0;
}
void RTCPAgent::recv(Packet* p, Handler*)
{
        session_->recv_ctrl(p);
}
void RTCPAgent::sendpkt()
{
        Packet* p = allocpkt();
        hdr_rtp* rh = hdr_rtp::access(p);
        hdr_rtp* tmp = new hdr_rtp;
        tmp = session_->access_hdr_rtp();
        /* Fill in srcid_ and seqno */
        rh->seqno() = seqno_++;
        rh->srcid() = session_->srcid();
        rh->timestamp() = Scheduler::instance().clock();
        rh->sr_ = tmp->sr_;
        rh->rr_ = tmp->rr_;
        target_->recv(p);
}


void RTCPAgent::timeout(int)
{
        if (running_) {
                size_ = session_->build_report(0);
                sendpkt();
                double t = interval_;
                if (random_)
                        /* add some zero-mean white noise */
                        t += interval_ * Random::uniform(-0.5, 0.5);    
                rtcpup_timer_.resched(t);
                /* XXX */
                Tcl::instance().evalf("%s rtcp_timeout", session_->name());
        }
}
int RTCPAgent::command(int argc, const char*const* argv)
{
        if (argc == 2) {
                if (strcmp(argv[1], "start") == 0) {
                        start();
                        return (TCL_OK);
                }
                if (strcmp(argv[1], "stop") == 0) {
                        stop();
                        return (TCL_OK);
                }
                if (strcmp(argv[1], "bye") == 0) {
                        size_ = session_->build_report(1);
                        sendpkt();
                        stop();
                        return (TCL_OK);
                }
        } else if (argc == 3) {
                if (strcmp(argv[1], "session") == 0) {
                        session_ = (RTPSession*)TclObject::lookup(argv[2]);
                        return (TCL_OK);
                }
        }

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

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

---