RTP.h

#pragma once
 
#include "../Video/IVideoDecoder.h"
 
#include "Base.h"
 
#include "Foundation/Network/Address.h"
#include "Foundation/Network/Connection.h"
 
#include <unordered_map>
#include <mutex>
 
namespace jrtplib{
  class RTPSession;
}// namespace ...
 
namespace Cogs{
  namespace Core{ class Context; };
 
  struct COGSCORE_DLL_API RTPStream
  {
    RTPStream(Core::Context * context,
              uint32_t clock_rate = 90000,
              uint16_t client_port = 0,
              Cogs::Network::AddrIn mc_adapter = Cogs::Network::AddrIn(),
              bool udp = true);
    ~RTPStream();
 
    RTPStream(const RTPStream&) = delete;
    RTPStream& operator=(const RTPStream&) = delete;
    RTPStream(RTPStream&&) = delete;
    RTPStream& operator=(RTPStream&&) = delete;
 
    void setUserData(intptr_t data) { userData = data; }
    void setConnectTimeout(int64_t milliseconds) { tcpConnection.setConnectTimeout(milliseconds); }
 
    uint16_t GetRTPPort() const { return rtp_port; }
    uint16_t GetRTCPPort() const { return rtcp_port; }
    intptr_t getUserData() const { return userData; }
 
    void AddDestination(const uint8_t ip[4], uint16_t server_port);
    void JoinMulticastGroup(const uint8_t ip[4], uint16_t server_port);
 
    void SendPacket(const uint8_t *buffer, size_t size);
 
    void AddSSRC(uint32_t ssrc, Cogs::Core::Codec codec, ResourceId textureId);
 
    struct Dest;
    void WriteData(Dest &dest);
 
    Dest *GetLatestStream();
 
    void Update();
 
    Core::Context * context = nullptr;
    bool use_pool_thread = false;
    bool useUDP = true;
 
    uint32_t clock_rate = 0;
    uint16_t client_port = 0;
    uint16_t server_port = 0;
    uint8_t ip[4] = {};
 
    uint16_t rtp_port = 0;
    uint16_t rtcp_port = 0;
    jrtplib::RTPSession *session = nullptr;
 
    Cogs::Core::Codec codec = Cogs::Core::Codec::None;
 
    bool rtp_one_byte_header_extension = true; // rfc5285
    bool rtp_two_byte_header_extension = false; // rfc5285
 
    uint16_t rfc6051_ext_id = 1; // rfc6051: Synchronisation metadata: 64-bit timestamp format
 
    uint32_t stream_number = 0;
    struct Dest{
      Cogs::Core::TextureHandle textureHandle;
      Cogs::Core::Codec codec;
 
      bool first = true;
      uint64_t receive_time = 0, prev_receive_time = 0; // us
      uint64_t timestamp = 0, prev_timestamp = 0; // us
      size_t size = 0;
      uint32_t eseq = 0, prev_eseq = 0;
      uint32_t dropped_packages = 0, last_dropped = 0;
 
      uint32_t size_akk = 0;
      double rate = 0.0;
      uint64_t rate_time = 0;
 
      FILE *fp = nullptr;
      char *buffer = nullptr;
      size_t buffer_use = 0;
      size_t buffer_size = 0;
      uint64_t buffer_timestamp = 0;
      bool buffer_first = false;
      bool buffer_last = false;
      bool buffer_discontinuity = false;
 
      std::string vps;
      std::string sps;
      std::string pps;
      Memory::MemoryBuffer nalu;  // Current NALU being processed.
    };
    std::mutex dest_mu;
    std::unordered_map<uint32_t, Dest> dest;
 
  private:
    Cogs::Network::ConnectionTCP tcpConnection;
    intptr_t userData;
 
    void processH264NALU(Dest& dest, uint32_t rtpType, const void* data, size_t size);
    void processH265NALU(Dest& dest, uint32_t rtpType, const void* data, size_t size);
  };
}// namespace ...