StreamReplicator Class Reference

#include <StreamReplicator.hh>

Inheritance diagram for StreamReplicator:

Inheritance graph
[legend]
Collaboration diagram for StreamReplicator:

Collaboration graph
[legend]

Public Member Functions

FramedSource * createStreamReplica ()
unsigned numReplicas () const
FramedSource * inputSource () const
void detachInputSource ()
UsageEnvironment & envir () const
char const * name () const
virtual Boolean isSource () const
virtual Boolean isSink () const
virtual Boolean isRTCPInstance () const
virtual Boolean isRTSPClient () const
virtual Boolean isRTSPServer () const
virtual Boolean isMediaSession () const
virtual Boolean isServerMediaSession () const
virtual Boolean isDarwinInjector () const

Static Public Member Functions

static StreamReplicator * createNew (UsageEnvironment &env, FramedSource *inputSource, Boolean deleteWhenLastReplicaDies=True)
static Boolean lookupByName (UsageEnvironment &env, char const *mediumName, Medium *&resultMedium)
static void close (UsageEnvironment &env, char const *mediumName)
static void close (Medium *medium)

Protected Member Functions

 StreamReplicator (UsageEnvironment &env, FramedSource *inputSource, Boolean deleteWhenLastReplicaDies)
virtual ~StreamReplicator ()
TaskToken & nextTask ()

Private Member Functions

void getNextFrame (StreamReplica *replica)
void deactivateStreamReplica (StreamReplica *replica)
void removeStreamReplica (StreamReplica *replica)
void afterGettingFrame (unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds)
void onSourceClosure ()
void deliverReceivedFrame ()

Static Private Member Functions

static void afterGettingFrame (void *clientData, unsigned frameSize, unsigned numTruncatedBytes, struct timeval presentationTime, unsigned durationInMicroseconds)
static void onSourceClosure (void *clientData)

Private Attributes

FramedSource * fInputSource
Boolean fDeleteWhenLastReplicaDies
Boolean fInputSourceHasClosed
unsigned fNumReplicas
unsigned fNumActiveReplicas
unsigned fNumDeliveriesMadeSoFar
int fFrameIndex
StreamReplica * fMasterReplica
StreamReplica * fReplicasAwaitingCurrentFrame
StreamReplica * fReplicasAwaitingNextFrame

Friends

class StreamReplica
class MediaLookupTable

Detailed Description

Definition at line 30 of file StreamReplicator.hh.

Constructor & Destructor Documentation

StreamReplicator::StreamReplicator ( UsageEnvironment &  env,
FramedSource *  inputSource,
Boolean  deleteWhenLastReplicaDies 
) [protected]

Definition at line 53 of file StreamReplicator.cpp.

Referenced by createNew().

00054   : Medium(env),
00055     fInputSource(inputSource), fDeleteWhenLastReplicaDies(deleteWhenLastReplicaDies), fInputSourceHasClosed(False),
00056     fNumReplicas(0), fNumActiveReplicas(0), fNumDeliveriesMadeSoFar(0),
00057     fFrameIndex(0), fMasterReplica(NULL), fReplicasAwaitingCurrentFrame(NULL), fReplicasAwaitingNextFrame(NULL) {
00058 }

StreamReplicator::~StreamReplicator (  )  [protected, virtual]

Definition at line 60 of file StreamReplicator.cpp.

References Medium::close(), and fInputSource.

00060                                     {
00061   Medium::close(fInputSource);
00062 }

Member Function Documentation

StreamReplicator * StreamReplicator::createNew ( UsageEnvironment &  env,
FramedSource *  inputSource,
Boolean  deleteWhenLastReplicaDies = True 
) [static]

Definition at line 49 of file StreamReplicator.cpp.

References env, inputSource(), and StreamReplicator().

Referenced by main().

00049                                                                                                                                  {
00050   return new StreamReplicator(env, inputSource, deleteWhenLastReplicaDies);
00051 }

FramedSource * StreamReplicator::createStreamReplica (  ) 

Definition at line 64 of file StreamReplicator.cpp.

References fNumReplicas, and StreamReplica.

Referenced by startReplicaFileSink(), and startReplicaUDPSink().

00064                                                     {
00065   ++fNumReplicas;
00066   return new StreamReplica(*this);
00067 }

unsigned StreamReplicator::numReplicas (  )  const [inline]

Definition at line 42 of file StreamReplicator.hh.

References fNumReplicas.

00042 { return fNumReplicas; }

FramedSource* StreamReplicator::inputSource (  )  const [inline]

Definition at line 44 of file StreamReplicator.hh.

References fInputSource.

Referenced by createNew(), and T140TextMatroskaFileServerMediaSubsession::seekStreamSource().

00044 { return fInputSource; }

void StreamReplicator::detachInputSource (  )  [inline]

Definition at line 47 of file StreamReplicator.hh.

References fInputSource, and NULL.

00047 { fInputSource = NULL; }

void StreamReplicator::getNextFrame ( StreamReplica *  replica  )  [private]

Definition at line 69 of file StreamReplicator.cpp.

