ReorderingPacketBuffer Class Reference

Collaboration diagram for ReorderingPacketBuffer:


Public Member Functions
	ReorderingPacketBuffer (BufferedPacketFactory *packetFactory)
virtual	~ReorderingPacketBuffer ()
void	reset ()
BufferedPacket *	getFreePacket (MultiFramedRTPSource *ourSource)
Boolean	storePacket (BufferedPacket *bPacket)
BufferedPacket *	getNextCompletedPacket (Boolean &packetLossPreceded)
void	releaseUsedPacket (BufferedPacket *packet)
void	freePacket (BufferedPacket *packet)
Boolean	isEmpty () const
void	setThresholdTime (unsigned uSeconds)
Private Attributes
BufferedPacketFactory *	fPacketFactory
unsigned	fThresholdTime
Boolean	fHaveSeenFirstPacket
unsigned short	fNextExpectedSeqNo
BufferedPacket *	fHeadPacket
BufferedPacket *	fSavedPacket
Boolean	fSavedPacketFree

Detailed Description

Definition at line 28 of file MultiFramedRTPSource.cpp.

Constructor & Destructor Documentation

ReorderingPacketBuffer::ReorderingPacketBuffer ( BufferedPacketFactory * packetFactory )

Definition at line 441 of file MultiFramedRTPSource.cpp.

References NULL.

00442   : fThresholdTime(100000) /* default reordering threshold: 100 ms */,
00443     fHaveSeenFirstPacket(False), fHeadPacket(NULL), fSavedPacket(NULL), fSavedPacketFree(True) {
00444   fPacketFactory = (packetFactory == NULL)
00445     ? (new BufferedPacketFactory)
00446     : packetFactory;
00447 }

ReorderingPacketBuffer::~ReorderingPacketBuffer ( ) [virtual]

Definition at line 449 of file MultiFramedRTPSource.cpp.

References fPacketFactory, and reset().

00449                                                 {
00450   reset();
00451   delete fPacketFactory;
00452 }

Member Function Documentation

void ReorderingPacketBuffer::reset ( )

Definition at line 454 of file MultiFramedRTPSource.cpp.

References False, fHaveSeenFirstPacket, fHeadPacket, fSavedPacket, fSavedPacketFree, and NULL.

Referenced by MultiFramedRTPSource::doStopGettingFrames(), and ~ReorderingPacketBuffer().

00454                                    {
00455   if (fSavedPacketFree) delete fSavedPacket; // because fSavedPacket is not in the list
00456   delete fHeadPacket; // will also delete fSavedPacket if it's in the list
00457   fHaveSeenFirstPacket = False;
00458   fHeadPacket = NULL;
00459   fSavedPacket = NULL;
00460 }

BufferedPacket * ReorderingPacketBuffer::getFreePacket ( MultiFramedRTPSource * ourSource )

Definition at line 463 of file MultiFramedRTPSource.cpp.

References BufferedPacketFactory::createNewPacket(), False, fPacketFactory, fSavedPacket, fSavedPacketFree, NULL, and True.

Referenced by MultiFramedRTPSource::networkReadHandler().

00463                                                {
00464   if (fSavedPacket == NULL) { // we're being called for the first time
00465     fSavedPacket = fPacketFactory->createNewPacket(ourSource);
00466     fSavedPacketFree = True;
00467   }
00468 
00469   if (fSavedPacketFree == True) {
00470     fSavedPacketFree = False;
00471     return fSavedPacket;
00472   } else {
00473     return fPacketFactory->createNewPacket(ourSource);
00474   }
00475 }

Boolean ReorderingPacketBuffer::storePacket ( BufferedPacket * bPacket )

Definition at line 477 of file MultiFramedRTPSource.cpp.

References False, fHaveSeenFirstPacket, fHeadPacket, fNextExpectedSeqNo, BufferedPacket::isFirstPacket(), BufferedPacket::nextPacket(), NULL, BufferedPacket::rtpSeqNo(), seqNumLT(), and True.

Referenced by MultiFramedRTPSource::networkReadHandler().

