RTPInterface Class Reference

#include <RTPInterface.hh>

Collaboration diagram for RTPInterface:


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 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 111 of file RTPInterface.cpp.

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

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

RTPInterface::~RTPInterface ( ) [virtual]

Definition at line 125 of file RTPInterface.cpp.

References fTCPStreams.

00125                             {
00126   delete fTCPStreams;
00127 }

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 129 of file RTPInterface.cpp.

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

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

00130                                                                   {
00131   fGS->removeAllDestinations();
00132   addStreamSocket(sockNum, streamChannelId);
00133 }

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

Definition at line 135 of file RTPInterface.cpp.

References fTCPStreams, and NULL.

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

00136                                                                   {
00137   if (sockNum < 0) return;
00138 
00139   for (tcpStreamRecord* streams = fTCPStreams; streams != NULL;
00140        streams = streams->fNext) {
00141     if (streams->fStreamSocketNum == sockNum
00142         && streams->fStreamChannelId == streamChannelId) {
00143       return; // we already have it
00144     }
00145   }
00146 
00147   fTCPStreams = new tcpStreamRecord(sockNum, streamChannelId, fTCPStreams);
00148 }

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

Definition at line 159 of file RTPInterface.cpp.

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

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

00160                                                                      {
00161   for (tcpStreamRecord** streamsPtr = &fTCPStreams; *streamsPtr != NULL;
00162        streamsPtr = &((*streamsPtr)->fNext)) {
00163     if ((*streamsPtr)->fStreamSocketNum == sockNum
00164         && (*streamsPtr)->fStreamChannelId == streamChannelId) {
00165       deregisterSocket(envir(), sockNum, streamChannelId);
00166 
00167       // Then remove the record pointed to by *streamsPtr :
00168       tcpStreamRecord* next = (*streamsPtr)->fNext;
00169       (*streamsPtr)->fNext = NULL;
00170       delete (*streamsPtr);
00171       *streamsPtr = next;
00172       return;
00173     }
00174   }
00175 }

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

Definition at line 178 of file RTPInterface.cpp.

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

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

00178                                                                                                                       {
00179   SocketDescriptor* socketDescriptor = lookupSocketDescriptor(envir(), socketNum);
00180 
00181   if (socketDescriptor != NULL) socketDescriptor->setServerRequestAlternativeByteHandler(handler, clientData);
00182 }

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

Definition at line 185 of file RTPInterface.cpp.

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

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

00185                                                                            {
00186   Boolean success = True; // we'll return False instead if any of the sends fail
00187 
00188   // Normal case: Send as a UDP packet:
00189   if (!fGS->output(envir(), fGS->ttl(), packet, packetSize)) success = False;
00190 
00191   // Also, send over each of our TCP sockets:
00192   for (tcpStreamRecord* streams = fTCPStreams; streams != NULL;
00193        streams = streams->fNext) {
00194     if (!sendRTPOverTCP(packet, packetSize,
00195                         streams->fStreamSocketNum, streams->fStreamChannelId)) {
00196       success = False;
00197     }
00198   }
00199 
00200   return success;
00201 }

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

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

00204                                                                      {
00205   // Normal case: Arrange to read UDP packets:
00206   envir().taskScheduler().
00207     turnOnBackgroundReadHandling(fGS->socketNum(), handlerProc, fOwner);
00208 
00209   // Also, receive RTP over TCP, on each of our TCP connections:
00210   fReadHandlerProc = handlerProc;
00211   for (tcpStreamRecord* streams = fTCPStreams; streams != NULL;
00212        streams = streams->fNext) {
00213     // Get a socket descriptor for "streams->fStreamSocketNum":
00214     SocketDescriptor* socketDescriptor = lookupSocketDescriptor(envir(), streams->fStreamSocketNum);
00215 
00216     // Tell it about our subChannel:
00217     socketDescriptor->registerRTPInterface(streams->fStreamChannelId, this);
00218   }
00219 }

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

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

