庖丁解牛-----Live555源码彻底解密(根据MediaServer讲解Rtsp的建立过程)

live555MediaServer.cpp服务端源码讲解

int main(int argc, char** argv) {

// Begin by setting up our usage environment:

TaskScheduler* scheduler = BasicTaskScheduler::createNew();

UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);

UserAuthenticationDatabase* authDB = NULL;

// Create the RTSP server.  Try first with the default port number (554),

// and then with the alternative port number (8554):

RTSPServer* rtspServer;

portNumBits rtspServerPortNum = 554;

//先使用554默认端口建立Rtsp Server

rtspServer = DynamicRTSPServer::createNew(*env, rtspServerPortNum, authDB);

//如果建立不成功，使用8554建立rtsp server

if (rtspServer == NULL) {

rtspServerPortNum = 8554;

rtspServer = DynamicRTSPServer::createNew(*env, rtspServerPortNum, authDB);

}

if (rtspServer == NULL) {

*env << "Failed to create RTSP server: " << env->getResultMsg() << "\n";

// exit(1);

return -1;

}

env->taskScheduler().doEventLoop(); // does not return

return 0; // only to prevent compiler warning

}

跟踪进入CreateNew函数;

DynamicRTSPServer*

DynamicRTSPServer::createNew(UsageEnvironment&env,PortourPort,

UserAuthenticationDatabase*authDatabase,

unsigned reclamationTestSeconds) {

int ourSocket = setUpOurSocket(env,ourPort); //建立tcp socket

if (ourSocket == -1)returnNULL;

return new DynamicRTSPServer(env,ourSocket,ourPort,authDatabase,reclamationTestSeconds);

}

DynamicRTSPServer::DynamicRTSPServer(UsageEnvironment&env,intourSocket,

Port ourPort,

UserAuthenticationDatabase*authDatabase,unsignedreclamationTestSeconds)

: RTSPServerSupportingHTTPStreaming(env,ourSocket,ourPort,authDatabase,reclamationTestSeconds) {

}

首先建立socket，然后在调用DynamicRtspServer的构造函数，DynamicRtspServer继承RTSPServerSupportingHTTPStreaming类; RTSPServerSupportingHTTPStreaming类又继承RTSPServer类；

RTSPServerSupportingHTTPStreaming类的主要作用是支持Http；

接着看setUpOurSocket函数在前面已经讲过；就是建立socket；最后我们跟踪进入RTSPServer类的构造函数：

RTSPServer::RTSPServer(UsageEnvironment& env,

int ourSocket, Port ourPort,

UserAuthenticationDatabase* authDatabase,

unsigned reclamationTestSeconds)

: Medium(env),

fRTSPServerPort(ourPort), fRTSPServerSocket(ourSocket), fHTTPServerSocket(-1), fHTTPServerPort(0),

fServerMediaSessions(HashTable::create(STRING_HASH_KEYS)),

fClientConnections(HashTable::create(ONE_WORD_HASH_KEYS)),

fClientConnectionsForHTTPTunneling(NULL), // will get created if needed

fClientSessions(HashTable::create(STRING_HASH_KEYS)),

fPendingRegisterRequests(HashTable::create(ONE_WORD_HASH_KEYS)),

fAuthDB(authDatabase), fReclamationTestSeconds(reclamationTestSeconds) {

ignoreSigPipeOnSocket(ourSocket); // so that clients on the same host that are killed don't also kill us

// Arrange to handle connections from others:

env.taskScheduler().turnOnBackgroundReadHandling(fRTSPServerSocket,

(TaskScheduler::BackgroundHandlerProc*)&incomingConnectionHandlerRTSP,this);

}

当fRTSPServerSocket收到数据时，调用incomingConnectionHandlerRTSP回调函数，继续跟进到incomingConnectionHandlerRTSP函数，源码如下：

void RTSPServer::incomingConnectionHandlerRTSP(void* instance,int/*mask*/) {

RTSPServer* server = (RTSPServer*)instance;

server->incomingConnectionHandlerRTSP1();

}

void RTSPServer::incomingConnectionHandler(int serverSocket) {

struct sockaddr_in clientAddr;

SOCKLEN_T clientAddrLen = sizeof clientAddr;

int clientSocket = accept(serverSocket, (struct sockaddr*)&clientAddr, &clientAddrLen);

if (clientSocket < 0) {

int err = envir().getErrno();

if (err != EWOULDBLOCK) {

envir().setResultErrMsg("accept() failed: ");

}

return;

}

makeSocketNonBlocking(clientSocket);

increaseSendBufferTo(envir(), clientSocket, 50*1024);

#ifdef DEBUG

envir() << "accept()ed connection from " << AddressString(clientAddr).val() << "\n";

#endif

// Create a new object for handling this RTSP connection:

(void)createNewClientConnection(clientSocket, clientAddr);

}

当收到客户的连接时需保存下代表客户端的新socket，以后用这个socket与这个客户通讯。每个客户将来会对应一个rtp会话，而且各客户的RTSP请求只控制自己的rtp会话；

incomingConnectionHandler函数的作用是accept接受客户端的socket连接,然后设置clientSocket的属性,这里需要注意,我们在建立服务端socket时已经对服务端socket设置了非阻塞属性,这个地方又要设置accept后的clientSecket的属性;

incomingConnectionHandler函数最后调用createNewClientConnection函数，源码如下：

RTSPServer::RTSPClientConnection*

RTSPServer::createNewClientConnection(int clientSocket,struct sockaddr_in clientAddr) {

return new RTSPClientConnection(*this, clientSocket, clientAddr);

}

对于每个新建立的客户端连接请求,new RTSPClientConnection的对象进行管理;

RTSPServer::RTSPClientConnection

::RTSPClientConnection(RTSPServer& ourServer, int clientSocket, struct sockaddr_in clientAddr)

: fOurServer(ourServer), fIsActive(True),

fClientInputSocket(clientSocket), fClientOutputSocket(clientSocket), fClientAddr(clientAddr),

fRecursionCount(0), fOurSessionCookie(NULL) {

// Add ourself to our 'client connections' table:

fOurServer.fClientConnections->Add((charconst*)this,this);

// Arrange to handle incoming requests:

resetRequestBuffer();

envir().taskScheduler().setBackgroundHandling(fClientInputSocket, SOCKET_READABLE|SOCKET_EXCEPTION,

(TaskScheduler::BackgroundHandlerProc*)&incomingRequestHandler,this);

}

在该函数中首先对RTSPServer的成员变量进行赋值：

fOurServer= ourServer;

fClientInputSocket= clientSocket;

fClientOutputSocket= clientSocket;

fClientAddr= clientAddr;

setBackgroundHandling函数用来处理fClientInputSocket socket上收到数据，或异常时，调用incomingRequestHandler回调函数;

下面在跟进到incomingRequestHandler函数:

void RTSPServer::RTSPClientConnection::incomingRequestHandler(void* instance,int/*mask*/) {

RTSPClientConnection* session = (RTSPClientConnection*)instance;

session->incomingRequestHandler1();

}

Session 为刚才new的RTSPClientConnection 对象，这个地方需要调试验证下;调用成员函数incomingRequestHandler1;跟进到该成员函数的代码:

void RTSPServer::RTSPClientConnection::incomingRequestHandler1() {

struct sockaddr_in dummy; // 'from' address, meaningless in this case

int bytesRead = readSocket(envir(), fClientInputSocket, &fRequestBuffer[fRequestBytesAlreadySeen], fRequestBufferBytesLeft, dummy);

handleRequestBytes(bytesRead);

}

该函数调用ReadSocket从fClientInputSocket上读取数据；读到的数据保存在fRequestBuffer中，readSocket的返回值为实际读到的数据的长度；源码如下：

int readSocket(UsageEnvironment& env,

int socket, unsigned char* buffer, unsigned bufferSize,

struct sockaddr_in& fromAddress) {

SOCKLEN_T addressSize = sizeof fromAddress;

int bytesRead = recvfrom(socket, (char*)buffer, bufferSize, 0,

(struct sockaddr*)&fromAddress,

&addressSize);

if (bytesRead < 0) {

//##### HACK to work around bugs in Linux and Windows:

int err = env.getErrno();

if (err == 111 /*ECONNREFUSED (Linux)*/

#if defined(__WIN32__) ||defined(_WIN32)

// What a piece of crap Windows is. Sometimes

// recvfrom() returns -1, but with an 'errno' of 0.

// This appears not to be a real error; just treat

// it as if it were a read of zero bytes, and hope

// we don't have to do anything else to 'reset'

// this alleged error:

|| err == 0 || err == EWOULDBLOCK

#else

|| err == EAGAIN

#endif

|| err == 113 /*EHOSTUNREACH (Linux)*/) {// Why does Linux return this for datagram sock?

fromAddress.sin_addr.s_addr = 0;

return 0;

}

//##### END HACK

socketErr(env, "recvfrom() error: ");

} else if (bytesRead == 0) {

// "recvfrom()" on a stream socket can return 0 if the remote end has closed the connection. Treat this as an error:

return -1;

}

return bytesRead;

}