References afterGettingFrame(), deliverReceivedFrame(), fFrameIndex, StreamReplica::fFrameIndex, fInputSource, fInputSourceHasClosed, fMasterReplica, FramedSource::fMaxSize, StreamReplica::fNext, fNumActiveReplicas, fReplicasAwaitingCurrentFrame, fReplicasAwaitingNextFrame, FramedSource::fTo, FramedSource::getNextFrame(), FramedSource::handleClosure(), FramedSource::isCurrentlyAwaitingData(), NULL, and onSourceClosure().

Referenced by StreamReplica::doGetNextFrame().

00069                                                           {
00070   if (fInputSourceHasClosed) { // handle closure instead
00071     FramedSource::handleClosure(replica);
00072     return;
00073   }
00074 
00075   if (replica->fFrameIndex == -1) {
00076     // This replica had stopped playing (or had just been created), but is now actively reading.  Note this:
00077     replica->fFrameIndex = fFrameIndex;
00078     ++fNumActiveReplicas;
00079   }
00080 
00081   if (fMasterReplica == NULL) {
00082     // This is the first replica to request the next unread frame.  Make it the 'master' replica - meaning that we read the frame
00083     // into its buffer, and then copy from this into the other replicas' buffers.
00084     fMasterReplica = replica;
00085 
00086     // Arrange to read the next frame into this replica's buffer:
00087     if (fInputSource != NULL) fInputSource->getNextFrame(fMasterReplica->fTo, fMasterReplica->fMaxSize,
00088                                                          afterGettingFrame, this, onSourceClosure, this);
00089   } else if (replica->fFrameIndex != fFrameIndex) {
00090     // This replica is already asking for the next frame (because it has already received the current frame).  Enqueue it:
00091     replica->fNext = fReplicasAwaitingNextFrame;
00092     fReplicasAwaitingNextFrame = replica;
00093   } else {
00094     // This replica is asking for the current frame.  Enqueue it:
00095     replica->fNext = fReplicasAwaitingCurrentFrame;
00096     fReplicasAwaitingCurrentFrame = replica;
00097 
00098     if (fInputSource != NULL && !fInputSource->isCurrentlyAwaitingData()) {
00099       // The current frame has already arrived, so deliver it to this replica now:
00100       deliverReceivedFrame();
00101     }
00102   }
00103 }

void StreamReplicator::deactivateStreamReplica ( StreamReplica *  replica  )  [private]

Definition at line 105 of file StreamReplicator.cpp.

References afterGettingFrame(), StreamReplica::copyReceivedFrame(), fInputSource, fMasterReplica, FramedSource::fMaxSize, StreamReplica::fNext, fNumActiveReplicas, fNumReplicas, fReplicasAwaitingCurrentFrame, fReplicasAwaitingNextFrame, FramedSource::fTo, FramedSource::getNextFrame(), FramedSource::isCurrentlyAwaitingData(), NULL, onSourceClosure(), and FramedSource::stopGettingFrames().

Referenced by StreamReplica::doStopGettingFrames(), and removeStreamReplica().

00105                                                                                      {
00106   // Assert: fNumActiveReplicas > 0
00107   if (fNumReplicas == 0) fprintf(stderr, "StreamReplicator::deactivateStreamReplica() Internal Error!\n"); // should not happen
00108   --fNumActiveReplicas;
00109 
00110   // Check whether the replica being deactivated is the 'master' replica, or is enqueued awaiting a frame:
00111   if (replicaBeingDeactivated == fMasterReplica) {
00112     // We need to replace the 'master replica', if we can:
00113     if (fReplicasAwaitingCurrentFrame == NULL) {
00114       // There's currently no replacement 'master replica'
00115       fMasterReplica = NULL;
00116     } else {
00117       // There's another replica that we can use as a replacement 'master replica':
00118       fMasterReplica = fReplicasAwaitingCurrentFrame;
00119       fReplicasAwaitingCurrentFrame = fReplicasAwaitingCurrentFrame->fNext;
00120       fMasterReplica->fNext = NULL;
00121     }
00122 
00123     // Check whether the read into the old master replica's buffer is still pending, or has completed:
00124     if (fInputSource != NULL) {
00125       if (fInputSource->isCurrentlyAwaitingData()) {
00126         // We have a pending read into the old master replica's buffer.
00127         // We need to stop it, and retry the read with a new master (if available)
00128         fInputSource->stopGettingFrames();
00129 
00130         if (fMasterReplica != NULL) {
00131           fInputSource->getNextFrame(fMasterReplica->fTo, fMasterReplica->fMaxSize,
00132                                      afterGettingFrame, this, onSourceClosure, this);
00133         }
00134       } else {
00135         // The read into the old master replica's buffer has already completed.  Copy the data to the new master replica (if any):
00136         if (fMasterReplica != NULL) {
00137           StreamReplica::copyReceivedFrame(fMasterReplica, replicaBeingDeactivated);
00138         } else {
00139           // We don't have a new master replica, so we can't copy the received frame to any new replica that might ask for it.
00140           // Fortunately this should be a very rare occurrence.
00141         }
00142       }
00143     }
00144   } else {
00145     // The replica that's being removed was not our 'master replica', but make sure it's not on either of our queues:
00146     if (fReplicasAwaitingCurrentFrame != NULL) {
00147       if (replicaBeingDeactivated == fReplicasAwaitingCurrentFrame) {
00148         fReplicasAwaitingCurrentFrame = replicaBeingDeactivated->fNext;
00149         replicaBeingDeactivated->fNext = NULL;
00150       }
00151       else {
00152         for (StreamReplica* r1 = fReplicasAwaitingCurrentFrame; r1->fNext != NULL; r1 = r1->fNext) {
00153           if (r1->fNext == replicaBeingDeactivated) {
00154             r1->fNext = replicaBeingDeactivated->fNext;
00155             replicaBeingDeactivated->fNext = NULL;
00156             break;
00157           }
00158         }
00159       }
00160     }
00161     if (fReplicasAwaitingNextFrame != NULL) {
00162       if (replicaBeingDeactivated == fReplicasAwaitingNextFrame) {
00163         fReplicasAwaitingNextFrame = replicaBeingDeactivated->fNext;
00164         replicaBeingDeactivated->fNext = NULL;
00165       }
00166       else {
00167         for (StreamReplica* r2 = fReplicasAwaitingNextFrame; r2->fNext != NULL; r2 = r2->fNext) {
00168           if (r2->fNext == replicaBeingDeactivated) {
00169             r2->fNext = replicaBeingDeactivated->fNext;
00170             replicaBeingDeactivated->fNext = NULL;
00171             break;
00172           }
00173         }
00174       }
00175     }
00176   }
00177 }

