RTCPInstance Class Reference

#include <RTCP.hh>

Inheritance diagram for RTCPInstance:

[legend]Collaboration diagram for RTCPInstance:


Public Member Functions
unsigned	numMembers () const
unsigned	totSessionBW () const
void	setByeHandler (TaskFunc handlerTask, void clientData, Boolean handleActiveParticipantsOnly=True)
void	setSRHandler (TaskFunc handlerTask, void clientData)
void	setRRHandler (TaskFunc handlerTask, void clientData)
void	setSpecificRRHandler (netAddressBits fromAddress, Port fromPort, TaskFunc handlerTask, void clientData)
void	unsetSpecificRRHandler (netAddressBits fromAddress, Port fromPort)
Groupsock *	RTCPgs () const
void	setStreamSocket (int sockNum, unsigned char streamChannelId)
void	addStreamSocket (int sockNum, unsigned char streamChannelId)
void	removeStreamSocket (int sockNum, unsigned char streamChannelId)
void	setAuxilliaryReadHandler (AuxHandlerFunc handlerFunc, void handlerClientData)
void	schedule (double nextTime)
void	reschedule (double nextTime)
void	sendReport ()
void	sendBYE ()
int	typeOfEvent ()
int	sentPacketSize ()
int	packetType ()
int	receivedPacketSize ()
int	checkNewSSRC ()
void	removeLastReceivedSSRC ()
void	removeSSRC (u_int32_t ssrc, Boolean alsoRemoveStats)
UsageEnvironment &	envir () const
char const *	name () const
virtual Boolean	isSource () const
virtual Boolean	isSink () const
virtual Boolean	isRTSPClient () const
virtual Boolean	isRTSPServer () const
virtual Boolean	isMediaSession () const
virtual Boolean	isServerMediaSession () const
virtual Boolean	isDarwinInjector () const
Static Public Member Functions
static RTCPInstance *	createNew (UsageEnvironment &env, Groupsock RTCPgs, unsigned totSessionBW, unsigned char const cname, RTPSink sink, RTPSource const source, Boolean isSSMSource=False)
static Boolean	lookupByName (UsageEnvironment &env, char const instanceName, RTCPInstance &resultInstance)
static Boolean	lookupByName (UsageEnvironment &env, char const mediumName, Medium &resultMedium)
static void	close (UsageEnvironment &env, char const *mediumName)
static void	close (Medium *medium)
Protected Member Functions
	RTCPInstance (UsageEnvironment &env, Groupsock RTPgs, unsigned totSessionBW, unsigned char const cname, RTPSink sink, RTPSource const source, Boolean isSSMSource)
virtual	~RTCPInstance ()
TaskToken &	nextTask ()
Private Member Functions
virtual Boolean	isRTCPInstance () const
void	addReport ()
void	addSR ()
void	addRR ()
void	enqueueCommonReportPrefix (unsigned char packetType, u_int32_t SSRC, unsigned numExtraWords=0)
void	enqueueCommonReportSuffix ()
void	enqueueReportBlock (RTPReceptionStats *receptionStats)
void	addSDES ()
void	addBYE ()
void	sendBuiltPacket ()
void	onExpire1 ()
void	incomingReportHandler1 ()
void	onReceive (int typeOfPacket, int totPacketSize, u_int32_t ssrc)
Static Private Member Functions
static void	onExpire (RTCPInstance *instance)
static void	incomingReportHandler (RTCPInstance *instance, int)
Private Attributes
unsigned char *	fInBuf
unsigned	fNumBytesAlreadyRead
OutPacketBuffer *	fOutBuf
RTPInterface	fRTCPInterface
unsigned	fTotSessionBW
RTPSink *	fSink
RTPSource const *	fSource
Boolean	fIsSSMSource
SDESItem	fCNAME
RTCPMemberDatabase *	fKnownMembers
unsigned	fOutgoingReportCount
double	fAveRTCPSize
int	fIsInitial
double	fPrevReportTime
double	fNextReportTime
int	fPrevNumMembers
int	fLastSentSize
int	fLastReceivedSize
u_int32_t	fLastReceivedSSRC
int	fTypeOfEvent
int	fTypeOfPacket
Boolean	fHaveJustSentPacket
unsigned	fLastPacketSentSize
TaskFunc *	fByeHandlerTask
void *	fByeHandlerClientData
Boolean	fByeHandleActiveParticipantsOnly
TaskFunc *	fSRHandlerTask
void *	fSRHandlerClientData
TaskFunc *	fRRHandlerTask
void *	fRRHandlerClientData
AddressPortLookupTable *	fSpecificRRHandlerTable
Friends
class	MediaLookupTable

Detailed Description

Definition at line 44 of file RTCP.hh.

Constructor & Destructor Documentation

RTCPInstance::RTCPInstance	(	UsageEnvironment &	env,
		Groupsock *	RTPgs,
		unsigned	totSessionBW,
		unsigned char const *	cname,
		RTPSink *	sink,
		RTPSource const *	source,
		Boolean	isSSMSource
	)			`[protected]`

Definition at line 120 of file RTCP.cpp.

References dTimeNow(), env, EVENT_REPORT, fInBuf, fKnownMembers, fNextReportTime, fNumBytesAlreadyRead, fOutBuf, fPrevReportTime, fRTCPInterface, fTotSessionBW, fTypeOfEvent, incomingReportHandler(), maxPacketSize, OutPacketBuffer::maxSize, Groupsock::multicastSendOnly(), NULL, onExpire(), preferredPacketSize, RTCPgs(), and RTPInterface::startNetworkReading().

Referenced by createNew().

00125   : Medium(env), fRTCPInterface(this, RTCPgs), fTotSessionBW(totSessionBW),
00126     fSink(sink), fSource(source), fIsSSMSource(isSSMSource),
00127     fCNAME(RTCP_SDES_CNAME, cname), fOutgoingReportCount(1),
00128     fAveRTCPSize(0), fIsInitial(1), fPrevNumMembers(0),
00129     fLastSentSize(0), fLastReceivedSize(0), fLastReceivedSSRC(0),
00130     fTypeOfEvent(EVENT_UNKNOWN), fTypeOfPacket(PACKET_UNKNOWN_TYPE),
00131     fHaveJustSentPacket(False), fLastPacketSentSize(0),
00132     fByeHandlerTask(NULL), fByeHandlerClientData(NULL),
00133     fSRHandlerTask(NULL), fSRHandlerClientData(NULL),
00134     fRRHandlerTask(NULL), fRRHandlerClientData(NULL),
00135     fSpecificRRHandlerTable(NULL) {
00136 #ifdef DEBUG
00137   fprintf(stderr, "RTCPInstance[%p]::RTCPInstance()\n", this);
00138 #endif
00139   if (fTotSessionBW == 0) { // not allowed!
00140     env << "RTCPInstance::RTCPInstance error: totSessionBW parameter should not be zero!\n";
00141     fTotSessionBW = 1;
00142   }
00143 
00144   if (isSSMSource) RTCPgs->multicastSendOnly(); // don't receive multicast
00145 
00146   double timeNow = dTimeNow();
00147   fPrevReportTime = fNextReportTime = timeNow;
00148 
00149   fKnownMembers = new RTCPMemberDatabase(*this);
00150   fInBuf = new unsigned char[maxPacketSize];
00151   if (fKnownMembers == NULL || fInBuf == NULL) return;
00152   fNumBytesAlreadyRead = 0;
00153 
00154   // A hack to save buffer space, because RTCP packets are always small:
00155   unsigned savedMaxSize = OutPacketBuffer::maxSize;
00156   OutPacketBuffer::maxSize = maxPacketSize;
00157   fOutBuf = new OutPacketBuffer(preferredPacketSize, maxPacketSize);
00158   OutPacketBuffer::maxSize = savedMaxSize;
00159   if (fOutBuf == NULL) return;
00160 
00161   // Arrange to handle incoming reports from others:
00162   TaskScheduler::BackgroundHandlerProc* handler
00163     = (TaskScheduler::BackgroundHandlerProc*)&incomingReportHandler;
00164   fRTCPInterface.startNetworkReading(handler);
00165 
00166   // Send our first report.
00167   fTypeOfEvent = EVENT_REPORT;
00168   onExpire(this);
00169 }

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

