SocketDescriptor Class Reference

Collaboration diagram for SocketDescriptor:

[legend]

Public Member Functions
	SocketDescriptor (UsageEnvironment &env, int socketNum)
virtual	~SocketDescriptor ()
void	registerRTPInterface (unsigned char streamChannelId, RTPInterface *rtpInterface)
RTPInterface *	lookupRTPInterface (unsigned char streamChannelId)
void	deregisterRTPInterface (unsigned char streamChannelId)
Static Private Member Functions
static void	tcpReadHandler (SocketDescriptor *, int mask)
Private Attributes
UsageEnvironment &	fEnv
int	fOurSocketNum
HashTable *	fSubChannelHashTable

---

Detailed Description

Definition at line 49 of file RTPInterface.cpp.

---

Constructor & Destructor Documentation

SocketDescriptor::SocketDescriptor	(	UsageEnvironment &	env,
		int	socketNum
	)

Definition at line 278 of file RTPInterface.cpp.

  : fEnv(env), fOurSocketNum(socketNum),
    fSubChannelHashTable(HashTable::create(ONE_WORD_HASH_KEYS)) {
}

SocketDescriptor::~SocketDescriptor

(

)

[virtual]

Definition at line 283 of file RTPInterface.cpp.

References fSubChannelHashTable.

                                    {
  delete fSubChannelHashTable;
}

---

Member Function Documentation

void SocketDescriptor::registerRTPInterface	(	unsigned char	streamChannelId,
		RTPInterface *	rtpInterface
	)

Definition at line 287 of file RTPInterface.cpp.

References HashTable::Add(), fEnv, fOurSocketNum, fSubChannelHashTable, HashTable::IsEmpty(), UsageEnvironment::taskScheduler(), and tcpReadHandler().

                                                                        {
  Boolean isFirstRegistration = fSubChannelHashTable->IsEmpty();
  fSubChannelHashTable->Add((char const*)(long)streamChannelId,
                            rtpInterface);

  if (isFirstRegistration) {
    // Arrange to handle reads on this TCP socket:
    TaskScheduler::BackgroundHandlerProc* handler
      = (TaskScheduler::BackgroundHandlerProc*)&tcpReadHandler;
    fEnv.taskScheduler().
      turnOnBackgroundReadHandling(fOurSocketNum, handler, this);
  }
}

RTPInterface * SocketDescriptor::lookupRTPInterface

(

unsigned char

streamChannelId

)

Definition at line 303 of file RTPInterface.cpp.

References fSubChannelHashTable, and HashTable::Lookup().

Referenced by tcpReadHandler().

                                                  {
  char const* lookupArg = (char const*)(long)streamChannelId;
  return (RTPInterface*)(fSubChannelHashTable->Lookup(lookupArg));
}

void SocketDescriptor::deregisterRTPInterface

(

unsigned char

streamChannelId

)

Definition at line 309 of file RTPInterface.cpp.

References fEnv, fOurSocketNum, fSubChannelHashTable, HashTable::IsEmpty(), HashTable::Remove(), removeSocketDescription(), UsageEnvironment::taskScheduler(), and TaskScheduler::turnOffBackgroundReadHandling().

                                                      {
  fSubChannelHashTable->Remove((char const*)(long)streamChannelId);

  if (fSubChannelHashTable->IsEmpty()) {
    // No more interfaces are using us, so it's curtains for us now
    fEnv.taskScheduler().turnOffBackgroundReadHandling(fOurSocketNum);
    removeSocketDescription(fEnv, fOurSocketNum);
    delete this;
  }
}

void SocketDescriptor::tcpReadHandler	(	SocketDescriptor *	,
		int	mask
	)			[static, private]

Definition at line 320 of file RTPInterface.cpp.

References env, fEnv, RTPInterface::fNextTCPReadSize, RTPInterface::fNextTCPReadStreamChannelId, RTPInterface::fNextTCPReadStreamSocketNum, fOurSocketNum, RTPInterface::fOwner, RTPInterface::fReadHandlerProc, lookupRTPInterface(), NULL, readSocket(), readSocketExact(), size, UsageEnvironment::taskScheduler(), and TaskScheduler::turnOffBackgroundReadHandling().

Referenced by registerRTPInterface().

                                                {
  do {
    UsageEnvironment& env = socketDescriptor->fEnv; // abbrev
    int socketNum = socketDescriptor->fOurSocketNum;

    // Begin by reading and discarding any characters that aren't '$'.
    // Any such characters are probably regular RTSP responses or
    // commands from the server.  At present, we can't do anything with
    // these, because we have taken complete control of reading this socket.
    // (Later, fix) #####
    unsigned char c;
    struct sockaddr_in fromAddress;
    struct timeval timeout; timeout.tv_sec = 0; timeout.tv_usec = 0;
    do {
      int result = readSocket(env, socketNum, &c, 1, fromAddress, &timeout);
      if (result != 1) { // error reading TCP socket
        if (result < 0) {
          env.taskScheduler().turnOffBackgroundReadHandling(socketNum); // stops further calls to us
        }
        return;
      }
    } while (c != '$');

    // The next byte is the stream channel id:
    unsigned char streamChannelId;
    if (readSocket(env, socketNum, &streamChannelId, 1, fromAddress)
        != 1) break;
    RTPInterface* rtpInterface
      = socketDescriptor->lookupRTPInterface(streamChannelId);
    if (rtpInterface == NULL) break; // we're not interested in this channel

    // The next two bytes are the RTP or RTCP packet size (in network order)
    unsigned short size;
    if (readSocketExact(env, socketNum, (unsigned char*)&size, 2,
                        fromAddress) != 2) break;
    rtpInterface->fNextTCPReadSize = ntohs(size);
    rtpInterface->fNextTCPReadStreamSocketNum = socketNum;
    rtpInterface->fNextTCPReadStreamChannelId = streamChannelId;
#ifdef DEBUG
    fprintf(stderr, "SocketDescriptor::tcpReadHandler() reading %d bytes on channel %d\n", rtpInterface->fNextTCPReadSize, streamChannelId);
#endif

    // Now that we have the data set up, call this subchannel's
    // read handler:
    if (rtpInterface->fReadHandlerProc != NULL) {
      rtpInterface->fReadHandlerProc(rtpInterface->fOwner, mask);
    }

  } while (0);
}

---

Field Documentation

UsageEnvironment& SocketDescriptor::fEnv [private]

Definition at line 63 of file RTPInterface.cpp.

Referenced by deregisterRTPInterface(), registerRTPInterface(), and tcpReadHandler().

int SocketDescriptor::fOurSocketNum [private]

Definition at line 64 of file RTPInterface.cpp.

Referenced by deregisterRTPInterface(), registerRTPInterface(), and tcpReadHandler().

HashTable* SocketDescriptor::fSubChannelHashTable [private]

Definition at line 65 of file RTPInterface.cpp.

Referenced by deregisterRTPInterface(), lookupRTPInterface(), registerRTPInterface(), and ~SocketDescriptor().

---

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

• liveMedia/RTPInterface.cpp

---