Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

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 (u_int32 ssrc=0)
 RTPReceiverInfo (const RTPReceiverInfo &receiverInfo)
virtual ~RTPReceiverInfo ()
RTPReceiverInfo & operator= (const RTPReceiverInfo &receiverInfo)
virtual cObject * dup () const
virtual const char * className () const
virtual void processRTPPacket (RTPPacket *packet, simtime_t arrivalTime)
virtual void processSenderReport (SenderReport *report, simtime_t arrivalTime)
virtual void processSDESChunk (SDESChunk *sdesChunk, simtime_t arrivalTime)
virtual ReceptionReport * receptionReport (simtime_t now)
virtual void nextInterval (simtime_t now)
virtual bool active ()
virtual bool valid ()
virtual bool toBeDeleted (simtime_t now)

Private Attributes

u_int16 _sequenceNumberBase
u_int16 _highestSequenceNumber
u_int32 _highestSequenceNumberPrior
u_int32 _sequenceNumberCycles
u_int32 _packetsReceived
u_int32 _packetsReceivedPrior
double _jitter
int _clockRate
u_int32 _lastSenderReportRTPTimeStamp
u_int64 _lastSenderReportNTPTimeStamp
u_int32 _lastPacketRTPTimeStamp
simtime_t _lastPacketArrivalTime
simtime_t _lastSenderReportArrivalTime
int _inactiveIntervals
simtime_t _startOfInactivity
int _itemsReceived

Constructor & Destructor Documentation

RTPReceiverInfo::RTPReceiverInfo (  u_int32  ssrc = 0  ) 
 

Default constructor. 

00031                                              : RTPParticipantInfo(ssrc)  {
00032 
00033     _sequenceNumberBase = 0;
00034     _highestSequenceNumber = 0;
00035     _highestSequenceNumberPrior = 0;
00036     _sequenceNumberCycles = 0;
00037 
00038     _packetsReceived = 0;
00039     _packetsReceivedPrior = 0;
00040 
00041     _jitter = 0.0;
00042     _clockRate = 0;
00043     _lastSenderReportRTPTimeStamp = 0;
00044     _lastSenderReportNTPTimeStamp = 0;
00045     _lastPacketRTPTimeStamp = 0;
00046 
00047     _lastPacketArrivalTime = 0.0;
00048     _lastSenderReportArrivalTime = 0.0;
00049 
00050     _inactiveIntervals = 0;
00051     _startOfInactivity = 0.0;
00052     _itemsReceived = 0;
00053 };

RTPReceiverInfo::RTPReceiverInfo (  const RTPReceiverInfo &  receiverInfo  ) 
 

Copy constructor. 

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

RTPReceiverInfo::~RTPReceiverInfo (   )  [virtual]
 

Destructor. 

00062                                   {
00063 }

Member Function Documentation

bool RTPReceiverInfo::active (   )  [virtual]
 

Returns true if this rtp end system is regarded active. 

00225                              {
00226     return (_inactiveIntervals < 5);
00227 };

const char * RTPReceiverInfo::className (   )  const [virtual]
 

Returns the class name "RTPReceiverInfo".

Reimplemented from RTPParticipantInfo.

00099                                              {
00100     return "RTPReceiverInfo";
00101 };

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

Duplicates this RTPReceiverInfo by calling the copy constructor.

Reimplemented from RTPParticipantInfo.

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

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

Informs this RTPReceiverInfo that one rtcp interval has past.

Reimplemented from RTPParticipantInfo.

00214                                                 {
00215     _inactiveIntervals++;
00216     if (_inactiveIntervals == 5) {
00217         _startOfInactivity = now;
00218     }
00219     _highestSequenceNumberPrior = _highestSequenceNumber + _sequenceNumberCycles;
00220     _packetsReceivedPrior = _packetsReceived;
00221     RTPParticipantInfo::nextInterval(now);
00222 };

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

Assignment operator. 

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

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

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

Reimplemented from RTPParticipantInfo.

00104                                                                                {
00105 
00106     // this endsystem sends, it isn't inactive
00107     _inactiveIntervals = 0;
00108 
00109     _packetsReceived++;
00110     _itemsReceived++;
00111 
00112     if (_packetsReceived == 1) {
00113         _sequenceNumberBase = packet->sequenceNumber();
00114     }
00115     else {
00116         if (packet->sequenceNumber() > _highestSequenceNumber) {
00117             // it is possible that this is a late packet from the
00118             // previous sequence wrap
00119             if (!(packet->sequenceNumber() > 0xFFEF && _highestSequenceNumber < 0x10))
00120                 _highestSequenceNumber = packet->sequenceNumber();
00121         }
00122         else {
00123             // is it a sequence number wrap around 0xFFFF to 0x0000 ?
00124             if (packet->sequenceNumber() < 0x10 && _highestSequenceNumber > 0xFFEF) {
00125                 _sequenceNumberCycles += 0x00010000;
00126                 _highestSequenceNumber = packet->sequenceNumber();
00127             }
00128         };
00129         // calculate interarrival jitter
00130         if (_clockRate != 0) {
00131             double d = (double)(packet->timeStamp() - _lastPacketRTPTimeStamp) - (arrivalTime - _lastPacketArrivalTime) * (double)_clockRate;
00132             if (d < 0)
00133                 d = -d;
00134             _jitter = _jitter + (d - _jitter) / 16;
00135         };
00136         _lastPacketRTPTimeStamp = packet->timeStamp();
00137         _lastPacketArrivalTime = arrivalTime;
00138     };
00139 
00140 
00141 
00142     RTPParticipantInfo::processRTPPacket(packet, arrivalTime);
00143 
00144 };

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

Extracts information of the given SDESChunk.

