RTCPInstance Class Reference

#include <RTCP.hh>

Inheritance diagram for RTCPInstance:

Inheritance graph
[legend]
Collaboration diagram for RTCPInstance:

Collaboration graph
[legend]

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)
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)
void unsetSpecificRRHandler (netAddressBits fromAddress, Port fromPort)

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

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(), and setupStreams().

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::endPlaying(), and StreamState::startPlaying().

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 }

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

Definition at line 83 of file RTCP.hh.

References fRTCPInterface, and RTPInterface::gs().

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

00083 { 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 87 of file RTCP.hh.

References fRTCPInterface, and RTPInterface::removeStreamSocket().

Referenced by StreamState::endPlaying().

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

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

Definition at line 92 of file RTCP.hh.

References fRTCPInterface, and RTPInterface::setAuxilliaryReadHandler().

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

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 677 of file RTCP.cpp.

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

Referenced by sendBYE(), and sendReport().

00677                              {
00678   // Include a SR or a RR, depending on whether we
00679   // have an associated sink or source:
00680   if (fSink != NULL) {
00681     addSR();
00682   } else if (fSource != NULL) {
00683     addRR();
00684   }
00685 }

void RTCPInstance::addSR (  )  [private]

Definition at line 687 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().

00687                          {
00688   // ASSERT: fSink != NULL
00689 
00690   enqueueCommonReportPrefix(RTCP_PT_SR, fSink->SSRC(),
00691                             5 /* extra words in a SR */);
00692 
00693   // Now, add the 'sender info' for our sink
00694 
00695   // Insert the NTP and RTP timestamps for the 'wallclock time':
00696   struct timeval timeNow;
00697   gettimeofday(&timeNow, NULL);
00698   fOutBuf->enqueueWord(timeNow.tv_sec + 0x83AA7E80);
00699       // NTP timestamp most-significant word (1970 epoch -> 1900 epoch)
00700   double fractionalPart = (timeNow.tv_usec/15625.0)*0x04000000; // 2^32/10^6
00701   fOutBuf->enqueueWord((unsigned)(fractionalPart+0.5));
00702       // NTP timestamp least-significant word
00703   unsigned rtpTimestamp = fSink->convertToRTPTimestamp(timeNow);
00704   fOutBuf->enqueueWord(rtpTimestamp); // RTP ts
00705 
00706   // Insert the packet and byte counts:
00707   fOutBuf->enqueueWord(fSink->packetCount());
00708   fOutBuf->enqueueWord(fSink->octetCount());
00709 
00710   enqueueCommonReportSuffix();
00711 }

void RTCPInstance::addRR (  )  [private]

Definition at line 713 of file RTCP.cpp.

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

Referenced by addReport().

00713                          {
00714   // ASSERT: fSource != NULL
00715 
00716   enqueueCommonReportPrefix(RTCP_PT_RR, fSource->SSRC());
00717   enqueueCommonReportSuffix();
00718 }

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 745 of file RTCP.cpp.

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

Referenced by addRR(), and addSR().

00745                                              {
00746   // Output the report blocks for each source:
00747   if (fSource != NULL) {
00748     RTPReceptionStatsDB& allReceptionStats
00749       = fSource->receptionStatsDB();
00750 
00751     RTPReceptionStatsDB::Iterator iterator(allReceptionStats);
00752     while (1) {
00753       RTPReceptionStats* receptionStats = iterator.next();
00754       if (receptionStats == NULL) break;
00755       enqueueReportBlock(receptionStats);
00756     }
00757 
00758     allReceptionStats.reset(); // because we have just generated a report
00759   }
00760 }

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

Definition at line 763 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().

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

void RTCPInstance::addSDES (  )  [private]

Definition at line 823 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().

00823                            {
00824   // For now we support only the CNAME item; later support more #####
00825 
00826   // Begin by figuring out the size of the entire SDES report:
00827   unsigned numBytes = 4;
00828       // counts the SSRC, but not the header; it'll get subtracted out
00829   numBytes += fCNAME.totalSize(); // includes id and length
00830   numBytes += 1; // the special END item
00831 
00832   unsigned num4ByteWords = (numBytes + 3)/4;
00833 
00834   unsigned rtcpHdr = 0x81000000; // version 2, no padding, 1 SSRC chunk
00835   rtcpHdr |= (RTCP_PT_SDES<<16);
00836   rtcpHdr |= num4ByteWords;
00837   fOutBuf->enqueueWord(rtcpHdr);
00838 
00839   if (fSource != NULL) {
00840     fOutBuf->enqueueWord(fSource->SSRC());
00841   } else if (fSink != NULL) {
00842     fOutBuf->enqueueWord(fSink->SSRC());
00843   }
00844 
00845   // Add the CNAME:
00846   fOutBuf->enqueue(fCNAME.data(), fCNAME.totalSize());
00847 
00848   // Add the 'END' item (i.e., a zero byte), plus any more needed to pad:
00849   unsigned numPaddingBytesNeeded = 4 - (fOutBuf->curPacketSize() % 4);
00850   unsigned char const zero = '\0';
00851   while (numPaddingBytesNeeded-- > 0) fOutBuf->enqueue(&zero, 1);
00852 }

void RTCPInstance::addBYE (  )  [private]

Definition at line 854 of file RTCP.cpp.

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

Referenced by sendBYE().

00854                           {
00855   unsigned rtcpHdr = 0x81000000; // version 2, no padding, 1 SSRC
00856   rtcpHdr |= (RTCP_PT_BYE<<16);
00857   rtcpHdr |= 1; // 2 32-bit words total (i.e., with 1 SSRC)
00858   fOutBuf->enqueueWord(rtcpHdr);
00859 
00860   if (fSource != NULL) {
00861     fOutBuf->enqueueWord(fSource->SSRC());
00862   } else if (fSink != NULL) {
00863     fOutBuf->enqueueWord(fSink->SSRC());
00864   }
00865 }

void RTCPInstance::sendBuiltPacket (  )  [private]

Definition at line 633 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().

00633                                    {
00634 #ifdef DEBUG
00635   fprintf(stderr, "sending RTCP packet\n");
00636   unsigned char* p = fOutBuf->packet();
00637   for (unsigned i = 0; i < fOutBuf->curPacketSize(); ++i) {
00638     if (i%4 == 0) fprintf(stderr," ");
00639     fprintf(stderr, "%02x", p[i]);
00640   }
00641   fprintf(stderr, "\n");
00642 #endif
00643   unsigned reportSize = fOutBuf->curPacketSize();
00644   fRTCPInterface.sendPacket(fOutBuf->packet(), reportSize);
00645   fOutBuf->resetOffset();
00646 
00647   fLastSentSize = IP_UDP_HDR_SIZE + reportSize;
00648   fHaveJustSentPacket = True;
00649   fLastPacketSentSize = reportSize;
00650 }

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

Definition at line 671 of file RTCP.cpp.

References onExpire1().

Referenced by RTCPInstance(), and schedule().

00671                                                   {
00672   instance->onExpire1();
00673 }

void RTCPInstance::onExpire1 (  )  [private]

Definition at line 885 of file RTCP.cpp.

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

Referenced by onExpire().

00885                              {
00886   // Note: fTotSessionBW is kbits per second
00887   double rtcpBW = 0.05*fTotSessionBW*1024/8; // -> bytes per second
00888 
00889   OnExpire(this, // event
00890            numMembers(), // members
00891            (fSink != NULL) ? 1 : 0, // senders
00892            rtcpBW, // rtcp_bw
00893            (fSink != NULL) ? 1 : 0, // we_sent
00894            &fAveRTCPSize, // ave_rtcp_size
00895            &fIsInitial, // initial
00896            dTimeNow(), // tc
00897            &fPrevReportTime, // tp
00898            &fPrevNumMembers // pmembers
00899            );
00900 }

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

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

Referenced by incomingReportHandler1().

void RTCPInstance::unsetSpecificRRHandler ( netAddressBits  fromAddress,
Port  fromPort 
) [private]

Definition at line 273 of file RTCP.cpp.

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

Referenced by 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 }

