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

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 (Packet *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 (Packet *packet)
	Extracts information of a sent RtpPacket. More...
virtual void	processIncomingRTPPacket (Packet *packet, Ipv4Address address, int port)
	Extracts information of a received RtpPacket. More...
virtual void	processIncomingRTCPPacket (Packet *packet, Ipv4Address address, int port)
	Extracts information of a received RtcpCompoundPacket. More...
void	processIncomingRTCPSenderReportPacket (const Ptr< const RtcpSenderReportPacket > &rtcpSenderReportPacket, Ipv4Address address, int port)
void	processIncomingRTCPReceiverReportPacket (const Ptr< const RtcpReceiverReportPacket > &rtcpReceiverReportPacket, Ipv4Address address, int port)
void	processIncomingRTCPSDESPacket (const Ptr< const RtcpSdesPacket > &rtcpSDESPacket, Ipv4Address address, int port, simtime_t arrivalTime)
void	processIncomingRTCPByePacket (const Ptr< const RtcpByePacket > &rtcpByePacket, Ipv4Address address, int port)
virtual RtpParticipantInfo *	findParticipantInfo (uint32_t 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...

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

Rtcp()

inet::rtp::Rtcp::Rtcp

(

)

{
}

~Rtcp()

inet::rtp::Rtcp::~Rtcp ( )

virtual

{
    if (!_ssrcChosen)
        delete _senderInfo;
}

Member Function Documentation

calculateAveragePacketSize()

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.

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

Referenced by createPacket(), and processIncomingRTCPPacket().

chooseSSRC()

void inet::rtp::Rtcp::chooseSSRC ( )

protectedvirtual

Chooses the ssrc identifier for this end system.

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

Referenced by handleSelfMessage().

connectRet()

void inet::rtp::Rtcp::connectRet ( )

protectedvirtual

Called when the socket layer has finished a connect.

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

Referenced by createSocket().

createPacket()

void inet::rtp::Rtcp::createPacket ( )

protectedvirtual

Creates and sends an RtcpCompoundPacket.

{
    // first packet in an rtcp compound packet must
    // be a sender or receiver report
    Ptr<RtcpReceiverReportPacket> reportPacket = nullptr;
 
    // if this rtcp end system is a sender (see SenderInformation::isSender() for
    // details) insert a sender report
    if (_senderInfo->isSender()) {
        const auto& senderReportPacket = makeShared<RtcpSenderReportPacket>();
        SenderReport *senderReport = _senderInfo->senderReport(simTime());
        senderReportPacket->setSenderReport(*senderReport);
        delete senderReport;
        reportPacket = senderReportPacket;
    }
    else {
        reportPacket = makeShared<RtcpReceiverReportPacket>();
    }
    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 = check_and_cast<RtpParticipantInfo *>(_participantInfos.get(i));
            if (participantInfo->getSsrc() != _senderInfo->getSsrc()) {
                ReceptionReport *report = check_and_cast<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
            }
        }
    }
    reportPacket->paddingAndSetLength();
 
    // insert source description items (at least common name)
    const auto& sdesPacket = makeShared<RtcpSdesPacket>();
 
    SdesChunk *chunk = _senderInfo->getSDESChunk();
    sdesPacket->addSDESChunk(chunk);
    sdesPacket->paddingAndSetLength();
 
    Packet *compoundPacket = new Packet("RtcpCompoundPacket");
 
    compoundPacket->insertAtBack(reportPacket);
    compoundPacket->insertAtBack(sdesPacket);
 
    // create rtcp app/bye packets if needed
    if (_leaveSession) {
        const auto& byePacket = makeShared<RtcpByePacket>();
        byePacket->setSsrc(_senderInfo->getSsrc());
        byePacket->paddingAndSetLength();
        compoundPacket->insertAtBack(byePacket);
    }
 
    calculateAveragePacketSize(compoundPacket->getByteLength());
 
    _udpSocket.sendTo(compoundPacket, _destinationAddress, _port);
 
    if (_leaveSession) {
        RtpInnerPacket *rinp = new RtpInnerPacket("sessionLeft()");
        rinp->setSessionLeftPkt();
        send(rinp, "rtpOut");
    }
}

Referenced by handleSelfMessage().

createSocket()

void inet::rtp::Rtcp::createSocket ( )

protectedvirtual

Request a server socket from the socket layer.

{
    _udpSocket.bind(_port); // TODO 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();
}

Referenced by handleInitializeRTCP().

findParticipantInfo()