Definition at line 176 of file RTCP.cpp.

References EVENT_BYE, fInBuf, fKnownMembers, fOutBuf, fRTCPInterface, fSpecificRRHandlerTable, fTypeOfEvent, iter, MediaSubsessionIterator::next(), NULL, sendBYE(), and RTPInterface::stopNetworkReading().

00176                             {
00177 #ifdef DEBUG
00178   fprintf(stderr, "RTCPInstance[%p]::~RTCPInstance()\n", this);
00179 #endif
00180   // Turn off background read handling:
00181   fRTCPInterface.stopNetworkReading();
00182 
00183   // Begin by sending a BYE.  We have to do this immediately, without
00184   // 'reconsideration', because "this" is going away.
00185   fTypeOfEvent = EVENT_BYE; // not used, but...
00186   sendBYE();
00187 
00188   if (fSpecificRRHandlerTable != NULL) {
00189     AddressPortLookupTable::Iterator iter(*fSpecificRRHandlerTable);
00190     RRHandlerRecord* rrHandler;
00191     while ((rrHandler = (RRHandlerRecord*)iter.next()) != NULL) {
00192       delete rrHandler;
00193     }
00194     delete fSpecificRRHandlerTable;
00195   }
00196 
00197   delete fKnownMembers;
00198   delete fOutBuf;
00199   delete[] fInBuf;
00200 }

Member Function Documentation

RTCPInstance * RTCPInstance::createNew	(	UsageEnvironment &	env,
		Groupsock *	RTCPgs,
		unsigned	totSessionBW,
		unsigned char const *	cname,
		RTPSink *	sink,
		RTPSource const *	source,
		Boolean	isSSMSource = `False`
	)			`[static]`

Definition at line 202 of file RTCP.cpp.

References env, RTCPgs(), and RTCPInstance().

Referenced by MediaSubsession::initiate(), main(), and StreamState::startPlaying().

00206                                                            {
00207   return new RTCPInstance(env, RTCPgs, totSessionBW, cname, sink, source,
00208                           isSSMSource);
00209 }

Boolean RTCPInstance::lookupByName	(	UsageEnvironment &	env,
		char const *	instanceName,
		RTCPInstance *&	resultInstance
	)			`[static]`

Definition at line 211 of file RTCP.cpp.

References env, False, Medium::isRTCPInstance(), Medium::lookupByName(), NULL, and True.

00213                                                                   {
00214   resultInstance = NULL; // unless we succeed
00215 
00216   Medium* medium;
00217   if (!Medium::lookupByName(env, instanceName, medium)) return False;
00218 
00219   if (!medium->isRTCPInstance()) {
00220     env.setResultMsg(instanceName, " is not a RTCP instance");
00221     return False;
00222   }
00223 
00224   resultInstance = (RTCPInstance*)medium;
00225   return True;
00226 }

unsigned RTCPInstance::numMembers ( ) const

Definition at line 232 of file RTCP.cpp.

References fKnownMembers, NULL, and RTCPMemberDatabase::numMembers().

Referenced by onExpire1().

00232                                         {
00233   if (fKnownMembers == NULL) return 0;
00234 
00235   return fKnownMembers->numMembers();
00236 }

unsigned RTCPInstance::totSessionBW ( ) const [inline]

Definition at line 57 of file RTCP.hh.

References fTotSessionBW.

Referenced by PassiveServerMediaSubsession::sdpLines(), and PassiveServerMediaSubsession::startStream().

00057 { return fTotSessionBW; }

void RTCPInstance::setByeHandler	(	TaskFunc *	handlerTask,
		void *	clientData,
		Boolean	handleActiveParticipantsOnly = `True`
	)

Definition at line 238 of file RTCP.cpp.

References fByeHandleActiveParticipantsOnly, fByeHandlerClientData, and fByeHandlerTask.

Referenced by AVIFileSink::AVIFileSink(), QuickTimeFileSink::QuickTimeFileSink(), setupStreams(), and shutdownStream().

00239                                                                        {
00240   fByeHandlerTask = handlerTask;
00241   fByeHandlerClientData = clientData;
00242   fByeHandleActiveParticipantsOnly = handleActiveParticipantsOnly;
00243 }

void RTCPInstance::setSRHandler	(	TaskFunc *	handlerTask,
		void *	clientData
	)

Definition at line 245 of file RTCP.cpp.

References fSRHandlerClientData, and fSRHandlerTask.

00245                                                                        {
00246   fSRHandlerTask = handlerTask;
00247   fSRHandlerClientData = clientData;
00248 }

void RTCPInstance::setRRHandler	(	TaskFunc *	handlerTask,
		void *	clientData
	)

Definition at line 250 of file RTCP.cpp.

References fRRHandlerClientData, and fRRHandlerTask.

00250                                                                        {
00251   fRRHandlerTask = handlerTask;
00252   fRRHandlerClientData = clientData;
00253 }

void RTCPInstance::setSpecificRRHandler	(	netAddressBits	fromAddress,
		Port	fromPort,
		TaskFunc *	handlerTask,
		void *	clientData
	)

Definition at line 256 of file RTCP.cpp.

References AddressPortLookupTable::Add(), fSpecificRRHandlerTable, NULL, RRHandlerRecord::rrHandlerClientData, RRHandlerRecord::rrHandlerTask, and unsetSpecificRRHandler().

Referenced by StreamState::startPlaying(), and PassiveServerMediaSubsession::startStream().

00257                                                                 {
00258   if (handlerTask == NULL && clientData == NULL) {
00259     unsetSpecificRRHandler(fromAddress, fromPort);
00260     return;
00261   }
00262 
00263   RRHandlerRecord* rrHandler = new RRHandlerRecord;
00264   rrHandler->rrHandlerTask = handlerTask;
00265   rrHandler->rrHandlerClientData = clientData;
00266   if (fSpecificRRHandlerTable == NULL) {
00267     fSpecificRRHandlerTable = new AddressPortLookupTable;
00268   }
00269   fSpecificRRHandlerTable->Add(fromAddress, (~0), fromPort, rrHandler);
00270 }

void RTCPInstance::unsetSpecificRRHandler	(	netAddressBits	fromAddress,
		Port	fromPort
	)

Definition at line 273 of file RTCP.cpp.

References fSpecificRRHandlerTable, AddressPortLookupTable::Lookup(), NULL, and AddressPortLookupTable::Remove().

Referenced by PassiveServerMediaSubsession::deleteStream(), StreamState::endPlaying(), and setSpecificRRHandler().

00273                                                                   {
00274   if (fSpecificRRHandlerTable == NULL) return;
00275 
00276   RRHandlerRecord* rrHandler
00277     = (RRHandlerRecord*)(fSpecificRRHandlerTable->Lookup(fromAddress, (~0), fromPort));
00278   if (rrHandler != NULL) {
00279     fSpecificRRHandlerTable->Remove(fromAddress, (~0), fromPort);
00280     delete rrHandler;
00281   }
00282 }

Groupsock* RTCPInstance::RTCPgs ( ) const [inline]

Definition at line 84 of file RTCP.hh.

References fRTCPInterface, and RTPInterface::gs().

Referenced by createNew(), PassiveServerMediaSubsession::getStreamParameters(), incomingReportHandler1(), and RTCPInstance().

00084 { return fRTCPInterface.gs(); }

void RTCPInstance::setStreamSocket	(	int	sockNum,
		unsigned char	streamChannelId
	)

Definition at line 284 of file RTCP.cpp.

References fRTCPInterface, incomingReportHandler(), RTPInterface::setStreamSocket(), RTPInterface::startNetworkReading(), and RTPInterface::stopNetworkReading().

Referenced by RTSPClient::handleSETUPResponse(), and DarwinInjector::setDestination().