void RTCPInstance::schedule ( double  nextTime  ) 

Definition at line 867 of file RTCP.cpp.

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

Referenced by reschedule(), and Schedule().

00867                                            {
00868   fNextReportTime = nextTime;
00869 
00870   double secondsToDelay = nextTime - dTimeNow();
00871   if (secondsToDelay < 0) secondsToDelay = 0;
00872 #ifdef DEBUG
00873   fprintf(stderr, "schedule(%f->%f)\n", secondsToDelay, nextTime);
00874 #endif
00875   int64_t usToGo = (int64_t)(secondsToDelay * 1000000);
00876   nextTask() = envir().taskScheduler().scheduleDelayedTask(usToGo,
00877                                 (TaskFunc*)RTCPInstance::onExpire, this);
00878 }

void RTCPInstance::reschedule ( double  nextTime  ) 

Definition at line 880 of file RTCP.cpp.

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

Referenced by Reschedule().

00880                                              {
00881   envir().taskScheduler().unscheduleDelayedTask(nextTask());
00882   schedule(nextTime);
00883 }

void RTCPInstance::sendReport (  ) 

Definition at line 596 of file RTCP.cpp.

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

Referenced by SendRTCPReport().

00596                               {
00597   // Hack: Don't send a SR during those (brief) times when the timestamp of the
00598   // next outgoing RTP packet has been preset, to ensure that that timestamp gets
00599   // used for that outgoing packet. (David Bertrand, 2006.07.18)
00600   if (fSink != NULL && fSink->nextTimestampHasBeenPreset()) return;
00601 
00602 #ifdef DEBUG
00603   fprintf(stderr, "sending REPORT\n");
00604 #endif
00605   // Begin by including a SR and/or RR report:
00606   addReport();
00607 
00608   // Then, include a SDES:
00609   addSDES();
00610 
00611   // Send the report:
00612   sendBuiltPacket();
00613 
00614   // Periodically clean out old members from our SSRC membership database:
00615   const unsigned membershipReapPeriod = 5;
00616   if ((++fOutgoingReportCount) % membershipReapPeriod == 0) {
00617     unsigned threshold = fOutgoingReportCount - membershipReapPeriod;
00618     fKnownMembers->reapOldMembers(threshold);
00619   }
00620 }