RtpParticipantInfo * inet::rtp::Rtcp::findParticipantInfo ( uint32_t  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.

{
    std::string ssrcString = RtpParticipantInfo::ssrcToName(ssrc);
    return check_and_cast_nullable<RtpParticipantInfo *>(_participantInfos.get(ssrcString.c_str()));
}

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

handleDataIn()

void inet::rtp::Rtcp::handleDataIn ( RtpInnerPacket *  rinp )

protectedvirtual

Stores information about an outgoing Rtp data packet.

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

Referenced by handleMessageFromRTP().

handleDataOut()

void inet::rtp::Rtcp::handleDataOut ( RtpInnerPacket *  packet )

protectedvirtual

Stores information about an outgoing Rtp data packet.

{
    Packet *packet = check_and_cast<Packet *>(innerPacket->decapsulate());
    processOutgoingRTPPacket(packet);
}

Referenced by handleMessageFromRTP().

handleInitializeRTCP()

void inet::rtp::Rtcp::handleInitializeRTCP ( RtpInnerPacket *  rinp )

protectedvirtual

Initializes the rtcp module when the session is started.

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

Referenced by handleMessageFromRTP().

handleLeaveSession()

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.

{
    _leaveSession = true;
}

Referenced by handleMessageFromRTP().

handleMessage()

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

handleMessageFromRTP()

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

protectedvirtual

Handles messages from the Rtp module.

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

Referenced by handleMessage().

handleMessageFromUDP()

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

protectedvirtual

Handles messages coming from the socket layer.

{
    // from SocketLayer all message are of type cMessage
    readRet(check_and_cast<Packet *>(msg));
}

Referenced by handleMessage().

handleSelfMessage()

void inet::rtp::Rtcp::handleSelfMessage ( cMessage *  msg )

protectedvirtual

Handles self messages.

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

Referenced by handleMessage().

handleSenderModuleInitialized()

void inet::rtp::Rtcp::handleSenderModuleInitialized ( RtpInnerPacket *  rinp )

protectedvirtual

Stores information about the new transmission.

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

Referenced by handleMessageFromRTP().

initialize()

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

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processIncomingRTCPByePacket()

void inet::rtp::Rtcp::processIncomingRTCPByePacket ( const Ptr< const RtcpByePacket > &  rtcpByePacket, Ipv4Address  address, int  port  )

protected

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

Referenced by processIncomingRTCPPacket().

processIncomingRTCPPacket()

void inet::rtp::Rtcp::processIncomingRTCPPacket ( Packet *  packet, Ipv4Address  address, int  port  )

protectedvirtual

Extracts information of a received RtcpCompoundPacket.

{
    calculateAveragePacketSize(packet->getByteLength());
    simtime_t arrivalTime = packet->getArrivalTime();
 
    for (int i = 0; packet->getByteLength() > 0; i++) {
        // remove the rtcp packet from the rtcp compound packet
        const auto& rtcpPacket = packet->popAtFront<RtcpPacket>();
        if (rtcpPacket) {
            switch (rtcpPacket->getPacketType()) {
                case RTCP_PT_SR:
                    processIncomingRTCPSenderReportPacket(CHK(dynamicPtrCast<const RtcpSenderReportPacket>(rtcpPacket)), address, port);
                    break;
 
                case RTCP_PT_RR:
                    processIncomingRTCPReceiverReportPacket(CHK(dynamicPtrCast<const RtcpReceiverReportPacket>(rtcpPacket)), address, port);
                    break;
 
                case RTCP_PT_SDES:
                    processIncomingRTCPSDESPacket(CHK(dynamicPtrCast<const RtcpSdesPacket>(rtcpPacket)), address, port, arrivalTime);
                    break;
 
                case RTCP_PT_BYE:
                    processIncomingRTCPByePacket(CHK(dynamicPtrCast<const RtcpByePacket>(rtcpPacket)), address, port);
                    break;
 
                default:
                    throw cRuntimeError("unknown Rtcp packet type");
                    break;
            }
        }
    }
    delete packet;
}

Referenced by readRet().

processIncomingRTCPReceiverReportPacket()

void inet::rtp::Rtcp::processIncomingRTCPReceiverReportPacket ( const Ptr< const RtcpReceiverReportPacket > &  rtcpReceiverReportPacket, Ipv4Address  address, int  port  )

protected

{
    uint32_t 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
        }
    }
 
    const cArray& receptionReports = rtcpReceiverReportPacket->getReceptionReports();
    for (int j = 0; j < receptionReports.size(); j++) {
        if (receptionReports.exist(j)) {
            const ReceptionReport *receptionReport = check_and_cast<const ReceptionReport *>(receptionReports.get(j));
            if (_senderInfo && (receptionReport->getSsrc() == _senderInfo->getSsrc())) {
                _senderInfo->processReceptionReport(receptionReport, simTime());
            }
        }
    }
}

