inet::rtp::RTCP Class Reference

The class RTCP is responsible for creating, receiving and processing of rtcp packets. More...

#include <RTCP.h>

Inheritance diagram for inet::rtp::RTCP:

Public Member Functions
	RTCP ()
virtual	~RTCP ()
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
	Message handling. More...
virtual void	handleMessageFromRTP (cMessage *msg)
	Handles messages from the RTP module. More...
virtual void	handleMessageFromUDP (cMessage *msg)
	Handles messages coming from the socket layer. More...
virtual void	handleSelfMessage (cMessage *msg)
	Handles self messages. More...
virtual void	handleInitializeRTCP (RTPInnerPacket *rinp)
	Initializes the rtcp module when the session is started. More...
virtual void	handleSenderModuleInitialized (RTPInnerPacket *rinp)
	Stores information about the new transmission. More...
virtual void	handleDataOut (RTPInnerPacket *packet)
	Stores information about an outgoing RTP data packet. More...
virtual void	handleDataIn (RTPInnerPacket *rinp)
	Stores information about an outgoing RTP data packet. More...
virtual void	handleLeaveSession (RTPInnerPacket *rinp)
	Makes the rtcp module send an RTCPByePacket in the next RTCPCompoundPacket to tell other participants in the RTP session that this end system leaves. More...
virtual void	connectRet ()
	Called when the socket layer has finished a connect. More...
virtual void	readRet (cPacket *sifpIn)
	Called when this rtcp module receives data from the socket layer. More...
virtual void	createSocket ()
	Request a server socket from the socket layer. More...
virtual void	chooseSSRC ()
	Chooses the ssrc identifier for this end system. More...
virtual void	scheduleInterval ()
	Calculates the length of the next rtcp interval an issues a self message to remind itself. More...
virtual void	createPacket ()
	Creates and sends an RTCPCompoundPacket. More...
virtual void	processOutgoingRTPPacket (RTPPacket *packet)
	Extracts information of a sent RTPPacket. More...
virtual void	processIncomingRTPPacket (RTPPacket *packet, IPv4Address address, int port)
	Extracts information of a received RTPPacket. More...
virtual void	processIncomingRTCPPacket (RTCPCompoundPacket *packet, IPv4Address address, int port)
	Extracts information of a received RTCPCompoundPacket. More...
void	processIncomingRTCPSenderReportPacket (RTCPSenderReportPacket *rtcpSenderReportPacket, IPv4Address address, int port)
void	processIncomingRTCPReceiverReportPacket (RTCPReceiverReportPacket *rtcpReceiverReportPacket, IPv4Address address, int port)
void	processIncomingRTCPSDESPacket (RTCPSDESPacket *rtcpSDESPacket, IPv4Address address, int port, simtime_t arrivalTime)
void	processIncomingRTCPByePacket (RTCPByePacket *rtcpByePacket, IPv4Address address, int port)
virtual RTPParticipantInfo *	findParticipantInfo (uint32 ssrc)
	Returns the RTPParticipantInfo object used for storing information about the RTP end system with this ssrc identifier. More...
virtual void	calculateAveragePacketSize (int size)
	Recalculates the average size of an RTCPCompoundPacket when one of this size has been sent or received. More...

Protected Attributes
int	_mtu = 0
	The maximum size an RTCPCompundPacket can have. More...
int	_bandwidth = 0
	The bandwidth for this RTP session. More...
int	_rtcpPercentage = 0
	The percentage of bandwidth for rtcp. More...
IPv4Address	_destinationAddress
	The destination address. More...
int	_port = -1
	The rtcp port. More...
bool	_ssrcChosen = false
	True when this end system has chosen its ssrc identifier. More...
bool	_leaveSession = false
	True when this end system is about to leave the session. More...
RTPSenderInfo *	_senderInfo = nullptr
	The RTPSenderInfo about this end system. More...
cArray	_participantInfos
	Information about all known RTP end system participating in this RTP session. More...
