Live555 客户端解包
以testRTSPClient.cpp为例讲解：
Medium<-MediaSource<-FramedSource<-RTPSource<-MultiFramedRTPSource<-H264VideoRTPSource
其中，我们要重点关注的类是下面几个：
FramedSource,RTPSource,MultiFramedRTPSource。
continuePlaying()函数中调用Source类（以MultiFramedRTPSource为例，因为它以实现doGetFrame()函数）的getNextFrame()函数以得到发送数据，而getNextFrame()是通过调用doGetNextFrame()，继而是doGetNextFrame1()，最终在doNextFrame1中由语句fReorderingBuffer->getNextCompletedPacket()将存放在fReorderingBuffer中的数据取出交给Sink类来发送。
Boolean DummySink::continuePlaying() {
if (fSource == NULL) return False; // sanity check (should not happen)
// Request the next frame of data from our input source. "afterGettingFrame()" will get called later, when it arrives:
fSource->getNextFrame(fReceiveBuffer, DUMMY_SINK_RECEIVE_BUFFER_SIZE,
afterGettingFrame, this,
onSourceClosure, this);
return True;
}
fSource调用的是FrameSource类的getNextFrame函数，源码如下：
void FramedSource::getNextFrame(unsigned char* 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()在FramedSource类中为纯虚函数，在子类MultiFramedRTPSource中实现，源码如下：
void MultiFramedRTPSource::doGetNextFrame() {
if (!fAreDoingNetworkReads) {
// Turn on background read handling of incoming packets:
//将标志位置为TRUE
fAreDoingNetworkReads = True;
TaskScheduler::BackgroundHandlerProc* handler
= (TaskScheduler::BackgroundHandlerProc*)&networkReadHandler;
//如何获取数据：networkReadHandler1()函数不断从fRTPInterface所指向的socket读入， 最终执行语句fReorderingBuffer->storePacket(bPacket);实现。
//开始网络数据包接收
fRTPInterface.startNetworkReading(handler);
}
fSavedTo = fTo;
fSavedMaxSize = fMaxSize;
fFrameSize = 0; // for now
fNeedDelivery = True;
doGetNextFrame1();
}
networkReadHandler源码如下：
void MultiFramedRTPSource::networkReadHandler(MultiFramedRTPSource* source, int /*mask*/) {
source->networkReadHandler1();
}
networkReadHandler1源码如下：
void MultiFramedRTPSource::networkReadHandler1() {
BufferedPacket* bPacket = fPacketReadInProgress;
if (bPacket == NULL) {
// Normal case: Get a free BufferedPacket descriptor to hold the new network packet:
bPacket = fReorderingBuffer->getFreePacket(this);
}
// Read the network packet, and perform sanity checks on the RTP header:
//读出网络数据包，并检查RTP包头
Boolean readSuccess = False;
do {
Boolean packetReadWasIncomplete = fPacketReadInProgress != NULL;
if (!bPacket->fillInData(fRTPInterface, packetReadWasIncomplete)) {
if (bPacket->bytesAvailable() == 0) {
envir() << "MultiFramedRTPSource error: Hit limit when reading incoming packet over TCP. Increase \"MAX_PACKET_SIZE\"\n";
}
fPacketReadInProgress = NULL;
break;
}
if (packetReadWasIncomplete) {
// We need additional read(s) before we can process the incoming packet:
fPacketReadInProgress = bPacket;
return;
} else {
fPacketReadInProgress = NULL;
}
#ifdef TEST_LOSS
setPacketReorderingThresholdTime(0);
// don't wait for 'lost' packets to arrive out-of-order later
if ((our_random()%10) == 0) break; // simulate 10% packet loss
#endif
// Check for the 12-byte RTP header:
if (bPacket->dataSize() < 12) break;
unsigned rtpHdr = ntohl(*(u_int32_t*)(bPacket->data())); ADVANCE(4);
Boolean rtpMarkerBit = (rtpHdr&0x00800000) != 0;
unsigned rtpTimestamp = ntohl(*(u_int32_t*)(bPacket->data()));ADVANCE(4);
unsigned rtpSSRC = ntohl(*(u_int32_t*)(bPacket->data())); ADVANCE(4);
// Check the RTP version number (it should be 2):
if ((rtpHdr&0xC0000000) != 0x80000000) break;
// Skip over any CSRC identifiers in the header:
unsigned cc = (rtpHdr>>24)&0xF;
if (bPacket->dataSize() < cc) break;
ADVANCE(cc*4);
// Check for (& ignore) any RTP header extension
if (rtpHdr&0x10000000) {
if (bPacket->dataSize() < 4) break;
unsigned extHdr = ntohl(*(u_int32_t*)(bPacket->data())); ADVANCE(4);
unsigned remExtSize = 4*(extHdr&0xFFFF);
if (bPacket->dataSize() < remExtSize) break;
ADVANCE(remExtSize);
}
// Discard any padding bytes:
if (rtpHdr&0x20000000) {
if (bPacket->dataSize() == 0) break;
unsigned numPaddingBytes
= (unsigned)(bPacket->data())[bPacket->dataSize()-1];
if (bPacket->dataSize() < numPaddingBytes) break;
bPacket->removePadding(numPaddingBytes);
}
// Check the Payload Type.
if ((unsigned char)((rtpHdr&0x007F0000)>>16)
!= rtpPayloadFormat()) {
break;
}
// The rest of the packet is the usable data. Record and save it:
if (rtpSSRC != fLastReceivedSSRC) {
// The SSRC of incoming packets has changed. Unfortunately we don't yet handle streams that contain multiple SSRCs,
// but we can handle a single-SSRC stream where the SSRC changes occasionally:
fLastReceivedSSRC = rtpSSRC;
fReorderingBuffer->resetHaveSeenFirstPacket();
}
unsigned short rtpSeqNo = (unsigned short)(rtpHdr&0xFFFF);
Boolean usableInJitterCalculation
= packetIsUsableInJitterCalculation((bPacket->data()),
bPacket->dataSize());
struct timeval presentationTime; // computed by:
Boolean hasBeenSyncedUsingRTCP; // computed by:
receptionStatsDB()
.noteIncomingPacket(rtpSSRC, rtpSeqNo, rtpTimestamp,
timestampFrequency(),
usableInJitterCalculation, presentationTime,
hasBeenSyncedUsingRTCP, bPacket->dataSize());
// Fill in the rest of the packet descriptor, and store it:
struct timeval timeNow;
gettimeofday(&timeNow, NULL);
bPacket->assignMiscParams(rtpSeqNo, rtpTimestamp, presentationTime,
hasBeenSyncedUsingRTCP, rtpMarkerBit,
timeNow);
//将收到的包插入到fReorderingBuffer中
if (!fReorderingBuffer->storePacket(bPacket)) break;
readSuccess = True;
} while (0);
if (!readSuccess) fReorderingBuffer->freePacket(bPacket);
doGetNextFrame1();
// If we didn't get proper data this time, we'll get another chance
}
1）fillInData函数源码如下:
Boolean BufferedPacket::fillInData(RTPInterface& rtpInterface, Boolean& packetReadWasIncomplete) {
if (!packetReadWasIncomplete) reset();
unsigned numBytesRead;
struct sockaddr_in fromAddress;
unsigned const maxBytesToRead = bytesAvailable();
if (maxBytesToRead == 0) return False; // exceeded buffer size when reading over TCP
if (!rtpInterface.handleRead(&fBuf[fTail], maxBytesToRead, numBytesRead, fromAddress, packetReadWasIncomplete)) {
return False;
}
fTail += numBytesRead;
return True;
}
fillInData调用handleRead实现了将rtpInterface指向的数据存入fBuf中的功能。
源码如下：
Boolean RTPInterface::handleRead(unsigned char* buffer, unsigned bufferMaxSize,
unsigned& bytesRead, struct sockaddr_in& fromAddress, Boolean& packetReadWasIncomplete) {
packetReadWasIncomplete = False; // by default
Boolean readSuccess;
if (fNextTCPReadStreamSocketNum < 0) {
// Normal case: read from the (datagram) 'groupsock':
readSuccess = fGS->handleRead(buffer, bufferMaxSize, bytesRead, fromAddress);
} else {
// Read from the TCP connection:
bytesRead = 0;
unsigned totBytesToRead = fNextTCPReadSize;
if (totBytesToRead > bufferMaxSize) totBytesToRead = bufferMaxSize;
unsigned curBytesToRead = totBytesToRead;
int curBytesRead;
while ((curBytesRead = readSocket(envir(), fNextTCPReadStreamSocketNum,
&buffer[bytesRead], curBytesToRead,
fromAddress)) > 0) {
bytesRead += curBytesRead;
if (bytesRead >= totBytesToRead) break;
curBytesToRead -= curBytesRead;
}
fNextTCPReadSize -= bytesRead;
if (fNextTCPReadSize == 0) {
// We've read all of the data that we asked for
readSuccess = True;
} else if (curBytesRead < 0) {
// There was an error reading the socket
bytesRead = 0;
readSuccess = False;
} else {
// We need to read more bytes, and there was not an error reading the socket
packetReadWasIncomplete = True;
return True;
}
fNextTCPReadStreamSocketNum = -1; // default, for next time
}
if (readSuccess && fAuxReadHandlerFunc != NULL) {
// Also pass the newly-read packet data to our auxilliary handler:
(*fAuxReadHandlerFunc)(fAuxReadHandlerClientData, buffer, bytesRead);
}
return readSuccess;
}
该函数从socket中读数据包；
2）storePacket函数源码如下：
Boolean ReorderingPacketBuffer::storePacket(BufferedPacket* bPacket) {
unsigned short rtpSeqNo = bPacket->rtpSeqNo();
if (!fHaveSeenFirstPacket) {
fNextExpectedSeqNo = rtpSeqNo; // initialization
bPacket->isFirstPacket() = True;
fHaveSeenFirstPacket = True;
}
// Ignore this packet if its sequence number is less than the one
// that we're looking for (in this case, it's been excessively delayed).
if (seqNumLT(rtpSeqNo, fNextExpectedSeqNo)) return False;
if (fTailPacket == NULL) {
// Common case: There are no packets in the queue; this will be the first one:
bPacket->nextPacket() = NULL;
fHeadPacket = fTailPacket = bPacket;
return True;
}
if (seqNumLT(fTailPacket->rtpSeqNo(), rtpSeqNo)) {
// The next-most common case: There are packets already in the queue; this packet arrived in order => put it at the tail:
bPacket->nextPacket() = NULL;
fTailPacket->nextPacket() = bPacket;
fTailPacket = bPacket;
return True;
}
if (rtpSeqNo == fTailPacket->rtpSeqNo()) {
// This is a duplicate packet - ignore it
return False;
}
// Rare case: This packet is out-of-order. Run through the list (from the head), to figure out where it belongs:
BufferedPacket* beforePtr = NULL;
BufferedPacket* afterPtr = fHeadPacket;
while (afterPtr != NULL) {
if (seqNumLT(rtpSeqNo, afterPtr->rtpSeqNo())) break; // it comes here
if (rtpSeqNo == afterPtr->rtpSeqNo()) {
// This is a duplicate packet - ignore it
return False;
}
beforePtr = afterPtr;
afterPtr = afterPtr->nextPacket();
}
// Link our new packet between "beforePtr" and "afterPtr":
bPacket->nextPacket() = afterPtr;
if (beforePtr == NULL) {
fHeadPacket = bPacket;
} else {
beforePtr->nextPacket() = bPacket;
}
return True;
}
该函数中有do while（0）的妙用，可以参考：
http://www.cnblogs.com/flying_bat/archive/2008/01/18/1044693.html
继续调用doGetNextFrame1()函数，源码如下：
void MultiFramedRTPSource::doGetNextFrame1() {
//是否需要发送,交给sink处理
while (fNeedDelivery) {
// If we already have packet data available, then deliver it now.
Boolean packetLossPrecededThis;
//获取下一个完整的数据包
BufferedPacket* nextPacket
= fReorderingBuffer->getNextCompletedPacket(packetLossPrecededThis);
if (nextPacket == NULL) break;
//丢给Sink后将fNeedDelivery置为False
fNeedDelivery = False;
if (nextPacket->useCount() == 0) {
// Before using the packet, check whether it has a special header
// that needs to be processed:
unsigned specialHeaderSize;
//处理特殊包头，比如FU-A的分片包头
if (!processSpecialHeader(nextPacket, specialHeaderSize)) {
// Something's wrong with the header; reject the packet:
fReorderingBuffer->releaseUsedPacket(nextPacket);
fNeedDelivery = True;
break;
}
nextPacket->skip(specialHeaderSize);
}
// Check whether we're part of a multi-packet frame, and whether
// there was packet loss that would render this packet unusable:
if (fCurrentPacketBeginsFrame) {
if (packetLossPrecededThis || fPacketLossInFragmentedFrame) {
// We didn't get all of the previous frame.
// Forget any data that we used from it:
fTo = fSavedTo; fMaxSize = fSavedMaxSize;
fFrameSize = 0;
}
fPacketLossInFragmentedFrame = False;
} else if (packetLossPrecededThis) {
// We're in a multi-packet frame, with preceding packet loss
fPacketLossInFragmentedFrame = True;
}
if (fPacketLossInFragmentedFrame) {
// This packet is unusable; reject it:
fReorderingBuffer->releaseUsedPacket(nextPacket);
fNeedDelivery = True;
break;
}
// The packet is usable. Deliver all or part of it to our caller:
unsigned frameSize;
nextPacket->use(fTo, fMaxSize, frameSize, fNumTruncatedBytes,
fCurPacketRTPSeqNum, fCurPacketRTPTimestamp,
fPresentationTime, fCurPacketHasBeenSynchronizedUsingRTCP,
fCurPacketMarkerBit);
fFrameSize += frameSize;
if (!nextPacket->hasUsableData()) {
// We're completely done with this packet now
fReorderingBuffer->releaseUsedPacket(nextPacket);
}
//已经是完整的一帧数据了，回调给Sink处理
if (fCurrentPacketCompletesFrame) {
// We have all the data that the client wants.
if (fNumTruncatedBytes > 0) {
envir() << "MultiFramedRTPSource::doGetNextFrame1(): The total received frame size exceeds the client's buffer size ("
<< fSavedMaxSize << "). "
<< fNumTruncatedBytes << " bytes of trailing data will be dropped!\n";
}
// Call our own 'after getting' function, so that the downstream object can consume the data:
if (fReorderingBuffer->isEmpty()) {
// Common case optimization: There are no more queued incoming packets, so this code will not get
// executed again without having first returned to the event loop. Call our 'after getting' function
// directly, because there's no risk of a long chain of recursion (and thus stack overflow):
afterGetting(this);
} else {
// Special case: Call our 'after getting' function via the event loop.
nextTask() = envir().taskScheduler().scheduleDelayedTask(0,
(TaskFunc*)FramedSource::afterGetting, this);
}
} else {
// This packet contained fragmented data, and does not complete
// the data that the client wants. Keep getting data:
fTo += frameSize; fMaxSize -= frameSize;
fNeedDelivery = True;
}
}
}
其中几个重要的函数解析如下：
1） getNextCompletedPacket
BufferedPacket* ReorderingPacketBuffer
::getNextCompletedPacket(Boolean& packetLossPreceded) {
if (fHeadPacket == NULL) return NULL;
// Check whether the next packet we want is already at the head
// of the queue:
// ASSERT: fHeadPacket->rtpSeqNo() >= fNextExpectedSeqNo
if (fHeadPacket->rtpSeqNo() == fNextExpectedSeqNo) {
packetLossPreceded = fHeadPacket->isFirstPacket();
// (The very first packet is treated as if there was packet loss beforehand.)
return fHeadPacket;
}
// We're still waiting for our desired packet to arrive. However, if
// our time threshold has been exceeded, then forget it, and return
// the head packet instead:
Boolean timeThresholdHasBeenExceeded;
if (fThresholdTime == 0) {
timeThresholdHasBeenExceeded = True; // optimization
} else {
struct timeval timeNow;
gettimeofday(&timeNow, NULL);
unsigned uSecondsSinceReceived
= (timeNow.tv_sec - fHeadPacket->timeReceived().tv_sec)*1000000
+ (timeNow.tv_usec - fHeadPacket->timeReceived().tv_usec);
timeThresholdHasBeenExceeded = uSecondsSinceReceived > fThresholdTime;
}
if (timeThresholdHasBeenExceeded) {
fNextExpectedSeqNo = fHeadPacket->rtpSeqNo();
// we've given up on earlier packets now
packetLossPreceded = True;
return fHeadPacket;
}
// Otherwise, keep waiting for our desired packet to arrive:
return NULL;
}
2） processSpecialHeader
H264的特殊头处理函数如下：
Boolean H264VideoRTPSource
::processSpecialHeader(BufferedPacket* packet,
unsigned& resultSpecialHeaderSize) {
unsigned char* headerStart = packet->data();
unsigned packetSize = packet->dataSize();
// The header has a minimum size of 0, since the NAL header is used
// as a payload header
unsigned expectedHeaderSize = 0;
// Check if the type field is 28 (FU-A) or 29 (FU-B)
fCurPacketNALUnitType = (headerStart[0]&0x1F);
switch (fCurPacketNALUnitType) {
case 24: { // STAP-A
expectedHeaderSize = 1; // discard the type byte
break;
}
case 25: case 26: case 27: { // STAP-B, MTAP16, or MTAP24
expectedHeaderSize = 3; // discard the type byte, and the initial DON
break;
}
case 28: case 29: { // // FU-A or FU-B
// For these NALUs, the first two bytes are the FU indicator and the FU header.
// If the start bit is set, we reconstruct the original NAL header:
unsigned char startBit = headerStart[1]&0x80;
unsigned char endBit = headerStart[1]&0x40;
if (startBit) {
expectedHeaderSize = 1;
if (packetSize < expectedHeaderSize) return False;
headerStart[1] = (headerStart[0]&0xE0)+(headerStart[1]&0x1F);
fCurrentPacketBeginsFrame = True;
} else {
// If the startbit is not set, both the FU indicator and header
// can be discarded
expectedHeaderSize = 2;
if (packetSize < expectedHeaderSize) return False;
fCurrentPacketBeginsFrame = False;
}
fCurrentPacketCompletesFrame = (endBit != 0);
break;
}
default: {
// This packet contains one or more complete, decodable NAL units
fCurrentPacketBeginsFrame = fCurrentPacketCompletesFrame = True;
break;
}
}
resultSpecialHeaderSize = expectedHeaderSize;
return True;
}
3）use将解析的内容放到to的Buff中;
void BufferedPacket::use(unsigned char* to, unsigned toSize,
unsigned& bytesUsed, unsigned& bytesTruncated,
unsigned short& rtpSeqNo, unsigned& rtpTimestamp,
struct timeval& presentationTime,
Boolean& hasBeenSyncedUsingRTCP,
Boolean& rtpMarkerBit) {
unsigned char* origFramePtr = &fBuf[fHead];
unsigned char* newFramePtr = origFramePtr; // may change in the call below
unsigned frameSize, frameDurationInMicroseconds;
getNextEnclosedFrameParameters(newFramePtr, fTail - fHead,
frameSize, frameDurationInMicroseconds);
if (frameSize > toSize) {
bytesTruncated += frameSize - toSize;
bytesUsed = toSize;
} else {
bytesTruncated = 0;
bytesUsed = frameSize;
}
memmove(to, newFramePtr, bytesUsed);
fHead += (newFramePtr - origFramePtr) + frameSize;
++fUseCount;
rtpSeqNo = fRTPSeqNo;
rtpTimestamp = fRTPTimestamp;
presentationTime = fPresentationTime;
hasBeenSyncedUsingRTCP = fHasBeenSyncedUsingRTCP;
rtpMarkerBit = fRTPMarkerBit;
// Update "fPresentationTime" for the next enclosed frame (if any):
fPresentationTime.tv_usec += frameDurationInMicroseconds;
if (fPresentationTime.tv_usec >= 1000000) {
fPresentationTime.tv_sec += fPresentationTime.tv_usec/1000000;
fPresentationTime.tv_usec = fPresentationTime.tv_usec%1000000;
}
}
其中getNextEnclosedFrameParameters函数源码如下：
void BufferedPacket
::getNextEnclosedFrameParameters(unsigned char*& framePtr, unsigned dataSize,
unsigned& frameSize,
unsigned& frameDurationInMicroseconds) {
// By default, use the entire buffered data, even though it may consist
// of more than one frame, on the assumption that the client doesn't
// care. (This is more efficient than delivering a frame at a time)
// For backwards-compatibility with existing uses of (the now deprecated)
// "nextEnclosedFrameSize()", call that function to implement this one:
frameSize = nextEnclosedFrameSize(framePtr, dataSize);
frameDurationInMicroseconds = 0; // by default. Subclasses should correct this.
}
nextEnclosedFrameSize函数源码如下：
unsigned H264BufferedPacket
::nextEnclosedFrameSize(unsigned char*& framePtr, unsigned dataSize) {
unsigned resultNALUSize = 0; // if an error occurs
switch (fOurSource.fCurPacketNALUnitType) {
case 24: case 25: { // STAP-A or STAP-B
// The first two bytes are NALU size:
if (dataSize < 2) break;
resultNALUSize = (framePtr[0]<<8)|framePtr[1];
framePtr += 2;
break;
}
case 26: { // MTAP16
// The first two bytes are NALU size. The next three are the DOND and TS offset:
if (dataSize < 5) break;
resultNALUSize = (framePtr[0]<<8)|framePtr[1];
framePtr += 5;
break;
}
case 27: { // MTAP24
// The first two bytes are NALU size. The next four are the DOND and TS offset:
if (dataSize < 6) break;
resultNALUSize = (framePtr[0]<<8)|framePtr[1];
framePtr += 6;
break;
}
default: {
// Common case: We use the entire packet data:
return dataSize;
}
}
return (resultNALUSize <= dataSize) ? resultNALUSize : dataSize;
}
4）afterGetting
afterGetting表示一个Loop结束，调用的是FramedSource的afterGetting
void FramedSource::afterGetting(FramedSource* source) {
source->fIsCurrentlyAwaitingData = False;
// indicates that we can be read again
// Note that this needs to be done here, in case the "fAfterFunc"
// called below tries to read another frame (which it usually will)
// fAfterGettingFunc就是afterGettingFrame函数
if (source->fAfterGettingFunc != NULL) {
(*(source->fAfterGettingFunc))(source->fAfterGettingClientData,
source->fFrameSize, source->fNumTruncatedBytes,
source->fPresentationTime,
source->fDurationInMicroseconds);
}
}
最终调用表示将Source的数据传递到Sink，由Sink进行处理，
void DummySink::afterGettingFrame(void* clientData, unsigned frameSize, unsigned numTruncatedBytes,
struct timeval presentationTime, unsigned durationInMicroseconds) {
DummySink* sink = (DummySink*)clientData;
sink->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
}
void DummySink::afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes,
struct timeval presentationTime, unsigned /*durationInMicroseconds*/) {
// We've just received a frame of data. (Optionally) print out information about it:
#ifdef DEBUG_PRINT_EACH_RECEIVED_FRAME
if (fStreamId != NULL) envir() << "Stream \"" << fStreamId << "\"; ";
envir() << fSubsession.mediumName() << "/" << fSubsession.codecName() << ":\tReceived " << frameSize << " bytes";
if (numTruncatedBytes > 0) envir() << " (with " << numTruncatedBytes << " bytes truncated)";
char uSecsStr[6+1]; // used to output the 'microseconds' part of the presentation time
sprintf(uSecsStr, "%06u", (unsigned)presentationTime.tv_usec);
envir() << ".\tPresentation time: " << (int)presentationTime.tv_sec << "." << uSecsStr;
if (fSubsession.rtpSource() != NULL && !fSubsession.rtpSource()->hasBeenSynchronizedUsingRTCP()) {
envir() << "!"; // mark the debugging output to indicate that this presentation time is not RTCP-synchronized
}
#ifdef DEBUG_PRINT_NPT
envir() << "\tNPT: " << fSubsession.getNormalPlayTime(presentationTime);
#endif
envir() << "\n";
#endif
// Then continue, to request the next frame of data:
//再次调用continuePlaying()获取下一帧数据
continuePlaying();
}
其中还有一个很重要的解析sps/pps函数，源码如下：
解析Sps/Pps函数：
SPropRecord* parseSPropParameterSets(char const* sPropParameterSetsStr,
// result parameter:
unsigned& numSPropRecords) {
// Make a copy of the input string, so we can replace the commas with '\0's:
char* inStr = strDup(sPropParameterSetsStr);
if (inStr == NULL) {
numSPropRecords = 0;
return NULL;
}
// Count the number of commas (and thus the number of parameter sets):
numSPropRecords = 1;
char* s;
for (s = inStr; *s != '\0'; ++s) {
if (*s == ',') {
++numSPropRecords;
*s = '\0';
}
}
// Allocate and fill in the result array:
SPropRecord* resultArray = new SPropRecord[numSPropRecords];
s = inStr;
for (unsigned i = 0; i < numSPropRecords; ++i) {
resultArray[i].sPropBytes = base64Decode(s, resultArray[i].sPropLength);
s += strlen(s) + 1;
}
delete[] inStr;
return resultArray;
}
from:http://blog.csdn.net/smilestone_322/article/details/18940005