sampleExtInfo.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <vector>
#include <stdexcept>
#include <cstring>
#include <boost/endian/conversion.hpp>
 
#include <ifw/fnd/defs/dataType.hpp>
 
 
namespace ifw::rtmslib {
 
  // Full extended-info size: timestamp + datatype + width + height + offset_x + offset_y
  constexpr std::size_t SIZE_SAMPLE_EXT_INFO = sizeof(double) + 5U * sizeof(std::int32_t);
 
  namespace {
    // These defaults must match the in-class initialisers below.
    constexpr double  DEF_TIME_STAMP = 0.0;
    constexpr int32_t DEF_WIDTH      = 0;
    constexpr int32_t DEF_HEIGHT     = 0;
    constexpr int32_t DEF_OFFSET_X   = -1;
    constexpr int32_t DEF_OFFSET_Y   = -1;
  }
 
  class SampleExtInfo {
    public:
      SampleExtInfo();
      explicit SampleExtInfo(double timestamp);
      explicit SampleExtInfo(const std::vector<uint8_t>& sample_ext_info);
 
      ~SampleExtInfo() = default;
 
      SampleExtInfo& SetTimestamp(double timestamp);
      double GetTimestamp() const;
 
      SampleExtInfo& SetDataType(ifw::fnd::datatype::DataType datatype);
      ifw::fnd::datatype::DataType GetDataType() const;
 
      SampleExtInfo& SetWidth(std::int32_t width);
      std::int32_t GetWidth() const;
 
      SampleExtInfo& SetHeight(std::int32_t height);
      std::int32_t GetHeight() const;
 
      SampleExtInfo& SetOffsetX(std::int32_t offset_x);
      std::int32_t GetOffsetX() const;
 
      SampleExtInfo& SetOffsetY(std::int32_t offset_y);
      std::int32_t GetOffsetY() const;

      void Pack(std::vector<uint8_t>& sample_ext_info_packed) const;

      void Unpack(const std::vector<uint8_t>& sample_ext_info_packed);

      int32_t GetExtInfoSize() const;
 
 
    private:
      double                        m_timestamp{DEF_TIME_STAMP};
      ifw::fnd::datatype::DataType  m_datatype{ifw::fnd::datatype::DataType::UNSPECIFIED};
      std::int32_t                  m_width{DEF_WIDTH};
      std::int32_t                  m_height{DEF_HEIGHT};
      std::int32_t                  m_offset_x{DEF_OFFSET_X};
      std::int32_t                  m_offset_y{DEF_OFFSET_Y};
  };
 
  // ===== Inline implementation ==============================================
 
  inline SampleExtInfo::SampleExtInfo() = default;
 
  inline SampleExtInfo::SampleExtInfo(double timestamp) {
    m_timestamp = timestamp;
  }
 
  inline SampleExtInfo::SampleExtInfo(
      const std::vector<uint8_t>& sample_ext_info) {
    Unpack(sample_ext_info);
  }
 
  inline SampleExtInfo& SampleExtInfo::SetTimestamp(double timestamp) {
    m_timestamp = timestamp;
    return *this;
  }
 
  inline double SampleExtInfo::GetTimestamp() const {
    return m_timestamp;
  }
 
  inline SampleExtInfo& SampleExtInfo::SetDataType(ifw::fnd::datatype::DataType datatype) {
    m_datatype = datatype;
    return *this;
  }
 
  inline ifw::fnd::datatype::DataType SampleExtInfo::GetDataType() const {
    return m_datatype;
  }
 
  inline SampleExtInfo& SampleExtInfo::SetWidth(std::int32_t width) {
    m_width = width;
    return *this;
  }
 
  inline std::int32_t SampleExtInfo::GetWidth() const {
    return m_width;
  }
 
  inline SampleExtInfo& SampleExtInfo::SetHeight(std::int32_t height) {
    m_height = height;
    return *this;
  }
 
  inline std::int32_t SampleExtInfo::GetHeight() const {
    return m_height;
  }
 
  inline SampleExtInfo& SampleExtInfo::SetOffsetX(std::int32_t offset_x) {
    m_offset_x = offset_x;
    return *this;
  }
 
  inline std::int32_t SampleExtInfo::GetOffsetX() const {
    return m_offset_x;
  }
 
  inline SampleExtInfo& SampleExtInfo::SetOffsetY(std::int32_t offset_y) {
    m_offset_y = offset_y;
    return *this;
  }
 