void StreamReplicator::removeStreamReplica ( StreamReplica *  replica  )  [private]

Definition at line 179 of file StreamReplicator.cpp.

References deactivateStreamReplica(), fDeleteWhenLastReplicaDies, StreamReplica::fFrameIndex, and fNumReplicas.

Referenced by StreamReplica::~StreamReplica().

00179                                                                              {
00180   // Assert: fNumReplicas > 0
00181   if (fNumReplicas == 0) fprintf(stderr, "StreamReplicator::removeStreamReplica() Internal Error!\n"); // should not happen
00182   --fNumReplicas;
00183 
00184   // If this was the last replica, then delete ourselves (if we were set up to do so):
00185   if (fNumReplicas == 0 && fDeleteWhenLastReplicaDies) {
00186     delete this;
00187     return;
00188   }
00189 
00190   // Now handle the replica that's being removed the same way that we would if it were merely being deactivated:
00191   if (replicaBeingRemoved->fFrameIndex != -1) { // i.e., we haven't already done this
00192     deactivateStreamReplica(replicaBeingRemoved);
00193   }
00194 }

void StreamReplicator::afterGettingFrame ( void *  clientData,
unsigned  frameSize,
unsigned  numTruncatedBytes,
struct timeval  presentationTime,
unsigned  durationInMicroseconds 
) [static, private]

Definition at line 196 of file StreamReplicator.cpp.

Referenced by deactivateStreamReplica(), deliverReceivedFrame(), and getNextFrame().

00197                                                                                                            {
00198   ((StreamReplicator*)clientData)->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
00199 }

void StreamReplicator::afterGettingFrame ( unsigned  frameSize,
unsigned  numTruncatedBytes,
struct timeval  presentationTime,
unsigned  durationInMicroseconds 
) [private]

Definition at line 201 of file StreamReplicator.cpp.

References deliverReceivedFrame(), FramedSource::fDurationInMicroseconds, FramedSource::fFrameSize, fMasterReplica, FramedSource::fNumTruncatedBytes, and FramedSource::fPresentationTime.

00202                                                                                                            {
00203   // The frame was read into our master replica's buffer.  Update the master replica's state, but don't complete delivery to it
00204   // just yet.  We do that later, after we're sure that we've delivered it to all other replicas.
00205   fMasterReplica->fFrameSize = frameSize;
00206   fMasterReplica->fNumTruncatedBytes = numTruncatedBytes;
00207   fMasterReplica->fPresentationTime = presentationTime;
00208   fMasterReplica->fDurationInMicroseconds = durationInMicroseconds;
00209 
00210   deliverReceivedFrame();
00211 }

void StreamReplicator::onSourceClosure ( void *  clientData  )  [static, private]

Definition at line 213 of file StreamReplicator.cpp.

00213                                                        {
00214   ((StreamReplicator*)clientData)->onSourceClosure();
00215 }

void StreamReplicator::onSourceClosure (  )  [private]

Definition at line 217 of file StreamReplicator.cpp.

References fInputSourceHasClosed, fMasterReplica, StreamReplica::fNext, fReplicasAwaitingCurrentFrame, fReplicasAwaitingNextFrame, FramedSource::handleClosure(), NULL, and True.

Referenced by deactivateStreamReplica(), deliverReceivedFrame(), and getNextFrame().

00217                                        {
00218   fInputSourceHasClosed = True;
00219 
00220   // Signal the closure to each replica that is currently awaiting a frame:
00221   StreamReplica* replica;
00222   while ((replica = fReplicasAwaitingCurrentFrame) != NULL) {
00223     fReplicasAwaitingCurrentFrame = replica->fNext;
00224     replica->fNext = NULL;
00225     FramedSource::handleClosure(replica);
00226   }
00227   while ((replica = fReplicasAwaitingNextFrame) != NULL) {
00228     fReplicasAwaitingNextFrame = replica->fNext;
00229     replica->fNext = NULL;
00230     FramedSource::handleClosure(replica);
00231   }
00232   if ((replica = fMasterReplica) != NULL) {
00233     fMasterReplica = NULL;
00234     FramedSource::handleClosure(replica);
00235   }
00236 }