00222                                                                                                                          {
00223   packetReadWasIncomplete = False; // by default
00224   Boolean readSuccess;
00225   if (fNextTCPReadStreamSocketNum < 0) {
00226     // Normal case: read from the (datagram) 'groupsock':
00227     readSuccess = fGS->handleRead(buffer, bufferMaxSize, bytesRead, fromAddress);
00228   } else {
00229     // Read from the TCP connection:
00230     bytesRead = 0;
00231     unsigned totBytesToRead = fNextTCPReadSize;
00232     if (totBytesToRead > bufferMaxSize) totBytesToRead = bufferMaxSize;
00233     unsigned curBytesToRead = totBytesToRead;
00234     int curBytesRead;
00235     while ((curBytesRead = readSocket(envir(), fNextTCPReadStreamSocketNum,
00236                                       &buffer[bytesRead], curBytesToRead,
00237                                       fromAddress)) > 0) {
00238       bytesRead += curBytesRead;
00239       if (bytesRead >= totBytesToRead) break;
00240       curBytesToRead -= curBytesRead;
00241     }
00242     fNextTCPReadSize -= bytesRead;
00243     if (curBytesRead == 0 && curBytesToRead > 0) {
00244       packetReadWasIncomplete = True;
00245       return True;
00246     } else if (curBytesRead < 0) {
00247       bytesRead = 0;
00248       readSuccess = False;
00249     } else {
00250       readSuccess = True;
00251     }
00252     fNextTCPReadStreamSocketNum = -1; // default, for next time
00253   }
00254 
00255   if (readSuccess && fAuxReadHandlerFunc != NULL) {
00256     // Also pass the newly-read packet data to our auxilliary handler:
00257     (*fAuxReadHandlerFunc)(fAuxReadHandlerClientData, buffer, bytesRead);
00258   }
00259   return readSuccess;
00260 }

void RTPInterface::stopNetworkReading ( )

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

00262                                       {
00263   // Normal case
00264   envir().taskScheduler().turnOffBackgroundReadHandling(fGS->socketNum());
00265 
00266   // Also turn off read handling on each of our TCP connections:
00267   for (tcpStreamRecord* streams = fTCPStreams; streams != NULL;
00268        streams = streams->fNext) {
00269     deregisterSocket(envir(), streams->fStreamSocketNum, streams->fStreamChannelId);
00270   }
00271 }

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

Definition at line 74 of file RTPInterface.hh.

References Medium::envir(), and fOwner.

Referenced by handleRead(), removeStreamSocket(), RTPInterface(), 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; }

Friends And Related Function Documentation

friend class SocketDescriptor [friend]

Definition at line 87 of file RTPInterface.hh.

Field Documentation

Medium* RTPInterface::fOwner [private]

Definition at line 88 of file RTPInterface.hh.

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

Groupsock* RTPInterface::fGS [private]

Definition at line 89 of file RTPInterface.hh.

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

tcpStreamRecord* RTPInterface::fTCPStreams [private]

Definition at line 90 of file RTPInterface.hh.

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

unsigned short RTPInterface::fNextTCPReadSize [private]

Definition at line 92 of file RTPInterface.hh.

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

int RTPInterface::fNextTCPReadStreamSocketNum [private]

Definition at line 94 of file RTPInterface.hh.

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

unsigned char RTPInterface::fNextTCPReadStreamChannelId [private]

Definition at line 95 of file RTPInterface.hh.

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

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

Definition at line 96 of file RTPInterface.hh.

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

AuxHandlerFunc* RTPInterface::fAuxReadHandlerFunc [private]

Definition at line 98 of file RTPInterface.hh.

Referenced by handleRead(), and setAuxilliaryReadHandler().

void* RTPInterface::fAuxReadHandlerClientData [private]

Definition at line 99 of file RTPInterface.hh.

Referenced by handleRead(), and setAuxilliaryReadHandler().

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

liveMedia/include/RTPInterface.hh
liveMedia/RTPInterface.cpp

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

1.5.2

RTPInterface Class Reference

Public Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Field Documentation