inet::SimpleVoipReceiver Class Reference

Implements a simple VoIP source. More...

#include <SimpleVoipReceiver.h>

Inheritance diagram for inet::SimpleVoipReceiver:

Classes
class	TalkspurtInfo
class	VoipPacketInfo

Public Member Functions
	SimpleVoipReceiver ()
	~SimpleVoipReceiver ()
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 ()
Public Member Functions inherited from inet::UdpSocket::ICallback
virtual	~ICallback ()

Protected Member Functions
virtual int	numInitStages () const override
void	initialize (int stage) override
void	handleMessage (cMessage *msg) override
virtual void	finish () override
virtual void	socketDataArrived (UdpSocket *socket, Packet *packet) override
	Notifies about data arrival, packet ownership is transferred to the callee. More...
virtual void	socketErrorArrived (UdpSocket *socket, Indication *indication) override
	Notifies about error indication arrival, indication ownership is transferred to the callee. More...
virtual void	socketClosed (UdpSocket *socket) override
	Notifies about socket closed, indication ownership is transferred to the callee. More...

Private Types
typedef std::list< VoipPacketInfo * >	PacketsList
typedef std::vector< VoipPacketInfo >	PacketsVector

Private Member Functions
double	eModel (double delay, double loss)
void	evaluateTalkspurt (bool finish)
void	startTalkspurt (Packet *packet)

Private Attributes
double	emodelRo = NaN
unsigned int	bufferSpace = 0
int	emodelIe = -1
int	emodelBpl = -1
int	emodelA = -1
simtime_t	playoutDelay
simtime_t	mosSpareTime
UdpSocket	socket
cMessage *	selfTalkspurtFinished = nullptr
TalkspurtInfo	currentTalkspurt

Static Private Attributes
static simsignal_t	voipPacketLossRateSignal = registerSignal("voipPacketLossRate")
static simsignal_t	voipPacketDelaySignal = registerSignal("voipPacketDelay")
static simsignal_t	voipPlayoutDelaySignal = registerSignal("voipPlayoutDelay")
static simsignal_t	voipPlayoutLossRateSignal = registerSignal("voipPlayoutLossRate")
static simsignal_t	voipMosRateSignal = registerSignal("voipMosRate")
static simsignal_t	voipTaildropLossRateSignal = registerSignal("voipTaildropLossRate")

Detailed Description

Implements a simple VoIP source.

See the NED file for more information.

Member Typedef Documentation

PacketsList

typedef std::list<VoipPacketInfo *> inet::SimpleVoipReceiver::PacketsList

private

PacketsVector

typedef std::vector<VoipPacketInfo> inet::SimpleVoipReceiver::PacketsVector

private

Constructor & Destructor Documentation

SimpleVoipReceiver()

inet::SimpleVoipReceiver::SimpleVoipReceiver

(

)

{
}

~SimpleVoipReceiver()

inet::SimpleVoipReceiver::~SimpleVoipReceiver

(

)

{
    cancelAndDelete(selfTalkspurtFinished);
}

Member Function Documentation

eModel()

double inet::SimpleVoipReceiver::eModel ( double  delay, double  loss  )

private

{
    static const double alpha3 = 177.3; // ms
    double delayms = 1000.0 * delay;
 
    // Compute the Id parameter
    int u = (delayms - alpha3) > 0 ? 1 : 0;
    double id = 0.024 * delayms + 0.11 * (delayms - alpha3) * u;
 
    // p: Packet loss rate in %
    double p = lossRate * 100;
    // Compute the Ie,eff parameter
    double ie_eff = emodelIe + (95 - emodelIe) * p / (p + emodelBpl);
 
    // Compute the R factor
    double Rfactor = emodelRo - id - ie_eff + emodelA;
 
    // Compute the MOS value
    double mos = 0.0;
 
    if (Rfactor < 0.0) {
        mos = 1.0;
    }
    else if (Rfactor > 100.0) {
        mos = 4.5;
    }
    else {
        mos = 1.0 + 0.035 * Rfactor + 7.0 * 1E-6 * Rfactor * (Rfactor - 60.0) * (100.0 - Rfactor);
    }
 
    mos = (mos < 1.0) ? 1.0 : mos;
 
    return mos;
}

Referenced by evaluateTalkspurt().

evaluateTalkspurt()

void inet::SimpleVoipReceiver::evaluateTalkspurt ( bool  finish )

private

