cffishappy
cffishappy

live555学习3（转）

九 h264 RTP传输详解(1)


前几章对Server端的介绍中有个比较重要的问题没有仔细探究：如何打开文件并获得其SDP信息。我们就从这里入手吧。


当RTSPServer收到对某个媒体的DESCRIBE请求时，它会找到对应的ServerMediaSession,调用ServerMediaSession::generateSDPDescription()。generateSDPDescription()中会遍历调用ServerMediaSession中所有的调用ServerMediaSubsession，通过subsession->sdpLines()取得每个Subsession的sdp，合并成一个完整的SDP返回之。
我们几乎可以断定，文件的打开和分析应该是在每个Subsession的sdpLines()函数中完成的，看看这个函数：

[cpp] view plain copy print ?
  1. char const* OnDemandServerMediaSubsession::sdpLines()  
  2. {  
  3.     if (fSDPLines == NULL) {  
  4.         // We need to construct a set of SDP lines that describe this  
  5.         // subsession (as a unicast stream).  To do so, we first create  
  6.         // dummy (unused) source and "RTPSink" objects,  
  7.         // whose parameters we use for the SDP lines:  
  8.         unsigned estBitrate;  
  9.         FramedSource* inputSource = createNewStreamSource(0, estBitrate);  
  10.         if (inputSource == NULL)  
  11.             return NULL; // file not found  
  12.   
  13.         struct in_addr dummyAddr;  
  14.         dummyAddr.s_addr = 0;  
  15.         Groupsock dummyGroupsock(envir(), dummyAddr, 0, 0);  
  16.         unsigned char rtpPayloadType = 96 + trackNumber() - 1; // if dynamic  
  17.         RTPSink* dummyRTPSink = createNewRTPSink(&dummyGroupsock,  
  18.                 rtpPayloadType, inputSource);  
  19.   
  20.         setSDPLinesFromRTPSink(dummyRTPSink, inputSource, estBitrate);  
  21.         Medium::close(dummyRTPSink);  
  22.         closeStreamSource(inputSource);  
  23.     }  
  24.   
  25.     return fSDPLines;  
  26. }  
其所为如是：Subsession中直接保存了对应媒体文件的SDP，但是在第一次获取时fSDPLines为NULL，所以需先获取fSDPLines。其做法比较费事，竟然是建了临时的Source和RTPSink，把它们连接成一个StreamToken，Playing一段时间之后才取得了fSDPLines。createNewStreamSource()和createNewRTPSink()都是虚函数，所以此处创建的source和sink都是继承类指定的，我们分析的是H264，也就是H264VideoFileServerMediaSubsession所指定的，来看一下这两个函数：

[cpp] view plain copy print ?
  1. FramedSource* H264VideoFileServerMediaSubsession::createNewStreamSource(  
  2.         unsigned /*clientSessionId*/,  
  3.         unsigned& estBitrate)  
  4. {  
  5.     estBitrate = 500; // kbps, estimate  
  6.   
  7.     // Create the video source:  
  8.     ByteStreamFileSource* fileSource = ByteStreamFileSource::createNew(envir(),  
  9.             fFileName);  
  10.     if (fileSource == NULL)  
  11.         return NULL;  
  12.     fFileSize = fileSource->fileSize();  
  13.   
  14.     // Create a framer for the Video Elementary Stream:  
  15.     return H264VideoStreamFramer::createNew(envir(), fileSource);  
  16. }  
  17.   
  18. RTPSink* H264VideoFileServerMediaSubsession::createNewRTPSink(  
  19.         Groupsock* rtpGroupsock,  
  20.         unsigned char rtpPayloadTypeIfDynamic,  
  21.         FramedSource* /*inputSource*/)  
  22. {  
  23.     return H264VideoRTPSink::createNew(envir(), rtpGroupsock,  
  24.             rtpPayloadTypeIfDynamic);  
  25. }  
可以看到，分别创建了H264VideoStreamFramer和H264VideoRTPSink。可以肯定H264VideoStreamFramer也是一个Source，但它内部又利用了另一个source--ByteStreamFileSource。后面会分析为什么要这样做，这里先不要管它。还没有看到真正打开文件的代码，继续探索：