UDPSocket	_udpSocket
	The UDP socket for sending/receiving rtcp packets. More...
int	_packetsCalculated = 0
	The number of packets this rtcp module has calculated. More...
double	_averagePacketSize = 0
	The average size of an RTCPCompoundPacket. More...

Static Protected Attributes
static simsignal_t	rcvdPkSignal = registerSignal("rcvdPk")
	The output vector for statistical data about the behaviour of rtcp. More...

Detailed Description

The class RTCP is responsible for creating, receiving and processing of rtcp packets.

It also keeps track of this and other RTP end systems.

Constructor & Destructor Documentation

inet::rtp::RTCP::RTCP

(

)

{
}

inet::rtp::RTCP::~RTCP ( )

virtual

{
    if (!_ssrcChosen)
        delete _senderInfo;
}

Member Function Documentation

void inet::rtp::RTCP::calculateAveragePacketSize ( int  size )

protectedvirtual

Recalculates the average size of an RTCPCompoundPacket when one of this size has been sent or received.

Referenced by createPacket(), and processIncomingRTCPPacket().

{
    // add size of ip and udp header to given size before calculating
#if 1
    double sumPacketSize = (double)(_packetsCalculated) * _averagePacketSize + (double)(size + 20 + 8);
    _averagePacketSize = sumPacketSize / (double)(++_packetsCalculated);
#else // if 1
    _averagePacketSize += ((double)(size + 20 + 8) - _averagePacketSize) / (double)(++_packetsCalculated);
#endif // if 1
}

void inet::rtp::RTCP::chooseSSRC ( )

protectedvirtual

Chooses the ssrc identifier for this end system.

Referenced by handleSelfMessage().

{
    uint32 ssrc = 0;
    bool ssrcConflict = false;
    do {
        ssrc = intrand(0x7fffffff);
        ssrcConflict = findParticipantInfo(ssrc) != nullptr;
    } while (ssrcConflict);

    EV_INFO << "chooseSSRC" << ssrc;
    _senderInfo->setSsrc(ssrc);
    _participantInfos.add(_senderInfo);
    _ssrcChosen = true;
}

void inet::rtp::RTCP::connectRet ( )

protectedvirtual

Called when the socket layer has finished a connect.

Referenced by createSocket().

{
    // schedule first rtcp packet
    double intervalLength = 2.5 * (dblrand() + 0.5);
    cMessage *reminderMessage = new cMessage("Interval");
    scheduleAt(simTime() + intervalLength, reminderMessage);
}

void inet::rtp::RTCP::createPacket ( )

protectedvirtual

Creates and sends an RTCPCompoundPacket.

Referenced by handleSelfMessage().

