inet::rtp::RtpProfile Class Reference

The class RtpProfile is a module which handles RtpPayloadSender and RtpPayloadReceiver modules. More...

#include <RtpProfile.h>

Inheritance diagram for inet::rtp::RtpProfile:

Classes
class	SsrcGate

Public Member Functions
	RtpProfile ()

Protected Types
typedef std::map< uint32_t, SsrcGate * >	SsrcGateMap
	Stores information to which gate rtp data packets from a ssrc must be forwarded. More...

Protected Member Functions
virtual void	initialize () override
	Initializes variables. More...
virtual	~RtpProfile ()
virtual void	handleMessage (cMessage *msg) override
	Creates and removes payload sender and receiver modules on demand. More...
virtual void	handleMessageFromRTP (cMessage *msg)
	Handles messages received from the rtp module. More...
virtual void	handleMessageFromPayloadSender (cMessage *msg)
	Handles messages coming from the sender module. More...
virtual void	handleMessageFromPayloadReceiver (cMessage *msg)
	Handles messages coming from a receiver module. More...
virtual void	initializeProfile (RtpInnerPacket *rinp)
	Initialization message received from rtp module. More...
virtual void	createSenderModule (RtpInnerPacket *rinp)
	This method is called when the application issued the creation of an rtp payload sender module to transmit data. More...
virtual void	deleteSenderModule (RtpInnerPacket *rinp)
	When a sender module is no longer needed it can be deleted by the profile module. More...
virtual void	senderModuleControl (RtpInnerPacket *rinp)
	The profile module forwards sender control messages to the sender module. More...
virtual void	dataIn (RtpInnerPacket *rinp)
	Handles incoming data packets: If there isn't a receiver module for this sender it creates one. More...
virtual void	senderModuleInitialized (RtpInnerPacket *rinp)
	The sender module returns a senderModuleInitialized message after being initialized. More...
virtual void	senderModuleStatus (RtpInnerPacket *rinp)
	After having received a sender module control message the sender module returns a sender status message to inform the application what it's doing at the moment. More...
virtual void	dataOut (RtpInnerPacket *rinp)
	Handles outgoing data packets: Calls processOutgoingPacket and forwards the packet to the rtp module. More...
virtual void	processIncomingPacket (RtpInnerPacket *rinp)
	Every time a rtp packet is received it it pre-processed by this method to remove profile specific extension which are not handled by the payload receiver module. More...
virtual void	processOutgoingPacket (RtpInnerPacket *rinp)
	Simular to the procedure for incoming packets, this adds profile specific extensions to outgoing rtp packets. More...
virtual SsrcGate *	findSSRCGate (uint32_t ssrc)
	Finds the gate of the receiver module for rtp data packets from this ssrc. More...
virtual SsrcGate *	newSSRCGate (uint32_t ssrc)
	Creates a new association ssrc/gateId for this ssrc. More...

Protected Attributes
const char *	_profileName = nullptr
	The name of this profile. More...
int	_maxReceivers = 0
	The maximum number of incoming data streams this profile module can handle. More...
SsrcGateMap	_ssrcGates
int	_rtcpPercentage = 0
	The percentage of the available bandwidth to be used for rtcp. More...
int	_preferredPort = -1
	The rtp port this profile uses if no port is given. More...
int	_mtu = 0
	The maximum size an RtpPacket can have. More...
bool	_autoOutputFileNames = false
	If this is set true the RtpProfile automatically sets the output file name for payload receiver modules so the user is not bothered to set them manually during simulation runtime. More...

Detailed Description

The class RtpProfile is a module which handles RtpPayloadSender and RtpPayloadReceiver modules.

It creates them dynamically on demand. This class offers all functionality for the above tasks, subclasses just need to set variables like profile name, rtcp percentage and preferred port in their initialize() method. The dynamically created sender and receiver modules must have have following class names: Rtp<profileName>Payload<payloadType>Sender Rtp<profileName>Payload<payloadType>Receiver