从socket中读到数据后必须对数据进行解析，解析的源码如下：

void RTSPServer::RTSPClientConnection::handleRequestBytes(int newBytesRead) {

int numBytesRemaining = 0;

++fRecursionCount;

do {

RTSPServer::RTSPClientSession* clientSession = NULL;

if (newBytesRead < 0 || (unsigned)newBytesRead >= fRequestBufferBytesLeft) {

// Either the client socket has died, or the request was too big for us.

// Terminate this connection:

#ifdef DEBUG

fprintf(stderr, "RTSPClientConnection[%p]::handleRequestBytes() read %d new bytes (of %d); terminating connection!\n", this, newBytesRead, fRequestBufferBytesLeft);

#endif

fIsActive = False;

break;

}

Boolean endOfMsg = False;

unsigned char* ptr = &fRequestBuffer[fRequestBytesAlreadySeen];

#ifdef DEBUG

ptr[newBytesRead] = '\0';

fprintf(stderr, "RTSPClientConnection[%p]::handleRequestBytes() %s %d new bytes:%s\n",

this, numBytesRemaining > 0 ? "processing" : "read", newBytesRead, ptr);

#endif

if (fClientOutputSocket != fClientInputSocket) {

// We're doing RTSP-over-HTTP tunneling, and input commands are assumed to have been Base64-encoded.

// We therefore Base64-decode as much of this new data as we can (i.e., up to a multiple of 4 bytes).

// But first, we remove any whitespace that may be in the input data:

unsigned toIndex = 0;

for (int fromIndex = 0; fromIndex < newBytesRead; ++fromIndex) {

char c = ptr[fromIndex];

if (!(c == ' ' || c == '\t' || c == '\r' || c == '\n')) { // not 'whitespace': space,tab,CR,NL

ptr[toIndex++] = c;

}

}

newBytesRead = toIndex;

unsigned numBytesToDecode = fBase64RemainderCount + newBytesRead;

unsigned newBase64RemainderCount = numBytesToDecode%4;

numBytesToDecode -= newBase64RemainderCount;

if (numBytesToDecode > 0) {

ptr[newBytesRead] = '\0';

unsigned decodedSize;

unsigned char* decodedBytes = base64Decode((char const*)(ptr-fBase64RemainderCount), numBytesToDecode, decodedSize);

#ifdef DEBUG

fprintf(stderr, "Base64-decoded %d input bytes into %d new bytes:", numBytesToDecode, decodedSize);

for (unsigned k = 0; k < decodedSize; ++k) fprintf(stderr, "%c", decodedBytes[k]);

fprintf(stderr, "\n");

#endif

// Copy the new decoded bytes in place of the old ones (we can do this because there are fewer decoded bytes than original):

unsigned char* to = ptr-fBase64RemainderCount;

for (unsigned i = 0; i < decodedSize; ++i) *to++ = decodedBytes[i];

// Then copy any remaining (undecoded) bytes to the end:

for (unsigned j = 0; j < newBase64RemainderCount; ++j) *to++ = (ptr-fBase64RemainderCount+numBytesToDecode)[j];

newBytesRead = decodedSize + newBase64RemainderCount; // adjust to allow for the size of the new decoded data (+ remainder)

delete[] decodedBytes;

}

fBase64RemainderCount = newBase64RemainderCount;

if (fBase64RemainderCount > 0)break;// because we know that we have more input bytes still to receive

}

// Look for the end of the message: <CR><LF><CR><LF>

unsigned char *tmpPtr = fLastCRLF + 2;

if (tmpPtr < fRequestBuffer) tmpPtr = fRequestBuffer;

while (tmpPtr < &ptr[newBytesRead-1]) {

if (*tmpPtr == '\r' && *(tmpPtr+1) == '\n') {

if (tmpPtr - fLastCRLF == 2) {// This is it:

endOfMsg = True;

break;

}

fLastCRLF = tmpPtr;

}

++tmpPtr;

}

fRequestBufferBytesLeft -= newBytesRead;

fRequestBytesAlreadySeen += newBytesRead;

if (!endOfMsg) break; // subsequent reads will be needed to complete the request

// Parse the request string into command name and 'CSeq', then handle the command:

fRequestBuffer[fRequestBytesAlreadySeen] = '\0';

char cmdName[RTSP_PARAM_STRING_MAX];

char urlPreSuffix[RTSP_PARAM_STRING_MAX];

char urlSuffix[RTSP_PARAM_STRING_MAX];

char cseq[RTSP_PARAM_STRING_MAX];

char sessionIdStr[RTSP_PARAM_STRING_MAX];

unsigned contentLength = 0;

fLastCRLF[2] = '\0'; // temporarily, for parsing

//解析Rtsp请求字符串

Boolean parseSucceeded = parseRTSPRequestString((char*)fRequestBuffer, fLastCRLF+2 - fRequestBuffer,

cmdName, sizeof cmdName,

urlPreSuffix, sizeof urlPreSuffix,

urlSuffix, sizeof urlSuffix,

cseq, sizeof cseq,

sessionIdStr, sizeof sessionIdStr,

contentLength);

fLastCRLF[2] = '\r'; // restore its value

if (parseSucceeded) {

#ifdef DEBUG

fprintf(stderr, "parseRTSPRequestString() succeeded, returning cmdName \"%s\", urlPreSuffix \"%s\", urlSuffix \"%s\", CSeq \"%s\", Content-Length %u, with %d bytes following the message.\n", cmdName, urlPreSuffix, urlSuffix, cseq, contentLength, ptr + newBytesRead - (tmpPtr + 2));

#endif

// If there was a "Content-Length:" header, then make sure we've received all of the data that it specified:

if (ptr + newBytesRead < tmpPtr + 2 + contentLength)break;// we still need more data; subsequent reads will give it to us

// We now have a complete RTSP request.

// Handle the specified command (beginning by checking those that don't require session ids):

fCurrentCSeq = cseq;

//收到客户端的OPTIONS请求

if (strcmp(cmdName, "OPTIONS") == 0) {

// If the request included a "Session:" id, and it refers to a client session that's current ongoing, then use this

// command to indicate 'liveness' on that client session:

if (sessionIdStr[0] != '\0') {

clientSession = (RTSPServer::RTSPClientSession*)(fOurServer.fClientSessions->Lookup(sessionIdStr));

//根据sessionIdStr查表，看该客户端的会话是否存在,存在会话，调用noteLiveness函数

if (clientSession != NULL) clientSession->noteLiveness();

}

//处理Opinion请求,构建应答包

handleCmd_OPTIONS();

} else if (urlPreSuffix[0] == '\0' && urlSuffix[0] =='*' && urlSuffix[1] =='\0') {

// The special "*" URL means: an operation on the entire server. This works only for GET_PARAMETER and SET_PARAMETER:

if (strcmp(cmdName, "GET_PARAMETER") == 0) {

handleCmd_GET_PARAMETER((charconst*)fRequestBuffer);

} else if (strcmp(cmdName, "SET_PARAMETER") == 0) {

handleCmd_SET_PARAMETER((charconst*)fRequestBuffer);

} else {

handleCmd_notSupported();

}

} else if (strcmp(cmdName, "DESCRIBE") == 0) {

//收到客户端的Describe请求,处理该请求，构建应答包

handleCmd_DESCRIBE(urlPreSuffix, urlSuffix, (charconst*)fRequestBuffer);

} else if (strcmp(cmdName, "SETUP") == 0) {

//收到客户端的Setup请求,如果是第一次Setup，那么就需要调用createNewClientSession函数进行会话，然后将sessionIdStr和clientSession关联起来

if (sessionIdStr[0] == '\0') {

// No session id was present in the request. So create a new "RTSPClientSession" object for this request.

// Choose a random (unused) 32-bit integer for the session id (it will be encoded as a 8-digit hex number).

// (We avoid choosing session id 0, because that has a special use (by "OnDemandServerMediaSubsession").)

u_int32_t sessionId;

do {

sessionId = (u_int32_t)our_random32();

sprintf(sessionIdStr, "%08X", sessionId);

} while (sessionId == 0 || fOurServer.fClientSessions->Lookup(sessionIdStr) != NULL);

clientSession = fOurServer.createNewClientSession(sessionId);

fOurServer.fClientSessions->Add(sessionIdStr, clientSession);

} else {

// The request included a session id. Make sure it's one that we have already set up:

//如果存在会话，直接查找原来的会话；

clientSession = (RTSPServer::RTSPClientSession*)(fOurServer.fClientSessions->Lookup(sessionIdStr));

if (clientSession == NULL) {

handleCmd_sessionNotFound();

}

}

//构建Setup应答包

if (clientSession != NULL) clientSession->handleCmd_SETUP(this, urlPreSuffix, urlSuffix, (charconst*)fRequestBuffer);

} else if (strcmp(cmdName, "TEARDOWN") == 0

|| strcmp(cmdName, "PLAY") == 0

|| strcmp(cmdName, "PAUSE") == 0

|| strcmp(cmdName, "GET_PARAMETER") == 0

|| strcmp(cmdName, "SET_PARAMETER") == 0) {

RTSPServer::RTSPClientSession* clientSession

= sessionIdStr[0] == '\0' ? NULL : (RTSPServer::RTSPClientSession*)(fOurServer.fClientSessions->Lookup(sessionIdStr));

if (clientSession == NULL) {

handleCmd_sessionNotFound();

} else {

clientSession->handleCmd_withinSession(this, cmdName, urlPreSuffix, urlSuffix, (charconst*)fRequestBuffer);

}

} else if (strcmp(cmdName, "REGISTER") == 0 || strcmp(cmdName,"REGISTER_REMOTE") == 0) {

// Because - unlike other commands - an implementation of these commands needs the entire URL, we re-parse the

// command to get it:

char* url = strDupSize((char*)fRequestBuffer);

if (sscanf((char*)fRequestBuffer,"%*s %s", url) == 1) {

handleCmd_REGISTER(url, urlSuffix, strcmp(cmdName, "REGISTER_REMOTE") == 0);

} else {

handleCmd_bad();

}

delete[] url;

} else {

// The command is one that we don't handle:

handleCmd_notSupported();

}

} else {

#ifdef DEBUG

fprintf(stderr, "parseRTSPRequestString() failed; checking now for HTTP commands (for RTSP-over-HTTP tunneling)...\n");

#endif

// The request was not (valid) RTSP, but check for a special case: HTTP commands (for setting up RTSP-over-HTTP tunneling):

char sessionCookie[RTSP_PARAM_STRING_MAX];

char acceptStr[RTSP_PARAM_STRING_MAX];

*fLastCRLF = '\0'; // temporarily, for parsing

parseSucceeded = parseHTTPRequestString(cmdName, sizeof cmdName,

urlSuffix, sizeof urlPreSuffix,

sessionCookie, sizeof sessionCookie,

acceptStr, sizeof acceptStr);

*fLastCRLF = '\r';

if (parseSucceeded) {

#ifdef DEBUG

fprintf(stderr, "parseHTTPRequestString() succeeded, returning cmdName \"%s\", urlSuffix \"%s\", sessionCookie \"%s\", acceptStr \"%s\"\n", cmdName, urlSuffix, sessionCookie, acceptStr);

#endif

// Check that the HTTP command is valid for RTSP-over-HTTP tunneling: There must be a 'session cookie'.

Boolean isValidHTTPCmd = True;

if (sessionCookie[0] == '\0') {

// There was no "x-sessioncookie:" header. If there was an "Accept: application/x-rtsp-tunnelled" header,

// then this is a bad tunneling request. Otherwise, assume that it's an attempt to access the stream via HTTP.

if (strcmp(acceptStr, "application/x-rtsp-tunnelled") == 0) {

isValidHTTPCmd = False;

} else {

handleHTTPCmd_StreamingGET(urlSuffix, (charconst*)fRequestBuffer);

}

} else if (strcmp(cmdName, "GET") == 0) {

handleHTTPCmd_TunnelingGET(sessionCookie);

} else if (strcmp(cmdName, "POST") == 0) {

// We might have received additional data following the HTTP "POST" command - i.e., the first Base64-encoded RTSP command.

// Check for this, and handle it if it exists:

unsigned char const* extraData = fLastCRLF+4;

unsigned extraDataSize = &fRequestBuffer[fRequestBytesAlreadySeen] - extraData;

if (handleHTTPCmd_TunnelingPOST(sessionCookie, extraData, extraDataSize)) {

// We don't respond to the "POST" command, and we go away:

fIsActive = False;

break;

}

} else {

isValidHTTPCmd = False;

}

if (!isValidHTTPCmd) {

handleHTTPCmd_notSupported();

}

} else {

#ifdef DEBUG

fprintf(stderr, "parseHTTPRequestString() failed!\n");

#endif

handleCmd_bad();

}

}

#ifdef DEBUG

fprintf(stderr, "sending response: %s", fResponseBuffer);

#endif

//发送应答包

send(fClientOutputSocket, (charconst*)fResponseBuffer, strlen((char*)fResponseBuffer), 0);

if (clientSession != NULL && clientSession->fStreamAfterSETUP && strcmp(cmdName,"SETUP") == 0) {

// The client has asked for streaming to commence now, rather than after a

// subsequent "PLAY" command.  So, simulate the effect of a "PLAY" command:

clientSession->handleCmd_withinSession(this,"PLAY", urlPreSuffix, urlSuffix, (charconst*)fRequestBuffer);

}

// Check whether there are extra bytes remaining in the buffer, after the end of the request (a rare case).

// If so, move them to the front of our buffer, and keep processing it, because it might be a following, pipelined request.

unsigned requestSize = (fLastCRLF+4-fRequestBuffer) + contentLength;

numBytesRemaining = fRequestBytesAlreadySeen - requestSize;

resetRequestBuffer(); // to prepare for any subsequent request

if (numBytesRemaining > 0) {

memmove(fRequestBuffer, &fRequestBuffer[requestSize], numBytesRemaining);

newBytesRead = numBytesRemaining;

}

} while (numBytesRemaining > 0);

--fRecursionCount;

if (!fIsActive) {

if (fRecursionCount > 0) closeSockets();elsedeletethis;

// Note: The "fRecursionCount" test is for a pathological situation where we reenter the event loop and get called recursively

// while handling a command (e.g., while handling a "DESCRIBE", to get a SDP description).

// In such a case we don't want to actually delete ourself until we leave the outermost call.

}

}