[cpp] view plain copy print ?
  1. void OnDemandServerMediaSubsession::setSDPLinesFromRTPSink(  
  2.         RTPSink* rtpSink,  
  3.         FramedSource* inputSource,  
  4.         unsigned estBitrate)  
  5. {  
  6.     if (rtpSink == NULL)  
  7.         return;  
  8.   
  9.     char const* mediaType = rtpSink->sdpMediaType();  
  10.     unsigned char rtpPayloadType = rtpSink->rtpPayloadType();  
  11.     struct in_addr serverAddrForSDP;  
  12.     serverAddrForSDP.s_addr = fServerAddressForSDP;  
  13.     char* const ipAddressStr = strDup(our_inet_ntoa(serverAddrForSDP));  
  14.     char* rtpmapLine = rtpSink->rtpmapLine();  
  15.     char const* rangeLine = rangeSDPLine();  
  16.     char const* auxSDPLine = getAuxSDPLine(rtpSink, inputSource);  
  17.     if (auxSDPLine == NULL)  
  18.         auxSDPLine = "";  
  19.   
  20.     char const* const sdpFmt = "m=%s %u RTP/AVP %d\r\n"  
  21.             "c=IN IP4 %s\r\n"  
  22.             "b=AS:%u\r\n"  
  23.             "%s"  
  24.             "%s"  
  25.             "%s"  
  26.             "a=control:%s\r\n";  
  27.     unsigned sdpFmtSize = strlen(sdpFmt) + strlen(mediaType) + 5 /* max short len */  
  28.     + 3 /* max char len */  
  29.     + strlen(ipAddressStr) + 20 /* max int len */  
  30.     + strlen(rtpmapLine) + strlen(rangeLine) + strlen(auxSDPLine)  
  31.             + strlen(trackId());  
  32.     char* sdpLines = new char[sdpFmtSize];  
  33.     sprintf(sdpLines, sdpFmt, mediaType, // m= <media>  
  34.             fPortNumForSDP, // m= <port>   
  35.             rtpPayloadType, // m= <fmt list>  
  36.             ipAddressStr, // c= address   
  37.             estBitrate, // b=AS:<bandwidth>  
  38.             rtpmapLine, // a=rtpmap:... (if present)  
  39.             rangeLine, // a=range:... (if present)  
  40.             auxSDPLine, // optional extra SDP line  
  41.             trackId()); // a=control:<track-id>  
  42.     delete[] (char*) rangeLine;  
  43.     delete[] rtpmapLine;  
  44.     delete[] ipAddressStr;  
  45.   
  46.     fSDPLines = strDup(sdpLines);  
  47.     delete[] sdpLines;  
  48. }  
此函数中取得Subsession的sdp并保存到fSDPLines。打开文件应在rtpSink->rtpmapLine()甚至是Source创建时已经做了。我们不防先把它放一放，而是先把SDP的获取过程搞个通透。所以把焦点集中到getAuxSDPLine()上。

[cpp] view plain copy print ?
  1. char const* OnDemandServerMediaSubsession::getAuxSDPLine(  
  2.         RTPSink* rtpSink,  
  3.         FramedSource* /*inputSource*/)  
  4. {  
  5.     // Default implementation:  
  6.     return rtpSink == NULL ? NULL : rtpSink->auxSDPLine();  
  7. }  
很简单，调用了rtpSink->auxSDPLine()那么我们要看H264VideoRTPSink::auxSDPLine()：不用看了，很简单，取得source 中保存的PPS,SPS等形成a=fmpt行。但事实上并没有这么简单，H264VideoFileServerMediaSubsession重写了getAuxSDPLine()！如果不重写，则说明auxSDPLine已经在前面分析文件时获得了，那么既然重写，就说明前面没有获取到，只能在这个函数中重写。look　H264VideoFileServerMediaSubsession中这个函数:

[cpp] view plain copy print ?
  1. char const* H264VideoFileServerMediaSubsession::getAuxSDPLine(  
  2.         RTPSink* rtpSink,  
  3.         FramedSource* inputSource)  
  4. {  
  5.     if (fAuxSDPLine != NULL)  
  6.         return fAuxSDPLine; // it's already been set up (for a previous client)  
  7.   
  8.     if (fDummyRTPSink == NULL) { // we're not already setting it up for another, concurrent stream  
  9.         // Note: For H264 video files, the 'config' information ("profile-level-id" and "sprop-parameter-sets") isn't known  
  10.         // until we start reading the file.  This means that "rtpSink"s "auxSDPLine()" will be NULL initially,  
  11.         // and we need to start reading data from our file until this changes.  
  12.         fDummyRTPSink = rtpSink;  
  13.   
  14.         // Start reading the file:   
  15.         fDummyRTPSink->startPlaying(*inputSource, afterPlayingDummy, this);  
  16.   
  17.         // Check whether the sink's 'auxSDPLine()' is ready:  
  18.         checkForAuxSDPLine(this);  
  19.     }  
  20.   
  21.     envir().taskScheduler().doEventLoop(&fDoneFlag);  
  22.   
  23.     return fAuxSDPLine;  
  24. }  
注释里面解释得很清楚，H264不能在文件头中取得PPS/SPS，必须在播放一下后（当然，它是一个原始流文件，没有文件头）才行。也就是说不能从rtpSink中取得了。为了保证在函数退出前能取得AuxSDP，把大循环搬到这里来了。afterPlayingDummy()是在播放结束也就是取得aux sdp之后执行。在大循环之前的checkForAuxSDPLine()做了什么呢？

[cpp] view plain copy print ?
  1. void H264VideoFileServerMediaSubsession::checkForAuxSDPLine1()  
  2. {  
  3.     char const* dasl;  
  4.   
  5.     if (fAuxSDPLine != NULL) {  
  6.         // Signal the event loop that we're done:  
  7.         setDoneFlag();  
  8.     } else if (fDummyRTPSink != NULL  
  9.             && (dasl = fDummyRTPSink->auxSDPLine()) != NULL) {  
  10.         fAuxSDPLine = strDup(dasl);  
  11.         fDummyRTPSink = NULL;  
  12.   
  13.         // Signal the event loop that we're done:  
  14.         setDoneFlag();  
  15.     } else {  
  16.         // try again after a brief delay:   
  17.         int uSecsToDelay = 100000; // 100 ms  
  18.         nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecsToDelay,  
  19.                 (TaskFunc*) checkForAuxSDPLine, this);  
  20.     }  
  21. }  