00285                                                                   {
00286   // Turn off background read handling:
00287   fRTCPInterface.stopNetworkReading();
00288 
00289   // Switch to RTCP-over-TCP:
00290   fRTCPInterface.setStreamSocket(sockNum, streamChannelId);
00291 
00292   // Turn background reading back on:
00293   TaskScheduler::BackgroundHandlerProc* handler
00294     = (TaskScheduler::BackgroundHandlerProc*)&incomingReportHandler;
00295   fRTCPInterface.startNetworkReading(handler);
00296 }

void RTCPInstance::addStreamSocket	(	int	sockNum,
		unsigned char	streamChannelId
	)

Definition at line 298 of file RTCP.cpp.

References RTPInterface::addStreamSocket(), Medium::envir(), fRTCPInterface, RTPInterface::gs(), incomingReportHandler(), Socket::socketNum(), RTPInterface::startNetworkReading(), UsageEnvironment::taskScheduler(), and TaskScheduler::turnOffBackgroundReadHandling().

Referenced by StreamState::startPlaying().

00299                                                                   {
00300   // First, turn off background read handling for the default (UDP) socket:
00301   envir().taskScheduler().turnOffBackgroundReadHandling(fRTCPInterface.gs()->socketNum());
00302 
00303   // Add the RTCP-over-TCP interface:
00304   fRTCPInterface.addStreamSocket(sockNum, streamChannelId);
00305 
00306   // Turn on background reading for this socket (in case it's not on already):
00307   TaskScheduler::BackgroundHandlerProc* handler
00308     = (TaskScheduler::BackgroundHandlerProc*)&incomingReportHandler;
00309   fRTCPInterface.startNetworkReading(handler);
00310 }

void RTCPInstance::removeStreamSocket	(	int	sockNum,
		unsigned char	streamChannelId
	)			`[inline]`

Definition at line 88 of file RTCP.hh.

References fRTCPInterface, and RTPInterface::removeStreamSocket().

Referenced by StreamState::endPlaying().

00088                                                                       {
00089     fRTCPInterface.removeStreamSocket(sockNum, streamChannelId);
00090   }

void RTCPInstance::setAuxilliaryReadHandler	(	AuxHandlerFunc *	handlerFunc,
		void *	handlerClientData
	)			`[inline]`

Definition at line 93 of file RTCP.hh.

References fRTCPInterface, and RTPInterface::setAuxilliaryReadHandler().

00094                                                          {
00095     fRTCPInterface.setAuxilliaryReadHandler(handlerFunc,
00096                                             handlerClientData);
00097   }

Boolean RTCPInstance::isRTCPInstance ( ) const [private, virtual]

Reimplemented from Medium.

Definition at line 228 of file RTCP.cpp.

References True.

00228                                            {
00229   return True;
00230 }

void RTCPInstance::addReport ( ) [private]

Definition at line 694 of file RTCP.cpp.

References addRR(), addSR(), fSink, fSource, and NULL.

Referenced by sendBYE(), and sendReport().

00694                              {
00695   // Include a SR or a RR, depending on whether we
00696   // have an associated sink or source:
00697   if (fSink != NULL) {
00698     addSR();
00699   } else if (fSource != NULL) {
00700     addRR();
00701   }
00702 }

void RTCPInstance::addSR ( ) [private]

Definition at line 704 of file RTCP.cpp.

References RTPSink::convertToRTPTimestamp(), enqueueCommonReportPrefix(), enqueueCommonReportSuffix(), OutPacketBuffer::enqueueWord(), fOutBuf, fSink, NULL, RTPSink::octetCount(), RTPSink::packetCount(), RTCP_PT_SR, and RTPSink::SSRC().

Referenced by addReport().

00704                          {
00705   // ASSERT: fSink != NULL
00706 
00707   enqueueCommonReportPrefix(RTCP_PT_SR, fSink->SSRC(),
00708                             5 /* extra words in a SR */);
00709 
00710   // Now, add the 'sender info' for our sink
00711 
00712   // Insert the NTP and RTP timestamps for the 'wallclock time':
00713   struct timeval timeNow;
00714   gettimeofday(&timeNow, NULL);
00715   fOutBuf->enqueueWord(timeNow.tv_sec + 0x83AA7E80);
00716       // NTP timestamp most-significant word (1970 epoch -> 1900 epoch)
00717   double fractionalPart = (timeNow.tv_usec/15625.0)*0x04000000; // 2^32/10^6
00718   fOutBuf->enqueueWord((unsigned)(fractionalPart+0.5));
00719       // NTP timestamp least-significant word
00720   unsigned rtpTimestamp = fSink->convertToRTPTimestamp(timeNow);
00721   fOutBuf->enqueueWord(rtpTimestamp); // RTP ts
00722 
00723   // Insert the packet and byte counts:
00724   fOutBuf->enqueueWord(fSink->packetCount());
00725   fOutBuf->enqueueWord(fSink->octetCount());
00726 
00727   enqueueCommonReportSuffix();
00728 }

void RTCPInstance::addRR ( ) [private]

Definition at line 730 of file RTCP.cpp.

References enqueueCommonReportPrefix(), enqueueCommonReportSuffix(), fSource, RTCP_PT_RR, and RTPSource::SSRC().

Referenced by addReport().

00730                          {
00731   // ASSERT: fSource != NULL
00732 
00733   enqueueCommonReportPrefix(RTCP_PT_RR, fSource->SSRC());
00734   enqueueCommonReportSuffix();
00735 }

void RTCPInstance::enqueueCommonReportPrefix	(	unsigned char	packetType,
		u_int32_t	SSRC,
		unsigned	numExtraWords = `0`
	)			`[private]`

Referenced by addRR(), and addSR().

void RTCPInstance::enqueueCommonReportSuffix ( ) [private]

Definition at line 762 of file RTCP.cpp.

References enqueueReportBlock(), fSource, RTPReceptionStatsDB::Iterator::next(), NULL, RTPSource::receptionStatsDB(), and RTPReceptionStatsDB::reset().

Referenced by addRR(), and addSR().

00762                                              {
00763   // Output the report blocks for each source:
00764   if (fSource != NULL) {
00765     RTPReceptionStatsDB& allReceptionStats
00766       = fSource->receptionStatsDB();
00767 
00768     RTPReceptionStatsDB::Iterator iterator(allReceptionStats);
00769     while (1) {
00770       RTPReceptionStats* receptionStats = iterator.next();
00771       if (receptionStats == NULL) break;
00772       enqueueReportBlock(receptionStats);
00773     }
00774 
00775     allReceptionStats.reset(); // because we have just generated a report
00776   }
00777 }

void RTCPInstance::enqueueReportBlock ( RTPReceptionStats * receptionStats ) [private]

Definition at line 780 of file RTCP.cpp.

References RTPReceptionStats::baseExtSeqNumReceived(), OutPacketBuffer::enqueueWord(), fOutBuf, RTPReceptionStats::highestExtSeqNumReceived(), RTPReceptionStats::jitter(), RTPReceptionStats::lastReceivedSR_NTPlsw(), RTPReceptionStats::lastReceivedSR_NTPmsw(), RTPReceptionStats::lastReceivedSR_time(), RTPReceptionStats::lastResetExtSeqNumReceived(), NULL, RTPReceptionStats::numPacketsReceivedSinceLastReset(), RTPReceptionStats::SSRC(), and RTPReceptionStats::totNumPacketsReceived().

Referenced by enqueueCommonReportSuffix().

