This class, a subclass of RTPParticipantInfo, is used for storing information about other RTP endsystems. More...

#include <RTPReceiverInfo.h>

Inheritance diagram for inet::rtp::RTPReceiverInfo:

Public Types
enum	{ MAX_INACTIVE_INTERVALS = 5 }

Public Member Functions
	RTPReceiverInfo (uint32 ssrc=0)
	Default constructor. More...

	RTPReceiverInfo (const RTPReceiverInfo &receiverInfo)
	Copy constructor. More...

virtual	~RTPReceiverInfo ()
	Destructor. More...

RTPReceiverInfo &	operator= (const RTPReceiverInfo &receiverInfo)
	Assignment operator. More...

virtual RTPReceiverInfo *	dup () const override
	Duplicates this RTPReceiverInfo by calling the copy constructor. More...

virtual void	processRTPPacket (RTPPacket *packet, int id, simtime_t arrivalTime) override
	Extracts information of the given RTPPacket. More...

virtual void	processSenderReport (SenderReport *report, simtime_t arrivalTime)
	Extracts information of the given SenderReport. More...

virtual void	processSDESChunk (SDESChunk *sdesChunk, simtime_t arrivalTime) override
	Extracts information of the given SDESChunk. More...

virtual ReceptionReport *	receptionReport (simtime_t now) override
	Returns a ReceptionReport if this RTP end system is a sender, nullptr otherwise. More...

virtual void	nextInterval (simtime_t now) override
	Informs this RTPReceiverInfo that one rtcp interval has past. More...

virtual bool	isActive ()
	Returns true if this RTP end system is regarded active. More...

virtual bool	isValid ()
	Returns true if this RTP end system is regarded valid. More...

virtual bool	toBeDeleted (simtime_t now) override
	Returns true if this RTP end system should be deleted from the list of known RTP session participant. More...

Public Member Functions inherited from inet::rtp::RTPParticipantInfo
	RTPParticipantInfo (uint32 ssrc=0)
	Default constructor. More...

	RTPParticipantInfo (const RTPParticipantInfo &participantInfo)
	Copy constructor. More...

virtual	~RTPParticipantInfo ()
	Destructor. More...

RTPParticipantInfo &	operator= (const RTPParticipantInfo &participantInfo)
	Assignment operator. More...

virtual void	processSenderReport (SenderReport &report, simtime_t arrivalTime)
	This method extracts information about an RTP endsystem as provided by the given SenderReport. More...

virtual void	processReceptionReport (ReceptionReport &report, simtime_t arrivalTime)
	This method extracts information of the given ReceptionReport. More...

virtual SDESChunk *	getSDESChunk () const
	Returns a copy of the sdes chunk used for storing source description items about this system. More...

virtual void	addSDESItem (SDESItem *sdesItem)
	Adds this sdes item to the sdes chunk of this participant. More...

virtual SenderReport *	senderReport (simtime_t now)
	This method is intended to be overwritten by subclasses which are used for storing information about itself. More...

virtual bool	isSender () const
	Returns true if this endsystem has sent at least one RTP data packet during the last two rtcp intervals (including the current one). More...

virtual uint32	getSsrc () const override
	Returns the ssrc identifier of the RTP endsystem. More...

virtual void	setSsrc (uint32 ssrc) override
	Sets the ssrc identifier. More...

virtual void	addSDESItem (SDESItem::SDES_ITEM_TYPE type, const char *content)
	Creates a new SDESItem and adds it to the SDESChunk stored in this RTPParticipantInfo. More...

virtual void	parsimPack (cCommBuffer *b) const override

virtual void	parsimUnpack (cCommBuffer *b) override

Public Member Functions inherited from inet::rtp::RTPParticipantInfo_Base
virtual	~RTPParticipantInfo_Base ()

virtual void	parsimPack (omnetpp::cCommBuffer *b) const override

virtual void	parsimUnpack (omnetpp::cCommBuffer *b) override

virtual IPv4Address &	getAddress ()

virtual const IPv4Address &	getAddress () const

virtual void	setAddress (const IPv4Address &address)

virtual int	getRTPPort () const

virtual void	setRTPPort (int RTPPort)

virtual int	getRTCPPort () const

virtual void	setRTCPPort (int RTCPPort)

Protected Attributes
uint16	_sequenceNumberBase = 0
	The sequence number of the first RTPPacket received. More...

uint16	_highestSequenceNumber = 0
	The highest sequence number of an RTPPacket received. More...

uint32	_highestSequenceNumberPrior = 0
	The highest sequence number of an RTPPacket received before the beginning of the current rtcp interval. More...

uint32	_sequenceNumberCycles = 0
	The number of sequence number wrap arounds. More...

uint32	_packetsReceived = 0
	How many RTP packets from this source have been received. More...

