SegmentQueue Class Reference

Collaboration diagram for SegmentQueue:

[legend]

Public Member Functions
	SegmentQueue (Boolean directionIsToADU, Boolean includeADUdescriptors)
unsigned	headIndex ()
Segment &	headSegment ()
unsigned	nextFreeIndex ()
Segment &	nextFreeSegment ()
Boolean	isEmpty ()
Boolean	isFull ()
unsigned	totalDataSize ()
void	enqueueNewSegment (FramedSource *inputSource, FramedSource *usingSource)
Boolean	dequeue ()
Boolean	insertDummyBeforeTail (unsigned backpointer)
void	reset ()
Static Public Member Functions
static unsigned	nextIndex (unsigned ix)
static unsigned	prevIndex (unsigned ix)
Data Fields
Segment	s [SegmentQueueSize]
Private Member Functions
Boolean	sqAfterGettingCommon (Segment &seg, unsigned numBytesRead)
Boolean	isEmptyOrFull ()
Static Private Member Functions
static void	sqAfterGettingSegment (void *clientData, unsigned numBytesRead, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds)
Private Attributes
unsigned	fHeadIndex
unsigned	fNextFreeIndex
unsigned	fTotalDataSize
FramedSource *	fUsingSource
Boolean	fDirectionIsToADU
Boolean	fIncludeADUdescriptors

---

Detailed Description

Definition at line 54 of file MP3ADU.cpp.

---

Constructor & Destructor Documentation

SegmentQueue::SegmentQueue	(	Boolean	directionIsToADU,
		Boolean	includeADUdescriptors
	)			[inline]

Definition at line 56 of file MP3ADU.cpp.

References reset().

    : fDirectionIsToADU(directionIsToADU),
      fIncludeADUdescriptors(includeADUdescriptors) {
    reset();
  }

---

Member Function Documentation

unsigned SegmentQueue::headIndex

(

)

[inline]

Definition at line 64 of file MP3ADU.cpp.

References fHeadIndex.

Referenced by dequeue(), ADUFromMP3Source::doGetNextFrame1(), MP3FromADUSource::generateFrameFromHeadADU(), MP3FromADUSource::insertDummyADUsIfNecessary(), isEmptyOrFull(), and MP3FromADUSource::needToGetAnADU().

{return fHeadIndex;}

Segment& SegmentQueue::headSegment

(

)

[inline]

Definition at line 65 of file MP3ADU.cpp.

References fHeadIndex, and s.

Referenced by MP3FromADUSource::generateFrameFromHeadADU(), and MP3FromADUSource::needToGetAnADU().

{return s[fHeadIndex];}

unsigned SegmentQueue::nextFreeIndex

(

)

[inline]

Definition at line 67 of file MP3ADU.cpp.

References fNextFreeIndex.

Referenced by ADUFromMP3Source::doGetNextFrame1(), MP3FromADUSource::generateFrameFromHeadADU(), MP3FromADUSource::insertDummyADUsIfNecessary(), insertDummyBeforeTail(), isEmptyOrFull(), and MP3FromADUSource::needToGetAnADU().

{return fNextFreeIndex;}

Segment& SegmentQueue::nextFreeSegment

(

)

[inline]

Definition at line 68 of file MP3ADU.cpp.

References fNextFreeIndex, and s.

Referenced by enqueueNewSegment(), and sqAfterGettingSegment().

{return s[fNextFreeIndex];}

Boolean SegmentQueue::isEmpty

(

)

[inline]

Definition at line 69 of file MP3ADU.cpp.

References isEmptyOrFull(), and totalDataSize().

Referenced by dequeue(), ADUFromMP3Source::doGetNextFrame1(), MP3FromADUSource::generateFrameFromHeadADU(), MP3FromADUSource::insertDummyADUsIfNecessary(), and MP3FromADUSource::needToGetAnADU().

{return isEmptyOrFull() && totalDataSize() == 0;}

Boolean SegmentQueue::isFull

(

)

[inline]

Definition at line 70 of file MP3ADU.cpp.

References isEmptyOrFull(), and totalDataSize().

Referenced by enqueueNewSegment().

{return isEmptyOrFull() && totalDataSize() > 0;}

static unsigned SegmentQueue::nextIndex

(

unsigned

ix

)

[inline, static]

Definition at line 72 of file MP3ADU.cpp.

References SegmentQueueSize.

Referenced by dequeue(), ADUFromMP3Source::doGetNextFrame1(), MP3FromADUSource::generateFrameFromHeadADU(), MP3FromADUSource::needToGetAnADU(), and sqAfterGettingCommon().

{return (ix+1)%SegmentQueueSize;}

static unsigned SegmentQueue::prevIndex

(

unsigned

ix

)

[inline, static]

Definition at line 73 of file MP3ADU.cpp.

References SegmentQueueSize.

Referenced by ADUFromMP3Source::doGetNextFrame1(), MP3FromADUSource::insertDummyADUsIfNecessary(), and insertDummyBeforeTail().

{return (ix+SegmentQueueSize-1)%SegmentQueueSize;}

unsigned SegmentQueue::totalDataSize

