inet::SimpleVoIPSender Class Reference

Implements a simple VoIP source. More...

#include <SimpleVoIPSender.h>

Inheritance diagram for inet::SimpleVoIPSender:

Public Member Functions
virtual	~SimpleVoIPSender ()
	SimpleVoIPSender ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
void	talkspurt (simtime_t dur)
void	selectTalkOrSilenceInterval ()
void	sendVoIPPacket ()
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...

Private Attributes
UDPSocket	socket
simtime_t	stopTime
simtime_t	packetizationInterval
int	localPort = -1
int	destPort = -1
int	talkPacketSize = 0
L3Address	destAddress
cMessage *	selfSender = nullptr
cMessage *	selfSource = nullptr
simtime_t	silenceDuration
simtime_t	talkspurtDuration
int	packetID = -1
int	talkspurtID = -1
int	talkspurtNumPackets = 0
bool	isTalk = false

Detailed Description

Implements a simple VoIP source.

See the NED file for more information.

Constructor & Destructor Documentation

inet::SimpleVoIPSender::~SimpleVoIPSender ( )

virtual

{
    cancelAndDelete(selfSender);
    cancelAndDelete(selfSource);
}

inet::SimpleVoIPSender::SimpleVoIPSender

(

)

{
}

Member Function Documentation

void inet::SimpleVoIPSender::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

{
    if (msg->isSelfMessage()) {
        if (msg == selfSender)
            sendVoIPPacket();
        else
            selectTalkOrSilenceInterval();
    }
}

virtual bool inet::SimpleVoIPSender::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

inlineoverrideprotectedvirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

    { Enter_Method_Silent(); throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName()); return true; }

void inet::SimpleVoIPSender::initialize ( int  stage )

overrideprotectedvirtual

{
    EV_TRACE << "VoIP Sender initialize: stage " << stage << endl;

    cSimpleModule::initialize(stage);

    // avoid multiple initializations
    if (stage == INITSTAGE_LOCAL) {
        talkspurtDuration = 0;
        silenceDuration = 0;
        selfSource = new cMessage("selfSource");
        isTalk = false;
        talkspurtID = 0;
        talkspurtNumPackets = 0;
        packetID = 0;
        talkPacketSize = par("talkPacketSize");
        packetizationInterval = par("packetizationInterval").doubleValue();
        selfSender = new cMessage("selfSender");
        localPort = par("localPort");
        destPort = par("destPort");
    }
    else if (stage == INITSTAGE_APPLICATION_LAYER) {
        bool isOperational;
        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
        isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
        if (!isOperational)
            throw cRuntimeError("This module doesn't support starting in node DOWN state");

        socket.setOutputGate(gate("udpOut"));
        socket.bind(localPort);

        EV_INFO << "VoIPSender::initialize - binding to port: local:" << localPort << " , dest:" << destPort << endl;

        // calculating traffic starting time
        simtime_t startTime = par("startTime").doubleValue();
        stopTime = par("stopTime").doubleValue();
        if (stopTime >= SIMTIME_ZERO && stopTime < startTime)
            throw cRuntimeError("Invalid startTime/stopTime settings: startTime %g s greater than stopTime %g s", SIMTIME_DBL(startTime), SIMTIME_DBL(stopTime));

        scheduleAt(startTime, selfSource);
        EV_INFO << "\t starting traffic in " << startTime << " s" << endl;
    }
}

virtual int inet::SimpleVoIPSender::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::SimpleVoIPSender::selectTalkOrSilenceInterval ( )

protected

Referenced by handleMessage().

{
    simtime_t now = simTime();
    if (stopTime >= SIMTIME_ZERO && now >= stopTime)
        return;

    if (isTalk) {
        silenceDuration = par("silenceDuration").doubleValue();
        EV_DEBUG << "SILENCE: " << "Duration: " << silenceDuration << " seconds\n\n";
        simtime_t endSilence = now + silenceDuration;
        if (stopTime >= SIMTIME_ZERO && endSilence > stopTime)
            endSilence = stopTime;
        scheduleAt(endSilence, selfSource);
        isTalk = false;
    }
    else {
        talkspurtDuration = par("talkspurtDuration").doubleValue();
        EV_DEBUG << "TALKSPURT: " << talkspurtID << " Duration: " << talkspurtDuration << " seconds\n\n";
        simtime_t endTalk = now + talkspurtDuration;
        if (stopTime >= SIMTIME_ZERO && endTalk > stopTime) {
            endTalk = stopTime;
            talkspurtDuration = stopTime - now;
        }
        talkspurt(talkspurtDuration);
        scheduleAt(endTalk, selfSource);
        isTalk = true;
    }
}

