RTPReceiverInfo Class Reference

#include <RTPReceiverInfo.h>

Inheritance diagram for RTPReceiverInfo:

RTPParticipantInfo

List of all members.


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.

Public Member Functions

 RTPReceiverInfo (uint32 ssrc=0)
 RTPReceiverInfo (const RTPReceiverInfo &receiverInfo)
virtual ~RTPReceiverInfo ()
RTPReceiverInfooperator= (const RTPReceiverInfo &receiverInfo)
virtual RTPReceiverInfodup () const
virtual void processRTPPacket (RTPPacket *packet, int id, simtime_t arrivalTime)
virtual void processSenderReport (SenderReport *report, simtime_t arrivalTime)
virtual void processSDESChunk (SDESChunk *sdesChunk, simtime_t arrivalTime)
virtual ReceptionReportreceptionReport (simtime_t now)
virtual void nextInterval (simtime_t now)
virtual bool isActive ()
virtual bool isValid ()
virtual bool toBeDeleted (simtime_t now)

Protected Attributes

uint16 _sequenceNumberBase
uint16 _highestSequenceNumber
uint32 _highestSequenceNumberPrior
uint32 _sequenceNumberCycles
uint32 _packetsReceived
uint32 _packetsReceivedPrior
simtime_t _jitter
cOutVector _jitterOutVector
cOutVector _packetLostOutVector
int _clockRate
uint32 _lastSenderReportRTPTimeStamp
uint64 _lastSenderReportNTPTimeStamp
uint32 _lastPacketRTPTimeStamp
simtime_t _lastPacketArrivalTime
simtime_t _lastSenderReportArrivalTime
int _inactiveIntervals
simtime_t _startOfInactivity
int _itemsReceived
int packetLoss
FILE * packetSequenceLostLogFile

Constructor & Destructor Documentation

RTPReceiverInfo::RTPReceiverInfo ( uint32  ssrc = 0  ) 

Default constructor.

Referenced by dup().

00028                                             : RTPParticipantInfo(ssrc)
00029 {
00030     _sequenceNumberBase = 0;
00031     _highestSequenceNumber = 0;
00032     _highestSequenceNumberPrior = 0;
00033     _sequenceNumberCycles = 0;
00034 
00035     _packetsReceived = 0;
00036     _packetsReceivedPrior = 0;
00037 
00038     _jitter = 0.0;
00039     _clockRate = 0;
00040     _lastSenderReportRTPTimeStamp = 0;
00041     _lastSenderReportNTPTimeStamp = 0;
00042     _lastPacketRTPTimeStamp = 0;
00043 
00044     _lastPacketArrivalTime = 0.0;
00045     _lastSenderReportArrivalTime = 0.0;
00046 
00047     _inactiveIntervals = 0;
00048     _startOfInactivity = 0.0;
00049     _itemsReceived = 0;
00050     //_jitterOutVector.setName("Jitter");
00051     //_packetLostOutVector.setName("Packet Lost");
00052 
00053     //packetSequenceLostLogFile = NULL;
00054 };

RTPReceiverInfo::RTPReceiverInfo ( const RTPReceiverInfo receiverInfo  ) 

Copy constructor.

00056                                                                     : RTPParticipantInfo()
00057 {
00058     operator=(receiverInfo);
00059 };

RTPReceiverInfo::~RTPReceiverInfo (  )  [virtual]

Destructor.

00062 {
00063 }


Member Function Documentation

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

Assignment operator.

Referenced by RTPReceiverInfo().

00066 {
00067     RTPParticipantInfo::operator=(receiverInfo);
00068 
00069     _sequenceNumberBase = receiverInfo._sequenceNumberBase;
00070     _highestSequenceNumber = receiverInfo._highestSequenceNumber;
00071     _highestSequenceNumberPrior = receiverInfo._highestSequenceNumberPrior;
00072     _sequenceNumberCycles = receiverInfo._sequenceNumberCycles;
00073 
00074     _packetsReceived = receiverInfo._packetsReceived;
00075     _packetsReceivedPrior = receiverInfo._packetsReceivedPrior;
00076 
00077     _jitter = receiverInfo._jitter;
00078     _clockRate = receiverInfo._clockRate;
00079     _lastSenderReportRTPTimeStamp = receiverInfo._lastSenderReportRTPTimeStamp;
00080     _lastSenderReportNTPTimeStamp = receiverInfo._lastSenderReportNTPTimeStamp;
00081     _lastPacketRTPTimeStamp = receiverInfo._lastPacketRTPTimeStamp;
00082 
00083     _lastPacketArrivalTime = receiverInfo._lastPacketArrivalTime;
00084     _lastSenderReportArrivalTime = receiverInfo._lastSenderReportArrivalTime;
00085 
00086     _inactiveIntervals = receiverInfo._inactiveIntervals;
00087     _startOfInactivity = receiverInfo._startOfInactivity;
00088     _itemsReceived = receiverInfo._itemsReceived;
00089 
00090     return *this;
00091 };

