RTPInterface Class Reference

#include <RTPInterface.hh>

Collaboration diagram for RTPInterface:

Collaboration graph
[legend]

Public Member Functions

 RTPInterface (Medium *owner, Groupsock *gs)
virtual ~RTPInterface ()
Groupsockgs () const
void setStreamSocket (int sockNum, unsigned char streamChannelId)
void addStreamSocket (int sockNum, unsigned char streamChannelId)
void removeStreamSocket (int sockNum, unsigned char streamChannelId)
void setServerRequestAlternativeByteHandler (int socketNum, ServerRequestAlternativeByteHandler *handler, void *clientData)
Boolean sendPacket (unsigned char *packet, unsigned packetSize)
void startNetworkReading (TaskScheduler::BackgroundHandlerProc *handlerProc)
Boolean handleRead (unsigned char *buffer, unsigned bufferMaxSize, unsigned &bytesRead, struct sockaddr_in &fromAddress, Boolean &packetReadWasIncomplete)
void stopNetworkReading ()
UsageEnvironmentenvir () const
void setAuxilliaryReadHandler (AuxHandlerFunc *handlerFunc, void *handlerClientData)
int nextTCPReadStreamSocketNum () const
unsigned char nextTCPReadStreamChannelId () const

Private Member Functions

Boolean sendRTPorRTCPPacketOverTCP (unsigned char *packet, unsigned packetSize, int socketNum, unsigned char streamChannelId)
Boolean sendDataOverTCP (int socketNum, u_int8_t const *data, unsigned dataSize, Boolean forceSendToSucceed)

Private Attributes

MediumfOwner
GroupsockfGS
tcpStreamRecordfTCPStreams
unsigned short fNextTCPReadSize
int fNextTCPReadStreamSocketNum
unsigned char fNextTCPReadStreamChannelId
TaskScheduler::BackgroundHandlerProcfReadHandlerProc
AuxHandlerFuncfAuxReadHandlerFunc
void * fAuxReadHandlerClientData

Friends

class SocketDescriptor

Detailed Description

Definition at line 55 of file RTPInterface.hh.


Constructor & Destructor Documentation

RTPInterface::RTPInterface ( Medium owner,
Groupsock gs 
)

Definition at line 117 of file RTPInterface.cpp.

References envir(), fGS, increaseSendBufferTo(), makeSocketNonBlocking(), and Socket::socketNum().

00118   : fOwner(owner), fGS(gs),
00119     fTCPStreams(NULL),
00120     fNextTCPReadSize(0), fNextTCPReadStreamSocketNum(-1),
00121     fNextTCPReadStreamChannelId(0xFF), fReadHandlerProc(NULL),
00122     fAuxReadHandlerFunc(NULL), fAuxReadHandlerClientData(NULL) {
00123   // Make the socket non-blocking, even though it will be read from only asynchronously, when packets arrive.
00124   // The reason for this is that, in some OSs, reads on a blocking socket can (allegedly) sometimes block,
00125   // even if the socket was previously reported (e.g., by "select()") as having data available.
00126   // (This can supposedly happen if the UDP checksum fails, for example.)
00127   makeSocketNonBlocking(fGS->socketNum());
00128   increaseSendBufferTo(envir(), fGS->socketNum(), 50*1024);
00129 }

RTPInterface::~RTPInterface (  )  [virtual]

Definition at line 131 of file RTPInterface.cpp.

References fTCPStreams.

00131                             {
00132   delete fTCPStreams;
00133 }


Member Function Documentation

Groupsock* RTPInterface::gs (  )  const [inline]

Definition at line 60 of file RTPInterface.hh.

References fGS.

Referenced by RTCPInstance::addStreamSocket(), RTPSink::groupsockBeingUsed(), RTCPInstance::RTCPgs(), and RTPSource::RTPgs().

00060 { return fGS; }

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

Definition at line 135 of file RTPInterface.cpp.

References addStreamSocket(), fGS, and Groupsock::removeAllDestinations().

Referenced by RTCPInstance::setStreamSocket(), RTPSource::setStreamSocket(), and RTPSink::setStreamSocket().

00136                                                                   {
00137   fGS->removeAllDestinations();
00138   addStreamSocket(sockNum, streamChannelId);
00139 }

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

Definition at line 141 of file RTPInterface.cpp.

References fTCPStreams, and NULL.

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

