cffishappy
cffishappy

live555学习2（转）

六　建立RTP会话


首先更正一个概念：
ServerMediaSession原先说代表一个流，其实是不准确的。它代表的是server端的一个媒体的名字，而说ServerMediaSubsession代表一个Track是准确的。以后流指的是那些有数据流动的组合。


RTP的建立：
RTP的建立过程无非是这样：client告诉server自己的rtp/rtcp端口号，server建立自己的rtp/rtcp socket，然后在收到PLAY请求时向客户端发数据。看起来非常简单。
在收到SETUP请求时才建立连接，让我们看一下处理这个命令的函数：
[cpp] view plain copy print ?
  1. void RTSPServer::RTSPClientSession::handleCmd_SETUP(  
  2.         char const* cseq,  
  3.         char const* urlPreSuffix,  
  4.         char const* urlSuffix,  
  5.         char const* fullRequestStr)  
  6. {  
  7.     // Normally, "urlPreSuffix" should be the session (stream) name,  
  8.     // and "urlSuffix" should be the subsession (track) name.  
  9.     // However (being "liberal in what we accept"), we also handle  
  10.     // 'aggregate' SETUP requests (i.e., without a track name),  
  11.     // in the special case where we have only a single track.  I.e.,  
  12.     // in this case, we also handle:   
  13.     //    "urlPreSuffix" is empty and "urlSuffix" is the session (stream) name, or  
  14.     //    "urlPreSuffix" concatenated with "urlSuffix" (with "/" inbetween)  
  15.     //    is the session (stream) name.  
  16.     char const* streamName = urlPreSuffix; // in the normal case  
  17.     char const* trackId = urlSuffix; // in the normal case  
  18.     char* concatenatedStreamName = NULL; // in the normal case  
  19.   
  20.   
  21.     do {  
  22.         // First, make sure the specified stream name exists:  
  23.         fOurServerMediaSession = fOurServer.lookupServerMediaSession(streamName);  
  24.         if (fOurServerMediaSession == NULL) {  
  25.             // Check for the special case (noted above), before we up:  
  26.             if (urlPreSuffix[0] == '\0') {  
  27.                 streamName = urlSuffix;  
  28.             } else {  
  29.                 concatenatedStreamName = new char[strlen(urlPreSuffix)  
  30.                         + strlen(urlSuffix) + 2]; // allow for the "/" and the trailing '\0'  
  31.                 sprintf(concatenatedStreamName, "%s/%s", urlPreSuffix,  
  32.                         urlSuffix);  
  33.                 streamName = concatenatedStreamName;  
  34.             }  
  35.             trackId = NULL;  
  36.   
  37.   
  38.             // Check again:   
  39.             fOurServerMediaSession = fOurServer.lookupServerMediaSession(streamName);  
  40.         }  
  41.         if (fOurServerMediaSession == NULL) {  
  42.             handleCmd_notFound(cseq);  
  43.             break;  
  44.         }  
  45.   
  46.   
  47.         fOurServerMediaSession->incrementReferenceCount();  
  48.   
  49.   
  50.         //为一个流中所有的track都分配一个stream state   
  51.         if (fStreamStates == NULL) {  
  52.             // This is the first "SETUP" for this session.  Set up our  
  53.             // array of states for all of this session's subsessions (tracks):  
  54.             ServerMediaSubsessionIterator iter(*fOurServerMediaSession);  
  55.             for (fNumStreamStates = 0; iter.next() != NULL; ++fNumStreamStates) {  
  56.             } // begin by counting the number of subsessions (tracks)  
  57.   
  58.   
  59.             fStreamStates = new struct streamState[fNumStreamStates];  
  60.   
  61.   
  62.             iter.reset();  
  63.             ServerMediaSubsession* subsession;  
  64.             for (unsigned i = 0; i < fNumStreamStates; ++i) {  
  65.                 subsession = iter.next();  
  66.                 fStreamStates[i].subsession = subsession;  
  67.                 fStreamStates[i].streamToken = NULL; // for now; it may be changed by the "getStreamParameters()" call that comes later  
  68.             }  
  69.         }  
  70.   
  71.   
  72.         //查找当前请求的track的信息   
  73.         // Look up information for the specified subsession (track):  
  74.         ServerMediaSubsession* subsession = NULL;  
  75.         unsigned streamNum;  
  76.         if (trackId != NULL && trackId[0] != '\0') { // normal case  
  77.             for (streamNum = 0; streamNum < fNumStreamStates; ++streamNum) {  
  78.                 subsession = fStreamStates[streamNum].subsession;  
  79.                 if (subsession != NULL  && strcmp(trackId, subsession->trackId()) == 0)  
  80.                     break; //找到啦！  
  81.             }  
  82.             if (streamNum >= fNumStreamStates) {  
  83.                 // The specified track id doesn't exist, so this request fails:  
  84.                 handleCmd_notFound(cseq);  
  85.                 break;  
  86.             }  
  87.         } else {  
  88.             // Weird case: there was no track id in the URL.  
  89.             // This works only if we have only one subsession:  
  90.             if (fNumStreamStates != 1) {  
  91.                 handleCmd_bad(cseq);  
  92.                 break;  
  93.             }  
  94.             streamNum = 0;  
  95.             subsession = fStreamStates[streamNum].subsession;  
  96.         }  
  97.         // ASSERT: subsession != NULL  
  98.   
  99.   
  100.         //分析RTSP请求字符串中的传输要求   
  101.         // Look for a "Transport:" header in the request string, to extract client parameters:  
  102.         StreamingMode streamingMode;  
  103.         char* streamingModeString = NULL; // set when RAW_UDP streaming is specified  
  104.         char* clientsDestinationAddressStr;  
  105.         u_int8_t clientsDestinationTTL;  
  106.         portNumBits clientRTPPortNum, clientRTCPPortNum;  
  107.         unsigned char rtpChannelId, rtcpChannelId;  
  108.         parseTransportHeader(fullRequestStr, streamingMode, streamingModeString,  
  109.                 clientsDestinationAddressStr, clientsDestinationTTL,  
  110.                 clientRTPPortNum, clientRTCPPortNum, rtpChannelId,  
  111.                 rtcpChannelId);  
  112.         if (streamingMode == RTP_TCP && rtpChannelId == 0xFF  
  113.                 || streamingMode != RTP_TCP &&  
  114.                 fClientOutputSocket != fClientInputSocket) {  
  115.             // An anomolous situation, caused by a buggy client.  Either:  
  116.             //     1/ TCP streaming was requested, but with no "interleaving=" fields.  (QuickTime Player sometimes does this.), or  
  117.             //     2/ TCP streaming was not requested, but we're doing RTSP-over-HTTP tunneling (which implies TCP streaming).  
  118.             // In either case, we assume TCP streaming, and set the RTP and RTCP channel ids to proper values:  
  119.             streamingMode = RTP_TCP;  
  120.             rtpChannelId = fTCPStreamIdCount;  
  121.             rtcpChannelId = fTCPStreamIdCount + 1;  
  122.         }  
  123.         fTCPStreamIdCount += 2;  
  124.   
  125.   
  126.         Port clientRTPPort(clientRTPPortNum);  
  127.         Port clientRTCPPort(clientRTCPPortNum);  
  128.   
  129.   
  130.         // Next, check whether a "Range:" header is present in the request.  
  131.         // This isn't legal, but some clients do this to combine "SETUP" and "PLAY":  
  132.         double rangeStart = 0.0, rangeEnd = 0.0;  
  133.         fStreamAfterSETUP = parseRangeHeader(fullRequestStr, rangeStart,  
  134.                 rangeEnd) || parsePlayNowHeader(fullRequestStr);  
  135.   
  136.   
  137.         // Then, get server parameters from the 'subsession':  
  138.         int tcpSocketNum = streamingMode == RTP_TCP ? fClientOutputSocket : -1;  
  139.         netAddressBits destinationAddress = 0;  
  140.         u_int8_t destinationTTL = 255;  
  141. #ifdef RTSP_ALLOW_CLIENT_DESTINATION_SETTING  
  142.         if (clientsDestinationAddressStr != NULL) {  
  143.             // Use the client-provided "destination" address.  
  144.             // Note: This potentially allows the server to be used in denial-of-service  
  145.             // attacks, so don't enable this code unless you're sure that clients are  
  146.             // trusted.   
  147.             destinationAddress = our_inet_addr(clientsDestinationAddressStr);  
  148.         }  
  149.         // Also use the client-provided TTL.  
  150.         destinationTTL = clientsDestinationTTL;  
  151. #endif   
  152.         delete[] clientsDestinationAddressStr;  
  153.         Port serverRTPPort(0);  
  154.         Port serverRTCPPort(0);  
  155.   
  156.   
  157.         // Make sure that we transmit on the same interface that's used by  
  158.         // the client (in case we're a multi-homed server):  
  159.         struct sockaddr_in sourceAddr;  
  160.         SOCKLEN_T namelen = sizeof sourceAddr;  
  161.         getsockname(fClientInputSocket, (struct sockaddr*) &sourceAddr, &namelen);  
  162.         netAddressBits origSendingInterfaceAddr = SendingInterfaceAddr;  
  163.         netAddressBits origReceivingInterfaceAddr = ReceivingInterfaceAddr;  
  164.         // NOTE: The following might not work properly, so we ifdef it out for now:  
  165. #ifdef HACK_FOR_MULTIHOMED_SERVERS  
  166.         ReceivingInterfaceAddr = SendingInterfaceAddr = sourceAddr.sin_addr.s_addr;  
  167. #endif   
  168.   
  169.   
  170.         //获取rtp连接信息，在其中已建立起了server端的rtp和rtcp socket，返回  
  171.         //fStreamStates[streamNum].streamToken表示数据流已经建立起来了  
  172.         subsession->getStreamParameters(fOurSessionId,  
  173.                 fClientAddr.sin_addr.s_addr, clientRTPPort, clientRTCPPort,  
  174.                 tcpSocketNum, rtpChannelId, rtcpChannelId, destinationAddress,  
  175.                 destinationTTL, fIsMulticast, serverRTPPort, serverRTCPPort,  
  176.                 fStreamStates[streamNum].streamToken);  
  177.         SendingInterfaceAddr = origSendingInterfaceAddr;  
  178.         ReceivingInterfaceAddr = origReceivingInterfaceAddr;  
  179.   
  180.   
  181.         //形成RTSP回应字符串   
  182.         struct in_addr destinationAddr;  
  183.         destinationAddr.s_addr = destinationAddress;  
  184.         char* destAddrStr = strDup(our_inet_ntoa(destinationAddr));  
  185.         char* sourceAddrStr = strDup(our_inet_ntoa(sourceAddr.sin_addr));  
  186.         if (fIsMulticast) {  
  187.             switch (streamingMode) {  
  188.             case RTP_UDP:  
  189.                 snprintf(  
  190.                         (char*) fResponseBuffer,  
  191.                         sizeof fResponseBuffer,  
  192.                         "RTSP/1.0 200 OK\r\n"  
  193.                                 "CSeq: %s\r\n"  
  194.                                 "%s"  
  195.                                 "Transport: RTP/AVP;multicast;destination=%s;source=%s;port=%d-%d;ttl=%d\r\n"  
  196.                                 "Session: %08X\r\n\r\n", cseq, dateHeader(),  
  197.                         destAddrStr, sourceAddrStr, ntohs(serverRTPPort.num()),  
  198.                         ntohs(serverRTCPPort.num()), destinationTTL,  
  199.                         fOurSessionId);  
  200.                 break;  
  201.             case RTP_TCP:  
  202.                 // multicast streams can't be sent via TCP  
  203.                 handleCmd_unsupportedTransport(cseq);  
  204.                 break;  
  205.             case RAW_UDP:  
  206.                 snprintf(  
  207.                         (char*) fResponseBuffer,  
  208.                         sizeof fResponseBuffer,  
  209.                         "RTSP/1.0 200 OK\r\n"  
  210.                                 "CSeq: %s\r\n"  
  211.                                 "%s"  
  212.                                 "Transport: %s;multicast;destination=%s;source=%s;port=%d;ttl=%d\r\n"  
  213.                                 "Session: %08X\r\n\r\n", cseq, dateHeader(),  
  214.                         streamingModeString, destAddrStr, sourceAddrStr,  
  215.                         ntohs(serverRTPPort.num()), destinationTTL,  
  216.                         fOurSessionId);  
  217.                 break;  
  218.             }  
  219.         } else {  
  220.             switch (streamingMode) {  
  221.             case RTP_UDP: {  
  222.                 snprintf(  
  223.                         (char*) fResponseBuffer,  
  224.                         sizeof fResponseBuffer,  
  225.                         "RTSP/1.0 200 OK\r\n"  
  226.                                 "CSeq: %s\r\n"  
  227.                                 "%s"  
  228.                                 "Transport: RTP/AVP;unicast;destination=%s;source=%s;client_port=%d-%d;server_port=%d-%d\r\n"  
  229.                                 "Session: %08X\r\n\r\n", cseq, dateHeader(),  
  230.                         destAddrStr, sourceAddrStr, ntohs(clientRTPPort.num()),  
  231.                         ntohs(clientRTCPPort.num()), ntohs(serverRTPPort.num()),  
  232.                         ntohs(serverRTCPPort.num()), fOurSessionId);  
  233.                 break;  
  234.             }  
  235.             case RTP_TCP: {  
  236.                 snprintf(  
  237.                         (char*) fResponseBuffer,  
  238.                         sizeof fResponseBuffer,  
  239.                         "RTSP/1.0 200 OK\r\n"  
  240.                                 "CSeq: %s\r\n"  
  241.                                 "%s"  
  242.                                 "Transport: RTP/AVP/TCP;unicast;destination=%s;source=%s;interleaved=%d-%d\r\n"  
  243.                                 "Session: %08X\r\n\r\n", cseq, dateHeader(),  
  244.                         destAddrStr, sourceAddrStr, rtpChannelId, rtcpChannelId,  
  245.                         fOurSessionId);  
  246.                 break;  
  247.             }  
  248.             case RAW_UDP: {  
  249.                 snprintf(  
  250.                         (char*) fResponseBuffer,  
  251.                         sizeof fResponseBuffer,  
  252.                         "RTSP/1.0 200 OK\r\n"  
  253.                                 "CSeq: %s\r\n"  
  254.                                 "%s"  
  255.                                 "Transport: %s;unicast;destination=%s;source=%s;client_port=%d;server_port=%d\r\n"  
  256.                                 "Session: %08X\r\n\r\n", cseq, dateHeader(),  
  257.                         streamingModeString, destAddrStr, sourceAddrStr,  
  258.                         ntohs(clientRTPPort.num()), ntohs(serverRTPPort.num()),  
  259.                         fOurSessionId);  
  260.                 break;  
  261.             }  
  262.             }  
  263.         }  
  264.         delete[] destAddrStr;  
  265.         delete[] sourceAddrStr;  
  266.         delete[] streamingModeString;  
  267.     } while (0);  
  268.   
  269.   
  270.     delete[] concatenatedStreamName;  
  271.     //返回后，回应字符串会被立即发送   
  272. }  


