RTSP.h

#pragma once
 
#include "Base.h"
 
#include "Foundation/Memory/MemoryBuffer.h"
#include "Foundation/Network/Connection.h"
#include "Foundation/Platform/Threads.h"
 
#include <algorithm>
#include <deque>
#include <map>
#include <string>
#include <vector>
 
typedef void CURL;
 
namespace Cogs{
  class COGSCORE_DLL_API RTSP : public Network::ConnectionTCP {
  public:
    struct MediaDescription {
      std::string media_name; // m=video 0 RTP/AVP 96
      std::string media_type; // video audio
      std::string control_id;
      uint32_t    rtp_payload_type; // 96, 97, 98, 99
      std::string encoding_name; // H264, MPA
      uint32_t    rtp_clock_rate; // 90000 Hz
      uint32_t    packetization_mode; // 1
      uint32_t    profile_level_id;
      std::string vps;
      std::string sps;
      std::string pps;
      uint16_t    server_port[2] = {};
      uint16_t    client_port[2] = {};
      uint32_t    ssrc = 0;
      uint8_t     ip[4];
    };
 
    struct CaseInsensitiveCompare {
      bool operator()(const std::string& lhs, const std::string& rhs) const {
        std::string s1;
        std::string s2;
 
        s1.resize(lhs.size());
        s2.resize(rhs.size());
 
        std::transform(lhs.begin(), lhs.end(), s1.begin(), [](unsigned char c){ return std::tolower(c); });
        std::transform(rhs.begin(), rhs.end(), s2.begin(), [](unsigned char c){ return std::tolower(c); });
 
        return s1 < s2;
      }
    };
 
    struct Message : Memory::MemoryBuffer {
      using HeaderMap = std::map<std::string, std::string, CaseInsensitiveCompare>;
 
      std::string firstLine;                  
      HeaderMap   headers;                    
      void*       userData = nullptr;         
      bool        finishedHeaders = false;    
      bool        finishedBody = false;       
 
      void reset() {
        MemoryBuffer::clear();
        firstLine.clear();
        headers.clear();
        userData = nullptr;
        finishedHeaders = false;
        finishedBody = false;
      }
    };
 
    using MediaList = std::vector<MediaDescription>;
 
                                  RTSP(std::string_view url, std::string_view userAgent = "Cogs/1.0");
                                  ~RTSP();
 
            bool                  sendSetup(MediaDescription& mediaDescription, const std::string& mediaURL, uint16_t client_port_a, uint16_t client_port_b);
            bool                  sendPlay();
            bool                  sendPause();
            bool                  sendTeardown();
 
            bool                  isActive() const                { return is_active; }
 
            const std::string&    getOriginalURL() const          { return originalURL; }
            const MediaList&      getMediaDescriptions() const    { return mediaDescriptions; }
 
  protected:
            MediaList             mediaDescriptions;    
            bool                  has_describe : 1;
            bool                  has_setup : 1;
            bool                  has_play : 1;
            bool                  has_pause : 1;
            bool                  has_teardown : 1;
            bool                  has_set_parameter : 1;
            bool                  has_get_parameter : 1;
            bool                  is_active : 1;
            bool                  has_video : 1;
            bool                  has_audio : 1;
 
    virtual bool                  processOutgoing() override;
    virtual bool                  processIncoming() override;
    virtual void                  processIncomingMessage(Message& message);
 
    virtual void                  receivedMediaDescriptions() = 0;
    virtual void                  receivedStreamSetup(MediaDescription& md) = 0;
 
            void                  queueMessage(Message* message);
 
  private:
            std::deque<Message*>  queuedMessages;             
            Cogs::Mutex           queueMutex;                 
            Memory::MemoryBuffer  outgoingBuffer;             
            Message*              outgoingMessage = nullptr;  
            std::deque<Message*>  sentMessages;               
            Memory::MemoryBuffer  incomingBuffer;             
            Message               incomingMessage;            
            std::string           originalURL;                
            std::string           userInfo;                   
            std::string           hostname;                   
            std::string           resourcePath;               
            uint16_t              hostPort = 554;             
            std::string           agentString;                
            int                   sequenceNumber = 0;         
            std::string           sessionID;                  
            int64_t               timeout = 60000;            
            int64_t               keepAliveTime = 0;          
 
            void                  addStandardHeaders(Message& message);
            bool                  breakdownURL(std::string_view uri);
            std::string           buildURL(std::string_view method);
            void                  parseSDP(const std::string& sdp);
 
            void                  sendOptions();
            void                  sendDescribe();
  };
}