void RTCPInstance::sendBYE (  ) 

Definition at line 622 of file RTCP.cpp.

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

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

00622                            {
00623 #ifdef DEBUG
00624   fprintf(stderr, "sending BYE\n");
00625 #endif
00626   // The packet must begin with a SR and/or RR report:
00627   addReport();
00628 
00629   addBYE();
00630   sendBuiltPacket();
00631 }

int RTCPInstance::typeOfEvent (  )  [inline]

Definition at line 174 of file RTCP.hh.

References fTypeOfEvent.

Referenced by TypeOfEvent().

00174 {return fTypeOfEvent;}

int RTCPInstance::sentPacketSize (  )  [inline]

Definition at line 175 of file RTCP.hh.

References fLastSentSize.

Referenced by SentPacketSize().

00175 {return fLastSentSize;}

int RTCPInstance::packetType (  )  [inline]

Definition at line 176 of file RTCP.hh.

References fTypeOfPacket.

Referenced by PacketType().

00176 {return fTypeOfPacket;}

int RTCPInstance::receivedPacketSize (  )  [inline]

Definition at line 177 of file RTCP.hh.

References fLastReceivedSize.

Referenced by ReceivedPacketSize().

00177 {return fLastReceivedSize;}

int RTCPInstance::checkNewSSRC (  ) 

Definition at line 652 of file RTCP.cpp.

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

Referenced by NewMember().

00652                                {
00653   return fKnownMembers->noteMembership(fLastReceivedSSRC,
00654                                        fOutgoingReportCount);
00655 }

void RTCPInstance::removeLastReceivedSSRC (  ) 

Definition at line 657 of file RTCP.cpp.

References False, fLastReceivedSSRC, and removeSSRC().

Referenced by RemoveMember().

00657                                           {
00658   removeSSRC(fLastReceivedSSRC, False/*keep stats around*/);
00659 }

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

Definition at line 661 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().

