RTCP Class Reference

#include <RTCP.h>

List of all members.


Detailed Description

The class RTCP is responsible for creating, receiving and processing of rtcp packets. It also keeps track of this and other rtp end systems.

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 RTPParticipantInfofindParticipantInfo (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

Constructor & Destructor Documentation

RTCP::RTCP (  ) 

00035            {
00036     _participantInfos = NULL;
00037 }

RTCP::~RTCP (  )  [protected, virtual]

00054 {
00055     delete _participantInfos;
00056 }


Member Function Documentation

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]

Handles messages coming from the socket layer.

Referenced by handleMessage().

00105                                              {
00106     // from SocketLayer all message are of type cMessage
00107     readRet(PK(msg));
00108 };

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().

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


Member Data Documentation

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().

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().

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]

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


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

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