inet::rtp::RTP Class Reference

An RTP is the center of the RTP layer of an endsystem. More...

#include <RTP.h>

Inheritance diagram for inet::rtp::RTP:

Public Member Functions
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual void	initialize (int stage) override
	Initializes variables. More...
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
	Handles incoming messages. More...
virtual void	handleMessageFromApp (cMessage *msg)
	Handles messages received from the applicaiton. More...
virtual void	handleMessageFromProfile (cMessage *msg)
	Handles messages received from the profile module. More...
virtual void	handleMessageFromRTCP (cMessage *msg)
	Handles messages received from the rtcp module. More...
virtual void	handleMessagefromUDP (cMessage *msg)
	Handles messages received from the UDP layer. More...
virtual void	enterSession (RTPCIEnterSession *rifp)
	Creates the profile module and initializes it. More...
virtual void	leaveSession (RTPCILeaveSession *rifp)
	Destroys the profile module and orders the rtcp module to send an rtcp bye packet. More...
virtual void	createSenderModule (RTPCICreateSenderModule *rifp)
virtual void	deleteSenderModule (RTPCIDeleteSenderModule *rifp)
virtual void	senderModuleControl (RTPCISenderControl *rifp)
virtual void	profileInitialized (RTPInnerPacket *rinp)
	Called when the profile module is initialized. More...
virtual void	senderModuleCreated (RTPInnerPacket *rinp)
virtual void	senderModuleDeleted (RTPInnerPacket *rinp)
virtual void	senderModuleInitialized (RTPInnerPacket *rinp)
virtual void	senderModuleStatus (RTPInnerPacket *rinp)
virtual void	dataOut (RTPInnerPacket *rinp)
	Sends a RTP data packet to the UDP layer and a copy of it to the rtcp module. More...
virtual void	rtcpInitialized (RTPInnerPacket *rinp)
	Informs the application that the session is entered. More...
virtual void	sessionLeft (RTPInnerPacket *rinp)
	Informs the application that this end system has left the RTP session. More...
virtual void	createProfile (const char *profileName)
	Creates the profile module. More...
virtual void	createSocket ()
	Requests a server socket from the UDP layer. More...
virtual void	socketRet ()
	Called when the socket layer returns a socket. More...
virtual void	connectRet ()
	Called when the socket layer has connected a socket. More...
virtual void	readRet (cMessage *sifp)
	Called when data from the socket layer has been received. More...
virtual void	initializeProfile ()
	Initializes the profile module. More...
virtual void	initializeRTCP ()
	Initializes the rtcp module-. More...
virtual int	resolveMTU ()
	Determines the maximum transmission unit that can be uses for RTP. More...

Protected Attributes
std::string	_commonName
	The CNAME of this end system. More...
int	_bandwidth
	The available bandwidth for this session. More...
IPv4Address	_destinationAddress
	The destination address. More...
int	_port
	The RTP port. More...
int	_mtu
	The maximum size of a packet. More...
int	_rtcpPercentage
	The percentage of the bandwidth used for rtcp. More...
UDPSocket	_udpSocket
	The UDP socket. More...
bool	_leaveSession
	True when this end system is about to leave the session. More...
int	appInGate
int	profileInGate
int	rtcpInGate
int	udpInGate

Static Protected Attributes
static simsignal_t	rcvdPkSignal = registerSignal("rcvdPk")

Detailed Description

An RTP is the center of the RTP layer of an endsystem.

It creates the profile module, sends and receives RTP data packets and forwards messages. It also communicates with the application.

Member Function Documentation

void inet::rtp::RTP::connectRet ( )

protectedvirtual

Called when the socket layer has connected a socket.

Referenced by createSocket().

{
    initializeRTCP();
}

void inet::rtp::RTP::createProfile ( const char *  profileName )

protectedvirtual

Creates the profile module.

Referenced by enterSession().