Member Typedef Documentation

SsrcGateMap

typedef std::map<uint32_t, SsrcGate *> inet::rtp::RtpProfile::SsrcGateMap

protected

Stores information to which gate rtp data packets from a ssrc must be forwarded.

Constructor & Destructor Documentation

RtpProfile()

inet::rtp::RtpProfile::RtpProfile

(

)

{
}

~RtpProfile()

inet::rtp::RtpProfile::~RtpProfile ( )

protectedvirtual

{
    for (auto& elem : _ssrcGates)
        delete elem.second;
}

Member Function Documentation

createSenderModule()

void inet::rtp::RtpProfile::createSenderModule ( RtpInnerPacket *  rinp )

protectedvirtual

This method is called when the application issued the creation of an rtp payload sender module to transmit data.

It creates a new sender module and connects it. The profile module informs the rtp module of having finished this task. Then it initializes the newly create sender module with a inititalizeSenderModule message.

{
    EV_TRACE << "createSenderModule Enter" << endl;
    int ssrc = rinp->getSsrc();
    int payloadType = rinp->getPayloadType();
 
    EV_INFO << "ProfileName: " << _profileName << " payloadType: " << payloadType << endl;
 
    std::string moduleTypeName(std::string("inet.transportlayer.rtp.Rtp") + _profileName + "Payload" + std::to_string(payloadType) + "Sender");
    std::string moduleName(std::string("rtp") + _profileName + "Payload" + std::to_string(payloadType) + "Sender");
 
    cModuleType *moduleType = cModuleType::find(moduleTypeName.c_str());
    if (moduleType == nullptr)
        throw cRuntimeError("RtpProfile: payload sender module '%s' not found", moduleTypeName.c_str());
 
    RtpPayloadSender *rtpPayloadSender = check_and_cast<RtpPayloadSender *>(moduleType->create(moduleName.c_str(), this));
    rtpPayloadSender->finalizeParameters();
 
    gate("payloadSenderOut")->connectTo(rtpPayloadSender->gate("profileIn"));
    rtpPayloadSender->gate("profileOut")->connectTo(gate("payloadSenderIn"));
 
    rtpPayloadSender->callInitialize();
    rtpPayloadSender->scheduleStart(simTime());
 
    RtpInnerPacket *rinpOut1 = new RtpInnerPacket("senderModuleCreated()");
    rinpOut1->setSenderModuleCreatedPkt(ssrc);
    send(rinpOut1, "rtpOut");
 
    RtpInnerPacket *rinpOut2 = new RtpInnerPacket("initializeSenderModule()");
    rinpOut2->setInitializeSenderModulePkt(ssrc, rinp->getFileName(), _mtu);
    send(rinpOut2, "payloadSenderOut");
 
    delete rinp;
    EV_TRACE << "createSenderModule Exit" << endl;
}

Referenced by handleMessageFromRTP().

dataIn()

void inet::rtp::RtpProfile::dataIn ( RtpInnerPacket *  rinp )

protectedvirtual

Handles incoming data packets: If there isn't a receiver module for this sender it creates one.

The data packet is forwarded to the receiver module after calling processIncomingPacket.

