rtms2DdtGateway.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <limits>
 
#include <ifw/fnd/defs/dataType.hpp>
 
#include <ifw/rtmstools/rtms2ddtlib_llnetio/ddtImage.hpp>
#include <ifw/rtmstools/llnetio/receiverToolStats.hpp>
#include <ifw/rtmslib_llnetio/rtmsReceiver.hpp>
#include <ifw/rtmslib_llnetio/sampleExtInfo.hpp>
#include <ifw/rtmslib_llnetio/logger.hpp>
 
namespace ifw::rtmstools::rtms2ddtlib_llnetio {
 
    constexpr auto RTMSTOOLS_DDT_NB_SAMPLE = 5;
 
    inline uint32_t GetDdtDataType(ifw::fnd::datatype::DataType data_type) {
      switch (data_type) {
        case ifw::fnd::datatype::DataType::INT16:
        case ifw::fnd::datatype::DataType::UINT16:
          return ddt::SINT16;
        case ifw::fnd::datatype::DataType::INT32:
          break;
        case ifw::fnd::datatype::DataType::FLOAT:
          break;
        case ifw::fnd::datatype::DataType::INT64:
          break;
        case ifw::fnd::datatype::DataType::DOUBLE:
          break;
        case ifw::fnd::datatype::DataType::BYTE:
          return ddt::UINT8;
        default:
          return -1;
      };
      return -1;
    }

    class Rtms2DdtGateway: public ifw::rtmslib::RtmsReceiver {
      public:
 
        Rtms2DdtGateway(const std::string& receiver_ip,
                        const std::string& interface_name,
                        const int port,
                        const ifw::fnd::datatype::DataType data_type,
                        const int width,
                        const int height,
                        const std::string& ddt_broker_uri,
                        const std::string& ddt_stream,
                        const double ddt_interval,
                        const uint16_t mtu_size,
                        const int32_t topic_id,
                        ifw::rtmslib::ExtendedInfoMode ext_info_mode,
                        std::string log_file = ifw::rtmslib::RTMSLIB_LOG_PROPS,
                        std::string log_level = "ERROR");
 
        ~Rtms2DdtGateway();
 
        virtual void HandleSampleUser(ifw::rtmslib::SampleExtInfo& ext_info,
                                      std::vector<uint8_t>& sample_payload);
 
        ifw::rtmstools::llnetio::ReceiverToolStats GetStatistics() const;
        void StopReceiving() { RequestStop(); }
 
      private:
        bool EnsureGeometry(const ifw::rtmslib::SampleExtInfo& ext_info,
                            std::size_t payload_size);
        void ResetIntervalStats();
        void UpdateIntervalStats(double interval_ms);
 
          int                       m_width;
          int                       m_height;
          ifw::fnd::datatype::DataType   m_datatype;
          std::string               m_ddt_broker_uri;
          std::string               m_ddt_stream;
          double                    m_ddt_interval;
          int                       m_im_size;
          std::shared_ptr<DdtImage>  m_ddt_image;
 
          ddt::DdtLogger*                          m_ddt_logger;
          std::unique_ptr<ddt::DdtDataPublisher>   m_ddt_pub;
          DdtEncDecImage3D                         m_encoder;
          MetaDataElementsImage3D                  m_ddt_metadata;
          bool                                     m_initialised{false};
          bool                                     m_geometry_known{false};
          bool                                     m_missing_geometry_logged{false};
          bool                                     m_missing_bii_logged{false};
 
          // Stats tracking
          uint32_t                                 m_samples_received{0};
          uint32_t                                 m_samples_lost{0};
          uint32_t                                 m_last_sample_id{0};
          uint64_t                                 m_total_bytes{0};
          std::chrono::steady_clock::time_point    m_start_time{};
          std::chrono::steady_clock::time_point    m_last_sample_time{};
          double                                   m_min_interval_ms{std::numeric_limits<double>::max()};
          double                                   m_max_interval_ms{0.0};
          double                                   m_sum_interval_ms{0.0};
          uint64_t                                 m_interval_count{0};
          double                                   m_interval_mean_ms{0.0};
          double                                   m_interval_m2_ms{0.0};
 
    };
}