00661                                                                      {
00662   fKnownMembers->remove(ssrc);
00663 
00664   if (alsoRemoveStats) {
00665     // Also, remove records of this SSRC from any reception or transmission stats
00666     if (fSource != NULL) fSource->receptionStatsDB().removeRecord(ssrc);
00667     if (fSink != NULL) fSink->transmissionStatsDB().removeRecord(ssrc);
00668   }
00669 }

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

Definition at line 65 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().

00066                                                          {
00067   resultMedium = MediaLookupTable::ourMedia(env)->lookup(mediumName);
00068   if (resultMedium == NULL) {
00069     env.setResultMsg("Medium ", mediumName, " does not exist");
00070     return False;
00071   }
00072 
00073   return True;
00074 }

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

Definition at line 76 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(), MediaSubsession::initiate(), MPEG1or2ProgramStreamFileDuration(), MPEG1or2Demux::noteElementaryStreamDeletion(), ByteStreamMultiFileSource::onSourceClosure1(), StreamState::reclaim(), RTSPServer::removeServerMediaSession(), OnDemandServerMediaSubsession::sdpLines(), H264VideoRTPSink::stopPlaying(), subsessionAfterPlaying(), ClientTrickPlayState::updateStateOnScaleChange(), AMRDeinterleaver::~AMRDeinterleaver(), ByteStreamMultiFileSource::~ByteStreamMultiFileSource(), DarwinInjector::~DarwinInjector(), FramedFilter::~FramedFilter(), H264VideoRTPSink::~H264VideoRTPSink(), InputESSourceRecord::~InputESSourceRecord(), MPEG1or2Demux::~MPEG1or2Demux(), MPEG1or2FileServerDemux::~MPEG1or2FileServerDemux(), MPEG2TransportFileServerMediaSubsession::~MPEG2TransportFileServerMediaSubsession(), MPEG2TransportStreamFromPESSource::~MPEG2TransportStreamFromPESSource(), ServerMediaSession::~ServerMediaSession(), and ServerMediaSubsession::~ServerMediaSubsession().

00076                                                           {
00077   MediaLookupTable::ourMedia(env)->remove(name);
00078 }

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

Definition at line 80 of file Media.cpp.

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

00080                                  {
00081   if (medium == NULL) return;
00082 
00083   close(medium->envir(), medium->name());
00084 }

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

Definition at line 59 of file Media.hh.

References Medium::fEnviron.