uint32	_packetsReceivedPrior = 0
	How many RTP packets have been received from this source before the current rtcp interval began. More...

simtime_t	_jitter
	The interarrival jitter. More...

int	_clockRate = 0
	The output vector for jitter value. More...

uint32	_lastSenderReportRTPTimeStamp = 0
	The RTP time stamp of the last SenderReport received from this sender. More...

uint64	_lastSenderReportNTPTimeStamp = 0
	The ntp time stamp of the last SenderReport received from this sender. More...

uint32	_lastPacketRTPTimeStamp = 0
	The RTP time stamp of the last RTPPacket received from this sender. More...

simtime_t	_lastPacketArrivalTime
	The arrival time of the last RTPPacket received from this sender. More...

simtime_t	_lastSenderReportArrivalTime
	The arrival time of the last SenderReport received from this sender. More...

int	_inactiveIntervals = 0
	The consecutive number of rtcp intervals this rtcp end system hasn't sent anything. More...

simtime_t	_startOfInactivity = 0.0
	The time when this RTP end system has been inactive for five consecutive rtcp intervals. More...

int	_itemsReceived = 0
	The number of RTP and rtcp packets received from this RTP end system. More...

Protected Attributes inherited from inet::rtp::RTPParticipantInfo
SDESChunk	_sdesChunk
	Used for storing sdes information about this RTP endsystem. More...

int	_silentIntervals
	Stores the number of rtcp intervals (including the current one) during which this RTP endsystem hasn't sent any RTP data packets. More...

Protected Attributes inherited from inet::rtp::RTPParticipantInfo_Base
IPv4Address	address

int	RTPPort

int	RTCPPort

Private Member Functions
void	copy (const RTPReceiverInfo &other)

Additional Inherited Members
Static Public Member Functions inherited from inet::rtp::RTPParticipantInfo
static std::string	ssrcToName (uint32 ssrc)
	This method returns the given 32 bit ssrc identifier as an 8 character hexadecimal number which is used as name of an RTPParticipantInfo object. More...

Protected Member Functions inherited from inet::rtp::RTPParticipantInfo_Base
bool	operator== (const RTPParticipantInfo_Base &)

	RTPParticipantInfo_Base (const char *name=nullptr)

	RTPParticipantInfo_Base (const RTPParticipantInfo_Base &other)

RTPParticipantInfo_Base &	operator= (const RTPParticipantInfo_Base &other)

Detailed Description

This class, a subclass of RTPParticipantInfo, is used for storing information about other RTP endsystems.

This class processes RTP packets, rtcp sender reports and rtcp sdes chunks originating from this endsystem.

Member Enumeration Documentation

anonymous enum

Enumerator
MAX_INACTIVE_INTERVALS

39 { MAX_INACTIVE_INTERVALS = 5 };

inet::rtp::RTPReceiverInfo::MAX_INACTIVE_INTERVALS

Definition: RTPReceiverInfo.h:39

Constructor & Destructor Documentation

inet::rtp::RTPReceiverInfo::RTPReceiverInfo ( uint32 ssrc = 0 )

Default constructor.

Referenced by dup().

                                             : RTPParticipantInfo(ssrc)
 {
 }

inet::rtp::RTPReceiverInfo::RTPReceiverInfo ( const RTPReceiverInfo & receiverInfo )

Copy constructor.

                                                                     : RTPParticipantInfo(receiverInfo)
 {
     copy(receiverInfo);
 }

inet::rtp::RTPReceiverInfo::~RTPReceiverInfo ( )

virtual

Destructor.

39 {

40 }

Member Function Documentation

void inet::rtp::RTPReceiverInfo::copy ( const RTPReceiverInfo & other )

private

Referenced by operator=(), and RTPReceiverInfo().

 {
     _sequenceNumberBase = receiverInfo._sequenceNumberBase;
     _highestSequenceNumber = receiverInfo._highestSequenceNumber;
     _highestSequenceNumberPrior = receiverInfo._highestSequenceNumberPrior;
     _sequenceNumberCycles = receiverInfo._sequenceNumberCycles;
 
     _packetsReceived = receiverInfo._packetsReceived;
     _packetsReceivedPrior = receiverInfo._packetsReceivedPrior;
 
     _jitter = receiverInfo._jitter;
     _clockRate = receiverInfo._clockRate;
     _lastSenderReportRTPTimeStamp = receiverInfo._lastSenderReportRTPTimeStamp;
     _lastSenderReportNTPTimeStamp = receiverInfo._lastSenderReportNTPTimeStamp;
     _lastPacketRTPTimeStamp = receiverInfo._lastPacketRTPTimeStamp;
 
     _lastPacketArrivalTime = receiverInfo._lastPacketArrivalTime;
     _lastSenderReportArrivalTime = receiverInfo._lastSenderReportArrivalTime;
 
     _inactiveIntervals = receiverInfo._inactiveIntervals;
     _startOfInactivity = receiverInfo._startOfInactivity;
     _itemsReceived = receiverInfo._itemsReceived;
 }