live555 中有两个 streamstate，一个是类 StreamState ，一个是此处的结构 struct streamState。类 SteamState 就是 streamToken，而 struct streamState 中保存了 MediaSubsession (即track) 和类 StreamState 的对应。类 StreamState 代表一个真正流动起来的数据流。这个数据流是从源流到 Sink 。客户端与服务端的一个 rtp 会话中，有两个数据流，服务端是从 XXXFileSouce 流到 RTPSink，而客户端则是从 RTPSource 流到 XXXFileSink 。建立数据流的过程就是把 Source 与 Sink 连接起来。
为何不把 StreamToken 保存在 MediaSubsession 中呢？看起来在 struct streamState 中是一个 MediaSubsession 对应一个 streamToken 呀？ 因为 MediaSubsession  代表一个 track 的静态数据，它是可以被其它 rtp 会话重用的。比如不同的用户可能会连接到同一个媒体的同一个 track 。所以　streamToken　与　MediaSubsession　独立存在，只是被　RTSPClientSession　给对应了起来。


streamToken的建立过程存在于函数subsession->getStreamParameters（）中，让我们看一下下：
[cpp] view plain copy print ?
  1. void OnDemandServerMediaSubsession::getStreamParameters(  
  2.         unsigned clientSessionId,  
  3.         netAddressBits clientAddress,  
  4.         Port const& clientRTPPort,  
  5.         Port const& clientRTCPPort,  
  6.         int tcpSocketNum,  
  7.         unsigned char rtpChannelId,  
  8.         unsigned char rtcpChannelId,  
  9.         netAddressBits& destinationAddress,  
  10.         u_int8_t& /*destinationTTL*/,  
  11.         Boolean& isMulticast,  
  12.         Port& serverRTPPort,  
  13.         Port& serverRTCPPort,  
  14.         void*& streamToken)  
  15. {  
  16.     if (destinationAddress == 0)  
  17.         destinationAddress = clientAddress;  
  18.   
  19.   
  20.     struct in_addr destinationAddr;  
  21.     destinationAddr.s_addr = destinationAddress;  
  22.     isMulticast = False;  
  23.   
  24.   
  25.     //ServerMediaSubsession并没有保存所有基于自己的数据流，而是只记录了最后一次建立的数据流。  
  26.     //利用这个变量和fReuseFirstSource可以实现多client连接到一个流的形式。  
  27.     if (fLastStreamToken != NULL && fReuseFirstSource) {  
  28.         //如果已经基于这个ServerMediaSubsession创建了一个连接，并且希望使用这个连接  
  29.         //则直接返回这个连接。   
  30.         // Special case: Rather than creating a new 'StreamState',  
  31.         // we reuse the one that we've already created:  
  32.         serverRTPPort = ((StreamState*) fLastStreamToken)->serverRTPPort();  
  33.         serverRTCPPort = ((StreamState*) fLastStreamToken)->serverRTCPPort();  
  34.         ++((StreamState*) fLastStreamToken)->referenceCount();  
  35.         streamToken = fLastStreamToken;  
  36.     } else {  
  37.         // Normal case: Create a new media source:  
  38.         unsigned streamBitrate;  
  39.         FramedSource* mediaSource = createNewStreamSource(clientSessionId,streamBitrate);  
  40.   
  41.   
  42.         // Create 'groupsock' and 'sink' objects for the destination,  
  43.         // using previously unused server port numbers:  
  44.         RTPSink* rtpSink;  
  45.         BasicUDPSink* udpSink;  
  46.         Groupsock* rtpGroupsock;  
  47.         Groupsock* rtcpGroupsock;  
  48.         portNumBits serverPortNum;  
  49.         if (clientRTCPPort.num() == 0) {  
  50.             // We're streaming raw UDP (not RTP). Create a single groupsock:  
  51.             NoReuse dummy; // ensures that we skip over ports that are already in use  
  52.             for (serverPortNum = fInitialPortNum;; ++serverPortNum) {  
  53.                 struct in_addr dummyAddr;  
  54.                 dummyAddr.s_addr = 0;  
  55.   
  56.   
  57.                 serverRTPPort = serverPortNum;  
  58.                 rtpGroupsock = new Groupsock(envir(), dummyAddr, serverRTPPort, 255);  
  59.                 if (rtpGroupsock->socketNum() >= 0)  
  60.                     break; // success  
  61.             }  
  62.   
  63.   
  64.             rtcpGroupsock = NULL;  
  65.             rtpSink = NULL;  
  66.             udpSink = BasicUDPSink::createNew(envir(), rtpGroupsock);  
  67.         } else {  
  68.             // Normal case: We're streaming RTP (over UDP or TCP).  Create a pair of  
  69.             // groupsocks (RTP and RTCP), with adjacent port numbers (RTP port number even):  
  70.             NoReuse dummy; // ensures that we skip over ports that are already in use  
  71.             for (portNumBits serverPortNum = fInitialPortNum;; serverPortNum += 2) {  
  72.                 struct in_addr dummyAddr;  
  73.                 dummyAddr.s_addr = 0;  
  74.   
  75.   
  76.                 serverRTPPort = serverPortNum;  
  77.                 rtpGroupsock = new Groupsock(envir(), dummyAddr, serverRTPPort, 255);  
  78.                 if (rtpGroupsock->socketNum() < 0) {  
  79.                     delete rtpGroupsock;  
  80.                     continue; // try again  
  81.                 }  
  82.   
  83.   
  84.                 serverRTCPPort = serverPortNum + 1;  
  85.                 rtcpGroupsock = new Groupsock(envir(), dummyAddr,serverRTCPPort, 255);  
  86.                 if (rtcpGroupsock->socketNum() < 0) {  
  87.                     delete rtpGroupsock;  
  88.                     delete rtcpGroupsock;  
  89.                     continue; // try again  
  90.                 }  
  91.   
  92.   
  93.                 break; // success  
  94.             }  
  95.   
  96.   
  97.             unsigned char rtpPayloadType = 96 + trackNumber() - 1; // if dynamic  
  98.             rtpSink = createNewRTPSink(rtpGroupsock, rtpPayloadType,mediaSource);  
  99.             udpSink = NULL;  
  100.         }  
  101.   
  102.   
  103.         // Turn off the destinations for each groupsock.  They'll get set later  
  104.         // (unless TCP is used instead):   
  105.         if (rtpGroupsock != NULL)  
  106.             rtpGroupsock->removeAllDestinations();  
  107.         if (rtcpGroupsock != NULL)  
  108.             rtcpGroupsock->removeAllDestinations();  
  109.   
  110.   
  111.         if (rtpGroupsock != NULL) {  
  112.             // Try to use a big send buffer for RTP -  at least 0.1 second of  
  113.             // specified bandwidth and at least 50 KB  
  114.             unsigned rtpBufSize = streamBitrate * 25 / 2; // 1 kbps * 0.1 s = 12.5 bytes  
  115.             if (rtpBufSize < 50 * 1024)  
  116.                 rtpBufSize = 50 * 1024;  
  117.             increaseSendBufferTo(envir(), rtpGroupsock->socketNum(),rtpBufSize);  
  118.         }  
  119.   
  120.   
  121.         // Set up the state of the stream.  The stream will get started later:  
  122.         streamToken = fLastStreamToken = new StreamState(*this, serverRTPPort,  
  123.                 serverRTCPPort, rtpSink, udpSink, streamBitrate, mediaSource,  
  124.                 rtpGroupsock, rtcpGroupsock);  
  125.     }  
  126.   
  127.   
  128.     // Record these destinations as being for this client session id:  
  129.     Destinations* destinations;  
  130.     if (tcpSocketNum < 0) { // UDP  
  131.         destinations = new Destinations(destinationAddr, clientRTPPort, clientRTCPPort);  
  132.     } else { // TCP  
  133.         destinations = new Destinations(tcpSocketNum, rtpChannelId, rtcpChannelId);  
  134.     }  
  135.       
  136.     //记录下所有clientSessionID对应的目的rtp/rtcp地址，是因为现在不能把目的rtp,rtcp地址加入到  
  137.     //server端rtp的groupSocket中。试想在ReuseFirstSource时，这样会引起client端立即收到rtp数据。  
  138.     //其次，也可以利用这个hash table找出client的rtp/rtcp端口等信息，好像其它地方还真没有可以保存的  
  139.     //RTSPClientSession中的streamstates在ReuseFirstSource时也不能准确找出client端的端口等信息。  
  140.     fDestinationsHashTable->Add((char const*) clientSessionId, destinations);  
  141. }  


流程不复杂：如果需要重用上一次建立的流，就利用之（这样就可以实现一rtp server对应多个rtp client的形式）；如果不需要，则创建合适的source，然后创建rtp sink，然后利用它们创建streamSoken。


启动一个流：
当RTSPClientSession收到PLAY请求时，就开始传输RTP数据。下面看一下流启动的代码：
[cpp] view plain copy print ?
  1. void RTSPServer::RTSPClientSession::handleCmd_PLAY(  
  2.         ServerMediaSubsession* subsession,  
  3.         char const* cseq,  
  4.         char const* fullRequestStr)  
  5. {  
  6.     char* rtspURL = fOurServer.rtspURL(fOurServerMediaSession,fClientInputSocket);  
  7.     unsigned rtspURLSize = strlen(rtspURL);  
  8.   
  9.   
  10.     // Parse the client's "Scale:" header, if any:  
  11.     float scale;  
  12.     Boolean sawScaleHeader = parseScaleHeader(fullRequestStr, scale);  
  13.   
  14.   
  15.     // Try to set the stream's scale factor to this value:  
  16.     if (subsession == NULL /*aggregate op*/) {  
  17.         fOurServerMediaSession->testScaleFactor(scale);  
  18.     } else {  
  19.         subsession->testScaleFactor(scale);  
  20.     }  
  21.   
  22.   
  23.     char buf[100];  
  24.     char* scaleHeader;  
  25.     if (!sawScaleHeader) {  
  26.         buf[0] = '\0'; // Because we didn't see a Scale: header, don't send one back  
  27.     } else {  
  28.         sprintf(buf, "Scale: %f\r\n", scale);  
  29.     }  
  30.     scaleHeader = strDup(buf);  
  31.   
  32.   
  33.     //分析客户端对于播放范围的要求   
  34.     // Parse the client's "Range:" header, if any:  
  35.     double rangeStart = 0.0, rangeEnd = 0.0;  
  36.     Boolean sawRangeHeader = parseRangeHeader(fullRequestStr, rangeStart,rangeEnd);  
  37.   
  38.   
  39.     // Use this information, plus the stream's duration (if known), to create  
  40.     // our own "Range:" header, for the response:  
  41.     float duration = subsession == NULL /*aggregate op*/  
  42.     ? fOurServerMediaSession->duration() : subsession->duration();  
  43.     if (duration < 0.0) {  
  44.         // We're an aggregate PLAY, but the subsessions have different durations.  
  45.         // Use the largest of these durations in our header  
  46.         duration = -duration;  
  47.     }  
  48.   
  49.   
  50.     // Make sure that "rangeStart" and "rangeEnd" (from the client's "Range:" header) have sane values  
  51.     // before we send back our own "Range:" header in our response:  
  52.     if (rangeStart < 0.0)  
  53.         rangeStart = 0.0;  
  54.     else if (rangeStart > duration)  
  55.         rangeStart = duration;  
  56.     if (rangeEnd < 0.0)  
  57.         rangeEnd = 0.0;  
  58.     else if (rangeEnd > duration)  
  59.         rangeEnd = duration;  
  60.     if ((scale > 0.0 && rangeStart > rangeEnd && rangeEnd > 0.0)  
  61.             || (scale < 0.0 && rangeStart < rangeEnd)) {  
  62.         // "rangeStart" and "rangeEnd" were the wrong way around; swap them:  
  63.         double tmp = rangeStart;  
  64.         rangeStart = rangeEnd;  
  65.         rangeEnd = tmp;  
  66.     }  
  67.   
  68.   
  69.     char* rangeHeader;  
  70.     if (!sawRangeHeader) {  
  71.         buf[0] = '\0'; // Because we didn't see a Range: header, don't send one back  
  72.     } else if (rangeEnd == 0.0 && scale >= 0.0) {  
  73.         sprintf(buf, "Range: npt=%.3f-\r\n", rangeStart);  
  74.     } else {  
  75.         sprintf(buf, "Range: npt=%.3f-%.3f\r\n", rangeStart, rangeEnd);  
  76.     }  
  77.     rangeHeader = strDup(buf);  
  78.   
  79.   
  80.     // Create a "RTP-Info:" line.  It will get filled in from each subsession's state:  
  81.     char const* rtpInfoFmt = "%s" // "RTP-Info:", plus any preceding rtpInfo items  
  82.                     "%s"// comma separator, if needed  
  83.                     "url=%s/%s"  
  84.                     ";seq=%d"  
  85.                     ";rtptime=%u";  
  86.     unsigned rtpInfoFmtSize = strlen(rtpInfoFmt);  
  87.     char* rtpInfo = strDup("RTP-Info: ");  
  88.     unsigned i, numRTPInfoItems = 0;  
  89.   
  90.   
  91.     // Do any required seeking/scaling on each subsession, before starting streaming:  
  92.     for (i = 0; i < fNumStreamStates; ++i) {  
  93.         if (subsession == NULL /* means: aggregated operation */  
  94.         || subsession == fStreamStates[i].subsession) {  
  95.             if (sawScaleHeader) {  
  96.                 fStreamStates[i].subsession->setStreamScale(fOurSessionId,  
  97.                         fStreamStates[i].streamToken, scale);  
  98.             }  
  99.             if (sawRangeHeader) {  
  100.                 double streamDuration = 0.0; // by default; means: stream until the end of the media  
  101.                 if (rangeEnd > 0.0 && (rangeEnd + 0.001) < duration) { // the 0.001 is because we limited the values to 3 decimal places  
  102.                     // We want the stream to end early.  Set the duration we want:  
  103.                     streamDuration = rangeEnd - rangeStart;  
  104.                     if (streamDuration < 0.0)  
  105.                         streamDuration = -streamDuration; // should happen only if scale < 0.0  
  106.                 }  
  107.                 u_int64_t numBytes;  
  108.                 fStreamStates[i].subsession->seekStream(fOurSessionId,  
  109.                         fStreamStates[i].streamToken, rangeStart,  
  110.                         streamDuration, numBytes);  
  111.             }  
  112.         }  
  113.     }  
  114.   
  115.   
  116.     // Now, start streaming:   
  117.     for (i = 0; i < fNumStreamStates; ++i) {  
  118.         if (subsession == NULL /* means: aggregated operation */  
  119.                 || subsession == fStreamStates[i].subsession) {  
  120.             unsigned short rtpSeqNum = 0;  
  121.             unsigned rtpTimestamp = 0;  
  122.             //启动流   
  123.             fStreamStates[i].subsession->startStream(fOurSessionId,  
  124.                     fStreamStates[i].streamToken,  
  125.                     (TaskFunc*) noteClientLiveness, this, rtpSeqNum,  
  126.                     rtpTimestamp, handleAlternativeRequestByte, this);  
  127.             const char *urlSuffix = fStreamStates[i].subsession->trackId();  
  128.             char* prevRTPInfo = rtpInfo;  
  129.             unsigned rtpInfoSize = rtpInfoFmtSize + strlen(prevRTPInfo) + 1  
  130.                     + rtspURLSize + strlen(urlSuffix) + 5 /*max unsigned short len*/  
  131.             + 10 /*max unsigned (32-bit) len*/  
  132.             + 2 /*allows for trailing \r\n at final end of string*/;  
  133.             rtpInfo = new char[rtpInfoSize];  
  134.             sprintf(rtpInfo, rtpInfoFmt, prevRTPInfo,  
  135.                     numRTPInfoItems++ == 0 ? "" : ",", rtspURL, urlSuffix,  
  136.                     rtpSeqNum, rtpTimestamp);  
  137.             delete[] prevRTPInfo;  
  138.         }  
  139.     }  
  140.     if (numRTPInfoItems == 0) {  
  141.         rtpInfo[0] = '\0';  
  142.     } else {  
  143.         unsigned rtpInfoLen = strlen(rtpInfo);  
  144.         rtpInfo[rtpInfoLen] = '\r';  
  145.         rtpInfo[rtpInfoLen + 1] = '\n';  
  146.         rtpInfo[rtpInfoLen + 2] = '\0';  
  147.     }  
  148.   
  149.   
  150.     // Fill in the response:   
  151.     snprintf((char*) fResponseBuffer, sizeof fResponseBuffer,  
  152.             "RTSP/1.0 200 OK\r\n"  
  153.                     "CSeq: %s\r\n"  
  154.                     "%s"  
  155.                     "%s"  
  156.                     "%s"  
  157.                     "Session: %08X\r\n"  
  158.                     "%s\r\n", cseq, dateHeader(), scaleHeader, rangeHeader,  
  159.             fOurSessionId, rtpInfo);  
  160.     delete[] rtpInfo;  
  161.     delete[] rangeHeader;  
  162.     delete[] scaleHeader;  
  163.     delete[] rtspURL;  
  164. }  


