#include <RTPReceiverInfo.h>
Inheritance diagram for RTPReceiverInfo:
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 };
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] |
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 };
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.
The highest sequence number of an RTPPacket received.
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.
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.
The ntp time stamp of the last SenderReport received from this sender.
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.
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.
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.