庖丁解牛-----Live555源码彻底解密(RTP打包)

 本文主要讲解live555的服务端RTP打包流程,根据MediaServer讲解RTP的打包流程，所以大家看这篇文章时，先看看下面这个链接的内容;

庖丁解牛-----Live555源码彻底解密(根据MediaServer讲解Rtsp的建立过程)

http://blog.csdn.net/smilestone_322/article/details/18923139

在收到客户端的Play命令后，调用StartStream函数启动流

void OnDemandServerMediaSubsession::startStream(unsigned clientSessionId,

                            void* streamToken,

                            TaskFunc* rtcpRRHandler,

                            void* rtcpRRHandlerClientData,

                            unsignedshort& rtpSeqNum,

                            unsigned& rtpTimestamp,

                            ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,

                            void* serverRequestAlternativeByteHandlerClientData) {

  StreamState* streamState = (StreamState*)streamToken;

  Destinations* destinations

    = (Destinations*)(fDestinationsHashTable->Lookup((charconst*)clientSessionId));

  if (streamState != NULL) {

    //启动流

    streamState->startPlaying(destinations,

                    rtcpRRHandler, rtcpRRHandlerClientData,

                    serverRequestAlternativeByteHandler, serverRequestAlternativeByteHandlerClientData);

    RTPSink* rtpSink = streamState->rtpSink(); // alias

if (rtpSink != NULL) {

 //获取序列号与时间戳

      rtpSeqNum = rtpSink->currentSeqNo();

      rtpTimestamp = rtpSink->presetNextTimestamp();

    }

  }

}

 

接着跟踪streamState类中的startPlaying函数;源码如下：

void StreamState

::startPlaying(Destinations* dests,

            TaskFunc* rtcpRRHandler, void* rtcpRRHandlerClientData,

            ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,

            void* serverRequestAlternativeByteHandlerClientData) {

  if (dests == NULL) return;

 

  if (fRTCPInstance == NULL && fRTPSink != NULL) {

// Create (and start) a 'RTCP instance' for this RTP sink:

//用来发送RTCP数据包

    fRTCPInstance

      = RTCPInstance::createNew(fRTPSink->envir(), fRTCPgs,

                   fTotalBW, (unsignedchar*)fMaster.fCNAME,

                   fRTPSink, NULL /* we're a server */);

        // Note: This starts RTCP running automatically

  }

 

  if (dests->isTCP) {

// Change RTP and RTCP to use the TCP socket instead of UDP:

//使用TCP Socket代替UDP socket，使用什么socket由客户端确定，客户端在Setup时，将socket的连接方式告诉服务端；

 

    if (fRTPSink != NULL) {

      fRTPSink->addStreamSocket(dests->tcpSocketNum, dests->rtpChannelId);

      RTPInterface

     ::setServerRequestAlternativeByteHandler(fRTPSink->envir(), dests->tcpSocketNum,

                             serverRequestAlternativeByteHandler, serverRequestAlternativeByteHandlerClientData);

        // So that we continue to handle RTSP commands from the client

    }

    if (fRTCPInstance != NULL) {

      fRTCPInstance->addStreamSocket(dests->tcpSocketNum, dests->rtcpChannelId);

      fRTCPInstance->setSpecificRRHandler(dests->tcpSocketNum, dests->rtcpChannelId,

                         rtcpRRHandler, rtcpRRHandlerClientData);

    }

  } else {

    // Tell the RTP and RTCP 'groupsocks' about this destination

    // (in case they don't already have it):

    if (fRTPgs != NULL) fRTPgs->addDestination(dests->addr, dests->rtpPort);

    if (fRTCPgs != NULL) fRTCPgs->addDestination(dests->addr, dests->rtcpPort);

    if (fRTCPInstance != NULL) {

      fRTCPInstance->setSpecificRRHandler(dests->addr.s_addr, dests->rtcpPort,

                         rtcpRRHandler, rtcpRRHandlerClientData);

    }

  }

 

  if (fRTCPInstance != NULL) {

    // Hack: Send an initial RTCP "SR" packet, before the initial RTP packet, so that receivers will (likely) be able to

    // get RTCP-synchronized presentation times immediately:

    fRTCPInstance->sendReport();

  }

 

  if (!fAreCurrentlyPlaying && fMediaSource != NULL) {

if (fRTPSink != NULL) {

 //启动流

      fRTPSink->startPlaying(*fMediaSource, afterPlayingStreamState,this);

      fAreCurrentlyPlaying = True;

    } else if (fUDPSink != NULL) {

      fUDPSink->startPlaying(*fMediaSource, afterPlayingStreamState,this);

      fAreCurrentlyPlaying = True;

    }

  }

}

 