{
    cModuleType *moduleType = cModuleType::find(profileName);
    if (moduleType == nullptr)
        throw cRuntimeError("Profile type `%s' not found", profileName);

    RTPProfile *profile = check_and_cast<RTPProfile *>(moduleType->create("Profile", this));
    profile->finalizeParameters();

    profile->setGateSize("payloadReceiverOut", 30);
    profile->setGateSize("payloadReceiverIn", 30);

    this->gate("profileOut")->connectTo(profile->gate("rtpIn"));
    profile->gate("rtpOut")->connectTo(this->gate("profileIn"));

    profile->callInitialize();
    profile->scheduleStart(simTime());
}

void inet::rtp::RTP::createSenderModule ( RTPCICreateSenderModule *  rifp )

protectedvirtual

Referenced by handleMessageFromApp().

{
    RTPInnerPacket *rinp = new RTPInnerPacket("createSenderModule()");
    EV_INFO << rifp->getSsrc() << endl;
    rinp->setCreateSenderModulePkt(rifp->getSsrc(), rifp->getPayloadType(), rifp->getFileName());
    send(rinp, "profileOut");

    delete rifp;
}

void inet::rtp::RTP::createSocket ( )

protectedvirtual

Requests a server socket from the UDP layer.

Referenced by profileInitialized().

{
    _udpSocket.bind(_port);
    MulticastGroupList mgl = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this)->collectMulticastGroups();
    _udpSocket.joinLocalMulticastGroups(mgl);    //TODO make it parameter-dependent
    connectRet();
}

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

protectedvirtual

Sends a RTP data packet to the UDP layer and a copy of it to the rtcp module.

Referenced by handleMessageFromProfile().

{
    RTPPacket *msg = check_and_cast<RTPPacket *>(rinp->getEncapsulatedPacket()->dup());

    _udpSocket.sendTo(msg, _destinationAddress, _port);

    // RTCP module must be informed about sent rtp data packet
    send(rinp, "rtcpOut");
}

void inet::rtp::RTP::deleteSenderModule ( RTPCIDeleteSenderModule *  rifp )

protectedvirtual

Referenced by handleMessageFromApp().

{
    RTPInnerPacket *rinp = new RTPInnerPacket("deleteSenderModule()");
    rinp->setDeleteSenderModulePkt(rifp->getSsrc());
    send(rinp, "profileOut");

    delete rifp;
}

void inet::rtp::RTP::enterSession ( RTPCIEnterSession *  rifp )

protectedvirtual

Creates the profile module and initializes it.

Referenced by handleMessageFromApp().

{
    const char *profileName = rifp->getProfileName();
    _commonName = rifp->getCommonName();
    _bandwidth = rifp->getBandwidth();
    _destinationAddress = rifp->getDestinationAddress();

    _port = rifp->getPort();
    if (_port & 1)
        _port--;

    _mtu = resolveMTU();

    createProfile(profileName);
    initializeProfile();
    delete rifp;
}

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

overrideprotectedvirtual

Handles incoming messages.

{
    if (msg->getArrivalGateId() == appInGate) {
        handleMessageFromApp(msg);
    }
    else if (msg->getArrivalGateId() == profileInGate) {
        handleMessageFromProfile(msg);
    }
    else if (msg->getArrivalGateId() == rtcpInGate) {
        handleMessageFromRTCP(msg);
    }
    else if (msg->getArrivalGateId() == udpInGate) {
        handleMessagefromUDP(msg);
    }
    else {
        throw cRuntimeError("Message from unknown gate");
    }
}

void inet::rtp::RTP::handleMessageFromApp ( cMessage *  msg )

protectedvirtual

Handles messages received from the applicaiton.

Referenced by handleMessage().

{
    RTPControlInfo *ci = check_and_cast<RTPControlInfo *>(msg->removeControlInfo());
    delete msg;

    switch (ci->getType()) {
        case RTP_IFP_ENTER_SESSION:
            enterSession(check_and_cast<RTPCIEnterSession *>(ci));
            break;

        case RTP_IFP_CREATE_SENDER_MODULE:
            createSenderModule(check_and_cast<RTPCICreateSenderModule *>(ci));
            break;

        case RTP_IFP_DELETE_SENDER_MODULE:
            deleteSenderModule(check_and_cast<RTPCIDeleteSenderModule *>(ci));
            break;

        case RTP_IFP_SENDER_CONTROL:
            senderModuleControl(check_and_cast<RTPCISenderControl *>(ci));
            break;

        case RTP_IFP_LEAVE_SESSION:
            leaveSession(check_and_cast<RTPCILeaveSession *>(ci));
            break;

        default:
            throw cRuntimeError("Unknown RTPControlInfo type from application");
    }
}