它检查是否已取得Aux sdp，如果取得了，设置结束标志，直接返回。如果没有，就检查是否sink中已取得了aux sdp，如果是，也设置结束标志，返回。如果还没有取得，则把这个检查函数做为delay task加入计划任务中。每100毫秒检查一次，每检查一次主要就是调用一次fDummyRTPSink->auxSDPLine()。大循环在检测到fDoneFlag改变时停止，此时已取得了aux sdp。但是如果直到文件结束也没有得到aux sdp，则afterPlayingDummy（）被执行，在其中停止掉这个大循环。然后在父Subsession类中关掉这些临时的source和sink。在直正播放时重新创建。

 

 

 

十 h264 RTP传输详解(2)


上一章并没有把打开文件分析文件的代码找到，因为发现它隐藏得比较深，而且H264的Source又有多个，形成了连环计。所以此章中就将文件处理与H264的Source们并在一起分析吧。
从哪里开始呢？从source开始吧!为什么要从它开始呢？我就想从这里开始，行了吧？

[cpp] view plain copy print ?
  1. FramedSource* H264VideoFileServerMediaSubsession::createNewStreamSource(  
  2.         unsigned /*clientSessionId*/,  
  3.         unsigned& estBitrate)  
  4. {  
  5.     estBitrate = 500; // kbps, estimate   
  6.   
  7.     // Create the video source:   
  8.     ByteStreamFileSource* fileSource = ByteStreamFileSource::createNew(envir(),  
  9.             fFileName);  
  10.     if (fileSource == NULL)  
  11.         return NULL;  
  12.     fFileSize = fileSource->fileSize();  
  13.   
  14.     // Create a framer for the Video Elementary Stream:   
  15.     return H264VideoStreamFramer::createNew(envir(), fileSource);  
  16. }  

先创建一个ByteStreamFileSource，显然这是一个从文件按字节读取数据的source，没什么可细说的。但是，打开文件，读写文件操作的确就在其中。最终来处理h264文件，分析其格式，解析出帧或nal的应是这个source: H264VideoStreamFramer。打开文件的地方找到了，但分析文件的代码才是更有价值的。那我们只能来看H264VideoStreamFramer。
H264VideoStreamFramer继承自MPEGVideoStreamFramer，MPEGVideoStreamFramer继承自FramedFilter,FramedFilter继承自FramedSource。
啊，中间又冒出个Filter。看到它，是不是联想到了DirectShow的filter？或者说Photoshop中的filter？它们的意义应该都差不多吧？即插入到source和render(sink)之间的处理媒体数据的东东？如果这样理解，还是更接近于photoshop中的概念。唉，说实话，我估计自己说的也不全对，反正就这样认识吧，谬不了一千里。既然我们这样认识了，那么我们就有理由相信可能会出现多个filter们一个连一个,然后高唱：手牵着脚脚牵着手一起向前走...
H264VideoStreamFramer继承自MPEGVideoStreamFramer，MPEGVideoStreamFramer比较简单，它只是把一些工作交给了MPEGVideoStreamParser（又出来个parser，这可是个新东西哦，先不要管它吧），重点来看一下。
构造函数：

[cpp] view plain copy print ?
  1. H264VideoStreamFramer::H264VideoStreamFramer(UsageEnvironment& env,  
  2.         FramedSource* inputSource,  
  3.         Boolean createParser,  
  4.         Boolean includeStartCodeInOutput)  
  5.         : MPEGVideoStreamFramer(env, inputSource),  
  6.                 fIncludeStartCodeInOutput(includeStartCodeInOutput),  
  7.                 fLastSeenSPS(NULL),  
  8.                 fLastSeenSPSSize(0),  
  9.                 fLastSeenPPS(NULL),  
  10.                 fLastSeenPPSSize(0)  
  11. {  
  12.     fParser = createParser ?  
  13.             new H264VideoStreamParser(this, inputSource,  
  14.                     includeStartCodeInOutput) : NULL;  
  15.     fNextPresentationTime = fPresentationTimeBase;  
  16.     fFrameRate = 25.0; // We assume a frame rate of 25 fps,    
  17.         //unless we learn otherwise (from parsing a Sequence Parameter Set NAL unit)   
  18. }  

由于createParser肯定为真，所以主要内容是创建了H264VideoStreamParser对象（先不管这个parser）。
其它的函数就没什么可看的了，都集中在所保存的PPS与SPS上。看来分析工作移到了H264VideoStreamParser，Parser嘛，就是分析器。分析器的基类是StreamParser。StreamParser做了不少的工作，那我们就先搞明白StreamParser做了哪些工作吧，并且可能为继承者提供什么样的调用框架呢？.....我看完了，呵呵。直接说分析结果吧：
StreamParser的主要工作是实现了对数据以位为单位进行访问。因为在处理媒体格式时，按位分析是很常见的情况。这两个函数skipBits(unsigned　numBits)和unsigned getBits(unsigned numBits)很明显是基于位的操作。unsigned char* fBank[2]这个变量中的两个缓冲区被轮换使用。这个类中保存了一个Source，理所当然地它应该保存ByteStreamFileSource的实例，而不是FramedFilter的。那些getBytes()或getBits()最终会导致读文件的操作。从文件读取一次数据后，StreamParser::afterGettingBytes1（）被调用，StreamParser::afterGettingBytes1（）中做一点简单的工作后便调用fClientContinueFunc这个回调函数。fClientContinueFunc可能指向Frame的函数体也可能是指向RtpSink的函数体－－因为Framer完全可以把RtpSink的函数体传给Parser。至于到底指向哪个，只能在进一步分析之后才得知。

下面再来分析StreamParser的儿子:MPEGVideoStreamParser。

[cpp] view plain copy print ?
  1. MPEGVideoStreamParser::MPEGVideoStreamParser(  
  2.         MPEGVideoStreamFramer* usingSource,  
  3.         FramedSource* inputSource)  
  4.         : StreamParser(inputSource,  
  5.             FramedSource::handleClosure,   
  6.             usingSource,  
  7.             &MPEGVideoStreamFramer::continueReadProcessing,  
  8.             usingSource),  
  9.             fUsingSource(usingSource)  
  10. {  
  11. }  

MPEGVideoStreamParser的构造函数中有很多有意思的东西。
首先参数usingSource是什么意思？表示正在使用这个Parser的Source? inputSource 很明确，就是能获取数据的source，也就是 ByteStreamFileSource。而且很明显的，StreamParser中保存的source是ByteStreamFileSource。从传入给StreamParser的回调函数以及它们的参数可以看出，这些回调函数全是指向的StreamParser的子类的函数（为啥不用虚函数的方式？哦，回调函数全是静态函数，不能成为虚函数）。这说明在每读一次数据后，MPEGVideoStreamFramer::continueReadProcessing()被调用，在其中对帧进行界定和分析，完成后再调用RTPSink的相应函数，RTPSink中对帧进行打包和发送（还记得吗，不记得了请回头看以前的章节）。
MPEGVideoStreamParser的fTo是RTPSink传入的缓冲指针，其saveByte(),save4Bytes()是把数据从StreamParser的缓冲把数据复制到fTo中，是给继承类使用的。saveToNextCode()是复制数据直到遇到一个同步字节串（比如h264中分隔nal的那一陀东东，当然此处的跟h264还不一样），也是给继承类使用的。纯虚函数parse()很明显是留继承类去写帧分析代码的地方。registerReadInterest()被调用者用来告诉MPEGVideoStreamParser其接收帧的缓冲地址与容量。
现在应该来分析一下MPEGVideoStreamFramer，以明确MPEGVideoStreamFramer与MPEGVideoStreamParser是怎样配合的。
MPEGVideoStreamFramer中用到Parser的重要的函数只有两个，一是：

[cpp] view plain copy print ?
  1. void MPEGVideoStreamFramer::doGetNextFrame()  
  2. {  
  3.     fParser->registerReadInterest(fTo, fMaxSize);  
  4.     continueReadProcessing();  
  5. }  

很简单，只是告诉了Parser保存帧的缓冲和缓冲的大小，然后执行continueReadProcessing()，那么来看一下continueReadProcessing()：

[cpp] view plain copy print ?
  1. void MPEGVideoStreamFramer::continueReadProcessing()  
  2. {  
  3.     unsigned acquiredFrameSize = fParser->parse();  
  4.     if (acquiredFrameSize > 0) {  
  5.         // We were able to acquire a frame from the input.   
  6.         // It has already been copied to the reader's space.   
  7.         fFrameSize = acquiredFrameSize;  
  8.         fNumTruncatedBytes = fParser->numTruncatedBytes();  
  9.   
  10.         // "fPresentationTime" should have already been computed.   
  11.   
  12.         // Compute "fDurationInMicroseconds" now:   
  13.         fDurationInMicroseconds =  
  14.                 (fFrameRate == 0.0 || ((int) fPictureCount) < 0) ?  
  15.                         0 : (unsigned) ((fPictureCount * 1000000) / fFrameRate);  
  16.         fPictureCount = 0;  
  17.   
  18.         // Call our own 'after getting' function.  Because we're not a 'leaf'   
  19.         // source, we can call this directly, without risking infinite recursion.   
  20.         afterGetting(this);  
  21.     } else {  
  22.         // We were unable to parse a complete frame from the input, because:   
  23.         // - we had to read more data from the source stream, or   
  24.         // - the source stream has ended.   
  25.     }  
  26. }  

先利用Parser进行分析（应该是解析出一帧吧？），分析完成后，帧数据已到了MPEGVideoStreamFramer的缓冲fTo中。计算出帧的持续时间后，调用FrameSource的afterGetting()，最终会调用RTPSink的函数。
看到这里，可以总结一下，其实看来看去，Parser直正被外部使用的函数几乎只有一个：parse()。

下面可以看H264VideoStreamParser了。其实也很简单，多了一些用于分析h264格式的函数，当然是非公开的，只供自己使用的。在哪里使用呢？当然是在parser()中使用。至于H264VideoStreamFramer前面已经说过了，没什么太多的东西，所以就不看了。总结起来也就是这样：RTPSink向H264VideoStreamFramer要下一帧（其实h264中肯定不是一帧了，而是一个NAL Unit），H264VideoStreamFramer告诉H264VideoStreamParser输出缓冲和容内的字节数，然后调用H264VideoStreamParser的parser()函数，parser()中调用ByteStreamFileSource从文件中读取数据，直到parser()获得完整的一帧，parser()返回，H264VideoStreamFramer进行一些自己的处理后把这一帧返回给了RTPSink（当然是以回调函数的方式返回）。
还有一个东西，H264FUAFragmenter，被H264VideoRTPSink所使用，继承自FramedFilter。它最初在RTPSink开始播放后创建，如下：

[cpp] view plain copy print ?
  1. Boolean H264VideoRTPSink::continuePlaying()  
  2. {  
  3.     // First, check whether we have a 'fragmenter' class set up yet.   
  4.     // If not, create it now:   
  5.     if (fOurFragmenter == NULL) {  
  6.         fOurFragmenter = new H264FUAFragmenter(envir(), fSource,  
  7.                 OutPacketBuffer::maxSize,  
  8.                 ourMaxPacketSize() - 12/*RTP hdr size*/);  
  9.         fSource = fOurFragmenter;  
  10.     }  
  11.   
  12.     // Then call the parent class's implementation:   
  13.     return MultiFramedRTPSink::continuePlaying();  
  14. }  

并且它取代了H264VideoStreamFramer成为直接与RTPSink发生关系的source.如此一来，RTPSink要获取帧时，都是从它获取的．看它最主要的一个函数吧：

[cpp] view plain copy print ?
  1. void H264FUAFragmenter::doGetNextFrame()  
  2. {  
  3.     if (fNumValidDataBytes == 1) {  
  4.         // We have no NAL unit data currently in the buffer.  Read a new one:   
  5.         fInputSource->getNextFrame(&fInputBuffer[1], fInputBufferSize - 1,  
  6.                 afterGettingFrame, this, FramedSource::handleClosure, this);  
  7.     } else {  
  8.         // We have NAL unit data in the buffer.  There are three cases to consider:   
  9.         // 1. There is a new NAL unit in the buffer, and it's small enough to deliver   
  10.         //    to the RTP sink (as is).   
  11.         // 2. There is a new NAL unit in the buffer, but it's too large to deliver to   
  12.         //    the RTP sink in its entirety.  Deliver the first fragment of this data,   
  13.         //    as a FU-A packet, with one extra preceding header byte.   
  14.         // 3. There is a NAL unit in the buffer, and we've already delivered some   
  15.         //    fragment(s) of this.  Deliver the next fragment of this data,   
  16.         //    as a FU-A packet, with two extra preceding header bytes.   
  17.   
  18.         if (fMaxSize < fMaxOutputPacketSize) { // shouldn't happen   
  19.             envir() << "H264FUAFragmenter::doGetNextFrame(): fMaxSize ("  
  20.                     << fMaxSize << ") is smaller than expected\n";  
  21.         } else {  
  22.             fMaxSize = fMaxOutputPacketSize;  
  23.         }  
  24.   
  25.         fLastFragmentCompletedNALUnit = True; // by default   
  26.         if (fCurDataOffset == 1) { // case 1 or 2   
  27.             if (fNumValidDataBytes - 1 <= fMaxSize) { // case 1   
  28.                 memmove(fTo, &fInputBuffer[1], fNumValidDataBytes - 1);  
  29.                 fFrameSize = fNumValidDataBytes - 1;  
  30.                 fCurDataOffset = fNumValidDataBytes;  
  31.             } else { // case 2   
  32.                 // We need to send the NAL unit data as FU-A packets.  Deliver the first   
  33.                 // packet now.  Note that we add FU indicator and FU header bytes to the front   
  34.                 // of the packet (reusing the existing NAL header byte for the FU header).   
  35.                 fInputBuffer[0] = (fInputBuffer[1] & 0xE0) | 28; // FU indicator   
  36.                 fInputBuffer[1] = 0x80 | (fInputBuffer[1] & 0x1F); // FU header (with S bit)   
  37.                 memmove(fTo, fInputBuffer, fMaxSize);  
  38.                 fFrameSize = fMaxSize;  
  39.                 fCurDataOffset += fMaxSize - 1;  
  40.                 fLastFragmentCompletedNALUnit = False;  
  41.             }  
  42.         } else { // case 3   
  43.             // We are sending this NAL unit data as FU-A packets.  We've already sent the   
  44.             // first packet (fragment).  Now, send the next fragment.  Note that we add   
  45.             // FU indicator and FU header bytes to the front.  (We reuse these bytes that   
  46.             // we already sent for the first fragment, but clear the S bit, and add the E   
  47.             // bit if this is the last fragment.)   
  48.             fInputBuffer[fCurDataOffset - 2] = fInputBuffer[0]; // FU indicator   
  49.             fInputBuffer[fCurDataOffset - 1] = fInputBuffer[1] & ~0x80; // FU header (no S bit)   
  50.             unsigned numBytesToSend = 2 + fNumValidDataBytes - fCurDataOffset;  
  51.             if (numBytesToSend > fMaxSize) {  
  52.                 // We can't send all of the remaining data this time:   
  53.                 numBytesToSend = fMaxSize;  
  54.                 fLastFragmentCompletedNALUnit = False;  
  55.             } else {  
  56.                 // This is the last fragment:   
  57.                 fInputBuffer[fCurDataOffset - 1] |= 0x40; // set the E bit in the FU header   
  58.                 fNumTruncatedBytes = fSaveNumTruncatedBytes;  
  59.             }  
  60.             memmove(fTo, &fInputBuffer[fCurDataOffset - 2], numBytesToSend);  
  61.             fFrameSize = numBytesToSend;  
  62.             fCurDataOffset += numBytesToSend - 2;  
  63.         }  
  64.   
  65.         if (fCurDataOffset >= fNumValidDataBytes) {  
  66.             // We're done with this data.  Reset the pointers for receiving new data:   
  67.             fNumValidDataBytes = fCurDataOffset = 1;  
  68.         }  
  69.   
  70.         // Complete delivery to the client:   
  71.         FramedSource::afterGetting(this);  
  72.     }  
  73. }  

如果输入缓冲中没有数据，调用fInputSource->getNextFrame()，fInputSource是H264VideoStreamFramer，H264VideoStreamFramer的getNextFrame()会调用H264VideoStreamParser的parser()，parser()又调用ByteStreamFileSource获取数据，然后分析，parser()完成后会调用：

[cpp] view plain copy print ?
  1. void H264FUAFragmenter::afterGettingFrame1(  
  2.         unsigned frameSize,  
  3.         unsigned numTruncatedBytes,  
  4.         struct timeval presentationTime,  
  5.         unsigned durationInMicroseconds)  
  6. {  
  7.     fNumValidDataBytes += frameSize;  
  8.     fSaveNumTruncatedBytes = numTruncatedBytes;  
  9.     fPresentationTime = presentationTime;  
  10.     fDurationInMicroseconds = durationInMicroseconds;  
  11.   
  12.     // Deliver data to the client:   
  13.     doGetNextFrame();  
  14. }  

然后又调用回H264FUAFragmenter::doGetNextFrame()，此时输入缓冲中有数据了，H264FUAFragmenter就进行分析处理．H264FUAFragmenter又对数据做了什么呢？

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

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • 《策划经理回忆录之二》 路基雅虎
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • swagger访问路径 igotyback swagger
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
  • 30天风格练习-DAY2 黄希夷
    Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 开心 蒋泳频
    从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • 本周第二次约练 2cfbdfe28a51
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
  • 回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录leetcode算法职场和发展
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
  • 今日联对0306 诗图佳得
    自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
  • 每日一题——第八十九题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • 每日一题——第八十四题 互联网打工人no1 C语言程序设计每日一练c语言
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
  • 《小满细雨轻湿尘》 快乐的人ZZM
    图片发自App《小满细雨轻湿尘》文/快乐的人zzm小满细雨轻湿尘石榴花开落纷纷落红不是无情物坠入泥土育养根2018-5-23
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 怎么起诉借钱不还的人？怎样起诉欠款不还的人？ 影子爱学习
    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
  • 辗转相处求最大公约数 沐刃青蛟 C++漏洞
    无言面对”江东父老“了，接触编程一年了，今天发现还不会辗转相除法求最大公约数。惭愧惭愧！   为此，总结一下以方便日后忘了好查找。   1.输入要比较的两个数a,b   忽略：2.比较大小（因为后面要的是大的数对小的数做%操作）   3.辗转相除（用循环不停的取余，如a%b,直至b=0）   4.最后的a为两数的最大公约数 &
  • F5负载均衡会话保持技术及原理技术白皮书 bijian1013 F5负载均衡
    一.什么是会话保持？        在大多数电子商务的应用系统或者需要进行用户身份认证的在线系统中，一个客户与服务器经常经过好几次的交互过程才能完成一笔交易或者是一个请求的完成。由于这几次交互过程是密切相关的，服务器在进行这些交互过程的某一个交互步骤时，往往需要了解上一次交互过程的处理结果，或者上几步的交互过程结果，服务器进行下
  • Object.equals方法：重载还是覆盖 Cwind javagenericsoverrideoverload
    本文译自StackOverflow上对此问题的讨论。 原问题链接   在阅读Joshua Bloch的《Effective Java（第二版）》第8条“覆盖equals时请遵守通用约定”时对如下论述有疑问： “不要将equals声明中的Object对象替换为其他的类型。程序员编写出下面这样的equals方法并不鲜见，这会使程序员花上数个小时都搞不清它为什么不能正常工作：” pu
  • 初始线程 15700786134
          暑假学习的第一课是讲线程，任务是是界面上的一条线运动起来。            既然是在界面上，那必定得先有一个界面，所以第一步就是，自己的类继承JAVA中的JFrame，在新建的类中写一个界面，代码如下： public class ShapeFr
  • Linux的tcpdump 被触发 tcpdump
    用简单的话来定义tcpdump，就是：dump the traffic on a network，根据使用者的定义对网络上的数据包进行截获的包分析工具。 tcpdump可以将网络中传送的数据包的“头”完全截获下来提供分析。它支 持针对网络层、协议、主机、网络或端口的过滤，并提供and、or、not等逻辑语句来帮助你去掉无用的信息。 实用命令实例 默认启动 tcpdump 普通情况下，直
  • 安卓程序listview优化后还是卡顿 肆无忌惮_ ListView
    最近用eclipse开发一个安卓app，listview使用baseadapter，里面有一个ImageView和两个TextView。使用了Holder内部类进行优化了还是很卡顿。后来发现是图片资源的问题。把一张分辨率高的图片放在了drawable-mdpi文件夹下，当我在每个item中显示，他都要进行缩放，导致很卡顿。解决办法是把这个高分辨率图片放到drawable-xxhdpi下。 &nb
  • 扩展easyUI tab控件，添加加载遮罩效果 知了ing jquery
    (function () { $.extend($.fn.tabs.methods, { //显示遮罩 loading: function (jq, msg) { return jq.each(function () { var panel = $(this).tabs(&
  • gradle上传jar到nexus 矮蛋蛋 gradle
    原文地址： https://docs.gradle.org/current/userguide/maven_plugin.html configurations {     deployerJars } dependencies {     deployerJars "org.apache.maven.wagon
  • 千万条数据外网导入数据库的解决方案。 alleni123 sqlmysql
    从某网上爬了数千万的数据，存在文本中。 然后要导入mysql数据库。 悲剧的是数据库和我存数据的服务器不在一个内网里面。。 ping了一下， 19ms的延迟。 于是下面的代码是没用的。 ps = con.prepareStatement(sql); ps.setString(1, info.getYear())............; ps.exec
  • JAVA IO InputStreamReader和OutputStreamReader 百合不是茶 JAVA.io操作 字符流
    这是第三篇关于java.io的文章了，从开始对io的不了解-->熟悉--->模糊，是这几天来对文件操作中最大的感受，本来自己认为的熟悉了的，刚刚在回想起前面学的好像又不是很清晰了，模糊对我现在或许是最好的鼓励 我会更加的去学 加油！： JAVA的API提供了另外一种数据保存途径，使用字符流来保存的，字符流只能保存字符形式的流   字节流和字符的难点：a,怎么将读到的数据
  • MO、MT解读 bijian1013 GSM
    MO= Mobile originate，上行，即用户上发给SP的信息。MT= Mobile Terminate，下行，即SP端下发给用户的信息； 上行:mo提交短信到短信中心下行:mt短信中心向特定的用户转发短信，你的短信是这样的，你所提交的短信，投递的地址是短信中心。短信中心收到你的短信后，存储转发，转发的时候就会根据你填写的接收方号码寻找路由，下发。在彩信领域是一样的道理。下行业务：由SP
  • 五个JavaScript基础问题 bijian1013 JavaScriptcallapplythisHoisting
    下面是五个关于前端相关的基础问题，但却很能体现JavaScript的基本功底。 问题1：Scope作用范围 考虑下面的代码：  (function() { var a = b = 5; })(); console.log(b); 什么会被打印在控制台上？  回答：         上面的代码会打印 5。 &nbs
  • 【Thrift二】Thrift Hello World bit1129 Hello world
    本篇，不考虑细节问题和为什么，先照葫芦画瓢写一个Thrift版本的Hello World，了解Thrift RPC服务开发的基本流程   1. 在Intellij中创建一个Maven模块，加入对Thrift的依赖，同时还要加上slf4j依赖，如果不加slf4j依赖，在后面启动Thrift Server时会报错 <dependency>
  • 【Avro一】Avro入门 bit1129 入门
    本文的目的主要是总结下基于Avro Schema代码生成，然后进行序列化和反序列化开发的基本流程。需要指出的是，Avro并不要求一定得根据Schema文件生成代码，这对于动态类型语言很有用。   1. 添加Maven依赖   <?xml version="1.0" encoding="UTF-8"?> <proj
  • 安装nginx+ngx_lua支持WAF防护功能 ronin47
    需要的软件:LuaJIT-2.0.0.tar.gz                   nginx-1.4.4.tar.gz          &nb
  • java-5.查找最小的K个元素-使用最大堆 bylijinnan java
    import java.util.Arrays; import java.util.Random; public class MinKElement { /** * 5.最小的K个元素 * I would like to use MaxHeap. * using QuickSort is also OK */ public static void
  • TCP的TIME-WAIT bylijinnan socket
    原文连接： http://vincent.bernat.im/en/blog/2014-tcp-time-wait-state-linux.html 以下为对原文的阅读笔记 说明： 主动关闭的一方称为local end，被动关闭的一方称为remote end 本地IP、本地端口、远端IP、远端端口这一“四元组”称为quadruplet，也称为socket 1、TIME_WA
  • jquery ajax 序列化表单 coder_xpf Jquery ajax 序列化
       checkbox 如果不设定值，默认选中值为on；设定值之后，选中则为设定的值   <input type="checkbox" name="favor" id="favor" checked="checked"/> $("#favor&quo
  • Apache集群乱码和最高并发控制 cuisuqiang apachetomcat并发集群乱码
    都知道如果使用Http访问，那么在Connector中增加URIEncoding即可，其实使用AJP时也一样，增加useBodyEncodingForURI和URIEncoding即可。 最大连接数也是一样的，增加maxThreads属性即可，如下，配置如下： <Connector maxThreads="300" port="8019" prot
  • websocket dalan_123 websocket
    一、低延迟的客户端-服务器 和 服务器-客户端的连接 很多时候所谓的http的请求、响应的模式，都是客户端加载一个网页，直到用户在进行下一次点击的时候，什么都不会发生。并且所有的http的通信都是客户端控制的，这时候就需要用户的互动或定期轮训的，以便从服务器端加载新的数据。   通常采用的技术比如推送和comet（使用http长连接、无需安装浏览器安装插件的两种方式：基于ajax的长
  • 菜鸟分析网络执法官 dcj3sjt126com 网络
      最近在论坛上看到很多贴子在讨论网络执法官的问题。菜鸟我正好知道这回事情.人道"人之患好为人师" 手里忍不住,就写点东西吧. 我也很忙.又没有MM,又没有MONEY....晕倒有点跑题. OK,闲话少说,切如正题. 要了解网络执法官的原理. 就要先了解局域网的通信的原理. 前面我们看到了.在以太网上传输的都是具有以太网头的数据包. 
  • Android相对布局属性全集 dcj3sjt126com android
    RelativeLayout布局android:layout_marginTop="25dip" //顶部距离android:gravity="left" //空间布局位置android:layout_marginLeft="15dip //距离左边距 // 相对于给定ID控件android:layout_above 将该控件的底部置于给定ID的
  • Tomcat内存设置详解 eksliang jvmtomcattomcat内存设置
    Java内存溢出详解   一、常见的Java内存溢出有以下三种：   1. java.lang.OutOfMemoryError: Java heap space ----JVM Heap（堆）溢出JVM在启动的时候会自动设置JVM Heap的值，其初始空间(即-Xms)是物理内存的1/64，最大空间(-Xmx)不可超过物理内存。 可以利用JVM提
  • Java6 JVM参数选项 greatwqs javaHotSpotjvmjvm参数JVM Options
    Java 6 JVM参数选项大全（中文版）   作者：Ken Wu Email: [email protected] 转载本文档请注明原文链接 http://kenwublog.com/docs/java6-jvm-options-chinese-edition.htm！   本文是基于最新的SUN官方文档Java SE 6 Hotspot VM Opt
  • weblogic创建JMC i5land weblogicjms
    进入 weblogic控制太 1.创建持久化存储 --Services--Persistant Stores--new--Create FileStores--name随便起--target默认--Directory写入在本机建立的文件夹的路径--ok 2.创建JMS服务器 --Services--Messaging--JMS Servers--new--name随便起--Pers
  • 基于 DHT 网络的磁力链接和BT种子的搜索引擎架构 justjavac DHT
    上周开发了一个磁力链接和 BT 种子的搜索引擎 {Magnet & Torrent}，本文简单介绍一下主要的系统功能和用到的技术。 系统包括几个独立的部分： 使用 Python 的 Scrapy 框架开发的网络爬虫，用来爬取磁力链接和种子； 使用 PHP CI 框架开发的简易网站； 搜索引擎目前直接使用的 MySQL，将来可以考虑使
  • sql添加、删除表中的列 macroli sql
    添加没有默认值：alter table Test add BazaarType char(1) 有默认值的添加列：alter table Test add BazaarType char(1) default(0) 删除没有默认值的列：alter table Test drop COLUMN BazaarType 删除有默认值的列：先删除约束（默认值）alter table Test DRO
  • PHP中二维数组的排序方法 abc123456789cba 排序二维数组PHP
    <?php/*** @package     BugFree* @version     $Id: FunctionsMain.inc.php,v 1.32 2005/09/24 11:38:37 wwccss Exp $*** Sort an two-dimension array by some level
  • hive优化之------控制hive任务中的map数和reduce数 superlxw1234 hivehive优化
    一、    控制hive任务中的map数: 1.    通常情况下，作业会通过input的目录产生一个或者多个map任务。 主要的决定因素有： input的文件总个数，input的文件大小，集群设置的文件块大小(目前为128M, 可在hive中通过set dfs.block.size;命令查看到，该参数不能自定义修改)；2. 
  • Spring Boot 1.2.4 发布 wiselyman spring boot
    Spring Boot 1.2.4已于6.4日发布，repo.spring.io and Maven Central可以下载(推荐使用maven或者gradle构建下载)。   这是一个维护版本，包含了一些修复small number of fixes,建议所有的用户升级。   Spring Boot 1.3的第一个里程碑版本将在几天后发布，包含许多
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他