common.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
#include <iostream>
#include <thread>
 
#include <boost/endian/arithmetic.hpp>
 
#include <fmt/format.h>
 
#include <fitsio.h>
 
#include <llnetio/mudpi/io.hpp>
#include <llnetio/rtms/io.hpp>
#include <llnetio/rtms/rtms.hpp>
 
#include <ifw/fnd/defs/dataType.hpp>
#include <ifw/fnd/tools/tools.hpp>
#include <ifw/rtmslib_llnetio/sampleExtInfo.hpp>
 
namespace ifw::rtmslib {
 
    enum class ExtendedInfoMode {
        None,              
        TimestampOnly,     
        BasicImageInfo,    
    };
 
    // Computed per-packet overheads (MUDPI + RTMS headers, no padding).
    constexpr auto MAX_NB_BUFFERS_FOR_UDP_PACKET = 6;
    constexpr auto UDP_HDR_SZ = 8;
    constexpr auto IP_HDR_SZ = 20;
    constexpr auto CHECK_SUM_HDR_SZ = 2;
    constexpr std::size_t RTMS_LEADER_HDR_SZ =
        sizeof(llnetio::mudpi::Header) +
        sizeof(llnetio::rtms::CommonHeader) +
        sizeof(llnetio::rtms::LeaderHeader);
    constexpr std::size_t RTMS_PAYLOAD_HDR_SZ =
        sizeof(llnetio::mudpi::Header) +
        sizeof(llnetio::rtms::CommonHeader) +
        sizeof(llnetio::rtms::PayloadHeader);
    constexpr std::size_t MUDPI_HDR_SZ = 
        RTMS_PAYLOAD_HDR_SZ + 
        UDP_HDR_SZ +
        IP_HDR_SZ +
        CHECK_SUM_HDR_SZ;  
    constexpr std::size_t RTMS_TRAILER_HDR_SZ = RTMS_LEADER_HDR_SZ;
    constexpr auto LEADER_TRAILER_PACKET_NB = 2;
 
    inline constexpr uint16_t ExtInfoSizeFromMode(ExtendedInfoMode mode) {
        switch (mode) {
            case ExtendedInfoMode::None:
                return 0;
            case ExtendedInfoMode::TimestampOnly:
                return static_cast<uint16_t>(sizeof(double));
            case ExtendedInfoMode::BasicImageInfo:
            default:
                return static_cast<uint16_t>(SIZE_SAMPLE_EXT_INFO);
        }
    }
 
    inline constexpr const char* ToString(ExtendedInfoMode mode) {
        switch (mode) {
            case ExtendedInfoMode::None:
                return "None";
            case ExtendedInfoMode::TimestampOnly:
                return "TimestampOnly";
            case ExtendedInfoMode::BasicImageInfo:
            default:
                return "BasicImageInfo";
        }
    }
 
    std::string ExtInfoSummary(const std::vector<uint8_t>& packed_ext_info);
 
// The RTMSLIB_DEBUG environment variable can be defined to switch on log level 
// debugging in the RTMS Lib.
constexpr const char* RTMSLIB_DEBUG = "RTMSLIB_DEBUG";
 
extern int8_t __rtmslib_debug__;
 
#define RTT_DEBUG \
    if (__rtmslib_debug__ == -1) { \
        __rtmslib_debug__ = std::getenv(RTMSLIB_DEBUG) != nullptr; \
    } \
    if (__rtmslib_debug__) 
 
#define RTT_PRINT(msg) \
    do { \
        fmt::print("RTMSLIB-DEBUG:{}:{}: {}\n", ifw::rtmslib::Time(), IFWLOC, msg); \
    } while (0);
 
  inline double Time() {
    std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();
    auto duration = now.time_since_epoch();
    auto time_now_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(duration).count();
    return (time_now_ns / 1e9);
  }
 
  inline void Sleep(const double sleep_time) {
    std::chrono::duration<double> chrono_sleep_time(sleep_time);
    std::this_thread::sleep_for(chrono_sleep_time);
  }
 
  void HandleCfitsioError(const std::string& operation,
                          const int cfitsio_status);
 
  std::tuple<std::vector<uint8_t>, int, int, int, int> LoadFitsImageCube(const char* filename);
 
}