下面主要分析:

fRTPSink->startPlaying(*fMediaSource, afterPlayingStreamState, this);

代码;RTPSink* fRTPSink;RTPSink继承自MediaSink，所以fRTPSink调用的是MediaSink中的startPlaying函数;跟踪进入到startPlaying函数;

    Boolean MediaSink::startPlaying(MediaSource& source,

                   afterPlayingFunc* afterFunc,

                   void* afterClientData) {

  // Make sure we're not already being played:

  if (fSource != NULL) {

    envir().setResultMsg("This sink is already being played");

    return False;

  }

 

  // Make sure our source is compatible:

  if (!sourceIsCompatibleWithUs(source)) {

    envir().setResultMsg("MediaSink::startPlaying(): source is not compatible!");

    return False;

  }

 

  //保存下一些变量

  fSource = (FramedSource*)&source;

  fAfterFunc = afterFunc;

  fAfterClientData = afterClientData;

  return continuePlaying();

}

 

这个函数的内容对于客户端和服务端来说，都差不多，就是Sink跟source要数据，对服务器来说，source就是读文件或读实时流，将数据数据传递到sink，sink负责打包发送，对于客户端来说，source就是从网络上接收数据包，组成帧，而sink就是数据的解码等内容;下面接着跟进到continuePlaying()；

  virtual Boolean continuePlaying() = 0;函数在MediaSink类中定义的是一个纯虚函数，实现就是在它的子类里面实现了。跟进代码，看在哪个子类中实现该函数；

 

Boolean MultiFramedRTPSink::continuePlaying() {

  // Send the first packet.

  // (This will also schedule any future sends.)

  buildAndSendPacket(True);

  return True;

}

 

在MultiFrameRTPSink中找到continuePlaying()函数，该函数很简单，就是调用buildAndSendPacket(True);函数；MultiFrameRTPSink是一个与帧有关的类，它每次从source中获得一帧数据，buildAndSendPacket函数，顾名思义就是打包和发送的函数了。

 

void MultiFramedRTPSink::buildAndSendPacket(Boolean isFirstPacket) {

  fIsFirstPacket = isFirstPacket;

 

  // Set up the RTP header:

  //填充RTP包头

  unsigned rtpHdr = 0x80000000; // RTP version 2; marker ('M') bit not set (by default; it can be set later)

  rtpHdr |= (fRTPPayloadType<<16); //负载类型

  rtpHdr |= fSeqNo; // sequence number //序列号

  //往包buff中加入rtpHdr

  fOutBuf->enqueueWord(rtpHdr);

 

  // Note where the RTP timestamp will go.

  // (We can't fill this in until we start packing payload frames.)

  fTimestampPosition = fOutBuf->curPacketSize();

 

  //缓冲区中空出一个时间戳的位置，时间戳在以后在填充

  fOutBuf->skipBytes(4); // leave a hole for the timestamp

 

  //缓冲区中填入SSRC内容;

  fOutBuf->enqueueWord(SSRC());

 

  // Allow for a special, payload-format-specific header following the

  // RTP header:

  fSpecialHeaderPosition = fOutBuf->curPacketSize();

  fSpecialHeaderSize = specialHeaderSize();

  fOutBuf->skipBytes(fSpecialHeaderSize);

 

  // Begin packing as many (complete) frames into the packet as we can:

  fTotalFrameSpecificHeaderSizes = 0;

  fNoFramesLeft = False;

  fNumFramesUsedSoFar = 0;

  //前面的内容都是填充RTP包头,packFrame就是打包数据了

  packFrame();

}

 

