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, 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 ssrc)
	Finds the gate of the receiver module for rtp data packets from this ssrc. More...
virtual SSRCGate *	newSSRCGate (uint32 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

typedef std::map<uint32, SSRCGate *> inet::rtp::RTPProfile::SSRCGateMap

protected

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

Constructor & Destructor Documentation

inet::rtp::RTPProfile::RTPProfile

(

)

{
}

inet::rtp::RTPProfile::~RTPProfile ( )

protectedvirtual

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

Member Function Documentation

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.

Referenced by handleMessageFromRTP().

{
    EV_TRACE << "createSenderModule Enter" << endl;
    int ssrc = rinp->getSsrc();
    int payloadType = rinp->getPayloadType();
    char moduleName[100];

    EV_INFO << "ProfileName: " << _profileName << " payloadType: " << payloadType << endl;
    const char *pkgPrefix = "inet.transportlayer.rtp.";    //FIXME hardcoded string
    sprintf(moduleName, "%sRTP%sPayload%iSender", pkgPrefix, _profileName, payloadType);

    cModuleType *moduleType = cModuleType::find(moduleName);
    if (moduleType == nullptr)
        throw cRuntimeError("RTPProfile: payload sender module '%s' not found", moduleName);

    RTPPayloadSender *rtpPayloadSender = (RTPPayloadSender *)(moduleType->create(moduleName, 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;
}

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.

Referenced by handleMessageFromRTP().

{
    EV_TRACE << "dataIn(RTPInnerPacket *rinp) Enter" << endl;
    processIncomingPacket(rinp);

    RTPPacket *packet = check_and_cast<RTPPacket *>(rinp->getEncapsulatedPacket());

    uint32 ssrc = packet->getSsrc();

    SSRCGate *ssrcGate = findSSRCGate(ssrc);

    if (!ssrcGate) {
        ssrcGate = newSSRCGate(ssrc);
        char payloadReceiverName[100];
        const char *pkgPrefix = "inet.transportlayer.rtp.";    //FIXME hardcoded string
        sprintf(payloadReceiverName, "%sRTP%sPayload%iReceiver",
                pkgPrefix, _profileName, packet->getPayloadType());

        cModuleType *moduleType = cModuleType::find(payloadReceiverName);
        if (moduleType == nullptr)
            throw cRuntimeError("Receiver module type %s not found", payloadReceiverName);
        else {
            RTPPayloadReceiver *receiverModule =
                (RTPPayloadReceiver *)(moduleType->create(payloadReceiverName, 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;
}

void inet::rtp::RTPProfile::dataOut ( RTPInnerPacket *  rinp )

protectedvirtual

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

Referenced by handleMessageFromPayloadSender().

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

void inet::rtp::RTPProfile::deleteSenderModule ( RTPInnerPacket *  rinp )

protectedvirtual

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

Referenced by handleMessageFromRTP().

{
    cModule *senderModule = gate("payloadSenderOut")->getNextGate()->getOwnerModule();
    senderModule->deleteModule();

    RTPInnerPacket *rinpOut = new RTPInnerPacket("senderModuleDeleted()");
    rinpOut->setSenderModuleDeletedPkt(rinpIn->getSsrc());
    delete rinpIn;

    send(rinpOut, "rtpOut");
}

RTPProfile::SSRCGate * inet::rtp::RTPProfile::findSSRCGate ( uint32  ssrc )

protectedvirtual

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

Referenced by dataIn().

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

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

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

protectedvirtual

Handles messages coming from a receiver module.

Referenced by handleMessage().

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

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

protectedvirtual

Handles messages coming from the sender module.

Referenced by handleMessage().

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

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

protectedvirtual

Handles messages received from the rtp module.

Referenced by handleMessage().

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

void inet::rtp::RTPProfile::initialize ( )

overrideprotectedvirtual

Initializes variables.

Must be overwritten by subclasses.

Reimplemented in inet::rtp::RTPAVProfile.

Referenced by inet::rtp::RTPAVProfile::initialize().

{
    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").boolValue();
    EV_TRACE << "initialize() Exit" << endl;
}

void inet::rtp::RTPProfile::initializeProfile ( RTPInnerPacket *  rinp )

protectedvirtual

Initialization message received from rtp module.

Referenced by handleMessageFromRTP().

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

RTPProfile::SSRCGate * inet::rtp::RTPProfile::newSSRCGate ( uint32  ssrc )

protectedvirtual

Creates a new association ssrc/gateId for this ssrc.

Referenced by dataIn().

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

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.

Referenced by dataIn().

{
    // do nothing with the packet
}

void inet::rtp::RTPProfile::processOutgoingPacket ( RTPInnerPacket *  rinp )

protectedvirtual

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

Referenced by dataOut().

{
    // do nothing with the packet
}

void inet::rtp::RTPProfile::senderModuleControl ( RTPInnerPacket *  rinp )

protectedvirtual

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

Referenced by handleMessageFromRTP().

{
    send(rinp, "payloadSenderOut");
}

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.

Referenced by handleMessageFromPayloadSender().

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

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.

Referenced by handleMessageFromPayloadSender().

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

Member Data Documentation

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().

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().

int inet::rtp::RTPProfile::_mtu = 0

protected

The maximum size an RTPPacket can have.

Referenced by createSenderModule(), and initializeProfile().

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

protected

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

Referenced by inet::rtp::RTPAVProfile::initialize(), initialize(), and initializeProfile().

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(), inet::rtp::RTPAVProfile::initialize(), and initialize().

int inet::rtp::RTPProfile::_rtcpPercentage = 0

protected

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

Referenced by inet::rtp::RTPAVProfile::initialize(), initialize(), and initializeProfile().

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