void StreamReplicator::deliverReceivedFrame (  )  [private]

Definition at line 238 of file StreamReplicator.cpp.

References FramedSource::afterGetting(), afterGettingFrame(), StreamReplica::copyReceivedFrame(), fFrameIndex, StreamReplica::fFrameIndex, fInputSource, fMasterReplica, FramedSource::fMaxSize, StreamReplica::fNext, fNumActiveReplicas, fNumDeliveriesMadeSoFar, fReplicasAwaitingCurrentFrame, fReplicasAwaitingNextFrame, FramedSource::fTo, FramedSource::getNextFrame(), NULL, and onSourceClosure().

Referenced by afterGettingFrame(), and getNextFrame().

00238                                             {
00239   // The 'master replica' has received its copy of the current frame.
00240   // Copy it (and complete delivery) to any other replica that has requested this frame.
00241   // Then, if no more requests for this frame are expected, complete delivery to the 'master replica' itself.
00242   StreamReplica* replica;
00243   while ((replica = fReplicasAwaitingCurrentFrame) != NULL) {
00244     fReplicasAwaitingCurrentFrame = replica->fNext;
00245     replica->fNext = NULL;
00246     
00247     // Assert: fMasterReplica != NULL
00248     if (fMasterReplica == NULL) fprintf(stderr, "StreamReplicator::deliverReceivedFrame() Internal Error 1!\n"); // shouldn't happen
00249     StreamReplica::copyReceivedFrame(replica, fMasterReplica);
00250     replica->fFrameIndex = 1 - replica->fFrameIndex; // toggle it (0<->1), because this replica no longer awaits the current frame
00251     ++fNumDeliveriesMadeSoFar;
00252 
00253     // Assert: fNumDeliveriesMadeSoFar < fNumActiveReplicas; // because we still have the 'master replica' to deliver to
00254     if (!(fNumDeliveriesMadeSoFar < fNumActiveReplicas)) fprintf(stderr, "StreamReplicator::deliverReceivedFrame() Internal Error 2(%d,%d)!\n", fNumDeliveriesMadeSoFar, fNumActiveReplicas); // should not happen
00255 
00256     // Complete delivery to this replica:
00257     FramedSource::afterGetting(replica);
00258   }
00259 
00260   if (fNumDeliveriesMadeSoFar == fNumActiveReplicas - 1 && fMasterReplica != NULL) {
00261     // No more requests for this frame are expected, so complete delivery to the 'master replica':
00262     replica = fMasterReplica;
00263     fMasterReplica = NULL;
00264     replica->fFrameIndex = 1 - replica->fFrameIndex; // toggle it (0<->1), because this replica no longer awaits the current frame
00265     fFrameIndex = 1 - fFrameIndex; // toggle it (0<->1) for the next frame
00266     fNumDeliveriesMadeSoFar = 0; // reset for the next frame
00267 
00268     if (fReplicasAwaitingNextFrame != NULL) {
00269       // One of the other replicas has already requested the next frame, so make it the next 'master replica':
00270       fMasterReplica = fReplicasAwaitingNextFrame;
00271       fReplicasAwaitingNextFrame = fReplicasAwaitingNextFrame->fNext;
00272       fMasterReplica->fNext = NULL;
00273 
00274       // Arrange to read the next frame into this replica's buffer:
00275       if (fInputSource != NULL) fInputSource->getNextFrame(fMasterReplica->fTo, fMasterReplica->fMaxSize,
00276                                                            afterGettingFrame, this, onSourceClosure, this);
00277     }      
00278 
00279     // Move any other replicas that had already requested the next frame to the 'requesting current frame' list:
00280     // Assert: fReplicasAwaitingCurrentFrame == NULL;
00281     if (!(fReplicasAwaitingCurrentFrame == NULL)) fprintf(stderr, "StreamReplicator::deliverReceivedFrame() Internal Error 3!\n"); // should not happen
00282     fReplicasAwaitingCurrentFrame = fReplicasAwaitingNextFrame;
00283     fReplicasAwaitingNextFrame = NULL;
00284     
00285     FramedSource::afterGetting(replica);
00286   }
00287 }

Boolean Medium::lookupByName ( UsageEnvironment &  env,
char const *  mediumName,
Medium *&  resultMedium 
) [static, inherited]

Definition at line 41 of file Media.cpp.

References env, False, MediaLookupTable::lookup(), NULL, MediaLookupTable::ourMedia(), UsageEnvironment::setResultMsg(), and True.

Referenced by ServerMediaSession::lookupByName(), RTSPServer::lookupByName(), RTSPClient::lookupByName(), RTCPInstance::lookupByName(), MediaSource::lookupByName(), MediaSink::lookupByName(), MediaSession::lookupByName(), and DarwinInjector::lookupByName().