PackFrame函数源码如下:

void MultiFramedRTPSink::packFrame() {

  // Get the next frame.

 

  // First, see if we have an overflow frame that was too big for the last pkt

  if (fOutBuf->haveOverflowData()) {

     //上一帧的数据太大，溢出了

    // Use this frame before reading a new one from the source

    unsigned frameSize = fOutBuf->overflowDataSize();

    struct timeval presentationTime = fOutBuf->overflowPresentationTime();

    unsigned durationInMicroseconds = fOutBuf->overflowDurationInMicroseconds();

    fOutBuf->useOverflowData();

 

    afterGettingFrame1(frameSize, 0, presentationTime, durationInMicroseconds);

  } else {

    // Normal case: we need to read a new frame from the source

    if (fSource == NULL) return;

    //更新缓冲区的位置信息

    fCurFrameSpecificHeaderPosition = fOutBuf->curPacketSize();

    fCurFrameSpecificHeaderSize = frameSpecificHeaderSize();

    fOutBuf->skipBytes(fCurFrameSpecificHeaderSize);

    fTotalFrameSpecificHeaderSizes += fCurFrameSpecificHeaderSize;

   

//再次从source要数据, fOutBuf->curPtr()表示数据存放的起始Buff地址;第2个参数表示Buff可用缓冲区的size，afterGettingFrame为收到一帧数据的回调函数，对该帧数据进行处理；ourHandleClosure在关闭文件时调用该函数；

    fSource->getNextFrame(fOutBuf->curPtr(), fOutBuf->totalBytesAvailable(),

                afterGettingFrame, this, ourHandleClosure,this);

  }

}

GetNextFrame函数就是Source读文件或某个设备(比如IP Camera)中读取一帧数据，读完后返回给Sink，然后调用afterGettingFrame函数；

 

下面接着讲解getNextFrame函数；

void FramedSource::getNextFrame(unsignedchar* to,unsigned maxSize,

                   afterGettingFunc* afterGettingFunc,

                   void* afterGettingClientData,

                   onCloseFunc* onCloseFunc,

                   void* onCloseClientData) {

  // Make sure we're not already being read:

  if (fIsCurrentlyAwaitingData) {

    envir() << "FramedSource[" <<this <<"]::getNextFrame(): attempting to read more than once at the same time!\n";

    envir().internalError();

  }

 

//保存一些变量

  fTo = to;

  fMaxSize = maxSize;

  fNumTruncatedBytes = 0; // by default; could be changed by doGetNextFrame()

  fDurationInMicroseconds = 0; // by default; could be changed by doGetNextFrame()

  fAfterGettingFunc = afterGettingFunc;

  fAfterGettingClientData = afterGettingClientData;

  fOnCloseFunc = onCloseFunc;

  fOnCloseClientData = onCloseClientData;

  fIsCurrentlyAwaitingData = True;

 

  doGetNextFrame();

}

 

调用doGetNextFrame()函数取下一帧数据;

H264FUAFragmenter类是H264VideoRTPSink的中调用，为H264VideoRTPSink的一个成员变量，H264VideoRTPSink继承自VideoRTPSink，而VideoRTPSink又继承自MultiFramedRTPSink；MultiFramedRTPSink继承自MediaSink；H264FUAFragmenter类取代了H264VideoStreamFramer成为和RTPSink的source，RTPSink要获取数据帧时，从H264FUAFragmenter获取。

 