00780                                                          {
00781   fOutBuf->enqueueWord(stats->SSRC());
00782 
00783   unsigned highestExtSeqNumReceived = stats->highestExtSeqNumReceived();
00784 
00785   unsigned totNumExpected
00786     = highestExtSeqNumReceived - stats->baseExtSeqNumReceived();
00787   int totNumLost = totNumExpected - stats->totNumPacketsReceived();
00788   // 'Clamp' this loss number to a 24-bit signed value:
00789   if (totNumLost > 0x007FFFFF) {
00790     totNumLost = 0x007FFFFF;
00791   } else if (totNumLost < 0) {
00792     if (totNumLost < -0x00800000) totNumLost = 0x00800000; // unlikely, but...
00793     totNumLost &= 0x00FFFFFF;
00794   }
00795 
00796   unsigned numExpectedSinceLastReset
00797     = highestExtSeqNumReceived - stats->lastResetExtSeqNumReceived();
00798   int numLostSinceLastReset
00799     = numExpectedSinceLastReset - stats->numPacketsReceivedSinceLastReset();
00800   unsigned char lossFraction;
00801   if (numExpectedSinceLastReset == 0 || numLostSinceLastReset < 0) {
00802     lossFraction = 0;
00803   } else {
00804     lossFraction = (unsigned char)
00805       ((numLostSinceLastReset << 8) / numExpectedSinceLastReset);
00806   }
00807 
00808   fOutBuf->enqueueWord((lossFraction<<24) | totNumLost);
00809   fOutBuf->enqueueWord(highestExtSeqNumReceived);
00810 
00811   fOutBuf->enqueueWord(stats->jitter());
00812 
00813   unsigned NTPmsw = stats->lastReceivedSR_NTPmsw();
00814   unsigned NTPlsw = stats->lastReceivedSR_NTPlsw();
00815   unsigned LSR = ((NTPmsw&0xFFFF)<<16)|(NTPlsw>>16); // middle 32 bits
00816   fOutBuf->enqueueWord(LSR);
00817 
00818   // Figure out how long has elapsed since the last SR rcvd from this src:
00819   struct timeval const& LSRtime = stats->lastReceivedSR_time(); // "last SR"
00820   struct timeval timeNow, timeSinceLSR;
00821   gettimeofday(&timeNow, NULL);
00822   if (timeNow.tv_usec < LSRtime.tv_usec) {
00823     timeNow.tv_usec += 1000000;
00824     timeNow.tv_sec -= 1;
00825   }
00826   timeSinceLSR.tv_sec = timeNow.tv_sec - LSRtime.tv_sec;
00827   timeSinceLSR.tv_usec = timeNow.tv_usec - LSRtime.tv_usec;
00828   // The enqueued time is in units of 1/65536 seconds.
00829   // (Note that 65536/1000000 == 1024/15625)
00830   unsigned DLSR;
00831   if (LSR == 0) {
00832     DLSR = 0;
00833   } else {
00834     DLSR = (timeSinceLSR.tv_sec<<16)
00835          | ( (((timeSinceLSR.tv_usec<<11)+15625)/31250) & 0xFFFF);
00836   }
00837   fOutBuf->enqueueWord(DLSR);
00838 }

void RTCPInstance::addSDES ( ) [private]

Definition at line 840 of file RTCP.cpp.

References OutPacketBuffer::curPacketSize(), SDESItem::data(), OutPacketBuffer::enqueue(), OutPacketBuffer::enqueueWord(), fCNAME, fOutBuf, fSink, fSource, NULL, RTCP_PT_SDES, RTPSink::SSRC(), RTPSource::SSRC(), and SDESItem::totalSize().

Referenced by sendReport().

00840                            {
00841   // For now we support only the CNAME item; later support more #####
00842 
00843   // Begin by figuring out the size of the entire SDES report:
00844   unsigned numBytes = 4;
00845       // counts the SSRC, but not the header; it'll get subtracted out
00846   numBytes += fCNAME.totalSize(); // includes id and length
00847   numBytes += 1; // the special END item
00848 
00849   unsigned num4ByteWords = (numBytes + 3)/4;
00850 
00851   unsigned rtcpHdr = 0x81000000; // version 2, no padding, 1 SSRC chunk
00852   rtcpHdr |= (RTCP_PT_SDES<<16);
00853   rtcpHdr |= num4ByteWords;
00854   fOutBuf->enqueueWord(rtcpHdr);
00855 
00856   if (fSource != NULL) {
00857     fOutBuf->enqueueWord(fSource->SSRC());
00858   } else if (fSink != NULL) {
00859     fOutBuf->enqueueWord(fSink->SSRC());
00860   }
00861 
00862   // Add the CNAME:
00863   fOutBuf->enqueue(fCNAME.data(), fCNAME.totalSize());
00864 
00865   // Add the 'END' item (i.e., a zero byte), plus any more needed to pad:
00866   unsigned numPaddingBytesNeeded = 4 - (fOutBuf->curPacketSize() % 4);
00867   unsigned char const zero = '\0';
00868   while (numPaddingBytesNeeded-- > 0) fOutBuf->enqueue(&zero, 1);
00869 }

void RTCPInstance::addBYE ( ) [private]

Definition at line 871 of file RTCP.cpp.

References OutPacketBuffer::enqueueWord(), fOutBuf, fSink, fSource, NULL, RTCP_PT_BYE, RTPSink::SSRC(), and RTPSource::SSRC().

Referenced by sendBYE().

00871                           {
00872   unsigned rtcpHdr = 0x81000000; // version 2, no padding, 1 SSRC
00873   rtcpHdr |= (RTCP_PT_BYE<<16);
00874   rtcpHdr |= 1; // 2 32-bit words total (i.e., with 1 SSRC)
00875   fOutBuf->enqueueWord(rtcpHdr);
00876 
00877   if (fSource != NULL) {
00878     fOutBuf->enqueueWord(fSource->SSRC());
00879   } else if (fSink != NULL) {
00880     fOutBuf->enqueueWord(fSink->SSRC());
00881   }
00882 }

void RTCPInstance::sendBuiltPacket ( ) [private]

Definition at line 650 of file RTCP.cpp.

References OutPacketBuffer::curPacketSize(), fHaveJustSentPacket, fLastPacketSentSize, fLastSentSize, fOutBuf, fRTCPInterface, IP_UDP_HDR_SIZE, OutPacketBuffer::packet(), OutPacketBuffer::resetOffset(), RTPInterface::sendPacket(), and True.

Referenced by sendBYE(), and sendReport().

00650                                    {
00651 #ifdef DEBUG
00652   fprintf(stderr, "sending RTCP packet\n");
00653   unsigned char* p = fOutBuf->packet();
00654   for (unsigned i = 0; i < fOutBuf->curPacketSize(); ++i) {
00655     if (i%4 == 0) fprintf(stderr," ");
00656     fprintf(stderr, "%02x", p[i]);
00657   }
00658   fprintf(stderr, "\n");
00659 #endif
00660   unsigned reportSize = fOutBuf->curPacketSize();
00661   fRTCPInterface.sendPacket(fOutBuf->packet(), reportSize);
00662   fOutBuf->resetOffset();
00663 
00664   fLastSentSize = IP_UDP_HDR_SIZE + reportSize;
00665   fHaveJustSentPacket = True;
00666   fLastPacketSentSize = reportSize;
00667 }

void RTCPInstance::onExpire ( RTCPInstance * instance ) [static, private]

Definition at line 688 of file RTCP.cpp.

References onExpire1().

Referenced by RTCPInstance(), and schedule().

00688                                                   {
00689   instance->onExpire1();
00690 }

void RTCPInstance::onExpire1 ( ) [private]

Definition at line 902 of file RTCP.cpp.

References dTimeNow(), fAveRTCPSize, fIsInitial, fPrevNumMembers, fPrevReportTime, fSink, fTotSessionBW, NULL, numMembers(), and OnExpire().

Referenced by onExpire().

00902                              {
00903   // Note: fTotSessionBW is kbits per second
00904   double rtcpBW = 0.05*fTotSessionBW*1024/8; // -> bytes per second
00905 
00906   OnExpire(this, // event
00907            numMembers(), // members
00908            (fSink != NULL) ? 1 : 0, // senders
00909            rtcpBW, // rtcp_bw
00910            (fSink != NULL) ? 1 : 0, // we_sent
00911            &fAveRTCPSize, // ave_rtcp_size
00912            &fIsInitial, // initial
00913            dTimeNow(), // tc
00914            &fPrevReportTime, // tp
00915            &fPrevNumMembers // pmembers
00916            );
00917 }

void RTCPInstance::incomingReportHandler	(	RTCPInstance *	instance,
		int
	)			`[static, private]`

Definition at line 317 of file RTCP.cpp.

References incomingReportHandler1().

Referenced by addStreamSocket(), RTCPInstance(), and setStreamSocket().

00318                                                        {
00319   instance->incomingReportHandler1();
00320 }

