live555中是如何获取SPS和PPS的

关于这个问题，困扰了很长时间，主要是为了获取这2个东东，设计到的类太多了，首先的理清设计到了哪些类，其次得把这些类的依属关系给理清，下面就让咱们一步一步的来分析:
SPS和PPS的获取是在服务器接受到了Descripute命令后进行的，在看下面的内容之前请大家先看上篇文章: http://www.shouyanwang.org/thread-704-1-1.html


RtspServerMediaSubSession sdpLines:

FramedSource* inputSource = createNewStreamSource(0, estBitrate);
RTPSink* dummyRTPSink= createNewRTPSink(&dummyGroupsock, rtpPayloadType, inputSource);


上面的2个类基本表明了H264这种类型在解析的时候所涉及的类层次:

初步看了下FramedSource和RTPSink的类结构层次,觉得FrameSource于从文件中提取一帧一帧的H264帧有关系，而RTPSink可能与拆包封装为RTP/RTCP 传给服务器有关联。

由此引发的2条主干继承关系如下:

FramedSource* inputSource = createNewStreamSource(0, estBitrate);
引发的继承关系:
H264VideoStreamFramer --- MPEGVideoStreamFamer --- FramedFilter---FramedSource -- Media
因此后面看到inputSoure其实本质上是 H264VideoStreamFramer

RTPSink* dummyRTPSink= createNewRTPSink(&dummyGroupsock, rtpPayloadType, inputSource);
引发的继承关系如下:
H264VideoRTPSink -- VideoRTPSink  --  MultiFramedRTPSink -- RTPSink --- MediaSink
因此后面看到的RTSPink其实本质上是H264VideoRTPSink.