{
    // first packet in an rtcp compound packet must
    // be a sender or receiver report
    RTCPReceiverReportPacket *reportPacket;

    // if this rtcp end system is a sender (see SenderInformation::isSender() for
    // details) insert a sender report
    if (_senderInfo->isSender()) {
        RTCPSenderReportPacket *senderReportPacket = new RTCPSenderReportPacket("SenderReportPacket");
        SenderReport *senderReport = _senderInfo->senderReport(simTime());
        senderReportPacket->setSenderReport(*senderReport);
        delete senderReport;
        reportPacket = senderReportPacket;
    }
    else {
        reportPacket = new RTCPReceiverReportPacket("ReceiverReportPacket");
    }
    reportPacket->setSsrc(_senderInfo->getSsrc());

    // insert receiver reports for packets from other sources
    for (int i = 0; i < _participantInfos.size(); i++) {
        if (_participantInfos.exist(i)) {
            RTPParticipantInfo *participantInfo = (RTPParticipantInfo *)(_participantInfos.get(i));
            if (participantInfo->getSsrc() != _senderInfo->getSsrc()) {
                ReceptionReport *report = ((RTPReceiverInfo *)participantInfo)->receptionReport(simTime());
                if (report != nullptr) {
                    reportPacket->addReceptionReport(report);
                }
            }
            participantInfo->nextInterval(simTime());

            if (participantInfo->toBeDeleted(simTime())) {
                _participantInfos.remove(participantInfo);
                delete participantInfo;
                // perhaps inform the profile
            }
        }
    }

    // insert source description items (at least common name)
    RTCPSDESPacket *sdesPacket = new RTCPSDESPacket("SDESPacket");

    SDESChunk *chunk = _senderInfo->getSDESChunk();
    sdesPacket->addSDESChunk(chunk);

    RTCPCompoundPacket *compoundPacket = new RTCPCompoundPacket("RTCPCompoundPacket");

    compoundPacket->addRTCPPacket(reportPacket);
    compoundPacket->addRTCPPacket(sdesPacket);

    // create rtcp app/bye packets if needed
    if (_leaveSession) {
        RTCPByePacket *byePacket = new RTCPByePacket("ByePacket");
        byePacket->setSsrc(_senderInfo->getSsrc());
        compoundPacket->addRTCPPacket(byePacket);
    }

    calculateAveragePacketSize(compoundPacket->getByteLength());

    cPacket *msg = new cPacket("RTCPCompoundPacket");
    msg->encapsulate(compoundPacket);
    _udpSocket.sendTo(msg, _destinationAddress, _port);

    if (_leaveSession) {
        RTPInnerPacket *rinp = new RTPInnerPacket("sessionLeft()");
        rinp->setSessionLeftPkt();
        send(rinp, "rtpOut");
    }
}

void inet::rtp::RTCP::createSocket ( )

protectedvirtual

Request a server socket from the socket layer.

Referenced by handleInitializeRTCP().

{
    _udpSocket.bind(_port);    //XXX this will fail if this function is invoked multiple times; not sure that may (or is expected to) happen
    MulticastGroupList mgl = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this)->collectMulticastGroups();
    _udpSocket.joinLocalMulticastGroups(mgl);    //TODO make it parameter-dependent
    connectRet();
}

RTPParticipantInfo * inet::rtp::RTCP::findParticipantInfo ( uint32  ssrc )

protectedvirtual

Returns the RTPParticipantInfo object used for storing information about the RTP end system with this ssrc identifier.

Returns nullptr if this end system is unknown.

Referenced by chooseSSRC(), processIncomingRTCPByePacket(), processIncomingRTCPReceiverReportPacket(), processIncomingRTCPSDESPacket(), processIncomingRTCPSenderReportPacket(), and processIncomingRTPPacket().

{
    std::string ssrcString = RTPParticipantInfo::ssrcToName(ssrc);
    return (RTPParticipantInfo *)(_participantInfos.get(ssrcString.c_str()));
}

void inet::rtp::RTCP::handleDataIn ( RTPInnerPacket *  rinp )

protectedvirtual

Stores information about an outgoing RTP data packet.

Referenced by handleMessageFromRTP().

{
    RTPPacket *rtpPacket = check_and_cast<RTPPacket *>(rinp->decapsulate());
    //rtpPacket->dump();
    processIncomingRTPPacket(rtpPacket, rinp->getAddress(), rinp->getPort());
}

void inet::rtp::RTCP::handleDataOut ( RTPInnerPacket *  packet )

protectedvirtual

Stores information about an outgoing RTP data packet.

Referenced by handleMessageFromRTP().

{
    RTPPacket *rtpPacket = check_and_cast<RTPPacket *>(packet->decapsulate());
    processOutgoingRTPPacket(rtpPacket);
}

void inet::rtp::RTCP::handleInitializeRTCP ( RTPInnerPacket *  rinp )

protectedvirtual

Initializes the rtcp module when the session is started.

Referenced by handleMessageFromRTP().