00042                                                          {
00043   resultMedium = MediaLookupTable::ourMedia(env)->lookup(mediumName);
00044   if (resultMedium == NULL) {
00045     env.setResultMsg("Medium ", mediumName, " does not exist");
00046     return False;
00047   }
00048 
00049   return True;
00050 }

void Medium::close ( UsageEnvironment &  env,
char const *  mediumName 
) [static, inherited]

Definition at line 52 of file Media.cpp.

References env, MediaLookupTable::ourMedia(), and MediaLookupTable::remove().

Referenced by afterPlaying(), Medium::close(), closeMediaSinks(), OnDemandServerMediaSubsession::closeStreamSource(), continueAfterTEARDOWN(), WAVAudioFileSource::createNew(), QuickTimeFileSink::createNew(), QCELPAudioRTPSource::createNew(), MP3FileSource::createNew(), AVIFileSink::createNew(), AMRAudioRTPSource::createNew(), WAVAudioFileServerMediaSubsession::createNewStreamSource(), MPEG1or2DemuxedServerMediaSubsession::createNewStreamSource(), MediaSubsession::deInitiate(), RTSPServerSupportingHTTPStreaming::RTSPClientSessionSupportingHTTPStreaming::handleHTTPCmd_StreamingGET(), MediaSubsession::initiate(), MPEG1or2ProgramStreamFileDuration(), MPEG1or2Demux::noteElementaryStreamDeletion(), ByteStreamMultiFileSource::onSourceClosure1(), StreamState::reclaim(), RTSPServer::removeServerMediaSession(), OnDemandServerMediaSubsession::sdpLines(), shutdownStream(), subsessionAfterPlaying(), ClientTrickPlayState::updateStateOnScaleChange(), AMRDeinterleaver::~AMRDeinterleaver(), ByteStreamMultiFileSource::~ByteStreamMultiFileSource(), DarwinInjector::~DarwinInjector(), FramedFilter::~FramedFilter(), H264VideoRTPSink::~H264VideoRTPSink(), InputESSourceRecord::~InputESSourceRecord(), MatroskaFileParser::~MatroskaFileParser(), MatroskaFileServerDemux::~MatroskaFileServerDemux(), MPEG1or2Demux::~MPEG1or2Demux(), MPEG1or2FileServerDemux::~MPEG1or2FileServerDemux(), MPEG2TransportFileServerMediaSubsession::~MPEG2TransportFileServerMediaSubsession(), MPEG2TransportStreamFromPESSource::~MPEG2TransportStreamFromPESSource(), ProxyServerMediaSession::~ProxyServerMediaSession(), RTSPServerSupportingHTTPStreaming::RTSPClientSessionSupportingHTTPStreaming::~RTSPClientSessionSupportingHTTPStreaming(), ServerMediaSession::~ServerMediaSession(), ServerMediaSubsession::~ServerMediaSubsession(), StreamClientState::~StreamClientState(), ~StreamReplicator(), and T140TextRTPSink::~T140TextRTPSink().

00052                                                           {
00053   MediaLookupTable::ourMedia(env)->remove(name);
00054 }

void Medium::close ( Medium *  medium  )  [static, inherited]

Definition at line 56 of file Media.cpp.

References Medium::close(), Medium::envir(), Medium::name(), and NULL.

00056                                  {
00057   if (medium == NULL) return;
00058 
00059   close(medium->envir(), medium->name());
00060 }

UsageEnvironment& Medium::envir (  )  const [inline, inherited]

Definition at line 59 of file Media.hh.

References Medium::fEnviron.

