liveserver.h

Go to the documentation of this file.

#ifndef SERVER_HEADER_GUARD 
#define SERVER_HEADER_GUARD
 
/*
 * liveserver.h : Live555 interface for server side: streaming to udp sockets directly or by using an on-demand rtsp server
 * 
 * (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/>
 *
 */
 
// TODO!  There is no way to close these suckers with Medium::close().  Then BasicUsageEnvironment can't be reclaimed at we get a (minor) memory leak upon exit.
 
#include "livedep.h"
#include "framefifo.h"
#include "frame.h"
#include "logging.h"
 
 
class BufferSource: public FramedSource {
 
public:
  BufferSource(UsageEnvironment &env, FrameFifo &fifo, Boolean &canary, unsigned preferredFrameSize = 0, unsigned playTimePerFrame =0, unsigned offset=0);
  virtual ~BufferSource();
  
private:
  virtual void doGetNextFrame();  
  
private:
  FrameFifo &fifo;                
  Boolean   &canary;              
  unsigned  fPreferredFrameSize;
  unsigned  fPlayTimePerFrame;
  unsigned  offset;
  std::mutex mutex;
  long int  prevtime;
  
public:
  std::deque<BasicFrame*> internal_fifo; 
  bool      active;             
  
public:
  void handleFrame(Frame* f);   
  
};
 
 
class Stream {
  
public:
  Stream(UsageEnvironment &env, FrameFifo &fifo, const std::string adr, unsigned short int portnum, const unsigned char ttl=255);
  virtual ~Stream();
  
protected:
  UsageEnvironment  &env;   
  FrameFifo         &fifo;  
  
  RTPSink           *sink;  
  RTCPInstance      *rtcp;
  
  Groupsock  *rtpGroupsock;
  Groupsock  *rtcpGroupsock;
  unsigned char cname[101];
  
  BufferSource *buffer_source;   
  FramedSource *terminal;        
  Boolean      source_alive;   
  
public:
  void handleFrame(Frame *f);
  void startPlaying();
  static void afterPlaying(void* cdata);
};
 
 
 
class ValkkaServerMediaSubsession: public OnDemandServerMediaSubsession {
  
protected: // we're a virtual base class
  ValkkaServerMediaSubsession(UsageEnvironment &env, FrameFifo &fifo, Boolean reuseFirstSource);
  virtual ~ValkkaServerMediaSubsession();
 
protected:
  // char const* fFileName;
  // u_int64_t fFileSize; // if known
  BufferSource *buffer_source;  
  FrameFifo    &fifo;
  Boolean      source_alive;   
  
protected:
  virtual void setDoneFlag() =0; 
  
public:
  void handleFrame(Frame *f);   
};
 
 
 
class H264ServerMediaSubsession: public ValkkaServerMediaSubsession {
  
public:
  static H264ServerMediaSubsession* createNew(UsageEnvironment& env, FrameFifo &fifo, Boolean reuseFirstSource);
  // Used to implement "getAuxSDPLine()":
  void checkForAuxSDPLine1();
  void afterPlayingDummy1();
 
protected:
  static void afterPlayingDummy(void* clientData);
  static void checkForAuxSDPLine(void* clientData);
  
protected:
  H264ServerMediaSubsession(UsageEnvironment& env, FrameFifo &fifo, Boolean reuseFirstSource); // called only by createNew();
  virtual ~H264ServerMediaSubsession();
  void setDoneFlag() { fDoneFlag = ~0; }
 
protected: // redefined virtual functions
  virtual char const* getAuxSDPLine(RTPSink* rtpSink, FramedSource* inputSource);
  virtual FramedSource* createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate); // returns BufferSource, framed with correct type
  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource); // returns H264RTPSink
 
private:
  char* fAuxSDPLine;
  char fDoneFlag; // used when setting up "fAuxSDPLine"
  RTPSink* fDummyRTPSink; // ditto
};
 
 
 
class H264Stream : public Stream {
 
public:
  H264Stream(UsageEnvironment &env, FrameFifo &fifo, const std::string adr, unsigned short int portnum, const unsigned char ttl=255);
  ~H264Stream();
    
};
 
#endif