void H264FUAFragmenter::doGetNextFrame() {

  if (fNumValidDataBytes == 1) {

// We have no NAL unit data currently in the buffer. Read a new one:

//buff中没有数据,则调用fInputSource->getNextFrame函数从source中获取数据;

//fInputSource为H264VideoStreamFramer，H264VideoStreamFramer的getNextFrame()会调用H264VideoStreamParser的parser(),parser()又调用ByteStreamFileSource获取数据;

    fInputSource->getNextFrame(&fInputBuffer[1], fInputBufferSize - 1,

                     afterGettingFrame, this,                       

                     FramedSource::handleClosure, this);

  } else {

    // We have NAL unit data in the buffer. There are three cases to consider:

    // 1. There is a new NAL unit in the buffer, and it's small enough to deliver

    //    to the RTP sink (as is).

    // 2. There is a new NAL unit in the buffer, but it's too large to deliver to

    //    the RTP sink in its entirety.  Deliver the first fragment of this data,

    //    as a FU-A packet, with one extra preceding header byte.

    // 3. There is a NAL unit in the buffer, and we've already delivered some

    //    fragment(s) of this.  Deliver the next fragment of this data,

    //    as a FU-A packet, with two extra preceding header bytes.

 

    if (fMaxSize < fMaxOutputPacketSize) {// shouldn't happen

      envir() << "H264FUAFragmenter::doGetNextFrame(): fMaxSize ("

           << fMaxSize << ") is smaller than expected\n";

    } else {

      fMaxSize = fMaxOutputPacketSize;

    }

 

fLastFragmentCompletedNALUnit = True; // by default

//1)非分片包

    if (fCurDataOffset == 1) { // case 1 or 2

      if (fNumValidDataBytes - 1 <= fMaxSize) {// case 1

     memmove(fTo, &fInputBuffer[1], fNumValidDataBytes - 1);

     fFrameSize = fNumValidDataBytes - 1;

     fCurDataOffset = fNumValidDataBytes;

      } else { // case 2

     // We need to send the NAL unit data as FU-A packets. Deliver the first

     // packet now.  Note that we add FU indicator and FU header bytes to the front

     // of the packet (reusing the existing NAL header byte for the FU header).

    //2)为FU-A的第一个包

     fInputBuffer[0] = (fInputBuffer[1] & 0xE0) | 28; // FU indicator

     fInputBuffer[1] = 0x80 | (fInputBuffer[1] & 0x1F); // FU header (with S bit)

     memmove(fTo, fInputBuffer, fMaxSize);

     fFrameSize = fMaxSize;

     fCurDataOffset += fMaxSize - 1;

     fLastFragmentCompletedNALUnit = False;

      }

    } else { // case 3

      // We are sending this NAL unit data as FU-A packets. We've already sent the

      // first packet (fragment).  Now, send the next fragment.  Note that we add

      // FU indicator and FU header bytes to the front. (We reuse these bytes that

      // we already sent for the first fragment, but clear the S bit, and add the E

      //3） bit if this is the last fragment.)

      //为FU-A的中间的包，复用FU indicator and FU header,清除掉FU header (no S bit开始标记)

      fInputBuffer[fCurDataOffset-2] = fInputBuffer[0]; // FU indicator

      fInputBuffer[fCurDataOffset-1] = fInputBuffer[1]&~0x80; // FU header (no S bit)

      unsigned numBytesToSend = 2 + fNumValidDataBytes - fCurDataOffset;

      if (numBytesToSend > fMaxSize) {

     // We can't send all of the remaining data this time:

     numBytesToSend = fMaxSize;

     fLastFragmentCompletedNALUnit = False;

      } else {

     // This is the last fragment:

     //4）这是FU(分片包28)的最后一个包了，将FU头部的设置成E表示End，方便客户端组帧

     fInputBuffer[fCurDataOffset-1] |= 0x40; // set the E bit in the FU header

     fNumTruncatedBytes = fSaveNumTruncatedBytes;

      }

      memmove(fTo, &fInputBuffer[fCurDataOffset-2], numBytesToSend);

      fFrameSize = numBytesToSend;

      fCurDataOffset += numBytesToSend - 2;

    }

 

    if (fCurDataOffset >= fNumValidDataBytes) {

      // We're done with this data.  Reset the pointers for receiving new data:

      fNumValidDataBytes = fCurDataOffset = 1;

    }

 

    // Complete delivery to the client:

    FramedSource::afterGetting(this);

  }

}

 