void RTCPInstance::incomingReportHandler1 ( ) [private]

Definition at line 322 of file RTCP.cpp.

References ADVANCE, Medium::envir(), False, fByeHandleActiveParticipantsOnly, fByeHandlerClientData, fByeHandlerTask, fHaveJustSentPacket, fInBuf, fIsSSMSource, fLastPacketSentSize, fNumBytesAlreadyRead, fRRHandlerClientData, fRRHandlerTask, fRTCPInterface, fSink, fSource, fSpecificRRHandlerTable, fSRHandlerClientData, fSRHandlerTask, RTPInterface::handleRead(), IP_UDP_HDR_SIZE, RTPTransmissionStatsDB::lookup(), RTPReceptionStatsDB::lookup(), AddressPortLookupTable::Lookup(), maxPacketSize, RTPInterface::nextTCPReadStreamChannelId(), RTPInterface::nextTCPReadStreamSocketNum(), RTPTransmissionStatsDB::noteIncomingRR(), RTPReceptionStatsDB::noteIncomingSR(), NULL, onReceive(), PACKET_BYE, PACKET_RTCP_REPORT, PACKET_UNKNOWN_TYPE, RTPSource::receptionStatsDB(), RRHandlerRecord::rrHandlerClientData, RRHandlerRecord::rrHandlerTask, RTCP_PT_BYE, RTCP_PT_RR, RTCP_PT_SR, RTCPgs(), RTPInterface::sendPacket(), RTPSink::SSRC(), RTPSink::transmissionStatsDB(), and True.

Referenced by incomingReportHandler().

00322                                           {
00323   do {
00324     Boolean callByeHandler = False;
00325     int tcpReadStreamSocketNum = fRTCPInterface.nextTCPReadStreamSocketNum();
00326     unsigned char tcpReadStreamChannelId = fRTCPInterface.nextTCPReadStreamChannelId();
00327     unsigned packetSize = 0;
00328     unsigned numBytesRead;
00329     struct sockaddr_in fromAddress;
00330     Boolean packetReadWasIncomplete;
00331     Boolean readResult
00332       = fRTCPInterface.handleRead(&fInBuf[fNumBytesAlreadyRead], maxPacketSize - fNumBytesAlreadyRead,
00333                                   numBytesRead, fromAddress, packetReadWasIncomplete);
00334     if (packetReadWasIncomplete) {
00335       fNumBytesAlreadyRead += numBytesRead;
00336       return; // more reads are needed to get the entire packet
00337     } else { // normal case: We've read the entire packet 
00338       packetSize = fNumBytesAlreadyRead + numBytesRead;
00339       fNumBytesAlreadyRead = 0; // for next time
00340     }
00341     if (!readResult) break;
00342 
00343     // Ignore the packet if it was looped-back from ourself:
00344     Boolean packetWasFromOurHost = False;
00345     if (RTCPgs()->wasLoopedBackFromUs(envir(), fromAddress)) {
00346       packetWasFromOurHost = True;
00347       // However, we still want to handle incoming RTCP packets from
00348       // *other processes* on the same machine.  To distinguish this
00349       // case from a true loop-back, check whether we've just sent a
00350       // packet of the same size.  (This check isn't perfect, but it seems
00351       // to be the best we can do.)
00352       if (fHaveJustSentPacket && fLastPacketSentSize == packetSize) {
00353         // This is a true loop-back:
00354         fHaveJustSentPacket = False;
00355         break; // ignore this packet
00356       }
00357     }
00358 
00359     unsigned char* pkt = fInBuf;
00360     if (fIsSSMSource && !packetWasFromOurHost) {
00361       // This packet is assumed to have been received via unicast (because we're a SSM source, and SSM receivers send back RTCP "RR"
00362       // packets via unicast).  'Reflect' the packet by resending it to the multicast group, so that any other receivers can also
00363       // get to see it.
00364 
00365       // NOTE: Denial-of-service attacks are possible here.
00366       // Users of this software may wish to add their own,
00367       // application-specific mechanism for 'authenticating' the
00368       // validity of this packet before reflecting it.
00369 
00370       // NOTE: The test for "!packetWasFromOurHost" means that we won't reflect RTCP packets that come from other processes on
00371       // the same host as us.  The reason for this is that the 'packet size' test above is not 100% reliable; some packets
00372       // that were truly looped back from us might not be detected as such, and this might lead to infinite forwarding/receiving
00373       // of some packets.  To avoid this possibility, we only reflect RTCP packets that we know for sure originated elsewhere.
00374       // (Note, though, that if we ever re-enable the code in "Groupsock::multicastSendOnly()", then we could remove the test for
00375       // "!packetWasFromOurHost".)
00376       fRTCPInterface.sendPacket(pkt, packetSize);
00377       fHaveJustSentPacket = True;
00378       fLastPacketSentSize = packetSize;
00379     }
00380 
00381 #ifdef DEBUG
00382     fprintf(stderr, "[%p]saw incoming RTCP packet (from address %s, port %d)\n", this, AddressString(fromAddress).val(), ntohs(fromAddress.sin_port));
00383     for (unsigned i = 0; i < packetSize; ++i) {
00384       if (i%4 == 0) fprintf(stderr, " ");
00385       fprintf(stderr, "%02x", pkt[i]);
00386     }
00387     fprintf(stderr, "\n");
00388 #endif
00389     int totPacketSize = IP_UDP_HDR_SIZE + packetSize;
00390 
00391     // Check the RTCP packet for validity:
00392     // It must at least contain a header (4 bytes), and this header
00393     // must be version=2, with no padding bit, and a payload type of
00394     // SR (200) or RR (201):
00395     if (packetSize < 4) break;
00396     unsigned rtcpHdr = ntohl(*(u_int32_t*)pkt);
00397     if ((rtcpHdr & 0xE0FE0000) != (0x80000000 | (RTCP_PT_SR<<16))) {
00398 #ifdef DEBUG
00399       fprintf(stderr, "rejected bad RTCP packet: header 0x%08x\n", rtcpHdr);
00400 #endif
00401       break;
00402     }
00403 
00404     // Process each of the individual RTCP 'subpackets' in (what may be)
00405     // a compound RTCP packet.
00406     int typeOfPacket = PACKET_UNKNOWN_TYPE;
00407     unsigned reportSenderSSRC = 0;
00408     Boolean packetOK = False;
00409     while (1) {
00410       unsigned rc = (rtcpHdr>>24)&0x1F;
00411       unsigned pt = (rtcpHdr>>16)&0xFF;
00412       unsigned length = 4*(rtcpHdr&0xFFFF); // doesn't count hdr
00413       ADVANCE(4); // skip over the header
00414       if (length > packetSize) break;
00415 
00416       // Assume that each RTCP subpacket begins with a 4-byte SSRC:
00417       if (length < 4) break; length -= 4;
00418       reportSenderSSRC = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00419 
00420       Boolean subPacketOK = False;
00421       switch (pt) {
00422         case RTCP_PT_SR: {
00423 #ifdef DEBUG
00424           fprintf(stderr, "SR\n");
00425 #endif
00426           if (length < 20) break; length -= 20;
00427 
00428           // Extract the NTP timestamp, and note this:
00429           unsigned NTPmsw = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00430           unsigned NTPlsw = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00431           unsigned rtpTimestamp = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00432           if (fSource != NULL) {
00433             RTPReceptionStatsDB& receptionStats
00434               = fSource->receptionStatsDB();
00435             receptionStats.noteIncomingSR(reportSenderSSRC,
00436                                           NTPmsw, NTPlsw, rtpTimestamp);
00437           }
00438           ADVANCE(8); // skip over packet count, octet count
00439 
00440           // If a 'SR handler' was set, call it now:
00441           if (fSRHandlerTask != NULL) (*fSRHandlerTask)(fSRHandlerClientData);
00442 
00443           // The rest of the SR is handled like a RR (so, no "break;" here)
00444         }
00445         case RTCP_PT_RR: {
00446 #ifdef DEBUG
00447           fprintf(stderr, "RR\n");
00448 #endif
00449           unsigned reportBlocksSize = rc*(6*4);
00450           if (length < reportBlocksSize) break;
00451           length -= reportBlocksSize;
00452 
00453           if (fSink != NULL) {
00454             // Use this information to update stats about our transmissions:
00455             RTPTransmissionStatsDB& transmissionStats = fSink->transmissionStatsDB();
00456             for (unsigned i = 0; i < rc; ++i) {
00457               unsigned senderSSRC = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00458               // We care only about reports about our own transmission, not others'
00459               if (senderSSRC == fSink->SSRC()) {
00460                 unsigned lossStats = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00461                 unsigned highestReceived = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00462                 unsigned jitter = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00463                 unsigned timeLastSR = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00464                 unsigned timeSinceLastSR = ntohl(*(u_int32_t*)pkt); ADVANCE(4);
00465                 transmissionStats.noteIncomingRR(reportSenderSSRC, fromAddress,
00466                                                  lossStats,
00467                                                  highestReceived, jitter,
00468                                                  timeLastSR, timeSinceLastSR);
00469               } else {
00470                 ADVANCE(4*5);
00471               }
00472             }
00473           } else {
00474             ADVANCE(reportBlocksSize);
00475           }
00476 
00477           if (pt == RTCP_PT_RR) { // i.e., we didn't fall through from 'SR'
00478             // If a 'RR handler' was set, call it now:
00479 
00480             // Specific RR handler:
00481             if (fSpecificRRHandlerTable != NULL) {
00482               netAddressBits fromAddr;
00483               portNumBits fromPortNum;
00484               if (tcpReadStreamSocketNum < 0) {
00485                 // Normal case: We read the RTCP packet over UDP
00486                 fromAddr = fromAddress.sin_addr.s_addr;
00487                 fromPortNum = ntohs(fromAddress.sin_port);
00488               } else {
00489                 // Special case: We read the RTCP packet over TCP (interleaved)
00490                 // Hack: Use the TCP socket and channel id to look up the handler
00491                 fromAddr = tcpReadStreamSocketNum;
00492                 fromPortNum = tcpReadStreamChannelId;
00493               }
00494               Port fromPort(fromPortNum);
00495               RRHandlerRecord* rrHandler
00496                 = (RRHandlerRecord*)(fSpecificRRHandlerTable->Lookup(fromAddr, (~0), fromPort));
00497               if (rrHandler != NULL) {
00498                 if (rrHandler->rrHandlerTask != NULL) {
00499                   (*(rrHandler->rrHandlerTask))(rrHandler->rrHandlerClientData);
00500                 }
00501               }
00502             }
00503 
00504             // General RR handler:
00505             if (fRRHandlerTask != NULL) (*fRRHandlerTask)(fRRHandlerClientData);
00506           }
00507 
00508           subPacketOK = True;
00509           typeOfPacket = PACKET_RTCP_REPORT;
00510           break;
00511         }
00512         case RTCP_PT_BYE: {
00513 #ifdef DEBUG
00514           fprintf(stderr, "BYE\n");
00515 #endif
00516           // If a 'BYE handler' was set, arrange for it to be called at the end of this routine.
00517           // (Note: We don't call it immediately, in case it happens to cause "this" to be deleted.)
00518           if (fByeHandlerTask != NULL
00519               && (!fByeHandleActiveParticipantsOnly
00520                   || (fSource != NULL
00521                       && fSource->receptionStatsDB().lookup(reportSenderSSRC) != NULL)
00522                   || (fSink != NULL
00523                       && fSink->transmissionStatsDB().lookup(reportSenderSSRC) != NULL))) {
00524             callByeHandler = True;
00525           }
00526 
00527           // We should really check for & handle >1 SSRCs being present #####
00528 
00529           subPacketOK = True;
00530           typeOfPacket = PACKET_BYE;
00531           break;
00532         }
00533         // Later handle SDES, APP, and compound RTCP packets #####
00534         default:
00535 #ifdef DEBUG
00536           fprintf(stderr, "UNSUPPORTED TYPE(0x%x)\n", pt);
00537 #endif
00538           subPacketOK = True;
00539           break;
00540       }
00541       if (!subPacketOK) break;
00542 
00543       // need to check for (& handle) SSRC collision! #####
00544 
00545 #ifdef DEBUG
00546       fprintf(stderr, "validated RTCP subpacket (type %d): %d, %d, %d, 0x%08x\n", typeOfPacket, rc, pt, length, reportSenderSSRC);
00547 #endif
00548 
00549       // Skip over any remaining bytes in this subpacket:
00550       ADVANCE(length);
00551 
00552       // Check whether another RTCP 'subpacket' follows:
00553       if (packetSize == 0) {
00554         packetOK = True;
00555         break;
00556       } else if (packetSize < 4) {
00557 #ifdef DEBUG
00558         fprintf(stderr, "extraneous %d bytes at end of RTCP packet!\n", packetSize);
00559 #endif
00560         break;
00561       }
00562       rtcpHdr = ntohl(*(u_int32_t*)pkt);
00563       if ((rtcpHdr & 0xC0000000) != 0x80000000) {
00564 #ifdef DEBUG
00565         fprintf(stderr, "bad RTCP subpacket: header 0x%08x\n", rtcpHdr);
00566 #endif
00567         break;
00568       }
00569     }
00570 
00571     if (!packetOK) {
00572 #ifdef DEBUG
00573       fprintf(stderr, "rejected bad RTCP subpacket: header 0x%08x\n", rtcpHdr);
00574 #endif
00575       break;
00576     } else {
00577 #ifdef DEBUG
00578       fprintf(stderr, "validated entire RTCP packet\n");
00579 #endif
00580     }
00581 
00582     onReceive(typeOfPacket, totPacketSize, reportSenderSSRC);
00583 
00584     // Finally, if we need to call a "BYE" handler, do so now (in case it causes "this" to get deleted):
00585     if (callByeHandler && fByeHandlerTask != NULL/*sanity check*/) {
00586       TaskFunc* byeHandler = fByeHandlerTask;
00587       fByeHandlerTask = NULL; // because we call the handler only once, by default
00588       (*byeHandler)(fByeHandlerClientData);
00589     }
00590   } while (0);
00591 }