Referenced by processIncomingRTCPPacket().

processIncomingRTCPSDESPacket()

void inet::rtp::Rtcp::processIncomingRTCPSDESPacket ( const Ptr< const RtcpSdesPacket > &  rtcpSDESPacket, Ipv4Address  address, int  port, simtime_t  arrivalTime  )

protected

{
    const 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
            const SdesChunk *sdesChunk = check_and_cast<const SdesChunk *>(sdesChunks.get(j));
            // this is needed to avoid seg faults
//            sdesChunk->setOwner(this);
            uint32_t 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);
        }
    }
}

Referenced by processIncomingRTCPPacket().

processIncomingRTCPSenderReportPacket()

void inet::rtp::Rtcp::processIncomingRTCPSenderReportPacket ( const Ptr< const RtcpSenderReportPacket > &  rtcpSenderReportPacket, Ipv4Address  address, int  port  )

protected

{
    uint32_t 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());
 
    const cArray& receptionReports = rtcpSenderReportPacket->getReceptionReports();
    for (int j = 0; j < receptionReports.size(); j++) {
        if (receptionReports.exist(j)) {
            const ReceptionReport *receptionReport = check_and_cast<const ReceptionReport *>(receptionReports.get(j));
            if (_senderInfo && (receptionReport->getSsrc() == _senderInfo->getSsrc())) {
                _senderInfo->processReceptionReport(receptionReport, simTime());
            }
        }
    }
}

Referenced by processIncomingRTCPPacket().

processIncomingRTPPacket()

void inet::rtp::Rtcp::processIncomingRTPPacket ( Packet *  packet, Ipv4Address  address, int  port  )

protectedvirtual

Extracts information of a received RtpPacket.

{
    bool good = false;
    const auto& rtpHeader = packet->peekAtFront<RtpHeader>();
    uint32_t ssrc = rtpHeader->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;
    }
}

Referenced by handleDataIn().

processOutgoingRTPPacket()

void inet::rtp::Rtcp::processOutgoingRTPPacket ( Packet *  packet )

protectedvirtual

Extracts information of a sent RtpPacket.

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

Referenced by handleDataOut().

readRet()

void inet::rtp::Rtcp::readRet ( Packet *  sifpIn )

protectedvirtual

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

{
    emit(packetReceivedSignal, sifpIn);
    processIncomingRTCPPacket(sifpIn, Ipv4Address(_destinationAddress), _port);
}

Referenced by handleMessageFromUDP().

scheduleInterval()

void inet::rtp::Rtcp::scheduleInterval ( )

protectedvirtual

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

{
    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");
    scheduleAfter(intervalLength, reminderMessage);
}

Referenced by handleSelfMessage().

Member Data Documentation

_averagePacketSize

double inet::rtp::Rtcp::_averagePacketSize = 0

protected

The average size of an RtcpCompoundPacket.

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

_bandwidth

int inet::rtp::Rtcp::_bandwidth = 0

protected

The bandwidth for this Rtp session.

Referenced by handleInitializeRTCP(), and scheduleInterval().

_destinationAddress

Ipv4Address inet::rtp::Rtcp::_destinationAddress

protected

The destination address.

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

_leaveSession

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

_mtu

int inet::rtp::Rtcp::_mtu = 0

protected

The maximum size an RTCPCompundPacket can have.

Referenced by handleInitializeRTCP().

_packetsCalculated

int inet::rtp::Rtcp::_packetsCalculated = 0

protected

The number of packets this rtcp module has calculated.

Referenced by calculateAveragePacketSize(), and initialize().

_participantInfos

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

_port

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

protected

The rtcp port.

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

_rtcpPercentage

int inet::rtp::Rtcp::_rtcpPercentage = 0

protected

The percentage of bandwidth for rtcp.

Referenced by handleInitializeRTCP(), and scheduleInterval().

_senderInfo

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

_ssrcChosen

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

UdpSocket inet::rtp::Rtcp::_udpSocket

protected

The UDP socket for sending/receiving rtcp packets.

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

---

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

• Rtcp.h
• Rtcp.cc