{
    _mtu = rinp->getMTU();
    _bandwidth = rinp->getBandwidth();
    _rtcpPercentage = rinp->getRtcpPercentage();
    _destinationAddress = rinp->getAddress();
    _port = rinp->getPort();

    _senderInfo = new RTPSenderInfo();

    SDESItem *sdesItem = new SDESItem(SDESItem::SDES_CNAME, rinp->getCommonName());
    _senderInfo->addSDESItem(sdesItem);

    // create server socket for receiving rtcp packets
    createSocket();
}

void inet::rtp::RTCP::handleLeaveSession ( RTPInnerPacket *  rinp )

protectedvirtual

Makes the rtcp module send an RTCPByePacket in the next RTCPCompoundPacket to tell other participants in the RTP session that this end system leaves.

Referenced by handleMessageFromRTP().

{
    _leaveSession = true;
}

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

overrideprotectedvirtual

Message handling.

Dispatches messages by arrival gate.

{
    // first distinguish incoming messages by arrival gate
    if (msg->isSelfMessage()) {
        handleSelfMessage(msg);
    }
    else if (msg->getArrivalGateId() == findGate("rtpIn")) {
        handleMessageFromRTP(msg);
    }
    else if (msg->getArrivalGateId() == findGate("udpIn")) {
        handleMessageFromUDP(msg);
    }
    else {
        throw cRuntimeError("Message from unknown gate");
    }

    delete msg;
}

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

protectedvirtual

Handles messages from the RTP module.

Referenced by handleMessage().

{
    // from the rtp module all messages are of type RTPInnerPacket
    RTPInnerPacket *rinp = check_and_cast<RTPInnerPacket *>(msg);

    // distinguish by type
    switch (rinp->getType()) {
        case RTP_INP_INITIALIZE_RTCP:
            handleInitializeRTCP(rinp);
            break;

        case RTP_INP_SENDER_MODULE_INITIALIZED:
            handleSenderModuleInitialized(rinp);
            break;

        case RTP_INP_DATA_OUT:
            handleDataOut(rinp);
            break;

        case RTP_INP_DATA_IN:
            handleDataIn(rinp);
            break;

        case RTP_INP_LEAVE_SESSION:
            handleLeaveSession(rinp);
            break;

        default:
            throw cRuntimeError("Unknown RTPInnerPacket type");
    }
}

void inet::rtp::RTCP::handleMessageFromUDP ( cMessage *  msg )

protectedvirtual

Handles messages coming from the socket layer.

Referenced by handleMessage().

{
    // from SocketLayer all message are of type cMessage
    readRet(PK(msg));
}

bool inet::rtp::RTCP::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::RTCP::handleSelfMessage ( cMessage *  msg )

protectedvirtual

Handles self messages.

Referenced by handleMessage().

{
    // it's time to create an rtcp packet
    if (!_ssrcChosen) {
        chooseSSRC();
        RTPInnerPacket *rinp1 = new RTPInnerPacket("rtcpInitialized()");
        rinp1->setRtcpInitializedPkt(_senderInfo->getSsrc());
        send(rinp1, "rtpOut");
    }

    createPacket();

    if (!_leaveSession) {
        scheduleInterval();
    }
}

void inet::rtp::RTCP::handleSenderModuleInitialized ( RTPInnerPacket *  rinp )

protectedvirtual

Stores information about the new transmission.

Referenced by handleMessageFromRTP().

{
    _senderInfo->setStartTime(simTime());
    _senderInfo->setClockRate(rinp->getClockRate());
    _senderInfo->setTimeStampBase(rinp->getTimeStampBase());
    _senderInfo->setSequenceNumberBase(rinp->getSequenceNumberBase());
}

void inet::rtp::RTCP::initialize ( int  stage )

overrideprotectedvirtual

Initializes variables.

{
    cSimpleModule::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        // initialize variables
        _ssrcChosen = false;
        _leaveSession = false;
        _udpSocket.setOutputGate(gate("udpOut"));

        _packetsCalculated = 0;
        _averagePacketSize = 0.0;

        _participantInfos.setName("ParticipantInfos");
    }
    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");
    }
}

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