(

)

[inline]

Definition at line 75 of file MP3ADU.cpp.

References fTotalDataSize.

Referenced by ADUFromMP3Source::doGetNextFrame(), isEmpty(), and isFull().

{return fTotalDataSize;}

void SegmentQueue::enqueueNewSegment	(	FramedSource *	inputSource,
		FramedSource *	usingSource
	)

Definition at line 512 of file MP3ADU.cpp.

References Segment::buf, Medium::envir(), fUsingSource, FramedSource::getNextFrame(), FramedSource::handleClosure(), isFull(), nextFreeSegment(), and sqAfterGettingSegment().

Referenced by MP3FromADUSource::doGetNextFrame(), and ADUFromMP3Source::doGetNextFrame().

                                                                {
  if (isFull()) {
    usingSource->envir() << "SegmentQueue::enqueueNewSegment() overflow\n";
    FramedSource::handleClosure(usingSource);
    return;
  }

  fUsingSource = usingSource;

  Segment& seg = nextFreeSegment();
  inputSource->getNextFrame(seg.buf, sizeof seg.buf,
                            sqAfterGettingSegment, this,
                            FramedSource::handleClosure, usingSource);
}

Boolean SegmentQueue::dequeue

(

)

Definition at line 588 of file MP3ADU.cpp.

References Segment::dataHere(), Medium::envir(), False, fHeadIndex, fTotalDataSize, fUsingSource, headIndex(), isEmpty(), nextIndex(), s, and True.

Referenced by ADUFromMP3Source::doGetNextFrame1(), and MP3FromADUSource::generateFrameFromHeadADU().

                              {
  if (isEmpty()) {
    fUsingSource->envir() << "SegmentQueue::dequeue(): underflow!\n";
    return False;
  }

  Segment& seg = s[headIndex()];
  fTotalDataSize -= seg.dataHere();
  fHeadIndex = nextIndex(fHeadIndex);
  return True;
}

Boolean SegmentQueue::insertDummyBeforeTail

(

unsigned

backpointer

)

Definition at line 600 of file MP3ADU.cpp.

References Segment::buf, Segment::descriptorSize, False, fIncludeADUdescriptors, Segment::frameSize, ADUdescriptor::generateDescriptor(), ADUdescriptor::generateTwoByteDescriptor(), Segment::headerSize, isEmptyOrFull(), nextFreeIndex(), prevIndex(), s, Segment::sideInfoSize, sqAfterGettingCommon(), and ZeroOutMP3SideInfo().

Referenced by MP3FromADUSource::insertDummyADUsIfNecessary().

                                                                {
  if (isEmptyOrFull()) return False;

  // Copy the current tail segment to its new position, then modify the
  // old tail segment to be a 'dummy' ADU

  unsigned newTailIndex = nextFreeIndex();
  Segment& newTailSeg = s[newTailIndex];

  unsigned oldTailIndex = prevIndex(newTailIndex);
  Segment& oldTailSeg = s[oldTailIndex];

  newTailSeg = oldTailSeg; // structure copy

  // Begin by setting (replacing) the ADU descriptor of the dummy ADU:
  unsigned char* ptr = oldTailSeg.buf;
  if (fIncludeADUdescriptors) {
    unsigned remainingFrameSize
      = oldTailSeg.headerSize + oldTailSeg.sideInfoSize + 0 /* 0-size ADU */;
    unsigned currentDescriptorSize = oldTailSeg.descriptorSize;

    if (currentDescriptorSize == 2) {
      ADUdescriptor::generateTwoByteDescriptor(ptr, remainingFrameSize);
    } else {
      (void)ADUdescriptor::generateDescriptor(ptr, remainingFrameSize);
    }
  }

  // Then zero out the side info of the dummy frame:
  if (!ZeroOutMP3SideInfo(ptr, oldTailSeg.frameSize,
                          backpointer)) return False;

  unsigned dummyNumBytesRead
    = oldTailSeg.descriptorSize + 4/*header size*/ + oldTailSeg.sideInfoSize;
  return sqAfterGettingCommon(oldTailSeg, dummyNumBytesRead);
}

void SegmentQueue::reset

(

)

[inline]

Definition at line 83 of file MP3ADU.cpp.

References fHeadIndex, fNextFreeIndex, and fTotalDataSize.

Referenced by ADUFromMP3Source::resetInput(), and SegmentQueue().

{ fHeadIndex = fNextFreeIndex = fTotalDataSize = 0; }

void SegmentQueue::sqAfterGettingSegment	(	void *	clientData,
		unsigned	numBytesRead,
		unsigned	numTruncatedBytes,
		struct timeval	presentationTime,
		unsigned	durationInMicroseconds
	)			[static, private]

Definition at line 528 of file MP3ADU.cpp.

References Segment::aduSize, Segment::backpointer, Segment::dataHere(), Segment::descriptorSize, FramedSource::doGetNextFrame(), Segment::durationInMicroseconds, fDirectionIsToADU, Segment::frameSize, fUsingSource, nextFreeSegment(), Segment::presentationTime, Segment::sideInfoSize, and sqAfterGettingCommon().