该函数的else部分实现RTP数据打包工作;live555只处理2种包;单独的包,比如sps,pps信息,一个包就是一个数据帧,2)包很大，拆包，采用FU-A的方法拆包，参考RTP打包协议！

 http://blog.csdn.net/smilestone_322/article/details/7574253

//fInputSource->getNextFrame()后调用回调函数：

void H264FUAFragmenter::afterGettingFrame(void* clientData,unsigned frameSize,

                         unsigned numTruncatedBytes,

                         struct timeval presentationTime,

                         unsigned durationInMicroseconds) {

  H264FUAFragmenter* fragmenter = (H264FUAFragmenter*)clientData;

  fragmenter->afterGettingFrame1(frameSize, numTruncatedBytes, presentationTime,

                    durationInMicroseconds);

}

 

void H264FUAFragmenter::afterGettingFrame1(unsigned frameSize,

                          unsigned numTruncatedBytes,

                          struct timeval presentationTime,

                          unsigned durationInMicroseconds) {

  fNumValidDataBytes += frameSize;

  fSaveNumTruncatedBytes = numTruncatedBytes;

  fPresentationTime = presentationTime;

  fDurationInMicroseconds = durationInMicroseconds;

 

  // Deliver data to the client:

  doGetNextFrame();

}

 

doGetNextFrame();获取到一帧数据后，就打包将数据发送给客户端；调用H264FUAFragmenter的doGetNextFrame()函数，对数据进行分析处理;这时走的doGetNextFrame()的else部分；

 

afterGettingFrame函数的源码如下：

void MultiFramedRTPSink

::afterGettingFrame(void* clientData,unsigned numBytesRead,

             unsigned numTruncatedBytes,

             struct timeval presentationTime,

             unsigned durationInMicroseconds) {

  MultiFramedRTPSink* sink = (MultiFramedRTPSink*)clientData;

  sink->afterGettingFrame1(numBytesRead, numTruncatedBytes,

                 presentationTime, durationInMicroseconds);

}

 

 

afterGettingFrame又调用afterGettingFrame1来消费数据，afterGettingFrame1我猜是发送数据；

看源码；

void MultiFramedRTPSink

