#include <RTCP.h>
Public Member Functions | |
RTCP () | |
Protected Member Functions | |
virtual void | initialize () |
virtual | ~RTCP () |
virtual void | handleMessage (cMessage *msg) |
virtual void | handleMessageFromRTP (cMessage *msg) |
virtual void | handleMessageFromUDP (cMessage *msg) |
virtual void | handleSelfMessage (cMessage *msg) |
virtual void | initializeRTCP (RTPInnerPacket *rinp) |
virtual void | senderModuleInitialized (RTPInnerPacket *rinp) |
virtual void | dataOut (RTPInnerPacket *packet) |
virtual void | dataIn (RTPInnerPacket *rinp) |
virtual void | leaveSession (RTPInnerPacket *rinp) |
virtual void | connectRet () |
virtual void | readRet (cPacket *sifpIn) |
virtual void | createSocket () |
virtual void | chooseSSRC () |
virtual void | scheduleInterval () |
virtual void | createPacket () |
virtual void | processOutgoingRTPPacket (RTPPacket *packet) |
virtual void | processIncomingRTPPacket (RTPPacket *packet, IPAddress address, int port) |
virtual void | processIncomingRTCPPacket (RTCPCompoundPacket *packet, IPAddress address, int port) |
virtual RTPParticipantInfo * | findParticipantInfo (uint32 ssrc) |
virtual void | calculateAveragePacketSize (int size) |
Protected Attributes | |
int | _mtu |
int | _bandwidth |
int | _rtcpPercentage |
IPAddress | _destinationAddress |
int | _port |
bool | _ssrcChosen |
bool | _leaveSession |
RTPSenderInfo * | _senderInfo |
cArray * | _participantInfos |
int | _socketFdIn |
int | _socketFdOut |
int | _packetsCalculated |
double | _averagePacketSize |
cOutVector * | _rtcpIntervalOutVector |
RTCP::RTCP | ( | ) |
RTCP::~RTCP | ( | ) | [protected, virtual] |
void RTCP::initialize | ( | ) | [protected, virtual] |
Initializes variables.
00039 { 00040 00041 // initialize variables 00042 _ssrcChosen = false; 00043 _leaveSession = false; 00044 _socketFdIn = -1; 00045 _socketFdOut = -1; 00046 00047 _packetsCalculated = 0; 00048 _averagePacketSize = 0.0; 00049 00050 _participantInfos = new cArray("ParticipantInfos"); 00051 };
void RTCP::handleMessage | ( | cMessage * | msg | ) | [protected, virtual] |
Message handling. Dispatches messages by arrival gate.
00058 { 00059 00060 // first distinguish incoming messages by arrival gate 00061 if (msg->getArrivalGateId() == findGate("fromRTP")) { 00062 handleMessageFromRTP(msg); 00063 } 00064 else if (msg->getArrivalGateId() == findGate("fromUDP")) { 00065 handleMessageFromUDP(msg); 00066 } 00067 else { 00068 handleSelfMessage(msg); 00069 } 00070 00071 delete msg; 00072 };
void RTCP::handleMessageFromRTP | ( | cMessage * | msg | ) | [protected, virtual] |
Handles messages from the rtp module.
Referenced by handleMessage().
00078 { 00079 00080 // from the rtp module all messages are of type RTPInnerPacket 00081 RTPInnerPacket *rinp = (RTPInnerPacket *)msg; 00082 00083 // distinguish by type 00084 if (rinp->getType() == RTPInnerPacket::RTP_INP_INITIALIZE_RTCP) { 00085 initializeRTCP(rinp); 00086 } 00087 else if (rinp->getType() == RTPInnerPacket::RTP_INP_SENDER_MODULE_INITIALIZED) { 00088 senderModuleInitialized(rinp); 00089 } 00090 else if (rinp->getType() == RTPInnerPacket::RTP_INP_DATA_OUT) { 00091 dataOut(rinp); 00092 } 00093 else if (rinp->getType() == RTPInnerPacket::RTP_INP_DATA_IN) { 00094 dataIn(rinp); 00095 } 00096 else if (rinp->getType() == RTPInnerPacket::RTP_INP_LEAVE_SESSION) { 00097 leaveSession(rinp); 00098 } 00099 else { 00100 error("unknown RTPInnerPacket type"); 00101 } 00102 };
void RTCP::handleMessageFromUDP | ( | cMessage * | msg | ) | [protected, virtual] |
void RTCP::handleSelfMessage | ( | cMessage * | msg | ) | [protected, virtual] |
Handles self messages.
Referenced by handleMessage().
00111 { 00112 // it's time to create an rtcp packet 00113 if (!_ssrcChosen) { 00114 chooseSSRC(); 00115 RTPInnerPacket *rinp1 = new RTPInnerPacket("rtcpInitialized()"); 00116 rinp1->rtcpInitialized(_senderInfo->getSSRC()); 00117 send(rinp1, "toRTP"); 00118 } 00119 00120 createPacket(); 00121 00122 if (!_leaveSession) { 00123 scheduleInterval(); 00124 } 00125 };
void RTCP::initializeRTCP | ( | RTPInnerPacket * | rinp | ) | [protected, virtual] |
Initializes the rtcp module when the session is started.
Referenced by handleMessageFromRTP().
00132 { 00133 _mtu = rinp->getMTU(); 00134 _bandwidth = rinp->getBandwidth(); 00135 _rtcpPercentage = rinp->getRtcpPercentage(); 00136 _destinationAddress = rinp->getAddress(); 00137 _port = rinp->getPort(); 00138 00139 _senderInfo = new RTPSenderInfo(); 00140 00141 SDESItem *sdesItem = new SDESItem(SDESItem::SDES_CNAME, rinp->getCommonName()); 00142 _senderInfo->addSDESItem(sdesItem); 00143 00144 00145 // create server socket for receiving rtcp packets 00146 createSocket(); 00147 };
void RTCP::senderModuleInitialized | ( | RTPInnerPacket * | rinp | ) | [protected, virtual] |
Stores information about the new transmission.
Referenced by handleMessageFromRTP().
00151 { 00152 _senderInfo->setStartTime(simTime()); 00153 _senderInfo->setClockRate(rinp->getClockRate()); 00154 _senderInfo->setTimeStampBase(rinp->getTimeStampBase()); 00155 _senderInfo->setSequenceNumberBase(rinp->getSequenceNumberBase()); 00156 };
void RTCP::dataOut | ( | RTPInnerPacket * | packet | ) | [protected, virtual] |
Stores information about an outgoing rtp data packet.
Referenced by handleMessageFromRTP().
00160 { 00161 RTPPacket *rtpPacket = (RTPPacket *)(packet->decapsulate()); 00162 processOutgoingRTPPacket(rtpPacket); 00163 };
void RTCP::dataIn | ( | RTPInnerPacket * | rinp | ) | [protected, virtual] |
Stores information about an outgoing rtp data packet.
Referenced by handleMessageFromRTP().
00167 { 00168 RTPPacket *rtpPacket = (RTPPacket *)(rinp->decapsulate()); 00169 //rtpPacket->dump(); 00170 processIncomingRTPPacket(rtpPacket, rinp->getAddress(), rinp->getPort()); 00171 };
void RTCP::leaveSession | ( | RTPInnerPacket * | rinp | ) | [protected, virtual] |
Makes the rtcp module send an RTCPByePacket in the next RTCPCompoundPacket to tell other participants in the rtp session that this end system leaves.
Referenced by handleMessageFromRTP().
00175 { 00176 _leaveSession = true; 00177 };
void RTCP::connectRet | ( | ) | [protected, virtual] |
Called when the socket layer has finished a connect.
Referenced by createSocket().
00181 { 00182 // schedule first rtcp packet 00183 double intervalLength = 2.5 * (dblrand() + 0.5); 00184 cMessage *reminderMessage = new cMessage("Interval"); 00185 scheduleAt(simTime() + intervalLength, reminderMessage); 00186 };
void RTCP::readRet | ( | cPacket * | sifpIn | ) | [protected, virtual] |
Called when this rtcp module receives data from the socket layer.
Referenced by handleMessageFromUDP().
00190 { 00191 RTCPCompoundPacket *packet = (RTCPCompoundPacket *)(sifpIn->decapsulate()); 00192 processIncomingRTCPPacket(packet, IPAddress(_destinationAddress), _port); 00193 };
void RTCP::createSocket | ( | ) | [protected, virtual] |
Request a server socket from the socket layer.
Referenced by initializeRTCP().
00196 { 00197 // TODO UDPAppBase should be ported to use UDPSocket sometime, but for now 00198 // we just manage the UDP socket by hand... 00199 if (_socketFdIn == -1) { 00200 _socketFdIn = UDPSocket::generateSocketId(); 00201 UDPControlInfo *ctrl = new UDPControlInfo(); 00202 IPAddress ipaddr(_destinationAddress); 00203 00204 if (ipaddr.isMulticast()) { 00205 ctrl->setSrcAddr(IPAddress(_destinationAddress)); 00206 ctrl->setSrcPort(_port); 00207 } 00208 else { 00209 ctrl->setSrcPort(_port); 00210 ctrl->setSockId(_socketFdOut); 00211 } 00212 ctrl->setSockId((int)_socketFdIn); 00213 cMessage *msg = new cMessage("UDP_C_BIND", UDP_C_BIND); 00214 msg->setControlInfo(ctrl); 00215 send(msg,"toUDP"); 00216 00217 connectRet(); 00218 } 00219 };
void RTCP::chooseSSRC | ( | ) | [protected, virtual] |
Chooses the ssrc identifier for this end system.
Referenced by handleSelfMessage().
00243 { 00244 00245 uint32 ssrc = 0; 00246 bool ssrcConflict = false; 00247 do { 00248 ssrc = intrand(0x7fffffff); 00249 ssrcConflict = findParticipantInfo(ssrc) != NULL; 00250 } while (ssrcConflict); 00251 ev << "chooseSSRC" << ssrc; 00252 _senderInfo->setSSRC(ssrc); 00253 _participantInfos->add(_senderInfo); 00254 _ssrcChosen = true; 00255 };
void RTCP::scheduleInterval | ( | ) | [protected, virtual] |
Calculates the length of the next rtcp interval an issues a self message to remind itself.
Referenced by handleSelfMessage().
00222 { 00223 00224 simtime_t intervalLength = _averagePacketSize * (simtime_t)(_participantInfos->size()) / (simtime_t)(_bandwidth * _rtcpPercentage * (_senderInfo->isSender() ? 1.0 : 0.75) / 100.0); 00225 00226 00227 // interval length must be at least 5 seconds 00228 if (intervalLength < 5.0) 00229 intervalLength = 5.0; 00230 00231 00232 // to avoid rtcp packet bursts multiply calculated interval length 00233 // with a random number between 0.5 and 1.5 00234 intervalLength = intervalLength * (0.5 + dblrand()); 00235 00236 intervalLength /= (double) (2.71828-1.5); // [RFC 3550] , by Ahmed ayadi 00237 00238 cMessage *reminderMessage = new cMessage("Interval"); 00239 scheduleAt(simTime() + intervalLength, reminderMessage); 00240 };
void RTCP::createPacket | ( | ) | [protected, virtual] |
Creates and sends an RTCPCompoundPacket.
Referenced by handleSelfMessage().
00259 { 00260 // first packet in an rtcp compound packet must 00261 // be a sender or receiver report 00262 RTCPReceiverReportPacket *reportPacket; 00263 00264 // if this rtcp end system is a sender (see SenderInformation::isSender() for 00265 // details) insert a sender report 00266 if (_senderInfo->isSender()) { 00267 RTCPSenderReportPacket *senderReportPacket = new RTCPSenderReportPacket("SenderReportPacket"); 00268 senderReportPacket->setSenderReport(_senderInfo->senderReport(simTime())); 00269 reportPacket = senderReportPacket; 00270 } 00271 else 00272 reportPacket = new RTCPReceiverReportPacket("ReceiverReportPacket"); 00273 reportPacket->setSSRC(_senderInfo->getSSRC()); 00274 00275 00276 // insert receiver reports for packets from other sources 00277 for (int i = 0; i < _participantInfos->size(); i++) { 00278 00279 if (_participantInfos->exist(i)) { 00280 RTPParticipantInfo *participantInfo = (RTPParticipantInfo *)(_participantInfos->get(i)); 00281 if (participantInfo->getSSRC() != _senderInfo->getSSRC()) { 00282 ReceptionReport *report = ((RTPReceiverInfo *)participantInfo)->receptionReport(simTime()); 00283 if (report != NULL) { 00284 reportPacket->addReceptionReport(report); 00285 }; 00286 }; 00287 participantInfo->nextInterval(simTime()); 00288 00289 if (participantInfo->toBeDeleted(simTime())) { 00290 _participantInfos->remove(participantInfo); 00291 delete participantInfo; 00292 // perhaps inform the profile 00293 }; 00294 } 00295 }; 00296 // insert source description items (at least common name) 00297 RTCPSDESPacket *sdesPacket = new RTCPSDESPacket("SDESPacket"); 00298 00299 SDESChunk *chunk = _senderInfo->getSDESChunk(); 00300 sdesPacket->addSDESChunk(chunk); 00301 00302 RTCPCompoundPacket *compoundPacket = new RTCPCompoundPacket("RTCPCompoundPacket"); 00303 00304 compoundPacket->addRTCPPacket(reportPacket); 00305 compoundPacket->addRTCPPacket(sdesPacket); 00306 00307 // create rtcp app/bye packets if needed 00308 if (_leaveSession) { 00309 RTCPByePacket *byePacket = new RTCPByePacket("ByePacket"); 00310 byePacket->setSSRC(_senderInfo->getSSRC()); 00311 compoundPacket->addRTCPPacket(byePacket); 00312 }; 00313 00314 calculateAveragePacketSize(compoundPacket->getByteLength()); 00315 00316 cPacket *msg = new cPacket("RTCPCompoundPacket"); 00317 msg->encapsulate(compoundPacket); 00318 msg->setKind(UDP_C_DATA); 00319 UDPControlInfo *ctrl = new UDPControlInfo(); 00320 ctrl->setSockId(_socketFdOut); 00321 ctrl->setDestAddr(_destinationAddress); 00322 ctrl->setDestPort(_port); 00323 msg->setControlInfo(ctrl); 00324 00325 send(msg, "toUDP"); 00326 00327 if (_leaveSession) { 00328 RTPInnerPacket *rinp = new RTPInnerPacket("sessionLeft()"); 00329 rinp->sessionLeft(); 00330 send(rinp, "toRTP"); 00331 }; 00332 };
void RTCP::processOutgoingRTPPacket | ( | RTPPacket * | packet | ) | [protected, virtual] |
Extracts information of a sent RTPPacket.
Referenced by dataOut().
00336 { 00337 _senderInfo->processRTPPacket(packet, getId(), simTime()); 00338 };
void RTCP::processIncomingRTPPacket | ( | RTPPacket * | packet, | |
IPAddress | address, | |||
int | port | |||
) | [protected, virtual] |
Extracts information of a received RTPPacket.
Referenced by dataIn().
00341 { 00342 uint32 ssrc = packet->getSSRC(); 00343 RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc); 00344 if (participantInfo == NULL) { 00345 participantInfo = new RTPParticipantInfo(ssrc); 00346 participantInfo->setAddress(address); 00347 participantInfo->setRTPPort(port); 00348 _participantInfos->add(participantInfo); 00349 } 00350 else { 00351 // check for ssrc conflict 00352 if (participantInfo->getAddress() != address) { 00353 // we have an address conflict 00354 } 00355 if (participantInfo->getRTPPort() == PORT_UNDEF) { 00356 participantInfo->setRTPPort(port); 00357 } 00358 else if (participantInfo->getRTPPort() != port) { 00359 // we have an rtp port conflict 00360 } 00361 } 00362 participantInfo->processRTPPacket(packet, getId(), packet->getArrivalTime()); 00363 };
void RTCP::processIncomingRTCPPacket | ( | RTCPCompoundPacket * | packet, | |
IPAddress | address, | |||
int | port | |||
) | [protected, virtual] |
Extracts information of a received RTCPCompoundPacket.
Referenced by readRet().
00367 { 00368 calculateAveragePacketSize(packet->getByteLength()); 00369 cArray *rtcpPackets = packet->getRtcpPackets(); 00370 00371 simtime_t arrivalTime = packet->getArrivalTime(); 00372 delete packet; 00373 00374 for (int i = 0; i < rtcpPackets->size(); i++) { 00375 if (rtcpPackets->exist(i)) { 00376 // remove the rtcp packet from the rtcp compound packet 00377 RTCPPacket *rtcpPacket = (RTCPPacket *)(rtcpPackets->remove(i)); 00378 if (rtcpPacket->getPacketType() == RTCPPacket::RTCP_PT_SR) { 00379 RTCPSenderReportPacket *rtcpSenderReportPacket = (RTCPSenderReportPacket *)rtcpPacket; 00380 uint32 ssrc = rtcpSenderReportPacket->getSSRC(); 00381 RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc); 00382 00383 if (participantInfo == NULL) { 00384 participantInfo = new RTPReceiverInfo(ssrc); 00385 participantInfo->setAddress(address); 00386 participantInfo->setRTCPPort(port); 00387 _participantInfos->add(participantInfo); 00388 } 00389 else { 00390 if (participantInfo->getAddress() == address) { 00391 if (participantInfo->getRTCPPort() == PORT_UNDEF) { 00392 participantInfo->setRTCPPort(port); 00393 } 00394 else { 00395 // check for ssrc conflict 00396 } 00397 } 00398 else { 00399 // check for ssrc conflict 00400 }; 00401 } 00402 participantInfo->processSenderReport(rtcpSenderReportPacket->getSenderReport(), simTime()); 00403 00404 cArray *receptionReports = rtcpSenderReportPacket->getReceptionReports(); 00405 for (int j = 0; j < receptionReports->size(); j++) { 00406 if (receptionReports->exist(j)) { 00407 ReceptionReport *receptionReport = (ReceptionReport *)(receptionReports->remove(j)); 00408 if (_senderInfo) { 00409 if (receptionReport->getSSRC() == _senderInfo->getSSRC()) { 00410 _senderInfo->processReceptionReport(receptionReport, simTime()); 00411 } 00412 } 00413 else 00414 //cancelAndDelete(receptionReport); 00415 delete receptionReport; 00416 } 00417 }; 00418 delete receptionReports; 00419 00420 } 00421 else if (rtcpPacket->getPacketType() == RTCPPacket::RTCP_PT_RR) { 00422 RTCPReceiverReportPacket *rtcpReceiverReportPacket = (RTCPReceiverReportPacket *)rtcpPacket; 00423 uint32 ssrc = rtcpReceiverReportPacket->getSSRC(); 00424 RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc); 00425 if (participantInfo == NULL) { 00426 participantInfo = new RTPReceiverInfo(ssrc); 00427 participantInfo->setAddress(address); 00428 participantInfo->setRTCPPort(port); 00429 _participantInfos->add(participantInfo); 00430 } 00431 else { 00432 if (participantInfo->getAddress() == address) { 00433 if (participantInfo->getRTCPPort() == PORT_UNDEF) { 00434 participantInfo->setRTCPPort(port); 00435 } 00436 else { 00437 // check for ssrc conflict 00438 } 00439 } 00440 else { 00441 // check for ssrc conflict 00442 }; 00443 } 00444 00445 cArray *receptionReports = rtcpReceiverReportPacket->getReceptionReports(); 00446 for (int j = 0; j < receptionReports->size(); j++) { 00447 if (receptionReports->exist(j)) { 00448 ReceptionReport *receptionReport = (ReceptionReport *)(receptionReports->remove(j)); 00449 if (_senderInfo) { 00450 00451 if (receptionReport->getSSRC() == _senderInfo->getSSRC()) { 00452 _senderInfo->processReceptionReport(receptionReport, simTime()); 00453 } 00454 } 00455 00456 else 00457 //cancelAndDelete(receptionReport); 00458 delete receptionReport; 00459 } 00460 }; 00461 delete receptionReports; 00462 } 00463 else if (rtcpPacket->getPacketType() == RTCPPacket::RTCP_PT_SDES) { 00464 RTCPSDESPacket *rtcpSDESPacket = (RTCPSDESPacket *)rtcpPacket; 00465 cArray *sdesChunks = rtcpSDESPacket->getSdesChunks(); 00466 00467 for (int j = 0; j < sdesChunks->size(); j++) { 00468 if (sdesChunks->exist(j)) { 00469 // remove the sdes chunk from the cArray of sdes chunks 00470 SDESChunk *sdesChunk = (SDESChunk *)(sdesChunks->remove(j)); 00471 // this is needed to avoid seg faults 00472 //sdesChunk->setOwner(this); 00473 uint32 ssrc = sdesChunk->getSSRC(); 00474 RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc); 00475 if (participantInfo == NULL) { 00476 participantInfo = new RTPReceiverInfo(ssrc); 00477 participantInfo->setAddress(address); 00478 participantInfo->setRTCPPort(port); 00479 _participantInfos->add(participantInfo); 00480 } 00481 else { 00482 // check for ssrc conflict 00483 } 00484 participantInfo->processSDESChunk(sdesChunk, arrivalTime); 00485 } 00486 } 00487 delete sdesChunks; 00488 00489 } 00490 else if (rtcpPacket->getPacketType() == RTCPPacket::RTCP_PT_BYE) { 00491 RTCPByePacket *rtcpByePacket = (RTCPByePacket *)rtcpPacket; 00492 uint32 ssrc = rtcpByePacket->getSSRC(); 00493 RTPParticipantInfo *participantInfo = findParticipantInfo(ssrc); 00494 00495 if (participantInfo != NULL && participantInfo != _senderInfo) { 00496 _participantInfos->remove(participantInfo); 00497 00498 delete participantInfo; 00499 // perhaps it would be useful to inform 00500 // the profile to remove the corresponding 00501 // receiver module 00502 }; 00503 } 00504 else { 00505 // app rtcp packets 00506 } 00507 delete rtcpPacket; 00508 } 00509 } 00510 delete rtcpPackets; 00511 };
RTPParticipantInfo * RTCP::findParticipantInfo | ( | uint32 | ssrc | ) | [protected, virtual] |
Returns the RTPParticipantInfo object used for storing information about the rtp end system with this ssrc identifier. Returns NULL if this end system is unknown.
Referenced by chooseSSRC(), processIncomingRTCPPacket(), and processIncomingRTPPacket().
00514 { 00515 char *ssrcString = RTPParticipantInfo::ssrcToName(ssrc); 00516 int participantIndex = _participantInfos->find(ssrcString); 00517 if (participantIndex != -1) { 00518 return (RTPParticipantInfo *)(_participantInfos->get(participantIndex)); 00519 } 00520 else { 00521 return NULL; 00522 }; 00523 };
void RTCP::calculateAveragePacketSize | ( | int | size | ) | [protected, virtual] |
Recalculates the average size of an RTCPCompoundPacket when one of this size has been sent or received.
Referenced by createPacket(), and processIncomingRTCPPacket().
00526 { 00527 // add size of ip and udp header to given size before calculating 00528 _averagePacketSize = ((double)(_packetsCalculated) * _averagePacketSize + (double)(size + 20 + 8)) / (double)(++_packetsCalculated); 00529 };
int RTCP::_mtu [protected] |
The maximum size an RTCPCompundPacket can have.
Referenced by initializeRTCP().
int RTCP::_bandwidth [protected] |
The bandwidth for this rtp session.
Referenced by initializeRTCP(), and scheduleInterval().
int RTCP::_rtcpPercentage [protected] |
The percentage of bandwidth for rtcp.
Referenced by initializeRTCP(), and scheduleInterval().
IPAddress RTCP::_destinationAddress [protected] |
The destination address.
Referenced by createPacket(), createSocket(), initializeRTCP(), and readRet().
int RTCP::_port [protected] |
The rtcp port.
Referenced by createPacket(), createSocket(), initializeRTCP(), and readRet().
bool RTCP::_ssrcChosen [protected] |
True when this end system has chosen its ssrc identifier.
Referenced by chooseSSRC(), handleSelfMessage(), and initialize().
bool RTCP::_leaveSession [protected] |
True when this end system is about to leave the session.
Referenced by createPacket(), handleSelfMessage(), initialize(), and leaveSession().
RTPSenderInfo* RTCP::_senderInfo [protected] |
The RTPSenderInfo about this end system.
Referenced by chooseSSRC(), createPacket(), handleSelfMessage(), initializeRTCP(), processIncomingRTCPPacket(), processOutgoingRTPPacket(), scheduleInterval(), and senderModuleInitialized().
cArray* RTCP::_participantInfos [protected] |
Information about all known rtp end system participating in this rtp session.
Referenced by chooseSSRC(), createPacket(), findParticipantInfo(), initialize(), processIncomingRTCPPacket(), processIncomingRTPPacket(), RTCP(), scheduleInterval(), and ~RTCP().
int RTCP::_socketFdIn [protected] |
The server socket for receiving rtcp packets.
Referenced by createSocket(), and initialize().
int RTCP::_socketFdOut [protected] |
The client socket for sending rtcp packets.
Referenced by createPacket(), createSocket(), and initialize().
int RTCP::_packetsCalculated [protected] |
The number of packets this rtcp module has calculated.
Referenced by calculateAveragePacketSize(), and initialize().
double RTCP::_averagePacketSize [protected] |
The average size of an RTCPCompoundPacket.
Referenced by calculateAveragePacketSize(), initialize(), and scheduleInterval().
cOutVector* RTCP::_rtcpIntervalOutVector [protected] |
The output vector for statistical data about the behaviour of rtcp. Every participant's rtcp module writes its calculated rtcp interval (without variation