void inet::rtp::RTCP::processIncomingRTCPByePacket ( RTCPByePacket *  rtcpByePacket, IPv4Address  address, int  port  )

protected

Referenced by processIncomingRTCPPacket().

{
    uint32 ssrc = rtcpByePacket->getSsrc();
    RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc);

    if (participantInfo != nullptr && participantInfo != _senderInfo) {
        _participantInfos.remove(participantInfo);

        delete participantInfo;
        // perhaps it would be useful to inform
        // the profile to remove the corresponding
        // receiver module
    }
}

void inet::rtp::RTCP::processIncomingRTCPPacket ( RTCPCompoundPacket *  packet, IPv4Address  address, int  port  )

protectedvirtual

Extracts information of a received RTCPCompoundPacket.

Referenced by readRet().

{
    calculateAveragePacketSize(packet->getByteLength());
    cArray& rtcpPackets = packet->getRtcpPackets();
    simtime_t arrivalTime = packet->getArrivalTime();

    for (int i = 0; i < rtcpPackets.size(); i++) {
        RTCPPacket *rtcpPacket = (RTCPPacket *)(rtcpPackets.remove(i));
        if (rtcpPacket) {
            // remove the rtcp packet from the rtcp compound packet
            switch (rtcpPacket->getPacketType()) {
                case RTCP_PT_SR:
                    processIncomingRTCPSenderReportPacket(
                        (RTCPSenderReportPacket *)rtcpPacket, address, port);
                    break;

                case RTCP_PT_RR:
                    processIncomingRTCPReceiverReportPacket(
                        (RTCPReceiverReportPacket *)rtcpPacket, address, port);
                    break;

                case RTCP_PT_SDES:
                    processIncomingRTCPSDESPacket(
                        (RTCPSDESPacket *)rtcpPacket, address, port, arrivalTime);
                    break;

                case RTCP_PT_BYE:
                    processIncomingRTCPByePacket(
                        (RTCPByePacket *)rtcpPacket, address, port);
                    break;

                default:
                    // app rtcp packets
                    break;
            }
            delete rtcpPacket;
        }
    }
    delete packet;
}

void inet::rtp::RTCP::processIncomingRTCPReceiverReportPacket ( RTCPReceiverReportPacket *  rtcpReceiverReportPacket, IPv4Address  address, int  port  )

protected

Referenced by processIncomingRTCPPacket().

{
    uint32 ssrc = rtcpReceiverReportPacket->getSsrc();
    RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc);
    if (participantInfo == nullptr) {
        participantInfo = new RTPReceiverInfo(ssrc);
        participantInfo->setAddress(address);
        participantInfo->setRTCPPort(port);
        _participantInfos.add(participantInfo);
    }
    else {
        if ((participantInfo->getAddress() == address) &&
            (participantInfo->getRTCPPort() == PORT_UNDEF))
        {
            participantInfo->setRTCPPort(port);
        }
        else {
            // check for ssrc conflict
        }
    }

    cArray& receptionReports = rtcpReceiverReportPacket->getReceptionReports();
    for (int j = 0; j < receptionReports.size(); j++) {
        if (receptionReports.exist(j)) {
            ReceptionReport *receptionReport = (ReceptionReport *)(receptionReports.remove(j));
            if (_senderInfo && (receptionReport->getSsrc() == _senderInfo->getSsrc())) {
                _senderInfo->processReceptionReport(receptionReport, simTime());
            }
            else
                //cancelAndDelete(receptionReport);
                delete receptionReport;
        }
    }
}

void inet::rtp::RTCP::processIncomingRTCPSDESPacket ( RTCPSDESPacket *  rtcpSDESPacket, IPv4Address  address, int  port, simtime_t  arrivalTime  )

protected

Referenced by processIncomingRTCPPacket().

