live.h

Go to the documentation of this file.

#ifndef live_HEADER_GUARD
#define live_HEADER_GUARD
/*
 * live.h : Interface to live555
 * 
 * (c) Copyright 2017-2024 Sampsa Riikonen
 * 
 * Authors: Sampsa Riikonen <sampsa.riikonen@iki.fi>
 * 
 * This file is part of the Valkka library.
 * 
 * Valkka 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.
 * 
 * This program 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 program.  If not, see <https://www.gnu.org/licenses/>
 *
 */
 
#include "livedep.h"
#include "frame.h"
#include "framefifo.h"
#include "framefilter.h"
#include "logging.h"
 
UsageEnvironment& operator<<(UsageEnvironment& env, const RTSPClient& rtspClient);       
UsageEnvironment& operator<<(UsageEnvironment& env, const MediaSubsession& subsession);  
Logger& operator<<(Logger& logger, const RTSPClient& rtspClient);                        
Logger& operator<<(Logger& logger, const MediaSubsession& subsession);                   
void usage(UsageEnvironment& env, char const* progName);
 
 
 
enum class LiveStatus {
  none,          
  pending,       
  alive,         
  closed         
};
 
 
class StreamClientState {
public:
  StreamClientState();            
  virtual ~StreamClientState();   
 
public:
  MediaSubsessionIterator* iter;  
  int subsession_index;           
  MediaSession* session;          
  MediaSubsession* subsession;    
  TaskToken streamTimerTask;
  TaskToken pingGetParameterTask;      
  
  double duration;
  bool frame_flag;                
  
public:
  void close();                   
  
public: // setters & getters
  void setFrame()     {this->frame_flag=true;}
  void clearFrame()   {this->frame_flag=false;}
  bool gotFrame()     {return this->frame_flag;}
};
 
 
 
class ValkkaRTSPClient: public RTSPClient {
  
public:
  static ValkkaRTSPClient* createNew(UsageEnvironment& env, const std::string rtspURL, FrameFilter& framefilter, LiveStatus* livestatus, bool& termplease, int verbosityLevel = 0, char const* applicationName = NULL, portNumBits tunnelOverHTTPPortNum = 0);
  
protected:
  ValkkaRTSPClient(UsageEnvironment& env, const std::string rtspURL, FrameFilter& framefilter, LiveStatus* livestatus, bool& termplease, int verbosityLevel, char const* applicationName, portNumBits tunnelOverHTTPPortNum);
  virtual ~ValkkaRTSPClient();
  
public:
  bool  passthrough;             
 
public:
  StreamClientState scs;
  FrameFilter& framefilter;     
  LiveStatus* livestatus;       
  bool& termplease;             
 
public: // some extra parameters and their setters
  bool     request_multicast; 
  bool     request_tcp;       
  unsigned recv_buffer_size;  
  unsigned reordering_time;   
  void     requestMulticast()               {this->request_multicast=true;}
  void     requestTCP()                     {this->request_tcp=true;}
  void     setRecvBufferSize(unsigned i)    {this->recv_buffer_size=i;}
  void     setReorderingTime(unsigned i)    {this->reordering_time=i;}
  
public: 
  // Response handlers
  static void continueAfterDESCRIBE(RTSPClient* rtspClient, int resultCode, char* resultString); 
  static void continueAfterGET_PARAMETER(RTSPClient* rtspClient, int resultCode, char* resultString); 
  static void continueAfterSETUP(RTSPClient* rtspClient, int resultCode, char* resultString);    
  static void continueAfterPLAY(RTSPClient* rtspClient, int resultCode, char* resultString);     
 
  // Other event handler functions:
  static void subsessionAfterPlaying(void* clientData); 
  static void subsessionByeHandler(void* clientData);   
  static void streamTimerHandler(void* clientData);     
  static void setupNextSubsession(RTSPClient* rtspClient); 
  static void shutdownStream(RTSPClient* rtspClient, int exitCode = 1); 
  static void pingGetParameter(void* clientData); 
};
 
 
class FrameSink: public MediaSink {
 
public:
 
  static FrameSink* createNew(UsageEnvironment& env, 
    StreamClientState& scs, FrameFilter& framefilter, bool& passthrough,
    char const* streamId = NULL);
 
private:
  FrameSink(UsageEnvironment& env, 
    StreamClientState& scs, FrameFilter& framefilter, bool& passthrough,
   char const* streamId);
  virtual ~FrameSink();
 
  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:
  void setReceiveBuffer(unsigned target_size);     
  unsigned checkBufferSize(unsigned target_size);  
  void sendParameterSets();                        
  
private: // redefined virtual functions:
  virtual Boolean continuePlaying();  
 
private:
  StreamClientState &scs;
  u_int8_t*         fReceiveBuffer;
  long unsigned     nbuf;       
  MediaSubsession&  fSubsession;
  char*             fStreamId;
  FrameFilter&      framefilter;
  SetupFrame        setupframe;  
  BasicFrame        basicframe;  
  int               subsession_index;
  bool&             passthrough; 
 
public: // getters & setters
  uint8_t* getReceiveBuffer() {return fReceiveBuffer;}
  
public:
  bool on;
};
 
#endif