RTPReceiverInfo * inet::rtp::RTPReceiverInfo::dup ( ) const

overridevirtual

Duplicates this RTPReceiverInfo by calling the copy constructor.

Reimplemented from inet::rtp::RTPParticipantInfo.

 {
     return new RTPReceiverInfo(*this);
 }

bool inet::rtp::RTPReceiverInfo::isActive ( )

virtual

Returns true if this RTP end system is regarded active.

Referenced by toBeDeleted().

 {
     return _inactiveIntervals < MAX_INACTIVE_INTERVALS;
 }

bool inet::rtp::RTPReceiverInfo::isValid ( )

virtual

Returns true if this RTP end system is regarded valid.

Referenced by toBeDeleted().

 {
     return _itemsReceived >= MAX_INACTIVE_INTERVALS;
 }

void inet::rtp::RTPReceiverInfo::nextInterval ( simtime_t now )

overridevirtual

Informs this RTPReceiverInfo that one rtcp interval has past.

Reimplemented from inet::rtp::RTPParticipantInfo.

 {
     _inactiveIntervals++;
     if (_inactiveIntervals == MAX_INACTIVE_INTERVALS) {
         _startOfInactivity = now;
     }
     _highestSequenceNumberPrior = _highestSequenceNumber + _sequenceNumberCycles;
     _packetsReceivedPrior = _packetsReceived;
     RTPParticipantInfo::nextInterval(now);
 }

RTPReceiverInfo & inet::rtp::RTPReceiverInfo::operator= ( const RTPReceiverInfo & receiverInfo )

Assignment operator.

 {
     if (this == &receiverInfo)
         return *this;
     RTPParticipantInfo::operator=(receiverInfo);
     copy(receiverInfo);
     return *this;
 }

void inet::rtp::RTPReceiverInfo::processRTPPacket	(	RTPPacket *	packet,
		int	id,
		simtime_t	arrivalTime
	)

overridevirtual

Extracts information of the given RTPPacket.

Also sets _inactiveIntervals to 0.

Reimplemented from inet::rtp::RTPParticipantInfo.

 {
     // this endsystem sends, it isn't inactive
     _inactiveIntervals = 0;
 
     _packetsReceived++;
     _itemsReceived++;
 
     if (_packetsReceived == 1) {
         _sequenceNumberBase = packet->getSequenceNumber();
     }
     else {
         /*if (packet->getSequenceNumber() > _highestSequenceNumber+1)
            {
             _packetLostOutVector.record(packet->getSequenceNumber() - _highestSequenceNumber -1);
             for (int i = _highestSequenceNumber+1; i< packet->getSequenceNumber(); i++ )
             {
                 //std::cout << "id = "<< id <<" SequeceNumber loss = "<<i<<endl;
                 packetSequenceLostLogFile = fopen ("PacketLossLog.log","+w");
                 if (packetSequenceLostLogFile != nullptr)
                 {
                     //sprintf (line, "id = %d SequeceNumber loss = %f ", id,i);
                     fputs (i, packetSequenceLostLogFile);
                     fclose (packetSequenceLostLogFile);
                 }
             }
            }*/
 
         if (packet->getSequenceNumber() > _highestSequenceNumber) {
             // it is possible that this is a late packet from the
             // previous sequence wrap
             if (!(packet->getSequenceNumber() > 0xFFEF && _highestSequenceNumber < 0x10))
                 _highestSequenceNumber = packet->getSequenceNumber();
         }
         else {
             // is it a sequence number wrap around 0xFFFF to 0x0000 ?
             if (packet->getSequenceNumber() < 0x10 && _highestSequenceNumber > 0xFFEF) {
                 _sequenceNumberCycles += 0x00010000;
                 _highestSequenceNumber = packet->getSequenceNumber();
             }
         }
         // calculate interarrival jitter
         if (_clockRate != 0) {
             simtime_t d = packet->getTimeStamp() - _lastPacketRTPTimeStamp
                 - (arrivalTime - _lastPacketArrivalTime) * (double)_clockRate;
             if (d < 0)
                 d = -d;
             _jitter = _jitter + (d - _jitter) / 16;
         }
 
         _lastPacketRTPTimeStamp = packet->getTimeStamp();
         _lastPacketArrivalTime = arrivalTime;
     }
 
     RTPParticipantInfo::processRTPPacket(packet, id, arrivalTime);
 }