Referenced by QuickTimeFileSink::addArbitraryString(), FileSink::addData(), RTCPInstance::addStreamSocket(), MPEG2IFrameIndexFromTransportStream::addToTail(), StreamParser::afterGettingBytes1(), DummySink::afterGettingFrame(), TCPStreamSink::afterGettingFrame(), T140IdleFilter::afterGettingFrame(), FileSink::afterGettingFrame(), MultiFramedRTPSink::afterGettingFrame1(), InputESSourceRecord::afterGettingFrame1(), MPEG2TransportStreamFramer::afterGettingFrame1(), MPEG2IFrameIndexFromTransportStream::afterGettingFrame1(), H264VideoStreamDiscreteFramer::afterGettingFrame1(), BasicUDPSink::afterGettingFrame1(), MPEG4VideoFileServerMediaSubsession::afterPlayingDummy1(), H264VideoFileServerMediaSubsession::afterPlayingDummy1(), MPEG4VideoStreamParser::analyzeVOLHeader(), announceStream(), RTSPServer::RTSPClientSession::changeClientInputSocket(), MPEG4VideoFileServerMediaSubsession::checkForAuxSDPLine1(), H264VideoFileServerMediaSubsession::checkForAuxSDPLine1(), Medium::close(), ProxyServerMediaSubsession::closeStreamSource(), MPEG2IFrameIndexFromTransportStream::compactParseBuffer(), RTSPClient::connectionHandler1(), RTSPClient::connectToServer(), ProxyServerMediaSession::continueAfterDESCRIBE(), ProxyRTSPClient::continueAfterOPTIONS(), ProxyRTSPClient::continueAfterSETUP(), T140TextRTPSink::continuePlaying(), QuickTimeFileSink::continuePlaying(), H264VideoRTPSink::continuePlaying(), AVIFileSink::continuePlaying(), VP8VideoMatroskaFileServerMediaSubsession::createNewRTPSink(), VorbisAudioMatroskaFileServerMediaSubsession::createNewRTPSink(), T140TextMatroskaFileServerMediaSubsession::createNewRTPSink(), ProxyServerMediaSubsession::createNewRTPSink(), MPEG4VideoFileServerMediaSubsession::createNewRTPSink(), MPEG2TransportUDPServerMediaSubsession::createNewRTPSink(), MPEG2TransportFileServerMediaSubsession::createNewRTPSink(), MPEG1or2VideoFileServerMediaSubsession::createNewRTPSink(), MPEG1or2DemuxedServerMediaSubsession::createNewRTPSink(), MP3AudioFileServerMediaSubsession::createNewRTPSink(), H264VideoFileServerMediaSubsession::createNewRTPSink(), H263plusVideoFileServerMediaSubsession::createNewRTPSink(), DVVideoFileServerMediaSubsession::createNewRTPSink(), AMRAudioFileServerMediaSubsession::createNewRTPSink(), ADTSAudioFileServerMediaSubsession::createNewRTPSink(), AC3AudioMatroskaFileServerMediaSubsession::createNewRTPSink(), AC3AudioFileServerMediaSubsession::createNewRTPSink(), AACAudioMatroskaFileServerMediaSubsession::createNewRTPSink(), ProxyServerMediaSubsession::createNewStreamSource(), MPEG4VideoFileServerMediaSubsession::createNewStreamSource(), MPEG2TransportUDPServerMediaSubsession::createNewStreamSource(), MPEG2TransportFileServerMediaSubsession::createNewStreamSource(), MPEG1or2VideoFileServerMediaSubsession::createNewStreamSource(), MPEG1or2DemuxedServerMediaSubsession::createNewStreamSource(), MP3AudioFileServerMediaSubsession::createNewStreamSource(), H264VideoMatroskaFileServerMediaSubsession::createNewStreamSource(), H264VideoFileServerMediaSubsession::createNewStreamSource(), H263plusVideoFileServerMediaSubsession::createNewStreamSource(), DVVideoFileServerMediaSubsession::createNewStreamSource(), AMRAudioFileServerMediaSubsession::createNewStreamSource(), ADTSAudioFileServerMediaSubsession::createNewStreamSource(), AC3AudioFileServerMediaSubsession::createNewStreamSource(), AMRDeinterleavingBuffer::deliverIncomingFrame(), MPEG2IFrameIndexFromTransportStream::deliverIndexRecord(), SegmentQueue::dequeue(), DeviceSource::DeviceSource(), WAVAudioFileSource::doGetNextFrame(), T140IdleFilter::doGetNextFrame(), MPEG2IFrameIndexFromTransportStream::doGetNextFrame(), MP3FileSource::doGetNextFrame(), H264FUAFragmenter::doGetNextFrame(), ByteStreamMultiFileSource::doGetNextFrame(), ByteStreamFileSource::doGetNextFrame(), BasicUDPSource::doGetNextFrame(), AMRAudioFileSource::doGetNextFrame(), ADTSAudioFileSource::doGetNextFrame(), MultiFramedRTPSource::doGetNextFrame1(), MP3FileSource::doGetNextFrame1(), ADUFromMP3Source::doGetNextFrame1(), SIPClient::doInviteStateMachine(), WAVAudioFileSource::doReadFromFile(), ByteStreamFileSource::doReadFromFile(), MPEG1or2VideoRTPSink::doSpecialFrameHandling(), MP3ADURTPSink::doSpecialFrameHandling(), H263plusVideoRTPSink::doSpecialFrameHandling(), WAVAudioFileSource::doStopGettingFrames(), T140IdleFilter::doStopGettingFrames(), ByteStreamFileSource::doStopGettingFrames(), BasicUDPSource::doStopGettingFrames(), SegmentQueue::enqueueNewSegment(), StreamParser::ensureValidBytes1(), MediaSubsession::env(), SubsessionIOState::envir(), RTSPServer::RTSPClientSession::envir(), RTPInterface::envir(), AVISubsessionIOState::envir(), ServerMediaSession::generateSDPDescription(), RTPSource::getAttributes(), MP3FileSource::getAttributes(), MP3ADUTranscoder::getAttributes(), MediaSource::getAttributes(), MPEG4VideoFileServerMediaSubsession::getAuxSDPLine(), H264VideoFileServerMediaSubsession::getAuxSDPLine(), getMPEG1or2TimeCode(), FramedSource::getNextFrame(), getOptions(), DVVideoStreamFramer::getProfile(), SIPClient::getResponse(), SIPClient::getResponseCode(), getSDPDescription(), OnDemandServerMediaSubsession::getStreamParameters(), RTSPClient::handleGET_PARAMETERResponse(), RTSPServerSupportingHTTPStreaming::RTSPClientSessionSupportingHTTPStreaming::handleHTTPCmd_StreamingGET(), RTSPClient::handleIncomingRequest(), RTSPClient::handlePLAYResponse(), RTSPClient::handleRequestError(), RTSPClient::handleResponseBytes(), RTSPClient::handleSETUPResponse(), RTSPServer::incomingConnectionHandler(), RTSPClient::incomingDataHandler1(), RTCPInstance::incomingReportHandler1(), MP3FileSource::initializeStream(), MediaSession::initializeWithSDP(), MediaSession::initiateByMediaType(), SIPClient::invite1(), DynamicRTSPServer::lookupServerMediaSession(), MatroskaDemux::MatroskaDemux(), MatroskaFile::MatroskaFile(), MPEG4GenericRTPSource::MPEG4GenericRTPSource(), MatroskaDemux::newDemuxedTrack(), MPEG1or2FileServerDemux::newElementaryStream(), MPEG1or2Demux::newElementaryStream(), MPEG4GenericBufferedPacket::nextEnclosedFrameSize(), AMRBufferedPacket::nextEnclosedFrameSize(), T140IdleFilter::onSourceClosure(), RTSPClient::openConnection(), MPEG2TransportStreamIndexFile::openFid(), MPEG2IFrameIndexFromTransportStream::parseFrame(), AC3AudioStreamParser::parseFrame(), MPEGProgramStreamParser::parsePackHeader(), MPEGProgramStreamParser::parsePESPacket(), SIPClient::parseResponseCode(), MediaSession::parseSDPLine(), MPEG1or2VideoStreamParser::parseSlice(), MatroskaFileParser::parseStartOfFile(), MPEGProgramStreamParser::parseSystemHeader(), MPEG4VideoStreamParser::parseVideoObjectLayer(), MPEG4VideoStreamParser::parseVideoObjectPlane(), MPEG4VideoStreamParser::parseVisualObject(), TCPStreamSink::processBuffer(), SIPClient::processURL(), AC3AudioStreamParser::readAndSaveAFrame(), MPEG1or2Demux::registerReadInterest(), RTCPInstance::reschedule(), RTSPClient::resendCommand(), ProxyRTSPClient::reset(), RTSPClient::resetTCPSockets(), RTSPClient::responseHandlerForHTTP_GET1(), RTSPServer::rtspURLPrefix(), RTCPInstance::schedule(), ProxyRTSPClient::scheduleDESCRIBECommand(), ProxyRTSPClient::scheduleLivenessCommand(), OnDemandServerMediaSubsession::sdpLines(), SIPClient::sendACK(), SIPClient::sendBYE(), SIPClient::sendINVITE(), MultiFramedRTPSink::sendPacketIfNecessary(), SIPClient::sendRequest(), RTSPClient::sendRequest(), DarwinInjector::setDestination(), RTSPClient::setupHTTPTunneling1(), setupNextSubsession(), RTSPServer::setUpTunnelingOverHTTP(), QuickTimeFileSink::setWord(), AVIFileSink::setWord(), QuickTimeFileSink::setWord64(), shutdownStream(), SIPClient::SIPClient(), TCPStreamSink::socketWritableHandler1(), AMRAudioRTPSink::sourceIsCompatibleWithUs(), QuickTimeFileSink::startPlaying(), StreamState::startPlaying(), MediaSink::startPlaying(), AVIFileSink::startPlaying(), startPlayingSession(), PassiveServerMediaSubsession::startStream(), MediaSink::stopPlaying(), ProxyServerMediaSubsession::subsessionByeHandler(), tearDownSession(), SIPClient::timerAHandler(), SIPClient::timerBHandler(), SIPClient::timerDHandler(), ClientTrickPlayState::updateStateOnScaleChange(), MPEG2TransportStreamFramer::updateTSPacketDurationEstimate(), BasicUDPSource::~BasicUDPSource(), ByteStreamFileSource::~ByteStreamFileSource(), DeviceSource::~DeviceSource(), RTSPServer::~RTSPServer(), StreamClientState::~StreamClientState(), T140IdleFilter::~T140IdleFilter(), and WAVAudioFileSource::~WAVAudioFileSource().