void inet::rtp::RTP::handleMessageFromProfile ( cMessage *  msg )

protectedvirtual

Handles messages received from the profile module.

Referenced by handleMessage().

{
    RTPInnerPacket *rinp = check_and_cast<RTPInnerPacket *>(msg);

    switch (rinp->getType()) {
        case RTP_INP_PROFILE_INITIALIZED:
            profileInitialized(rinp);
            break;

        case RTP_INP_SENDER_MODULE_CREATED:
            senderModuleCreated(rinp);
            break;

        case RTP_INP_SENDER_MODULE_DELETED:
            senderModuleDeleted(rinp);
            break;

        case RTP_INP_SENDER_MODULE_INITIALIZED:
            senderModuleInitialized(rinp);
            break;

        case RTP_INP_SENDER_MODULE_STATUS:
            senderModuleStatus(rinp);
            break;

        case RTP_INP_DATA_OUT:
            dataOut(rinp);
            break;

        default:
            throw cRuntimeError("Unknown RTPInnerPacket type %d from profile", rinp->getType());
    }
    EV_DEBUG << "handleMessageFromProfile(cMessage *msg) Exit" << endl;
}

void inet::rtp::RTP::handleMessageFromRTCP ( cMessage *  msg )

protectedvirtual

Handles messages received from the rtcp module.

Referenced by handleMessage().

{
    RTPInnerPacket *rinp = check_and_cast<RTPInnerPacket *>(msg);

    switch (rinp->getType()) {
        case RTP_INP_RTCP_INITIALIZED:
            rtcpInitialized(rinp);
            break;

        case RTP_INP_SESSION_LEFT:
            sessionLeft(rinp);
            break;

        default:
            throw cRuntimeError("Unknown RTPInnerPacket type %d from rtcp", rinp->getType());
    }
}

void inet::rtp::RTP::handleMessagefromUDP ( cMessage *  msg )

protectedvirtual

Handles messages received from the UDP layer.

Referenced by handleMessage().

{
    readRet(msg);
}

bool inet::rtp::RTP::handleOperationStage ( LifecycleOperation *  operation, int  stage, IDoneCallback *  doneCallback  )

overridevirtual

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::rtp::RTP::initialize ( int  stage )

overrideprotectedvirtual

Initializes variables.

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        _commonName = "";
        _leaveSession = false;
        appInGate = findGate("appIn");
        profileInGate = findGate("profileIn");
        rtcpInGate = findGate("rtcpIn");
        udpInGate = findGate("udpIn");
        _udpSocket.setOutputGate(gate("udpOut"));
    }
    else if (stage == INITSTAGE_TRANSPORT_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");
    }
}

void inet::rtp::RTP::initializeProfile ( )

protectedvirtual

Initializes the profile module.

Referenced by enterSession().

{
    RTPInnerPacket *rinp = new RTPInnerPacket("initializeProfile()");
    rinp->setInitializeProfilePkt(_mtu);
    send(rinp, "profileOut");
}

void inet::rtp::RTP::initializeRTCP ( )

protectedvirtual

Initializes the rtcp module-.

Referenced by connectRet().

{
    RTPInnerPacket *rinp = new RTPInnerPacket("initializeRTCP()");
    int rtcpPort = _port + 1;
    rinp->setInitializeRTCPPkt(_commonName.c_str(), _mtu, _bandwidth, _rtcpPercentage, _destinationAddress, rtcpPort);
    send(rinp, "rtcpOut");
}

void inet::rtp::RTP::leaveSession ( RTPCILeaveSession *  rifp )

protectedvirtual