  inline std::int32_t SampleExtInfo::GetOffsetY() const {
    return m_offset_y;
  }
 
  inline void SampleExtInfo::Pack(std::vector<uint8_t>& sample_ext_info_packed) const {
    sample_ext_info_packed.clear();
 
    const bool ts_is_def  = (m_timestamp == DEF_TIME_STAMP);
    const bool dt_is_def  = (m_datatype == ifw::fnd::datatype::DataType::UNSPECIFIED);
    const bool w_is_def   = (m_width == DEF_WIDTH);
    const bool h_is_def   = (m_height == DEF_HEIGHT);
    const bool ox_is_def  = (m_offset_x == DEF_OFFSET_X);
    const bool oy_is_def  = (m_offset_y == DEF_OFFSET_Y);
 
    const bool all_default =
        ts_is_def && dt_is_def && w_is_def && h_is_def &&
        ox_is_def && oy_is_def;
 
    if (all_default) {
      // Case 1: no values to be packed.
      return;
    }
 
    const bool others_all_default =
        dt_is_def && w_is_def && h_is_def && ox_is_def && oy_is_def;
 
    if (!ts_is_def && others_all_default) {
      // Case 2: only timestamp.
      sample_ext_info_packed.resize(sizeof(double));
      unsigned char* char_ptr = reinterpret_cast<unsigned char*>(sample_ext_info_packed.data());
      uint64_t ts_bits = 0;
      std::memcpy(&ts_bits, &m_timestamp, sizeof(ts_bits));
      ts_bits = boost::endian::native_to_big(ts_bits);
      std::memcpy(char_ptr, &ts_bits, sizeof(ts_bits));
      return;
    }
 
    // Otherwise at least one of the extended fields is non-default.
    // We only allow the full set together with a non-default timestamp.
    const bool some_other_non_default =
        !dt_is_def || !w_is_def || !h_is_def || !ox_is_def || !oy_is_def;
    const bool all_other_non_default =
        !dt_is_def && !w_is_def && !h_is_def && !ox_is_def && !oy_is_def;
 
    if (!(some_other_non_default && all_other_non_default && !ts_is_def)) {
      throw std::runtime_error(fmt::format("{}: SampleExtInfo::Pack: invalid combination of "
        "fields; allowed are: none, only timestamp, or "
        "timestamp + datatype + width + height + offset_x + offset_y.", IFWLOC));
    }
 
    // Case 3: full set (timestamp + datatype + width + height + offsets).
    constexpr std::size_t full_size = SIZE_SAMPLE_EXT_INFO;
 
    sample_ext_info_packed.resize(full_size);
    unsigned char* char_ptr = reinterpret_cast<unsigned char*>(sample_ext_info_packed.data());
    std::size_t idx = 0;
 
    // Timestamp
    uint64_t ts_bits = 0;
    std::memcpy(&ts_bits, &m_timestamp, sizeof(ts_bits));
    ts_bits = boost::endian::native_to_big(ts_bits);
    std::memcpy(char_ptr + idx, &ts_bits, sizeof(ts_bits));
    idx += sizeof(ts_bits);
 
    // Data type as 32-bit integer
    std::int32_t dt = static_cast<std::int32_t>(m_datatype);
    dt = boost::endian::native_to_big(dt);
    std::memcpy(char_ptr + idx, &dt, sizeof(dt));
    idx += sizeof(dt);
 
    // Width
    auto w_be = boost::endian::native_to_big(m_width);
    std::memcpy(char_ptr + idx, &w_be, sizeof(w_be));
    idx += sizeof(m_width);
 
    // Height
    auto h_be = boost::endian::native_to_big(m_height);
    std::memcpy(char_ptr + idx, &h_be, sizeof(h_be));
    idx += sizeof(m_height);
 
    // Offset X
    auto ox_be = boost::endian::native_to_big(m_offset_x);
    std::memcpy(char_ptr + idx, &ox_be, sizeof(ox_be));
    idx += sizeof(ox_be);
 
    // Offset Y
    auto oy_be = boost::endian::native_to_big(m_offset_y);
    std::memcpy(char_ptr + idx, &oy_be, sizeof(oy_be));
    idx += sizeof(oy_be);
  }
 