有个问题，如果这个streamToken使用的是已存在的（还记得ReuseFirstSource吗），为它再次调用startStream()时，究竟会做什么呢？你猜啊！呵呵我猜吧：应该是把这个客户端的地址和rtp/rtcp端口传给rtp server的groupSocket，rtp server自然就开始向这个客户端发送数据了。是不是这样尼？看代码吧：
[cpp] view plain copy print ?
  1. void StreamState::startPlaying(  
  2.         Destinations* dests,  
  3.         TaskFunc* rtcpRRHandler,  
  4.         void* rtcpRRHandlerClientData,  
  5.         ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,  
  6.         void* serverRequestAlternativeByteHandlerClientData)   
  7. {  
  8.     //目标ip address rtp && rtcp port   
  9.     if (dests == NULL)  
  10.         return;  
  11.   
  12.   
  13.     //创建RTCPInstance对象，以计算和收发RTCP包  
  14.     if (fRTCPInstance == NULL && fRTPSink != NULL) {  
  15.         // Create (and start) a 'RTCP instance' for this RTP sink:  
  16.         fRTCPInstance = RTCPInstance::createNew(fRTPSink->envir(), fRTCPgs,  
  17.                 fTotalBW, (unsigned char*) fMaster.fCNAME, fRTPSink,  
  18.                 NULL /* we're a server */);  
  19.         // Note: This starts RTCP running automatically  
  20.     }  
  21.   
  22.   
  23.     if (dests->isTCP) {  
  24.         //如果RTP over TCP   
  25.         // Change RTP and RTCP to use the TCP socket instead of UDP:  
  26.         if (fRTPSink != NULL) {  
  27.             fRTPSink->addStreamSocket(dests->tcpSocketNum, dests->rtpChannelId);  
  28.             fRTPSink->setServerRequestAlternativeByteHandler(  
  29.                     dests->tcpSocketNum, serverRequestAlternativeByteHandler,  
  30.                     serverRequestAlternativeByteHandlerClientData);  
  31.         }  
  32.         if (fRTCPInstance != NULL) {  
  33.             fRTCPInstance->addStreamSocket(dests->tcpSocketNum,  
  34.                     dests->rtcpChannelId);  
  35.             fRTCPInstance->setSpecificRRHandler(dests->tcpSocketNum,  
  36.                     dests->rtcpChannelId, rtcpRRHandler,  
  37.                     rtcpRRHandlerClientData);  
  38.         }  
  39.     } else {  
  40.         //向RTP和RTCP的groupsocket增加这个目标   
  41.         // Tell the RTP and RTCP 'groupsocks' about this destination  
  42.         // (in case they don't already have it):  
  43.         if (fRTPgs != NULL)  
  44.             fRTPgs->addDestination(dests->addr, dests->rtpPort);  
  45.         if (fRTCPgs != NULL)  
  46.             fRTCPgs->addDestination(dests->addr, dests->rtcpPort);  
  47.         if (fRTCPInstance != NULL) {  
  48.             fRTCPInstance->setSpecificRRHandler(dests->addr.s_addr,  
  49.                     dests->rtcpPort, rtcpRRHandler, rtcpRRHandlerClientData);  
  50.         }  
  51.     }  
  52.   
  53.   
  54.     if (!fAreCurrentlyPlaying && fMediaSource != NULL) {  
  55.         //如果还没有启动传输，现在启动之。   
  56.         if (fRTPSink != NULL) {  
  57.             fRTPSink->startPlaying(*fMediaSource, afterPlayingStreamState,  
  58.                     this);  
  59.             fAreCurrentlyPlaying = True;  
  60.         } else if (fUDPSink != NULL) {  
  61.             fUDPSink->startPlaying(*fMediaSource, afterPlayingStreamState,this);  
  62.             fAreCurrentlyPlaying = True;  
  63.         }  
  64.     }  
  65. }  



嘿嘿，还真的这样嘀！




 

七　RTP打包与发送


rtp传送开始于函数：MediaSink::startPlaying()。想想也有道理，应是sink跟source要数据，所以从sink上调用startplaying（嘿嘿，相当于directshow的拉模式）。


看一下这个函数：

[cpp] view plain copy print ?
  1. Boolean MediaSink::startPlaying(MediaSource& source,  
  2.         afterPlayingFunc* afterFunc, void* afterClientData)  
  3. {  
  4.     //参数afterFunc是在播放结束时才被调用。   
  5.     // Make sure we're not already being played:  
  6.     if (fSource != NULL) {  
  7.         envir().setResultMsg("This sink is already being played");  
  8.         return False;  
  9.     }  
  10.   
  11.   
  12.     // Make sure our source is compatible:  
  13.     if (!sourceIsCompatibleWithUs(source)) {  
  14.         envir().setResultMsg(  
  15.                 "MediaSink::startPlaying(): source is not compatible!");  
  16.         return False;  
  17.     }  
  18.     //记下一些要使用的对象   
  19.     fSource = (FramedSource*) &source;  
  20.   
  21.   
  22.     fAfterFunc = afterFunc;  
  23.     fAfterClientData = afterClientData;  
  24.     return continuePlaying();  
  25. }  

为了进一步封装（让继承类少写一些代码），搞出了一个虚函数continuePlaying()。让我们来看一下：

[cpp] view plain copy print ?
  1. Boolean MultiFramedRTPSink::continuePlaying() {  
  2.     // Send the first packet.   
  3.     // (This will also schedule any future sends.)  
  4.     buildAndSendPacket(True);  
  5.     return True;  
  6. }  

MultiFramedRTPSink是与帧有关的类，其实它要求每次必须从source获得一个帧的数据，所以才叫这个name。可以看到continuePlaying()完全被buildAndSendPacket()代替。看一下buildAndSendPacket():

[cpp] view plain copy print ?
  1. void MultiFramedRTPSink::buildAndSendPacket(Boolean isFirstPacket)   
  2. {  
  3.     //此函数中主要是准备rtp包的头，为一些需要跟据实际数据改变的字段留出位置。  
  4.     fIsFirstPacket = isFirstPacket;  
  5.   
  6.   
  7.     // Set up the RTP header:   
  8.     unsigned rtpHdr = 0x80000000; // RTP version 2; marker ('M') bit not set (by default; it can be set later)  
  9.     rtpHdr |= (fRTPPayloadType << 16);  
  10.     rtpHdr |= fSeqNo; // sequence number   
  11.     fOutBuf->enqueueWord(rtpHdr);//向包中加入一个字  
  12.   
  13.   
  14.     // Note where the RTP timestamp will go.  
  15.     // (We can't fill this in until we start packing payload frames.)  
  16.     fTimestampPosition = fOutBuf->curPacketSize();  
  17.     fOutBuf->skipBytes(4); // leave a hole for the timestamp　在缓冲中空出时间戳的位置  
  18.   
  19.   
  20.     fOutBuf->enqueueWord(SSRC());   
  21.   
  22.   
  23.     // Allow for a special, payload-format-specific header following the  
  24.     // RTP header:   
  25.     fSpecialHeaderPosition = fOutBuf->curPacketSize();  
  26.     fSpecialHeaderSize = specialHeaderSize();  
  27.     fOutBuf->skipBytes(fSpecialHeaderSize);  
  28.   
  29.   
  30.     // Begin packing as many (complete) frames into the packet as we can:  
  31.     fTotalFrameSpecificHeaderSizes = 0;  
  32.     fNoFramesLeft = False;  
  33.     fNumFramesUsedSoFar = 0; // 一个包中已打入的帧数。  
  34.     //头准备好了，再打包帧数据   
  35.     packFrame();  
  36. }  

继续看packFrame()：

[cpp] view plain copy print ?
  1. void MultiFramedRTPSink::packFrame()  
  2. {  
  3.     // First, see if we have an overflow frame that was too big for the last pkt  
  4.     if (fOutBuf->haveOverflowData()) {  
  5.         //如果有帧数据，则使用之。OverflowData是指上次打包时剩下的帧数据，因为一个包可能容纳不了一个帧。  
  6.         // Use this frame before reading a new one from the source  
  7.         unsigned frameSize = fOutBuf->overflowDataSize();  
  8.         struct timeval presentationTime = fOutBuf->overflowPresentationTime();  
  9.         unsigned durationInMicroseconds =fOutBuf->overflowDurationInMicroseconds();  
  10.         fOutBuf->useOverflowData();  
  11.   
  12.   
  13.         afterGettingFrame1(frameSize, 0, presentationTime,durationInMicroseconds);  
  14.     } else {  
  15.         //一点帧数据都没有，跟source要吧。   
  16.         // Normal case: we need to read a new frame from the source  
  17.         if (fSource == NULL)  
  18.             return;  
  19.   
  20.   
  21.         //更新缓冲中的一些位置   
  22.         fCurFrameSpecificHeaderPosition = fOutBuf->curPacketSize();  
  23.         fCurFrameSpecificHeaderSize = frameSpecificHeaderSize();  
  24.         fOutBuf->skipBytes(fCurFrameSpecificHeaderSize);  
  25.         fTotalFrameSpecificHeaderSizes += fCurFrameSpecificHeaderSize;  
  26.   
  27.   
  28.         //从source获取下一帧   
  29.         fSource->getNextFrame(fOutBuf->curPtr(),//新数据存放开始的位置  
  30.                 fOutBuf->totalBytesAvailable(),//缓冲中空余的空间大小  
  31.                 afterGettingFrame,  //因为可能source中的读数据函数会被放在任务调度中，所以把获取帧后应调用的函数传给source  
  32.                 this,  
  33.                 ourHandleClosure, //这个是source结束时(比如文件读完了)要调用的函数。  
  34.                 this);  
  35.     }  
  36. }  

可以想像下面就是source从文件（或某个设备）中读取一帧数据，读完后返回给sink，当然不是从函数返回了，而是以调用afterGettingFrame这个回调函数的方式。所以下面看一下afterGettingFrame():

[cpp] view plain copy print ?
  1. void MultiFramedRTPSink::afterGettingFrame(void* clientData,  
  2.         unsigned numBytesRead, unsigned numTruncatedBytes,  
  3.         struct timeval presentationTime, unsigned durationInMicroseconds)  
  4. {  
  5.     MultiFramedRTPSink* sink = (MultiFramedRTPSink*) clientData;  
  6.     sink->afterGettingFrame1(numBytesRead, numTruncatedBytes, presentationTime,  
  7.             durationInMicroseconds);  
  8. }  

没什么可看的，只是过度为调用成员函数，所以afterGettingFrame1()才是重点：

