rtmsSender.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <csignal>
#include <cerrno>
#include <thread>
#include <chrono>
#include <cstdint>
 
#include <boost/endian/arithmetic.hpp>
 
#include <fmt/format.h>
 
#include <llnetio/ipv4.hpp>
#include <llnetio/mudpi/io.hpp>
#include <llnetio/rtms/io.hpp>
#include <llnetio/rtms/rtms.hpp>
#include <llnetio/udpSocket.hpp>
#include <llnetio/mockSocket.hpp>
 
#include <ifw/rtmslib_llnetio/logger.hpp>
#include <ifw/rtmslib_llnetio/common.hpp>
#include <ifw/rtmslib_llnetio/sampleExtInfo.hpp>
 
namespace ifw::rtmslib {
 
  class SenderConfig {
    public:
      SenderConfig() {};
 
      uint16_t         mtu_size{1500};
      int32_t          topic_id{10};
      uint16_t         component_id{12345};
      bool             simulation{false};
 
      // Extended info layout to emit in leader packets.
      ExtendedInfoMode ext_info_mode{ExtendedInfoMode::None};
 
      // Optional per-packet pacing delay in MICROSECONDS. <= 0 disables pacing.
      // Implemented as a deadline-based busy-spin (see SpinWaitUntil in the .cpp),
      // NOT a sleep_for: at high packet rates a syscall sleep's granularity floor
      // (~tens-hundreds of µs) and overhead would dwarf the intended delay and
      // accumulate into large per-frame stalls. The deadline scheme is also
      // drift-free (the average inter-packet rate stays accurate).
      int16_t          packet_send_delay{-1};
 
      // The next flag is used to make the RTMS Sender continue trying to send, even if there is
      // no receiver running.
      bool             ignore_connection_refused{true};
  };
 

    class RtmsSender {
      public:

        RtmsSender(const std::string&    src_ip,  
                   const std::string&    dest_ip,
                   const int             dest_port,
                   const int8_t          bytes_per_pixel,
                   const size_t          raw_image_size,
                   const SenderConfig&   sndr_cfg = SenderConfig());
 
        virtual ~RtmsSender();

        int SendSample(const SampleExtInfo& ext_info,
                       const std::vector<uint8_t>& sample_payload);
 
        int GetPixelsPerSample() const;
 
        uint32_t    m_sample_id;
 
    private:
      void Initialise(const SampleExtInfo& ext_info);
 
      // Helper to aggregate and throttle logging of connection refused errors
      void LogConnRefusedIfNeeded(const char* where, const std::error_code& ec);
 
      std::string                              m_src_ip;
      std::string                              m_dest_ip;
      int                                      m_dest_port;
      int8_t                                   m_bytes_per_pixel;
      size_t                                   m_raw_image_size;
      SenderConfig                             m_sndr_cfg;
 
      size_t                                   m_pixels_per_sample;
      size_t                                   m_current_raw_image_size{0};
      int32_t                                  m_nb_of_udp_packets;
 
      llnetio::UdpTxSocket::Config             m_udp_cfg{};
      std::unique_ptr<llnetio::UdpTxSocket>    m_udp_socket;
      llnetio::mudpi::Sender::Config           m_mudpi_cfg{};
      std::unique_ptr<llnetio::mudpi::Sender>  m_mudpi_sender;
      llnetio::rtms::Sender::Config            m_rtms_cfg{};
      std::unique_ptr<llnetio::rtms::Sender>   m_rtms_sender;
 
      std::vector<uint8_t>                     m_packed_ext_info;
 
      // State for connection-refused logging (throttled)
      std::chrono::steady_clock::time_point    m_last_conn_refused_log{};
      std::uint64_t                            m_conn_refused_errors{0};
 
    };
}