Destroys the profile module and orders the rtcp module to send an rtcp bye packet.

Referenced by handleMessageFromApp().

{
    if (!_leaveSession) {
        _leaveSession = true;
        cModule *profileModule = gate("profileOut")->getNextGate()->getOwnerModule();
        profileModule->deleteModule();
        RTPInnerPacket *rinp = new RTPInnerPacket("leaveSession()");
        rinp->setLeaveSessionPkt();
        send(rinp, "rtcpOut");
    }
    delete rifp;
}

virtual int inet::rtp::RTP::numInitStages ( ) const

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::rtp::RTP::profileInitialized ( RTPInnerPacket *  rinp )

protectedvirtual

Called when the profile module is initialized.

Referenced by handleMessageFromProfile().

{
    _rtcpPercentage = rinp->getRtcpPercentage();
    if (_port == PORT_UNDEF) {
        _port = rinp->getPort();
        if (_port & 1)
            _port--;
    }

    delete rinp;

    createSocket();
}

void inet::rtp::RTP::readRet ( cMessage *  sifp )

protectedvirtual

Called when data from the socket layer has been received.

Referenced by handleMessagefromUDP().

{
    if (!_leaveSession) {
        RTPPacket *msg = check_and_cast<RTPPacket *>(sifp);

        emit(rcvdPkSignal, msg);

        msg->dump();
        RTPInnerPacket *rinp1 = new RTPInnerPacket("dataIn1()");
        rinp1->setDataInPkt(new RTPPacket(*msg), IPv4Address(_destinationAddress), _port);
        RTPInnerPacket *rinp2 = new RTPInnerPacket(*rinp1);
        send(rinp2, "rtcpOut");
        send(rinp1, "profileOut");
    }

    delete sifp;
}

int inet::rtp::RTP::resolveMTU ( )

protectedvirtual

Determines the maximum transmission unit that can be uses for RTP.

This implementation assumes that we use an ethernet with 1500 bytes mtu. The returned value is 1500 bytes minus header sizes for ip and udp.

Referenced by enterSession().

{
    // it returns MTU bytelength (ethernet) minus ip
    // and udp headers
    // TODO: How to do get the valid length of IP and ETHERNET header?
    IIPv4RoutingTable *rt = getModuleFromPar<IIPv4RoutingTable>(par("routingTableModule"), this);
    const InterfaceEntry *rtie = rt->getInterfaceForDestAddr(_destinationAddress);

    if (rtie == nullptr)
        throw cRuntimeError("No interface for remote address %s found!", _destinationAddress.str().c_str());

    int pmtu = rtie->getMTU();
    return pmtu - 20 - 8;
}

void inet::rtp::RTP::rtcpInitialized ( RTPInnerPacket *  rinp )

protectedvirtual

Informs the application that the session is entered.

Referenced by handleMessageFromRTCP().

{
    RTPCISessionEntered *ci = new RTPCISessionEntered();
    ci->setSsrc(rinp->getSsrc());
    cMessage *msg = new RTPControlMsg("sessionEntered()");
    msg->setControlInfo(ci);
    send(msg, "appOut");

    delete rinp;
}

void inet::rtp::RTP::senderModuleControl ( RTPCISenderControl *  rifp )

protectedvirtual

Referenced by handleMessageFromApp().

{
    RTPInnerPacket *rinp = new RTPInnerPacket("senderModuleControl()");
    RTPSenderControlMessage *scm = new RTPSenderControlMessage();
    scm->setCommand(rifp->getCommand());
    scm->setCommandParameter1(rifp->getCommandParameter1());
    scm->setCommandParameter2(rifp->getCommandParameter2());
    rinp->setSenderModuleControlPkt(rinp->getSsrc(), scm);
    send(rinp, "profileOut");

    delete rifp;
}

void inet::rtp::RTP::senderModuleCreated ( RTPInnerPacket *  rinp )

protectedvirtual

Referenced by handleMessageFromProfile().