[cpp] view plain copy print ?
  1. void MultiFramedRTPSink::afterGettingFrame1(  
  2.         unsigned frameSize,  
  3.         unsigned numTruncatedBytes,  
  4.         struct timeval presentationTime,  
  5.         unsigned durationInMicroseconds)  
  6. {  
  7.     if (fIsFirstPacket) {  
  8.         // Record the fact that we're starting to play now:  
  9.         gettimeofday(&fNextSendTime, NULL);  
  10.     }  
  11.   
  12.   
  13.     //如果给予一帧的缓冲不够大，就会发生截断一帧数据的现象。但也只能提示一下用户  
  14.     if (numTruncatedBytes > 0) {  
  15.   
  16.   
  17.         unsigned const bufferSize = fOutBuf->totalBytesAvailable();  
  18.         envir()  
  19.                 << "MultiFramedRTPSink::afterGettingFrame1(): The input frame data was too large for our buffer size ("  
  20.                 << bufferSize  
  21.                 << ").  "  
  22.                 << numTruncatedBytes  
  23.                 << " bytes of trailing data was dropped!  Correct this by increasing \"OutPacketBuffer::maxSize\" to at least "  
  24.                 << OutPacketBuffer::maxSize + numTruncatedBytes  
  25.                 << ", *before* creating this 'RTPSink'.  (Current value is "  
  26.                 << OutPacketBuffer::maxSize << ".)\n";  
  27.     }  
  28.     unsigned curFragmentationOffset = fCurFragmentationOffset;  
  29.     unsigned numFrameBytesToUse = frameSize;  
  30.     unsigned overflowBytes = 0;  
  31.   
  32.   
  33.     //如果包只已经打入帧数据了，并且不能再向这个包中加数据了，则把新获得的帧数据保存下来。  
  34.     // If we have already packed one or more frames into this packet,  
  35.     // check whether this new frame is eligible to be packed after them.  
  36.     // (This is independent of whether the packet has enough room for this  
  37.     // new frame; that check comes later.)  
  38.     if (fNumFramesUsedSoFar > 0) {  
  39.         //如果包中已有了一个帧，并且不允许再打入新的帧了，则只记录下新的帧。  
  40.         if ((fPreviousFrameEndedFragmentation && !allowOtherFramesAfterLastFragment())  
  41.                 || !frameCanAppearAfterPacketStart(fOutBuf->curPtr(), frameSize))  
  42.         {  
  43.             // Save away this frame for next time:  
  44.             numFrameBytesToUse = 0;  
  45.             fOutBuf->setOverflowData(fOutBuf->curPacketSize(), frameSize,  
  46.                     presentationTime, durationInMicroseconds);  
  47.         }  
  48.     }  
  49.       
  50.     //表示当前打入的是否是上一个帧的最后一块数据。   
  51.     fPreviousFrameEndedFragmentation = False;  
  52.   
  53.   
  54.     //下面是计算获取的帧中有多少数据可以打到当前包中，剩下的数据就作为overflow数据保存下来。  
  55.     if (numFrameBytesToUse > 0) {  
  56.         // Check whether this frame overflows the packet  
  57.         if (fOutBuf->wouldOverflow(frameSize)) {  
  58.             // Don't use this frame now; instead, save it as overflow data, and  
  59.             // send it in the next packet instead.  However, if the frame is too  
  60.             // big to fit in a packet by itself, then we need to fragment it (and  
  61.             // use some of it in this packet, if the payload format permits this.)  
  62.             if (isTooBigForAPacket(frameSize)  
  63.                     && (fNumFramesUsedSoFar == 0 || allowFragmentationAfterStart())) {  
  64.                 // We need to fragment this frame, and use some of it now:  
  65.                 overflowBytes = computeOverflowForNewFrame(frameSize);  
  66.                 numFrameBytesToUse -= overflowBytes;  
  67.                 fCurFragmentationOffset += numFrameBytesToUse;  
  68.             } else {  
  69.                 // We don't use any of this frame now:  
  70.                 overflowBytes = frameSize;  
  71.                 numFrameBytesToUse = 0;  
  72.             }  
  73.             fOutBuf->setOverflowData(fOutBuf->curPacketSize() + numFrameBytesToUse,  
  74.                     overflowBytes, presentationTime, durationInMicroseconds);  
  75.         } else if (fCurFragmentationOffset > 0) {  
  76.             // This is the last fragment of a frame that was fragmented over  
  77.             // more than one packet.  Do any special handling for this case:  
  78.             fCurFragmentationOffset = 0;  
  79.             fPreviousFrameEndedFragmentation = True;  
  80.         }  
  81.     }  
  82.   
  83.   
  84.       
  85.     if (numFrameBytesToUse == 0 && frameSize > 0) {  
  86.         //如果包中有数据并且没有新数据了，则发送之。（这种情况好像很难发生啊！）  
  87.         // Send our packet now, because we have filled it up:  
  88.         sendPacketIfNecessary();  
  89.     } else {  
  90.         //需要向包中打入数据。   
  91.           
  92.         // Use this frame in our outgoing packet:  
  93.         unsigned char* frameStart = fOutBuf->curPtr();  
  94.         fOutBuf->increment(numFrameBytesToUse);  
  95.         // do this now, in case "doSpecialFrameHandling()" calls "setFramePadding()" to append padding bytes  
  96.   
  97.   
  98.         // Here's where any payload format specific processing gets done:  
  99.         doSpecialFrameHandling(curFragmentationOffset, frameStart,  
  100.                 numFrameBytesToUse, presentationTime, overflowBytes);  
  101.   
  102.   
  103.         ++fNumFramesUsedSoFar;  
  104.   
  105.   
  106.         // Update the time at which the next packet should be sent, based  
  107.         // on the duration of the frame that we just packed into it.  
  108.         // However, if this frame has overflow data remaining, then don't  
  109.         // count its duration yet.  
  110.         if (overflowBytes == 0) {  
  111.             fNextSendTime.tv_usec += durationInMicroseconds;  
  112.             fNextSendTime.tv_sec += fNextSendTime.tv_usec / 1000000;  
  113.             fNextSendTime.tv_usec %= 1000000;  
  114.         }  
  115.   
  116.   
  117.         //如果需要，就发出包，否则继续打入数据。   
  118.         // Send our packet now if (i) it's already at our preferred size, or  
  119.         // (ii) (heuristic) another frame of the same size as the one we just  
  120.         //      read would overflow the packet, or  
  121.         // (iii) it contains the last fragment of a fragmented frame, and we  
  122.         //      don't allow anything else to follow this or  
  123.         // (iv) one frame per packet is allowed:  
  124.         if (fOutBuf->isPreferredSize()  
  125.                 || fOutBuf->wouldOverflow(numFrameBytesToUse)  
  126.                 || (fPreviousFrameEndedFragmentation  
  127.                         && !allowOtherFramesAfterLastFragment())  
  128.                 || !frameCanAppearAfterPacketStart(  
  129.                         fOutBuf->curPtr() - frameSize, frameSize)) {  
  130.             // The packet is ready to be sent now  
  131.             sendPacketIfNecessary();  
  132.         } else {  
  133.             // There's room for more frames; try getting another:  
  134.             packFrame();  
  135.         }  
  136.     }  
  137. }  


看一下发送数据的函数：

[cpp] view plain copy print ?
  1. void MultiFramedRTPSink::sendPacketIfNecessary()  
  2. {  
  3.     //发送包   
  4.     if (fNumFramesUsedSoFar > 0) {  
  5.         // Send the packet:   
  6. #ifdef TEST_LOSS   
  7.         if ((our_random()%10) != 0) // simulate 10% packet loss #####  
  8. #endif   
  9.         if (!fRTPInterface.sendPacket(fOutBuf->packet(),fOutBuf->curPacketSize())) {  
  10.             // if failure handler has been specified, call it  
  11.             if (fOnSendErrorFunc != NULL)  
  12.                 (*fOnSendErrorFunc)(fOnSendErrorData);  
  13.         }  
  14.         ++fPacketCount;  
  15.         fTotalOctetCount += fOutBuf->curPacketSize();  
  16.         fOctetCount += fOutBuf->curPacketSize() - rtpHeaderSize  
  17.                 - fSpecialHeaderSize - fTotalFrameSpecificHeaderSizes;  
  18.   
  19.   
  20.         ++fSeqNo; // for next time   
  21.     }  
  22.   
  23.   
  24.     //如果还有剩余数据，则调整缓冲区   
  25.     if (fOutBuf->haveOverflowData()  
  26.             && fOutBuf->totalBytesAvailable() > fOutBuf->totalBufferSize() / 2) {  
  27.         // Efficiency hack: Reset the packet start pointer to just in front of  
  28.         // the overflow data (allowing for the RTP header and special headers),  
  29.         // so that we probably don't have to "memmove()" the overflow data  
  30.         // into place when building the next packet:  
  31.         unsigned newPacketStart = fOutBuf->curPacketSize()-   
  32.                 (rtpHeaderSize + fSpecialHeaderSize + frameSpecificHeaderSize());  
  33.         fOutBuf->adjustPacketStart(newPacketStart);  
  34.     } else {  
  35.         // Normal case: Reset the packet start pointer back to the start:  
  36.         fOutBuf->resetPacketStart();  
  37.     }  
  38.     fOutBuf->resetOffset();  
  39.     fNumFramesUsedSoFar = 0;  
  40.   
  41.   
  42.     if (fNoFramesLeft) {  
  43.         //如果再没有数据了，则结束之   
  44.         // We're done:   
  45.         onSourceClosure(this);  
  46.     } else {  
  47.         //如果还有数据，则在下一次需要发送的时间再次打包发送。  
  48.         // We have more frames left to send.  Figure out when the next frame  
  49.         // is due to start playing, then make sure that we wait this long before  
  50.         // sending the next packet.   
  51.         struct timeval timeNow;  
  52.         gettimeofday(&timeNow, NULL);  
  53.         int secsDiff = fNextSendTime.tv_sec - timeNow.tv_sec;  
  54.         int64_t uSecondsToGo = secsDiff * 1000000  
  55.                 + (fNextSendTime.tv_usec - timeNow.tv_usec);  
  56.         if (uSecondsToGo < 0 || secsDiff < 0) { // sanity check: Make sure that the time-to-delay is non-negative:  
  57.             uSecondsToGo = 0;  
  58.         }  
  59.   
  60.   
  61.         // Delay this amount of time:  
  62.         nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecondsToGo,  
  63.                 (TaskFunc*) sendNext, this);  
  64.     }  
  65. }  



可以看到为了延迟包的发送，使用了delay task来执行下次打包发送任务。

sendNext()中又调用了buildAndSendPacket()函数，呵呵，又是一个圈圈。

总结一下调用过程：

live555学习2（转）_第1张图片


最后，再说明一下包缓冲区的使用：

MultiFramedRTPSink中的帧数据和包缓冲区共用一个，只是用一些额外的变量指明缓冲区中属于包的部分以及属于帧数据的部分（包以外的数据叫做overflow data）。它有时会把overflow data以mem move的方式移到包开始的位置，有时把包的开始位置直接设置到overflow data开始的地方。那么这个缓冲的大小是怎样确定的呢？是跟据调用者指定的的一个最大的包的大小+60000算出的。这个地方把我搞胡涂了：如果一次从source获取一个帧的话，那这个缓冲应设为不小于最大的一个帧的大小才是，为何是按包的大小设置呢？可以看到，当缓冲不够时只是提示一下：

[cpp] view plain copy print ?
  1. if (numTruncatedBytes > 0) {  
  2.   
  3.   
  4.     unsigned const bufferSize = fOutBuf->totalBytesAvailable();  
  5.     envir()  
  6.             << "MultiFramedRTPSink::afterGettingFrame1(): The input frame data was too large for our buffer size ("  
  7.             << bufferSize  
  8.             << ").  "  
  9.             << numTruncatedBytes  
  10.             << " bytes of trailing data was dropped!  Correct this by increasing \"OutPacketBuffer::maxSize\" to at least "  
  11.             << OutPacketBuffer::maxSize + numTruncatedBytes  
  12.             << ", *before* creating this 'RTPSink'.  (Current value is "  
  13.             << OutPacketBuffer::maxSize << ".)\n";  
  14. }  

当然此时不会出错，但有可能导致时间戳计算不准，或增加时间戳计算与source端处理的复杂性(因为一次取一帧时间戳是很好计算的)。

 

 

 

 

八 RTSPClient分析

有RTSPServer，当然就要有RTSPClient。
如果按照Server端的架构，想一下Client端各部分的组成可能是这样：
因为要连接RTSP server，所以RTSPClient要有TCP socket。当获取到server端的DESCRIBE后，应建立一个对应于ServerMediaSession的ClientMediaSession。对应每个Track，ClientMediaSession中应建立ClientMediaSubsession。当建立RTP Session时，应分别为所拥有的Track发送SETUP请求连接，在获取回应后，分别为所有的track建立RTP socket，然后请求PLAY，然后开始传输数据。事实是这样吗？只能分析代码了。


testProgs中的OpenRTSP是典型的RTSPClient示例，所以分析它吧。
main()函数在playCommon.cpp文件中。main()的流程比较简单，跟服务端差别不大：建立任务计划对象－－建立环境对象－－处理用户输入的参数(RTSP地址)－－创建RTSPClient实例－－发出第一个RTSP请求（可能是OPTIONS也可能是DESCRIBE）－－进入Loop。


RTSP的tcp连接是在发送第一个RTSP请求时才建立的，在RTSPClient的那几个发请求的函数sendXXXXXXCommand()中最终都调用sendRequest()，sendRequest()中会跟据情况建立起TCP连接。在建立连接时马上向任务计划中加入处理从这个TCP接收数据的socket handler：RTSPClient::incomingDataHandler()。
下面就是发送RTSP请求，OPTIONS就不必看了，从请求DESCRIBE开始：

[cpp] view plain copy print ?
  1. void getSDPDescription(RTSPClient::responseHandler* afterFunc)  
  2. {  
  3.     ourRTSPClient->sendDescribeCommand(afterFunc, ourAuthenticator);  
  4. }  
  5. unsigned RTSPClient::sendDescribeCommand(responseHandler* responseHandler,  
  6.         Authenticator* authenticator)  
  7. {  
  8.     if (authenticator != NULL)  
  9.         fCurrentAuthenticator = *authenticator;  
  10.     return sendRequest(new RequestRecord(++fCSeq, "DESCRIBE", responseHandler));  
  11. }  