{
    EV_TRACE << "dataIn(RtpInnerPacket *rinp) Enter" << endl;
    processIncomingPacket(rinp);
 
    Packet *packet = check_and_cast<Packet *>(rinp->getEncapsulatedPacket());
    const auto& rtpHeader = packet->peekAtFront<RtpHeader>();
 
    uint32_t ssrc = rtpHeader->getSsrc();
 
    SsrcGate *ssrcGate = findSSRCGate(ssrc);
 
    if (!ssrcGate) {
        ssrcGate = newSSRCGate(ssrc);
        std::string payloadReceiverTypeName(std::string("inet.transportlayer.rtp.Rtp") + _profileName + "Payload" + std::to_string(rtpHeader->getPayloadType()) + "Receiver");
        std::string payloadReceiverName(std::string("rtp") + _profileName + "Payload" + std::to_string(rtpHeader->getPayloadType()) + "Receiver" + std::to_string(ssrc));
        cModuleType *moduleType = cModuleType::find(payloadReceiverTypeName.c_str());
        if (moduleType == nullptr)
            throw cRuntimeError("Receiver module type %s not found", payloadReceiverTypeName.c_str());
        else {
            RtpPayloadReceiver *receiverModule =
                check_and_cast<RtpPayloadReceiver *>(moduleType->create(payloadReceiverName.c_str(), this));
            if (_autoOutputFileNames) {
                char outputFileName[100];
                sprintf(outputFileName, "id%i.sim", receiverModule->getId());
                receiverModule->par("outputFileName") = outputFileName;
            }
            receiverModule->finalizeParameters();
 
            this->gate(ssrcGate->getGateId())->connectTo(receiverModule->gate("profileIn"));
            receiverModule->gate("profileOut")->connectTo(this->gate(ssrcGate->getGateId()
                            - findGate("payloadReceiverOut", 0) + findGate("payloadReceiverIn", 0)));
 
            for (int i = 0; receiverModule->callInitialize(i); i++)
                ;
 
            receiverModule->scheduleStart(simTime());
        }
    }
 
    send(rinp, ssrcGate->getGateId());
    EV_TRACE << "dataIn(RtpInnerPacket *rinp) Exit" << endl;
}

Referenced by handleMessageFromRTP().

dataOut()

void inet::rtp::RtpProfile::dataOut ( RtpInnerPacket *  rinp )

protectedvirtual

Handles outgoing data packets: Calls processOutgoingPacket and forwards the packet to the rtp module.

{
    processOutgoingPacket(rinp);
    send(rinp, "rtpOut");
}

Referenced by handleMessageFromPayloadSender().

deleteSenderModule()

void inet::rtp::RtpProfile::deleteSenderModule ( RtpInnerPacket *  rinp )

protectedvirtual

When a sender module is no longer needed it can be deleted by the profile module.

{
    cModule *senderModule = gate("payloadSenderOut")->getNextGate()->getOwnerModule();
    senderModule->deleteModule();
 
    RtpInnerPacket *rinpOut = new RtpInnerPacket("senderModuleDeleted()");
    rinpOut->setSenderModuleDeletedPkt(rinpIn->getSsrc());
    delete rinpIn;
 
    send(rinpOut, "rtpOut");
}

Referenced by handleMessageFromRTP().

findSSRCGate()

RtpProfile::SsrcGate * inet::rtp::RtpProfile::findSSRCGate ( uint32_t  ssrc )

protectedvirtual

Finds the gate of the receiver module for rtp data packets from this ssrc.

{
    auto objectIndex = _ssrcGates.find(ssrc);
    return (objectIndex == _ssrcGates.end()) ? nullptr : objectIndex->second;
}

Referenced by dataIn().

handleMessage()

void inet::rtp::RtpProfile::handleMessage ( cMessage *  msg )

overrideprotectedvirtual

Creates and removes payload sender and receiver modules on demand.

{
    if (msg->getArrivalGateId() == findGate("rtpIn")) {
        handleMessageFromRTP(msg);
    }
    else if (msg->getArrivalGateId() == findGate("payloadSenderIn")) {
        handleMessageFromPayloadSender(msg);
    }
    else if (msg->getArrivalGateId() >= findGate("payloadReceiverIn")
             && msg->getArrivalGateId() < findGate("payloadReceiverIn") + _maxReceivers)
    {
        handleMessageFromPayloadReceiver(msg);
    }
    else {
        throw cRuntimeError("message coming from unknown gate");
    }
}

handleMessageFromPayloadReceiver()

void inet::rtp::RtpProfile::handleMessageFromPayloadReceiver ( cMessage *  msg )

protectedvirtual

Handles messages coming from a receiver module.