{
    ASSERT(!currentTalkspurt.packets.empty());
    ASSERT(currentTalkspurt.isActive());
 
    VoipPacketInfo firstPacket = currentTalkspurt.packets.front();
 
    simtime_t firstPlayoutTime = firstPacket.arrivalTime + playoutDelay;
    simtime_t mouthToEarDelay = firstPlayoutTime - firstPacket.creationTime;
    unsigned int firstPacketId = firstPacket.packetID;
    unsigned int talkspurtNumPackets = currentTalkspurt.talkspurtNumPackets;
    unsigned int playoutLoss = 0;
    unsigned int tailDropLoss = 0;
    unsigned int channelLoss;
 
    if (finish) {
        unsigned int maxId = 0;
        for (auto& elem : currentTalkspurt.packets)
            maxId = std::max(maxId, (elem).packetID);
        channelLoss = maxId + 1 - currentTalkspurt.packets.size();
    }
    else
        channelLoss = currentTalkspurt.talkspurtNumPackets - currentTalkspurt.packets.size();
 
    // Note: duplicate packets may shadow lost packets in the above channel loss calculation,
    // we'll correct that in the code below when we detect duplicates.
 
    double packetLossRate = ((double)channelLoss / (double)talkspurtNumPackets);
    emit(voipPacketLossRateSignal, packetLossRate);
 
    // vector to manage duplicated packets
    bool *isArrived = new bool[talkspurtNumPackets];
    for (unsigned int y = 0; y < talkspurtNumPackets; y++)
        isArrived[y] = false;
 
    simtime_t lastLateness = -playoutDelay; // arrival time - playout time
    simtime_t maxLateness = -playoutDelay;
 
    // compute channelLoss, playoutLoss and tailDropLoss, needed for MOS and statistics
    PacketsList playoutQueue;
    for (auto& elem : currentTalkspurt.packets) {
        elem.playoutTime = (firstPlayoutTime + ((int)elem.packetID - (int)firstPacketId) * currentTalkspurt.voiceDuration);
 
        lastLateness = elem.arrivalTime - elem.playoutTime; // >0: packet is too late (missed its playout time)
        if (maxLateness < lastLateness)
            maxLateness = lastLateness;
 
        EV_DEBUG << "MEASURED PACKET LATENESS: " << lastLateness << " TALK " << currentTalkspurt.talkspurtID << " PACKET " << elem.packetID << "\n\n";
 
        // Management of duplicated packets
        if (isArrived[elem.packetID]) {
            ++channelLoss; // duplicate packets may shadow lost packets in the channel loss calculation above, we correct that here.
            EV_DEBUG << "DUPLICATED PACKET: TALK " << currentTalkspurt.talkspurtID << " PACKET " << elem.packetID << "\n\n";
        }
        else if (lastLateness > 0.0) {
            ++playoutLoss;
            EV_DEBUG << "REMOVED LATE PACKET: TALK " << currentTalkspurt.talkspurtID << " PACKET " << elem.packetID << ", LATENESS " << lastLateness * 1000.0 << "ms\n\n";
        }
        else {
            // insert packet into playout buffer (if there is room in it)
 
            // remove packets from queue
            auto qi = playoutQueue.begin();
            while (qi != playoutQueue.end()) {
                if ((*qi)->playoutTime < elem.arrivalTime) {
//                    EV_DEBUG << "REPRODUCED AND EXTRACT FROM BUFFER: TALK " << currentTalkspurt.talkspurtID << " PACKET " << (*qi)->packetID << "\n";
                    qi = playoutQueue.erase(qi);
                }
                else
                    ++qi;
            }
 
            if (playoutQueue.size() < bufferSpace) {
                EV_DEBUG << "PACKET INSERTED INTO PLAYOUT BUFFER: TALK "
                         << currentTalkspurt.talkspurtID << " PACKET " << elem.packetID << ", "
                         << "ARRIVAL TIME " << elem.arrivalTime << "s, "
                         << "PLAYOUT TIME " << elem.playoutTime << "s\n\n";
 
                isArrived[elem.packetID] = true; // isArrived[] is needed for detecting duplicate packets
 
                playoutQueue.push_back(&(elem));
            }
            else {
                // buffer full
                ++tailDropLoss;
                EV_DEBUG << "BUFFER FULL, PACKET DISCARDED: TALK " << currentTalkspurt.talkspurtID << " PACKET "
                         << elem.packetID << " ARRIVAL TIME " << elem.arrivalTime << "s\n\n";
            }
        }
    }
 
    double proportionalLossRate = (double)(tailDropLoss + playoutLoss + channelLoss) / (double)talkspurtNumPackets;
    EV_DEBUG << "proportionalLossRate " << proportionalLossRate << "(tailDropLoss=" << tailDropLoss
             << " - playoutLoss=" << playoutLoss << " - channelLoss=" << channelLoss << ")\n\n";
 
    double mos = eModel(SIMTIME_DBL(mouthToEarDelay), proportionalLossRate);
 
    emit(voipPlayoutDelaySignal, playoutDelay);
    double lossRate = ((double)playoutLoss / (double)talkspurtNumPackets);
    emit(voipPlayoutLossRateSignal, lossRate);
    emit(voipMosRateSignal, mos);
 
    // add calculated MOS value to fingerprint
    FINGERPRINT_ADD_EXTRA_DATA(mos);
 
    double tailDropRate = ((double)tailDropLoss / (double)talkspurtNumPackets);
    emit(voipTaildropLossRateSignal, tailDropRate);
 
    EV_DEBUG << "CALCULATED MOS: eModel( " << playoutDelay << " , " << tailDropLoss << "+" << playoutLoss << "+" << channelLoss << " ) = " << mos << "\n\n";
 
    EV_DEBUG << "PLAYOUT DELAY ADAPTATION \n" << "OLD PLAYOUT DELAY: " << playoutDelay << "\nMAX LATENESS MEASURED: " << maxLateness << "\n\n";
 
    if (par("adaptivePlayoutDelay")) {
        playoutDelay += maxLateness;
        if (playoutDelay < 0.0)
            playoutDelay = 0.0;
        EV_DEBUG << "NEW PLAYOUT DELAY: " << playoutDelay << "\n\n";
    }
 
    delete[] isArrived;
    currentTalkspurt.finishTalkspurt();
}