1. char const* H264VideoFileServerMediaSubsession::getAuxSDPLine(RTPSink* rtpSink, FramedSource* inputSource) {
   
2.   if (fAuxSDPLine != NULL) return fAuxSDPLine; // it's already been set up (for a previous client)
   
3. 
   
4.   printf("H264VideoFileServerMediaSubsession getAuxSDPLine\r\n");
   
5. 
   
6.   if (fDummyRTPSink == NULL) { // we're not already setting it up for another, concurrent stream
   
7.     // Note: For H264 video files, the 'config' information ("profile-level-id" and "sprop-parameter-sets") isn't known
   
8.     // until we start reading the file.  This means that "rtpSink"s "auxSDPLine()" will be NULL initially,
   
9.     // and we need to start reading data from our file until this changes.
   
10.     fDummyRTPSink = rtpSink;//加了dummy就代表是引用?
    
11. 
    
12.     // Start reading the file: 在这里的主要目的是为了获取SPS和PPS
    
13.     fDummyRTPSink->startPlaying(*inputSource, afterPlayingDummy, this);//函数的声明在 MediaSink 中完成，如果是H264那么这里的inputSource必然不为NULL

复制代码

fDummyRTPSink-startPlaying 实际调用的是MediaSink的startPlaying:

1. Boolean MediaSink::startPlaying(MediaSource& source,
   
2.                                 afterPlayingFunc* afterFunc,
   
3.                                 void* afterClientData) {
   
4. 
   
5.   printf("MediaSink startPlaying....\r\n");
   
6.   // Make sure we're not already being played:
   
7.   if (fSource != NULL) {//这里是fSource不是source
   
8.     printf("MediaSink is already being played\r\n");
   
9.     envir().setResultMsg("This sink is already being played");
   
10.     return False;
    
11.   }
    
12. 
    
13.   // Make sure our source is compatible: compatible(兼容)
    
14.   if (!sourceIsCompatibleWithUs(source)) {
    
15.     envir().setResultMsg("MediaSink::startPlaying(): source is not compatible!");
    
16.     return False;
    
17.   }
    
18.   fSource = (FramedSource*)&source;
    
19. 
    
20.   fAfterFunc = afterFunc;//MediaSink中定义的函数指针，用于指向H264FileServerMediaSubSession中的函数：afterPlayingDummy
    
21.   fAfterClientData = afterClientData;//实际指向H264FileMediaSubSession
    
22.   return continuePlaying();//调用的是H264的continuePlaying函数
    
23. }

复制代码

这里注意了fSource已经指向了传进来的source，这个 source就是最上面的 H264VideoStreamFramer.

continuePlaying调用的H264VideoRTPSink中得continuePlaying:

1. Boolean H264VideoRTPSink::continuePlaying() {
   
2.   // First, check whether we have a 'fragmenter' class set up yet.
   
3.   // If not, create it now:
   
4.   if (fOurFragmenter == NULL) {
   
5.     printf("H264VideoRTPSink init H264FUAFragmenter\r\n");
   
6. Boolean H264VideoRTPSink::continuePlaying() {

复制代码

在这里需要非常的注意，因此在这里引入了一个新的类H264FUAFramenter，这个类的继承关系如下:

H264FUAFramenter -- FramedFilter -- FrameSource -- MediaSourec

fOurFragmenter = new H264FUAFragmenter(envir(), fSource, OutPacketBuffer::maxSize,//100K

   ourMaxPacketSize() - 12/*RTP hdr size*/);

fSource = fOurFragmenter;//fOurFragmenter 主要用于是RTP的拆包实现


这里格外注意这2行代码，fSource首先参与到fOurFragmenter的初始化，然后改变指向，指向了刚刚创建的fOurFragmenter.

在fOurFragmenter初始化的过程中，其参数 FramedSource* fInputSource;指向了传进来的source，也就是 H264FUAFramenter

为什么在这里重点强调，后面要用到的.


conitnuePlay调用的核心是buildAndSendPacket,,buildAndPackFrame主要涉及到了RFC3984中得RTP封包部分,其调用的核心是:
packFrame();

1. void MultiFramedRTPSink::packFrame() {
   
2.   // Get the next frame.
   
3. 
   
4.   // First, see if we have an overflow frame that was too big for the last pkt
   
5.   if (fOutBuf->haveOverflowData()) {
   
6.           printf("MultiFramedRTPSink packFrame Over flow data---\r\n");
   
7.     // Use this frame before reading a new one from the source
   
8.     unsigned frameSize = fOutBuf->overflowDataSize(); //? fOutBuf的初始化在哪里完成?
   
9.     struct timeval presentationTime = fOutBuf->overflowPresentationTime();
   
10.     unsigned durationInMicroseconds = fOutBuf->overflowDurationInMicroseconds();
    
11.     fOutBuf->useOverflowData();
    
12. 
    
13.     afterGettingFrame1(frameSize, 0, presentationTime, durationInMicroseconds);
    
14.   } else {
    
15.     printf("MultiFrameRTPSink packFrame read a new frame from the source--\r\n");
    
16. 
    
17.     // Normal case: we need to read a new frame from the source
    
18.     if (fSource == NULL) return;
    
19. 
    
20.     fCurFrameSpecificHeaderPosition = fOutBuf->curPacketSize();
    
21.     fCurFrameSpecificHeaderSize = frameSpecificHeaderSize();
    
22.     fOutBuf->skipBytes(fCurFrameSpecificHeaderSize);
    
23.     fTotalFrameSpecificHeaderSizes += fCurFrameSpecificHeaderSize;
    
24. 
    
25. //        printf("MultiFrameRTPSink packFrame curptr:%d,totalBytesAvailable:%d--\r\n",fOutBuf->curPtr(), fOutBuf->totalBytesAvailable());
    
26.     fSource->getNextFrame(fOutBuf->curPtr(), fOutBuf->totalBytesAvailable(),
    
27.                           afterGettingFrame, this, ourHandleClosure, this);//似乎所有的核心都集中到了这里?-----
    
28.   }
    
29. }

复制代码

这个时候fSource-getNextFrame，fSource其实调用的是FrameSource的getNextFrame,因为H264FuaFragmenter并没有实现此方法:

1. void FramedSource::getNextFrame(unsigned char* to, unsigned maxSize,
   
2.                                 afterGettingFunc* afterGettingFunc,
   
3.                                 void* afterGettingClientData,
   
4.                                 onCloseFunc* onCloseFunc,
   
5.                                 void* onCloseClientData) {
   
6. 
   
7.   printf("FrameSource getNextFrame ...\r\n");
   
8.   // Make sure we're not already being read:
   
9.   if (fIsCurrentlyAwaitingData) {
   
10.     envir() << "FramedSource[" << this << "]::getNextFrame(): attempting to read more than once at the same time!\n";
    
11.     envir().internalError();
    
12.   }
    
13. 
    
14.   fTo = to;
    
15.   fMaxSize = maxSize;
    
16.   fNumTruncatedBytes = 0; // by default; could be changed by doGetNextFrame()
    
17.   fDurationInMicroseconds = 0; // by default; could be changed by doGetNextFrame()
    
18.   fAfterGettingFunc = afterGettingFunc;
    
19.   fAfterGettingClientData = afterGettingClientData;
    
20.   fOnCloseFunc = onCloseFunc;
    
21.   fOnCloseClientData = onCloseClientData;
    
22.   fIsCurrentlyAwaitingData = True;
    
23. 
    
24.   //实际调用的是: H264FUAFragmenter::doGetNextFrame()
    
25.   doGetNextFrame();//
    
26. }

复制代码

在上面完成了对FrameSource的成员函数的初始化，主要是函数指针和void*指针,void*指向H264VideoRTPSink，函数指针指向H264VideoRTPSink中得函数.

H264FUAFramenter中得doGetNextFrame

1. void H264FUAFragmenter::doGetNextFrame() {
   
2.   if (fNumValidDataBytes == 1) {
   
3. 
   
4.           //正常情况下应该执行的是这里
   
5.         printf("H264FUAFragmenter doGetNextFrame validDataBytes..\r\n");
   
6.     // We have no NAL unit data currently in the buffer.  Read a new one:
   
7. 
   
8.         //这里的fInputSource实际指的是:H264VideoStreamFramer
   
9.     fInputSource->getNextFrame(&fInputBuffer[1], fInputBufferSize - 1,
   
10.                                afterGettingFrame, this,
    
11.                                FramedSource::handleClosure, this);
    
12.   } else {
    
13. 
    
14.     //对NAL单元进行拆分或者合并发送

复制代码

看到上面的代码没,核心是fInputSource->getNextFrame，fInputSource是 H264VideoFramer类型的，但是H264VideoFramer并没有覆盖此方法，因此最终的执行是在FrameSource的getNextFrame中:

1. void FramedSource::getNextFrame(unsigned char* to, unsigned maxSize,
   
2.                                 afterGettingFunc* afterGettingFunc,
   
3.                                 void* afterGettingClientData,
   
4.                                 onCloseFunc* onCloseFunc,
   
5.                                 void* onCloseClientData) {
   
6. 
   
7.   printf("FrameSource getNextFrame ...\r\n");
   
8.   // Make sure we're not already being read:
   
9.   if (fIsCurrentlyAwaitingData) {
   
10.     envir() << "FramedSource[" << this << "]::getNextFrame(): attempting to read more than once at the same time!\n";
    
11.     envir().internalError();
    
12.   }
    
13. 
    
14.   fTo = to;
    
15.   fMaxSize = maxSize;
    
16.   fNumTruncatedBytes = 0; // by default; could be changed by doGetNextFrame()
    
17.   fDurationInMicroseconds = 0; // by default; could be changed by doGetNextFrame()
    
18.   fAfterGettingFunc = afterGettingFunc;
    
19.   fAfterGettingClientData = afterGettingClientData;
    
20.   fOnCloseFunc = onCloseFunc;
    
21.   fOnCloseClientData = onCloseClientData;
    
22.   fIsCurrentlyAwaitingData = True;
    
23. 
    
24.   //实际调用的是: H264FUAFragmenter::doGetNextFrame() ---(这里理解错误 ,因为这里的FrameSource并不是H264FUAFragmenter对象)
    
25.   doGetNextFrame();// ----这里实际调用的是那个对象的呢?
    
26. }

复制代码

从H264VideoStreamFrame的继承关系可以推敲出，doGetNextFrame其实调用的是其父类MPEGVideoStreamFramer的doGetNextFrame方法.

1. void MPEGVideoStreamFramer::doGetNextFrame() {
   
2.   printf("MPEGVideoStreamFrame doGetNextFrame ....\r\n");
   
3.   fParser->registerReadInterest(fTo, fMaxSize);
   
4.   continueReadProcessing();
   
5. }

复制代码

剩下的明天接着分析，就这么点分析就花了将近1个半钟头........类了，休息下。。。