{
    // currently payload receiver modules don't send messages
    delete msg;
}

Referenced by handleMessage().

handleMessageFromPayloadSender()

void inet::rtp::RtpProfile::handleMessageFromPayloadSender ( cMessage *  msg )

protectedvirtual

Handles messages coming from the sender module.

{
    RtpInnerPacket *rinpIn = check_and_cast<RtpInnerPacket *>(msg);
 
    switch (rinpIn->getType()) {
        case RTP_INP_DATA_OUT:
            dataOut(rinpIn);
            break;
 
        case RTP_INP_SENDER_MODULE_INITIALIZED:
            senderModuleInitialized(rinpIn);
            break;
 
        case RTP_INP_SENDER_MODULE_STATUS:
            senderModuleStatus(rinpIn);
            break;
 
        default:
            throw cRuntimeError("Profile received RtpInnerPacket from sender module with wrong type: %d", rinpIn->getType());
            break;
    }
}

Referenced by handleMessage().

handleMessageFromRTP()

void inet::rtp::RtpProfile::handleMessageFromRTP ( cMessage *  msg )

protectedvirtual

Handles messages received from the rtp module.

{
    EV_TRACE << "handleMessageFromRTP Enter " << endl;
 
    RtpInnerPacket *rinpIn = check_and_cast<RtpInnerPacket *>(msg);
 
    switch (rinpIn->getType()) {
        case RTP_INP_INITIALIZE_PROFILE:
            initializeProfile(rinpIn);
            break;
 
        case RTP_INP_CREATE_SENDER_MODULE:
            createSenderModule(rinpIn);
            break;
 
        case RTP_INP_DELETE_SENDER_MODULE:
            deleteSenderModule(rinpIn);
            break;
 
        case RTP_INP_SENDER_MODULE_CONTROL:
            senderModuleControl(rinpIn);
            break;
 
        case RTP_INP_DATA_IN:
            dataIn(rinpIn);
            break;
 
        default:
            throw cRuntimeError("RtpInnerPacket from RtpModule has wrong type: %d", rinpIn->getType());
            break;
    }
 
    EV_TRACE << "handleMessageFromRTP Exit " << endl;
}

Referenced by handleMessage().

initialize()

void inet::rtp::RtpProfile::initialize ( )

overrideprotectedvirtual

Initializes variables.

Must be overwritten by subclasses.

Reimplemented in inet::rtp::RtpAvProfile.

{
    EV_TRACE << "initialize() Enter" << endl;
    _profileName = "Profile";
    _rtcpPercentage = 5;
    _preferredPort = PORT_UNDEF;
 
    // how many gates to payload receivers do we have
    _maxReceivers = gateSize("payloadReceiverOut");
    _ssrcGates.clear();
    _autoOutputFileNames = par("autoOutputFileNames");
    EV_TRACE << "initialize() Exit" << endl;
}

initializeProfile()

void inet::rtp::RtpProfile::initializeProfile ( RtpInnerPacket *  rinp )

protectedvirtual

Initialization message received from rtp module.

{
    EV_TRACE << "initializeProfile Enter" << endl;
    _mtu = rinp->getMtu();
    delete rinp;
    RtpInnerPacket *rinpOut = new RtpInnerPacket("profileInitialized()");
    rinpOut->setProfileInitializedPkt(_rtcpPercentage, _preferredPort);
    send(rinpOut, "rtpOut");
    EV_TRACE << "initializeProfile Exit" << endl;
}

Referenced by handleMessageFromRTP().

newSSRCGate()

RtpProfile::SsrcGate * inet::rtp::RtpProfile::newSSRCGate ( uint32_t  ssrc )

protectedvirtual

Creates a new association ssrc/gateId for this ssrc.