void RTSPServer::RTSPClientSession::noteLiveness() {

if (fOurServer.fReclamationTestSeconds > 0) {

envir().taskScheduler()

.rescheduleDelayedTask(fLivenessCheckTask,

fOurServer.fReclamationTestSeconds*1000000,

(TaskFunc*)livenessTimeoutTask, this);

}

}

noteLiveness该函数可以用来判断流是不是断开；这个相当重要，我们可以使用它判断网络是否断开，尤其在客户端可以使用这样的方法来判断网络是否断开，然后实现断网重连的功能。

RTSPClientSession要提供什么功能呢,可以想象：需要监听客户端的rtsp请求并回应它，需要在DESCRIBE请求中返回所请求的流的信息，需要在SETUP请求中建立起RTP会话，需要在TEARDOWN请求中关闭RTP会话，等等;

下面在接着跟进到createNewClientSession会话的函数:

RTSPServer::RTSPClientSession*

RTSPServer::createNewClientSession(u_int32_t sessionId) {

return new RTSPClientSession(*this, sessionId);

}

RTSPServer::RTSPClientSession

::RTSPClientSession(RTSPServer& ourServer, u_int32_t sessionId)

: fOurServer(ourServer), fOurSessionId(sessionId), fOurServerMediaSession(NULL), fIsMulticast(False), fStreamAfterSETUP(False),

fTCPStreamIdCount(0), fLivenessCheckTask(NULL), fNumStreamStates(0), fStreamStates(NULL) {

noteLiveness();

}

这个构造函数旧版本的live555和v0.78版本是不同的，旧版本的live555，在accept后就建立了rtsp会话，而新版本的是在收到setup请求后才建立的会话，所以这些地方都不同，在旧版本中RTSPClientSession会有一个回调函数，新版本中没有，该回调函数在收到客户端的Connect命令时设置；