::afterGettingFrame1(unsigned frameSize,unsigned numTruncatedBytes,

              struct timeval presentationTime,

              unsigned durationInMicroseconds) {

  if (fIsFirstPacket) {

    // Record the fact that we're starting to play now:

    gettimeofday(&fNextSendTime, NULL);

  }

 

  fMostRecentPresentationTime = presentationTime;

  if (fInitialPresentationTime.tv_sec == 0 && fInitialPresentationTime.tv_usec == 0) {

    fInitialPresentationTime = presentationTime;

  }   

 

  if (numTruncatedBytes > 0) {

    unsigned const bufferSize = fOutBuf->totalBytesAvailable();

    envir() << "MultiFramedRTPSink::afterGettingFrame1(): The input frame data was too large for our buffer size ("

         << bufferSize << ").  "

         << numTruncatedBytes << " bytes of trailing data was dropped! Correct this by increasing \"OutPacketBuffer::maxSize\" to at least "

         << OutPacketBuffer::maxSize + numTruncatedBytes << ", *before* creating this 'RTPSink'.  (Current value is "

         << OutPacketBuffer::maxSize << ".)\n";

  }

  unsigned curFragmentationOffset = fCurFragmentationOffset;

  unsigned numFrameBytesToUse = frameSize;

  unsigned overflowBytes = 0;

 

  // If we have already packed one or more frames into this packet,

  // check whether this new frame is eligible to be packed after them.

  // (This is independent of whether the packet has enough room for this

  // new frame; that check comes later.)

  if (fNumFramesUsedSoFar > 0) {

    if ((fPreviousFrameEndedFragmentation

      && !allowOtherFramesAfterLastFragment())

     || !frameCanAppearAfterPacketStart(fOutBuf->curPtr(), frameSize)) {

      // Save away this frame for next time:

      numFrameBytesToUse = 0;

      fOutBuf->setOverflowData(fOutBuf->curPacketSize(), frameSize,

                     presentationTime, durationInMicroseconds);

    }

  }

  fPreviousFrameEndedFragmentation = False;

 

//缓冲区太小了，数据帧被截断了，提示用户增加缓冲区大小

  if (numFrameBytesToUse > 0) {

    // Check whether this frame overflows the packet

    if (fOutBuf->wouldOverflow(frameSize)) {

      // Don't use this frame now; instead, save it as overflow data, and

      // send it in the next packet instead. However, if the frame is too

      // big to fit in a packet by itself, then we need to fragment it (and

      // use some of it in this packet, if the payload format permits this.)

      if (isTooBigForAPacket(frameSize)

          && (fNumFramesUsedSoFar == 0 || allowFragmentationAfterStart())) {

        // We need to fragment this frame, and use some of it now:

        overflowBytes = computeOverflowForNewFrame(frameSize);

        numFrameBytesToUse -= overflowBytes;

        fCurFragmentationOffset += numFrameBytesToUse;

      } else {

        // We don't use any of this frame now:

        overflowBytes = frameSize;

        numFrameBytesToUse = 0;

      }

      fOutBuf->setOverflowData(fOutBuf->curPacketSize() + numFrameBytesToUse,

                     overflowBytes, presentationTime, durationInMicroseconds);

    } else if (fCurFragmentationOffset > 0) {

      // This is the last fragment of a frame that was fragmented over

      // more than one packet.  Do any special handling for this case:

      fCurFragmentationOffset = 0;

      fPreviousFrameEndedFragmentation = True;

    }

  }

 

  if (numFrameBytesToUse == 0 && frameSize > 0) {

// Send our packet now, because we have filled it up:

//发送数据包

    sendPacketIfNecessary();

  } else {

    // Use this frame in our outgoing packet:

    unsigned char* frameStart = fOutBuf->curPtr();

    fOutBuf->increment(numFrameBytesToUse);

        // do this now, in case "doSpecialFrameHandling()" calls "setFramePadding()" to append padding bytes

 

    // Here's where any payload format specific processing gets done:

    doSpecialFrameHandling(curFragmentationOffset, frameStart,

                 numFrameBytesToUse, presentationTime,

                 overflowBytes);

 

    ++fNumFramesUsedSoFar;

 

    // Update the time at which the next packet should be sent, based

    // on the duration of the frame that we just packed into it.

    // However, if this frame has overflow data remaining, then don't

// count its duration yet.

//更新时间戳

    if (overflowBytes == 0) {

      fNextSendTime.tv_usec += durationInMicroseconds;

      fNextSendTime.tv_sec += fNextSendTime.tv_usec/1000000;

      fNextSendTime.tv_usec %= 1000000;

    }

 

    // Send our packet now if (i) it's already at our preferred size, or

    // (ii) (heuristic) another frame of the same size as the one we just

    //      read would overflow the packet, or

    // (iii) it contains the last fragment of a fragmented frame, and we

    //      don't allow anything else to follow this or

// (iv) one frame per packet is allowed:

//1)数据包的size已经是一个恰当的大小了，在往里面打包数据可能造成缓冲区溢出了;

//2)已经包括了分片包的最后一个包了;

//3)容许一帧一个数据包

    if (fOutBuf->isPreferredSize()

        || fOutBuf->wouldOverflow(numFrameBytesToUse)

        || (fPreviousFrameEndedFragmentation &&

            !allowOtherFramesAfterLastFragment())

        || !frameCanAppearAfterPacketStart(fOutBuf->curPtr() - frameSize,

                          frameSize) ) {

      // The packet is ready to be sent now

      //发送数据包

      sendPacketIfNecessary();

    } else {

      // There's room for more frames; try getting another:

     //继承打包

      packFrame();

    }

  }

}

 

