liveMedia/include/OnDemandServerMediaSubsession.hh - meet/live555 - Git at Google

 /**********
 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
 **********/
 // "liveMedia"
 // Copyright (c) 1996-2020 Live Networks, Inc.  All rights reserved.
 // A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
 // on demand.
 // C++ header

 #ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
 #define _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH

 #ifndef _SERVER_MEDIA_SESSION_HH
 #include "ServerMediaSession.hh"
 #endif
 #ifndef _RTP_SINK_HH
 #include "RTPSink.hh"
 #endif
 #ifndef _BASIC_UDP_SINK_HH
 #include "BasicUDPSink.hh"
 #endif
 #ifndef _RTCP_HH
 #include "RTCP.hh"
 #endif

 class OnDemandServerMediaSubsession: public ServerMediaSubsession {
 protected: // we're a virtual base class
   OnDemandServerMediaSubsession(UsageEnvironment& env, Boolean reuseFirstSource,
 				portNumBits initialPortNum = 6970,
 				Boolean multiplexRTCPWithRTP = False);
   virtual ~OnDemandServerMediaSubsession();

 protected: // redefined virtual functions
   virtual char const* sdpLines();
   virtual void getStreamParameters(unsigned clientSessionId,
 				   netAddressBits clientAddress,
                                    Port const& clientRTPPort,
                                    Port const& clientRTCPPort,
 				   int tcpSocketNum,
                                    unsigned char rtpChannelId,
                                    unsigned char rtcpChannelId,
                                    netAddressBits& destinationAddress,
 				   u_int8_t& destinationTTL,
                                    Boolean& isMulticast,
                                    Port& serverRTPPort,
                                    Port& serverRTCPPort,
                                    void*& streamToken);
   virtual void startStream(unsigned clientSessionId, void* streamToken,
 			   TaskFunc* rtcpRRHandler,
 			   void* rtcpRRHandlerClientData,
 			   unsigned short& rtpSeqNum,
                            unsigned& rtpTimestamp,
 			   ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
                            void* serverRequestAlternativeByteHandlerClientData);
   virtual void pauseStream(unsigned clientSessionId, void* streamToken);
   virtual void seekStream(unsigned clientSessionId, void* streamToken, double& seekNPT, double streamDuration, u_int64_t& numBytes);
   virtual void seekStream(unsigned clientSessionId, void* streamToken, char*& absStart, char*& absEnd);
   virtual void nullSeekStream(unsigned clientSessionId, void* streamToken,
 			      double streamEndTime, u_int64_t& numBytes);
   virtual void setStreamScale(unsigned clientSessionId, void* streamToken, float scale);
   virtual float getCurrentNPT(void* streamToken);
   virtual FramedSource* getStreamSource(void* streamToken);
   virtual void getRTPSinkandRTCP(void* streamToken,
 				 RTPSink const*& rtpSink, RTCPInstance const*& rtcp);
   virtual void deleteStream(unsigned clientSessionId, void*& streamToken);

 protected: // new virtual functions, possibly redefined by subclasses
   virtual char const* getAuxSDPLine(RTPSink* rtpSink,
 				    FramedSource* inputSource);
   virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
     // This routine is used to seek by relative (i.e., NPT) time.
     // "streamDuration", if >0.0, specifies how much data to stream, past "seekNPT".  (If <=0.0, all remaining data is streamed.)
     // "numBytes" returns the size (in bytes) of the data to be streamed, or 0 if unknown or unlimited.
   virtual void seekStreamSource(FramedSource* inputSource, char*& absStart, char*& absEnd);
     // This routine is used to seek by 'absolute' time.
     // "absStart" should be a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z".
     // "absEnd" should be either NULL (for no end time), or a string of the same form as "absStart".
     // These strings may be modified in-place, or can be reassigned to a newly-allocated value (after delete[]ing the original).
   virtual void setStreamSourceScale(FramedSource* inputSource, float scale);
   virtual void setStreamSourceDuration(FramedSource* inputSource, double streamDuration, u_int64_t& numBytes);
   virtual void closeStreamSource(FramedSource* inputSource);

 protected: // new virtual functions, defined by all subclasses
   virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
 					      unsigned& estBitrate) = 0;
       // "estBitrate" is the stream's estimated bitrate, in kbps
   virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
 				    unsigned char rtpPayloadTypeIfDynamic,
 				    FramedSource* inputSource) = 0;

 protected: // new virtual functions, may be redefined by a subclass:
   virtual Groupsock* createGroupsock(struct in_addr const& addr, Port port);
   virtual RTCPInstance* createRTCP(Groupsock* RTCPgs, unsigned totSessionBW, /* in kbps */
 				   unsigned char const* cname, RTPSink* sink);

 public:
   void multiplexRTCPWithRTP() { fMultiplexRTCPWithRTP = True; }
     // An alternative to passing the "multiplexRTCPWithRTP" parameter as True in the constructor

   void setRTCPAppPacketHandler(RTCPAppHandlerFunc* handler, void* clientData);
     // Sets a handler to be called if a RTCP "APP" packet arrives from any future client.
     // (Any current clients are not affected; any "APP" packets from them will continue to be
     // handled by whatever handler existed when the client sent its first RTSP "PLAY" command.)
     // (Call with (NULL, NULL) to remove an existing handler - for future clients only)

   void sendRTCPAppPacket(u_int8_t subtype, char const* name,
 			 u_int8_t* appDependentData, unsigned appDependentDataSize);
     // Sends a custom RTCP "APP" packet to the most recent client (if "reuseFirstSource" was False),
     // or to all current clients (if "reuseFirstSource" was True).
     // The parameters correspond to their
     // respective fields as described in the RTP/RTCP definition (RFC 3550).
     // Note that only the low-order 5 bits of "subtype" are used, and only the first 4 bytes
     // of "name" are used.  (If "name" has fewer than 4 bytes, or is NULL,
     // then the remaining bytes are '\0'.)

 protected:
   void setSDPLinesFromRTPSink(RTPSink* rtpSink, FramedSource* inputSource,
 			      unsigned estBitrate);
       // used to implement "sdpLines()"

 protected:
   char* fSDPLines;
   HashTable* fDestinationsHashTable; // indexed by client session id

 private:
   Boolean fReuseFirstSource;
   portNumBits fInitialPortNum;
   Boolean fMultiplexRTCPWithRTP;
   void* fLastStreamToken;
   char fCNAME[100]; // for RTCP
   RTCPAppHandlerFunc* fAppHandlerTask;
   void* fAppHandlerClientData;
   friend class StreamState;
 };


 // A class that represents the state of an ongoing stream.  This is used only internally, in the implementation of
 // "OnDemandServerMediaSubsession", but we expose the definition here, in case subclasses of "OnDemandServerMediaSubsession"
 // want to access it.

 class Destinations {
 public:
   Destinations(struct in_addr const& destAddr,
                Port const& rtpDestPort,
                Port const& rtcpDestPort)
     : isTCP(False), addr(destAddr), rtpPort(rtpDestPort), rtcpPort(rtcpDestPort) {
   }
   Destinations(int tcpSockNum, unsigned char rtpChanId, unsigned char rtcpChanId)
     : isTCP(True), rtpPort(0) /*dummy*/, rtcpPort(0) /*dummy*/,
       tcpSocketNum(tcpSockNum), rtpChannelId(rtpChanId), rtcpChannelId(rtcpChanId) {
   }

 public:
   Boolean isTCP;
   struct in_addr addr;
   Port rtpPort;
   Port rtcpPort;
   int tcpSocketNum;
   unsigned char rtpChannelId, rtcpChannelId;
 };

 class StreamState {
 public:
   StreamState(OnDemandServerMediaSubsession& master,
               Port const& serverRTPPort, Port const& serverRTCPPort,
 	      RTPSink* rtpSink, BasicUDPSink* udpSink,
 	      unsigned totalBW, FramedSource* mediaSource,
 	      Groupsock* rtpGS, Groupsock* rtcpGS);
   virtual ~StreamState();

   void startPlaying(Destinations* destinations, unsigned clientSessionId,
 		    TaskFunc* rtcpRRHandler, void* rtcpRRHandlerClientData,
 		    ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
                     void* serverRequestAlternativeByteHandlerClientData);
   void pause();
   void sendRTCPAppPacket(u_int8_t subtype, char const* name,
 			 u_int8_t* appDependentData, unsigned appDependentDataSize);
   void endPlaying(Destinations* destinations, unsigned clientSessionId);
   void reclaim();

   unsigned& referenceCount() { return fReferenceCount; }

   Port const& serverRTPPort() const { return fServerRTPPort; }
   Port const& serverRTCPPort() const { return fServerRTCPPort; }

   RTPSink* rtpSink() const { return fRTPSink; }
   RTCPInstance* rtcpInstance() const { return fRTCPInstance; }

   float streamDuration() const { return fStreamDuration; }

   FramedSource* mediaSource() const { return fMediaSource; }
   float& startNPT() { return fStartNPT; }

 private:
   OnDemandServerMediaSubsession& fMaster;
   Boolean fAreCurrentlyPlaying;
   unsigned fReferenceCount;

   Port fServerRTPPort, fServerRTCPPort;

   RTPSink* fRTPSink;
   BasicUDPSink* fUDPSink;

   float fStreamDuration;
   unsigned fTotalBW;
   RTCPInstance* fRTCPInstance;

   FramedSource* fMediaSource;
   float fStartNPT; // initial 'normal play time'; reset after each seek

   Groupsock* fRTPgs;
   Groupsock* fRTCPgs;
 };

 #endif
	/**********
	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
	**********/
	// "liveMedia"
	// Copyright (c) 1996-2020 Live Networks, Inc. All rights reserved.
	// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
	// on demand.
	// C++ header

	#ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
	#define _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH

	#ifndef _SERVER_MEDIA_SESSION_HH
	#include "ServerMediaSession.hh"
	#endif
	#ifndef _RTP_SINK_HH
	#include "RTPSink.hh"
	#endif
	#ifndef _BASIC_UDP_SINK_HH
	#include "BasicUDPSink.hh"
	#endif
	#ifndef _RTCP_HH
	#include "RTCP.hh"
	#endif

	class OnDemandServerMediaSubsession: public ServerMediaSubsession {
	protected: // we're a virtual base class
	OnDemandServerMediaSubsession(UsageEnvironment& env, Boolean reuseFirstSource,
	portNumBits initialPortNum = 6970,
	Boolean multiplexRTCPWithRTP = False);
	virtual ~OnDemandServerMediaSubsession();

	protected: // redefined virtual functions
	virtual char const* sdpLines();
	virtual void getStreamParameters(unsigned clientSessionId,
	netAddressBits clientAddress,
	Port const& clientRTPPort,
	Port const& clientRTCPPort,
	int tcpSocketNum,
	unsigned char rtpChannelId,
	unsigned char rtcpChannelId,
	netAddressBits& destinationAddress,
	u_int8_t& destinationTTL,
	Boolean& isMulticast,
	Port& serverRTPPort,
	Port& serverRTCPPort,
	void*& streamToken);
	virtual void startStream(unsigned clientSessionId, void* streamToken,
	TaskFunc* rtcpRRHandler,
	void* rtcpRRHandlerClientData,
	unsigned short& rtpSeqNum,
	unsigned& rtpTimestamp,
	ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
	void* serverRequestAlternativeByteHandlerClientData);
	virtual void pauseStream(unsigned clientSessionId, void* streamToken);
	virtual void seekStream(unsigned clientSessionId, void* streamToken, double& seekNPT, double streamDuration, u_int64_t& numBytes);
	virtual void seekStream(unsigned clientSessionId, void* streamToken, char& absStart, char& absEnd);
	virtual void nullSeekStream(unsigned clientSessionId, void* streamToken,
	double streamEndTime, u_int64_t& numBytes);
	virtual void setStreamScale(unsigned clientSessionId, void* streamToken, float scale);
	virtual float getCurrentNPT(void* streamToken);
	virtual FramedSource* getStreamSource(void* streamToken);
	virtual void getRTPSinkandRTCP(void* streamToken,
	RTPSink const& rtpSink, RTCPInstance const& rtcp);
	virtual void deleteStream(unsigned clientSessionId, void*& streamToken);

	protected: // new virtual functions, possibly redefined by subclasses
	virtual char const* getAuxSDPLine(RTPSink* rtpSink,
	FramedSource* inputSource);
	virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
	// This routine is used to seek by relative (i.e., NPT) time.
	// "streamDuration", if >0.0, specifies how much data to stream, past "seekNPT". (If <=0.0, all remaining data is streamed.)
	// "numBytes" returns the size (in bytes) of the data to be streamed, or 0 if unknown or unlimited.
	virtual void seekStreamSource(FramedSource* inputSource, char& absStart, char& absEnd);
	// This routine is used to seek by 'absolute' time.
	// "absStart" should be a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z".
	// "absEnd" should be either NULL (for no end time), or a string of the same form as "absStart".
	// These strings may be modified in-place, or can be reassigned to a newly-allocated value (after delete[]ing the original).
	virtual void setStreamSourceScale(FramedSource* inputSource, float scale);
	virtual void setStreamSourceDuration(FramedSource* inputSource, double streamDuration, u_int64_t& numBytes);
	virtual void closeStreamSource(FramedSource* inputSource);

	protected: // new virtual functions, defined by all subclasses
	virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
	unsigned& estBitrate) = 0;
	// "estBitrate" is the stream's estimated bitrate, in kbps
	virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
	unsigned char rtpPayloadTypeIfDynamic,
	FramedSource* inputSource) = 0;

	protected: // new virtual functions, may be redefined by a subclass:
	virtual Groupsock* createGroupsock(struct in_addr const& addr, Port port);
	virtual RTCPInstance* createRTCP(Groupsock* RTCPgs, unsigned totSessionBW, /* in kbps */
	unsigned char const* cname, RTPSink* sink);

	public:
	void multiplexRTCPWithRTP() { fMultiplexRTCPWithRTP = True; }
	// An alternative to passing the "multiplexRTCPWithRTP" parameter as True in the constructor

	void setRTCPAppPacketHandler(RTCPAppHandlerFunc* handler, void* clientData);
	// Sets a handler to be called if a RTCP "APP" packet arrives from any future client.
	// (Any current clients are not affected; any "APP" packets from them will continue to be
	// handled by whatever handler existed when the client sent its first RTSP "PLAY" command.)
	// (Call with (NULL, NULL) to remove an existing handler - for future clients only)

	void sendRTCPAppPacket(u_int8_t subtype, char const* name,
	u_int8_t* appDependentData, unsigned appDependentDataSize);
	// Sends a custom RTCP "APP" packet to the most recent client (if "reuseFirstSource" was False),
	// or to all current clients (if "reuseFirstSource" was True).
	// The parameters correspond to their
	// respective fields as described in the RTP/RTCP definition (RFC 3550).
	// Note that only the low-order 5 bits of "subtype" are used, and only the first 4 bytes
	// of "name" are used. (If "name" has fewer than 4 bytes, or is NULL,
	// then the remaining bytes are '\0'.)

	protected:
	void setSDPLinesFromRTPSink(RTPSink* rtpSink, FramedSource* inputSource,
	unsigned estBitrate);
	// used to implement "sdpLines()"

	protected:
	char* fSDPLines;
	HashTable* fDestinationsHashTable; // indexed by client session id

	private:
	Boolean fReuseFirstSource;
	portNumBits fInitialPortNum;
	Boolean fMultiplexRTCPWithRTP;
	void* fLastStreamToken;
	char fCNAME[100]; // for RTCP
	RTCPAppHandlerFunc* fAppHandlerTask;
	void* fAppHandlerClientData;
	friend class StreamState;
	};


	// A class that represents the state of an ongoing stream. This is used only internally, in the implementation of
	// "OnDemandServerMediaSubsession", but we expose the definition here, in case subclasses of "OnDemandServerMediaSubsession"
	// want to access it.

	class Destinations {
	public:
	Destinations(struct in_addr const& destAddr,
	Port const& rtpDestPort,
	Port const& rtcpDestPort)
	: isTCP(False), addr(destAddr), rtpPort(rtpDestPort), rtcpPort(rtcpDestPort) {
	}
	Destinations(int tcpSockNum, unsigned char rtpChanId, unsigned char rtcpChanId)
	: isTCP(True), rtpPort(0) /dummy/, rtcpPort(0) /dummy/,
	tcpSocketNum(tcpSockNum), rtpChannelId(rtpChanId), rtcpChannelId(rtcpChanId) {
	}

	public:
	Boolean isTCP;
	struct in_addr addr;
	Port rtpPort;
	Port rtcpPort;
	int tcpSocketNum;
	unsigned char rtpChannelId, rtcpChannelId;
	};

	class StreamState {
	public:
	StreamState(OnDemandServerMediaSubsession& master,
	Port const& serverRTPPort, Port const& serverRTCPPort,
	RTPSink* rtpSink, BasicUDPSink* udpSink,
	unsigned totalBW, FramedSource* mediaSource,
	Groupsock* rtpGS, Groupsock* rtcpGS);
	virtual ~StreamState();

	void startPlaying(Destinations* destinations, unsigned clientSessionId,
	TaskFunc* rtcpRRHandler, void* rtcpRRHandlerClientData,
	ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
	void* serverRequestAlternativeByteHandlerClientData);
	void pause();
	void sendRTCPAppPacket(u_int8_t subtype, char const* name,
	u_int8_t* appDependentData, unsigned appDependentDataSize);
	void endPlaying(Destinations* destinations, unsigned clientSessionId);
	void reclaim();

	unsigned& referenceCount() { return fReferenceCount; }

	Port const& serverRTPPort() const { return fServerRTPPort; }
	Port const& serverRTCPPort() const { return fServerRTCPPort; }

	RTPSink* rtpSink() const { return fRTPSink; }
	RTCPInstance* rtcpInstance() const { return fRTCPInstance; }

	float streamDuration() const { return fStreamDuration; }

	FramedSource* mediaSource() const { return fMediaSource; }
	float& startNPT() { return fStartNPT; }

	private:
	OnDemandServerMediaSubsession& fMaster;
	Boolean fAreCurrentlyPlaying;
	unsigned fReferenceCount;

	Port fServerRTPPort, fServerRTCPPort;

	RTPSink* fRTPSink;
	BasicUDPSink* fUDPSink;

	float fStreamDuration;
	unsigned fTotalBW;
	RTCPInstance* fRTCPInstance;

	FramedSource* fMediaSource;
	float fStartNPT; // initial 'normal play time'; reset after each seek

	Groupsock* fRTPgs;
	Groupsock* fRTCPgs;
	};

	#endif