Referenced by finish(), handleMessage(), and socketDataArrived().

finish()

void inet::SimpleVoipReceiver::finish ( )

overrideprotectedvirtual

{
    // evaluate last talkspurt
    cancelEvent(selfTalkspurtFinished);
    if (currentTalkspurt.isActive())
        evaluateTalkspurt(true);
}

Referenced by evaluateTalkspurt().

handleMessage()

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

overrideprotected

{
    if (msg->isSelfMessage()) {
        // selfTalkspurtFinished
        evaluateTalkspurt(false);
    }
    else if (msg->arrivedOn("socketIn")) {
        socket.processMessage(msg);
    }
    else
        throw cRuntimeError("Unknown incoming gate: '%s'", msg->getArrivalGate()->getFullName());
}

initialize()

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

overrideprotected

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        emodelIe = par("emodelIe");
        emodelBpl = par("emodelBpl");
        emodelA = par("emodelA");
        emodelRo = par("emodelRo");
 
        bufferSpace = par("bufferSpace");
        playoutDelay = par("playoutDelay");
        mosSpareTime = par("mosSpareTime");
 
        currentTalkspurt.talkspurtID = -1;
    }
    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");
 
        int port = par("localPort");
        EV_INFO << "VoIPReceiver::initialize - binding to port: local:" << port << endl;
        if (port != -1) {
            socket.setOutputGate(gate("socketOut"));
            socket.bind(port);
        }
        socket.setCallback(this);
 
        selfTalkspurtFinished = new cMessage("selfTalkspurtFinished");
    }
}

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

socketClosed()

virtual void inet::SimpleVoipReceiver::socketClosed ( UdpSocket *  socket )

inlineoverrideprotectedvirtual

Notifies about socket closed, indication ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{}

socketDataArrived()

void inet::SimpleVoipReceiver::socketDataArrived ( UdpSocket *  socket, Packet *  packet  )

overrideprotectedvirtual

Notifies about data arrival, packet ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{
    // process incoming packet
    const auto& voice = packet->peekAtFront<SimpleVoipPacket>();
 
    if (currentTalkspurt.status == TalkspurtInfo::EMPTY) {
        // first talkspurt
        startTalkspurt(packet);
    }
    else if (voice->getTalkspurtID() > currentTalkspurt.talkspurtID) {
        // old talkspurt finished, new talkspurt started
        if (currentTalkspurt.isActive()) {
            cancelEvent(selfTalkspurtFinished);
            evaluateTalkspurt(false);
        }
        startTalkspurt(packet);
    }
    else if (currentTalkspurt.talkspurtID == voice->getTalkspurtID() && currentTalkspurt.status == TalkspurtInfo::ACTIVE) {
        // talkspurt continued
        if (!currentTalkspurt.checkPacket(voice.get()))
            throw cRuntimeError("Talkspurt parameters not equals");
        currentTalkspurt.addPacket(voice.get());
    }
    else {
        // packet from older talkspurt, ignore
        EV_DEBUG << "PACKET ARRIVED TOO LATE: TALKSPURT " << voice->getTalkspurtID() << " PACKET " << voice->getPacketID() << ", IGNORED\n\n";
        delete packet;
        return;
    }
 
    EV_DEBUG << "PACKET ARRIVED: TALKSPURT " << voice->getTalkspurtID() << " PACKET " << voice->getPacketID() << "\n\n";
 
    simtime_t delay = packet->getArrivalTime() - voice->getVoipTimestamp();
    emit(voipPacketDelaySignal, delay);
 
    delete packet;
}