00142                                                                   {
00143   if (sockNum < 0) return;
00144 
00145   for (tcpStreamRecord* streams = fTCPStreams; streams != NULL;
00146        streams = streams->fNext) {
00147     if (streams->fStreamSocketNum == sockNum
00148         && streams->fStreamChannelId == streamChannelId) {
00149       return; // we already have it
00150     }
00151   }
00152 
00153   fTCPStreams = new tcpStreamRecord(sockNum, streamChannelId, fTCPStreams);
00154 
00155   // Also, make sure this new socket is set up for receiving RTP/RTCP-over-TCP:
00156   SocketDescriptor* socketDescriptor = lookupSocketDescriptor(envir(), sockNum);
00157   socketDescriptor->registerRTPInterface(streamChannelId, this);
00158 }

void RTPInterface::removeStreamSocket ( int  sockNum,
unsigned char  streamChannelId 
)

Definition at line 169 of file RTPInterface.cpp.

References deregisterSocket(), envir(), fTCPStreams, and NULL.

Referenced by RTPSink::removeStreamSocket(), and RTCPInstance::removeStreamSocket().

00170                                                                      {
00171   for (tcpStreamRecord** streamsPtr = &fTCPStreams; *streamsPtr != NULL;
00172        streamsPtr = &((*streamsPtr)->fNext)) {
00173     if ((*streamsPtr)->fStreamSocketNum == sockNum
00174         && (*streamsPtr)->fStreamChannelId == streamChannelId) {
00175       deregisterSocket(envir(), sockNum, streamChannelId);
00176 
00177       // Then remove the record pointed to by *streamsPtr :
00178       tcpStreamRecord* next = (*streamsPtr)->fNext;
00179       (*streamsPtr)->fNext = NULL;
00180       delete (*streamsPtr);
00181       *streamsPtr = next;
00182       return;
00183     }
00184   }
00185 }

void RTPInterface::setServerRequestAlternativeByteHandler ( int  socketNum,
ServerRequestAlternativeByteHandler handler,
void *  clientData 
)

Definition at line 188 of file RTPInterface.cpp.

References envir(), lookupSocketDescriptor(), NULL, and SocketDescriptor::setServerRequestAlternativeByteHandler().

Referenced by RTPSource::setServerRequestAlternativeByteHandler(), and RTPSink::setServerRequestAlternativeByteHandler().

00188                                                                                                                       {
00189   SocketDescriptor* socketDescriptor = lookupSocketDescriptor(envir(), socketNum);
00190 
00191   if (socketDescriptor != NULL) socketDescriptor->setServerRequestAlternativeByteHandler(handler, clientData);
00192 }

Boolean RTPInterface::sendPacket ( unsigned char *  packet,
unsigned  packetSize 
)

Definition at line 195 of file RTPInterface.cpp.

References envir(), False, fGS, fTCPStreams, NULL, Groupsock::output(), sendRTPorRTCPPacketOverTCP(), True, and Groupsock::ttl().

Referenced by RTCPInstance::incomingReportHandler1(), RTCPInstance::sendBuiltPacket(), and MultiFramedRTPSink::sendPacketIfNecessary().

00195                                                                            {
00196   Boolean success = True; // we'll return False instead if any of the sends fail
00197 
00198   // Normal case: Send as a UDP packet:
00199   if (!fGS->output(envir(), fGS->ttl(), packet, packetSize)) success = False;
00200 
00201   // Also, send over each of our TCP sockets:
00202   for (tcpStreamRecord* streams = fTCPStreams; streams != NULL;
00203        streams = streams->fNext) {
00204     if (!sendRTPorRTCPPacketOverTCP(packet, packetSize,
00205                                     streams->fStreamSocketNum, streams->fStreamChannelId)) {
00206       success = False;
00207     }
00208   }
00209 
00210   return success;
00211 }

void RTPInterface::startNetworkReading ( TaskScheduler::BackgroundHandlerProc handlerProc  ) 

Definition at line 214 of file RTPInterface.cpp.

References envir(), fGS, fOwner, fReadHandlerProc, fTCPStreams, lookupSocketDescriptor(), NULL, SocketDescriptor::registerRTPInterface(), Socket::socketNum(), and UsageEnvironment::taskScheduler().

Referenced by RTCPInstance::addStreamSocket(), MultiFramedRTPSource::doGetNextFrame(), RTCPInstance::RTCPInstance(), and RTCPInstance::setStreamSocket().

00214                                                                      {
00215   // Normal case: Arrange to read UDP packets:
00216   envir().taskScheduler().
00217     turnOnBackgroundReadHandling(fGS->socketNum(), handlerProc, fOwner);
00218 
00219   // Also, receive RTP over TCP, on each of our TCP connections:
00220   fReadHandlerProc = handlerProc;
00221   for (tcpStreamRecord* streams = fTCPStreams; streams != NULL;
00222        streams = streams->fNext) {
00223     // Get a socket descriptor for "streams->fStreamSocketNum":
00224     SocketDescriptor* socketDescriptor = lookupSocketDescriptor(envir(), streams->fStreamSocketNum);
00225 
00226     // Tell it about our subChannel:
00227     socketDescriptor->registerRTPInterface(streams->fStreamChannelId, this);
00228   }
00229 }