下面在分析下服务端对Opinion各种命令的请求的处理的代码；首先还是分析Opinion，该命令请求的作用是客户端请求服务端支持哪些命令；Describe请求是得到会话描述信息，包括h264的sps，pps信息也可以在Describe的应答中发送；Setup命令是用来建立会话，服务端收到Setup请求后，建立会话，new 一个RTSPClientSession对象，该对象用来处理客户端的各种Rtsp命令请求；同时服务端保存会话Id和会话对象，每次可以从表中取出RTSPClientSession对象；响应客户端的请求；在收到Setup命令后;没有等到客户端的Play命令，就开始视频流；

if (clientSession != NULL && clientSession->fStreamAfterSETUP && strcmp(cmdName,"SETUP") == 0) {

// The client has asked for streaming to commence now, rather than after a

// subsequent "PLAY" command.  So, simulate the effect of a "PLAY" command:

clientSession->handleCmd_withinSession(this,"PLAY", urlPreSuffix, urlSuffix, (charconst*)fRequestBuffer);

}

1)服务端对Opinion命令的处理;跟踪源码:

void RTSPServer::RTSPClientConnection::handleCmd_OPTIONS() {

snprintf((char*)fResponseBuffer,sizeof fResponseBuffer,

"RTSP/1.0 200 OK\r\nCSeq: %s\r\n%sPublic: %s\r\n\r\n",

fCurrentCSeq, dateHeader(), fOurServer.allowedCommandNames());

}

1)      服务端对Describe命令的处理

void RTSPServer::RTSPClientConnection

::handleCmd_DESCRIBE(char const* urlPreSuffix, char const* urlSuffix, char const* fullRequestStr) {

char* sdpDescription = NULL;

char* rtspURL = NULL;

do {

//整理一下下RTSP地址

char urlTotalSuffix[RTSP_PARAM_STRING_MAX];

if (strlen(urlPreSuffix) + strlen(urlSuffix) + 2 >sizeof urlTotalSuffix) {

handleCmd_bad();

break;

}

urlTotalSuffix[0] = '\0';

if (urlPreSuffix[0] != '\0') {

strcat(urlTotalSuffix, urlPreSuffix);

strcat(urlTotalSuffix, "/");

}

strcat(urlTotalSuffix, urlSuffix);

//鉴权

if (!authenticationOK("DESCRIBE", urlTotalSuffix, fullRequestStr))break;

// We should really check that the request contains an "Accept:" #####

// for "application/sdp", because that's what we're sending back #####

// Begin by looking up the "ServerMediaSession" object for the specified "urlTotalSuffix":

//跟据流的名字查找ServerMediaSession

ServerMediaSession* session = fOurServer.lookupServerMediaSession(urlTotalSuffix);

if (session == NULL) {

handleCmd_notFound();

break;

}

// Then, assemble a SDP description for this session:

sdpDescription = session->generateSDPDescription();

if (sdpDescription == NULL) {

// This usually means that a file name that was specified for a

// "ServerMediaSubsession" does not exist.

setRTSPResponse("404 File Not Found, Or In Incorrect Format");

break;

}

unsigned sdpDescriptionSize = strlen(sdpDescription);

// Also, generate our RTSP URL, for the "Content-Base:" header

// (which is necessary to ensure that the correct URL gets used in subsequent "SETUP" requests).

rtspURL = fOurServer.rtspURL(session, fClientInputSocket);

snprintf((char*)fResponseBuffer,sizeof fResponseBuffer,

"RTSP/1.0 200 OK\r\nCSeq: %s\r\n"

"%s"

"Content-Base: %s/\r\n"

"Content-Type: application/sdp\r\n"

"Content-Length: %d\r\n\r\n"

"%s",

fCurrentCSeq,

dateHeader(),

rtspURL,

sdpDescriptionSize,

sdpDescription);

} while (0);

delete[] sdpDescription;

delete[] rtspURL;

}

ServerMediaSession*

DynamicRTSPServer::lookupServerMediaSession(charconst* streamName) {

// First, check whether the specified "streamName" exists as a local file:

FILE* fid = fopen(streamName, "rb");

Boolean fileExists = fid != NULL;

// Next, check whether we already have a "ServerMediaSession" for this file:

//查找是否已经存在一个ServerMediaSession

ServerMediaSession* sms = RTSPServer::lookupServerMediaSession(streamName);

Boolean smsExists = sms != NULL;

// Handle the four possibilities for "fileExists" and "smsExists":

if (!fileExists) {

//文件不存在

if (smsExists) {

// "sms" was created for a file that no longer exists. Remove it:

//删除ServerMediaSession

removeServerMediaSession(sms);

}

return NULL;

} else {

if (!smsExists) {

// Create a new "ServerMediaSession" object for streaming from the named file.

//如果ServerMediaSession不存在,新建一个ServerMediaSession

sms = createNewSMS(envir(), streamName, fid);

//将ServerMediaSession和会话关联起来

addServerMediaSession(sms);

}

fclose(fid);

return sms;

}

}

void RTSPServer::addServerMediaSession(ServerMediaSession* serverMediaSession) {

if (serverMediaSession == NULL)return;

char const* sessionName = serverMediaSession->streamName();

if (sessionName == NULL) sessionName ="";

removeServerMediaSession(sessionName); // in case an existing "ServerMediaSession" with this name already exists

fServerMediaSessions->Add(sessionName, (void*)serverMediaSession);

}

2)      服务端对Setup命令的处理

void RTSPServer::RTSPClientSession