RTPReceiverInfo * RTPReceiverInfo::dup (  )  const [virtual]

Duplicates this RTPReceiverInfo by calling the copy constructor.

Reimplemented from RTPParticipantInfo.

00093                                             {
00094     return new RTPReceiverInfo(*this);
00095 };

void RTPReceiverInfo::processRTPPacket ( RTPPacket packet,
int  id,
simtime_t  arrivalTime 
) [virtual]

Extracts information of the given RTPPacket. Also sets _inactiveIntervals to 0.

Reimplemented from RTPParticipantInfo.

00098 {
00099     // this endsystem sends, it isn't inactive
00100     _inactiveIntervals = 0;
00101 
00102     _packetsReceived++;
00103     _itemsReceived++;
00104 
00105     if (_packetsReceived == 1) {
00106         _sequenceNumberBase = packet->getSequenceNumber();
00107     }
00108     else {
00109 
00110         /*if (packet->getSequenceNumber() > _highestSequenceNumber+1)
00111         {
00112             _packetLostOutVector.record(packet->getSequenceNumber() - _highestSequenceNumber -1);
00113             for (int i = _highestSequenceNumber+1; i< packet->getSequenceNumber(); i++ )
00114             {
00115                 //std::cout << "id = "<< id <<" SequeceNumber loss = "<<i<<endl;
00116                 packetSequenceLostLogFile = fopen ("PacketLossLog.log","+w");
00117                 if (packetSequenceLostLogFile != NULL)
00118                 {
00119                     //sprintf (line, "id = %d SequeceNumber loss = %f ", id,i);
00120                     fputs (i, packetSequenceLostLogFile);
00121                     fclose (packetSequenceLostLogFile);
00122                 }
00123             }
00124         }*/
00125 
00126         if (packet->getSequenceNumber() > _highestSequenceNumber) {
00127             // it is possible that this is a late packet from the
00128             // previous sequence wrap
00129             if (!(packet->getSequenceNumber() > 0xFFEF && _highestSequenceNumber < 0x10))
00130                 _highestSequenceNumber = packet->getSequenceNumber();
00131         }
00132         else {
00133             // is it a sequence number wrap around 0xFFFF to 0x0000 ?
00134             if (packet->getSequenceNumber() < 0x10 && _highestSequenceNumber > 0xFFEF) {
00135                 _sequenceNumberCycles += 0x00010000;
00136                 _highestSequenceNumber = packet->getSequenceNumber();
00137             }
00138         };
00139         // calculate interarrival jitter
00140         if (_clockRate != 0) {
00141             simtime_t d = packet->getTimeStamp() - _lastPacketRTPTimeStamp - (arrivalTime - _lastPacketArrivalTime) * (double)_clockRate;
00142             if (d < 0)
00143                 d = -d;
00144             _jitter = _jitter + (d - _jitter) / 16;
00145         };
00146 
00147         _lastPacketRTPTimeStamp = packet->getTimeStamp();
00148         _lastPacketArrivalTime = arrivalTime;
00149     };
00150 
00151     //_jitterOutVector.record((uint32)_jitter);
00152 
00153     RTPParticipantInfo::processRTPPacket(packet, id, arrivalTime);
00154 };

void RTPReceiverInfo::processSenderReport ( SenderReport report,
simtime_t  arrivalTime 
) [virtual]

Extracts information of the given SenderReport.

Reimplemented from RTPParticipantInfo.

00157 {
00158     _lastSenderReportArrivalTime = arrivalTime;
00159     if (_lastSenderReportRTPTimeStamp == 0) {
00160         _lastSenderReportRTPTimeStamp = report->getRTPTimeStamp();
00161         _lastSenderReportNTPTimeStamp = report->getNTPTimeStamp();
00162     }
00163     else if (_clockRate == 0) {
00164         uint32 rtpTicks = report->getRTPTimeStamp() - _lastSenderReportRTPTimeStamp;
00165         uint64 ntpDifference = report->getNTPTimeStamp() - _lastSenderReportNTPTimeStamp;
00166         long double ntpSeconds = (long double)ntpDifference / (long double)(0xFFFFFFFF);
00167         _clockRate = (int)((long double)rtpTicks / ntpSeconds);
00168     }
00169 
00170     _inactiveIntervals = 0;
00171     _itemsReceived++;
00172 
00173     delete report;
00174 };

void RTPReceiverInfo::processSDESChunk ( SDESChunk sdesChunk,
simtime_t  arrivalTime 
) [virtual]

Extracts information of the given SDESChunk.

Reimplemented from RTPParticipantInfo.

00177 {
00178     RTPParticipantInfo::processSDESChunk(sdesChunk, arrivalTime);
00179     _itemsReceived++;
00180     _inactiveIntervals = 0;
00181 };

ReceptionReport * RTPReceiverInfo::receptionReport ( simtime_t  now  )  [virtual]

Returns a ReceptionReport if this rtp end system is a sender, NULL otherwise.

Reimplemented from RTPParticipantInfo.