{
    SsrcGate *ssrcGate = new SsrcGate(ssrc);
    bool assigned = false;
    int receiverGateId = findGate("payloadReceiverOut", 0);
    for (int i = receiverGateId; i < receiverGateId + _maxReceivers && !assigned; i++) {
        if (!gate(i)->isConnected()) {
            ssrcGate->setGateId(i);
            assigned = true;
        }
    }
 
    if (!assigned)
        throw cRuntimeError("Can't manage more senders");
 
    _ssrcGates[ssrc] = ssrcGate;
    return ssrcGate;
}

Referenced by dataIn().

processIncomingPacket()

void inet::rtp::RtpProfile::processIncomingPacket ( RtpInnerPacket *  rinp )

protectedvirtual

Every time a rtp packet is received it it pre-processed by this method to remove profile specific extension which are not handled by the payload receiver module.

In this implementation the packet isn't changed. Important: This method works with RtpInnerPacket. So the rtp packet must be decapsulated, changed and encapsulated again.

{
    // do nothing with the packet
}

Referenced by dataIn().

processOutgoingPacket()

void inet::rtp::RtpProfile::processOutgoingPacket ( RtpInnerPacket *  rinp )

protectedvirtual

Simular to the procedure for incoming packets, this adds profile specific extensions to outgoing rtp packets.

{
    // do nothing with the packet
}

Referenced by dataOut().

senderModuleControl()

void inet::rtp::RtpProfile::senderModuleControl ( RtpInnerPacket *  rinp )

protectedvirtual

The profile module forwards sender control messages to the sender module.

{
    send(rinp, "payloadSenderOut");
}

Referenced by handleMessageFromRTP().

senderModuleInitialized()

void inet::rtp::RtpProfile::senderModuleInitialized ( RtpInnerPacket *  rinp )

protectedvirtual

The sender module returns a senderModuleInitialized message after being initialized.

The profile module forwards this message to the rtp module which delivers it to its destination, the rtcp module.

{
    EV_TRACE << "senderModuleInitialized" << endl;
    send(rinp, "rtpOut");
}

Referenced by handleMessageFromPayloadSender().

senderModuleStatus()

void inet::rtp::RtpProfile::senderModuleStatus ( RtpInnerPacket *  rinp )

protectedvirtual

After having received a sender module control message the sender module returns a sender status message to inform the application what it's doing at the moment.

{
    EV_TRACE << "senderModuleStatus" << endl;
    send(rinp, "rtpOut");
}

Referenced by handleMessageFromPayloadSender().

Member Data Documentation

_autoOutputFileNames

bool inet::rtp::RtpProfile::_autoOutputFileNames = false

protected

If this is set true the RtpProfile automatically sets the output file name for payload receiver modules so the user is not bothered to set them manually during simulation runtime.

Referenced by dataIn(), and initialize().

_maxReceivers

int inet::rtp::RtpProfile::_maxReceivers = 0

protected

The maximum number of incoming data streams this profile module can handle.

It is set to the gate size of "payloadReceiverOut", "payloadReceiverIn".

Referenced by handleMessage(), initialize(), and newSSRCGate().

_mtu

int inet::rtp::RtpProfile::_mtu = 0

protected

The maximum size an RtpPacket can have.

Referenced by createSenderModule(), and initializeProfile().

_preferredPort

int inet::rtp::RtpProfile::_preferredPort = -1

protected

The rtp port this profile uses if no port is given.

Referenced by initialize(), and initializeProfile().

_profileName

const char* inet::rtp::RtpProfile::_profileName = nullptr

protected

The name of this profile.

Needed for dynamic creating of sender and receiver modules.

Referenced by createSenderModule(), dataIn(), and initialize().

_rtcpPercentage

int inet::rtp::RtpProfile::_rtcpPercentage = 0

protected

The percentage of the available bandwidth to be used for rtcp.

Referenced by initialize(), and initializeProfile().

_ssrcGates

SsrcGateMap inet::rtp::RtpProfile::_ssrcGates

protected

Referenced by findSSRCGate(), initialize(), newSSRCGate(), and ~RtpProfile().

---

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

• RtpProfile.h
• RtpProfile.cc