void RTCPInstance::onReceive	(	int	typeOfPacket,
		int	totPacketSize,
		u_int32_t	ssrc
	)			`[private]`

Referenced by incomingReportHandler1().

void RTCPInstance::schedule ( double nextTime )

Definition at line 884 of file RTCP.cpp.

References dTimeNow(), Medium::envir(), fNextReportTime, Medium::nextTask(), onExpire(), TaskScheduler::scheduleDelayedTask(), and UsageEnvironment::taskScheduler().

Referenced by reschedule(), and Schedule().

00884                                            {
00885   fNextReportTime = nextTime;
00886 
00887   double secondsToDelay = nextTime - dTimeNow();
00888   if (secondsToDelay < 0) secondsToDelay = 0;
00889 #ifdef DEBUG
00890   fprintf(stderr, "schedule(%f->%f)\n", secondsToDelay, nextTime);
00891 #endif
00892   int64_t usToGo = (int64_t)(secondsToDelay * 1000000);
00893   nextTask() = envir().taskScheduler().scheduleDelayedTask(usToGo,
00894                                 (TaskFunc*)RTCPInstance::onExpire, this);
00895 }

void RTCPInstance::reschedule ( double nextTime )

Definition at line 897 of file RTCP.cpp.

References Medium::envir(), Medium::nextTask(), schedule(), UsageEnvironment::taskScheduler(), and TaskScheduler::unscheduleDelayedTask().

Referenced by Reschedule().

00897                                              {
00898   envir().taskScheduler().unscheduleDelayedTask(nextTask());
00899   schedule(nextTime);
00900 }

void RTCPInstance::sendReport ( )

Definition at line 613 of file RTCP.cpp.

References addReport(), addSDES(), fKnownMembers, fOutgoingReportCount, fSink, RTPSink::nextTimestampHasBeenPreset(), NULL, RTCPMemberDatabase::reapOldMembers(), and sendBuiltPacket().

Referenced by SendRTCPReport().