参数responseHandler是调用者提供的回调函数，用于在处理完请求的回应后再调用之。并且在这个回调函数中会发出下一个请求－－所有的请求都是这样依次发出的。使用回调函数的原因主要是因为socket的发送与接收不是同步进行的。类RequestRecord就代表一个请求,它不但保存了RTSP请求相关的信息，而且保存了请求完成后的回调函数－－就是responseHandler。有些请求发出时还没建立tcp连接，不能立即发送，则加入fRequestsAwaitingConnection队列；有些发出后要等待Server端的回应，就加入fRequestsAwaitingResponse队列，当收到回应后再从队列中把它取出。
由于RTSPClient::sendRequest()太复杂，就不列其代码了，其无非是建立起RTSP请求字符串然后用TCP socket发送之。


现在看一下收到DESCRIBE的回应后如何处理它。理论上是跟据媒体信息建立起MediaSession了，看看是不是这样：

[cpp] view plain copy print ?
  1. void continueAfterDESCRIBE(RTSPClient*, int resultCode, char* resultString)  
  2. {  
  3.     char* sdpDescription = resultString;  
  4.     //跟据SDP创建MediaSession。   
  5.     // Create a media session object from this SDP description:  
  6.     session = MediaSession::createNew(*env, sdpDescription);  
  7.     delete[] sdpDescription;  
  8.   
  9.     // Then, setup the "RTPSource"s for the session:  
  10.     MediaSubsessionIterator iter(*session);  
  11.     MediaSubsession *subsession;  
  12.     Boolean madeProgress = False;  
  13.     char const* singleMediumToTest = singleMedium;  
  14.     //循环所有的MediaSubsession，为每个设置其RTPSource的参数  
  15.     while ((subsession = iter.next()) != NULL) {  
  16.         //初始化subsession，在其中会建立RTP/RTCP socket以及RTPSource。  
  17.         if (subsession->initiate(simpleRTPoffsetArg)) {  
  18.             madeProgress = True;  
  19.             if (subsession->rtpSource() != NULL) {  
  20.                 // Because we're saving the incoming data, rather than playing  
  21.                 // it in real time, allow an especially large time threshold  
  22.                 // (1 second) for reordering misordered incoming packets:  
  23.                 unsigned const thresh = 1000000; // 1 second  
  24.                 subsession->rtpSource()->setPacketReorderingThresholdTime(thresh);  
  25.   
  26.                 // Set the RTP source's OS socket buffer size as appropriate - either if we were explicitly asked (using -B),  
  27.                 // or if the desired FileSink buffer size happens to be larger than the current OS socket buffer size.  
  28.                 // (The latter case is a heuristic, on the assumption that if the user asked for a large FileSink buffer size,  
  29.                 // then the input data rate may be large enough to justify increasing the OS socket buffer size also.)  
  30.                 int socketNum = subsession->rtpSource()->RTPgs()->socketNum();  
  31.                 unsigned curBufferSize = getReceiveBufferSize(*env,socketNum);  
  32.                 if (socketInputBufferSize > 0　|| fileSinkBufferSize > curBufferSize) {  
  33.                     unsigned newBufferSize =　socketInputBufferSize > 0 ?　  
  34.                         socketInputBufferSize : fileSinkBufferSize;  
  35.                     newBufferSize = setReceiveBufferTo(*env, socketNum, newBufferSize);  
  36.                     if (socketInputBufferSize > 0) { // The user explicitly asked for the new socket buffer size; announce it:  
  37.                         *env  
  38.                                 << "Changed socket receive buffer size for the \""  
  39.                                 << subsession->mediumName() << "/"  
  40.                                 << subsession->codecName()  
  41.                                 << "\" subsession from " << curBufferSize  
  42.                                 << " to " << newBufferSize << " bytes\n";  
  43.                     }  
  44.                 }  
  45.             }  
  46.         }  
  47.     }  
  48.     if (!madeProgress)  
  49.         shutdown();  
  50.   
  51.     // Perform additional 'setup' on each subsession, before playing them:  
  52.     //下一步就是发送SETUP请求了。需要为每个Track分别发送一次。   
  53.     setupStreams();  
  54. }  
此函数被删掉很多枝叶，所以发现与原版不同请不要惊掉大牙。
的确在DESCRIBE回应后建立起了MediaSession，而且我们发现Client端的MediaSession不叫ClientMediaSesson，SubSession亦不是。我现在很想看看MediaSession与MediaSubsession的建立过程:

[cpp] view plain copy print ?
  1. MediaSession* MediaSession::createNew(UsageEnvironment& env,char const* sdpDescription)  
  2. {  
  3.     MediaSession* newSession = new MediaSession(env);  
  4.     if (newSession != NULL) {  
  5.         if (!newSession->initializeWithSDP(sdpDescription)) {  
  6.             delete newSession;  
  7.             return NULL;  
  8.         }  
  9.     }  
  10.   
  11.     return newSession;  
  12. }  

我可以告诉你，MediaSession的构造函数没什么可看的，那么就来看initializeWithSDP()：
内容太多，不必看了，我大体说说吧：就是处理SDP，跟据每一行来初始化一些变量。当遇到"m="行时，就建立一个MediaSubsession，然后再处理这一行之下，下一个"m="行之上的行们，用这些参数初始化MediaSubsession的变量。循环往复，直到尽头。然而这其中并没有建立RTP socket。我们发现在continueAfterDESCRIBE()中，创建MediaSession之后又调用了subsession->initiate(simpleRTPoffsetArg)，那么socket是不是在它里面创建的呢？look:

[cpp] view plain copy print ?
  1. Boolean MediaSubsession::initiate(int useSpecialRTPoffset)  
  2. {  
  3.     if (fReadSource != NULL)  
  4.         return True; // has already been initiated  
  5.   
  6.     do {  
  7.         if (fCodecName == NULL) {  
  8.             env().setResultMsg("Codec is unspecified");  
  9.             break;  
  10.         }  
  11.   
  12.         //创建RTP/RTCP sockets   
  13.         // Create RTP and RTCP 'Groupsocks' on which to receive incoming data.  
  14.         // (Groupsocks will work even for unicast addresses)  
  15.         struct in_addr tempAddr;  
  16.         tempAddr.s_addr = connectionEndpointAddress();  
  17.         // This could get changed later, as a result of a RTSP "SETUP"  
  18.   
  19.         if (fClientPortNum != 0) {  
  20.             //当server端指定了建议的client端口   
  21.             // The sockets' port numbers were specified for us.  Use these:  
  22.             fClientPortNum = fClientPortNum & ~1; // even  
  23.             if (isSSM()) {  
  24.                 fRTPSocket = new Groupsock(env(), tempAddr, fSourceFilterAddr,  
  25.                         fClientPortNum);  
  26.             } else {  
  27.                 fRTPSocket = new Groupsock(env(), tempAddr, fClientPortNum,  
  28.                         255);  
  29.             }  
  30.             if (fRTPSocket == NULL) {  
  31.                 env().setResultMsg("Failed to create RTP socket");  
  32.                 break;  
  33.             }  
  34.   
  35.             // Set our RTCP port to be the RTP port +1  
  36.             portNumBits const rtcpPortNum = fClientPortNum | 1;  
  37.             if (isSSM()) {  
  38.                 fRTCPSocket = new Groupsock(env(), tempAddr, fSourceFilterAddr,  
  39.                         rtcpPortNum);  
  40.             } else {  
  41.                 fRTCPSocket = new Groupsock(env(), tempAddr, rtcpPortNum, 255);  
  42.             }  
  43.             if (fRTCPSocket == NULL) {  
  44.                 char tmpBuf[100];  
  45.                 sprintf(tmpBuf, "Failed to create RTCP socket (port %d)",  
  46.                         rtcpPortNum);  
  47.                 env().setResultMsg(tmpBuf);  
  48.                 break;  
  49.             }  
  50.         } else {  
  51.             //Server端没有指定client端口，我们自己找一个。之所以做的这样复杂，是为了能找到连续的两个端口  
  52.             //RTP/RTCP的端口号不是要连续吗？还记得不？   
  53.             // Port numbers were not specified in advance, so we use ephemeral port numbers.  
  54.             // Create sockets until we get a port-number pair (even: RTP; even+1: RTCP).  
  55.             // We need to make sure that we don't keep trying to use the same bad port numbers over and over again.  
  56.             // so we store bad sockets in a table, and delete them all when we're done.  
  57.             HashTable* socketHashTable = HashTable::create(ONE_WORD_HASH_KEYS);  
  58.             if (socketHashTable == NULL)  
  59.                 break;  
  60.             Boolean success = False;  
  61.             NoReuse dummy; // ensures that our new ephemeral port number won't be one that's already in use  
  62.   
  63.             while (1) {  
  64.                 // Create a new socket:   
  65.                 if (isSSM()) {  
  66.                     fRTPSocket = new Groupsock(env(), tempAddr,  
  67.                             fSourceFilterAddr, 0);  
  68.                 } else {  
  69.                     fRTPSocket = new Groupsock(env(), tempAddr, 0, 255);  
  70.                 }  
  71.                 if (fRTPSocket == NULL) {  
  72.                     env().setResultMsg(  
  73.                             "MediaSession::initiate(): unable to create RTP and RTCP sockets");  
  74.                     break;  
  75.                 }  
  76.   
  77.                 // Get the client port number, and check whether it's even (for RTP):  
  78.                 Port clientPort(0);  
  79.                 if (!getSourcePort(env(), fRTPSocket->socketNum(),  
  80.                         clientPort)) {  
  81.                     break;  
  82.                 }  
  83.                 fClientPortNum = ntohs(clientPort.num());  
  84.                 if ((fClientPortNum & 1) != 0) { // it's odd  
  85.                     // Record this socket in our table, and keep trying:  
  86.                     unsigned key = (unsigned) fClientPortNum;  
  87.                     Groupsock* existing = (Groupsock*) socketHashTable->Add(  
  88.                             (char const*) key, fRTPSocket);  
  89.                     delete existing; // in case it wasn't NULL  
  90.                     continue;  
  91.                 }  
  92.   
  93.                 // Make sure we can use the next (i.e., odd) port number, for RTCP:  
  94.                 portNumBits rtcpPortNum = fClientPortNum | 1;  
  95.                 if (isSSM()) {  
  96.                     fRTCPSocket = new Groupsock(env(), tempAddr,  
  97.                             fSourceFilterAddr, rtcpPortNum);  
  98.                 } else {  
  99.                     fRTCPSocket = new Groupsock(env(), tempAddr, rtcpPortNum,  
  100.                             255);  
  101.                 }  
  102.                 if (fRTCPSocket != NULL && fRTCPSocket->socketNum() >= 0) {  
  103.                     // Success! Use these two sockets.  
  104.                     success = True;  
  105.                     break;  
  106.                 } else {  
  107.                     // We couldn't create the RTCP socket (perhaps that port number's already in use elsewhere?).  
  108.                     delete fRTCPSocket;  
  109.   
  110.                     // Record the first socket in our table, and keep trying:  
  111.                     unsigned key = (unsigned) fClientPortNum;  
  112.                     Groupsock* existing = (Groupsock*) socketHashTable->Add(  
  113.                             (char const*) key, fRTPSocket);  
  114.                     delete existing; // in case it wasn't NULL  
  115.                     continue;  
  116.                 }  
  117.             }  
  118.   
  119.             // Clean up the socket hash table (and contents):  
  120.             Groupsock* oldGS;  
  121.             while ((oldGS = (Groupsock*) socketHashTable->RemoveNext()) != NULL) {  
  122.                 delete oldGS;  
  123.             }  
  124.             delete socketHashTable;  
  125.   
  126.             if (!success)  
  127.                 break; // a fatal error occurred trying to create the RTP and RTCP sockets; we can't continue  
  128.         }  
  129.   
  130.         // Try to use a big receive buffer for RTP - at least 0.1 second of  
  131.         // specified bandwidth and at least 50 KB  
  132.         unsigned rtpBufSize = fBandwidth * 25 / 2; // 1 kbps * 0.1 s = 12.5 bytes  
  133.         if (rtpBufSize < 50 * 1024)  
  134.             rtpBufSize = 50 * 1024;  
  135.         increaseReceiveBufferTo(env(), fRTPSocket->socketNum(), rtpBufSize);  
  136.   
  137.         // ASSERT: fRTPSocket != NULL && fRTCPSocket != NULL  
  138.         if (isSSM()) {  
  139.             // Special case for RTCP SSM: Send RTCP packets back to the source via unicast:  
  140.             fRTCPSocket->changeDestinationParameters(fSourceFilterAddr, 0, ~0);  
  141.         }  
  142.   
  143.         //创建RTPSource的地方   
  144.         // Create "fRTPSource" and "fReadSource":  
  145.         if (!createSourceObjects(useSpecialRTPoffset))  
  146.             break;  
  147.   
  148.         if (fReadSource == NULL) {  
  149.             env().setResultMsg("Failed to create read source");  
  150.             break;  
  151.         }  
  152.   
  153.         // Finally, create our RTCP instance. (It starts running automatically)  
  154.         if (fRTPSource != NULL) {  
  155.             // If bandwidth is specified, use it and add 5% for RTCP overhead.  
  156.             // Otherwise make a guess at 500 kbps.  
  157.             unsigned totSessionBandwidth =  
  158.                     fBandwidth ? fBandwidth + fBandwidth / 20 : 500;  
  159.             fRTCPInstance = RTCPInstance::createNew(env(), fRTCPSocket,  
  160.                     totSessionBandwidth, (unsigned char const*) fParent.CNAME(),  
  161.                     NULL /* we're a client */, fRTPSource);  
  162.             if (fRTCPInstance == NULL) {  
  163.                 env().setResultMsg("Failed to create RTCP instance");  
  164.                 break;  
  165.             }  
  166.         }  
  167.   
  168.         return True;  
  169.     } while (0);  
  170.   
  171.     //失败时执行到这里   
  172.     delete fRTPSocket;  
  173.     fRTPSocket = NULL;  
  174.     delete fRTCPSocket;  
  175.     fRTCPSocket = NULL;  
  176.     Medium::close(fRTCPInstance);  
  177.     fRTCPInstance = NULL;  
  178.     Medium::close(fReadSource);  
  179.     fReadSource = fRTPSource = NULL;  
  180.     fClientPortNum = 0;  
  181.     return False;  
  182. }  
