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:

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

Additional Inherited Members
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 ()

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

connectRet()

void inet::rtp::Rtp::connectRet ( )

protectedvirtual

Called when the socket layer has connected a socket.

{
    initializeRTCP();
}

Referenced by createSocket().

createProfile()

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

protectedvirtual

Creates the profile module.

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

Referenced by enterSession().

createSenderModule()

void inet::rtp::Rtp::createSenderModule ( RtpCiCreateSenderModule *  rifp )

protectedvirtual

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

Referenced by handleMessageFromApp().

createSocket()

void inet::rtp::Rtp::createSocket ( )

protectedvirtual

Requests a server socket from the UDP layer.

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

Referenced by profileInitialized().

dataOut()

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.

{
    Packet *packet = check_and_cast<Packet *>(rinp->getEncapsulatedPacket()->dup());
//    RtpPacket *msg = check_and_cast<RtpPacket *>(rinp->getEncapsulatedPacket()->dup());      //FIXME kell itt az RtpPacket?
 
    _udpSocket.sendTo(packet, _destinationAddress, _port);
 
    // Rtcp module must be informed about sent rtp data packet
    send(rinp, "rtcpOut");
}

Referenced by handleMessageFromProfile().

deleteSenderModule()

void inet::rtp::Rtp::deleteSenderModule ( RtpCiDeleteSenderModule *  rifp )

protectedvirtual

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

Referenced by handleMessageFromApp().

enterSession()

void inet::rtp::Rtp::enterSession ( RtpCiEnterSession *  rifp )

protectedvirtual

Creates the profile module and initializes it.

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

Referenced by handleMessageFromApp().

handleMessage()

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

handleMessageFromApp()

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

protectedvirtual

Handles messages received from the applicaiton.

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

Referenced by handleMessage().

handleMessageFromProfile()

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

protectedvirtual

Handles messages received from the profile module.

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

Referenced by handleMessage().

handleMessageFromRTCP()

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

protectedvirtual

Handles messages received from the rtcp module.

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

Referenced by handleMessage().

handleMessagefromUDP()

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

protectedvirtual

Handles messages received from the UDP layer.

{
    readRet(msg);
}

Referenced by handleMessage().

initialize()

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

initializeProfile()

void inet::rtp::Rtp::initializeProfile ( )

protectedvirtual

Initializes the profile module.

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

Referenced by enterSession().

initializeRTCP()

void inet::rtp::Rtp::initializeRTCP ( )

protectedvirtual

Initializes the rtcp module-.

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

Referenced by connectRet().

leaveSession()

void inet::rtp::Rtp::leaveSession ( RtpCiLeaveSession *  rifp )

protectedvirtual

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

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

Referenced by handleMessageFromApp().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

profileInitialized()

void inet::rtp::Rtp::profileInitialized ( RtpInnerPacket *  rinp )

protectedvirtual

Called when the profile module is initialized.

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

Referenced by handleMessageFromProfile().

readRet()

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

protectedvirtual

Called when data from the socket layer has been received.

{
    if (!_leaveSession) {
        Packet *pk = check_and_cast<Packet *>(sifp);
        const auto& rtpHeader = pk->peekAtFront<RtpHeader>();
 
        emit(packetReceivedSignal, pk);
 
        rtpHeader->dump();
        RtpInnerPacket *rinp1 = new RtpInnerPacket("dataIn1()");
        rinp1->setDataInPkt(pk->dup(), Ipv4Address(_destinationAddress), _port);
        RtpInnerPacket *rinp2 = new RtpInnerPacket(*rinp1);
        send(rinp2, "rtcpOut");
        send(rinp1, "profileOut");
    }
 
    delete sifp;
}

Referenced by handleMessagefromUDP().

resolveMTU()

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.

{
    // 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 NetworkInterface *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;
}

Referenced by enterSession().

rtcpInitialized()

void inet::rtp::Rtp::rtcpInitialized ( RtpInnerPacket *  rinp )

protectedvirtual

Informs the application that the session is entered.

{
    RtpCiSessionEntered *ci = new RtpCiSessionEntered();
    ci->setSsrc(rinp->getSsrc());
    cMessage *msg = new RtpControlMsg("sessionEntered()");
    msg->setControlInfo(ci);
    send(msg, "appOut");
 
    delete rinp;
}

Referenced by handleMessageFromRTCP().

senderModuleControl()

void inet::rtp::Rtp::senderModuleControl ( RtpCiSenderControl *  rifp )

protectedvirtual

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

Referenced by handleMessageFromApp().

senderModuleCreated()

void inet::rtp::Rtp::senderModuleCreated ( RtpInnerPacket *  rinp )

protectedvirtual

{
    RtpCiSenderModuleCreated *ci = new RtpCiSenderModuleCreated();
    ci->setSsrc(rinp->getSsrc());
    cMessage *msg = new RtpControlMsg("senderModuleCreated()");
    msg->setControlInfo(ci);
    send(msg, "appOut");
 
    delete rinp;
}

Referenced by handleMessageFromProfile().

senderModuleDeleted()

void inet::rtp::Rtp::senderModuleDeleted ( RtpInnerPacket *  rinp )

protectedvirtual

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

Referenced by handleMessageFromProfile().

senderModuleInitialized()

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

protectedvirtual

{
    send(rinp, "rtcpOut");
}

Referenced by handleMessageFromProfile().

senderModuleStatus()

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

protectedvirtual

{
    RtpSenderStatusMessage *ssm = check_and_cast<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;
}

Referenced by handleMessageFromProfile().

sessionLeft()

void inet::rtp::Rtp::sessionLeft ( RtpInnerPacket *  rinp )

protectedvirtual

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

{
    RtpCiSessionLeft *ci = new RtpCiSessionLeft();
    cMessage *msg = new RtpControlMsg("sessionLeft()");
    msg->setControlInfo(ci);
    send(msg, "appOut");
 
    delete rinp;
}

Referenced by handleMessageFromRTCP().

socketRet()

void inet::rtp::Rtp::socketRet ( )

protectedvirtual

Called when the socket layer returns a socket.

{
}

Member Data Documentation

_bandwidth

int inet::rtp::Rtp::_bandwidth

protected

The available bandwidth for this session.

Referenced by enterSession(), and initializeRTCP().

_commonName

std::string inet::rtp::Rtp::_commonName

protected

The CNAME of this end system.

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

_destinationAddress

Ipv4Address inet::rtp::Rtp::_destinationAddress

protected

The destination address.

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

_leaveSession

bool inet::rtp::Rtp::_leaveSession

protected

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

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

_mtu

int inet::rtp::Rtp::_mtu

protected

The maximum size of a packet.

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

_port

int inet::rtp::Rtp::_port

protected

The RTP port.

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

_rtcpPercentage

int inet::rtp::Rtp::_rtcpPercentage

protected

The percentage of the bandwidth used for rtcp.

Referenced by initializeRTCP(), and profileInitialized().

_udpSocket

UdpSocket inet::rtp::Rtp::_udpSocket

protected

The UDP socket.

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

appInGate

int inet::rtp::Rtp::appInGate

protected

Referenced by handleMessage(), and initialize().

profileInGate

int inet::rtp::Rtp::profileInGate

protected

Referenced by handleMessage(), and initialize().

rtcpInGate

int inet::rtp::Rtp::rtcpInGate

protected

Referenced by handleMessage(), and initialize().

udpInGate

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