text: 
  #include "liveMedia.hh"
  #include "BasicUsageEnvironment.hh"
  #include "main.h"
  #include "screen.h"
  #include "decoder.h"
  
  
  // A function that outputs a string that identifies each stream (for debugging output).  Modify this if you wish:
  UsageEnvironment& operator<<(UsageEnvironment& env, const RTSPClient& rtspClient)
  {
    return env << "[URL:\"" << rtspClient.url() << "\"]: ";
  }
  
  // A function that outputs a string that identifies each subsession (for debugging output).  Modify this if you wish:
  UsageEnvironment& operator<<(UsageEnvironment& env, const MediaSubsession& subsession)
  {
    return env << subsession.mediumName() << "/" << subsession.codecName();
  }
  
  void usage(UsageEnvironment& env, char const* progName)
  {
  	env << "Usage: " << progName << " [rtsp-url]\n";
  }
  
  
  
  char eventLoopWatchVariable = 0;
  
  
  int main(int argc, char** argv)
  {
  	TaskScheduler* scheduler = BasicTaskScheduler::createNew();
  	UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);
  
  	if (argc < 2) {
  	    openURL(*env, argv[0], "rtsp://127.0.0.1:8554/testStream");
  	} else {
  	    openURL(*env, argv[0], argv[1]);
  	}
  
  	// All subsequent activity takes place within the event loop:
  	env->taskScheduler().doEventLoop(&eventLoopWatchVariable);
      // This function call does not return, unless, at some point in time, "eventLoopWatchVariable" gets set to something non-zero.
  	return 0;
  
    // If you choose to continue the application past this point (i.e., if you comment out the "return 0;" statement above),
    // and if you don't intend to do anything more with the "TaskScheduler" and "UsageEnvironment" objects,
    // then you can also reclaim the (small) memory used by these objects by uncommenting the following code:
    /*
      env->reclaim(); env = NULL;
      delete scheduler; scheduler = NULL;
    */
  }
  
  // Define a class to hold per-stream state that we maintain throughout each stream's lifetime:
  
  class StreamClientState {
  public:
    StreamClientState();
    virtual ~StreamClientState();
  
  public:
    MediaSubsessionIterator* iter;
    MediaSession* session;
    MediaSubsession* subsession;
    TaskToken streamTimerTask;
    double duration;
  };
  
  
  // If you're streaming just a single stream (i.e., just from a single URL, once), then you can define and use just a single
  // "StreamClientState" structure, as a global variable in your application.  However, because - in this demo application - we're
  // showing how to play multiple streams, concurrently, we can't do that.  Instead, we have to have a separate "StreamClientState"
  // structure for each "RTSPClient".  To do this, we subclass "RTSPClient", and add a "StreamClientState" field to the subclass:
  
  class ourRTSPClient: public RTSPClient {
  public:
    static ourRTSPClient* createNew(UsageEnvironment& env, char const* rtspURL,
  				  int verbosityLevel = 0,
  				  char const* applicationName = NULL,
  				  portNumBits tunnelOverHTTPPortNum = 0);
  
  protected:
    ourRTSPClient(UsageEnvironment& env, char const* rtspURL,
  		int verbosityLevel, char const* applicationName, portNumBits tunnelOverHTTPPortNum);
      // called only by createNew();
    virtual ~ourRTSPClient();
  
  public:
    StreamClientState scs;
  };
  
  // Define a data sink (a subclass of "MediaSink") to receive the data for each subsession (i.e., each audio or video 'substream').
  // In practice, this might be a class (or a chain of classes) that decodes and then renders the incoming audio or video.
  // Or it might be a "FileSink", for outputting the received data into a file (as is done by the "openRTSP" application).
  // In this example code, however, we define a simple 'dummy' sink that receives incoming data, but does nothing with it.
  
  class DummySink: public MediaSink {
  public:
    static DummySink* createNew(UsageEnvironment& env,
  			      MediaSubsession& subsession, // identifies the kind of data that's being received
  			      char const* streamId = NULL); // identifies the stream itself (optional)
  
  private:
    DummySink(UsageEnvironment& env, MediaSubsession& subsession, char const* streamId);
      // called only by "createNew()"
    virtual ~DummySink();
  
    static void afterGettingFrame(void* clientData, unsigned frameSize,
                                  unsigned numTruncatedBytes,
  				struct timeval presentationTime,
                                  unsigned durationInMicroseconds);
    void afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes,
  			 struct timeval presentationTime, unsigned durationInMicroseconds);
  
  private:
    // redefined virtual functions:
    virtual Boolean continuePlaying();
  
  private:
    	  u_int8_t* fReceiveBuffer;
    	  MediaSubsession& fSubsession;
    	  char* fStreamId;
  };
  
  
  #define RTSP_CLIENT_VERBOSITY_LEVEL 1 // by default, print verbose output from each "RTSPClient"
  
  static unsigned rtspClientCount = 0; // Counts how many streams (i.e., "RTSPClient"s) are currently in use.
  
  
  void openURL(UsageEnvironment& env, char const* progName, char const* rtspURL)
  {
    // Begin by creating a "RTSPClient" object.  Note that there is a separate "RTSPClient" object for each stream that we wish
    // to receive (even if more than stream uses the same "rtsp://" URL).
    RTSPClient* rtspClient = ourRTSPClient::createNew(env, rtspURL, RTSP_CLIENT_VERBOSITY_LEVEL, progName);
    if (rtspClient == NULL) {
      env << "Failed to create a RTSP client for URL \"" << rtspURL << "\": " << env.getResultMsg() << "\n";
      return;
    }
  
    ++rtspClientCount;
  
    // Next, send a RTSP "DESCRIBE" command, to get a SDP description for the stream.
    // Note that this command - like all RTSP commands - is sent asynchronously; we do not block, waiting for a response.
    // Instead, the following function call returns immediately, and we handle the RTSP response later, from within the event loop:
    rtspClient->sendDescribeCommand(continueAfterDESCRIBE); 
  }
  
  
  // Implementation of the RTSP 'response handlers':
  
  void continueAfterDESCRIBE(RTSPClient* rtspClient, int resultCode, char* resultString)
  {
    do {
      UsageEnvironment& env = rtspClient->envir(); // alias
      StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias
  
      if (resultCode != 0) {
        env << *rtspClient << "Failed to get a SDP description: " << resultString << "\n";
        delete[] resultString;
        break;
      }
  
      char* const sdpDescription = resultString;
      env << *rtspClient << "Got a SDP description:\n" << sdpDescription << "\n";
  
      // Create a media session object from this SDP description:
      scs.session = MediaSession::createNew(env, sdpDescription);
      delete[] sdpDescription; // because we don't need it anymore
      if (scs.session == NULL) {
        env << *rtspClient << "Failed to create a MediaSession object from the SDP description: " << env.getResultMsg() << "\n";
        break;
      } else if (!scs.session->hasSubsessions()) {
        env << *rtspClient << "This session has no media subsessions (i.e., no \"m=\" lines)\n";
        break;
      }
  
      // Then, create and set up our data source objects for the session.  We do this by iterating over the session's 'subsessions',
      // calling "MediaSubsession::initiate()", and then sending a RTSP "SETUP" command, on each one.
      // (Each 'subsession' will have its own data source.)
      scs.iter = new MediaSubsessionIterator(*scs.session);
      setupNextSubsession(rtspClient);
      return;
    } while (0);
  
    // An unrecoverable error occurred with this stream.
    shutdownStream(rtspClient);
  }
  
  // By default, we request that the server stream its data using RTP/UDP.
  // If, instead, you want to request that the server stream via RTP-over-TCP, change the following to True:
  #define REQUEST_STREAMING_OVER_TCP False
  
  
  void setupNextSubsession(RTSPClient* rtspClient)
  {
    UsageEnvironment& env = rtspClient->envir(); // alias
    StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias
    
    scs.subsession = scs.iter->next();
    if (scs.subsession != NULL) {
      if (!scs.subsession->initiate()) {
        env << *rtspClient << "Failed to initiate the \"" << *scs.subsession << "\" subsession: " << env.getResultMsg() << "\n";
        setupNextSubsession(rtspClient); // give up on this subsession; go to the next one
      } else {
        env << *rtspClient << "Initiated the \"" << *scs.subsession << "\" subsession (";
        if (scs.subsession->rtcpIsMuxed()) {
  	env << "client port " << scs.subsession->clientPortNum();
        } else {
  	env << "client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum()+1;
        }
        env << ")\n";
  
        // Continue setting up this subsession, by sending a RTSP "SETUP" command:
        rtspClient->sendSetupCommand(*scs.subsession, continueAfterSETUP, False, REQUEST_STREAMING_OVER_TCP);
      }
      return;
    }
  
    // We've finished setting up all of the subsessions.  Now, send a RTSP "PLAY" command to start the streaming:
    if (scs.session->absStartTime() != NULL) {
      // Special case: The stream is indexed by 'absolute' time, so send an appropriate "PLAY" command:
      rtspClient->sendPlayCommand(*scs.session, continueAfterPLAY, scs.session->absStartTime(), scs.session->absEndTime());
    } else {
      scs.duration = scs.session->playEndTime() - scs.session->playStartTime();
      rtspClient->sendPlayCommand(*scs.session, continueAfterPLAY);
    }
  }
  
  
  void continueAfterSETUP(RTSPClient* rtspClient, int resultCode, char* resultString)
  {
    do {
      UsageEnvironment& env = rtspClient->envir(); // alias
      StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias
  
      if (resultCode != 0) {
        env << *rtspClient << "Failed to set up the \"" << *scs.subsession << "\" subsession: " << resultString << "\n";
        break;
      }
  
      env << *rtspClient << "Set up the \"" << *scs.subsession << "\" subsession (";
      if (scs.subsession->rtcpIsMuxed()) {
        env << "client port " << scs.subsession->clientPortNum();
      } else {
        env << "client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum()+1;
      }
      env << ")\n";
  
      // Having successfully setup the subsession, create a data sink for it, and call "startPlaying()" on it.
      // (This will prepare the data sink to receive data; the actual flow of data from the client won't start happening until later,
      // after we've sent a RTSP "PLAY" command.)
  
      scs.subsession->sink = DummySink::createNew(env, *scs.subsession, rtspClient->url());
        // perhaps use your own custom "MediaSink" subclass instead
      if (scs.subsession->sink == NULL) {
        env << *rtspClient << "Failed to create a data sink for the \"" << *scs.subsession
  	  << "\" subsession: " << env.getResultMsg() << "\n";
        break;
      }
  
      env << *rtspClient << "Created a data sink for the \"" << *scs.subsession << "\" subsession\n";
      scs.subsession->miscPtr = rtspClient; // a hack to let subsession handler functions get the "RTSPClient" from the subsession 
      scs.subsession->sink->startPlaying(*(scs.subsession->readSource()),
  				       subsessionAfterPlaying, scs.subsession);
      // Also set a handler to be called if a RTCP "BYE" arrives for this subsession:
      if (scs.subsession->rtcpInstance() != NULL) {
        scs.subsession->rtcpInstance()->setByeHandler(subsessionByeHandler, scs.subsession);
      }
    } while (0);
    delete[] resultString;
  
    // Set up the next subsession, if any:
    setupNextSubsession(rtspClient);
  }
  
  
  void continueAfterPLAY(RTSPClient* rtspClient, int resultCode, char* resultString)
  {
    Boolean success = False;
  
    do {
      UsageEnvironment& env = rtspClient->envir(); // alias
      StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias
  
      if (resultCode != 0) {
        env << *rtspClient << "Failed to start playing session: " << resultString << "\n";
        break;
      }
  
      // Set a timer to be handled at the end of the stream's expected duration (if the stream does not already signal its end
      // using a RTCP "BYE").  This is optional.  If, instead, you want to keep the stream active - e.g., so you can later
      // 'seek' back within it and do another RTSP "PLAY" - then you can omit this code.
      // (Alternatively, if you don't want to receive the entire stream, you could set this timer for some shorter value.)
      if (scs.duration > 0) {
        unsigned const delaySlop = 2; // number of seconds extra to delay, after the stream's expected duration.  (This is optional.)
        scs.duration += delaySlop;
        unsigned uSecsToDelay = (unsigned)(scs.duration*1000000);
        scs.streamTimerTask = env.taskScheduler().scheduleDelayedTask(uSecsToDelay, (TaskFunc*)streamTimerHandler, rtspClient);
      }
  
      env << *rtspClient << "Started playing session";
      if (scs.duration > 0) {
        env << " (for up to " << scs.duration << " seconds)";
      }
      env << "...\n";
  
      success = True;
    } while (0);
    delete[] resultString;
  
    if (!success) {
      // An unrecoverable error occurred with this stream.
      shutdownStream(rtspClient);
    }
  }
  
  
  // Implementation of the other event handlers:
  
  void subsessionAfterPlaying(void* clientData)
  {
    MediaSubsession* subsession = (MediaSubsession*)clientData;
    RTSPClient* rtspClient = (RTSPClient*)(subsession->miscPtr);
  
    // Begin by closing this subsession's stream:
    Medium::close(subsession->sink);
    subsession->sink = NULL;
  
    // Next, check whether *all* subsessions' streams have now been closed:
    MediaSession& session = subsession->parentSession();
    MediaSubsessionIterator iter(session);
    while ((subsession = iter.next()) != NULL) {
      if (subsession->sink != NULL) return; // this subsession is still active
    }
  
    // All subsessions' streams have now been closed, so shutdown the client:
    shutdownStream(rtspClient);
  }
  
  
  void subsessionByeHandler(void* clientData)
  {
    MediaSubsession* subsession = (MediaSubsession*)clientData;
    RTSPClient* rtspClient = (RTSPClient*)subsession->miscPtr;
    UsageEnvironment& env = rtspClient->envir(); // alias
  
    env << *rtspClient << "Received RTCP \"BYE\" on \"" << *subsession << "\" subsession\n";
  
    // Now act as if the subsession had closed:
    subsessionAfterPlaying(subsession);
  }
  
  
  void streamTimerHandler(void* clientData)
  {
    ourRTSPClient* rtspClient = (ourRTSPClient*)clientData;
    StreamClientState& scs = rtspClient->scs; // alias
  
    scs.streamTimerTask = NULL;
  
    // Shut down the stream:
    shutdownStream(rtspClient);
  }
  
  
  void shutdownStream(RTSPClient* rtspClient, int exitCode)
  {
    UsageEnvironment& env = rtspClient->envir(); // alias
    StreamClientState& scs = ((ourRTSPClient*)rtspClient)->scs; // alias
  
    // First, check whether any subsessions have still to be closed:
    if (scs.session != NULL) { 
      Boolean someSubsessionsWereActive = False;
      MediaSubsessionIterator iter(*scs.session);
      MediaSubsession* subsession;
  
      while ((subsession = iter.next()) != NULL) {
        if (subsession->sink != NULL) {
  	Medium::close(subsession->sink);
  	subsession->sink = NULL;
  
  	if (subsession->rtcpInstance() != NULL) {
  	  subsession->rtcpInstance()->setByeHandler(NULL, NULL); // in case the server sends a RTCP "BYE" while handling "TEARDOWN"
  	}
  
  	someSubsessionsWereActive = True;
        }
      }
  
      if (someSubsessionsWereActive) {
        // Send a RTSP "TEARDOWN" command, to tell the server to shutdown the stream.
        // Don't bother handling the response to the "TEARDOWN".
        rtspClient->sendTeardownCommand(*scs.session, NULL);
      }
    }
  
    env << *rtspClient << "Closing the stream.\n";
    Medium::close(rtspClient);
      // Note that this will also cause this stream's "StreamClientState" structure to get reclaimed.
  
    if (--rtspClientCount == 0) {
      // The final stream has ended, so exit the application now.
      // (Of course, if you're embedding this code into your own application, you might want to comment this out,
      // and replace it with "eventLoopWatchVariable = 1;", so that we leave the LIVE555 event loop, and continue running "main()".)
      exit(exitCode);
    }
  }
  
  
  // Implementation of "ourRTSPClient":
  
  ourRTSPClient* ourRTSPClient::createNew(UsageEnvironment& env, char const* rtspURL,
  					int verbosityLevel, char const* applicationName, portNumBits tunnelOverHTTPPortNum)
  {
    return new ourRTSPClient(env, rtspURL, verbosityLevel, applicationName, tunnelOverHTTPPortNum);
  }
  
  
  ourRTSPClient::ourRTSPClient(UsageEnvironment& env, char const* rtspURL,
  			     int verbosityLevel, char const* applicationName, portNumBits tunnelOverHTTPPortNum)
    : RTSPClient(env,rtspURL, verbosityLevel, applicationName, tunnelOverHTTPPortNum, -1)
  {
  }
  
  ourRTSPClient::~ourRTSPClient() {
  }
  
  
  // Implementation of "StreamClientState":
  
  StreamClientState::StreamClientState() : iter(NULL), session(NULL), subsession(NULL), streamTimerTask(NULL), duration(0.0)
  {
  }
  
  
  StreamClientState::~StreamClientState()
  {
    delete iter;
    if (session != NULL) {
      // We also need to delete "session", and unschedule "streamTimerTask" (if set)
      UsageEnvironment& env = session->envir(); // alias
  
      env.taskScheduler().unscheduleDelayedTask(streamTimerTask);
      Medium::close(session);
    }
  }
  
  
  class Decoder1 : public Decoder {
  public:
  	Decoder1(int w,int h,Screen& s) : Decoder(w,h), s(s)
  	{
  	}
  
  	virtual void write(uint8_t *buf,int len)
  	{
  		s.show(buf,len);
  	}
  
  private:
  	Screen& s;
  };
  
  
  Screen screen(WIDTH,HEIGHT);
  Decoder1 dec(WIDTH,HEIGHT,screen);
  
  
  // Implementation of "DummySink":
  
  // Even though we're not going to be doing anything with the incoming data, we still need to receive it.
  // Define the size of the buffer that we'll use:
  #define DUMMY_SINK_RECEIVE_BUFFER_SIZE (200000+32)
  
  
  DummySink* DummySink::createNew(UsageEnvironment& env, MediaSubsession& subsession, char const* streamId)
  {
    return new DummySink(env, subsession, streamId);
  }
  
  DummySink::DummySink(UsageEnvironment& env, MediaSubsession& subsession, char const* streamId)
    : MediaSink(env), fSubsession(subsession)
  {
    fStreamId = strDup(streamId);
    fReceiveBuffer = new u_int8_t[DUMMY_SINK_RECEIVE_BUFFER_SIZE+4];
    fReceiveBuffer[0] = 0;
    fReceiveBuffer[1] = 0;
    fReceiveBuffer[2] = 0;
    fReceiveBuffer[3] = 1;
  }
  
  
  DummySink::~DummySink()
  {
    delete[] fReceiveBuffer;
    delete[] fStreamId;
  }
  
  
  void DummySink::afterGettingFrame(void* clientData, unsigned frameSize, unsigned numTruncatedBytes,
  				  struct timeval presentationTime, unsigned durationInMicroseconds)
  {
    DummySink* sink = (DummySink*)clientData;
    sink->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
  }
  
  
  // If you don't want to see debugging output for each received frame, then comment out the following line:
  #define DEBUG_PRINT_EACH_RECEIVED_FRAME 0
  
  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
    
    dec.decode(fReceiveBuffer,frameSize+4);
  
    // Then continue, to request the next frame of data:
    continuePlaying();
  }
  
  
  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+4,
  		  	  	  	  	  DUMMY_SINK_RECEIVE_BUFFER_SIZE,
                          afterGettingFrame,
  						this,
                          onSourceClosure,
  						this);
    return True;
  }
  
  