00477                                                                    {
00478   unsigned short rtpSeqNo = bPacket->rtpSeqNo();
00479 
00480   if (!fHaveSeenFirstPacket) {
00481     fNextExpectedSeqNo = rtpSeqNo; // initialization
00482     bPacket->isFirstPacket() = True;
00483     fHaveSeenFirstPacket = True;
00484   }
00485 
00486   // Ignore this packet if its sequence number is less than the one
00487   // that we're looking for (in this case, it's been excessively delayed).
00488   // (But (sanity check) if the new packet's sequence number is a *lot*
00489   // less, then accept it anyway.)
00490   unsigned short const seqNoThreshold = 100;
00491   if (seqNumLT(rtpSeqNo, fNextExpectedSeqNo)
00492       && seqNumLT(fNextExpectedSeqNo, rtpSeqNo+seqNoThreshold)) {
00493     return False;
00494   }
00495 
00496   // Figure out where the new packet will be stored in the queue:
00497   BufferedPacket* beforePtr = NULL;
00498   BufferedPacket* afterPtr = fHeadPacket;
00499   while (afterPtr != NULL) {
00500     if (seqNumLT(rtpSeqNo, afterPtr->rtpSeqNo())) break; // it comes here
00501     if (rtpSeqNo == afterPtr->rtpSeqNo()) {
00502       // This is a duplicate packet - ignore it
00503       return False;
00504     }
00505 
00506     beforePtr = afterPtr;
00507     afterPtr = afterPtr->nextPacket();
00508   }
00509 
00510   // Link our new packet between "beforePtr" and "afterPtr":
00511   bPacket->nextPacket() = afterPtr;
00512   if (beforePtr == NULL) {
00513     fHeadPacket = bPacket;
00514   } else {
00515     beforePtr->nextPacket() = bPacket;
00516   }
00517 
00518   return True;
00519 }

BufferedPacket * ReorderingPacketBuffer::getNextCompletedPacket ( Boolean & packetLossPreceded )

Definition at line 533 of file MultiFramedRTPSource.cpp.

References fHeadPacket, fNextExpectedSeqNo, fThresholdTime, BufferedPacket::isFirstPacket(), NULL, BufferedPacket::rtpSeqNo(), BufferedPacket::timeReceived(), and True.

Referenced by MultiFramedRTPSource::doGetNextFrame1().

00533                                                     {
00534   if (fHeadPacket == NULL) return NULL;
00535 
00536   // Check whether the next packet we want is already at the head
00537   // of the queue:
00538   // ASSERT: fHeadPacket->rtpSeqNo() >= fNextExpectedSeqNo
00539   if (fHeadPacket->rtpSeqNo() == fNextExpectedSeqNo) {
00540     packetLossPreceded = fHeadPacket->isFirstPacket();
00541         // (The very first packet is treated as if there was packet loss beforehand.)
00542     return fHeadPacket;
00543   }
00544 
00545   // We're still waiting for our desired packet to arrive.  However, if
00546   // our time threshold has been exceeded, then forget it, and return
00547   // the head packet instead:
00548   struct timeval timeNow;
00549   gettimeofday(&timeNow, NULL);
00550   unsigned uSecondsSinceReceived
00551     = (timeNow.tv_sec - fHeadPacket->timeReceived().tv_sec)*1000000
00552     + (timeNow.tv_usec - fHeadPacket->timeReceived().tv_usec);
00553   if (uSecondsSinceReceived > fThresholdTime) {
00554     fNextExpectedSeqNo = fHeadPacket->rtpSeqNo();
00555         // we've given up on earlier packets now
00556     packetLossPreceded = True;
00557     return fHeadPacket;
00558   }
00559 
00560   // Otherwise, keep waiting for our desired packet to arrive:
00561   return NULL;
00562 }

void ReorderingPacketBuffer::releaseUsedPacket ( BufferedPacket * packet )

Definition at line 521 of file MultiFramedRTPSource.cpp.

References fHeadPacket, fNextExpectedSeqNo, freePacket(), BufferedPacket::nextPacket(), and NULL.

Referenced by MultiFramedRTPSource::doGetNextFrame1().

00521                                                                      {
00522   // ASSERT: packet == fHeadPacket
00523   // ASSERT: fNextExpectedSeqNo == packet->rtpSeqNo()
00524   ++fNextExpectedSeqNo; // because we're finished with this packet now
00525 
00526   fHeadPacket = fHeadPacket->nextPacket();
00527   packet->nextPacket() = NULL;
00528 
00529   freePacket(packet);
00530 }

void ReorderingPacketBuffer::freePacket ( BufferedPacket * packet ) [inline]

Definition at line 38 of file MultiFramedRTPSource.cpp.

References fSavedPacket, fSavedPacketFree, and True.

Referenced by MultiFramedRTPSource::networkReadHandler(), and releaseUsedPacket().

00038                                           {
00039     if (packet != fSavedPacket) {
00040       delete packet;
00041     } else {
00042       fSavedPacketFree = True;
00043     }
00044   }