00613                               {
00614   // Hack: Don't send a SR during those (brief) times when the timestamp of the
00615   // next outgoing RTP packet has been preset, to ensure that that timestamp gets
00616   // used for that outgoing packet. (David Bertrand, 2006.07.18)
00617   if (fSink != NULL && fSink->nextTimestampHasBeenPreset()) return;
00618 
00619 #ifdef DEBUG
00620   fprintf(stderr, "sending REPORT\n");
00621 #endif
00622   // Begin by including a SR and/or RR report:
00623   addReport();
00624 
00625   // Then, include a SDES:
00626   addSDES();
00627 
00628   // Send the report:
00629   sendBuiltPacket();
00630 
00631   // Periodically clean out old members from our SSRC membership database:
00632   const unsigned membershipReapPeriod = 5;
00633   if ((++fOutgoingReportCount) % membershipReapPeriod == 0) {
00634     unsigned threshold = fOutgoingReportCount - membershipReapPeriod;
00635     fKnownMembers->reapOldMembers(threshold);
00636   }
00637 }

void RTCPInstance::sendBYE ( )

Definition at line 639 of file RTCP.cpp.

References addBYE(), addReport(), and sendBuiltPacket().

Referenced by SendBYEPacket(), and ~RTCPInstance().

00639                            {
00640 #ifdef DEBUG
00641   fprintf(stderr, "sending BYE\n");
00642 #endif
00643   // The packet must begin with a SR and/or RR report:
00644   addReport();
00645 
00646   addBYE();
00647   sendBuiltPacket();
00648 }

int RTCPInstance::typeOfEvent ( ) [inline]

Definition at line 173 of file RTCP.hh.

References fTypeOfEvent.

Referenced by TypeOfEvent().

00173 {return fTypeOfEvent;}

int RTCPInstance::sentPacketSize ( ) [inline]

Definition at line 174 of file RTCP.hh.

References fLastSentSize.

Referenced by SentPacketSize().

00174 {return fLastSentSize;}

int RTCPInstance::packetType ( ) [inline]

Definition at line 175 of file RTCP.hh.

References fTypeOfPacket.

Referenced by PacketType().

00175 {return fTypeOfPacket;}

int RTCPInstance::receivedPacketSize ( ) [inline]

Definition at line 176 of file RTCP.hh.

References fLastReceivedSize.

Referenced by ReceivedPacketSize().

00176 {return fLastReceivedSize;}

int RTCPInstance::checkNewSSRC ( )

Definition at line 669 of file RTCP.cpp.

References fKnownMembers, fLastReceivedSSRC, fOutgoingReportCount, and RTCPMemberDatabase::noteMembership().

Referenced by NewMember().

00669                                {
00670   return fKnownMembers->noteMembership(fLastReceivedSSRC,
00671                                        fOutgoingReportCount);
00672 }

void RTCPInstance::removeLastReceivedSSRC ( )

Definition at line 674 of file RTCP.cpp.

References False, fLastReceivedSSRC, and removeSSRC().

Referenced by RemoveMember().

00674                                           {
00675   removeSSRC(fLastReceivedSSRC, False/*keep stats around*/);
00676 }

void RTCPInstance::removeSSRC	(	u_int32_t	ssrc,
		Boolean	alsoRemoveStats
	)

Definition at line 678 of file RTCP.cpp.

References fKnownMembers, fSink, fSource, NULL, RTPSource::receptionStatsDB(), RTCPMemberDatabase::remove(), RTPTransmissionStatsDB::removeRecord(), RTPReceptionStatsDB::removeRecord(), and RTPSink::transmissionStatsDB().

Referenced by RTCPMemberDatabase::reapOldMembers(), and removeLastReceivedSSRC().

00678                                                                      {
00679   fKnownMembers->remove(ssrc);
00680 
00681   if (alsoRemoveStats) {
00682     // Also, remove records of this SSRC from any reception or transmission stats
00683     if (fSource != NULL) fSource->receptionStatsDB().removeRecord(ssrc);
00684     if (fSink != NULL) fSink->transmissionStatsDB().removeRecord(ssrc);
00685   }
00686 }

Boolean Medium::lookupByName	(	UsageEnvironment &	env,
		char const *	mediumName,
		Medium *&	resultMedium
	)			`[static, inherited]`

Definition at line 41 of file Media.cpp.

References env, False, MediaLookupTable::lookup(), NULL, MediaLookupTable::ourMedia(), UsageEnvironment::setResultMsg(), and True.

Referenced by ServerMediaSession::lookupByName(), RTSPServer::lookupByName(), RTSPClient::lookupByName(), lookupByName(), MediaSource::lookupByName(), MediaSink::lookupByName(), MediaSession::lookupByName(), and DarwinInjector::lookupByName().

00042                                                          {
00043   resultMedium = MediaLookupTable::ourMedia(env)->lookup(mediumName);
00044   if (resultMedium == NULL) {
00045     env.setResultMsg("Medium ", mediumName, " does not exist");
00046     return False;
00047   }
00048 
00049   return True;
00050 }

void Medium::close	(	UsageEnvironment &	env,
		char const *	mediumName
	)			`[static, inherited]`

Definition at line 52 of file Media.cpp.

References env, MediaLookupTable::ourMedia(), and MediaLookupTable::remove().

Referenced by afterPlaying(), Medium::close(), closeMediaSinks(), OnDemandServerMediaSubsession::closeStreamSource(), continueAfterTEARDOWN(), WAVAudioFileSource::createNew(), QuickTimeFileSink::createNew(), QCELPAudioRTPSource::createNew(), MP3HTTPSource::createNew(), MP3FileSource::createNew(), AVIFileSink::createNew(), AMRAudioRTPSource::createNew(), WAVAudioFileServerMediaSubsession::createNewStreamSource(), MPEG1or2DemuxedServerMediaSubsession::createNewStreamSource(), MediaSubsession::deInitiate(), RTSPServerSupportingHTTPStreaming::RTSPClientSessionSupportingHTTPStreaming::handleHTTPCmd_StreamingGET(), MediaSubsession::initiate(), MPEG1or2ProgramStreamFileDuration(), MPEG1or2Demux::noteElementaryStreamDeletion(), ByteStreamMultiFileSource::onSourceClosure1(), StreamState::reclaim(), RTSPServer::removeServerMediaSession(), OnDemandServerMediaSubsession::sdpLines(), shutdownStream(), T140TextRTPSink::stopPlaying(), H264VideoRTPSink::stopPlaying(), subsessionAfterPlaying(), ClientTrickPlayState::updateStateOnScaleChange(), AMRDeinterleaver::~AMRDeinterleaver(), ByteStreamMultiFileSource::~ByteStreamMultiFileSource(), DarwinInjector::~DarwinInjector(), FramedFilter::~FramedFilter(), InputESSourceRecord::~InputESSourceRecord(), MatroskaFileParser::~MatroskaFileParser(), MatroskaFileServerDemux::~MatroskaFileServerDemux(), MPEG1or2Demux::~MPEG1or2Demux(), MPEG1or2FileServerDemux::~MPEG1or2FileServerDemux(), MPEG2TransportFileServerMediaSubsession::~MPEG2TransportFileServerMediaSubsession(), MPEG2TransportStreamFromPESSource::~MPEG2TransportStreamFromPESSource(), RTSPServerSupportingHTTPStreaming::RTSPClientSessionSupportingHTTPStreaming::~RTSPClientSessionSupportingHTTPStreaming(), ServerMediaSession::~ServerMediaSession(), ServerMediaSubsession::~ServerMediaSubsession(), StreamClientState::~StreamClientState(), and StreamReplicator::~StreamReplicator().

00052                                                           {
00053   MediaLookupTable::ourMedia(env)->remove(name);
00054 }

void Medium::close ( Medium * medium ) [static, inherited]

Definition at line 56 of file Media.cpp.

References Medium::close(), Medium::envir(), Medium::name(), and NULL.

00056                                  {
00057   if (medium == NULL) return;
00058 
00059   close(medium->envir(), medium->name());
00060 }

UsageEnvironment& Medium::envir ( ) const [inline, inherited]

Definition at line 59 of file Media.hh.