Referenced by enqueueNewSegment().

                                                                          {
  SegmentQueue* segQueue = (SegmentQueue*)clientData;
  Segment& seg = segQueue->nextFreeSegment();

  seg.presentationTime = presentationTime;
  seg.durationInMicroseconds = durationInMicroseconds;

  if (segQueue->sqAfterGettingCommon(seg, numBytesRead)) {
#ifdef DEBUG
    char const* direction = segQueue->fDirectionIsToADU ? "m->a" : "a->m";
    fprintf(stderr, "%s:read frame %d<-%d, fs:%d, sis:%d, dh:%d, (descriptor size: %d)\n", direction, seg.aduSize, seg.backpointer, seg.frameSize, seg.sideInfoSize, seg.dataHere(), seg.descriptorSize);
#endif
  }

  // Continue our original calling source where it left off:
  segQueue->fUsingSource->doGetNextFrame();
}

Boolean SegmentQueue::sqAfterGettingCommon	(	Segment &	seg,
		unsigned	numBytesRead
	)			[private]

Definition at line 551 of file MP3ADU.cpp.

References Segment::aduSize, Segment::backpointer, Segment::buf, Segment::dataHere(), Segment::descriptorSize, False, fDirectionIsToADU, fIncludeADUdescriptors, fNextFreeIndex, Segment::frameSize, fTotalDataSize, GetADUInfoFromMP3Frame(), ADUdescriptor::getRemainingFrameSize(), nextIndex(), Segment::sideInfoSize, and True.

Referenced by insertDummyBeforeTail(), and sqAfterGettingSegment().

                                                                  {
  unsigned char* fromPtr = seg.buf;

  if (fIncludeADUdescriptors) {
    // The newly-read data is assumed to be an ADU with a descriptor
    // in front
    (void)ADUdescriptor::getRemainingFrameSize(fromPtr);
    seg.descriptorSize = (unsigned)(fromPtr-seg.buf);
  } else {
    seg.descriptorSize = 0;
  }

  // parse the MP3-specific info in the frame to get the ADU params
  unsigned hdr;
  MP3SideInfo sideInfo;
  if (!GetADUInfoFromMP3Frame(fromPtr, numBytesRead,
                              hdr, seg.frameSize,
                              sideInfo, seg.sideInfoSize,
                              seg.backpointer, seg.aduSize)) {
    return False;
  }

  // If we've just read an ADU (rather than a regular MP3 frame), then use the
  // entire "numBytesRead" data for the 'aduSize', so that we include any
  // 'ancillary data' that may be present at the end of the ADU:
  if (!fDirectionIsToADU) {
    unsigned newADUSize
      = numBytesRead - seg.descriptorSize - 4/*header size*/ - seg.sideInfoSize;
    if (newADUSize > seg.aduSize) seg.aduSize = newADUSize;
  }
  fTotalDataSize += seg.dataHere();
  fNextFreeIndex = nextIndex(fNextFreeIndex);

  return True;
}

Boolean SegmentQueue::isEmptyOrFull

(

)

[inline, private]

Definition at line 93 of file MP3ADU.cpp.

References headIndex(), and nextFreeIndex().

Referenced by insertDummyBeforeTail(), isEmpty(), and isFull().

{return headIndex() == nextFreeIndex();}

---

Field Documentation

Segment SegmentQueue::s[SegmentQueueSize]

Definition at line 62 of file MP3ADU.cpp.

Referenced by dequeue(), ADUFromMP3Source::doGetNextFrame1(), MP3FromADUSource::generateFrameFromHeadADU(), headSegment(), MP3FromADUSource::insertDummyADUsIfNecessary(), insertDummyBeforeTail(), MP3FromADUSource::needToGetAnADU(), and nextFreeSegment().

unsigned SegmentQueue::fHeadIndex [private]

Definition at line 95 of file MP3ADU.cpp.

Referenced by dequeue(), headIndex(), headSegment(), and reset().

unsigned SegmentQueue::fNextFreeIndex [private]

Definition at line 95 of file MP3ADU.cpp.

Referenced by nextFreeIndex(), nextFreeSegment(), reset(), and sqAfterGettingCommon().

unsigned SegmentQueue::fTotalDataSize [private]

Definition at line 95 of file MP3ADU.cpp.

Referenced by dequeue(), reset(), sqAfterGettingCommon(), and totalDataSize().

FramedSource* SegmentQueue::fUsingSource [private]

Definition at line 98 of file MP3ADU.cpp.

Referenced by dequeue(), enqueueNewSegment(), and sqAfterGettingSegment().

Boolean SegmentQueue::fDirectionIsToADU [private]

Definition at line 102 of file MP3ADU.cpp.

Referenced by sqAfterGettingCommon(), and sqAfterGettingSegment().

Boolean SegmentQueue::fIncludeADUdescriptors [private]

Definition at line 106 of file MP3ADU.cpp.

Referenced by insertDummyBeforeTail(), and sqAfterGettingCommon().

---

The documentation for this class was generated from the following file:

• liveMedia/MP3ADU.cpp

---