socketErrorArrived()

void inet::SimpleVoipReceiver::socketErrorArrived ( UdpSocket *  socket, Indication *  indication  )

overrideprotectedvirtual

Notifies about error indication arrival, indication ownership is transferred to the callee.

Implements inet::UdpSocket::ICallback.

{
    EV_WARN << "Unknown message '" << indication->getName() << "', kind = " << indication->getKind() << ", discarding it." << endl;
    delete indication;
}

startTalkspurt()

void inet::SimpleVoipReceiver::startTalkspurt ( Packet *  packet )

private

{
    const auto& voice = packet->peekAtFront<SimpleVoipPacket>();
    currentTalkspurt.startTalkspurt(voice.get());
    simtime_t endTime = simTime() + playoutDelay + (currentTalkspurt.talkspurtNumPackets - voice->getPacketID()) * currentTalkspurt.voiceDuration + mosSpareTime;
    scheduleAt(endTime, selfTalkspurtFinished);
}

Referenced by socketDataArrived().

Member Data Documentation

bufferSpace

unsigned int inet::SimpleVoipReceiver::bufferSpace = 0

private

Referenced by evaluateTalkspurt(), and initialize().

currentTalkspurt

TalkspurtInfo inet::SimpleVoipReceiver::currentTalkspurt

private

Referenced by evaluateTalkspurt(), finish(), initialize(), socketDataArrived(), and startTalkspurt().

emodelA

int inet::SimpleVoipReceiver::emodelA = -1

private

Referenced by eModel(), and initialize().

emodelBpl

int inet::SimpleVoipReceiver::emodelBpl = -1

private

Referenced by eModel(), and initialize().

emodelIe

int inet::SimpleVoipReceiver::emodelIe = -1

private

Referenced by eModel(), and initialize().

emodelRo

double inet::SimpleVoipReceiver::emodelRo = NaN

private

Referenced by eModel(), and initialize().

mosSpareTime

simtime_t inet::SimpleVoipReceiver::mosSpareTime

private

Referenced by initialize(), and startTalkspurt().

playoutDelay

simtime_t inet::SimpleVoipReceiver::playoutDelay

private

Referenced by evaluateTalkspurt(), initialize(), and startTalkspurt().

selfTalkspurtFinished

cMessage* inet::SimpleVoipReceiver::selfTalkspurtFinished = nullptr

private

Referenced by finish(), initialize(), socketDataArrived(), startTalkspurt(), and ~SimpleVoipReceiver().

socket

UdpSocket inet::SimpleVoipReceiver::socket

private

Referenced by handleMessage(), and initialize().

voipMosRateSignal

simsignal_t inet::SimpleVoipReceiver::voipMosRateSignal = registerSignal("voipMosRate")

staticprivate

Referenced by evaluateTalkspurt().

voipPacketDelaySignal

simsignal_t inet::SimpleVoipReceiver::voipPacketDelaySignal = registerSignal("voipPacketDelay")

staticprivate

Referenced by socketDataArrived().

voipPacketLossRateSignal

simsignal_t inet::SimpleVoipReceiver::voipPacketLossRateSignal = registerSignal("voipPacketLossRate")

staticprivate

Referenced by evaluateTalkspurt().

voipPlayoutDelaySignal

simsignal_t inet::SimpleVoipReceiver::voipPlayoutDelaySignal = registerSignal("voipPlayoutDelay")

staticprivate

Referenced by evaluateTalkspurt().

voipPlayoutLossRateSignal

simsignal_t inet::SimpleVoipReceiver::voipPlayoutLossRateSignal = registerSignal("voipPlayoutLossRate")

staticprivate

Referenced by evaluateTalkspurt().

voipTaildropLossRateSignal

simsignal_t inet::SimpleVoipReceiver::voipTaildropLossRateSignal = registerSignal("voipTaildropLossRate")

staticprivate

Referenced by evaluateTalkspurt().

---

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

• SimpleVoipReceiver.h
• SimpleVoipReceiver.cc