::handleCmd_SETUP(RTSPServer::RTSPClientConnection* ourClientConnection,

char const* urlPreSuffix, char const* urlSuffix, char const* fullRequestStr) {

// Normally, "urlPreSuffix" should be the session (stream) name, and "urlSuffix" should be the subsession (track) name.

// However (being "liberal in what we accept"), we also handle 'aggregate' SETUP requests (i.e., without a track name),

// in the special case where we have only a single track. I.e., in this case, we also handle:

//    "urlPreSuffix" is empty and "urlSuffix" is the session (stream) name, or

//    "urlPreSuffix" concatenated with "urlSuffix" (with "/" inbetween) is the session (stream) name.

char const* streamName = urlPreSuffix;// in the normal case

char const* trackId = urlSuffix;// in the normal case

char* concatenatedStreamName = NULL;// in the normal case

noteLiveness();

do {

// First, make sure the specified stream name exists:

//下面的注释参数参考：

http://blog.csdn.net/niu_gao/article/details/6911130

每个ServerMediaSession中至少要包含一个 //ServerMediaSubsession。一个ServerMediaSession对应一个媒体，可以认为是Server上的一个文件，或一个实时获取设备。其包含的每个ServerMediaSubSession代表媒体中的一个Track。所以一个ServerMediaSession对应一个媒体，如果客户请求的媒体名相同，就使用已存在的ServerMediaSession，如果不同，就创建一个新的。一个流对应一个StreamState，StreamState与ServerMediaSubsession相关，但代表的是动态的，而ServerMediaSubsession代表静态的。

fOurServer.lookupServerMediaSession(streamName)中会在找不到同名ServerMediaSession时新建一个，代表一个RTP流的ServerMediaSession们是被RTSPServer管理的，而不是被RTSPClientSession拥有。为什么呢？因为ServerMediaSession代表的是一个静态的流，也就是可以从它里面获取一个流的各种信息，但不能获取传输状态。不同客户可能连接到同一个流，所以ServerMediaSession应被RTSPServer所拥有。

ServerMediaSession* sms = fOurServer.lookupServerMediaSession(streamName);

if (sms == NULL) {

// Check for the special case (noted above), before we give up:

if (urlPreSuffix[0] == '\0') {

streamName = urlSuffix;

} else {

concatenatedStreamName = newchar[strlen(urlPreSuffix) + strlen(urlSuffix) + 2];// allow for the "/" and the trailing '\0'

sprintf(concatenatedStreamName, "%s/%s", urlPreSuffix, urlSuffix);

streamName = concatenatedStreamName;

}

trackId = NULL;

// Check again:

sms = fOurServer.lookupServerMediaSession(streamName);

}

if (sms == NULL) {

if (fOurServerMediaSession == NULL) {

// The client asked for a stream that doesn't exist (and this session descriptor has not been used before):

ourClientConnection->handleCmd_notFound();

} else {

// The client asked for a stream that doesn't exist, but using a stream id for a stream that does exist. Bad request:

ourClientConnection->handleCmd_bad();

}

break;

} else {

if (fOurServerMediaSession == NULL) {

// We're accessing the "ServerMediaSession" for the first time.

fOurServerMediaSession = sms;

fOurServerMediaSession->incrementReferenceCount();

} else if (sms != fOurServerMediaSession) {

// The client asked for a stream that's different from the one originally requested for this stream id. Bad request:

ourClientConnection->handleCmd_bad();

break;

}

}

if (fStreamStates == NULL) {

// This is the first "SETUP" for this session. Set up our array of states for all of this session's subsessions (tracks):

ServerMediaSubsessionIterator iter(*fOurServerMediaSession);

for (fNumStreamStates = 0; iter.next() != NULL; ++fNumStreamStates) {}// begin by counting the number of subsessions (tracks)

fStreamStates = new struct streamState[fNumStreamStates];

iter.reset();

ServerMediaSubsession* subsession;

for (unsigned i = 0; i < fNumStreamStates; ++i) {

subsession = iter.next();

fStreamStates[i].subsession = subsession;

fStreamStates[i].streamToken = NULL; // for now; it may be changed by the "getStreamParameters()" call that comes later

}

}

// Look up information for the specified subsession (track):

ServerMediaSubsession* subsession = NULL;

unsigned streamNum;

if (trackId != NULL && trackId[0] !='\0') {// normal case

for (streamNum = 0; streamNum < fNumStreamStates; ++streamNum) {

subsession = fStreamStates[streamNum].subsession;

if (subsession != NULL && strcmp(trackId, subsession->trackId()) == 0)break;

}

if (streamNum >= fNumStreamStates) {

// The specified track id doesn't exist, so this request fails:

ourClientConnection->handleCmd_notFound();

break;

}

} else {

// Weird case: there was no track id in the URL.

// This works only if we have only one subsession:

if (fNumStreamStates != 1 || fStreamStates[0].subsession == NULL) {

ourClientConnection->handleCmd_bad();

break;

}

streamNum = 0;

subsession = fStreamStates[streamNum].subsession;

}

// ASSERT: subsession != NULL

// Look for a "Transport:" header in the request string, to extract client parameters:

StreamingMode streamingMode;

char* streamingModeString = NULL;// set when RAW_UDP streaming is specified

char* clientsDestinationAddressStr;

u_int8_t clientsDestinationTTL;

portNumBits clientRTPPortNum, clientRTCPPortNum;

unsigned char rtpChannelId, rtcpChannelId;

parseTransportHeader(fullRequestStr, streamingMode, streamingModeString,

clientsDestinationAddressStr, clientsDestinationTTL,

clientRTPPortNum, clientRTCPPortNum,

rtpChannelId, rtcpChannelId);

if ((streamingMode == RTP_TCP && rtpChannelId == 0xFF) ||

(streamingMode != RTP_TCP && ourClientConnection->fClientOutputSocket != ourClientConnection->fClientInputSocket)) {

// An anomolous situation, caused by a buggy client. Either:

//     1/ TCP streaming was requested, but with no "interleaving=" fields.  (QuickTime Player sometimes does this.), or

//     2/ TCP streaming was not requested, but we're doing RTSP-over-HTTP tunneling (which implies TCP streaming).

// In either case, we assume TCP streaming, and set the RTP and RTCP channel ids to proper values:

streamingMode = RTP_TCP;

rtpChannelId = fTCPStreamIdCount; rtcpChannelId = fTCPStreamIdCount+1;

}

if (streamingMode == RTP_TCP) fTCPStreamIdCount += 2;

Port clientRTPPort(clientRTPPortNum);

Port clientRTCPPort(clientRTCPPortNum);

// Next, check whether a "Range:" or "x-playNow:" header is present in the request.

// This isn't legal, but some clients do this to combine "SETUP" and "PLAY":

double rangeStart = 0.0, rangeEnd = 0.0;

char* absStart = NULL; char* absEnd = NULL;

if (parseRangeHeader(fullRequestStr, rangeStart, rangeEnd, absStart, absEnd)) {

delete[] absStart; delete[] absEnd;

fStreamAfterSETUP = True;

} else if (parsePlayNowHeader(fullRequestStr)) {

fStreamAfterSETUP = True;

} else {

fStreamAfterSETUP = False;

}

// Then, get server parameters from the 'subsession':

int tcpSocketNum = streamingMode == RTP_TCP ? ourClientConnection->fClientOutputSocket : -1;

netAddressBits destinationAddress = 0;

u_int8_t destinationTTL = 255;

#ifdef RTSP_ALLOW_CLIENT_DESTINATION_SETTING

if (clientsDestinationAddressStr != NULL) {

// Use the client-provided "destination" address.

// Note: This potentially allows the server to be used in denial-of-service

// attacks, so don't enable this code unless you're sure that clients are

// trusted.

destinationAddress = our_inet_addr(clientsDestinationAddressStr);

}

// Also use the client-provided TTL.

destinationTTL = clientsDestinationTTL;

#endif

delete[] clientsDestinationAddressStr;

Port serverRTPPort(0);

Port serverRTCPPort(0);

// Make sure that we transmit on the same interface that's used by the client (in case we're a multi-homed server):

struct sockaddr_in sourceAddr; SOCKLEN_T namelen =sizeof sourceAddr;

getsockname(ourClientConnection->fClientInputSocket, (struct sockaddr*)&sourceAddr, &namelen);

netAddressBits origSendingInterfaceAddr = SendingInterfaceAddr;

netAddressBits origReceivingInterfaceAddr = ReceivingInterfaceAddr;

// NOTE: The following might not work properly, so we ifdef it out for now:

#ifdef HACK_FOR_MULTIHOMED_SERVERS

ReceivingInterfaceAddr = SendingInterfaceAddr = sourceAddr.sin_addr.s_addr;

#endif

subsession->getStreamParameters(fOurSessionId, ourClientConnection->fClientAddr.sin_addr.s_addr,

clientRTPPort, clientRTCPPort,

tcpSocketNum, rtpChannelId, rtcpChannelId,

destinationAddress, destinationTTL, fIsMulticast,

serverRTPPort, serverRTCPPort,

fStreamStates[streamNum].streamToken);

SendingInterfaceAddr = origSendingInterfaceAddr;

ReceivingInterfaceAddr = origReceivingInterfaceAddr;

AddressString destAddrStr(destinationAddress);

AddressString sourceAddrStr(sourceAddr);

if (fIsMulticast) {

switch (streamingMode) {

case RTP_UDP:

snprintf((char*)ourClientConnection->fResponseBuffer,sizeof ourClientConnection->fResponseBuffer,

"RTSP/1.0 200 OK\r\n"

"CSeq: %s\r\n"

"%s"

"Transport: RTP/AVP;multicast;destination=%s;source=%s;port=%d-%d;ttl=%d\r\n"

"Session: %08X\r\n\r\n",

ourClientConnection->fCurrentCSeq,

dateHeader(),

destAddrStr.val(), sourceAddrStr.val(), ntohs(serverRTPPort.num()), ntohs(serverRTCPPort.num()), destinationTTL,

fOurSessionId);

break;

case RTP_TCP:

// multicast streams can't be sent via TCP

ourClientConnection->handleCmd_unsupportedTransport();

break;

case RAW_UDP:

snprintf((char*)ourClientConnection->fResponseBuffer,sizeof ourClientConnection->fResponseBuffer,

"RTSP/1.0 200 OK\r\n"

"CSeq: %s\r\n"

"%s"

"Transport: %s;multicast;destination=%s;source=%s;port=%d;ttl=%d\r\n"

"Session: %08X\r\n\r\n",

ourClientConnection->fCurrentCSeq,

dateHeader(),

streamingModeString, destAddrStr.val(), sourceAddrStr.val(), ntohs(serverRTPPort.num()), destinationTTL,

fOurSessionId);

break;

}

} else {

switch (streamingMode) {

case RTP_UDP: {

snprintf((char*)ourClientConnection->fResponseBuffer,sizeof ourClientConnection->fResponseBuffer,

"RTSP/1.0 200 OK\r\n"

"CSeq: %s\r\n"

"%s"

"Transport: RTP/AVP;unicast;destination=%s;source=%s;client_port=%d-%d;server_port=%d-%d\r\n"

"Session: %08X\r\n\r\n",

ourClientConnection->fCurrentCSeq,

dateHeader(),

destAddrStr.val(), sourceAddrStr.val(), ntohs(clientRTPPort.num()), ntohs(clientRTCPPort.num()), ntohs(serverRTPPort.num()), ntohs(serverRTCPPort.num()),

fOurSessionId);

break;

}

case RTP_TCP: {

snprintf((char*)ourClientConnection->fResponseBuffer,sizeof ourClientConnection->fResponseBuffer,

"RTSP/1.0 200 OK\r\n"

"CSeq: %s\r\n"

"%s"

"Transport: RTP/AVP/TCP;unicast;destination=%s;source=%s;interleaved=%d-%d\r\n"

"Session: %08X\r\n\r\n",

ourClientConnection->fCurrentCSeq,

dateHeader(),

destAddrStr.val(), sourceAddrStr.val(), rtpChannelId, rtcpChannelId,

fOurSessionId);

break;

}

case RAW_UDP: {

snprintf((char*)ourClientConnection->fResponseBuffer,sizeof ourClientConnection->fResponseBuffer,

"RTSP/1.0 200 OK\r\n"

"CSeq: %s\r\n"

"%s"

"Transport: %s;unicast;destination=%s;source=%s;client_port=%d;server_port=%d\r\n"

"Session: %08X\r\n\r\n",

ourClientConnection->fCurrentCSeq,

dateHeader(),

streamingModeString, destAddrStr.val(), sourceAddrStr.val(), ntohs(clientRTPPort.num()), ntohs(serverRTPPort.num()),

fOurSessionId);

break;

}

}

}

delete[] streamingModeString;

} while (0);

delete[] concatenatedStreamName;

}

