defines.hpp

Go to the documentation of this file.

 
#ifndef CCF_PROTOCOLS_ARAVIS_LIB_DEFINES_HPP_H_
#define CCF_PROTOCOLS_ARAVIS_LIB_DEFINES_HPP_H_
 
#include <cstdint>
 
#include <arv.h>
#include <arvstream.h>
 
#include <ifw/ccf/common/setup.hpp>
 
 
namespace ifw::ccf::protocols::aravis {
 
  inline ifw::ccf::common::Setup& GetSetup() {
    return ifw::ccf::common::Setup::Instance();
  }
 
  inline std::string SetupKey(const std::vector<std::string>& names) {
    if (names.size() == 0) {
      CCFTHROW("No names given");
    }
    std::string name;
    if (names[0] != GetSetup().GetRootNodeName()) {
      name += (GetSetup().GetRootNodeName() + ".");
    }
    for (auto it : names) {
      name += (it + ".");
    }
    return name.substr(0, name.size() - 1);
  }

  const auto ARAVIS_INFINITE = 0xFFFFFFFF;

  typedef struct {
    // In:
    ArvBuffer*           aravis_buffer;        // Object from Aravis. Shall be deleted.
    const void*          image_buffer;         // Buffer for image/pixel data.
    unsigned long        image_buffer_size;    // Size of ImageBuffer in bytes
 
    void*                ancillary_buffer;    // NOT USED
                                              // Camera Firmware >= 1.42 Only.
                                              // Buffer to capture ancillary chunk mode data. See ChunkModeActive attr.
                                              // This MUST be 0 if not in use.
                                              // Chunk mode format:
                                              //     [Bytes 1 - 4]   acquisition count.
                                              //     [Bytes 5 - 8]   EF lens settings.
                                              //     [Bytes 9 - 12]  exposure value.
                                              //     [Bytes 13 - 16] gain value.
                                              //     [Bytes 17 - 18] sync in levels.
                                              //     [Bytes 19 - 20] sync out levels.
                                              //     [Bytes 21 - 40] not implemented. 0.
                                              //     [Bytes 41 - 44] chunk ID. 1000.
                                              //     [Bytes 45 - 48] chunk length.
 
    unsigned long        ancillary_buffer_size; // Size of your ancillary buffer in bytes. 
                                                // See NonImagePayloadSize attr.
                                                // Set to 0 for no buffer.
 
    // Out:
    ArvBufferStatus      status;              // Status of this frame
    ArvBufferPayloadType payload;             // Type of payload
    ArvPixelFormat       pixel_format;        // Pixel format
    uint64_t             frame_id;            // Frame ID
    int64_t              image_size;          // Image size, in bytes
    uint32_t             ancillary_size;      // Ancillary data size, in bytes
    uint32_t             bit_depth;           // Number of significant bits
    uint32_t             frame_count;         // Frame counter. Uses 16bit GigEVision BlockID. Rolls at 65535.
 
    int32_t              width;              // Image width
    int32_t              height;             // Image height
    uint32_t             offset_x;           // Start of readout region (left)
    uint32_t             offset_y;           // Start of readout region (top)
 
    // cppcheck complains about storing a double in a struct which is memset
    // so the timestamp is split into two unsigned ints
    uint32_t             timestamp_secs;      // Time stamp in seconds
    uint32_t             timestamp_frac;      // Fractional value of time stamp
 
} ArvFrame;

enum class ArvDatatype {
    ARV_DATA_TYPE_UNKNOWN = 0,
    ARV_DATA_TYPE_COMMAND,
    ARV_DATA_TYPE_ENUM,
    ARV_DATA_TYPE_BOOLEAN,
    ARV_DATA_TYPE_INTEGER,
    ARV_DATA_TYPE_STRING,
    ARV_DATA_TYPE_FLOAT,
    //_ARV_DATA_TYPE_FORCE_32 = 0xFFFFFFFF
    _ARV_DATA_TYPE_FORCE_32 = INT_MAX
};

typedef struct {
    ArvDatatype         data_type;      // Data type
    unsigned long       flags;          // Currently not used
    gint64              int_max;
    gint64              int_min;
    double              float_max;
    double              float_min;
} ArvAttributeInfo;
 
}
 
#endif // CCF_PROTOCOLS_ARAVIS_LIB_DEFINES_HPP_H_