Boolean RTPInterface::handleRead ( unsigned char *  buffer,
unsigned  bufferMaxSize,
unsigned &  bytesRead,
struct sockaddr_in &  fromAddress,
Boolean packetReadWasIncomplete 
)

Definition at line 231 of file RTPInterface.cpp.

References envir(), False, fAuxReadHandlerClientData, fAuxReadHandlerFunc, fGS, fNextTCPReadSize, fNextTCPReadStreamSocketNum, Groupsock::handleRead(), NULL, readSocket(), and True.

Referenced by BufferedPacket::fillInData(), and RTCPInstance::incomingReportHandler1().

00232                                                                                                                          {
00233   packetReadWasIncomplete = False; // by default
00234   Boolean readSuccess;
00235   if (fNextTCPReadStreamSocketNum < 0) {
00236     // Normal case: read from the (datagram) 'groupsock':
00237     readSuccess = fGS->handleRead(buffer, bufferMaxSize, bytesRead, fromAddress);
00238   } else {
00239     // Read from the TCP connection:
00240     bytesRead = 0;
00241     unsigned totBytesToRead = fNextTCPReadSize;
00242     if (totBytesToRead > bufferMaxSize) totBytesToRead = bufferMaxSize;
00243     unsigned curBytesToRead = totBytesToRead;
00244     int curBytesRead;
00245     while ((curBytesRead = readSocket(envir(), fNextTCPReadStreamSocketNum,
00246                                       &buffer[bytesRead], curBytesToRead,
00247                                       fromAddress)) > 0) {
00248       bytesRead += curBytesRead;
00249       if (bytesRead >= totBytesToRead) break;
00250       curBytesToRead -= curBytesRead;
00251     }
00252     fNextTCPReadSize -= bytesRead;
00253     if (fNextTCPReadSize == 0) {
00254       // We've read all of the data that we asked for
00255       readSuccess = True;
00256     } else if (curBytesRead < 0) {
00257       // There was an error reading the socket
00258       bytesRead = 0;
00259       readSuccess = False;
00260     } else {
00261       // We need to read more bytes, and there was not an error reading the socket
00262       packetReadWasIncomplete = True;
00263       return True;
00264     }
00265     fNextTCPReadStreamSocketNum = -1; // default, for next time
00266   }
00267 
00268   if (readSuccess && fAuxReadHandlerFunc != NULL) {
00269     // Also pass the newly-read packet data to our auxilliary handler:
00270     (*fAuxReadHandlerFunc)(fAuxReadHandlerClientData, buffer, bytesRead);
00271   }
00272   return readSuccess;
00273 }

void RTPInterface::stopNetworkReading (  ) 

Definition at line 275 of file RTPInterface.cpp.

References deregisterSocket(), envir(), fGS, fTCPStreams, NULL, Socket::socketNum(), UsageEnvironment::taskScheduler(), and TaskScheduler::turnOffBackgroundReadHandling().

Referenced by MultiFramedRTPSource::doStopGettingFrames(), RTCPInstance::setStreamSocket(), MultiFramedRTPSource::~MultiFramedRTPSource(), and RTCPInstance::~RTCPInstance().

00275                                       {
00276   // Normal case
00277   envir().taskScheduler().turnOffBackgroundReadHandling(fGS->socketNum());
00278 
00279   // Also turn off read handling on each of our TCP connections:
00280   for (tcpStreamRecord* streams = fTCPStreams; streams != NULL;
00281        streams = streams->fNext) {
00282     deregisterSocket(envir(), streams->fStreamSocketNum, streams->fStreamChannelId);
00283   }
00284 }

UsageEnvironment& RTPInterface::envir (  )  const [inline]

Definition at line 74 of file RTPInterface.hh.

References Medium::envir(), and fOwner.

Referenced by handleRead(), removeStreamSocket(), RTPInterface(), sendDataOverTCP(), sendPacket(), setServerRequestAlternativeByteHandler(), startNetworkReading(), and stopNetworkReading().

00074 { return fOwner->envir(); }

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

Definition at line 76 of file RTPInterface.hh.

References fAuxReadHandlerClientData, and fAuxReadHandlerFunc.

Referenced by RTPSource::setAuxilliaryReadHandler(), and RTCPInstance::setAuxilliaryReadHandler().