  inline void SampleExtInfo::Unpack(const std::vector<uint8_t>& sample_ext_info_packed) {
    const std::size_t sz = sample_ext_info_packed.size();
 
    if (sz == 0U) {
      // No values: reset to defaults.
      m_timestamp = DEF_TIME_STAMP;
      m_datatype  = ifw::fnd::datatype::DataType::UNSPECIFIED;
      m_width     = DEF_WIDTH;
      m_height    = DEF_HEIGHT;
      m_offset_x  = DEF_OFFSET_X;
      m_offset_y  = DEF_OFFSET_Y;
      return;
    }
 
    if (sz == sizeof(double)) {
      // Only timestamp.
      const unsigned char* char_ptr =
          reinterpret_cast<const unsigned char*>(
              sample_ext_info_packed.data());
      std::size_t idx = 0;
 
      uint64_t ts_bits = 0;
      std::memcpy(&ts_bits, char_ptr + idx, sizeof(ts_bits));
      ts_bits = boost::endian::big_to_native(ts_bits);
      std::memcpy(&m_timestamp, &ts_bits, sizeof(m_timestamp));
      idx += sizeof(ts_bits);
 
      // Others back to defaults.
      m_datatype  = ifw::fnd::datatype::DataType::UNSPECIFIED;
      m_width     = DEF_WIDTH;
      m_height    = DEF_HEIGHT;
      m_offset_x  = DEF_OFFSET_X;
      m_offset_y  = DEF_OFFSET_Y;
      return;
    }
 
    if (sz != SIZE_SAMPLE_EXT_INFO) {
      throw std::runtime_error(fmt::format("{}: SampleExtInfo::Unpack: invalid packed size; "
        "expected 0, 8 (timestamp), or full-size (timestamp + datatype + width + height + "
        "offset_x + offset_y).", IFWLOC));
    }
 
    const unsigned char* char_ptr =
        reinterpret_cast<const unsigned char*>(sample_ext_info_packed.data());
    std::size_t idx = 0;
 
    // Timestamp
    uint64_t ts_bits = 0;
    std::memcpy(&ts_bits, char_ptr + idx, sizeof(ts_bits));
    ts_bits = boost::endian::big_to_native(ts_bits);
    std::memcpy(&m_timestamp, &ts_bits, sizeof(m_timestamp));
    idx += sizeof(ts_bits);
 
    // Data type (int32 -> enum)
    std::int32_t dt_int = 0;
    std::memcpy(&dt_int, char_ptr + idx, sizeof(dt_int));
    dt_int = boost::endian::big_to_native(dt_int);
    idx += sizeof(dt_int);
    m_datatype = static_cast<ifw::fnd::datatype::DataType>(dt_int);
 
    // Width
    std::memcpy(&m_width, char_ptr + idx, sizeof(m_width));
    m_width = boost::endian::big_to_native(m_width);
    idx += sizeof(m_width);
 
    // Height
    std::memcpy(&m_height, char_ptr + idx, sizeof(m_height));
    m_height = boost::endian::big_to_native(m_height);
    idx += sizeof(m_height);
 
    // Offset X
    std::memcpy(&m_offset_x, char_ptr + idx, sizeof(m_offset_x));
    m_offset_x = boost::endian::big_to_native(m_offset_x);
    idx += sizeof(m_offset_x);
 
    // Offset Y
    std::memcpy(&m_offset_y, char_ptr + idx, sizeof(m_offset_y));
    m_offset_y = boost::endian::big_to_native(m_offset_y);
    idx += sizeof(m_offset_y);
  }
 
  inline int32_t SampleExtInfo::GetExtInfoSize() const {
    bool has_timestamp = (m_timestamp != DEF_TIME_STAMP);
    bool has_any_extra =
        (m_datatype != ifw::fnd::datatype::DataType::UNSPECIFIED) ||
        (m_width    != DEF_WIDTH)   ||
        (m_height   != DEF_HEIGHT)  ||
        (m_offset_x != DEF_OFFSET_X) ||
        (m_offset_y != DEF_OFFSET_Y);
 
    // Case 1: no extended info
    if (!has_timestamp && !has_any_extra) {
      return 0;
    }
 
    // Case 2: only timestamp
    if (has_timestamp && !has_any_extra) {
      return sizeof(double);
    }
 
    // Case 3: full basic image info (timestamp + datatype + w + h + ox + oy)
    if (has_timestamp && has_any_extra) {
      return sizeof(double) + static_cast<int32_t>(sizeof(int32_t) * 5);
    }
 
    // Any partial combination is invalid
    throw std::runtime_error(
        "Invalid SampleExtInfo info provided: partial basic image info not allowed");
  }
 
} // namespace ifw::rtmslib