Referenced by QuickTimeFileSink::addArbitraryString(), FileSink::addData(), addStreamSocket(), MPEG2IFrameIndexFromTransportStream::addToTail(), StreamParser::afterGettingBytes(), MultiFramedRTPSink::afterGettingFrame1(), InputESSourceRecord::afterGettingFrame1(), MPEG2TransportStreamFramer::afterGettingFrame1(), MPEG2IFrameIndexFromTransportStream::afterGettingFrame1(), HTTPSink::afterGettingFrame1(), BasicUDPSink::afterGettingFrame1(), MPEG4VideoFileServerMediaSubsession::afterPlayingDummy1(), MPEG4VideoStreamParser::analyzeVOLHeader(), announceStream(), MPEG4VideoFileServerMediaSubsession::checkForAuxSDPLine1(), Medium::close(), MPEG2IFrameIndexFromTransportStream::compactParseBuffer(), RTSPClient::connectionHandler1(), RTSPClient::connectToServer(), QuickTimeFileSink::continuePlaying(), HTTPSink::continuePlaying(), H264VideoRTPSink::continuePlaying(), AVIFileSink::continuePlaying(), MPEG4VideoFileServerMediaSubsession::createNewRTPSink(), MPEG2TransportFileServerMediaSubsession::createNewRTPSink(), MPEG1or2VideoFileServerMediaSubsession::createNewRTPSink(), MPEG1or2DemuxedServerMediaSubsession::createNewRTPSink(), H263plusVideoFileServerMediaSubsession::createNewRTPSink(), DVVideoFileServerMediaSubsession::createNewRTPSink(), AMRAudioFileServerMediaSubsession::createNewRTPSink(), ADTSAudioFileServerMediaSubsession::createNewRTPSink(), MPEG4VideoFileServerMediaSubsession::createNewStreamSource(), MPEG2TransportFileServerMediaSubsession::createNewStreamSource(), MPEG1or2VideoFileServerMediaSubsession::createNewStreamSource(), MPEG1or2DemuxedServerMediaSubsession::createNewStreamSource(), H263plusVideoFileServerMediaSubsession::createNewStreamSource(), DVVideoFileServerMediaSubsession::createNewStreamSource(), AMRAudioFileServerMediaSubsession::createNewStreamSource(), ADTSAudioFileServerMediaSubsession::createNewStreamSource(), MPEG2IFrameIndexFromTransportStream::deliverIndexRecord(), SegmentQueue::dequeue(), WAVAudioFileSource::doGetNextFrame(), MPEG2IFrameIndexFromTransportStream::doGetNextFrame(), MP3FileSource::doGetNextFrame(), H264FUAFragmenter::doGetNextFrame(), ByteStreamMultiFileSource::doGetNextFrame(), ByteStreamFileSource::doGetNextFrame(), BasicUDPSource::doGetNextFrame(), AMRAudioFileSource::doGetNextFrame(), ADTSAudioFileSource::doGetNextFrame(), MultiFramedRTPSource::doGetNextFrame1(), MP3FileSource::doGetNextFrame1(), ADUFromMP3Source::doGetNextFrame1(), SIPClient::doInviteStateMachine(), ByteStreamFileSource::doReadFromFile(), MPEG1or2VideoRTPSink::doSpecialFrameHandling(), MP3ADURTPSink::doSpecialFrameHandling(), H263plusVideoRTPSink::doSpecialFrameHandling(), ByteStreamFileSource::doStopGettingFrames(), BasicUDPSource::doStopGettingFrames(), SegmentQueue::enqueueNewSegment(), StreamParser::ensureValidBytes1(), MediaSubsession::env(), SubsessionIOState::envir(), RTSPServer::RTSPClientSession::envir(), RTSPOverHTTPServer::HTTPClientConnection::envir(), RTPInterface::envir(), AVISubsessionIOState::envir(), ServerMediaSession::generateSDPDescription(), RTPSource::getAttributes(), MP3FileSource::getAttributes(), MP3ADUTranscoder::getAttributes(), MediaSource::getAttributes(), MPEG4VideoFileServerMediaSubsession::getAuxSDPLine(), getMPEG1or2TimeCode(), FramedSource::getNextFrame(), getOptions(), DVVideoStreamFramer::getProfile(), SIPClient::getResponse(), SIPClient::getResponseCode(), getSDPDescription(), OnDemandServerMediaSubsession::getStreamParameters(), RTSPClient::handleGET_PARAMETERResponse(), RTSPClient::handleIncomingRequest(), RTSPClient::handlePLAYResponse(), RTSPClient::handleRequestError(), RTSPClient::handleResponseBytes(), RTSPClient::handleSETUPResponse(), RTSPServer::incomingConnectionHandler1(), RTSPOverHTTPServer::incomingConnectionHandler1(), RTSPClient::incomingDataHandler1(), incomingReportHandler1(), MP3FileSource::initializeStream(), MediaSession::initializeWithSDP(), MediaSession::initiateByMediaType(), SIPClient::invite1(), DynamicRTSPServer::lookupServerMediaSession(), MPEG4GenericRTPSource::MPEG4GenericRTPSource(), MPEG1or2FileServerDemux::newElementaryStream(), MPEG1or2Demux::newElementaryStream(), MPEG4GenericBufferedPacket::nextEnclosedFrameSize(), AMRBufferedPacket::nextEnclosedFrameSize(), RTSPClient::openConnection(), MPEG2TransportStreamIndexFile::openFid(), MPEG2IFrameIndexFromTransportStream::parseFrame(), AC3AudioStreamParser::parseFrame(), MPEGProgramStreamParser::parsePackHeader(), MPEGProgramStreamParser::parsePESPacket(), SIPClient::parseResponseCode(), MediaSession::parseSDPLine(), MPEG1or2VideoStreamParser::parseSlice(), MPEGProgramStreamParser::parseSystemHeader(), MPEG4VideoStreamParser::parseVideoObjectLayer(), MPEG4VideoStreamParser::parseVideoObjectPlane(), MPEG4VideoStreamParser::parseVisualObject(), AC3AudioRTPSource::processSpecialHeader(), SIPClient::processURL(), AC3AudioStreamParser::readAndSaveAFrame(), MPEG1or2Demux::registerReadInterest(), reschedule(), RTSPClient::resendCommand(), RTSPClient::resetTCPSockets(), RTSPClient::responseHandlerForHTTP_GET1(), RTSPServer::rtspURLPrefix(), schedule(), OnDemandServerMediaSubsession::sdpLines(), SIPClient::sendACK(), SIPClient::sendBYE(), SIPClient::sendINVITE(), MultiFramedRTPSink::sendPacketIfNecessary(), SIPClient::sendRequest(), RTSPClient::sendRequest(), DarwinInjector::setDestination(), RTSPClient::setupHTTPTunneling1(), QuickTimeFileSink::setWord(), AVIFileSink::setWord(), QuickTimeFileSink::setWord64(), SIPClient::SIPClient(), AMRAudioRTPSink::sourceIsCompatibleWithUs(), QuickTimeFileSink::startPlaying(), StreamState::startPlaying(), MediaSink::startPlaying(), AVIFileSink::startPlaying(), startPlayingSession(), PassiveServerMediaSubsession::startStream(), MediaSink::stopPlaying(), tearDownSession(), SIPClient::timerAHandler(), SIPClient::timerBHandler(), SIPClient::timerDHandler(), ClientTrickPlayState::updateStateOnScaleChange(), MPEG2TransportStreamFramer::updateTSPacketDurationEstimate(), BasicUDPSource::~BasicUDPSource(), ByteStreamFileSource::~ByteStreamFileSource(), RTSPOverHTTPServer::HTTPClientConnection::~HTTPClientConnection(), and RTSPServer::~RTSPServer().

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 86 of file Media.cpp.