00077                                                          {
00078     fAuxReadHandlerFunc = handlerFunc;
00079     fAuxReadHandlerClientData = handlerClientData;
00080   }

int RTPInterface::nextTCPReadStreamSocketNum (  )  const [inline]

Definition at line 83 of file RTPInterface.hh.

References fNextTCPReadStreamSocketNum.

Referenced by RTCPInstance::incomingReportHandler1().

00083 { return fNextTCPReadStreamSocketNum; }

unsigned char RTPInterface::nextTCPReadStreamChannelId (  )  const [inline]

Definition at line 84 of file RTPInterface.hh.

References fNextTCPReadStreamChannelId.

Referenced by RTCPInstance::incomingReportHandler1().

00084 { return fNextTCPReadStreamChannelId; }

Boolean RTPInterface::sendRTPorRTCPPacketOverTCP ( unsigned char *  packet,
unsigned  packetSize,
int  socketNum,
unsigned char  streamChannelId 
) [private]

Referenced by sendPacket().

Boolean RTPInterface::sendDataOverTCP ( int  socketNum,
u_int8_t const *  data,
unsigned  dataSize,
Boolean  forceSendToSucceed 
) [private]

Definition at line 321 of file RTPInterface.cpp.

References envir(), False, makeSocketBlocking(), makeSocketNonBlocking(), and True.

00321                                                                                                                         {
00322   if (send(socketNum, (char const*)data, dataSize, 0/*flags*/) != (int)dataSize) {
00323     // The TCP send() failed.
00324 
00325     if (forceSendToSucceed && envir().getErrno() == EAGAIN) {
00326       // The OS's TCP send buffer has filled up (because the stream's bitrate has exceeded the capacity of the TCP connection!).
00327       // Force this data write to succeed, by blocking if necessary until it does:
00328 #ifdef DEBUG_SEND
00329       fprintf(stderr, "sendDataOverTCP: resending %d-byte send (blocking)\n", dataSize); fflush(stderr);
00330 #endif
00331       makeSocketBlocking(socketNum);
00332       Boolean sendSuccess = send(socketNum, (char const*)data, dataSize, 0/*flags*/) == (int)dataSize;
00333       makeSocketNonBlocking(socketNum);
00334       return sendSuccess;
00335     }
00336     return False;
00337   }
00338 
00339   return True;
00340 }


Friends And Related Function Documentation

friend class SocketDescriptor [friend]

Definition at line 93 of file RTPInterface.hh.


Field Documentation

Medium* RTPInterface::fOwner [private]

Definition at line 94 of file RTPInterface.hh.

Referenced by envir(), startNetworkReading(), and SocketDescriptor::tcpReadHandler1().

Groupsock* RTPInterface::fGS [private]

Definition at line 95 of file RTPInterface.hh.

Referenced by gs(), handleRead(), RTPInterface(), sendPacket(), setStreamSocket(), startNetworkReading(), and stopNetworkReading().

tcpStreamRecord* RTPInterface::fTCPStreams [private]

Definition at line 96 of file RTPInterface.hh.

Referenced by addStreamSocket(), removeStreamSocket(), sendPacket(), startNetworkReading(), stopNetworkReading(), and ~RTPInterface().

unsigned short RTPInterface::fNextTCPReadSize [private]

Definition at line 98 of file RTPInterface.hh.

Referenced by handleRead(), and SocketDescriptor::tcpReadHandler1().

int RTPInterface::fNextTCPReadStreamSocketNum [private]

Definition at line 100 of file RTPInterface.hh.

Referenced by handleRead(), nextTCPReadStreamSocketNum(), and SocketDescriptor::tcpReadHandler1().

unsigned char RTPInterface::fNextTCPReadStreamChannelId [private]

Definition at line 101 of file RTPInterface.hh.

Referenced by nextTCPReadStreamChannelId(), and SocketDescriptor::tcpReadHandler1().

TaskScheduler::BackgroundHandlerProc* RTPInterface::fReadHandlerProc [private]

Definition at line 102 of file RTPInterface.hh.

Referenced by startNetworkReading(), and SocketDescriptor::tcpReadHandler1().

AuxHandlerFunc* RTPInterface::fAuxReadHandlerFunc [private]

Definition at line 104 of file RTPInterface.hh.

Referenced by handleRead(), and setAuxilliaryReadHandler().

void* RTPInterface::fAuxReadHandlerClientData [private]

Definition at line 105 of file RTPInterface.hh.

Referenced by handleRead(), and setAuxilliaryReadHandler().


The documentation for this class was generated from the following files:
Generated on Mon Apr 29 13:32:29 2013 for live by  doxygen 1.5.2