是的，在其中创建了RTP/RTCP socket并创建了RTPSource，创建RTPSource在函数createSourceObjects()中，看一下：

[cpp] view plain copy print ?
  1. Boolean MediaSubsession::createSourceObjects(int useSpecialRTPoffset)  
  2. {  
  3.     do {  
  4.         // First, check "fProtocolName"   
  5.         if (strcmp(fProtocolName, "UDP") == 0) {  
  6.             // A UDP-packetized stream (*not* a RTP stream)  
  7.             fReadSource = BasicUDPSource::createNew(env(), fRTPSocket);  
  8.             fRTPSource = NULL; // Note!   
  9.   
  10.             if (strcmp(fCodecName, "MP2T") == 0) { // MPEG-2 Transport Stream  
  11.                 fReadSource = MPEG2TransportStreamFramer::createNew(env(),  
  12.                         fReadSource);  
  13.                 // this sets "durationInMicroseconds" correctly, based on the PCR values  
  14.             }  
  15.         } else {  
  16.             // Check "fCodecName" against the set of codecs that we support,  
  17.             // and create our RTP source accordingly  
  18.             // (Later make this code more efficient, as this set grows #####)  
  19.             // (Also, add more fmts that can be implemented by SimpleRTPSource#####)  
  20.             Boolean createSimpleRTPSource = False; // by default; can be changed below  
  21.             Boolean doNormalMBitRule = False; // default behavior if "createSimpleRTPSource" is True  
  22.             if (strcmp(fCodecName, "QCELP") == 0) { // QCELP audio  
  23.                 fReadSource = QCELPAudioRTPSource::createNew(env(), fRTPSocket,  
  24.                         fRTPSource, fRTPPayloadFormat, fRTPTimestampFrequency);  
  25.                 // Note that fReadSource will differ from fRTPSource in this case  
  26.             } else if (strcmp(fCodecName, "AMR") == 0) { // AMR audio (narrowband)  
  27.                 fReadSource = AMRAudioRTPSource::createNew(env(), fRTPSocket,  
  28.                         fRTPSource, fRTPPayloadFormat, 0 /*isWideband*/,  
  29.                         fNumChannels, fOctetalign, fInterleaving,  
  30.                         fRobustsorting, fCRC);  
  31.                 // Note that fReadSource will differ from fRTPSource in this case  
  32.             } else if (strcmp(fCodecName, "AMR-WB") == 0) { // AMR audio (wideband)  
  33.                 fReadSource = AMRAudioRTPSource::createNew(env(), fRTPSocket,  
  34.                         fRTPSource, fRTPPayloadFormat, 1 /*isWideband*/,  
  35.                         fNumChannels, fOctetalign, fInterleaving,  
  36.                         fRobustsorting, fCRC);  
  37.                 // Note that fReadSource will differ from fRTPSource in this case  
  38.             } else if (strcmp(fCodecName, "MPA") == 0) { // MPEG-1 or 2 audio  
  39.                 fReadSource = fRTPSource = MPEG1or2AudioRTPSource::createNew(  
  40.                         env(), fRTPSocket, fRTPPayloadFormat,  
  41.                         fRTPTimestampFrequency);  
  42.             } else if (strcmp(fCodecName, "MPA-ROBUST") == 0) { // robust MP3 audio  
  43.                 fRTPSource = MP3ADURTPSource::createNew(env(), fRTPSocket,  
  44.                         fRTPPayloadFormat, fRTPTimestampFrequency);  
  45.                 if (fRTPSource == NULL)  
  46.                     break;  
  47.   
  48.                 // Add a filter that deinterleaves the ADUs after depacketizing them:  
  49.                 MP3ADUdeinterleaver* deinterleaver = MP3ADUdeinterleaver::createNew(  
  50.                         env(), fRTPSource);  
  51.                 if (deinterleaver == NULL)  
  52.                     break;  
  53.   
  54.                 // Add another filter that converts these ADUs to MP3 frames:  
  55.                 fReadSource = MP3FromADUSource::createNew(env(), deinterleaver);  
  56.             } else if (strcmp(fCodecName, "X-MP3-DRAFT-00") == 0) {  
  57.                 // a non-standard variant of "MPA-ROBUST" used by RealNetworks  
  58.                 // (one 'ADU'ized MP3 frame per packet; no headers)  
  59.                 fRTPSource = SimpleRTPSource::createNew(env(), fRTPSocket,  
  60.                         fRTPPayloadFormat, fRTPTimestampFrequency,  
  61.                         "audio/MPA-ROBUST" /*hack*/);  
  62.                 if (fRTPSource == NULL)  
  63.                     break;  
  64.   
  65.                 // Add a filter that converts these ADUs to MP3 frames:  
  66.                 fReadSource = MP3FromADUSource::createNew(env(), fRTPSource,  
  67.                         False /*no ADU header*/);  
  68.             } else if (strcmp(fCodecName, "MP4A-LATM") == 0) { // MPEG-4 LATM audio  
  69.                 fReadSource = fRTPSource = MPEG4LATMAudioRTPSource::createNew(  
  70.                         env(), fRTPSocket, fRTPPayloadFormat,  
  71.                         fRTPTimestampFrequency);  
  72.             } else if (strcmp(fCodecName, "AC3") == 0  
  73.                     || strcmp(fCodecName, "EAC3") == 0) { // AC3 audio  
  74.                 fReadSource = fRTPSource = AC3AudioRTPSource::createNew(env(),  
  75.                         fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);  
  76.             } else if (strcmp(fCodecName, "MP4V-ES") == 0) { // MPEG-4 Elem Str vid  
  77.                 fReadSource = fRTPSource = MPEG4ESVideoRTPSource::createNew(  
  78.                         env(), fRTPSocket, fRTPPayloadFormat,  
  79.                         fRTPTimestampFrequency);  
  80.             } else if (strcmp(fCodecName, "MPEG4-GENERIC") == 0) {  
  81.                 fReadSource = fRTPSource = MPEG4GenericRTPSource::createNew(  
  82.                         env(), fRTPSocket, fRTPPayloadFormat,  
  83.                         fRTPTimestampFrequency, fMediumName, fMode, fSizelength,  
  84.                         fIndexlength, fIndexdeltalength);  
  85.             } else if (strcmp(fCodecName, "MPV") == 0) { // MPEG-1 or 2 video  
  86.                 fReadSource = fRTPSource = MPEG1or2VideoRTPSource::createNew(  
  87.                         env(), fRTPSocket, fRTPPayloadFormat,  
  88.                         fRTPTimestampFrequency);  
  89.             } else if (strcmp(fCodecName, "MP2T") == 0) { // MPEG-2 Transport Stream  
  90.                 fRTPSource = SimpleRTPSource::createNew(env(), fRTPSocket,  
  91.                         fRTPPayloadFormat, fRTPTimestampFrequency, "video/MP2T",  
  92.                         0, False);  
  93.                 fReadSource = MPEG2TransportStreamFramer::createNew(env(),  
  94.                         fRTPSource);  
  95.                 // this sets "durationInMicroseconds" correctly, based on the PCR values  
  96.             } else if (strcmp(fCodecName, "H261") == 0) { // H.261  
  97.                 fReadSource = fRTPSource = H261VideoRTPSource::createNew(env(),  
  98.                         fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);  
  99.             } else if (strcmp(fCodecName, "H263-1998") == 0  
  100.                     || strcmp(fCodecName, "H263-2000") == 0) { // H.263+  
  101.                 fReadSource = fRTPSource = H263plusVideoRTPSource::createNew(  
  102.                         env(), fRTPSocket, fRTPPayloadFormat,  
  103.                         fRTPTimestampFrequency);  
  104.             } else if (strcmp(fCodecName, "H264") == 0) {  
  105.                 fReadSource = fRTPSource = H264VideoRTPSource::createNew(env(),  
  106.                         fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);  
  107.             } else if (strcmp(fCodecName, "DV") == 0) {  
  108.                 fReadSource = fRTPSource = DVVideoRTPSource::createNew(env(),  
  109.                         fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency);  
  110.             } else if (strcmp(fCodecName, "JPEG") == 0) { // motion JPEG  
  111.                 fReadSource = fRTPSource = JPEGVideoRTPSource::createNew(env(),  
  112.                         fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency,  
  113.                         videoWidth(), videoHeight());  
  114.             } else if (strcmp(fCodecName, "X-QT") == 0  
  115.                     || strcmp(fCodecName, "X-QUICKTIME") == 0) {  
  116.                 // Generic QuickTime streams, as defined in  
  117.                 // <http://developer.apple.com/quicktime/icefloe/dispatch026.html>  
  118.                 char* mimeType = new char[strlen(mediumName())  
  119.                         + strlen(codecName()) + 2];  
  120.                 sprintf(mimeType, "%s/%s", mediumName(), codecName());  
  121.                 fReadSource = fRTPSource = QuickTimeGenericRTPSource::createNew(  
  122.                         env(), fRTPSocket, fRTPPayloadFormat,  
  123.                         fRTPTimestampFrequency, mimeType);  
  124.                 delete[] mimeType;  
  125.             } else if (strcmp(fCodecName, "PCMU") == 0 // PCM u-law audio  
  126.             || strcmp(fCodecName, "GSM") == 0 // GSM audio  
  127.             || strcmp(fCodecName, "DVI4") == 0 // DVI4 (IMA ADPCM) audio  
  128.             || strcmp(fCodecName, "PCMA") == 0 // PCM a-law audio  
  129.             || strcmp(fCodecName, "MP1S") == 0 // MPEG-1 System Stream  
  130.             || strcmp(fCodecName, "MP2P") == 0 // MPEG-2 Program Stream  
  131.             || strcmp(fCodecName, "L8") == 0 // 8-bit linear audio  
  132.             || strcmp(fCodecName, "L16") == 0 // 16-bit linear audio  
  133.             || strcmp(fCodecName, "L20") == 0 // 20-bit linear audio (RFC 3190)  
  134.             || strcmp(fCodecName, "L24") == 0 // 24-bit linear audio (RFC 3190)  
  135.             || strcmp(fCodecName, "G726-16") == 0 // G.726, 16 kbps  
  136.             || strcmp(fCodecName, "G726-24") == 0 // G.726, 24 kbps  
  137.             || strcmp(fCodecName, "G726-32") == 0 // G.726, 32 kbps  
  138.             || strcmp(fCodecName, "G726-40") == 0 // G.726, 40 kbps  
  139.             || strcmp(fCodecName, "SPEEX") == 0 // SPEEX audio  
  140.             || strcmp(fCodecName, "T140") == 0 // T.140 text (RFC 4103)  
  141.             || strcmp(fCodecName, "DAT12") == 0 // 12-bit nonlinear audio (RFC 3190)  
  142.                     ) {  
  143.                 createSimpleRTPSource = True;  
  144.                 useSpecialRTPoffset = 0;  
  145.             } else if (useSpecialRTPoffset >= 0) {  
  146.                 // We don't know this RTP payload format, but try to receive  
  147.                 // it using a 'SimpleRTPSource' with the specified header offset:  
  148.                 createSimpleRTPSource = True;  
  149.             } else {  
  150.                 env().setResultMsg(  
  151.                         "RTP payload format unknown or not supported");  
  152.                 break;  
  153.             }  
  154.   
  155.             if (createSimpleRTPSource) {  
  156.                 char* mimeType = new char[strlen(mediumName())  
  157.                         + strlen(codecName()) + 2];  
  158.                 sprintf(mimeType, "%s/%s", mediumName(), codecName());  
  159.                 fReadSource = fRTPSource = SimpleRTPSource::createNew(env(),  
  160.                         fRTPSocket, fRTPPayloadFormat, fRTPTimestampFrequency,  
  161.                         mimeType, (unsigned) useSpecialRTPoffset,  
  162.                         doNormalMBitRule);  
  163.                 delete[] mimeType;  
  164.             }  
  165.         }  
  166.   
  167.         return True;  
  168.     } while (0);  
  169.   
  170.     return False; // an error occurred  
  171. }  
可以看到，这个函数里主要是跟据前面分析出的媒体和传输信息建立合适的Source。

socket建立了，Source也创建了，下一步应该是连接Sink，形成一个流。到此为止还未看到Sink的影子，应该是在下一步SETUP中建立，我们看到在continueAfterDESCRIBE()的最后调用了setupStreams（），那么就来探索一下setupStreams():

