testProgs/testRTSPClient.cpp File Reference

#include "liveMedia.hh"
#include "BasicUsageEnvironment.hh"

Include dependency graph for testRTSPClient.cpp:

Go to the source code of this file.

Data Structures
class	StreamClientState
class	ourRTSPClient
class	DummySink
Defines
#define	RTSP_CLIENT_VERBOSITY_LEVEL   1
#define	REQUEST_STREAMING_OVER_TCP   False
#define	DUMMY_SINK_RECEIVE_BUFFER_SIZE   100000
#define	DEBUG_PRINT_EACH_RECEIVED_FRAME   1
Functions
void	continueAfterDESCRIBE (RTSPClient *rtspClient, int resultCode, char *resultString)
void	continueAfterSETUP (RTSPClient *rtspClient, int resultCode, char *resultString)
void	continueAfterPLAY (RTSPClient *rtspClient, int resultCode, char *resultString)
void	subsessionAfterPlaying (void *clientData)
void	subsessionByeHandler (void *clientData)
void	streamTimerHandler (void *clientData)
void	openURL (UsageEnvironment &env, char const *progName, char const *rtspURL)
void	setupNextSubsession (RTSPClient *rtspClient)
void	shutdownStream (RTSPClient *rtspClient, int exitCode=1)
UsageEnvironment &	operator<< (UsageEnvironment &env, const RTSPClient &rtspClient)
UsageEnvironment &	operator<< (UsageEnvironment &env, const MediaSubsession &subsession)
void	usage (UsageEnvironment &env, char const *progName)
int	main (int argc, char **argv)
Variables
char	eventLoopWatchVariable = 0
static unsigned	rtspClientCount = 0

---

Define Documentation

#define DEBUG_PRINT_EACH_RECEIVED_FRAME   1

Definition at line 488 of file testRTSPClient.cpp.

#define DUMMY_SINK_RECEIVE_BUFFER_SIZE   100000

Definition at line 463 of file testRTSPClient.cpp.

Referenced by DummySink::continuePlaying(), and DummySink::DummySink().

#define REQUEST_STREAMING_OVER_TCP   False

Definition at line 229 of file testRTSPClient.cpp.

Referenced by setupNextSubsession().

#define RTSP_CLIENT_VERBOSITY_LEVEL   1

Definition at line 166 of file testRTSPClient.cpp.

Referenced by openURL().

---

Function Documentation

void continueAfterDESCRIBE	(	RTSPClient *	rtspClient,
		int	resultCode,
		char *	resultString
	)

void continueAfterPLAY	(	RTSPClient *	rtspClient,
		int	resultCode,
		char *	resultString
	)

void continueAfterSETUP	(	RTSPClient *	rtspClient,
		int	resultCode,
		char *	resultString
	)

int main	(	int	argc,
		char **	argv
	)

Definition at line 65 of file testRTSPClient.cpp.

References BasicUsageEnvironment::createNew(), BasicTaskScheduler::createNew(), TaskScheduler::doEventLoop(), env, eventLoopWatchVariable, openURL(), UsageEnvironment::taskScheduler(), and usage().

                                {
  // Begin by setting up our usage environment:
  TaskScheduler* scheduler = BasicTaskScheduler::createNew();
  UsageEnvironment* env = BasicUsageEnvironment::createNew(*scheduler);

  // We need at least one "rtsp://" URL argument:
  if (argc < 2) {
    usage(*env, argv[0]);
    return 1;
  }

  // There are argc-1 URLs: argv[1] through argv[argc-1].  Open and start streaming each one:
  for (int i = 1; i <= argc-1; ++i) {
    openURL(*env, argv[0], argv[i]);
  }

  // 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;
  */
}

void openURL	(	UsageEnvironment &	env,
		char const *	progName,
		char const *	rtspURL
	)

Definition at line 170 of file testRTSPClient.cpp.

References continueAfterDESCRIBE(), ourRTSPClient::createNew(), env, UsageEnvironment::getResultMsg(), NULL, RTSP_CLIENT_VERBOSITY_LEVEL, rtspClientCount, and RTSPClient::sendDescribeCommand().

Referenced by main().

                                                                               {
  // 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); 
}

UsageEnvironment& operator<<	(	UsageEnvironment &	env,
		const MediaSubsession &	subsession
	)

Definition at line 54 of file testRTSPClient.cpp.

References MediaSubsession::codecName(), env, MediaSubsession::mediumName(), and subsession.

                                                                                       {
  return env << subsession.mediumName() << "/" << subsession.codecName();
}

UsageEnvironment& operator<<	(	UsageEnvironment &	env,
		const RTSPClient &	rtspClient
	)

Definition at line 49 of file testRTSPClient.cpp.

References env, and RTSPClient::url().

                                                                                  {
  return env << "[URL:\"" << rtspClient.url() << "\"]: ";
}

void setupNextSubsession

(

RTSPClient *

rtspClient

)

Definition at line 231 of file testRTSPClient.cpp.

References MediaSession::absEndTime(), MediaSession::absStartTime(), MediaSubsession::clientPortNum(), continueAfterPLAY(), continueAfterSETUP(), StreamClientState::duration, env, Medium::envir(), False, UsageEnvironment::getResultMsg(), MediaSubsession::initiate(), StreamClientState::iter, MediaSubsessionIterator::next(), NULL, MediaSession::playEndTime(), MediaSession::playStartTime(), REQUEST_STREAMING_OVER_TCP, RTSPClient::sendPlayCommand(), RTSPClient::sendSetupCommand(), StreamClientState::session, and StreamClientState::subsession.

                                                 {
  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 (client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum()+1 << ")\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 shutdownStream	(	RTSPClient *	rtspClient,
		int	exitCode = 1
	)

Definition at line 382 of file testRTSPClient.cpp.

References Medium::close(), env, Medium::envir(), exit, False, iter, MediaSubsessionIterator::next(), NULL, MediaSubsession::rtcpInstance(), rtspClientCount, RTSPClient::sendTeardownCommand(), StreamClientState::session, RTCPInstance::setByeHandler(), MediaSubsession::sink, subsession, and True.

Referenced by streamTimerHandler().

                                                          {
  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);
  }
}

void streamTimerHandler

(

void *

clientData

)

Definition at line 372 of file testRTSPClient.cpp.

References NULL, ourRTSPClient::scs, shutdownStream(), and StreamClientState::streamTimerTask.

                                          {
  ourRTSPClient* rtspClient = (ourRTSPClient*)clientData;
  StreamClientState& scs = rtspClient->scs; // alias

  scs.streamTimerTask = NULL;

  // Shut down the stream:
  shutdownStream(rtspClient);
}

void subsessionAfterPlaying

(

void *

clientData

)

void subsessionByeHandler

(

void *

clientData

)

void usage	(	UsageEnvironment &	env,
		char const *	progName
	)

Definition at line 58 of file testRTSPClient.cpp.

References env.

                                                        {
  env << "Usage: " << progName << " <rtsp-url-1> ... <rtsp-url-N>\n";
  env << "\t(where each <rtsp-url-i> is a \"rtsp://\" URL)\n";
}

---

Variable Documentation

char eventLoopWatchVariable = 0

Definition at line 63 of file testRTSPClient.cpp.

Referenced by main().

unsigned rtspClientCount = 0 [static]

Definition at line 168 of file testRTSPClient.cpp.

Referenced by openURL(), and shutdownStream().

---