References Medium::fEnviron.

00059 {return fEnviron;}

char const* Medium::name ( ) const [inline, inherited]

Definition at line 61 of file Media.hh.

References Medium::fMediumName.

Referenced by QuickTimeFileSink::addAtom_hdlr2(), Medium::close(), MP3ADUTranscoder::createNew(), MP3FromADUSource::createNew(), ADUFromMP3Source::createNew(), and MP3FileSource::initializeStream().

00061 {return fMediumName;}

Boolean Medium::isSource ( ) const [virtual, inherited]

Reimplemented in MediaSource.

Definition at line 62 of file Media.cpp.

References False.

Referenced by MediaSource::lookupByName().

00062                                {
00063   return False; // default implementation
00064 }

Boolean Medium::isSink ( ) const [virtual, inherited]

Reimplemented in MediaSink.

Definition at line 66 of file Media.cpp.

References False.

Referenced by MediaSink::lookupByName().

00066                              {
00067   return False; // default implementation
00068 }

Boolean Medium::isRTSPClient ( ) const [virtual, inherited]

Reimplemented in RTSPClient.

Definition at line 74 of file Media.cpp.

References False.

Referenced by RTSPClient::lookupByName().

00074                                    {
00075   return False; // default implementation
00076 }

Boolean Medium::isRTSPServer ( ) const [virtual, inherited]

Reimplemented in RTSPServer.

Definition at line 78 of file Media.cpp.

References False.

Referenced by RTSPServer::lookupByName().

00078                                    {
00079   return False; // default implementation
00080 }

Boolean Medium::isMediaSession ( ) const [virtual, inherited]

Reimplemented in MediaSession.

Definition at line 82 of file Media.cpp.

References False.

Referenced by MediaSession::lookupByName().

00082                                      {
00083   return False; // default implementation
00084 }

Boolean Medium::isServerMediaSession ( ) const [virtual, inherited]

Reimplemented in ServerMediaSession.

Definition at line 86 of file Media.cpp.

References False.

Referenced by ServerMediaSession::lookupByName().

00086                                            {
00087   return False; // default implementation
00088 }

Boolean Medium::isDarwinInjector ( ) const [virtual, inherited]

Reimplemented in DarwinInjector.

Definition at line 90 of file Media.cpp.

References False.

Referenced by DarwinInjector::lookupByName().

00090                                        {
00091   return False; // default implementation
00092 }

TaskToken& Medium::nextTask ( ) [inline, protected, inherited]

Friends And Related Function Documentation

friend class MediaLookupTable [friend, inherited]

Definition at line 74 of file Media.hh.

Field Documentation

unsigned char* RTCPInstance::fInBuf [private]

Definition at line 132 of file RTCP.hh.

Referenced by incomingReportHandler1(), RTCPInstance(), and ~RTCPInstance().

unsigned RTCPInstance::fNumBytesAlreadyRead [private]

Definition at line 133 of file RTCP.hh.

Referenced by incomingReportHandler1(), and RTCPInstance().

OutPacketBuffer* RTCPInstance::fOutBuf [private]

Definition at line 134 of file RTCP.hh.

Referenced by addBYE(), addSDES(), addSR(), enqueueReportBlock(), RTCPInstance(), sendBuiltPacket(), and ~RTCPInstance().

RTPInterface RTCPInstance::fRTCPInterface [private]

Definition at line 135 of file RTCP.hh.

Referenced by addStreamSocket(), incomingReportHandler1(), removeStreamSocket(), RTCPgs(), RTCPInstance(), sendBuiltPacket(), setAuxilliaryReadHandler(), setStreamSocket(), and ~RTCPInstance().

unsigned RTCPInstance::fTotSessionBW [private]

Definition at line 136 of file RTCP.hh.

Referenced by onExpire1(), RTCPInstance(), and totSessionBW().

RTPSink* RTCPInstance::fSink [private]

Definition at line 137 of file RTCP.hh.

Referenced by addBYE(), addReport(), addSDES(), addSR(), incomingReportHandler1(), onExpire1(), removeSSRC(), and sendReport().

RTPSource const* RTCPInstance::fSource [private]

Definition at line 138 of file RTCP.hh.

Referenced by addBYE(), addReport(), addRR(), addSDES(), enqueueCommonReportSuffix(), incomingReportHandler1(), and removeSSRC().

Boolean RTCPInstance::fIsSSMSource [private]

Definition at line 139 of file RTCP.hh.

Referenced by incomingReportHandler1().

SDESItem RTCPInstance::fCNAME [private]

Definition at line 141 of file RTCP.hh.

Referenced by addSDES().

RTCPMemberDatabase* RTCPInstance::fKnownMembers [private]

Definition at line 142 of file RTCP.hh.

Referenced by checkNewSSRC(), numMembers(), removeSSRC(), RTCPInstance(), sendReport(), and ~RTCPInstance().

unsigned RTCPInstance::fOutgoingReportCount [private]

Definition at line 143 of file RTCP.hh.

Referenced by checkNewSSRC(), and sendReport().

double RTCPInstance::fAveRTCPSize [private]

Definition at line 145 of file RTCP.hh.

Referenced by onExpire1().

int RTCPInstance::fIsInitial [private]

Definition at line 146 of file RTCP.hh.

Referenced by onExpire1().

double RTCPInstance::fPrevReportTime [private]

Definition at line 147 of file RTCP.hh.

Referenced by onExpire1(), and RTCPInstance().

double RTCPInstance::fNextReportTime [private]

Definition at line 148 of file RTCP.hh.

Referenced by RTCPInstance(), and schedule().

int RTCPInstance::fPrevNumMembers [private]

Definition at line 149 of file RTCP.hh.

Referenced by onExpire1().

int RTCPInstance::fLastSentSize [private]

Definition at line 151 of file RTCP.hh.

Referenced by sendBuiltPacket(), and sentPacketSize().

int RTCPInstance::fLastReceivedSize [private]

Definition at line 152 of file RTCP.hh.

Referenced by receivedPacketSize().

u_int32_t RTCPInstance::fLastReceivedSSRC [private]

Definition at line 153 of file RTCP.hh.

Referenced by checkNewSSRC(), and removeLastReceivedSSRC().

int RTCPInstance::fTypeOfEvent [private]

Definition at line 154 of file RTCP.hh.

Referenced by RTCPInstance(), typeOfEvent(), and ~RTCPInstance().

int RTCPInstance::fTypeOfPacket [private]

Definition at line 155 of file RTCP.hh.

Referenced by packetType().

Boolean RTCPInstance::fHaveJustSentPacket [private]

Definition at line 156 of file RTCP.hh.

Referenced by incomingReportHandler1(), and sendBuiltPacket().

unsigned RTCPInstance::fLastPacketSentSize [private]

Definition at line 157 of file RTCP.hh.

Referenced by incomingReportHandler1(), and sendBuiltPacket().

TaskFunc* RTCPInstance::fByeHandlerTask [private]

Definition at line 159 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setByeHandler().

void* RTCPInstance::fByeHandlerClientData [private]

Definition at line 160 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setByeHandler().

Boolean RTCPInstance::fByeHandleActiveParticipantsOnly [private]

Definition at line 161 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setByeHandler().

TaskFunc* RTCPInstance::fSRHandlerTask [private]

Definition at line 162 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setSRHandler().

void* RTCPInstance::fSRHandlerClientData [private]

Definition at line 163 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setSRHandler().

TaskFunc* RTCPInstance::fRRHandlerTask [private]

Definition at line 164 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setRRHandler().

void* RTCPInstance::fRRHandlerClientData [private]

Definition at line 165 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setRRHandler().

AddressPortLookupTable* RTCPInstance::fSpecificRRHandlerTable [private]

Definition at line 166 of file RTCP.hh.

Referenced by incomingReportHandler1(), setSpecificRRHandler(), unsetSpecificRRHandler(), and ~RTCPInstance().

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

liveMedia/include/RTCP.hh
liveMedia/RTCP.cpp

Generated on Thu Feb 2 23:55:47 2012 for live by

1.5.2

RTCPInstance Class Reference

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation