H264 RTP传输学习2

h264 RTP传输详解(2)

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

[cpp] view plain copy

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. }  

[cpp] view plain copy

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

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. }  

[cpp] view plain copy

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

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. }  

[cpp] view plain copy

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

1. void MPEGVideoStreamFramer::doGetNextFrame()  
2. {  
3.     fParser->registerReadInterest(fTo, fMaxSize);  
4.     continueReadProcessing();  
5. }  

[cpp] view plain copy

1. void MPEGVideoStreamFramer::doGetNextFrame()  
2. {  
3.     fParser->registerReadInterest(fTo, fMaxSize);  
4.     continueReadProcessing();  
5. }  

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

[cpp] view plain copy

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. }  

[cpp] view plain copy

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

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. }  

[cpp] view plain copy

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

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. }  

[cpp] view plain copy

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

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. }  

[cpp] view plain copy

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又对数据做了什么呢？