void inet::rtp::RTPReceiverInfo::processSDESChunk	(	SDESChunk *	sdesChunk,
		simtime_t	arrivalTime
	)

overridevirtual

Extracts information of the given SDESChunk.

Reimplemented from inet::rtp::RTPParticipantInfo.

 {
     RTPParticipantInfo::processSDESChunk(sdesChunk, arrivalTime);
     _itemsReceived++;
     _inactiveIntervals = 0;
 }

void inet::rtp::RTPReceiverInfo::processSenderReport	(	SenderReport *	report,
		simtime_t	arrivalTime
	)

virtual

Extracts information of the given SenderReport.

 {
     _lastSenderReportArrivalTime = arrivalTime;
     if (_lastSenderReportRTPTimeStamp == 0) {
         _lastSenderReportRTPTimeStamp = report->getRTPTimeStamp();
         _lastSenderReportNTPTimeStamp = report->getNTPTimeStamp();
     }
     else if (_clockRate == 0) {
         uint32 rtpTicks = report->getRTPTimeStamp() - _lastSenderReportRTPTimeStamp;
         uint64 ntpDifference = report->getNTPTimeStamp() - _lastSenderReportNTPTimeStamp;
         long double ntpSeconds = (long double)ntpDifference / (long double)(0xFFFFFFFF);
         _clockRate = (int)((long double)rtpTicks / ntpSeconds);
     }
 
     _inactiveIntervals = 0;
     _itemsReceived++;
 
     delete report;
 }

ReceptionReport * inet::rtp::RTPReceiverInfo::receptionReport ( simtime_t now )

overridevirtual

Returns a ReceptionReport if this RTP end system is a sender, nullptr otherwise.

Reimplemented from inet::rtp::RTPParticipantInfo.

 {
     if (isSender()) {
         ReceptionReport *receptionReport = new ReceptionReport();
         receptionReport->setSsrc(getSsrc());
 
         uint64 packetsExpected = _sequenceNumberCycles + (uint64)_highestSequenceNumber
             - (uint64)_sequenceNumberBase + (uint64)1;
         uint64 packetsLost = packetsExpected - _packetsReceived;
 
         int32 packetsExpectedInInterval =
             _sequenceNumberCycles + _highestSequenceNumber - _highestSequenceNumberPrior;
         int32 packetsReceivedInInterval = _packetsReceived - _packetsReceivedPrior;
         int32 packetsLostInInterval = packetsExpectedInInterval - packetsReceivedInInterval;
         uint8 fractionLost = 0;
         if (packetsLostInInterval > 0) {
             fractionLost = (packetsLostInInterval << 8) / packetsExpectedInInterval;
         }
 
         receptionReport->setFractionLost(fractionLost);
         receptionReport->setPacketsLostCumulative(packetsLost);
         receptionReport->setSequenceNumber(_sequenceNumberCycles + _highestSequenceNumber);
 
         receptionReport->setJitter((uint32)SIMTIME_DBL(_jitter));    //XXX ??? store it in secs? --Andras
 
         // the middle 32 bit of the ntp time stamp of the last sender report
         receptionReport->setLastSR((_lastSenderReportNTPTimeStamp >> 16) & 0xFFFFFFFF);
 
         // the delay since the arrival of the last sender report in units
         // of 1 / 65536 seconds
         // 0 if no sender report has ben received
         receptionReport->setDelaySinceLastSR(_lastSenderReportArrivalTime == 0.0 ? 0
                 : (uint32)(SIMTIME_DBL(now - _lastSenderReportArrivalTime) * 65536.0));
 
         return receptionReport;
     }
     else
         return nullptr;
 }

bool inet::rtp::RTPReceiverInfo::toBeDeleted ( simtime_t now )

overridevirtual

Returns true if this RTP end system should be deleted from the list of known RTP session participant.

This method should be called directly after nextInterval().

Reimplemented from inet::rtp::RTPParticipantInfo.

 {
     // an RTP system should be removed from the list of known systems
     // when it hasn't been validated and hasn't been active for
     // 5 rtcp intervals or if it has been validated and has been
     // inactive for 30 minutes
     return (!isValid() && !isActive()) || (isValid() && !isActive() && (now - _startOfInactivity > 60.0 * 30.0));
 }

Member Data Documentation

int inet::rtp::RTPReceiverInfo::_clockRate = 0

protected

The output vector for jitter value.

The output vector for packet lost The clock rate (in ticks per second) the sender increases the RTP timestamps. It is calculated when two sender reports have been received.

Referenced by copy(), processRTPPacket(), and processSenderReport().

uint16 inet::rtp::RTPReceiverInfo::_highestSequenceNumber = 0

protected

The highest sequence number of an RTPPacket received.

Referenced by copy(), nextInterval(), processRTPPacket(), and receptionReport().