LIVE555play流程

5.1放假了，昨日研究了LIVE555的play部分的源码，不敢独享，贡献出来分享。

调用栈

BasicTaskScheduler0::doEventLoop()

{

  // Repeatedly loop, handling readble socketsand timed events:

  while (1)

  {

   SingleStep();

  }

}

 

void BasicTaskScheduler::SingleStep()

{

 //handler->handlerProc =RTSPServer::RTSPClientSession::incomingRequestHandler

 (*handler->handlerProc)(handler->clientData,resultConditionSet);

}

 

voidRTSPServer::RTSPClientSession::incomingRequestHandler1()

{

  handleRequestBytes(bytesRead);

}

 

void RTSPServer::RTSPClientSession::handleRequestBytes(intnewBytesRead)

{

  handleCmd_withinSession("PLAY", urlPreSuffix,urlSuffix, cseq,

                  (char const*)fRequestBuffer);

}

 

RTSPServer::RTSPClientSession::handleCmd_PLAY(ServerMediaSubsession*subsession,

char const* cseq,

char const* fullRequestStr)

{

     fStreamStates[i].subsession->startStream(fOurSessionId,

                            fStreamStates[i].streamToken,

                            (TaskFunc*)noteClientLiveness, this,

                            rtpSeqNum, rtpTimestamp,

                            handleAlternativeRequestByte, this);

}

 

void OnDemandServerMediaSubsession::startStream(unsignedclientSessionId,

        void* streamToken,

        TaskFunc* rtcpRRHandler,void* rtcpRRHandlerClientData,

        unsigned short& rtpSeqNum,

        unsigned& rtpTimestamp,

        ServerRequestAlternativeByteHandler*serverRequestAlternativeByteHandler,

        void* serverRequestAlternativeByteHandlerClientData )

{

 

到了Play阶段，会调用startStream，里面会调用StreamState::startPlaying然后，fRTPSin->startPlaying(定义在MediaSink::startPlaying)，里面会把MediaSink的参数fSource设置且前面的fMediaSource，然后执行continurePlaying()

  streamState->startPlaying(destinations,

 

                  rtcpRRHandler, rtcpRRHandlerClientData,

                  serverRequestAlternativeByteHandler,

serverRequestAlternativeByteHandlerClientData);

}

 

StreamState:startPlaying(Destinations* dests,

        TaskFunc* rtcpRRHandler,

        void* rtcpRRHandlerClientData,

        ServerRequestAlternativeByteHandler*serverRequestAlternativeByteHandler,

        void*serverRequestAlternativeByteHandlerClientData)

{

 

 fRTPSink->startPlaying(*fMediaSource,

                  afterPlayingStreamState,

                  this);

}

 

MediaSink::startPlaying(MediaSource& source,

              afterPlayingFunc* afterFunc,

              void* afterClientData)

{

  fSource =(FramedSource*)&source;

 

  fAfterFunc = afterFunc;

  fAfterClientData = afterClientData;

  return continuePlaying();

}

 

H264VideoRTPSink::continuePlaying()

{

  if (fOurFragmenter == NULL) {

   fOurFragmenter = new H264FUAFragmenter(envir(),

                        fSource,

 

在H264VideoRTPSink::continurePlaying()里面，会让fSource等于H264VideoRTPSink::fOurFragmenter(一个H264FUAFagmenterclass)，而原来的fSource变为fOurFragmenter的fInputSource，然后执行MultiFramedRTPSink::continuePlaying()......MultiFramedRTPSink::buildAndSendPacket(true)...... MultiFramedRTPSink :: packFrame()

                        OutPacketBuffer::maxSize,

 

                        ourMaxPacketSize() - 12);

    fSource =fOurFragmenter;

  }

 

  returnMultiFramedRTPSink::continuePlaying();

}

H264FUAFragmenter::H264FUAFragmenter(UsageEnvironment&env,

                      FramedSource* inputSource,

                      unsigned inputBufferMax,

                      unsigned maxOutputPacketSize)

  : FramedFilter(env, inputSource)

{

}

MultiFramedRTPSink::continuePlaying()

{

  buildAndSendPacket(True);

}

 

