u013805103
u013805103

live555学习笔记8－RTSPClient分析

八 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
  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
  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
  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
  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
  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
  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
  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学习笔记8－RTSPClient分析)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么 测评君高省
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！ 成长时间线
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 闲鱼鱼小铺怎么开通？鱼小铺开通需要哪些流程？ 高省APP大九
    闲鱼鱼小铺是平台推出的一个专业程度的店铺，与普通店铺相比会有更多的权益，比如说发布的商品数量从50增加到500；拥有专业的店铺数据看板与分析的功能，这对于专门在闲鱼做生意的用户来说是非常有帮助的，那么鱼小铺每个人都能开通吗？大家好，我是高省APP联合创始人蓓蓓导师，高省APP是2021年推出的电商导购平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个可省钱佣金高，能
  • 2019-11-04复盘——飞来山上千寻塔，闻说鸡鸣见日升。 那一叶秋
    1、大盘篇先上老图，看习惯了，也就知道走势了图1上证指数日线图还是那张老图，自己可以在自己的相关软件上画出来，快变盘了。2、个股篇未加仓、未减仓。分析量能的时候，突然发现这么一个东西：“放量突破年线，缩量回调。”合众科技日线图其实，最近的N只个股，在技术分析上，都到了变盘的临界时候。结合这么久的走势，特别是ZJH不断放开IPO的申请，本质上说是融资难度变大，或者说是为企业的融资开创便利。但现在市场
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • 果然只有离职的时候，才有人敢说真话！ return2ok
    今天公司出了神贴。今天中午吃饭，同事问我看了论坛上的神贴了吗？什么帖子？我问。同事显得很惊讶，你居然没看，现在那个帖子可能会成为年度最佳帖子。这么厉害？我等不及了，饭没吃完就快速的奔向办公室，打开公司论坛，我要一睹这个帖子的神奇。写这帖子的童鞋胆儿真肥。这哪里是一个帖子，这是很多个帖子，组成了一个系列。某人从公司文化、管理、人事、项目管理等多个方面分析了公司的概况，并抨击了公司的各种弊端，并提出了
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • 母亲节如何做小红书营销 美橙传媒
    小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
  • 系统架构设计师 需求分析篇二 AmHardy 软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
  • 语文主题教学学习笔记之87 东哥杂谈
    “语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
  • Python神器！WEB自动化测试集成工具 DrissionPage 亚丁号 python开发语言
    一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • 今日分享：有的孩子家长常常在对于小朋友老是说谎，还特别爱推卸责任，很头痛，不知道该怎么办！ 雨燕Cassie
    其实六岁以前都不叫撒谎，只能叫做逃避和害怕，因为他们都是没有撒谎的这个概念，家长所谓的撒谎只能说是因为做错了事情，怕受到责罚而找一个「台阶」给自己一下而已，所以家长不能给孩子一个贴上撒谎的这个标签，如果说孩子出现家长所说的撒谎，我们应该做的是：1.允许孩子将事情的原委进行一个表达，给孩子说明的机会，不提示孩子说谎，不急著批评孩子。2.不使用问句，不恐吓和严刑逼供，耐心的以故事或者以分析的形式和孩子
  • 06选课支付模块之基于消息队列发送支付通知消息 echo 云清 学成在线javarabbitmq消息队列支付通知学成在线
    消息队列发送支付通知消息需求分析订单服务作为通用服务，在订单支付成功后需要将支付结果异步通知给其他对接的微服务，微服务收到支付结果根据订单的类型去更新自己的业务数据技术方案使用消息队列进行异步通知需要保证消息的可靠性即生产端将消息成功通知到服务端：消息发送到交换机-->由交换机发送到队列-->消费者监听队列，收到消息进行处理，参考文章02-使用Docker安装RabbitMQ-CSDN博客生产者确
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • LeetCode[位运算] - #137 Single Number II Cwind javaAlgorithmLeetCode题解位运算
    原题链接：#137 Single Number II  要求： 给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间   难度：中等   分析： 与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
  • 《JavaScript语言精粹》笔记 aijuans JavaScript
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
  • 你应该更新的Java知识之常用程序库 Kai_Ge java
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 Guava Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
  • HttpClient 120153216 httpclient
    /** * 可以传对象的请求转发，对象已流形式放入HTTP中 */ public static Object doPost(Map<String,Object> parmMap,String url) { Object object = null; HttpClient hc = new HttpClient(); String fullURL
  • Django model字段类型清单 2002wmj django
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段) BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。 Cha
  • 在SQLSERVER中查找消耗CPU最多的SQL 357029540 SQL Server
    返回消耗CPU数目最多的10条语句 SELECT TOP 10    total_worker_time/execution_count AS avg_cpu_cost, plan_handle,    execution_count,    (SELECT SUBSTRING(text, statement_start_of
  • Myeclipse项目无法部署，Undefined exploded archive location 7454103 eclipseMyEclipse
    做个备忘！ 错误信息为：       Undefined exploded archive location 原因：           在工程转移过程中，导致工程的配置文件出错； 解决方法：    
  • GMT时间格式转换 adminjun GMT时间转换
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 1、可以使用 SimpleDateFormat SimpleDateFormat    EEE-三位星期 d-天 MMM-月 yyyy-四位年
  • Oracle数据库新装连接串问题 aijuans oracle数据库
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： Fatal NI connect error 12170.   VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
  • 回顾java数组复制 ayaoxinchao java数组
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
  • java web会话监听并使用spring注入 bewithme Java Web
            在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。        import java.util.ArrayList; import java.ut
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用) bijian1013 redis数据库NoSQL
    一 .Redis常用命令         Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。         a.键值相关命令         b.服务器相关命令 1.键值相关命令       &
  • java枚举序列化问题 bingyingao java枚举序列化
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 1.加一个枚举值 新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 2.删一个枚举值 新机器代码读分布式缓存中老对象，反序列
  • 【Spark七十八】Spark Kyro序列化 bit1129 spark
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 Spark
  • Hybridizing OO and Functional Design bookjovi erlanghaskell
      推荐博文： Tell Above, and Ask Below - Hybridizing OO and Functional Design 文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
  • Java-Collections Framework学习与总结-HashMap BrokenDreams Collections
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。  &nb
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请 * bylijinnan */ abstract class Handler { /*
  • Android中启动外部程序 cherishLC android
    1、启动外部程序 引用自： http://blog.csdn.net/linxcool/article/details/7692374 //方法一 Intent intent=new Intent(); //包名 包名+类名（全路径） intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
  • summary_keep_rate coollyj SUM
    BEGIN /*DECLARE minDate varchar(20) ; DECLARE maxDate varchar(20) ;*/ DECLARE stkDate varchar(20) ; DECLARE done int default -1; /* 游标中 注册服务器地址 */ DE
  • hadoop hdfs 添加数据目录出错 daizj hadoophdfs扩容
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
  • grep 目录级联查找 dongwei_6688 grep
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： grep -n -r "GET" .   上面的命令将会找出当前目录“.”及当前目录中所有下级目录
  • yii 修改模块使用的布局文件 dcj3sjt126com yiilayouts
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如: 'theme'=>'mythm', 那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件； 如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
  • 设计模式之单例模式 come_for_dream 设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。   *********************************
  • 8、数组 豆豆咖啡 二维数组数组一维数组
      一、概念       数组是同一种类型数据的集合。其实数组就是一个容器。   二、好处       可以自动给数组中的元素从0开始编号，方便操作这些元素   三、格式   //一维数组 1,元素类型[] 变量名 = new 元素类型[元素的个数] int[] arr =
  • Decode Ways hcx2013 decode
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 'A' -> 1 'B' -> 2 ... 'Z' -> 26 Given an encoded message containing digits, det
  • Spring4.1新特性——异步调度和事件机制的异常处理 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • squid3(高命中率)缓存服务器配置 liyonghui160com
        系统:centos 5.x   需要的软件:squid-3.0.STABLE25.tar.gz 1.下载squid wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz tar zxf squid-3.0.STABLE25.tar.gz &&
  • 避免Java应用中NullPointerException的技巧和最佳实践 pda158 java
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。 　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 Object unk
  • 如何在Swift语言中创建http请求 shoothao httpswift
    概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。 如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 在这里,我将作出一些建议来回答上述问题。常见的
  • Spring事务的传播方式 uule spring事务
    传播方式：        新建事务       required       required_new   - 挂起当前         非事务方式运行       supports   &nbs
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他