/**********
|
This library is free software; you can redistribute it and/or modify it under
|
the terms of the GNU Lesser General Public License as published by the
|
Free Software Foundation; either version 3 of the License, or (at your
|
option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)
|
|
This library is distributed in the hope that it will be useful, but WITHOUT
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
|
more details.
|
|
You should have received a copy of the GNU Lesser General Public License
|
along with this library; if not, write to the Free Software Foundation, Inc.,
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
**********/
|
// Copyright (c) 1996-2017, Live Networks, Inc. All rights reserved
|
// A demo application, showing how to create and run a RTSP client (that can potentially receive multiple streams concurrently).
|
//
|
// NOTE: This code - although it builds a running application - is intended only to illustrate how to develop your own RTSP
|
// client application. For a full-featured RTSP client application - with much more functionality, and many options - see
|
// "openRTSP": http://www.live555.com/openRTSP/
|
|
#include <liveMedia/liveMedia.hh>
|
#include <BasicUsageEnvironment/BasicUsageEnvironment.hh>
|
#include <groupsock/GroupsockHelper.hh>
|
|
#include <iostream>
|
|
#define RTSP_CLIENT_VERBOSITY_LEVEL 1 // by default, print verbose output from each "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 True
|
|
// 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 1920*1080*3//#todo
|
|
#define INCREASE_RECEIVE_BUFFER_TO 8000000
|
|
// 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 1
|
//#define DEBUG_PRINT_NPT 1
|
|
// Forward function definitions:
|
|
// RTSP 'response handlers':
|
void continueAfterDESCRIBE(RTSPClient* rtspClient, int resultCode, char* resultString);
|
void continueAfterSETUP(RTSPClient* rtspClient, int resultCode, char* resultString);
|
void continueAfterPLAY(RTSPClient* rtspClient, int resultCode, char* resultString);
|
|
// Other event handler functions:
|
void subsessionAfterPlaying(void* clientData); // called when a stream's subsession (e.g., audio or video substream) ends
|
void subsessionByeHandler(void* clientData); // called when a RTCP "BYE" is received for a subsession
|
void streamTimerHandler(void* clientData);
|
// called at the end of a stream's expected duration (if the stream has not already signaled its end using a RTCP "BYE")
|
|
// The main streaming routine (for each "rtsp://" URL):
|
void openURL(UsageEnvironment& env, const PL_RTSPClient_Config& _rtspConfig);
|
|
// Used to iterate through each stream's 'subsessions', setting up each one:
|
void setupNextSubsession(RTSPClient* rtspClient);
|
|
// Used to shut down and close a stream (including its "RTSPClient" object):
|
void shutdownStream(RTSPClient* rtspClient, int exitCode = 1);
|
|
// A function that outputs a string that identifies each stream (for debugging output). Modify this if you wish:
|
Logger& operator<<(Logger& logRoot, const RTSPClient& rtspClient)
|
{
|
return logRoot << "[URL:\"" << rtspClient.url() << "\"]: ";
|
}
|
|
// A function that outputs a string that identifies each subsession (for debugging output). Modify this if you wish:
|
Logger& operator<<(Logger& logRoot, const MediaSubsession& subsession)
|
{
|
return logRoot << subsession.mediumName() << "/" << subsession.codecName();
|
}
|
|
void usage(UsageEnvironment& env, char const* progName)
|
{
|
LOG_DEBUG << "Usage: " << progName << " <rtsp-url-1> ... <rtsp-url-N>" << LOG_ENDL;
|
LOG_DEBUG << "\t(where each <rtsp-url-i> is a \"rtsp://\" URL)" << LOG_ENDL;
|
}
|
|
char eventLoopWatchVariable = 0;
|
|
int test_main(int argc, char** argv)
|
{
|
// 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;
|
}
|
|
PL_RTSPClient_Config rtspConfig;
|
rtspConfig.progName = argv[0];
|
rtspConfig.rtspURL = "";
|
rtspConfig.aux = false;
|
rtspConfig.verbosityLevel = RTSP_CLIENT_VERBOSITY_LEVEL;
|
rtspConfig.tunnelOverHTTPPortNum = 0;
|
rtspConfig.args = nullptr;
|
|
// 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)
|
{
|
rtspConfig.rtspURL = argv[i];
|
openURL(*env, rtspConfig);
|
}
|
|
// 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, const PL_RTSPClient_Config& _rtspConfig);
|
|
protected:
|
ourRTSPClient(UsageEnvironment& env, const PL_RTSPClient_Config& _rtspConfig);
|
// called only by createNew();
|
virtual ~ourRTSPClient();
|
|
public:
|
StreamClientState scs;
|
const PL_RTSPClient_Config& rtspConfig;
|
int desiredPortNum;
|
};
|
|
// 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,
|
const PL_RTSPClient_Config& _rtspConfig,
|
MediaSubsession& subsession, // identifies the kind of data that's being received
|
char const* streamId = NULL); // identifies the stream itself (optional)
|
|
private:
|
DummySink(UsageEnvironment& env, const PL_RTSPClient_Config& _rtspConfig, 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);
|
|
public:
|
const PL_RTSPClient_Config& rtspConfig;
|
|
private:
|
// redefined virtual functions:
|
virtual Boolean continuePlaying();
|
|
private:
|
u_int8_t* fReceiveBuffer;
|
MediaSubsession& fSubsession;
|
char* fStreamId;
|
};
|
|
static unsigned rtspClientCount = 0; // Counts how many streams (i.e., "RTSPClient"s) are currently in use.
|
|
void openURL(UsageEnvironment& env, const PL_RTSPClient_Config& _rtspConfig)
|
{
|
if (!_rtspConfig.receivingInterfaceAddr.empty())
|
{
|
NetAddressList addresses(_rtspConfig.receivingInterfaceAddr.c_str());
|
if (addresses.numAddresses() == 0)
|
{
|
LOG_ERROR << "Failed to find network address for " << _rtspConfig.receivingInterfaceAddr << LOG_ENDL;
|
return;
|
}
|
else
|
{
|
ReceivingInterfaceAddr = *(unsigned*)(addresses.firstAddress()->data()); // declared in live555
|
LOG_INFO << "Use receiving interface addr " << _rtspConfig.receivingInterfaceAddr << LOG_ENDL;
|
}
|
}
|
|
if (_rtspConfig.desiredPortNum != 0)
|
{
|
if (_rtspConfig.desiredPortNum <= 0 || _rtspConfig.desiredPortNum >= 65536 || _rtspConfig.desiredPortNum&1)
|
{
|
LOG_ERROR << "bad port number: " << _rtspConfig.desiredPortNum << " (must be even, and in the range (0,65536))" << LOG_ENDL;
|
return;
|
}
|
else
|
LOG_INFO << "Use desired port num " << _rtspConfig.desiredPortNum << LOG_ENDL;
|
}
|
|
// 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, _rtspConfig);
|
if (rtspClient == NULL)
|
{
|
LOG_ERROR << "Failed to create a RTSP client for URL \"" << _rtspConfig.rtspURL.c_str() << "\": " << env.getResultMsg() << LOG_ENDL;
|
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)
|
{
|
LOG_WARN << *rtspClient << "Failed to get a SDP description: " << resultString << LOG_ENDL;
|
delete[] resultString;
|
break;
|
}
|
|
char* const sdpDescription = resultString;
|
LOG_INFO << *rtspClient << "Got a SDP description:\n" << sdpDescription << LOG_ENDL;
|
|
// 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)
|
{
|
LOG_ERROR << *rtspClient << "Failed to create a MediaSession object from the SDP description: " << env.getResultMsg() << LOG_ENDL;
|
break;
|
}
|
else if (!scs.session->hasSubsessions())
|
{
|
LOG_WARN << *rtspClient << "This session has no media subsessions (i.e., no \"m=\" lines)" << LOG_ENDL;
|
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);
|
}
|
|
void setupNextSubsession(RTSPClient* rtspClient)
|
{
|
UsageEnvironment& env = rtspClient->envir(); // alias
|
ourRTSPClient* _ourRTSPClient = (ourRTSPClient*)rtspClient;
|
StreamClientState& scs = _ourRTSPClient->scs; // alias
|
|
scs.subsession = scs.iter->next();
|
if (scs.subsession != NULL)
|
{
|
if (_ourRTSPClient->desiredPortNum != 0)
|
{
|
scs.subsession->setClientPortNum(_ourRTSPClient->desiredPortNum);
|
_ourRTSPClient->desiredPortNum += 2;
|
}
|
|
if (!scs.subsession->initiate())
|
{
|
LOG_ERROR << *rtspClient << "Failed to initiate the \"" << *scs.subsession << "\" subsession: " << env.getResultMsg() << LOG_ENDL;
|
setupNextSubsession(rtspClient); // give up on this subsession; go to the next one
|
}
|
else
|
{
|
LOG_INFO << *rtspClient << "Initiated the \"" << *scs.subsession << "\" subsession (" << LOG_ENDL;
|
if (scs.subsession->rtcpIsMuxed())
|
LOG_INFO << "client port " << scs.subsession->clientPortNum() << LOG_ENDL;
|
else
|
LOG_INFO << "client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum()+1 << LOG_ENDL;
|
LOG_INFO << ")" << LOG_ENDL;
|
|
#ifdef INCREASE_RECEIVE_BUFFER_TO
|
//sysctl net.core.rmem_max=40000000
|
if (INCREASE_RECEIVE_BUFFER_TO > 0)
|
increaseReceiveBufferTo(env, scs.subsession->rtpSource()->RTPgs()->socketNum(), INCREASE_RECEIVE_BUFFER_TO);
|
#endif
|
|
// Continue setting up this subsession, by sending a RTSP "SETUP" command:
|
rtspClient->sendSetupCommand(*scs.subsession, continueAfterSETUP, False, _ourRTSPClient->rtspConfig.requestStreamingOverTcp);
|
}
|
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)
|
{
|
LOG_ERROR << *rtspClient << "Failed to set up the \"" << *scs.subsession << "\" subsession: " << resultString << LOG_ENDL;
|
break;
|
}
|
|
//#todo temp usage
|
std::string sess_mime(scs.subsession->mediumName());
|
if (sess_mime != "video")
|
break;
|
|
LOG_INFO << *rtspClient << "Set up the \"" << *scs.subsession << "\" subsession (" << LOG_ENDL;
|
if (scs.subsession->rtcpIsMuxed())
|
{
|
LOG_INFO << "client port " << scs.subsession->clientPortNum() << LOG_ENDL;
|
}
|
else
|
{
|
LOG_INFO << "client ports " << scs.subsession->clientPortNum() << "-" << scs.subsession->clientPortNum()+1 << LOG_ENDL;
|
}
|
LOG_INFO << ")" << LOG_ENDL;
|
|
// 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, ((ourRTSPClient*)rtspClient)->rtspConfig, *scs.subsession, rtspClient->url());
|
// perhaps use your own custom "MediaSink" subclass instead
|
if (scs.subsession->sink == NULL)
|
{
|
LOG_ERROR << *rtspClient << "Failed to create a data sink for the \"" << *scs.subsession
|
<< "\" subsession: " << env.getResultMsg() << LOG_ENDL;
|
break;
|
}
|
|
LOG_INFO << *rtspClient << "Created a data sink for the \"" << *scs.subsession << "\" subsession" << LOG_ENDL;
|
scs.subsession->miscPtr = rtspClient; // a hack to let subsession handler functions get the "RTSPClient" from the subsession
|
Boolean startPlayingRet = scs.subsession->sink->startPlaying(*(scs.subsession->readSource()), subsessionAfterPlaying, scs.subsession);
|
LOG_INFO << "startPlayingRet=" << (bool)startPlayingRet << LOG_ENDL;
|
// 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)
|
{
|
LOG_ERROR << *rtspClient << "Failed to start playing session: " << resultString << LOG_ENDL;
|
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);
|
}
|
|
LOG_INFO << *rtspClient << "Started playing session" << LOG_ENDL;
|
if (scs.duration > 0)
|
{
|
LOG_INFO << " (for up to " << scs.duration << " seconds)" << LOG_ENDL;
|
}
|
LOG_INFO << "..." << LOG_ENDL;
|
|
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
|
|
LOG_INFO << *rtspClient << "Received RTCP \"BYE\" on \"" << *subsession << "\" subsession" << LOG_ENDL;
|
|
// 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);
|
}
|
}
|
|
LOG_NOTICE << *rtspClient << "Closing the stream." << LOG_ENDL;
|
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);
|
eventLoopWatchVariable = 1;
|
}
|
}
|
|
|
// Implementation of "ourRTSPClient":
|
|
ourRTSPClient* ourRTSPClient::createNew(UsageEnvironment& env, const PL_RTSPClient_Config& _rtspConfig)
|
{
|
return new ourRTSPClient(env, _rtspConfig);
|
}
|
|
ourRTSPClient::ourRTSPClient(UsageEnvironment& env, const PL_RTSPClient_Config& _rtspConfig)
|
: RTSPClient(env, _rtspConfig.rtspURL.c_str(), _rtspConfig.verbosityLevel, _rtspConfig.progName.c_str(),
|
_rtspConfig.tunnelOverHTTPPortNum, -1), scs(), rtspConfig(_rtspConfig), desiredPortNum(_rtspConfig.desiredPortNum)
|
{
|
}
|
|
ourRTSPClient::~ourRTSPClient()
|
{
|
}
|
|
|
// Implementation of "StreamClientState":
|
|
StreamClientState::StreamClientState()
|
: iter(NULL), session(NULL), subsession(NULL), streamTimerTask(), 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);
|
}
|
}
|
|
// Implementation of "DummySink":
|
|
DummySink* DummySink::createNew(UsageEnvironment& env, const PL_RTSPClient_Config& _rtspConfig, MediaSubsession& subsession, char const* streamId)
|
{
|
return new DummySink(env, _rtspConfig, subsession, streamId);
|
}
|
|
DummySink::DummySink(UsageEnvironment& env, const PL_RTSPClient_Config& _rtspConfig, MediaSubsession& subsession, char const* streamId)
|
: MediaSink(env), rtspConfig(_rtspConfig), fSubsession(subsession)
|
{
|
fStreamId = strDup(streamId);
|
fReceiveBuffer = new u_int8_t[DUMMY_SINK_RECEIVE_BUFFER_SIZE];
|
|
// ffmpeg need AUX header
|
if (rtspConfig.aux)
|
{
|
fReceiveBuffer[0]=0x00;
|
fReceiveBuffer[1]=0x00;
|
fReceiveBuffer[2]=0x00;
|
fReceiveBuffer[3]=0x01;
|
}
|
|
RtspClientParam param;
|
|
//parse sdp
|
param.sdp = fSubsession.savedSDPLines();
|
param.fmtp = fSubsession.fmtp_spropparametersets();
|
param.width = fSubsession.videoWidth();
|
param.height = fSubsession.videoHeight();
|
param.fps = fSubsession.videoFPS();
|
param.codecName = fSubsession.codecName();
|
param.bandwidth = fSubsession.bandwidth();
|
|
rtsp_client_set_param_callback(rtspConfig.args, param);
|
}
|
|
DummySink::~DummySink()
|
{
|
delete[] fReceiveBuffer;
|
delete[] fStreamId;
|
}
|
|
void DummySink::afterGettingFrame(void* clientData, unsigned frameSize, unsigned numTruncatedBytes,
|
struct timeval presentationTime, unsigned durationInMicroseconds)
|
{
|
DummySink* sink = (DummySink*)clientData;
|
|
if (frameSize > 0)
|
{
|
unsigned s = frameSize;
|
if (sink->rtspConfig.aux)
|
s += 4;
|
rtsp_client_frame_callback(sink->rtspConfig.args, sink->fReceiveBuffer, s, presentationTime);
|
}
|
|
sink->afterGettingFrame(frameSize, numTruncatedBytes, presentationTime, durationInMicroseconds);
|
}
|
|
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)
|
LOG_DEBUG << "Stream \"" << fStreamId << "\"; " << LOG_ENDL;
|
LOG_DEBUG << "\t" << fSubsession.mediumName() << "/" << fSubsession.codecName() << ":\tReceived " << frameSize << " bytes" << LOG_ENDL;
|
if (numTruncatedBytes > 0)
|
LOG_DEBUG << " (with " << numTruncatedBytes << " bytes truncated)" << LOG_ENDL;
|
|
char uSecsStr[6+1]; // used to output the 'microseconds' part of the presentation time
|
sprintf(uSecsStr, "%06u", (unsigned)presentationTime.tv_usec);
|
LOG_DEBUG << "\tPresentation time: " << (int)presentationTime.tv_sec << "." << uSecsStr << LOG_ENDL;
|
if (fSubsession.rtpSource() != NULL && !fSubsession.rtpSource()->hasBeenSynchronizedUsingRTCP())
|
{
|
LOG_DEBUG << "\tPTS not RTCP-synchronized" << LOG_ENDL; // mark the debugging output to indicate that this presentation time is not RTCP-synchronized
|
}
|
#ifdef DEBUG_PRINT_NPT
|
LOG_DEBUG << "\tNPT: " << fSubsession.getNormalPlayTime(presentationTime) << LOG_ENDL;
|
#endif
|
#endif
|
|
// Then continue, to request the next frame of data:
|
continuePlaying();
|
}
|
|
Boolean DummySink::continuePlaying()
|
{
|
if (fSource == NULL)
|
return False; // sanity check (should not happen)
|
|
rtsp_client_continue_callback(rtspConfig.args);
|
|
u_int8_t* b = fReceiveBuffer;
|
if (rtspConfig.aux)
|
b += 4;
|
|
// Request the next frame of data from our input source. "afterGettingFrame()" will get called later, when it arrives:
|
fSource->getNextFrame(b, DUMMY_SINK_RECEIVE_BUFFER_SIZE,
|
afterGettingFrame, this,
|
onSourceClosure, this);
|
|
return True;
|
}
|
