ainyko
ainyko

testProgs中的OpenRTSP是典型的RTSPClient示例分析

因为要连接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. }  

仔细看看注释，应很容易了解此函数。


原文地址：http://blog.csdn.net/niu_gao/article/details/6927461

live555源代码（VC6）：http://download.csdn.net/detail/leixiaohua1020/6374387

你可能感兴趣的:(session,源代码,ffmpeg,RTSP,视频流)

  • 关于流媒体播放器EasyPlayer和EasyPlayerPro的介绍以及其区别 EasyDarwin EasyDarwin音视频ffmpeg人工智能大数据ar
    EasyPlayer是一款流媒体播放器系列项目，它支持多种流媒体协议的播放，包括但不限于RTSP、RTMP、HTTP、HLS、UDP、RTP、File等。除此之外，EasyPlayer还支持本地文件播放和多种功能特性，包括本地抓拍、本地录像、播放旋转、多屏播放、倍数播放等。EasyPlayer核心基于ffmpeg，稳定、高效、可靠、可控。随着多年的不断发展和迭代，EasyPlayer基于成功的实践
  • EasyPlayer播放器系列开发计划2025 xiejiashu EasyPlayerEasyPlayerEasyPlayer播放器RTSP播放器js播放器Web播放器
    EasyPlayer系列产品发展至今，已经超过10年，从最早的EasyPlayerRTSP播放器，到如今维护的3条线：EasyPlayer-RTSP播放器：Windows、Android、iOS；EasyPlayerPro播放器：Windows、Android、iOS；EasyPlayer.js播放器：H5；这3个播放器各有各的应用场景，用户量也是巨大，像RTSP版本的播放器，到今天依然还有很多低
  • Matrix-Breakout 2 Morpheus靶场解题过程
    信息收集目标探测靶机目标很明显就是61.139.2.141了扫描开放端口发现22、80、81访问端口主机访问80翻译一下，并没有发现什么审查源代码发现里面有一张图片，下载下来看看是否有图片的隐写wgethttp://61.139.2.141/trinity.jpegstegoveritas-itrinity.jpeg-o/home/kali/Desktop/11分解后发现什么都没有，里面的keep
  • Redis + Caffeine 实现高效的两级缓存架构 周童學 Java缓存redis架构
    Redis+Caffeine实现高效的两级缓存架构引言在现代高并发系统中，缓存是提升系统性能的关键组件之一。传统的单一缓存方案往往难以同时满足高性能和高可用性的需求。本文将介绍如何结合Redis和Caffeine构建一个高效的两级缓存系统，并通过三个版本的演进展示如何逐步优化代码结构。项目源代码：github地址、gitee地址两级缓存架构概述两级缓存通常由本地缓存（如Caffeine）和分布式缓
  • 大学社团管理系统（11831） codercode2022 javaspringbootspringechartsspringcloudsentineljava-rocketmq
    有需要的同学，源代码和配套文档领取，加文章最下方的名片哦一、项目演示项目演示视频二、资料介绍完整源代码（前后端源代码+SQL脚本）配套文档（LW+PPT+开题报告）远程调试控屏包运行三、技术介绍Java语言SSM框架SpringBoot框架Vue框架JSP页面Mysql数据库IDEA/Eclipse开发四、项目截图有需要的同学，源代码和配套文档领取，加文章最下方的名片哦!
  • 如何在 Ubuntu 24.04 或 22.04 Linux 上安装和使用 NoMachine 山岚的运维笔记 Linux运维及使用linuxubuntu运维nomachine远程连接
    NoMachine是一款适用于Linux（Ubuntu）及其他支持的操作系统的远程桌面应用程序，允许用户通过本地或远程系统从世界任何地方控制计算机。它可以在低带宽连接下工作，被专业人士和家庭用户广泛使用。NoMachine的主要功能高性能远程访问跨平台兼容性易于使用，因为用户界面友好提供强大的加密协议，如SSH、SSL及其他安全标准支持远程文件传输和打印服务允许从远程计算机进行音频和视频流媒体传输
  • 构建高性能Web应用：深入Spring WebFlux 李多田
    本文还有配套的精品资源，点击获取简介：SpringWebFlux是Spring框架的一部分，支持反应式编程模型，适合高并发和低延迟Web应用。它提供了非阻塞I/O和事件驱动模型，优化了多核处理器资源的使用。SpringWebFlux拥有两种编程模式，核心组件包括WebHandler,RouterFunction,WebFilter,和WebSession。它与高性能服务器集成，并提供反应式HTTP
  • window显示驱动开发—Direct3D 11 视频设备驱动程序接口 (DDI) 程序员王马 windows图形显示驱动开发音视频
    这些设备驱动程序接口(DDI)是新的或针对Windows8更新的：CalcPrivateCryptoSessionSizeCalcPrivateAuthenticatedChannelSizeCalcPrivateVideoDecoderOutputViewSizeCalcPrivateVideoDecoderSizeCalcPrivateVideoProcessorEnumSizeCalcPri
  • Python 中的 JWT 认证：从生成到验证的完整指南 盛夏绽放 python开发语言有问必答后端
    文章目录Python中的JWT认证：从生成到验证的完整指南一、JWT是什么？为什么需要它？传统session与JWT对比二、JWT的结构解析三、Python中实现JWT1.安装PyJWT包2.生成JWT3.验证JWT4.错误处理大全四、高级应用场景1.双令牌系统（Access+Refresh）详细说明表格：异常处理补充表：2.与FastAPI/Django集成五、安全最佳实践六、性能优化技巧算法性
  • 掌握SQL注入：漏洞演示与防护策略实战源代码 May Wei
    本文还有配套的精品资源，点击获取简介：SQL注入是一个影响Web应用和数据库安全的漏洞。通过本项目源代码演示，开发者能深入理解SQL注入的工作机制及其攻击方法。文档和源代码示例将指导如何通过构造恶意SQL语句执行非授权数据库操作，以及如何通过实践学习防止此类攻击，包括安全编码、输入验证、错误处理、数据库权限设置和日志监控等。1.SQL注入概念和攻击方法1.1SQL注入漏洞的基本原理1.1.1SQL
  • 网络安全第14集 不灭锦鲤 web安全安全
    前言：小迪安全14集，这集重点内容：0、什么是js渗透测试？在javascript中也存在变量和函数，存在可控变量和函数就有可能存在在漏洞，js开发的web应用和php、java开发的区别是，js能看得到的源代码，php看不到，但是风险就是未授权访问、配置信息泄露（加密算法、key秘钥等），源代码看得到，存在更多的url泄露，从而可能会出现未授权访问，从url，前提：web应用可以采用前端语言或后
  • 音视频面试题集锦第 1 期 关键帧-Keyframe 音视频面试题集锦音视频面试
    想要学习和提升音视频技术的朋友，快来加入我们的【音视频技术社群】，加入后你就能：1）下载30+个开箱即用的「音视频及渲染Demo源代码」2）下载包含500+知识条目的完整版「音视频知识图谱」3）下载包含200+题目的完整版「音视频面试题集锦」4）技术和职业发展咨询100%得到回答5）获得简历优化建议和大厂内推现在加入，送你一张20元优惠券：点击领取优惠券前些时间，我在知识星球上创建了一个音视频技术
  • ubuntu之坑（十四）——安装FFmpeg进行本地视频推流（在海思平台上运行） 光电的一只菜鸡 linux虚拟机ubuntuffmpeg音视频
    1.编译x264（没有x264依赖项参考，有则跳过）  参考blog：ubuntu22.04下编译ffmpeg-6.0,并且激活x264编码功能。记录一下踩坑（ERROR:x264notfoundusingpkg-config）需要注意：sudo./configure--enable-static--prefix=/usr/local/x264  在执行上面命令时可能遇到下面问题，这是在Linux
  • 代码审计与web安全选择题1 m0_74726609 代码审计网络安全
    软件供应链安全的基础是（）A.完善的需求分析B.源代码安全C.渗透测试D.软件测试参考答案：B保证源代码安全的主要措施包括（）A.开发工具和环境的安全B.代码安全C.渗透测试D.代码审计E.软件的说明文档完整参考答案：ABCD通过（）技术，实现源代码在终端、网络及服务器存储场景下全周期的安全管理，防止内部代码有意、无意泄露、扩散出去。A.数据加B.数据脱C.数据安全隔离D.防火墙参考答案：C软件供
  • 解决：FFmpeg推流时报错：Broken Pipe -米兰的小铁匠 ffmpegpython
    最初利用如下代码进行FFmpeg推流：importsubprocessimportcv2importnumpyasnpimporttimeclassRTMPStreamer:def__init__(self,rtmp_url,width,height,fps=30):self.rtmp_url=rtmp_urlself.width=widthself.height=heightself.fps=f
  • 【免费下载】 探索PlantVillage-Dataset：深度学习在植物病害检测中的革命性突破
    探索PlantVillage-Dataset：深度学习在植物病害检测中的革命性突破在这个数字化时代，人工智能正逐步改变我们的生活，其中深度学习在农业领域的应用尤其引人注目。PlantVillage-Dataset是一个开放源代码的项目，它提供了一个庞大的植物病害识别数据集，旨在帮助开发人员和研究者利用机器学习技术改善农作物健康状况的监测。本文将深入探讨该项目的技术细节、应用价值及其独特之处。项目简
  • [python][flask]flask中session管理 awonw pythonpythonflask开发语言
    在Flask中，session是一个用于在客户端和服务器之间存储数据的机制。它允许你在多个请求之间保持数据的状态。session数据存储在客户端的Cookie中，但数据会经过加密，因此用户无法篡改数据内容。以下是关于Flask中session管理的详细说明和使用方法。1.启用session在Flask中，session默认是启用的，但需要设置一个密钥（SECRET_KEY），用于加密存储在客户端的
  • 深入理解作用域【JavaScript】 陆仟 Web前端开发javascript
    一、作用域的内部原理JavaScript的作用域机制是理解变量如何被访问和存储的重要概念。下面详细介绍作用域的内部原理，包括编译、执行、查询、嵌套和异常处理这五个步骤。1.编译在JavaScript的执行过程中，首要的步骤是编译。尽管JavaScript是解释性语言，但现代JavaScript引擎（如V8）在执行代码前会先进行编译。编译阶段主要完成以下几项工作：词法分析：将源代码分解成语法单元（t
  • 音视频流媒体开发【七十四】- WebRTC1-WebRTC入门 AlanGe
    音视频流媒体开发-目录iOS知识点-目录Android-目录Flutter-目录数据结构与算法-目录uni-pp-目录1WebRTC入门1.1什么是WebRTCWebRTC（WebRealTimeCommunication）是Google于2010以6829万美元从GlobalIPSolutions公司购买，并于2011年将其开源，旨在建立一个互联网浏览器间的实时通信的平台，让WebRTC技术成为
  • ByteBuf 码农崛起
    jdk自带ByteBuffer，看名字就知道作用差不多，区别是ByteBuffer读写都用一个指针，ByteBuf读写各有一个指针。都分为基于javaheap的headbuffer和基于DirectBuffer的buffer。DirectBuffer是不能被gc的，用完需要手动释放，虽然麻烦但是效率高，看吧，谁都有优点和缺点。加上一大堆看名字就知道干嘛的方法。ByteBuf是个抽象类，源代码里的文
  • 使用ffmpeg转码h265后mac默认播放器不支持问题 Auspemak-Derafru macosffmpeg
    由于mac自带录屏是mov并且文件特别大，我使用ffmpeg转码视频为h265使用如下命令ffmpeg_command=[ffmpeg_path,"-i",input_path,"-c:v","libx265","-preset","veryslow","-map_metadata","0",#保留元数据output_path]点开转码完的文件后，出现如下报错。continue进入后，发现音频正常
  • FFmpeg4.0.2 over版本av_register_all()流程(二十九) Android系统攻城狮 FFmpeg实战系列
    1.ffmpeg3.4.8中av_register_all()流程..ffmpeg-3.4.8/libavformat/allformats.cvoidav_register_all(void){staticAVOncecontrol=AV_ONCE_INIT;ff_thread_once(&control,register_all);}staticvoidregister_all(void){a
  • 音视频流媒体开发【七十二】- RTSP流媒体7-SDP协议分析 AlanGe
    音视频流媒体开发-目录iOS知识点-目录Android-目录Flutter-目录数据结构与算法-目录uni-pp-目录SDP（SessionDescriptionProtocol）完全是⼀种会话描述格式―它不属于传输协议―它只使⽤不同的适当的传输协议，包括会话通知协议（SAP）、会话初始协议（SIP）、实时流协议（RTSP）、MIME扩展协议的电⼦邮件以及超⽂本传输协议（HTTP）。SDP协议是也
  • Vue 浏览器本地存储 yume_sibai vue.jsjavascriptecmascript
    一、webStorage1.存储内容大小一般支持5MB左右（不同浏览器可能不一样）。2.浏览器通过Window.sessionStorage和Window.localStorage属性来实现本地存储机制。3.相关API:(1).xxxxStorage.setItem('Key','value')：该方法接受一个键和值作为参数，会把键值对添加到存储中，如果键名存在，则更新其对应的值。(2).xxxx
  • 随笔录-1 知与行！实践是掌握知识的唯一方法 随笔-专栏音视频
    1：阅读源码：源码面前，了无困难。通过选中函数转到定义如：FFmpeg的源码=结构体+函数结构体是内部参数函数是括号内的参数：自动显示+转到定义显示PS：以后绝不买盗版书，质量太差2：把数学学好教宝宝3：需要提前学好的：DS学好------>>>>>>再刷LCQT学好------>>>>>>做夏的项目4：熟练掌握FFmpeg的一些功能函数YUVMP4RGBMP4H264MP45：开始学习FFmpe
  • 跨境电商独立站建站 计算机驯养 跨境电商教育电商
    独立站是什么？独立站的本质就是网站，网站由建站程序，域名，服务器组成。独立站是网站的一种别称通常在行业里是指能够独立运营的商城网站（销售，购物，下单支付等在网站就能完成），用于区别网站的用途（例如：博客网站、展示官网等本质都是网站但它们有不同的业务需求）。开源系统建站是指什么？开源系统建站是指通过开源协议公开源码的系统进行建站，基于开源协议的内容可自由修改源代码开发应用功能等。基本上只要你技术强大
  • dll 动态库编程 | C++名称改编、标准C接口、extern “C”、函数调用约定以及def文件详解 dvlinker C/C++软件开发从入门到实战动态库编程C++名称改编标准C接口extern“C”函数调用约定def文件
    目录1、导入导出声明2、C++函数名称改编与extern"C"3、函数调用约定与跨语言调用3.1、函数调用约定3.2、跨语言调用dll库接口3.3、函数调用约定以哪个为准4、def文件的使用5、在C++程序中引用ffmpeg库中的头文件链接报错问题6、最后VC++常用功能开发汇总（专栏文章列表，欢迎订阅，持续更新...）https://blog.csdn.net/chenlycly/article
  • JAVA大文件分片上传示例，断点续传思路
    包教会，免费教学，提供免费技术支持，免费电话支持，免费远程协助，免费微信支持，免费QQ支持，免费代码编写，免费业务逻辑功能开发，完全开放产品源代码，这些代码包括前端，后端，控件源代码，也就是说能够满足企业100%自主可控需求。我们公司完全能够自主编译，自主发布，自主部署。并且不限用户，支持信创国产化环境。对于企业，完全开放产品源代码，包括前端，后端，控件源代码，控件源代码支持自主编译，自主打包，自
  • iOS渠道跟踪 3中方案的利弊（干货） 邂逅阳光
    总的来说有三种方案（1、2点算一条）1、使用SFSafariViewController来获取safari内的cookie，后来发现ios11之后是获取不到的，这一方案只适用于（ios9~ios11以下）2、ios11之后SFAuthenticationSession代替了SFSafariViewController共享cookie，但SFAuthenticationSession是OC语言的一个
  • 基于YOLOv5+pyQT6的目标检测系统通用项目模板
    本项目开发基于YOLOv5+pyQT6的目标检测项目，用来集成YOLO的目标检测系统，作为该类系统的开发模板，旨在通过替换模型文件即可进行照片、视频、摄像视频流的检测，设置日志系统，记录系统的每一步操作，并集成其他功能作为该模板的辅助功能。具体效果如下：yolo目标检测系统模板1.概述智能目标检测系统V2.1是一款基于PyQt6和YOLOv5模型开发的桌面应用程序。它提供了一个现代化、直观且功能丰
  • ASM系列五 利用TreeApi 解析生成Class lijingyao8206 ASM字节码动态生成ClassNodeTreeAPI
       前面CoreApi的介绍部分基本涵盖了ASMCore包下面的主要API及功能，其中还有一部分关于MetaData的解析和生成就不再赘述。这篇开始介绍ASM另一部分主要的Api。TreeApi。这一部分源码是关联的asm-tree-5.0.4的版本。          在介绍前，先要知道一点， Tree工程的接口基本可以完
  • 链表树——复合数据结构应用实例 bardo 数据结构树型结构表结构设计链表菜单排序
    我们清楚：数据库设计中，表结构设计的好坏，直接影响程序的复杂度。所以，本文就无限级分类（目录）树与链表的复合在表设计中的应用进行探讨。当然，什么是树，什么是链表，这里不作介绍。有兴趣可以去看相关的教材。 需求简介： 经常遇到这样的需求，我们希望能将保存在数据库中的树结构能够按确定的顺序读出来。比如，多级菜单、组织结构、商品分类。更具体的，我们希望某个二级菜单在这一级别中就是第一个。虽然它是最后
  • 为啥要用位运算代替取模呢 chenchao051 位运算哈希汇编
        在hash中查找key的时候，经常会发现用&取代%，先看两段代码吧，     JDK6中的HashMap中的indexFor方法： /** * Returns index for hash code h. */ static int indexFor(int h, int length) {
  • 最近的情况 麦田的设计者 生活感悟计划软考想
          今天是2015年4月27号      整理一下最近的思绪以及要完成的任务             1、最近在驾校科目二练车，每周四天，练三周。其实做什么都要用心，追求合理的途径解决。为
  • PHP去掉字符串中最后一个字符的方法 IT独行者 PHP字符串
    今天在PHP项目开发中遇到一个需求，去掉字符串中的最后一个字符 原字符串1,2,3,4,5,6, 去掉最后一个字符","，最终结果为1,2,3,4,5,6 代码如下： $str = "1,2,3,4,5,6,"; $newstr = substr($str,0,strlen($str)-1); echo $newstr;
  • hadoop在linux上单机安装过程 _wy_ linuxhadoop
    1、安装JDK     jdk版本最好是1.6以上，可以使用执行命令java -version查看当前JAVA版本号，如果报命令不存在或版本比较低，则需要安装一个高版本的JDK，并在/etc/profile的文件末尾，根据本机JDK实际的安装位置加上以下几行：    export JAVA_HOME=/usr/java/jdk1.7.0_25  
  • JAVA进阶----分布式事务的一种简单处理方法 无量 多系统交互分布式事务
    每个方法都是原子操作： 提供第三方服务的系统，要同时提供执行方法和对应的回滚方法 A系统调用B,C,D系统完成分布式事务 =========执行开始======== A.aa(); try { B.bb(); } catch(Exception e) { A.rollbackAa(); } try { C.cc(); } catch(Excep
  • 安墨移动广 告：移动DSP厚积薄发 引领未来广 告业发展命脉 矮蛋蛋 hadoop互联网
    　　“谁掌握了强大的DSP技术，谁将引领未来的广 告行业发展命脉。”2014年，移动广 告行业的热点非移动DSP莫属。各个圈子都在纷纷谈论，认为移动DSP是行业突破点，一时间许多移动广 告联盟风起云涌，竞相推出专属移动DSP产品。 　　到底什么是移动DSP呢? 　　DSP(Demand-SidePlatform)，就是需求方平台，为解决广 告主投放的各种需求，真正实现人群定位的精准广
  • myelipse设置 alafqq IP
      在一个项目的完整的生命周期中，其维护费用，往往是其开发费用的数倍。因此项目的可维护性、可复用性是衡量一个项目好坏的关键。而注释则是可维护性中必不可少的一环。 注释模板导入步骤  安装方法： 打开eclipse/myeclipse 选择 window-->Preferences-->JAVA-->Code-->Code
  • java数组 百合不是茶 java数组
    java数组的   声明  创建  初始化；   java支持C语言      数组中的每个数都有唯一的一个下标 一维数组的定义 声明： int[] a = new int[3];声明数组中有三个数int[3] int[] a 中有三个数，下标从0开始，可以同过for来遍历数组中的数
  • javascript读取表单数据 bijian1013 JavaScript
    利用javascript读取表单数据，可以利用以下三种方法获取： 1、通过表单ID属性：var a = document.getElementByIdx_x_x("id"); 2、通过表单名称属性：var b = document.getElementsByName("name"); 3、直接通过表单名字获取：var c = form.content.
  • 探索JUnit4扩展：使用Theory bijian1013 javaJUnitTheory
    理论机制（Theory） 一.为什么要引用理论机制（Theory）         当今软件开发中，测试驱动开发（TDD — Test-driven development）越发流行。为什么 TDD 会如此流行呢？因为它确实拥有很多优点，它允许开发人员通过简单的例子来指定和表明他们代码的行为意图。 TDD 的优点：     &nb
  • [Spring Data Mongo一]Spring Mongo Template操作MongoDB bit1129 template
    什么是Spring Data Mongo Spring Data MongoDB项目对访问MongoDB的Java客户端API进行了封装，这种封装类似于Spring封装Hibernate和JDBC而提供的HibernateTemplate和JDBCTemplate，主要能力包括 1. 封装客户端跟MongoDB的链接管理 2. 文档-对象映射，通过注解:@Document(collectio
  • 【Kafka八】Zookeeper上关于Kafka的配置信息 bit1129 zookeeper
    问题： 1. Kafka的哪些信息记录在Zookeeper中 2. Consumer Group消费的每个Partition的Offset信息存放在什么位置 3. Topic的每个Partition存放在哪个Broker上的信息存放在哪里 4. Producer跟Zookeeper究竟有没有关系？没有关系！！！   //consumers、config、brokers、cont
  • java OOM内存异常的四种类型及异常与解决方案 ronin47 java OOM 内存异常
          　OOM异常的四种类型： 　　　 　　一：　StackOverflowError ：通常因为递归函数引起（死递归，递归太深）。-Xss 128k 一般够用。     　  二：　out Of memory: PermGen Space：通常是动态类大多，比如web 服务器自动更新部署时引起。-Xmx
  • java-实现链表反转-递归和非递归实现 bylijinnan java
    20120422更新： 对链表中部分节点进行反转操作，这些节点相隔k个： 0->1->2->3->4->5->6->7->8->9 k=2 8->1->6->3->4->5->2->7->0->9 注意1 3 5 7 9 位置是不变的。 解法： 将链表拆成两部分： a.0-&
  • Netty源码学习-DelimiterBasedFrameDecoder bylijinnan javanetty
    看DelimiterBasedFrameDecoder的API，有举例： 接收到的ChannelBuffer如下： +--------------+ | ABC\nDEF\r\n | +--------------+ 经过DelimiterBasedFrameDecoder(Delimiters.lineDelimiter())之后，得到： +-----+----
  • linux的一些命令 -查看cc攻击-网口ip统计等 hotsunshine linux
    Linux判断CC攻击命令详解 2011年12月23日 ⁄ 安全 ⁄ 暂无评论 查看所有80端口的连接数 netstat -nat|grep -i '80'|wc -l 对连接的IP按连接数量进行排序 netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -n 查看TCP连接状态 n
  • Spring获取SessionFactory ctrain sessionFactory
    String sql = "select sysdate from dual"; WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext(); String[] names = wac.getBeanDefinitionNames(); for(int i=0; i&
  • Hive几种导出数据方式 daizj hive数据导出
    Hive几种导出数据方式   1.拷贝文件   如果数据文件恰好是用户需要的格式，那么只需要拷贝文件或文件夹就可以。 hadoop fs –cp source_path target_path   2.导出到本地文件系统   --不能使用insert into local directory来导出数据，会报错 --只能使用
  • 编程之美 dcj3sjt126com 编程PHP重构
    我个人的 PHP 编程经验中，递归调用常常与静态变量使用。静态变量的含义可以参考 PHP 手册。希望下面的代码，会更有利于对递归以及静态变量的理解   header("Content-type: text/plain"); function static_function () { static $i = 0; if ($i++ < 1
  • Android保存用户名和密码 dcj3sjt126com android
    转自：http://www.2cto.com/kf/201401/272336.html 我们不管在开发一个项目或者使用别人的项目，都有用户登录功能，为了让用户的体验效果更好，我们通常会做一个功能，叫做保存用户，这样做的目地就是为了让用户下一次再使用该程序不会重新输入用户名和密码，这里我使用3种方式来存储用户名和密码 1、通过普通 的txt文本存储 2、通过properties属性文件进行存
  • Oracle 复习笔记之同义词 eksliang Oracle 同义词Oracle synonym
    转载请出自出处：http://eksliang.iteye.com/blog/2098861 1.什么是同义词       同义词是现有模式对象的一个别名。       概念性的东西，什么是模式呢？创建一个用户，就相应的创建了 一个模式。模式是指数据库对象，是对用户所创建的数据对象的总称。模式对象包括表、视图、索引、同义词、序列、过
  • Ajax案例 gongmeitao Ajaxjsp
    数据库采用Sql Server2005 项目名称为:Ajax_Demo 1.com.demo.conn包 package com.demo.conn; import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException; //获取数据库连接的类public class DBConnec
  • ASP.NET中Request.RawUrl、Request.Url的区别 hvt .netWebC#asp.nethovertree
      如果访问的地址是：http://h.keleyi.com/guestbook/addmessage.aspx?key=hovertree%3C&n=myslider#zonemenu那么Request.Url.ToString() 的值是：http://h.keleyi.com/guestbook/addmessage.aspx?key=hovertree<&
  • SVG 教程 （七）SVG 实例，SVG 参考手册 天梯梦 svg
    SVG 实例 在线实例 下面的例子是把SVG代码直接嵌入到HTML代码中。 谷歌Chrome，火狐，Internet Explorer9，和Safari都支持。 注意：下面的例子将不会在Opera运行，即使Opera支持SVG - 它也不支持SVG在HTML代码中直接使用。   SVG 实例 SVG基本形状 一个圆 矩形 不透明矩形 一个矩形不透明2 一个带圆角矩
  • 事务管理 luyulong javaspring编程事务
    事物管理 spring事物的好处 为不同的事物API提供了一致的编程模型 支持声明式事务管理 提供比大多数事务API更简单更易于使用的编程式事务管理API 整合spring的各种数据访问抽象 TransactionDefinition 定义了事务策略 int getIsolationLevel()得到当前事务的隔离级别 READ_COMMITTED 
  • 基础数据结构和算法十一：Red-black binary search tree sunwinner AlgorithmRed-black
      The insertion algorithm for 2-3 trees just described is not difficult to understand; now, we will see that it is also not difficult to implement. We will consider a simple representation known
  • centos同步时间 stunizhengjia linux集群同步时间
    做了集群，时间的同步就显得非常必要了。 以下是查到的如何做时间同步。 在CentOS 5不再区分客户端和服务器，只要配置了NTP，它就会提供NTP服务。 1)确认已经ntp程序包： # yum install ntp 2)配置时间源（默认就行，不需要修改） # vi /etc/ntp.conf server pool.ntp.o
  • ITeye 9月技术图书有奖试读获奖名单公布 ITeye管理员 ITeye
    ITeye携手博文视点举办的9月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 9月试读活动回顾：http://webmaster.iteye.com/blog/2118112本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）：      《NFC：Arduino、Andro
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他