[cpp] view plain copy print ?
  1. void setupStreams()  
  2. {  
  3.     static MediaSubsessionIterator* setupIter = NULL;  
  4.     if (setupIter == NULL)  
  5.         setupIter = new MediaSubsessionIterator(*session);  
  6.   
  7.     //每次调用此函数只为一个Subsession发出SETUP请求。  
  8.     while ((subsession = setupIter->next()) != NULL) {  
  9.         // We have another subsession left to set up:  
  10.         if (subsession->clientPortNum() == 0)  
  11.             continue; // port # was not set  
  12.   
  13.         //为一个Subsession发送SETUP请求。请求处理完成时调用continueAfterSETUP()，  
  14.         //continueAfterSETUP()又调用了setupStreams()，在此函数中为下一个SubSession发送SETUP请求。  
[cpp] view plain copy print ?
  1. <SPAN style="WHITE-SPACE: pre">     </SPAN>//直到处理完所有的SubSession  
  2.         setupSubsession(subsession, streamUsingTCP, continueAfterSETUP);  
  3.         return;  
  4.     }  
  5.   
  6.     //执行到这里时，已循环完所有的SubSession了   
  7.     // We're done setting up subsessions.  
  8.     delete setupIter;  
  9.     if (!madeProgress)  
  10.         shutdown();  
  11.   
  12.     //创建输出文件，看来是在这里创建Sink了。创建sink后，就开始播放它。这个播放应该只是把socket的handler加入到  
  13.     //计划任务中，而没有数据的接收或发送。只有等到发出PLAY请求后才有数据的收发。  
  14.     // Create output files:   
  15.     if (createReceivers) {  
  16.         if (outputQuickTimeFile) {  
  17.             // Create a "QuickTimeFileSink", to write to 'stdout':  
  18.             qtOut = QuickTimeFileSink::createNew(*env, *session, "stdout",  
  19.                     fileSinkBufferSize, movieWidth, movieHeight, movieFPS,  
  20.                     packetLossCompensate, syncStreams, generateHintTracks,  
  21.                     generateMP4Format);  
  22.             if (qtOut == NULL) {  
  23.                 *env << "Failed to create QuickTime file sink for stdout: "  
  24.                         << env->getResultMsg();  
  25.                 shutdown();  
  26.             }  
  27.   
  28.             qtOut->startPlaying(sessionAfterPlaying, NULL);  
  29.         } else if (outputAVIFile) {  
  30.             // Create an "AVIFileSink", to write to 'stdout':  
  31.             aviOut = AVIFileSink::createNew(*env, *session, "stdout",  
  32.                     fileSinkBufferSize, movieWidth, movieHeight, movieFPS,  
  33.                     packetLossCompensate);  
  34.             if (aviOut == NULL) {  
  35.                 *env << "Failed to create AVI file sink for stdout: "  
  36.                         << env->getResultMsg();  
  37.                 shutdown();  
  38.             }  
  39.   
  40.             aviOut->startPlaying(sessionAfterPlaying, NULL);  
  41.         } else {  
  42.             // Create and start "FileSink"s for each subsession:  
  43.             madeProgress = False;  
  44.             MediaSubsessionIterator iter(*session);  
  45.             while ((subsession = iter.next()) != NULL) {  
  46.                 if (subsession->readSource() == NULL)  
  47.                     continue; // was not initiated  
  48.   
  49.                 // Create an output file for each desired stream:  
  50.                 char outFileName[1000];  
  51.                 if (singleMedium == NULL) {  
  52.                     // Output file name is  
  53.                     //     "<filename-prefix><medium_name>-<codec_name>-<counter>"  
  54.                     static unsigned streamCounter = 0;  
  55.                     snprintf(outFileName, sizeof outFileName, "%s%s-%s-%d",  
  56.                             fileNamePrefix, subsession->mediumName(),  
  57.                             subsession->codecName(), ++streamCounter);  
  58.                 } else {  
  59.                     sprintf(outFileName, "stdout");  
  60.                 }  
  61.                 FileSink* fileSink;  
  62.                 if (strcmp(subsession->mediumName(), "audio") == 0  
  63.                         && (strcmp(subsession->codecName(), "AMR") == 0  
  64.                                 || strcmp(subsession->codecName(), "AMR-WB")  
  65.                                         == 0)) {  
  66.                     // For AMR audio streams, we use a special sink that inserts AMR frame hdrs:  
  67.                     fileSink = AMRAudioFileSink::createNew(*env, outFileName,  
  68.                             fileSinkBufferSize, oneFilePerFrame);  
  69.                 } else if (strcmp(subsession->mediumName(), "video") == 0  
  70.                         && (strcmp(subsession->codecName(), "H264") == 0)) {  
  71.                     // For H.264 video stream, we use a special sink that insert start_codes:  
  72.                     fileSink = H264VideoFileSink::createNew(*env, outFileName,  
  73.                             subsession->fmtp_spropparametersets(),  
  74.                             fileSinkBufferSize, oneFilePerFrame);  
  75.                 } else {  
  76.                     // Normal case:   
  77.                     fileSink = FileSink::createNew(*env, outFileName,  
  78.                             fileSinkBufferSize, oneFilePerFrame);  
  79.                 }  
  80.                 subsession->sink = fileSink;  
  81.                 if (subsession->sink == NULL) {  
  82.                     *env << "Failed to create FileSink for \"" << outFileName  
  83.                             << "\": " << env->getResultMsg() << "\n";  
  84.                 } else {  
  85.                     if (singleMedium == NULL) {  
  86.                         *env << "Created output file: \"" << outFileName  
  87.                                 << "\"\n";  
  88.                     } else {  
  89.                         *env << "Outputting data from the \""  
  90.                                 << subsession->mediumName() << "/"  
  91.                                 << subsession->codecName()  
  92.                                 << "\" subsession to 'stdout'\n";  
  93.                     }  
  94.   
  95.                     if (strcmp(subsession->mediumName(), "video") == 0  
  96.                             && strcmp(subsession->codecName(), "MP4V-ES") == 0 &&  
  97.                             subsession->fmtp_config() != NULL) {  
  98.                         // For MPEG-4 video RTP streams, the 'config' information  
  99.                         // from the SDP description contains useful VOL etc. headers.  
  100.                         // Insert this data at the front of the output file:  
  101.                         unsigned                    configLen;  
  102.                         unsigned char* configData  
  103.                         = parseGeneralConfigStr(subsession->fmtp_config(), configLen);  
  104.                         struct timeval timeNow;  
  105.                         gettimeofday(&timeNow, NULL);  
  106.                         fileSink->addData(configData, configLen, timeNow);  
  107.                         delete[] configData;  
  108.                     }  
  109.   
  110.                     //开始传输   
  111.                     subsession->sink->startPlaying(*(subsession->readSource()),  
  112.                             subsessionAfterPlaying, subsession);  
  113.   
  114.                     // Also set a handler to be called if a RTCP "BYE" arrives  
  115.                     // for this subsession:  
  116.                     if (subsession->rtcpInstance() != NULL) {  
  117.                         subsession->rtcpInstance()->setByeHandler(  
  118.                                 subsessionByeHandler, subsession);  
  119.                     }  
  120.   
  121.                     madeProgress = True;  
  122.                 }  
  123.             }  
  124.             if (!madeProgress)  
  125.                 shutdown();  
  126.         }  
  127.     }  
  128.   
  129.     // Finally, start playing each subsession, to start the data flow:  
  130.     if (duration == 0) {  
  131.         if (scale > 0)  
  132.             duration = session->playEndTime() - initialSeekTime; // use SDP end time  
  133.         else if (scale < 0)  
  134.             duration = initialSeekTime;  
  135.     }  
  136.     if (duration < 0)  
  137.         duration = 0.0;  
  138.   
  139.     endTime = initialSeekTime;  
  140.     if (scale > 0) {  
  141.         if (duration <= 0)  
  142.             endTime = -1.0f;  
  143.         else  
  144.             endTime = initialSeekTime + duration;  
  145.     } else {  
  146.         endTime = initialSeekTime - duration;  
  147.         if (endTime < 0)  
  148.             endTime = 0.0f;  
  149.     }  
  150.   
  151.     //发送PLAY请求，之后才能从Server端接收数据  
  152.     startPlayingSession(session, initialSeekTime, endTime, scale,  
  153.             continueAfterPLAY);  
  154. }  
仔细看看注释，应很容易了解此函数。