下面继续看发送数据的函数：

void MultiFramedRTPSink::sendPacketIfNecessary() {

  if (fNumFramesUsedSoFar > 0) {

    // Send the packet:

#ifdef TEST_LOSS

    if ((our_random()%10) != 0) // simulate 10% packet loss #####

#endif

      if (!fRTPInterface.sendPacket(fOutBuf->packet(), fOutBuf->curPacketSize())) {

     // if failure handler has been specified, call it

     if (fOnSendErrorFunc != NULL) (*fOnSendErrorFunc)(fOnSendErrorData);

      }

    ++fPacketCount;

    fTotalOctetCount += fOutBuf->curPacketSize();

    fOctetCount += fOutBuf->curPacketSize()

      - rtpHeaderSize - fSpecialHeaderSize - fTotalFrameSpecificHeaderSizes;

 

    ++fSeqNo; // for next time

  }

 

  if (fOutBuf->haveOverflowData()

      && fOutBuf->totalBytesAvailable() > fOutBuf->totalBufferSize()/2) {

    // Efficiency hack: Reset the packet start pointer to just in front of

    // the overflow data (allowing for the RTP header and special headers),

    // so that we probably don't have to "memmove()" the overflow data

    // into place when building the next packet:

    unsigned newPacketStart = fOutBuf->curPacketSize()

      - (rtpHeaderSize + fSpecialHeaderSize + frameSpecificHeaderSize());

    fOutBuf->adjustPacketStart(newPacketStart);

  } else {

    // Normal case: Reset the packet start pointer back to the start:

    fOutBuf->resetPacketStart();

  }

  fOutBuf->resetOffset();

  fNumFramesUsedSoFar = 0;

 

  if (fNoFramesLeft) {

    // We're done:

    onSourceClosure(this);

  } else {

    // We have more frames left to send. Figure out when the next frame

    // is due to start playing, then make sure that we wait this long before

    // sending the next packet.

    struct timeval timeNow;

    gettimeofday(&timeNow, NULL);

    int secsDiff = fNextSendTime.tv_sec - timeNow.tv_sec;

    int64_t uSecondsToGo = secsDiff*1000000 + (fNextSendTime.tv_usec - timeNow.tv_usec);

    if (uSecondsToGo < 0 || secsDiff < 0) {// sanity check: Make sure that the time-to-delay is non-negative:

      uSecondsToGo = 0;

    }

 

    // Delay this amount of time:

    nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecondsToGo, (TaskFunc*)sendNext,this);

  }

}

 

在发送数据的函数中使用延迟任务，为了延迟包的发送，使用delay task来执行下次打包发送任务，看sendNext的代码;

void MultiFramedRTPSink::sendNext(void* firstArg) {

  MultiFramedRTPSink* sink = (MultiFramedRTPSink*)firstArg;

  sink->buildAndSendPacket(False);

}

它又调用了buildAndSendPacket函数，看下该函数参数的作用，True和False的区别;True表示该帧是第一帧，记下实际Play的时间；在afterGettingFrame1中有如下代码：

  if (fIsFirstPacket) {

    // Record the fact that we're starting to play now:

    gettimeofday(&fNextSendTime, NULL);

  }

 

在MultiFramedRTPSink中数据包和帧的缓冲区队列是同一个，使用了一些标记和对指针的移动来操作数据打包和发送数据帧；注意:如果数据帧溢出，时间戳会计算不准确;