00184 {
00185     if (isSender()) {
00186         ReceptionReport *receptionReport = new ReceptionReport();
00187         receptionReport->setSSRC(getSSRC());
00188 
00189         uint64 packetsExpected = _sequenceNumberCycles + (uint64)_highestSequenceNumber - (uint64)_sequenceNumberBase + (uint64)1;
00190         uint64 packetsLost = packetsExpected - _packetsReceived;
00191 
00192         int32 packetsExpectedInInterval = _sequenceNumberCycles + _highestSequenceNumber - _highestSequenceNumberPrior;
00193         int32 packetsReceivedInInterval = _packetsReceived - _packetsReceivedPrior;
00194         int32 packetsLostInInterval = packetsExpectedInInterval - packetsReceivedInInterval;
00195         uint8 fractionLost = 0;
00196         if (packetsLostInInterval > 0) {
00197             fractionLost = (packetsLostInInterval << 8) / packetsExpectedInInterval;
00198         };
00199 
00200         receptionReport->setFractionLost(fractionLost);
00201         receptionReport->setPacketsLostCumulative(packetsLost);
00202         receptionReport->setSequenceNumber(_sequenceNumberCycles + _highestSequenceNumber);
00203 
00204         receptionReport->setJitter((uint32)SIMTIME_DBL(_jitter)); //XXX ??? store it in secs? --Andras
00205 
00206         // the middle 32 bit of the ntp time stamp of the last sender report
00207         receptionReport->setLastSR((_lastSenderReportNTPTimeStamp >> 16) & 0xFFFFFFFF);
00208 
00209         // the delay since the arrival of the last sender report in units
00210         // of 1 / 65536 seconds
00211         // 0 if no sender report has ben received
00212 
00213         receptionReport->setDelaySinceLastSR(_lastSenderReportArrivalTime == 0.0 ? 0 : (uint32)(SIMTIME_DBL(now - _lastSenderReportArrivalTime) * 65536.0));
00214 
00215         return receptionReport;
00216     }
00217     else
00218         return NULL;
00219 };

void RTPReceiverInfo::nextInterval ( simtime_t  now  )  [virtual]

Informs this RTPReceiverInfo that one rtcp interval has past.

Reimplemented from RTPParticipantInfo.

bool RTPReceiverInfo::isActive (  )  [virtual]

Returns true if this rtp end system is regarded active.

Referenced by toBeDeleted().

00233 {
00234     return (_inactiveIntervals < 5);
00235 };

bool RTPReceiverInfo::isValid (  )  [virtual]

Returns true if this rtp end system is regarded valid.

Referenced by toBeDeleted().

00238 {
00239     return (_itemsReceived >= 5);
00240 };

bool RTPReceiverInfo::toBeDeleted ( simtime_t  now  )  [virtual]

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 RTPParticipantInfo.

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


Member Data Documentation

The sequence number of the first RTPPacket received.

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

The highest sequence number of an RTPPacket received.

Referenced by nextInterval(), operator=(), processRTPPacket(), receptionReport(), and RTPReceiverInfo().

The highest sequence number of an RTPPacket received before the beginning of the current rtcp interval.

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

The number of sequence number wrap arounds.

Referenced by nextInterval(), operator=(), processRTPPacket(), receptionReport(), and RTPReceiverInfo().

How many rtp packets from this source have been received.

Referenced by nextInterval(), operator=(), processRTPPacket(), receptionReport(), and RTPReceiverInfo().

How many rtp packets have been received from this source before the current rtcp interval began.

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

simtime_t RTPReceiverInfo::_jitter [protected]

The interarrival jitter. See rtp rfc for details.

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

cOutVector RTPReceiverInfo::_jitterOutVector [protected]

The output vector for jitter value

cOutVector RTPReceiverInfo::_packetLostOutVector [protected]

The output vector for packet lost

int RTPReceiverInfo::_clockRate [protected]

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 operator=(), processRTPPacket(), processSenderReport(), and RTPReceiverInfo().

The rtp time stamp of the last SenderReport received from this sender.

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

The ntp time stamp of the last SenderReport received from this sender.

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

The rtp time stamp of the last RTPPacket received from this sender. Needed for calculating the jitter.

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

The arrival time of the last RTPPacket received from this sender. Needed for calculating the jitter.

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

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

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

The consecutive number of rtcp intervals this rtcp end system hasn't sent anything.

Referenced by isActive(), nextInterval(), operator=(), processRTPPacket(), processSDESChunk(), processSenderReport(), and RTPReceiverInfo().

simtime_t RTPReceiverInfo::_startOfInactivity [protected]

The time when this rtp end system has been inactive for five consecutive rtcp intervals.

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

The number of rtp and rtcp packets received from this rtp end system.

Referenced by isValid(), operator=(), processRTPPacket(), processSDESChunk(), processSenderReport(), and RTPReceiverInfo().

int RTPReceiverInfo::packetLoss [protected]


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

Generated on Fri Mar 20 18:51:21 2009 for INET Framework for OMNeT++/OMNEST by  doxygen 1.5.5