你可能感兴趣的:(live555学习2（转）)

  • 「Selenium+Python自动化从0到1①｜2025最新环境搭建+浏览器驱动避坑指南（附验证代码）」 俗人咖 seleniumpython自动化
    Selenium+Python自动化1-环境搭建一、Selenium简介Selenium是一个广泛使用的自动化测试工具，主要用于Web应用程序的自动化测试。它支持多种编程语言（如Java、Python、C#、Ruby、JavaScript等），并允许用户控制浏览器执行自动化任务，例如点击按钮、填写表单、验证页面内容等。Selenium可以在多种浏览器（如Chrome、Firefox、Edge、Sa
  • 第二章：基础概念精讲 - 第二节 - Tailwind CSS 颜色系统和主题定制 tailwind-css
    颜色系统基础1.默认调色板TailwindCSS提供了一套精心设计的默认颜色系统：//tailwind.config.js默认颜色示例module.exports={theme:{colors:{//灰度gray:{50:'#f9fafb',100:'#f3f4f6',200:'#e5e7eb',//...更多色阶900:'#111827',},//主题色blue:{50:'#eff6ff',10
  • Go语言学习笔记——类型转换工具库cast PPPsych Go精进学习golang
    文章目录Golang类型转换工具库cast简介快速入门安装使用高级转换时间和时长转换时间类型的转换字符串转换为时间时长类型的转换转换为切片ToIntSliceEToStringSliceE转为`map[string]Type`类型Golang类型转换工具库cast简介cast可以在Go中轻松安全地从一种类型转换为另一种类型，cast提供了简单的函数来轻松地将数字转换为字符串，将接口转换为布尔值等。
  • 大模型成本优化实战：从分布式训练到量化剪枝，轻松降低AI计算开销 网罗开发 AI大模型人工智能机器学习深度学习
    网罗开发（小红书、快手、视频号同名）  大家好，我是展菲，目前在上市企业从事人工智能项目研发管理工作，平时热衷于分享各种编程领域的软硬技能知识以及前沿技术，包括iOS、前端、HarmonyOS、Java、Python等方向。在移动端开发、鸿蒙开发、物联网、嵌入式、云原生、开源等领域有深厚造诣。图书作者：《ESP32-C3物联网工程开发实战》图书作者：《SwiftUI入门，进阶与实战》超级个体：CO
  • 高并发微服务日志管理：ELK、Loki、Fluentd 终极对决与实战指南 网罗开发 java集后端云原生微服务elk架构
    网罗开发（小红书、快手、视频号同名）  大家好，我是展菲，目前在上市企业从事人工智能项目研发管理工作，平时热衷于分享各种编程领域的软硬技能知识以及前沿技术，包括iOS、前端、HarmonyOS、Java、Python等方向。在移动端开发、鸿蒙开发、物联网、嵌入式、云原生、开源等领域有深厚造诣。图书作者：《ESP32-C3物联网工程开发实战》图书作者：《SwiftUI入门，进阶与实战》超级个体：CO
  • Redis面试题----MySQL 里有 2000w 数据，Redis 中只存 20w 的数据，如何保证 Redis 中的数据都是热点数据？ 指尖下的技术 Java面试题redismysql数据库
    要保证Redis中存储的20w数据都是热点数据，可以从数据筛选和数据淘汰两个大的方面来考虑，以下是详细的实现思路和方法：数据筛选1.基于业务规则分析业务场景：不同的业务场景有不同的热点数据特征。例如，在电商系统中，热门商品、促销商品往往是热点数据；在新闻资讯系统中，最新发布、阅读量高的新闻是热点数据。根据业务的特点，确定热点数据的规则。定期同步：编写脚本或程序，根据业务规则从MySQL中筛选出符合
  • 简单叙述 Spring Boot 启动过程 魔道不误砍柴功 springbootjava数据库
    文章目录1.准备阶段：应用启动的入口2.创建SpringApplication对象：开始启动工作3.配置环境（Environment）：识别开发环境与生产环境4.启动监听器和初始化器：感知启动的关键事件5.创建ApplicationContext容器：加载核心Bean6.自动配置（Auto-Configuration）：自动加载所需Bean7.启动内嵌Web服务器：Tomcat、Jetty、Und
  • 深入解析STL与模板元编程的应用与心得 爱编程的Loren 活动文章活动文章
      一、引言  侯捷先生作为C++领域的权威专家，其课程深受开发者们的喜爱。本文将围绕侯捷C++系列课程中的STL（StandardTemplateLibrary，标准模板库）与模板元编程部分展开学习笔记，分享个人对这两大主题的深入理解与学习心得。  二、STL的深刻理解  1.STL概述  STL是C++标准库的一部分，提供了大量的通用算法、容器、迭代器和函数对象等。通过STL，我们可以更加高效
  • 正则大全，一定有你需要的，进来搜 二川bro 前端前端
    那些常用的正则-大全正则表达式（RegularExpression，简称regex或regexp）是编程中一个非常强大的工具，它用于匹配字符串中字符的组合。今天，我将为大家总结100个常用的正则表达式1.匹配数字正则：^\d+$描述：匹配一个或多个数字。2.匹配非负整数正则：^[0-9]+$或^\d*$（包含0）描述：匹配非负整数（包括0）。3.匹配正整数正则：^[1-9]\d*$描述：匹配正整数
  • stm32学习之路——使用串口打印日志 程序员kid1412 linux上stm32学习之路stm32学习嵌入式硬件
    滴答时钟配置完了，现在调试手段还是只能通过单步断点，断点调试太麻烦也太不稳定。参考linux内核的方式将日志加到串口上，通过串口输出一下日志。串口的配置很简单，这里使用USART2，主要是因为引脚比较好接线。使用同步模式，不配置中断。为了打印日志所以不想搞太复杂，异步或中断还要考虑实现buffer来处理缓冲区问题，可以但没必要，简单最好。配置完就可以生成代码了，生成出来后，查看一下可以用哪些api
  • QML实现自己的桌面萌宠源码分享 小灰灰搞电子 QML开发数据库
    一、效果展示1、撒娇2、拖动3、右下角效果二、源码分享1、工程目录2、主窗口源码Main.qmlimportQtQuickimportQtQuick.ControlsWindow{width:640height:480visible:truetitle:qsTr("HelloWorld")propertyQtObjectpetWindow:nullComponent.onCompleted:{va
  • 在Qt中使用SQLite数据库 未来无限 C++QT程序设计Qt数据库
    前言SQLite（sql）是一款开源轻量级的数据库软件，不需要server，可以集成在其他软件中，非常适合嵌入式系统。Qt5以上版本可以直接使用SQLite（Qt自带驱动）。用法1准备引入SQL模块在Qt项目文件(.pro文件)中，加入SQL模块：QT+=sql引用头文件在需要使用SQL的类定义中，引用相关头文件。例如：#include#include#include2使用1.建立数据库检查连接、
  • 网络协议 你一身傲骨怎能输 计算机网络网络协议网络
    网络协议是计算机网络中进行通信的规则和约定的集合。它们定义了数据如何在不同设备之间传输，以及如何解析和处理这些数据。以下是一些常见网络协议的详细介绍：1.TCP/IP协议族TCP/IP（传输控制协议/互联网协议）是互联网的基础协议，它定义了数据如何在网络中传输。IP协议：IPv4：目前广泛使用的互联网协议版本，使用32位地址。IPv6：下一代互联网协议，使用128位地址，提供更大的地址空间和改进的
  • python基础之零基础入门【参数说明+代码实战】 步入烟尘 Python超入门指南全册python开发语言高级语言Python入门
    本文已收录于《Python超入门指南全册》本专栏专门针对零基础和需要进阶提升的同学所准备的一套完整教学，从基础到精通不断进阶深入，后续还有实战项目，轻松应对面试，专栏订阅地址：https://blog.csdn.net/mrdeam/category_12647587.html优点：订阅限时19.9付费专栏，私信博主还可进入全栈VIP答疑群，作者优先解答机会（代码指导、远程服务），群里大佬众多可以
  • 基于大模型的肺纤维化预测及临床方案研究报告 LCG元 围术期危险因子预测模型研究人工智能
    目录一、引言1.1研究背景与意义1.2研究目的与方法二、大模型技术概述2.1大模型的基本原理2.2大模型在医疗领域的应用现状三、肺纤维化相关知识3.1肺纤维化的病因与发病机制3.2肺纤维化的临床症状与诊断方法3.3肺纤维化的治疗现状与挑战四、大模型预测肺纤维化的方法4.1数据收集与预处理4.2模型选择与构建4.3模型训练与优化4.4模型评估与验证五、大模型在肺纤维化术前预测中的应用5.1手术风险评
  • 软件调试之陷阱标志 maomao171314 软件调试陷阱标志软件调试
    陷阱标志IA-32处理器支持的调试陷阱标志共有3种。1.8086支持的单步执行标志(EFLAGS的TF位)。2.386引入的任务状态陷阱标志(TSS的T标志)。3.奔腾Pro引入的分支到分支单步执行标志(DebugCtl寄存器种的BTF标志)。1.单步执行标志标志寄存器(FLAGS)的TF(TrapFlag)位。当TF为1时，CPU每执行完一条指令便会产生一个调试异常(#DB),中断到调试异常处理
  • python学习第七天之面向对象 code_talking python学习开发语言
    面向对象及作用域一、面向对象1.__init__方法(构造方法)1.语法__init__方法是一个特殊的方法，在创建一个对象时自动调用。2.类的方法3.继承1.语法4.多继承1.语法4.方法重写5.类属性与方法1.类的私有属性2.类的方法3.类的私有方法4.类的专有方法5.运算符重载二、命名空间1.作用域2.关键字一、面向对象变量使用之前要先定义定义方法给就是给变量赋值#定义整数变量x=10#定义
  • 第二章：基础概念精讲 - 第一节 - Tailwind CSS 响应式设计系统 tailwind-css
    响应式设计基础1.断点系统TailwindCSS默认提供五个断点：//tailwind.config.js默认断点配置module.exports={theme:{screens:{'sm':'640px',//小屏幕，如手机横屏'md':'768px',//中等屏幕，如平板'lg':'1024px',//大屏幕，如笔记本'xl':'1280px',//超大屏幕，如桌面显示器'2xl':'1536
  • 敏捷开发实践中的质量保障：如何平衡速度与代码质量？ 服务器运维
    敏捷工程：现代软件开发的变革与实践近年来，软件工程领域经历了从传统瀑布模型到敏捷开发的深刻转变。这种转变不仅是技术方法的升级，更是团队协作、需求管理和交付模式的革新。本文将从敏捷开发的核心理念、主流方法、实践案例及未来趋势等角度展开，探讨其如何重塑现代软件开发流程，并为团队提供高效协作的解决方案。[]()一、敏捷开发的核心理念：响应变化，以人为本敏捷开发的起源可追溯至2001年发布的《敏捷宣言》，
  • 导读：生活中的设计模式——启程之前，请不要错过我 陌尘(MoChen) 精品课设计模式Python榜单
    为什么叫设计模式什么是设计模式设计模式与生活有什么联系为什么要学设计模式如何进行学习为什么选择Python弥补市场空缺大势所趋，Python已然成风简单的Python基础Python的特点基本语法常用容器List（列表）Tuple（元组）Dictionary（字典）类的定义Demo让你顿悟重要说明两年前CSDN出了一个产品叫ink，旨在提供一个高质量的写作环境，那时就有写设计模式这一系列的想法了，
  • 用 PyTorch/TensorFlow 搭建简单全连接神经网络 gs80140 AIpytorchtensorflow神经网络
    目录用PyTorch/TensorFlow搭建简单全连接神经网络网络结构概述1.使用PyTorch构建网络2.使用TensorFlow构建网络总结用PyTorch/TensorFlow搭建简单全连接神经网络在本篇博客中，我们将介绍如何使用两大深度学习框架——PyTorch和TensorFlow，构建一个简单的全连接神经网络。该网络包含输入层、一个隐藏层和输出层，适合初学者理解神经网络的基本构建模块
  • 设计模式1---简单工厂模式、工厂方法模式、抽象工厂模式 Sunと c++专栏设计模式简单工厂模式工厂方法模式c++
    三种工厂模式-创建对象的灵活工具在23种设计模式中，总体来说设计模式分为三大类：创建型模式结构型模式行为型模式其中，创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。本文将介绍工厂方法模式、抽象工厂模式2种，其中，工厂方法模式一般可以分为简单工厂模式及工厂模式。简单工厂模式概念简单工厂模式是一种创建型设计模式，旨在引入一个工厂类来创建不同类型的对象，无需直接实例化这些
  • information_schema.processlist 表详解 坚定的小辣鸡在努力 其他MySQLmysqlprocesslist
    information_schema.processlist表（或SHOWPROCESSLIST;命令）用于查看MySQL当前所有的连接进程，帮助管理员监控数据库活动并排查性能问题。以下是该表的字段及其具体含义：information_schema.processlist字段详解字段名数据类型含义示例IDBIGINT连接的唯一ID（线程ID）12345USERVARCHAR连接的MySQL用户ro
  • 力扣.sql.1795.每个产品在不同商店的价格 苏帕贝吉塔 sql刷题记录java数据库开发语言
    题目：表：Products+-------------+---------+|ColumnName|Type|+-------------+---------+|product_id|int||store1|int||store2|int||store3|int|+-------------+---------+在SQL中，这张表的主键是product_id（产品Id）。每行存储了这一产品在不同商
  • STM32-HAL库（下4-智能小车项目） Aspiring Q stm32单片机
    STM32-HAL库（下4-智能小车项目）269智能小车项目概述（1）小车项目综合了stm32各个知识点，具有代表性；270智能小车车身基础安装（1）小车组装后下载代码验证确保硬件无误;271车身基础安装完整版272电机驱动模块L9110S（1）参考文档链接：https://www.lxlinux.net/e/stm32/l9110s-tutorial.html（2）电机驱动模块：是一种用于控制和
  • 【练习】【排列No.1】力扣46. 全排列 柠石榴 回溯输入输出leetcode算法c++回溯
    题目全排列给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案。示例1：输入：nums=[1,2,3]输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]示例2：输入：nums=[0,1]输出：[[0,1],[1,0]]示例3：输入：nums=[1]输出：[[1]]来源：力扣46.全排列思路（注意事项）利用used
  • stm32智能小车设计_stm32智能小车设计方案 2401_87557129 stm32单片机嵌入式硬件
    externu8TIM2CH4_CAPTURE_STA;//输入捕获状态externu16TIM2CH4_CAPTURE_VAL;//输入捕获值intmain(void){u32temp=0;u32length1;u32length2;u32length3;Stm32_Clock_Init(9);//系统时钟设置delay_init(72);//延时初始化uart_init(72,9600);//
  • 2025年计算机毕业设计选题推荐、题目参考 计算机Java毕业设计 计算机毕设选题推荐案例springboot课程设计java毕业设计毕设后端大数据
    博主介绍：✌全网粉丝30W+,CSDN全栈领域优质创作者，博客之星、掘金/华为云/阿里云等平台优质作者,计算机毕设实战导师。目前专注于大学生项目实战开发,讲解,毕业答疑辅导✌主要服务内容：选题定题、开题报告、任务书、程序开发、文档编写和辅导、文档降重、程序讲解、答辩辅导等，欢迎咨询~文末获取源码+数据库+文档感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及文档编写等相关问题都可以给我沟通，希望
  • Golang笔记——Interface类型 m0_74825634 面试学习路线阿里巴巴golang笔记android
    大家好，这里是，关注公主号：Goodnote，专栏文章私信限时Free。本文详细介绍Golang的interface数据结构类型，包括基本实现和使用等。文章目录Go语言中的`interface`详解接口定义实现接口空接口`interface{}`示例：空接口的使用interface类型判断1.类型断言（TypeAssertion）语法示例类型转换和类型断言的区别2.类型开关（TypeSwitch）
  • 爬虫必备html和css基础知识 ylfhpy 爬虫项目入门爬虫htmlcsspython
    一、引言在当今数字化时代，网络上蕴含着海量的有价值数据。Python爬虫技术凭借其高效、灵活的特点，成为了获取这些数据的重要手段。而网页数据通常以HTML格式呈现，要想准确地从网页中提取所需信息，就需要深入了解HTML标签的结构和含义，以及如何运用CSS选择器精准定位目标元素。本文将围绕这两方面展开详细阐述，旨在帮助掌握Python爬虫的关键基础技能。二、常用HTML标签详解2.1文本结构标签2.
  • Spring中@Value注解，需要注意的地方 无量 springbean@Valuexml
    Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 1、在applicationContext.xml文件(或引用文件中)中配置properties文件 <bean id="appProperty" class="org.springframework.beans.fac
  • mongoDB 分片 开窍的石头 mongodb
        mongoDB的分片。要mongos查询数据时候 先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。     第一步启动两台以上的mongo服务 &nb
  • OVER(PARTITION BY)函数用法 0624chenhong oracle
    这篇写得很好，引自 http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html OVER(PARTITION BY)函数用法 2010年10月26日 OVER(PARTITION BY)函数介绍 开窗函数        &nb
  • Android开发中，ADB server didn't ACK 解决方法 一炮送你回车库 Android开发
    首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。   一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。 参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题 简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 &nb
  • canvas中的像素绘制问题 换个号韩国红果果 JavaScriptcanvas
    pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 2.如果绘制点为一个像素的
  • 编码乱码问题 灵静志远 javajvmjsp编码
    1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 3、getBytes()、getByte
  • java 求几个月后的日期 darkranger calendargetinstance
    Date plandate = planDate.toDate(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); Calendar cal = Calendar.getInstance(); cal.setTime(plandate); // 取得三个月后时间 cal.add(Calendar.M
  • 数据库设计的三大范式（通俗易懂） aijuans 数据库复习
    关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
  • 想学工作流怎么入手 atongyeye jbpm
    工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。 很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。 系统学习工作流，很重要的一本书《JBPM工作流开发指南》。 本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 1  首先要
  • Context和SQLiteOpenHelper创建数据库 百合不是茶 androidContext创建数据库
           一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper     一:SQLiteOpenHelper创建数据库:   1,SQLi
  • 浅谈group by和distinct bijian1013 oracle数据库group bydistinct
            group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。         譬如：统计每id数并且只显示数大于3 select id ,count(id) from ta
  • vi opertion 征客丶 macoprationvi
    进入 command mode （命令行模式） 按 esc 键 再按 shift + 冒号 注：以下命令中 带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】 一、文件操作 1.1、强制退出不保存 $ q! 1.2、保存 $ w 1.3、保存并退出 $ wq 1.4、刷新或重新加载已打开的文件 $ e 二、光标移动 2.1、跳到指定行 数字
  • 【Spark十四】深入Spark RDD第三部分RDD基本API bit1129 spark
      对于K/V类型的RDD,如下操作是什么含义？   val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5)) rdd.reduceByKey(_+_).collect  reduceByKey在这里的操作，是把
  • java类加载机制 BlueSkator java虚拟机
    java类加载机制 1.java类加载器的树状结构 引导类加载器 ^ | 扩展类加载器 ^ | 系统类加载器 java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。 虚拟机区分一个Cla
  • 动态添加文本框 BreakingBad 文本框
      <script>     var num=1; function AddInput() {      var str="";     str+="<input 
  • 读《研磨设计模式》-代码笔记-单例模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ public class Singleton { } /* * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题 */ class LazySingleton
  • iOS应用打包发布常见问题 chenhbc iosiOS发布iOS上传iOS打包
    这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。   1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
  • 工作流复杂拓扑结构处理新思路 comsci 设计模式工作算法企业应用OO
    我们走的设计路线和国外的产品不太一样，不一样在哪里呢？  国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
  • oracle 11g新特性Flashback data archive daizj oracle
    1. 什么是flashback data archive Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。
  • 多叉树:2-3-4树 dieslrae 树
        平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征:     1、有一个数据项的节点总是有2个子节点(称为2-节点)     2、有两个数据项的节点总是有3个子节点(称为3-节
  • C语言学习七动态分配 malloc的使用 dcj3sjt126com clanguagemalloc
    /* 2013年3月15日15:16:24 malloc 就memory(内存) allocate(分配)的缩写 本程序没有实际含义，只是理解使用 */ # include <stdio.h> # include <malloc.h> int main(void) { int i = 5; //分配了4个字节 静态分配 int * p
  • Objective-C编码规范[译] dcj3sjt126com 代码规范
      原文链接 : The official raywenderlich.com Objective-C style guide 原文作者 : raywenderlich.com Team 译文出自 : raywenderlich.com Objective-C编码规范 译者 : Sam Lau
  • 0.性能优化-目录 frank1234 性能优化
    从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。 主要内容包括： 一、性能测试指标 吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 http://frank1234.iteye.com/blog/2180305 二、性能测试策略 生产环境相同 基准测试 预热等 htt
  • Java父类取得子类传递的泛型参数Class类型 happyqing java泛型父类子类Class
      import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import org.junit.Test; abstract class BaseDao<T> { public void getType() { //Class<E> clazz =
  • 跟我学SpringMVC目录汇总贴、PDF下载、源码下载 jinnianshilongnian springMVC
      ----广告-------------------------------------------------------------- 网站核心商详页开发 掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架； 掌握数据库技术，表设计和索引优化，分库分表/读写分离； 了解缓存技术，熟练使用如Redis/Memcached等主流技术； 了解Ngin
  • the HTTP rewrite module requires the PCRE library 流浪鱼 rewrite
    ./configure: error: the HTTP rewrite module requires the PCRE library. 模块依赖性Nginx需要依赖下面3个包 1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 3. s
  • 第12章 Ajax（中） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Optimize query with Query Stripping in Web Intelligence blueoxygen BO
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence and a very straightfoward video http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
  • Java开发者写SQL时常犯的10个错误 tomcat_oracle javasql
    1、不用PreparedStatements 　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个： 　　他们对PreparedStatements不了解 　　他们认为使用PreparedStatements太慢了 　　他们认为写Prepar
  • 世纪互联与结盟有感 阿尔萨斯
    10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。 全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。 众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他