00059 {return fEnviron;}

char const* Medium::name (  )  const [inline, inherited]

Definition at line 61 of file Media.hh.

References Medium::fMediumName.

Referenced by QuickTimeFileSink::addAtom_hdlr2(), Medium::close(), MP3ADUTranscoder::createNew(), MP3FromADUSource::createNew(), ADUFromMP3Source::createNew(), and MP3FileSource::initializeStream().

00061 {return fMediumName;}

Boolean Medium::isSource (  )  const [virtual, inherited]

Reimplemented in MediaSource.

Definition at line 62 of file Media.cpp.

References False.

Referenced by MediaSource::lookupByName().

00062                                {
00063   return False; // default implementation
00064 }

Boolean Medium::isSink (  )  const [virtual, inherited]

Reimplemented in MediaSink.

Definition at line 66 of file Media.cpp.

References False.

Referenced by MediaSink::lookupByName().

00066                              {
00067   return False; // default implementation
00068 }

Boolean Medium::isRTCPInstance (  )  const [virtual, inherited]

Reimplemented in RTCPInstance.

Definition at line 70 of file Media.cpp.

References False.

Referenced by RTCPInstance::lookupByName().

00070                                      {
00071   return False; // default implementation
00072 }

Boolean Medium::isRTSPClient (  )  const [virtual, inherited]