{
    cArray& sdesChunks = rtcpSDESPacket->getSdesChunks();

    for (int j = 0; j < sdesChunks.size(); j++) {
        if (sdesChunks.exist(j)) {
            // remove the sdes chunk from the cArray of sdes chunks
            SDESChunk *sdesChunk = (SDESChunk *)(sdesChunks.remove(j));
            // this is needed to avoid seg faults
            //sdesChunk->setOwner(this);
            uint32 ssrc = sdesChunk->getSsrc();
            RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc);
            if (participantInfo == nullptr) {
                participantInfo = new RTPReceiverInfo(ssrc);
                participantInfo->setAddress(address);
                participantInfo->setRTCPPort(port);
                _participantInfos.add(participantInfo);
            }
            else {
                // check for ssrc conflict
            }
            participantInfo->processSDESChunk(sdesChunk, arrivalTime);
        }
    }
}

void inet::rtp::RTCP::processIncomingRTCPSenderReportPacket ( RTCPSenderReportPacket *  rtcpSenderReportPacket, IPv4Address  address, int  port  )

protected

Referenced by processIncomingRTCPPacket().

{
    uint32 ssrc = rtcpSenderReportPacket->getSsrc();
    RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc);

    if (participantInfo == nullptr) {
        participantInfo = new RTPReceiverInfo(ssrc);
        participantInfo->setAddress(address);
        participantInfo->setRTCPPort(port);
        _participantInfos.add(participantInfo);
    }
    else {
        if ((participantInfo->getAddress() == address) &&
            (participantInfo->getRTCPPort() == PORT_UNDEF))
        {
            participantInfo->setRTCPPort(port);
        }
        else {
            // check for ssrc conflict
        }
    }
    participantInfo->processSenderReport(rtcpSenderReportPacket->getSenderReport(), simTime());

    cArray& receptionReports = rtcpSenderReportPacket->getReceptionReports();
    for (int j = 0; j < receptionReports.size(); j++) {
        if (receptionReports.exist(j)) {
            ReceptionReport *receptionReport = (ReceptionReport *)(receptionReports.remove(j));
            if (_senderInfo && (receptionReport->getSsrc() == _senderInfo->getSsrc())) {
                _senderInfo->processReceptionReport(receptionReport, simTime());
            }
            else
                //cancelAndDelete(receptionReport);
                delete receptionReport;
        }
    }
}

void inet::rtp::RTCP::processIncomingRTPPacket ( RTPPacket *  packet, IPv4Address  address, int  port  )

protectedvirtual

Extracts information of a received RTPPacket.

Referenced by handleDataIn().

{
    bool good = false;
    uint32 ssrc = packet->getSsrc();
    RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc);
    if (participantInfo == nullptr) {
        participantInfo = new RTPParticipantInfo(ssrc);
        participantInfo->setAddress(address);
        participantInfo->setRTPPort(port);
        _participantInfos.add(participantInfo);
        good = true;
    }
    else {
        // check for ssrc conflict
        if (participantInfo->getAddress() == address) {
            if (participantInfo->getRTPPort() == port) {
                good = true;
            }
            else if (participantInfo->getRTPPort() == PORT_UNDEF) {
                participantInfo->setRTPPort(port);
                good = true;
            }
        }
    }
    if (good) {
        participantInfo->processRTPPacket(packet, getId(), packet->getArrivalTime());
    }
    else {
        EV_INFO << "Incoming packet address/port conflict, packet dropped.\n";
        delete packet;
    }
}

void inet::rtp::RTCP::processOutgoingRTPPacket ( RTPPacket *  packet )

protectedvirtual

Extracts information of a sent RTPPacket.

Referenced by handleDataOut().

{
    _senderInfo->processRTPPacket(packet, getId(), simTime());
}

void inet::rtp::RTCP::readRet ( cPacket *  sifpIn )

protectedvirtual

Called when this rtcp module receives data from the socket layer.

Referenced by handleMessageFromUDP().

{
    emit(rcvdPkSignal, sifpIn);
    RTCPCompoundPacket *packet = check_and_cast<RTCPCompoundPacket *>(sifpIn->decapsulate());
    processIncomingRTCPPacket(packet, IPv4Address(_destinationAddress), _port);
}