void inet::SimpleVoIPSender::sendVoIPPacket ( )

protected

Referenced by handleMessage().

{
    if (destAddress.isUnspecified())
        destAddress = L3AddressResolver().resolve(par("destAddress").stringValue());

    SimpleVoIPPacket *packet = new SimpleVoIPPacket("VoIP");
    packet->setTalkspurtID(talkspurtID - 1);
    packet->setTalkspurtNumPackets(talkspurtNumPackets);
    packet->setPacketID(packetID);
    packet->setVoipTimestamp(simTime() - packetizationInterval);    // start time of voice in this packet
    packet->setVoiceDuration(packetizationInterval);
    packet->setByteLength(talkPacketSize);
    EV_INFO << "TALKSPURT " << talkspurtID - 1 << " sending packet " << packetID << "\n";

    socket.sendTo(packet, destAddress, destPort);
    ++packetID;

    if (packetID < talkspurtNumPackets)
        scheduleAt(simTime() + packetizationInterval, selfSender);
}

void inet::SimpleVoIPSender::talkspurt ( simtime_t  dur )

protected

Referenced by selectTalkOrSilenceInterval().

{
    simtime_t curTime = simTime();
    simtime_t startTime = curTime;
    if (selfSender->isScheduled()) {
        // silence was too short, detected overlapping talkspurts
        simtime_t delta = selfSender->getArrivalTime() - curTime;
        startTime += delta;
        dur -= SIMTIME_DBL(delta);
        cancelEvent(selfSender);
    }

    talkspurtID++;
    packetID = 0;
    talkspurtNumPackets = (ceil(dur / packetizationInterval));
    EV_DEBUG << "TALKSPURT " << talkspurtID - 1 << " will be sent " << talkspurtNumPackets << " packets\n\n";

    scheduleAt(startTime + packetizationInterval, selfSender);
}

Member Data Documentation

L3Address inet::SimpleVoIPSender::destAddress

private

Referenced by sendVoIPPacket().

int inet::SimpleVoIPSender::destPort = -1

private

Referenced by initialize(), and sendVoIPPacket().

bool inet::SimpleVoIPSender::isTalk = false

private

Referenced by initialize(), and selectTalkOrSilenceInterval().

int inet::SimpleVoIPSender::localPort = -1

private

Referenced by initialize().

int inet::SimpleVoIPSender::packetID = -1

private

Referenced by initialize(), sendVoIPPacket(), and talkspurt().

simtime_t inet::SimpleVoIPSender::packetizationInterval

private

Referenced by initialize(), sendVoIPPacket(), and talkspurt().

cMessage* inet::SimpleVoIPSender::selfSender = nullptr

private

Referenced by handleMessage(), initialize(), sendVoIPPacket(), talkspurt(), and ~SimpleVoIPSender().

cMessage* inet::SimpleVoIPSender::selfSource = nullptr

private

Referenced by initialize(), selectTalkOrSilenceInterval(), and ~SimpleVoIPSender().

simtime_t inet::SimpleVoIPSender::silenceDuration

private

Referenced by initialize(), and selectTalkOrSilenceInterval().

UDPSocket inet::SimpleVoIPSender::socket

private

Referenced by initialize(), and sendVoIPPacket().

simtime_t inet::SimpleVoIPSender::stopTime

private

Referenced by initialize(), and selectTalkOrSilenceInterval().

int inet::SimpleVoIPSender::talkPacketSize = 0

private

Referenced by initialize(), and sendVoIPPacket().

simtime_t inet::SimpleVoIPSender::talkspurtDuration

private

Referenced by initialize(), and selectTalkOrSilenceInterval().

int inet::SimpleVoIPSender::talkspurtID = -1

private

Referenced by initialize(), selectTalkOrSilenceInterval(), sendVoIPPacket(), and talkspurt().

int inet::SimpleVoIPSender::talkspurtNumPackets = 0

private

Referenced by initialize(), sendVoIPPacket(), and talkspurt().

---

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

• SimpleVoIPSender.h
• SimpleVoIPSender.cc