Reimplemented in RTSPClient.

Definition at line 74 of file Media.cpp.

References False.

Referenced by RTSPClient::lookupByName().

00074                                    {
00075   return False; // default implementation
00076 }

Boolean Medium::isRTSPServer (  )  const [virtual, inherited]

Reimplemented in RTSPServer.

Definition at line 78 of file Media.cpp.

References False.

Referenced by RTSPServer::lookupByName().

00078                                    {
00079   return False; // default implementation
00080 }

Boolean Medium::isMediaSession (  )  const [virtual, inherited]

Reimplemented in MediaSession.

Definition at line 82 of file Media.cpp.

References False.

Referenced by MediaSession::lookupByName().

00082                                      {
00083   return False; // default implementation
00084 }

Boolean Medium::isServerMediaSession (  )  const [virtual, inherited]

Reimplemented in ServerMediaSession.

Definition at line 86 of file Media.cpp.

References False.

Referenced by ServerMediaSession::lookupByName().

00086                                            {
00087   return False; // default implementation
00088 }

Boolean Medium::isDarwinInjector (  )  const [virtual, inherited]

Reimplemented in DarwinInjector.

Definition at line 90 of file Media.cpp.

References False.

Referenced by DarwinInjector::lookupByName().

00090                                        {
00091   return False; // default implementation
00092 }

TaskToken& Medium::nextTask (  )  [inline, protected, inherited]

Definition at line 78 of file Media.hh.

References Medium::fNextTask.

Referenced by BasicUDPSink::afterGettingFrame1(), MPEG4VideoFileServerMediaSubsession::afterPlayingDummy1(), H264VideoFileServerMediaSubsession::afterPlayingDummy1(), MPEG4VideoFileServerMediaSubsession::checkForAuxSDPLine1(), H264VideoFileServerMediaSubsession::checkForAuxSDPLine1(), MP3FileSource::doGetNextFrame(), AMRAudioFileSource::doGetNextFrame(), ADTSAudioFileSource::doGetNextFrame(), MultiFramedRTPSource::doGetNextFrame1(), WAVAudioFileSource::doReadFromFile(), ByteStreamFileSource::doReadFromFile(), RTCPInstance::reschedule(), RTCPInstance::schedule(), MultiFramedRTPSink::sendPacketIfNecessary(), and MediaSink::stopPlaying().

00078                         {
00079         return fNextTask;
00080   }

Friends And Related Function Documentation

friend class StreamReplica [friend]

Definition at line 56 of file StreamReplicator.hh.

Referenced by createStreamReplica().

friend class MediaLookupTable [friend, inherited]

Definition at line 74 of file Media.hh.

Field Documentation

FramedSource* StreamReplicator::fInputSource [private]

Definition at line 75 of file StreamReplicator.hh.

Referenced by deactivateStreamReplica(), deliverReceivedFrame(), detachInputSource(), getNextFrame(), inputSource(), and ~StreamReplicator().

Boolean StreamReplicator::fDeleteWhenLastReplicaDies [private]

Definition at line 76 of file StreamReplicator.hh.

Referenced by removeStreamReplica().

Boolean StreamReplicator::fInputSourceHasClosed [private]

Definition at line 76 of file StreamReplicator.hh.

Referenced by getNextFrame(), and onSourceClosure().

unsigned StreamReplicator::fNumReplicas [private]

Definition at line 77 of file StreamReplicator.hh.

Referenced by createStreamReplica(), deactivateStreamReplica(), numReplicas(), and removeStreamReplica().

unsigned StreamReplicator::fNumActiveReplicas [private]

Definition at line 77 of file StreamReplicator.hh.

Referenced by deactivateStreamReplica(), deliverReceivedFrame(), and getNextFrame().

unsigned StreamReplicator::fNumDeliveriesMadeSoFar [private]

Definition at line 77 of file StreamReplicator.hh.

Referenced by deliverReceivedFrame().

int StreamReplicator::fFrameIndex [private]

Definition at line 78 of file StreamReplicator.hh.

Referenced by deliverReceivedFrame(), and getNextFrame().

StreamReplica* StreamReplicator::fMasterReplica [private]

Definition at line 80 of file StreamReplicator.hh.

Referenced by afterGettingFrame(), deactivateStreamReplica(), deliverReceivedFrame(), getNextFrame(), and onSourceClosure().

StreamReplica* StreamReplicator::fReplicasAwaitingCurrentFrame [private]

Definition at line 81 of file StreamReplicator.hh.

Referenced by deactivateStreamReplica(), deliverReceivedFrame(), getNextFrame(), and onSourceClosure().

StreamReplica* StreamReplicator::fReplicasAwaitingNextFrame [private]

Definition at line 82 of file StreamReplicator.hh.

Referenced by deactivateStreamReplica(), deliverReceivedFrame(), getNextFrame(), and onSourceClosure().

The documentation for this class was generated from the following files:
Generated on Thu May 17 07:16:22 2012 for live by  doxygen 1.5.2