void inet::rtp::RTCP::scheduleInterval ( )

protectedvirtual

Calculates the length of the next rtcp interval an issues a self message to remind itself.

Referenced by handleSelfMessage().

{
    simtime_t intervalLength = _averagePacketSize * (simtime_t)(_participantInfos.size())
        / (simtime_t)(_bandwidth * _rtcpPercentage * (_senderInfo->isSender() ? 1.0 : 0.75) / 100.0);

    // interval length must be at least 5 seconds
    if (intervalLength < 5.0)
        intervalLength = 5.0;

    // to avoid rtcp packet bursts multiply calculated interval length
    // with a random number between 0.5 and 1.5
    intervalLength = intervalLength * (0.5 + dblrand());

    intervalLength /= (double)(2.71828 - 1.5);    // [RFC 3550] , by Ahmed ayadi

    cMessage *reminderMessage = new cMessage("Interval");
    scheduleAt(simTime() + intervalLength, reminderMessage);
}

Member Data Documentation

double inet::rtp::RTCP::_averagePacketSize = 0

protected

The average size of an RTCPCompoundPacket.

Referenced by calculateAveragePacketSize(), initialize(), and scheduleInterval().

int inet::rtp::RTCP::_bandwidth = 0

protected

The bandwidth for this RTP session.

Referenced by handleInitializeRTCP(), and scheduleInterval().

IPv4Address inet::rtp::RTCP::_destinationAddress

protected

The destination address.

Referenced by createPacket(), handleInitializeRTCP(), and readRet().

bool inet::rtp::RTCP::_leaveSession = false

protected

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

Referenced by createPacket(), handleLeaveSession(), handleSelfMessage(), and initialize().

int inet::rtp::RTCP::_mtu = 0

protected

The maximum size an RTCPCompundPacket can have.

Referenced by handleInitializeRTCP().

int inet::rtp::RTCP::_packetsCalculated = 0

protected

The number of packets this rtcp module has calculated.

Referenced by calculateAveragePacketSize(), and initialize().

cArray inet::rtp::RTCP::_participantInfos

protected

Information about all known RTP end system participating in this RTP session.

Referenced by chooseSSRC(), createPacket(), findParticipantInfo(), initialize(), processIncomingRTCPByePacket(), processIncomingRTCPReceiverReportPacket(), processIncomingRTCPSDESPacket(), processIncomingRTCPSenderReportPacket(), processIncomingRTPPacket(), and scheduleInterval().

int inet::rtp::RTCP::_port = -1

protected

The rtcp port.

Referenced by createPacket(), createSocket(), handleInitializeRTCP(), and readRet().

int inet::rtp::RTCP::_rtcpPercentage = 0

protected

The percentage of bandwidth for rtcp.

Referenced by handleInitializeRTCP(), and scheduleInterval().

RTPSenderInfo* inet::rtp::RTCP::_senderInfo = nullptr

protected

The RTPSenderInfo about this end system.

Referenced by chooseSSRC(), createPacket(), handleInitializeRTCP(), handleSelfMessage(), handleSenderModuleInitialized(), processIncomingRTCPByePacket(), processIncomingRTCPReceiverReportPacket(), processIncomingRTCPSenderReportPacket(), processOutgoingRTPPacket(), scheduleInterval(), and ~RTCP().

bool inet::rtp::RTCP::_ssrcChosen = false

protected

True when this end system has chosen its ssrc identifier.

Referenced by chooseSSRC(), handleSelfMessage(), initialize(), and ~RTCP().

UDPSocket inet::rtp::RTCP::_udpSocket

protected

The UDP socket for sending/receiving rtcp packets.

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

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

staticprotected

The output vector for statistical data about the behaviour of rtcp.

Every participant's rtcp module writes its calculated rtcp interval (without variation

Referenced by readRet().

---

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

• RTCP.h
• RTCP.cc