//新建ServerMediaSession的源代码如下：

static ServerMediaSession* createNewSMS(UsageEnvironment& env,

char const* fileName, FILE* /*fid*/) {

// Use the file name extension to determine the type of "ServerMediaSession":

char const* extension = strrchr(fileName,'.');

if (extension == NULL) return NULL;

ServerMediaSession* sms = NULL;

Boolean const reuseSource = False;

if (strcmp(extension, ".aac") == 0) {

// Assumed to be an AAC Audio (ADTS format) file:

NEW_SMS("AAC Audio");

sms->addSubsession(ADTSAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));

} else if (strcmp(extension, ".amr") == 0) {

// Assumed to be an AMR Audio file:

NEW_SMS("AMR Audio");

sms->addSubsession(AMRAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));

} else if (strcmp(extension, ".ac3") == 0) {

// Assumed to be an AC-3 Audio file:

NEW_SMS("AC-3 Audio");

sms->addSubsession(AC3AudioFileServerMediaSubsession::createNew(env, fileName, reuseSource));

} else if (strcmp(extension, ".m4e") == 0) {

// Assumed to be a MPEG-4 Video Elementary Stream file:

NEW_SMS("MPEG-4 Video");

sms->addSubsession(MPEG4VideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));

} else if (strcmp(extension, ".264") == 0) {

// Assumed to be a H.264 Video Elementary Stream file:

NEW_SMS("H.264 Video");

OutPacketBuffer::maxSize = 100000; // allow for some possibly large H.264 frames

sms->addSubsession(H264VideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));

} else if (strcmp(extension, ".mp3") == 0) {

// Assumed to be a MPEG-1 or 2 Audio file:

NEW_SMS("MPEG-1 or 2 Audio");

// To stream using 'ADUs' rather than raw MP3 frames, uncomment the following:

//#define STREAM_USING_ADUS 1

// To also reorder ADUs before streaming, uncomment the following:

//#define INTERLEAVE_ADUS 1

// (For more information about ADUs and interleaving,

//  see <http://www.live555.com/rtp-mp3/>)

Boolean useADUs = False;

Interleaving* interleaving = NULL;

#ifdef STREAM_USING_ADUS

useADUs = True;

#ifdef INTERLEAVE_ADUS

unsigned char interleaveCycle[] = {0,2,1,3}; // or choose your own...

unsigned const interleaveCycleSize

= (sizeof interleaveCycle)/(sizeof (unsigned char));

interleaving = new Interleaving(interleaveCycleSize, interleaveCycle);

#endif

#endif

sms->addSubsession(MP3AudioFileServerMediaSubsession::createNew(env, fileName, reuseSource, useADUs, interleaving));

} else if (strcmp(extension, ".mpg") == 0) {

// Assumed to be a MPEG-1 or 2 Program Stream (audio+video) file:

NEW_SMS("MPEG-1 or 2 Program Stream");

MPEG1or2FileServerDemux* demux

= MPEG1or2FileServerDemux::createNew(env, fileName, reuseSource);

sms->addSubsession(demux->newVideoServerMediaSubsession());

sms->addSubsession(demux->newAudioServerMediaSubsession());

} else if (strcmp(extension, ".vob") == 0) {

// Assumed to be a VOB (MPEG-2 Program Stream, with AC-3 audio) file:

NEW_SMS("VOB (MPEG-2 video with AC-3 audio)");

MPEG1or2FileServerDemux* demux

= MPEG1or2FileServerDemux::createNew(env, fileName, reuseSource);

sms->addSubsession(demux->newVideoServerMediaSubsession());

sms->addSubsession(demux->newAC3AudioServerMediaSubsession());

} else if (strcmp(extension, ".ts") == 0) {

// Assumed to be a MPEG Transport Stream file:

// Use an index file name that's the same as the TS file name, except with ".tsx":

unsigned indexFileNameLen = strlen(fileName) + 2;// allow for trailing "x\0"

char* indexFileName = new char[indexFileNameLen];

sprintf(indexFileName, "%sx", fileName);

NEW_SMS("MPEG Transport Stream");

sms->addSubsession(MPEG2TransportFileServerMediaSubsession::createNew(env, fileName, indexFileName, reuseSource));

delete[] indexFileName;

} else if (strcmp(extension, ".wav") == 0) {

// Assumed to be a WAV Audio file:

NEW_SMS("WAV Audio Stream");

// To convert 16-bit PCM data to 8-bit u-law, prior to streaming,

// change the following to True:

Boolean convertToULaw = False;

sms->addSubsession(WAVAudioFileServerMediaSubsession::createNew(env, fileName, reuseSource, convertToULaw));

} else if (strcmp(extension, ".dv") == 0) {

// Assumed to be a DV Video file

// First, make sure that the RTPSinks' buffers will be large enough to handle the huge size of DV frames (as big as 288000).

OutPacketBuffer::maxSize = 300000;

NEW_SMS("DV Video");

sms->addSubsession(DVVideoFileServerMediaSubsession::createNew(env, fileName, reuseSource));

} else if (strcmp(extension, ".mkv") == 0 || strcmp(extension,".webm") == 0) {

// Assumed to be a Matroska file (note that WebM ('.webm') files are also Matroska files)

NEW_SMS("Matroska video+audio+(optional)subtitles");

// Create a Matroska file server demultiplexor for the specified file. (We enter the event loop to wait for this to complete.)

newMatroskaDemuxWatchVariable = 0;

MatroskaFileServerDemux::createNew(env, fileName, onMatroskaDemuxCreation, NULL);

env.taskScheduler().doEventLoop(&newMatroskaDemuxWatchVariable);

ServerMediaSubsession* smss;

while ((smss = demux->newServerMediaSubsession()) != NULL) {

sms->addSubsession(smss);

}

}

return sms;

}

3)      服务端对Play命令的处理

void RTSPServer::RTSPClientSession

::handleCmd_withinSession(RTSPServer::RTSPClientConnection* ourClientConnection,

char const* cmdName,

char const* urlPreSuffix, char const* urlSuffix,

char const* fullRequestStr) {

// This will either be:

// - a non-aggregated operation, if "urlPreSuffix" is the session (stream)

//   name and "urlSuffix" is the subsession (track) name, or

// - an aggregated operation, if "urlSuffix" is the session (stream) name,

//   or "urlPreSuffix" is the session (stream) name, and "urlSuffix" is empty,

//   or "urlPreSuffix" and "urlSuffix" are both nonempty, but when concatenated, (with "/") form the session (stream) name.

// Begin by figuring out which of these it is:

ServerMediaSubsession* subsession;

noteLiveness();

if (fOurServerMediaSession == NULL) {// There wasn't a previous SETUP!

ourClientConnection->handleCmd_notSupported();

return;

} else if (urlSuffix[0] != '\0' && strcmp(fOurServerMediaSession->streamName(), urlPreSuffix) == 0) {

// Non-aggregated operation.

// Look up the media subsession whose track id is "urlSuffix":

ServerMediaSubsessionIterator iter(*fOurServerMediaSession);

while ((subsession = iter.next()) != NULL) {

if (strcmp(subsession->trackId(), urlSuffix) == 0)break;// success

}

if (subsession == NULL) { // no such track!

ourClientConnection->handleCmd_notFound();

return;

}

} else if (strcmp(fOurServerMediaSession->streamName(), urlSuffix) == 0 ||

(urlSuffix[0] == '\0' && strcmp(fOurServerMediaSession->streamName(), urlPreSuffix) == 0)) {

// Aggregated operation

subsession = NULL;

} else if (urlPreSuffix[0] != '\0' && urlSuffix[0] !='\0') {

// Aggregated operation, if <urlPreSuffix>/<urlSuffix> is the session (stream) name:

unsigned const urlPreSuffixLen = strlen(urlPreSuffix);

if (strncmp(fOurServerMediaSession->streamName(), urlPreSuffix, urlPreSuffixLen) == 0 &&

fOurServerMediaSession->streamName()[urlPreSuffixLen] == '/' &&

strcmp(&(fOurServerMediaSession->streamName())[urlPreSuffixLen+1], urlSuffix) == 0) {

subsession = NULL;

} else {

ourClientConnection->handleCmd_notFound();

return;

}

} else { // the request doesn't match a known stream and/or track at all!

ourClientConnection->handleCmd_notFound();

return;

}

if (strcmp(cmdName, "TEARDOWN") == 0) {

handleCmd_TEARDOWN(ourClientConnection, subsession);

} else if (strcmp(cmdName, "PLAY") == 0) {

handleCmd_PLAY(ourClientConnection, subsession, fullRequestStr);

} else if (strcmp(cmdName, "PAUSE") == 0) {

handleCmd_PAUSE(ourClientConnection, subsession);

} else if (strcmp(cmdName, "GET_PARAMETER") == 0) {

handleCmd_GET_PARAMETER(ourClientConnection, subsession, fullRequestStr);

} else if (strcmp(cmdName, "SET_PARAMETER") == 0) {

handleCmd_SET_PARAMETER(ourClientConnection, subsession, fullRequestStr);

}

}