{
    RTPCISenderModuleCreated *ci = new RTPCISenderModuleCreated();
    ci->setSsrc(rinp->getSsrc());
    cMessage *msg = new RTPControlMsg("senderModuleCreated()");
    msg->setControlInfo(ci);
    send(msg, "appOut");

    delete rinp;
}

void inet::rtp::RTP::senderModuleDeleted ( RTPInnerPacket *  rinp )

protectedvirtual

Referenced by handleMessageFromProfile().

{
    RTPCISenderModuleDeleted *ci = new RTPCISenderModuleDeleted();
    ci->setSsrc(rinp->getSsrc());
    cMessage *msg = new RTPControlMsg("senderModuleDeleted()");
    msg->setControlInfo(ci);
    send(msg, "appOut");
    // perhaps we should send a message to rtcp module
    delete rinp;
}

void inet::rtp::RTP::senderModuleInitialized ( RTPInnerPacket *  rinp )

protectedvirtual

Referenced by handleMessageFromProfile().

{
    send(rinp, "rtcpOut");
}

void inet::rtp::RTP::senderModuleStatus ( RTPInnerPacket *  rinp )

protectedvirtual

Referenced by handleMessageFromProfile().

{
    RTPSenderStatusMessage *ssm = (RTPSenderStatusMessage *)(rinp->decapsulate());
    RTPCISenderStatus *ci = new RTPCISenderStatus();
    ci->setSsrc(rinp->getSsrc());
    ci->setStatus(ssm->getStatus());
    ci->setTimeStamp(ssm->getTimeStamp());
    cMessage *msg = new RTPControlMsg("senderModuleStatus()");
    msg->setControlInfo(ci);
    send(msg, "appOut");
    delete ssm;
    delete rinp;
}

void inet::rtp::RTP::sessionLeft ( RTPInnerPacket *  rinp )

protectedvirtual

Informs the application that this end system has left the RTP session.

Referenced by handleMessageFromRTCP().

{
    RTPCISessionLeft *ci = new RTPCISessionLeft();
    cMessage *msg = new RTPControlMsg("sessionLeft()");
    msg->setControlInfo(ci);
    send(msg, "appOut");

    delete rinp;
}

void inet::rtp::RTP::socketRet ( )

protectedvirtual

Called when the socket layer returns a socket.

{
}

Member Data Documentation

int inet::rtp::RTP::_bandwidth

protected

The available bandwidth for this session.

Referenced by enterSession(), and initializeRTCP().

std::string inet::rtp::RTP::_commonName

protected

The CNAME of this end system.

Referenced by enterSession(), initialize(), and initializeRTCP().

IPv4Address inet::rtp::RTP::_destinationAddress

protected

The destination address.

Referenced by dataOut(), enterSession(), initializeRTCP(), readRet(), and resolveMTU().

bool inet::rtp::RTP::_leaveSession

protected

True when this end system is about to leave the session.

Referenced by initialize(), leaveSession(), and readRet().

int inet::rtp::RTP::_mtu

protected

The maximum size of a packet.

Referenced by enterSession(), initializeProfile(), and initializeRTCP().

int inet::rtp::RTP::_port

protected

The RTP port.

Referenced by createSocket(), dataOut(), enterSession(), initializeRTCP(), profileInitialized(), and readRet().

int inet::rtp::RTP::_rtcpPercentage

protected

The percentage of the bandwidth used for rtcp.

Referenced by initializeRTCP(), and profileInitialized().

UDPSocket inet::rtp::RTP::_udpSocket

protected

The UDP socket.

Referenced by createSocket(), dataOut(), and initialize().

int inet::rtp::RTP::appInGate

protected

Referenced by handleMessage(), and initialize().

int inet::rtp::RTP::profileInGate

protected

Referenced by handleMessage(), and initialize().

simsignal_t inet::rtp::RTP::rcvdPkSignal = registerSignal("rcvdPk")

staticprotected

Referenced by readRet().

int inet::rtp::RTP::rtcpInGate

protected

Referenced by handleMessage(), and initialize().

int inet::rtp::RTP::udpInGate

protected

Referenced by handleMessage(), and initialize().

---

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

• RTP.h
• RTP.cc