上一章并没有把打开文件分析文件的代码找到,因为发现它隐藏得比较深,而且H264的Source又有多个,形成了连环计。所以此章中就将文件处理与H264的Source们并在一起分析吧。
从哪里开始呢?从source开始吧!为什么要从它开始呢?我就想从这里开始,行了吧?
1. FramedSource* H264VideoFileServerMediaSubsession::createNewStreamSource(
2. /*clientSessionId*/,
3. unsigned& estBitrate)
4. {
5. // kbps, estimate
6.
7. // Create the video source:
8. ByteStreamFileSource* fileSource = ByteStreamFileSource::createNew(envir(),
9. fFileName);
10. if
11. return
12. fFileSize = fileSource->fileSize();
13.
14. // Create a framer for the Video Elementary Stream:
15. return
16. }
1. FramedSource* H264VideoFileServerMediaSubsession::createNewStreamSource(
2. /*clientSessionId*/,
3. unsigned& estBitrate)
4. {
5. // kbps, estimate
6.
7. // Create the video source:
8. ByteStreamFileSource* fileSource = ByteStreamFileSource::createNew(envir(),
9. fFileName);
10. if
11. return
12. fFileSize = fileSource->fileSize();
13.
14. // Create a framer for the Video Elementary Stream:
15. return
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,这可是个新东西哦,先不要管它吧),重点来看一下。
构造函数:
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. // We assume a frame rate of 25 fps,
17. //unless we learn otherwise (from parsing a Sequence Parameter Set NAL unit)
18. }
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. // 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。
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. }
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的重要的函数只有两个,一是:
1. void
2. {
3. fParser->registerReadInterest(fTo, fMaxSize);
4. continueReadProcessing();
5. }
1. void
2. {
3. fParser->registerReadInterest(fTo, fMaxSize);
4. continueReadProcessing();
5. }
很简单,只是告诉了Parser保存帧的缓冲和缓冲的大小,然后执行continueReadProcessing(),那么来看一下continueReadProcessing():
1. void
2. {
3. unsigned acquiredFrameSize = fParser->parse();
4. if
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. 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. 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. }
1. void
2. {
3. unsigned acquiredFrameSize = fParser->parse();
4. if
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. 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. 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开始播放后创建,如下:
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
6. new
7. OutPacketBuffer::maxSize,
8. /*RTP hdr size*/);
9. fSource = fOurFragmenter;
10. }
11.
12. // Then call the parent class's implementation:
13. return
14. }
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
6. new
7. OutPacketBuffer::maxSize,
8. /*RTP hdr size*/);
9. fSource = fOurFragmenter;
10. }
11.
12. // Then call the parent class's implementation:
13. return
14. }
并且它取代了H264VideoStreamFramer成为直接与RTPSink发生关系的source.如此一来,RTPSink要获取帧时,都是从它获取的.看它最主要的一个函数吧:
1. void
2. {
3. if
4. // We have no NAL unit data currently in the buffer. Read a new one:
5. fInputSource->getNextFrame(&fInputBuffer[1], fInputBufferSize - 1,
6. 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. "H264FUAFragmenter::doGetNextFrame(): fMaxSize ("
20. ") is smaller than expected\n";
21. else
22. fMaxSize = fMaxOutputPacketSize;
23. }
24.
25. // 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. // FU indicator
36. // 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. // FU indicator
49. // FU header (no S bit)
50. unsigned numBytesToSend = 2 + fNumValidDataBytes - fCurDataOffset;
51. if
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. // 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
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. this);
72. }
73. }
1. void
2. {
3. if
4. // We have no NAL unit data currently in the buffer. Read a new one:
5. fInputSource->getNextFrame(&fInputBuffer[1], fInputBufferSize - 1,
6. 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. "H264FUAFragmenter::doGetNextFrame(): fMaxSize ("
20. ") is smaller than expected\n";
21. else
22. fMaxSize = fMaxOutputPacketSize;
23. }
24.
25. // 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. // FU indicator
36. // 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. // FU indicator
49. // FU header (no S bit)
50. unsigned numBytesToSend = 2 + fNumValidDataBytes - fCurDataOffset;
51. if
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. // 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
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. this);
72. }
73. }
如果输入缓冲中没有数据,调用fInputSource->getNextFrame(),fInputSource是H264VideoStreamFramer,H264VideoStreamFramer的getNextFrame()会调用H264VideoStreamParser的parser(),parser()又调用ByteStreamFileSource获取数据,然后分析,parser()完成后会调用:
1. void
2. unsigned frameSize,
3. unsigned numTruncatedBytes,
4. struct
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. }
1. void
2. unsigned frameSize,
3. unsigned numTruncatedBytes,
4. struct
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. }