MultiFramedRTPSink::buildAndSendPacket(BooleanisFirstPacket)

{

  处理RTP Header

 

  //packing as many (complete) frames into thepacket

  packFrame();

}

 

MultiFramedRTPSink::packFrame()

 

H264FUAFragmenter继承自FramedFilter :FramedSource在上面的fOurFragmenter的构造函数里面就定义了FramedFilter::fInputSource等于fSourceH264FUAFragm

enter :: doGetNextFrame() 會 設定 FramedFilter ::fInputSource 的 fTo ， i.e.

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

&fInputBuffer[1] =>startcode应该可以一起放进去，所以 fInputBuffer 是我们 startcode + NAL hdr + NALpayload 要存的地方

{

 

  //前一帧如果太大会在buffer留下剩余部分，加上

 

 //或者设定好fSource::fTo这个指针指向OutBuf->curPtr()

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

             fOutBuf->totalBytesAvailable(),

             afterGettingFrame,

             this,

             ourHandleClosure,

             this);

 

}

 

FramedSource::getNextFrame(unsigned char* to,

                unsigned maxSize,

                afterGettingFunc*afterGettingFunc,

                void*afterGettingClientData,

                onCloseFunc* onCloseFunc,

                void* onCloseClientData)

{

  //设置各个参数

  fTo = to;

  fMaxSize = maxSize;

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

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

  fAfterGettingFunc = afterGettingFunc;

  fAfterGettingClientData =afterGettingClientData;

  fOnCloseFunc = onCloseFunc;

  fOnCloseClientData = onCloseClientData;

  fIsCurrentlyAwaitingData = True;

 

 fSource::fAfterGettingFunc=MultiFramedRTPSink::afterGettingFrame

  fSource::fOnCloseFunc=MultiFramedRTPSink::ourHandleClosure

 

  doGetNextFrame();

}

 

H264FUAFragmenter::doGetNextFrame()

{

  _ If no NALU in the buffer (i.e.fNumValidDataBytes == 1) Read a new one:

    {

    FramedFilter::fInputSource->getNextFrame(&fInputBuffer[1],

                             fInputBufferSize- 1,

                              afterGettingFrame,

                              this,

                             FramedSource::handleClosure,

                              this);

    _ fInputSource::fAfterGettingFunc =H264FUAFragmenter::afterGettingFrame

  }

  _ Else

 {

   ......

   //// Complete delivery tothe client:

  FramedSource::afterGetting(this)

 }

}

 

FramedSource::afterGetting(FramedSource* source) {

  if (source->fAfterGettingFunc!= NULL) {

   (*(source->fAfterGettingFunc))(source->fAfterGettingClientData,

                    source->fFrameSize,source->fNumTruncatedBytes,

                    source->fPresentationTime,

                    source->fDurationInMicroseconds);

  }

}

 

 

MultiFramedRTPSink::afterGettingFrame(void* clientData,

                      unsigned numBytesRead,unsigned numTruncatedBytes,

                            struct timeval presentationTime,

                            unsigned durationInMicroseconds)

{

  MultiFramedRTPSink* sink =(MultiFramedRTPSink*)clientData;

 sink->afterGettingFrame1(numBytesRead,numTruncatedBytes,

                presentationTime,durationInMicroseconds);

}

 

MultiFramedRTPSink::afterGettingFrame1(unsigned frameSize,

unsigned numTruncatedBytes,

                    struct timeval presentationTime,

unsigned durationInMicroseconds)

{

  if (numFrameBytesToUse == 0) {

    // Sendour packet now, because we have filled it up:

   sendPacketIfNecessary();

  }

  else

  {

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

    packFrame();

  }

}

 

MultiFramedRTPSink::sendPacketIfNecessary()

{

    // Delaythis amount of time:

nextTask() = envir().taskScheduler()

.scheduleDelayedTask(uSecondsToGo, (TaskFunc*)sendNext,this);

}

 

// The following is called after each delay between packetsends:

MultiFramedRTPSink::sendNext(void* firstArg)

{

  MultiFramedRTPSink* sink =(MultiFramedRTPSink*)firstArg;

 sink->buildAndSendPacket(False);

}