void RTSPServer::RTSPClientSession

::handleCmd_PLAY(RTSPServer::RTSPClientConnection* ourClientConnection,

ServerMediaSubsession* subsession, char const* fullRequestStr) {

char* rtspURL = fOurServer.rtspURL(fOurServerMediaSession, ourClientConnection->fClientInputSocket);

unsigned rtspURLSize = strlen(rtspURL);

// Parse the client's "Scale:" header, if any:

float scale;

Boolean sawScaleHeader = parseScaleHeader(fullRequestStr, scale);

// Try to set the stream's scale factor to this value:

if (subsession == NULL /*aggregate op*/) {

fOurServerMediaSession->testScaleFactor(scale);

} else {

subsession->testScaleFactor(scale);

}

char buf[100];

char* scaleHeader;

if (!sawScaleHeader) {

buf[0] = '\0'; // Because we didn't see a Scale: header, don't send one back

} else {

sprintf(buf, "Scale: %f\r\n", scale);

}

scaleHeader = strDup(buf);

// Parse the client's "Range:" header, if any:

float duration = 0.0;

double rangeStart = 0.0, rangeEnd = 0.0;

char* absStart = NULL; char* absEnd = NULL;

Boolean sawRangeHeader = parseRangeHeader(fullRequestStr, rangeStart, rangeEnd, absStart, absEnd);

if (sawRangeHeader && absStart == NULL/*not seeking by 'absolute' time*/) {

// Use this information, plus the stream's duration (if known), to create our own "Range:" header, for the response:

duration = subsession == NULL /*aggregate op*/

? fOurServerMediaSession->duration() : subsession->duration();

if (duration < 0.0) {

// We're an aggregate PLAY, but the subsessions have different durations.

// Use the largest of these durations in our header

duration = -duration;

}

// Make sure that "rangeStart" and "rangeEnd" (from the client's "Range:" header) have sane values

// before we send back our own "Range:" header in our response:

if (rangeStart < 0.0) rangeStart = 0.0;

else if (rangeStart > duration) rangeStart = duration;

if (rangeEnd < 0.0) rangeEnd = 0.0;

else if (rangeEnd > duration) rangeEnd = duration;

if ((scale > 0.0 && rangeStart > rangeEnd && rangeEnd > 0.0) ||

(scale < 0.0 && rangeStart < rangeEnd)) {

// "rangeStart" and "rangeEnd" were the wrong way around; swap them:

double tmp = rangeStart;

rangeStart = rangeEnd;

rangeEnd = tmp;

}

}

// Create a "RTP-Info:" line.  It will get filled in from each subsession's state:

char const* rtpInfoFmt =

"%s" // "RTP-Info:", plus any preceding rtpInfo items

"%s" // comma separator, if needed

"url=%s/%s"

";seq=%d"

";rtptime=%u"

;

unsigned rtpInfoFmtSize = strlen(rtpInfoFmt);

char* rtpInfo = strDup("RTP-Info: ");

unsigned i, numRTPInfoItems = 0;

// Do any required seeking/scaling on each subsession, before starting streaming.

// (However, we don't do this if the "PLAY" request was for just a single subsession of a multiple-subsession stream;

//  for such streams, seeking/scaling can be done only with an aggregate "PLAY".)

for (i = 0; i < fNumStreamStates; ++i) {

if (subsession == NULL /* means: aggregated operation */ || fNumStreamStates == 1) {

if (sawScaleHeader) {

if (fStreamStates[i].subsession != NULL) {

fStreamStates[i].subsession->setStreamScale(fOurSessionId, fStreamStates[i].streamToken, scale);

}

}

if (sawRangeHeader) {

if (absStart != NULL) {

// Special case handling for seeking by 'absolute' time:

if (fStreamStates[i].subsession != NULL) {

fStreamStates[i].subsession->seekStream(fOurSessionId, fStreamStates[i].streamToken, absStart, absEnd);

}

} else {

// Seeking by relative (NPT) time:

double streamDuration = 0.0;// by default; means: stream until the end of the media

if (rangeEnd > 0.0 && (rangeEnd+0.001) < duration) {// the 0.001 is because we limited the values to 3 decimal places

// We want the stream to end early. Set the duration we want:

streamDuration = rangeEnd - rangeStart;

if (streamDuration < 0.0) streamDuration = -streamDuration;// should happen only if scale < 0.0

}

if (fStreamStates[i].subsession != NULL) {

u_int64_t numBytes;

//查找流

fStreamStates[i].subsession->seekStream(fOurSessionId, fStreamStates[i].streamToken,

rangeStart, streamDuration, numBytes);

}

}

} else {

// No "Range:" header was specified in the "PLAY", so we do a 'null' seek (i.e., we don't seek at all):

if (fStreamStates[i].subsession != NULL) {

fStreamStates[i].subsession->nullSeekStream(fOurSessionId, fStreamStates[i].streamToken);

}

}

}

}

// Create the "Range:" header that we'll send back in our response.

// (Note that we do this after seeking, in case the seeking operation changed the range start time.)

char* rangeHeader;

if (!sawRangeHeader) {

// There wasn't a "Range:" header in the request, so, in our response, begin the range with the current NPT (normal play time):

float curNPT = 0.0;

for (i = 0; i < fNumStreamStates; ++i) {

if (subsession == NULL /* means: aggregated operation */

|| subsession == fStreamStates[i].subsession) {

if (fStreamStates[i].subsession == NULL)continue;

float npt = fStreamStates[i].subsession->getCurrentNPT(fStreamStates[i].streamToken);

if (npt > curNPT) curNPT = npt;

// Note: If this is an aggregate "PLAY" on a multi-subsession stream, then it's conceivable that the NPTs of each subsession

// may differ (if there has been a previous seek on just one subsession). In this (unusual) case, we just return the

// largest NPT; I hope that turns out OK...

}

}

sprintf(buf, "Range: npt=%.3f-\r\n", curNPT);

} else if (absStart != NULL) {

// We're seeking by 'absolute' time:

if (absEnd == NULL) {

sprintf(buf, "Range: clock=%s-\r\n", absStart);

} else {

sprintf(buf, "Range: clock=%s-%s\r\n", absStart, absEnd);

}

delete[] absStart; delete[] absEnd;

} else {

// We're seeking by relative (NPT) time:

if (rangeEnd == 0.0 && scale >= 0.0) {

sprintf(buf, "Range: npt=%.3f-\r\n", rangeStart);

} else {

sprintf(buf, "Range: npt=%.3f-%.3f\r\n", rangeStart, rangeEnd);

}

}

rangeHeader = strDup(buf);

// Now, start streaming:

for (i = 0; i < fNumStreamStates; ++i) {

if (subsession == NULL /* means: aggregated operation */

|| subsession == fStreamStates[i].subsession) {

unsigned short rtpSeqNum = 0;

unsigned rtpTimestamp = 0;

if (fStreamStates[i].subsession == NULL)continue;

fStreamStates[i].subsession->startStream(fOurSessionId,

fStreamStates[i].streamToken,

(TaskFunc*)noteClientLiveness, this,

rtpSeqNum, rtpTimestamp,

RTSPServer::RTSPClientConnection::handleAlternativeRequestByte, ourClientConnection);

const char *urlSuffix = fStreamStates[i].subsession->trackId();

char* prevRTPInfo = rtpInfo;

unsigned rtpInfoSize = rtpInfoFmtSize

+ strlen(prevRTPInfo)

+ 1

+ rtspURLSize + strlen(urlSuffix)

+ 5 /*max unsigned short len*/

+ 10 /*max unsigned (32-bit) len*/

+ 2 /*allows for trailing \r\n at final end of string*/;

rtpInfo = new char[rtpInfoSize];

sprintf(rtpInfo, rtpInfoFmt,

prevRTPInfo,

numRTPInfoItems++ == 0 ? "" :",",

rtspURL, urlSuffix,

rtpSeqNum,

rtpTimestamp

);

delete[] prevRTPInfo;

}

}

if (numRTPInfoItems == 0) {

rtpInfo[0] = '\0';

} else {

unsigned rtpInfoLen = strlen(rtpInfo);

rtpInfo[rtpInfoLen] = '\r';

rtpInfo[rtpInfoLen+1] = '\n';

rtpInfo[rtpInfoLen+2] = '\0';

}

// Fill in the response:

snprintf((char*)ourClientConnection->fResponseBuffer,sizeof ourClientConnection->fResponseBuffer,

"RTSP/1.0 200 OK\r\n"

"CSeq: %s\r\n"

"%s"

"%s"

"%s"

"Session: %08X\r\n"

"%s\r\n",

ourClientConnection->fCurrentCSeq,

dateHeader(),

scaleHeader,

rangeHeader,

fOurSessionId,

rtpInfo);

delete[] rtpInfo; delete[] rangeHeader;

delete[] scaleHeader; delete[] rtspURL;

}