Reimplemented from RTPParticipantInfo.

00168                                                                                   {
00169     RTPParticipantInfo::processSDESChunk(sdesChunk, arrivalTime);
00170     _itemsReceived++;
00171     _inactiveIntervals = 0;
00172 };

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

Extracts information of the given SenderReport.

Reimplemented from RTPParticipantInfo.

00147                                                                                      {
00148 
00149     _lastSenderReportArrivalTime = arrivalTime;
00150     if (_lastSenderReportRTPTimeStamp == 0) {
00151         _lastSenderReportRTPTimeStamp = report->rtpTimeStamp();
00152         _lastSenderReportNTPTimeStamp = report->ntpTimeStamp();
00153     }
00154     else if (_clockRate == 0) {
00155         u_int32 rtpTicks = report->rtpTimeStamp() - _lastSenderReportRTPTimeStamp;
00156         u_int64 ntpDifference = report->ntpTimeStamp() - _lastSenderReportNTPTimeStamp;
00157         long double ntpSeconds = (long double)ntpDifference / (long double)(0xFFFFFFFF);
00158         _clockRate = (int)((long double)rtpTicks / ntpSeconds);
00159     }
00160 
00161     _inactiveIntervals = 0;
00162     _itemsReceived++;
00163 
00164     delete report;
00165 };

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

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

Reimplemented from RTPParticipantInfo.

00175                                                                {
00176 
00177     if (isSender()) {
00178         ReceptionReport *receptionReport = new ReceptionReport("ReceiverReport");
00179         receptionReport->setSSRC(ssrc());
00180 
00181         u_int64 packetsExpected = _sequenceNumberCycles + (u_int64)_highestSequenceNumber - (u_int64)_sequenceNumberBase + (u_int64)1;
00182         u_int64 packetsLost = packetsExpected - _packetsReceived;
00183 
00184         int32 packetsExpectedInInterval = _sequenceNumberCycles + _highestSequenceNumber - _highestSequenceNumberPrior;
00185         int32 packetsReceivedInInterval = _packetsReceived - _packetsReceivedPrior;
00186         int32 packetsLostInInterval = packetsExpectedInInterval - packetsReceivedInInterval;
00187         u_int8 fractionLost = 0;
00188         if (packetsLostInInterval > 0) {
00189             fractionLost = (packetsLostInInterval << 8) / packetsExpectedInInterval;
00190         };
00191 
00192         receptionReport->setFractionLost(fractionLost);
00193         receptionReport->setPacketsLostCumulative(packetsLost);
00194         receptionReport->setSequenceNumber(_sequenceNumberCycles + _highestSequenceNumber);
00195 
00196         receptionReport->setJitter((u_int32)_jitter);
00197 
00198         // the middle 32 bit of the ntp time stamp of the last sender report
00199         receptionReport->setLastSR((_lastSenderReportNTPTimeStamp >> 16) & 0xFFFFFFFF);
00200 
00201         // the delay since the arrival of the last sender report in units
00202         // of 1 / 65536 seconds
00203         // 0 if no sender report has ben received
00204 
00205         receptionReport->setDelaySinceLastSR(_lastSenderReportArrivalTime == 0.0 ? 0 : (u_int32)((now - _lastSenderReportArrivalTime) * 65536.0));
00206 
00207         return receptionReport;
00208     }
00209     else
00210         return NULL;
00211 };

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.

00235                                                {
00236     // an rtp system should be removed from the list of known systems
00237     // when it hasn't been validated and hasn't been active for
00238     // 5 rtcp intervals or if it has been validated and has been
00239     // inactive for 30 minutes
00240     return (!valid() && !active()) || (valid() && !active() && (now - _startOfInactivity > 60.0 * 30.0));
00241 };

bool RTPReceiverInfo::valid (   )  [virtual]
 

Returns true if this rtp end system is regarded valid. 

00230                             {
00231     return (_itemsReceived >= 5);
00232 };

Member Data Documentation

int RTPReceiverInfo::_clockRate [private]
 

The clock rate (in ticks per second) the sender increases the rtp timestamps. It is calculated when two sender reports have been received.

u_int16 RTPReceiverInfo::_highestSequenceNumber [private]
 

The highest sequence number of an RTPPacket received.

u_int32 RTPReceiverInfo::_highestSequenceNumberPrior [private]
 

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

int RTPReceiverInfo::_inactiveIntervals [private]
 

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

int RTPReceiverInfo::_itemsReceived [private]
 

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

double RTPReceiverInfo::_jitter [private]
 

The interarrival jitter. See rtp rfc for details.

simtime_t RTPReceiverInfo::_lastPacketArrivalTime [private]
 

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

u_int32 RTPReceiverInfo::_lastPacketRTPTimeStamp [private]
 

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

simtime_t RTPReceiverInfo::_lastSenderReportArrivalTime [private]
 

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

u_int64 RTPReceiverInfo::_lastSenderReportNTPTimeStamp [private]
 

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

u_int32 RTPReceiverInfo::_lastSenderReportRTPTimeStamp [private]
 

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

u_int32 RTPReceiverInfo::_packetsReceived [private]
 

How many rtp packets from this source have been received.

u_int32 RTPReceiverInfo::_packetsReceivedPrior [private]
 

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

u_int16 RTPReceiverInfo::_sequenceNumberBase [private]
 

The sequence number of the first RTPPacket received.

u_int32 RTPReceiverInfo::_sequenceNumberCycles [private]
 

The number of sequence number wrap arounds.

simtime_t RTPReceiverInfo::_startOfInactivity [private]
 

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

The documentation for this class was generated from the following files:
Generated on Sat Apr 1 20:52:24 2006 for INET Framework for OMNeT++/OMNEST by  doxygen 1.4.1