References False.

Referenced by MediaSource::lookupByName().

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

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

Reimplemented in MediaSink.

Definition at line 90 of file Media.cpp.

References False.

Referenced by MediaSink::lookupByName().

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

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

Reimplemented in RTSPClient.

Definition at line 98 of file Media.cpp.

References False.

Referenced by RTSPClient::lookupByName().

00098                                    {
00099   return False; // default implementation
00100 }

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

Reimplemented in RTSPServer.

Definition at line 102 of file Media.cpp.

References False.

Referenced by RTSPServer::lookupByName().

00102                                    {
00103   return False; // default implementation
00104 }

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

Reimplemented in MediaSession.

Definition at line 106 of file Media.cpp.

References False.

Referenced by MediaSession::lookupByName().

00106                                      {
00107   return False; // default implementation
00108 }

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

Reimplemented in ServerMediaSession.

Definition at line 110 of file Media.cpp.

References False.

Referenced by ServerMediaSession::lookupByName().

00110                                            {
00111   return False; // default implementation
00112 }

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

Reimplemented in DarwinInjector.

Definition at line 114 of file Media.cpp.

References False.

Referenced by DarwinInjector::lookupByName().

00114                                        {
00115   return False; // default implementation
00116 }

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

Definition at line 77 of file Media.hh.

References Medium::fNextTask.

Referenced by BasicUDPSink::afterGettingFrame1(), MPEG4VideoFileServerMediaSubsession::afterPlayingDummy1(), MPEG4VideoFileServerMediaSubsession::checkForAuxSDPLine1(), WAVAudioFileSource::doGetNextFrame(), MP3FileSource::doGetNextFrame(), AMRAudioFileSource::doGetNextFrame(), ADTSAudioFileSource::doGetNextFrame(), MultiFramedRTPSource::doGetNextFrame1(), ByteStreamFileSource::doReadFromFile(), reschedule(), schedule(), MultiFramedRTPSink::sendPacketIfNecessary(), and MediaSink::stopPlaying().

00077                         {
00078         return fNextTask;
00079   }

Field Documentation

unsigned char* RTCPInstance::fInBuf [private]

Definition at line 133 of file RTCP.hh.

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

unsigned RTCPInstance::fNumBytesAlreadyRead [private]

Definition at line 134 of file RTCP.hh.