Live555 RTP建立流程

RTP的建立流程在客户端发送Setup请求开始建立，客户端发送Setup请求时，会将RTP/RTCP的端口号告诉服务端，也会将Rtp over tcp还是udp的方式告诉到服务端，服务端收到Setup请求时，根据端口号建立socket，在收到客户端的Play命令时，启动流传输；启动流传输的代码如下：

void OnDemandServerMediaSubsession::startStream(unsigned clientSessionId,

void* streamToken,

TaskFunc* rtcpRRHandler,

void* rtcpRRHandlerClientData,

unsignedshort& rtpSeqNum,

unsigned& rtpTimestamp,

ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,

void* serverRequestAlternativeByteHandlerClientData) {

StreamState* streamState = (StreamState*)streamToken;

Destinations* destinations

= (Destinations*)(fDestinationsHashTable->Lookup((charconst*)clientSessionId));

if (streamState != NULL) {

streamState->startPlaying(destinations,

rtcpRRHandler, rtcpRRHandlerClientData,

serverRequestAlternativeByteHandler, serverRequestAlternativeByteHandlerClientData);

RTPSink* rtpSink = streamState->rtpSink(); // alias

if (rtpSink != NULL) {

rtpSeqNum = rtpSink->currentSeqNo();

rtpTimestamp = rtpSink->presetNextTimestamp();

}

}

}

//

Live555 rtsp/rtp是同一个socket，但端口号不同吗？

看源码：

void OnDemandServerMediaSubsession

::getStreamParameters(unsigned clientSessionId,

netAddressBits clientAddress,

Port const& clientRTPPort,

Port const& clientRTCPPort,

int tcpSocketNum,

unsigned char rtpChannelId,

unsigned char rtcpChannelId,

netAddressBits& destinationAddress,

u_int8_t& /*destinationTTL*/,

Boolean& isMulticast,

Port& serverRTPPort,

Port& serverRTCPPort,

void*& streamToken) {

if (destinationAddress == 0) destinationAddress = clientAddress;

struct in_addr destinationAddr; destinationAddr.s_addr = destinationAddress;

isMulticast = False;

if (fLastStreamToken != NULL && fReuseFirstSource) {

// Special case: Rather than creating a new 'StreamState',

// we reuse the one that we've already created:

serverRTPPort = ((StreamState*)fLastStreamToken)->serverRTPPort();

serverRTCPPort = ((StreamState*)fLastStreamToken)->serverRTCPPort();

++((StreamState*)fLastStreamToken)->referenceCount();

streamToken = fLastStreamToken;

} else {

// Normal case: Create a new media source:

unsigned streamBitrate;

FramedSource* mediaSource

= createNewStreamSource(clientSessionId, streamBitrate);

// Create 'groupsock' and 'sink' objects for the destination,

// using previously unused server port numbers:

RTPSink* rtpSink;

BasicUDPSink* udpSink;

Groupsock* rtpGroupsock;

Groupsock* rtcpGroupsock;

portNumBits serverPortNum;

if (clientRTCPPort.num() == 0) {

// We're streaming raw UDP (not RTP). Create a single groupsock:

NoReuse dummy(envir()); // ensures that we skip over ports that are already in use

for (serverPortNum = fInitialPortNum; ; ++serverPortNum) {

struct in_addr dummyAddr; dummyAddr.s_addr = 0;

serverRTPPort = serverPortNum;

rtpGroupsock = new Groupsock(envir(), dummyAddr, serverRTPPort, 255);

if (rtpGroupsock->socketNum() >= 0)break;// success

}

rtcpGroupsock = NULL;

rtpSink = NULL;

udpSink = BasicUDPSink::createNew(envir(), rtpGroupsock);

} else {

// Normal case: We're streaming RTP (over UDP or TCP). Create a pair of

// groupsocks (RTP and RTCP), with adjacent port numbers (RTP port number even):

NoReuse dummy(envir()); // ensures that we skip over ports that are already in use

for (portNumBits serverPortNum = fInitialPortNum; ; serverPortNum += 2) {

struct in_addr dummyAddr; dummyAddr.s_addr = 0;

serverRTPPort = serverPortNum;

//建立RTPsocket

rtpGroupsock = new Groupsock(envir(), dummyAddr, serverRTPPort, 255);

if (rtpGroupsock->socketNum() < 0) {

delete rtpGroupsock;

continue; // try again

}

//建立Rtcp socket

serverRTCPPort = serverPortNum+1;

rtcpGroupsock = new Groupsock(envir(), dummyAddr, serverRTCPPort, 255);

if (rtcpGroupsock->socketNum() < 0) {

delete rtpGroupsock;

delete rtcpGroupsock;

continue; // try again

}

break; // success

}

unsigned char rtpPayloadType = 96 + trackNumber()-1; // if dynamic

rtpSink = createNewRTPSink(rtpGroupsock, rtpPayloadType, mediaSource);

udpSink = NULL;

}

// Turn off the destinations for each groupsock. They'll get set later

// (unless TCP is used instead):

if (rtpGroupsock != NULL) rtpGroupsock->removeAllDestinations();

if (rtcpGroupsock != NULL) rtcpGroupsock->removeAllDestinations();

if (rtpGroupsock != NULL) {

// Try to use a big send buffer for RTP - at least 0.1 second of

// specified bandwidth and at least 50 KB

unsigned rtpBufSize = streamBitrate * 25 / 2;// 1 kbps * 0.1 s = 12.5 bytes

if (rtpBufSize < 50 * 1024) rtpBufSize = 50 * 1024;

increaseSendBufferTo(envir(), rtpGroupsock->socketNum(), rtpBufSize);

}

// Set up the state of the stream. The stream will get started later:

streamToken = fLastStreamToken

= new StreamState(*this, serverRTPPort, serverRTCPPort, rtpSink, udpSink,

streamBitrate, mediaSource,

rtpGroupsock, rtcpGroupsock);

}

// Record these destinations as being for this client session id:

Destinations* destinations;

if (tcpSocketNum < 0) { // UDP

destinations = new Destinations(destinationAddr, clientRTPPort, clientRTCPPort);

} else { // TCP

destinations = new Destinations(tcpSocketNum, rtpChannelId, rtcpChannelId);

}

fDestinationsHashTable->Add((charconst*)clientSessionId, destinations);

}

//从这段代码中可以看到rtsp，rtp，rtcp的socket是不同的；同时分析了客户端的源码，socket也是不一样的，初始化subsession时，在其中会建立RTP/RTCP socket以及RTPSource。对于每个subsession都会建立不同的socket。

3)MediaSession和socket的关系？一个MediaSession包括多个连接，关联到多个socket吗？

MediaSession 包括多个MediaSubSession,每个MediaSubSession对应相应的socket，source和sink，形成一个数据流！