RTPInterface Class Reference

#include <RTPInterface.hh>

Collaboration diagram for RTPInterface:

Collaboration graph
[legend]

Public Member Functions

 RTPInterface (Medium *owner, Groupsock *gs)
virtual ~RTPInterface ()
Groupsock * gs () 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 ()
UsageEnvironment & envir () 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

Medium * fOwner
Groupsock * fGS
tcpStreamRecord * fTCPStreams
unsigned short fNextTCPReadSize
int fNextTCPReadStreamSocketNum
unsigned char fNextTCPReadStreamChannelId
TaskScheduler::BackgroundHandlerProc * fReadHandlerProc
AuxHandlerFunc * fAuxReadHandlerFunc
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