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::LifecycleUnsupported
virtual bool	handleOperationStage (LifecycleOperation operation, IDoneCallback doneCallback) override
	Perform one stage of a lifecycle operation. More...

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

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

◆ ~SimpleVoipSender()

inet::SimpleVoipSender::~SimpleVoipSender ( )

virtual

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

◆ SimpleVoipSender()

inet::SimpleVoipSender::SimpleVoipSender ( )

21 {

22 }

Member Function Documentation

◆ handleMessage()

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

overrideprotectedvirtual

 {
     if (msg->isSelfMessage()) {
         if (msg == selfSender)
             sendVoIPPacket();
         else
             selectTalkOrSilenceInterval();
     }
     else
         throw cRuntimeError("Unknown incoming message: '%s' on gate '%s'", msg->getClassName(), msg->getArrivalGate()->getFullName());
 }

◆ initialize()

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");
         selfSender = new cMessage("selfSender");
         localPort = par("localPort");
         destPort = par("destPort");
     }
     else if (stage == INITSTAGE_APPLICATION_LAYER) {
         cModule *node = findContainingNode(this);
         NodeStatus *nodeStatus = node ? check_and_cast_nullable<NodeStatus *>(node->getSubmodule("status")) : nullptr;
         bool isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
         if (!isOperational)
             throw cRuntimeError("This module doesn't support starting in node DOWN state");
  
         socket.setOutputGate(gate("socketOut"));
         socket.bind(localPort);
  
         EV_INFO << "VoIPSender::initialize - binding to port: local:" << localPort << " , dest:" << destPort << endl;
  
         // calculating traffic starting time
         simtime_t startTime(par("startTime"));
         stopTime = par("stopTime");
         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;
     }
 }

◆ numInitStages()

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

inlineoverrideprotectedvirtual

50 { return NUM_INIT_STAGES; }

◆ selectTalkOrSilenceInterval()

void inet::SimpleVoipSender::selectTalkOrSilenceInterval ( )

protected

 {
     simtime_t now = simTime();
     if (stopTime >= SIMTIME_ZERO && now >= stopTime)
         return;
  
     if (isTalk) {
         silenceDuration = par("silenceDuration");
         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");
         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;
     }
 }

Referenced by handleMessage().

◆ sendVoIPPacket()

void inet::SimpleVoipSender::sendVoIPPacket ( )

protected

 {
     if (destAddress.isUnspecified())
         destAddress = L3AddressResolver().resolve(par("destAddress"));
  
     Packet *packet = new Packet("VoIP");
     const auto& voice = makeShared<SimpleVoipPacket>();
     voice->setTalkspurtID(talkspurtID - 1);
     voice->setTalkspurtNumPackets(talkspurtNumPackets);
     voice->setPacketID(packetID);
     voice->setVoipTimestamp(simTime() - packetizationInterval); // start time of voice in this packet
     voice->setVoiceDuration(packetizationInterval);
     voice->setTotalLengthField(talkPacketSize);
     voice->setChunkLength(B(talkPacketSize));
     packet->insertAtBack(voice);
  
     EV_INFO << "TALKSPURT " << talkspurtID - 1 << " sending packet " << packetID << "\n";
  
     socket.sendTo(packet, destAddress, destPort);
     ++packetID;
  
     if (packetID < talkspurtNumPackets)
         scheduleAfter(packetizationInterval, selfSender);
 }

Referenced by handleMessage().

◆ talkspurt()

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

protected

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