Referenced by incomingReportHandler1(), and RTCPInstance().

OutPacketBuffer* RTCPInstance::fOutBuf [private]

Definition at line 135 of file RTCP.hh.

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

RTPInterface RTCPInstance::fRTCPInterface [private]

Definition at line 136 of file RTCP.hh.

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

unsigned RTCPInstance::fTotSessionBW [private]

Definition at line 137 of file RTCP.hh.

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

RTPSink* RTCPInstance::fSink [private]

Definition at line 138 of file RTCP.hh.

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

RTPSource const* RTCPInstance::fSource [private]

Definition at line 139 of file RTCP.hh.

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

Boolean RTCPInstance::fIsSSMSource [private]

Definition at line 140 of file RTCP.hh.

Referenced by incomingReportHandler1().

SDESItem RTCPInstance::fCNAME [private]

Definition at line 142 of file RTCP.hh.

Referenced by addSDES().

RTCPMemberDatabase* RTCPInstance::fKnownMembers [private]

Definition at line 143 of file RTCP.hh.

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

unsigned RTCPInstance::fOutgoingReportCount [private]

Definition at line 144 of file RTCP.hh.

Referenced by checkNewSSRC(), and sendReport().

double RTCPInstance::fAveRTCPSize [private]

Definition at line 146 of file RTCP.hh.

Referenced by onExpire1().

int RTCPInstance::fIsInitial [private]

Definition at line 147 of file RTCP.hh.

Referenced by onExpire1().

double RTCPInstance::fPrevReportTime [private]

Definition at line 148 of file RTCP.hh.

Referenced by onExpire1(), and RTCPInstance().

double RTCPInstance::fNextReportTime [private]

Definition at line 149 of file RTCP.hh.

Referenced by RTCPInstance(), and schedule().

int RTCPInstance::fPrevNumMembers [private]

Definition at line 150 of file RTCP.hh.

Referenced by onExpire1().

int RTCPInstance::fLastSentSize [private]

Definition at line 152 of file RTCP.hh.

Referenced by sendBuiltPacket(), and sentPacketSize().

int RTCPInstance::fLastReceivedSize [private]

Definition at line 153 of file RTCP.hh.

Referenced by receivedPacketSize().

u_int32_t RTCPInstance::fLastReceivedSSRC [private]

Definition at line 154 of file RTCP.hh.

Referenced by checkNewSSRC(), and removeLastReceivedSSRC().

int RTCPInstance::fTypeOfEvent [private]

Definition at line 155 of file RTCP.hh.

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

int RTCPInstance::fTypeOfPacket [private]

Definition at line 156 of file RTCP.hh.

Referenced by packetType().

Boolean RTCPInstance::fHaveJustSentPacket [private]

Definition at line 157 of file RTCP.hh.

Referenced by incomingReportHandler1(), and sendBuiltPacket().

unsigned RTCPInstance::fLastPacketSentSize [private]

Definition at line 158 of file RTCP.hh.

Referenced by incomingReportHandler1(), and sendBuiltPacket().

TaskFunc* RTCPInstance::fByeHandlerTask [private]

Definition at line 160 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setByeHandler().

void* RTCPInstance::fByeHandlerClientData [private]

Definition at line 161 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setByeHandler().

Boolean RTCPInstance::fByeHandleActiveParticipantsOnly [private]

Definition at line 162 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setByeHandler().

TaskFunc* RTCPInstance::fSRHandlerTask [private]

Definition at line 163 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setSRHandler().

void* RTCPInstance::fSRHandlerClientData [private]

Definition at line 164 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setSRHandler().

TaskFunc* RTCPInstance::fRRHandlerTask [private]

Definition at line 165 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setRRHandler().

void* RTCPInstance::fRRHandlerClientData [private]

Definition at line 166 of file RTCP.hh.

Referenced by incomingReportHandler1(), and setRRHandler().

AddressPortLookupTable* RTCPInstance::fSpecificRRHandlerTable [private]

Definition at line 167 of file RTCP.hh.

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

The documentation for this class was generated from the following files:
Generated on Fri Sep 3 02:37:44 2010 for live by  doxygen 1.5.2