driver.hpp

#pragma once
 
#include <codecvt>
#include <locale>
#include <vector>
#include <type_traits>
#include <tuple>
 
#include "../flag.hpp"
#include "../global.hpp"
#include "../string.hpp"
#include "../genapi/genapi.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  namespace Driver
  {
 
    class FlowSetPool;
    using FlowSetPoolPtr = std::shared_ptr<FlowSetPool>;
 
    class DeviceControl;
    using DeviceControlPtr = std::shared_ptr<DeviceControl>;
 
    class RingBuffer;
    using RingBufferPtr = std::shared_ptr<RingBuffer>;
 
    class DigitalIO;
    using DigitalIOPtr = std::shared_ptr<DigitalIO>;
 
    class SoftwareTrigger;
    using SoftwareTriggerPtr = std::shared_ptr<SoftwareTrigger>;
 
    class NotifyObservable;
    using NotifyObservablePtr = std::shared_ptr<NotifyObservable>;
 
    class ImageRect;
    using ImageRectPtr = std::shared_ptr<ImageRect>;
 
    class DeviceImage;
    using DeviceImagePtr = std::shared_ptr<DeviceImage>;
 
    class VinDevice;
    using VinDevicePtr = std::shared_ptr<VinDevice>;
 
    class VideoDevice;
    using VideoDevicePtr = std::shared_ptr<VideoDevice>;
 
    class EmuDevice;
    using EmuDevicePtr = std::shared_ptr<EmuDevice>;
 
    class NonStreamingDevice;
    using NonStreamingDevicePtr = std::shared_ptr<NonStreamingDevice>;
 
    class GenDcDescriptor;
    using GenDcDescriptorPtr = std::unique_ptr<GenDcDescriptor>;
 
    class GenICamDevice;
    using GenICamDevicePtr = std::shared_ptr<GenICamDevice>;
 
    class RingBufferImage;
    using RingBufferImagePtr = std::shared_ptr<RingBufferImage>;
 
    class StreamImage;
    using StreamImagePtr = std::shared_ptr<StreamImage>;
 
    class MultiPartImage;
    using MultiPartImagePtr = std::shared_ptr<MultiPartImage>;
 
    class BufferImage;
    using BufferImagePtr = std::shared_ptr<BufferImage>;
 
    class Stream;
    using StreamPtr = std::shared_ptr<Stream>;
 
    class IndexedStream;
    using IndexedStreamPtr = std::shared_ptr<IndexedStream>;
 
    class StreamBase;
    using StreamBasePtr = std::shared_ptr<StreamBase>;
 
    class CompositeStreamBase;
    using CompositeStreamBasePtr = std::shared_ptr<CompositeStreamBase>;
 
    class ImageStream;
    using ImageStreamPtr = std::shared_ptr<ImageStream>;
 
    class CompositeStream;
    using CompositeStreamPtr = std::shared_ptr<CompositeStream>;
 
    class PointCloudStream;
    using PointCloudStreamPtr = std::shared_ptr<PointCloudStream>;
 
    class VideoImage;
    using VideoImagePtr = std::shared_ptr<VideoImage>;
 
    class EmuImage;
    using EmuImagePtr = std::shared_ptr<EmuImage>;
 
    class VinImage;
    using VinImagePtr = std::shared_ptr<VinImage>;
 
    class FlowSetPool;
    using FlowSetPoolPtr = std::shared_ptr<FlowSetPool>;
 
    enum class StreamType
    {
      Legacy,
      Composite,
      Image,
      PointCloud
    };


    struct Flow
    {
      size_t Size;

      void *Buffer;

      explicit Flow(size_t size = 0, void *buffer = nullptr)
          : Size(size)
          , Buffer(buffer)
      {
      }
      explicit Flow(size_t size = 0, void *buffer = nullptr) {…}
    };
    struct Flow {…};
 
    namespace Private
    {
 
      template <class T>
      inline StreamType StreamTypeFor() noexcept
      {
        static_assert(std::is_same<T, CompositeStream>::value || std::is_same<T, ImageStream>::value
                          || std::is_same<T, PointCloudStream>::value || std::is_same<T, class Stream>::value,
                      "unsupported stream type");
        return StreamType::Legacy;
      }
 
      template <>
      inline StreamType StreamTypeFor<class Stream>() noexcept
      {
        return StreamType::Legacy;
      }
 
      template <>
      inline StreamType StreamTypeFor<CompositeStream>() noexcept
      {
        return StreamType::Composite;
      }
 
      template <>
      inline StreamType StreamTypeFor<ImageStream>() noexcept
      {
        return StreamType::Image;
      }
 
      template <>
      inline StreamType StreamTypeFor<PointCloudStream>() noexcept
      {
        return StreamType::PointCloud;
      }
 
    }  // namespace Private

    enum class DiscoveryProperties
    {
      InterfaceSubNetList = CExports::DO_DISCOVER_INFO_INTERFACE_NET_LIST,
      InterfaceMac = CExports::DO_DISCOVER_INFO_INTERFACE_NET_MAC,
      InterfaceTLType = CExports::DO_DISCOVER_INFO_INTERFACE_TLTYPE,
      InterfaceDisplayName = CExports::DO_DISCOVER_INFO_INTERFACE_DISPLAYNAME,
      InterfaceDriverType = CExports::DO_DISCOVER_INFO_INTERFACE_DRIVERTYPE,
      InterfaceId = CExports::DO_DISCOVER_INFO_INTERFACE_ID,
      DeviceTransportLayerType = CExports::DO_DISCOVER_INFO_DEVICE_TLTYPE,
      DeviceUsername = CExports::DO_DISCOVER_INFO_DEVICE_USERNAME,
      DeviceSerialNumber = CExports::DO_DISCOVER_INFO_DEVICE_SERIALNUMBER,
      DeviceMac = CExports::DO_DISCOVER_INFO_DEVICE_NET_MAC,
      DeviceIP = CExports::DO_DISCOVER_INFO_DEVICE_NET_IP,
      DeviceSubnetMask = CExports::DO_DISCOVER_INFO_DEVICE_NET_SUBNETMASK,
      DeviceUsbVendorId = CExports::DO_DISCOVER_INFO_DEVICE_USB_VID,
      DeviceUsbProductId = CExports::DO_DISCOVER_INFO_DEVICE_USB_PID,
      DeviceVendor = CExports::DO_DISCOVER_INFO_DEVICE_VENDOR,
      DeviceModel = CExports::DO_DISCOVER_INFO_DEVICE_MODEL,
      DeviceId = CExports::DO_DISCOVER_INFO_DEVICE_ID,
      DeviceAccessStatus = CExports::DO_DISCOVER_INFO_DEVICE_ACCESS_STATUS,
      TransportLayerId = CExports::DO_DISCOVER_INFO_TRANSPORTLAYER_ID,
      TransportLayerPath = CExports::DO_DISCOVER_INFO_TRANSPORTLAYER_PATH,
      TransportLayerVendor = CExports::DO_DISCOVER_INFO_TRANSPORTLAYER_VENDOR,
      UsbPortPath = CExports::DO_DISCOVER_INFO_DEVICE_USB_PORT_PATH
    };
    enum class DiscoveryProperties {…};

    enum class AcquisitionStack
    {
      Vin,
      PreferVin,
      GenTL,
      PreferGenTL
    };
    enum class AcquisitionStack {…};


    enum class DiscoverFlags : std::uint64_t
    {
      FindAll = 0,
      IncludeEmpty = 1,
      IncludeInaccessible = 1 << 12,
      UpToLevelSystem = 1 << 1,
      UpToLevelVin = 2 << 1,
      UpToLevelTL = 3 << 1,
      UpToLevelInterface = 4 << 1,
      UpToLevelDevice = 5 << 1,
      UpToLevelStream = 6 << 1,
      IgnoreVins = 1 << 8,
      IgnoreTLs = 1 << 9,
      IgnoreGevSD = 1 << 10,
      IgnoreGevFD = 1 << 11,
      //  Normally MockTL.cti is filtered out: this flag includes it.
      IncludeMockTL = 1 << 13
    };
    enum class DiscoverFlags : std::uint64_t {…};

    enum class ModuleLayer
    {
      Unknown = CExports::DO_AT_LEVEL_UNKNOWN,
      System = CExports::DO_AT_LEVEL_SYSTEM,
      Vin = CExports::DO_AT_LEVEL_VIN,
      TransportLayerSystem = CExports::DO_AT_LEVEL_TLSYSTEM,
      TransportLayerInterface = CExports::DO_AT_LEVEL_TLIFACE,
      TransportLayerDevice = CExports::DO_AT_LEVEL_TLDEVICE,
      TransportLayerStream = CExports::DO_AT_LEVEL_TLSTREAM
    };
    enum class ModuleLayer {…};

    enum class NotifyDataType
    {
      Void = CExports::CVNO_DATA_VOID,
      Int64 = CExports::CVNO_DATA_INTEGER64,
      Float64 = CExports::CVNO_DATA_FLOAT64,
      String = CExports::CVNO_DATA_STRING,
      Binary = CExports::CVNO_DATA_BINARY,
      Boolean = CExports::CVNO_DATA_BOOL8,
    };
    enum class NotifyDataType {…};

    enum class DeviceState
    {
      DeviceDisconnected = 2,
      DeviceReconnect = 3,
      DeviceImageGeometryChanged = 4,
      NewMetaData = 5
    };
    enum class DeviceState {…};


    template <class T>
    struct WaitResult
    {
      WaitStatus Status = WaitStatus::Ok;
      std::shared_ptr<T> Image;
    };
    struct WaitResult {…};

    enum class RingBufferLockMode
    {
      Auto = CExports::RINGBUFFER_LOCKMODE_AUTO,
 
      // lockmode off removed

      On = CExports::RINGBUFFER_LOCKMODE_ON
    };
    enum class RingBufferLockMode {…};

    enum class PlaybackMode
    {
      FrameByFrame,
      Stream
    };
    enum class PlaybackMode {…};

    enum class AcquisitionInterface
    {
      Grabber,
      Grab2,
      GenTL
    };
    enum class AcquisitionInterface {…};


    enum class StreamInfo
    {
      IsCameraDetected = CExports::GRAB_INFO_CAMERA_DETECTED,
      NumBuffersAcquired = CExports::GRAB_INFO_NUMBER_IMAGES_AQCUIRED,
      NumBuffersDelivered = CExports::G2INFO_NumBuffersDelivered,
      NumBuffersLost = CExports::G2INFO_NumBuffersLost,
      NumBuffersLostTransfer = CExports::GRAB_INFO_NUMBER_IMAGES_LOST,
      NumBuffersLostLocked = CExports::GRAB_INFO_NUMBER_IMAGES_LOST_LOCKED,
      NumBuffersLocked = CExports::GRAB_INFO_NUMBER_IMAGES_LOCKED,
      NumBuffersPending = CExports::GRAB_INFO_NUMBER_IMAGES_PENDIG,
      NumBuffersCorruptOnArrival = CExports::G2INFO_NumBuffersCorrupt,
      NumBuffersCorruptOnDelivery = CExports::G2INFO_NumBuffersCorruptOnDelivery,
      NumTriggersLost = CExports::GRAB_INFO_NUMBER_TRIGGERS_LOST,
      NumBuffersAnnounced = CExports::G2INFO_NumBuffersAnnounced,
      NumBuffersQueued = CExports::G2INFO_NumBuffersQueued,
      NumBuffersBeingFilled = CExports::G2INFO_NumBuffersInIncompleteList,
      NumPacketsReceived = CExports::G2INFO_NumPacketsReceived,
      NumResends = CExports::G2INFO_NumResends
    };
    enum class StreamInfo {…};

    enum class DeviceControlOperation
    {
      Get = CExports::DC_GET,
      Set = CExports::DC_SET,
      GetMinimum = CExports::DC_GETMIN,
      GetMaxiumum = CExports::DC_GETMAX,
      Verify = CExports::DC_VERIFY
 
    };
    enum class DeviceControlOperation {…};

    enum class AcquisitionState
    {
      Started,
      Stopping,
      AbortingStop,
      Stopped
    };
    enum class AcquisitionState {…};

    namespace NodeMapID
    {
      static const Cvb::String Device = Cvb::String(CVB_LIT("Device"));  // NOLINT(cert-err58-cpp)
      static const Cvb::String Factory = Cvb::String(CVB_LIT("TLFactory"));  // NOLINT(cert-err58-cpp)
      static const Cvb::String System = Cvb::String(CVB_LIT("TLSystem"));  // NOLINT(cert-err58-cpp)
      static const Cvb::String Interface = Cvb::String(CVB_LIT("TLInterface"));  // NOLINT(cert-err58-cpp)
      static const Cvb::String TLDevice = Cvb::String(CVB_LIT("TLDevice"));  // NOLINT(cert-err58-cpp)
      static const Cvb::String DataStream = Cvb::String(CVB_LIT("TLDatastream"));  // NOLINT(cert-err58-cpp)
      static const Cvb::String VinDevice = Cvb::String(CVB_LIT("VinDevice"));  // NOLINT(cert-err58-cpp)
      static const Cvb::String VinBuffer = Cvb::String(CVB_LIT("VinBuffer"));  // NOLINT(cert-err58-cpp)
    }  // namespace NodeMapID
    namespace NodeMapID {…}

    template <class T>
    using WaitResultTuple = std::tuple<std::shared_ptr<T>, WaitStatus, NodeMapEnumerator>;

    enum class GenDCPartType : std::uint16_t
    {
      // NOLINTBEGIN bugprone-reserved-identifier
      _TypeUndefinedPart       = 0x0000,
      _TypeGenericPartMetadata = 0x4000 + 0x0000,
      _TypeGenericPart1D       = 0x4000 + 0x0100,
      _TypeGenericPart2D       = 0x4000 + 0x0200,
      // NOLINTEND bugprone-reserved-identifier

      TypeMetadataGenICamChunk = _TypeGenericPartMetadata + 0x00,
      TypeMetadataGenICamXML = _TypeGenericPartMetadata + 0x01,
      // 1D array (such as 3D Point Cloud).
      Type1D = _TypeGenericPart1D + 0x00,
      Type2D = _TypeGenericPart2D + 0x00,
      TypeJPEG = _TypeGenericPart2D + 0x01,
      TypeJPEG2000 = _TypeGenericPart2D + 0x02,
      TypeH264 = _TypeGenericPart2D + 0x03,
    };
    enum class GenDCPartType : std::uint16_t {…};

    enum class ComponentId
    {
      Intensity = 1,
      Infrared = 2,
      Ultraviolet = 3,
      Range = 4,
      Reflectance = 5,
      Confidence = 6,
      Scatter = 7,
      Disparity = 8,
      Multispectral = 9,
      Metadata = 0x8001,

      DeviceSpecific = static_cast<int>(0xFF00),

      Undefined = 0,
    };
    enum class ComponentId {…};

    enum class GenDcDescriptorFlag : std::uint16_t
    {
      TimestampPTP = 0,
      ComponentInvalid = 1,
    };
    enum class GenDcDescriptorFlag : std::uint16_t {…};

    enum class GenDcDescriptorVariableField : std::uint16_t
    {
      DataSize = 0,
      SizeX = 1,
      SizeY = 2,
      RegionOffset = 3,
      Format = 4,
      Timestamp = 5,
      ComponentCount = 6,
      ComponentInvalid = 7
    };
    enum class GenDcDescriptorVariableField : std::uint16_t {…};

    enum class GenDcComponentFlags : std::uint16_t
    {
      Invalid = 1 << 0,
    };
    enum class GenDcComponentFlags : std::uint16_t {…};

    enum class GenDcPartFlags : std::uint16_t
    {
      Zip = 1 << 8,
      Chunk = 1 << 9,
    };
    enum class GenDcPartFlags : std::uint16_t {…};

    enum class H264Flags : std::uint8_t
    {
      ConstraintSet0 = 1 << 0,
      ConstraintSet1 = 1 << 1,
      ConstraintSet2 = 1 << 2,
      ConstraintSet3 = 1 << 3,
      PacketizationModeNAL            = 0 << 4,
      PacketizationModeNonInterleaved = 1 << 4,
      PacketizationModeInterleaved    = 1 << 5,
    };
    enum class H264Flags : std::uint8_t {…};
  }  // namespace Driver

  template <>
  struct enum_flag_type<Driver::DiscoverFlags> : std::true_type
  {
  };
 
  template <>
  struct enum_flag_type<Driver::GenDcDescriptorFlag> : std::true_type
  {
  };
 
  template <>
  struct enum_flag_type<Driver::GenDcDescriptorVariableField> : std::true_type
  {
  };
 
  template <>
  struct enum_flag_type<Driver::GenDcComponentFlags> : std::true_type
  {
  };
 
  template <>
  struct enum_flag_type<Driver::GenDcPartFlags> : std::true_type
  {
  };
 
  template <>
  struct enum_flag_type<Driver::H264Flags> : std::true_type
  {
  };
 
  using Driver::DeviceControlPtr;
  using Driver::DigitalIOPtr;
  using Driver::ImageRectPtr;
  using Driver::NotifyObservablePtr;
  using Driver::RingBufferPtr;
  using Driver::SoftwareTriggerPtr;
 
  using Driver::BufferImagePtr;
  using Driver::CompositeStream;
  using Driver::CompositeStreamBase;
  using Driver::CompositeStreamBasePtr;
  using Driver::CompositeStreamPtr;
  using Driver::DeviceImagePtr;
  using Driver::EmuDevicePtr;
  using Driver::GenDcDescriptorPtr;
  using Driver::GenICamDevicePtr;
  using Driver::ImageStream;
  using Driver::ImageStreamPtr;
  using Driver::IndexedStream;
  using Driver::IndexedStreamPtr;
  using Driver::MultiPartImage;
  using Driver::MultiPartImagePtr;
  using Driver::NonStreamingDevicePtr;
  using Driver::PointCloudStream;
  using Driver::PointCloudStreamPtr;
  using Driver::RingBufferImagePtr;
  using Driver::Stream;
  using Driver::StreamBasePtr;
  using Driver::StreamImagePtr;
  using Driver::StreamPtr;
  using Driver::VideoDevicePtr;
  using Driver::VinDevicePtr;

  using Driver::AcquisitionInterface;
  using Driver::AcquisitionStack;
  using Driver::AcquisitionState;
  using Driver::DeviceControlOperation;
  using Driver::DeviceState;
  using Driver::DiscoverFlags;
  using Driver::DiscoveryProperties;
  using Driver::EmuImagePtr;
  using Driver::Flow;
  using Driver::FlowSetPool;
  using Driver::FlowSetPoolPtr;
  using Driver::ModuleLayer;
  using Driver::NotifyDataType;
  using Driver::PlaybackMode;
  using Driver::RingBufferLockMode;
  using Driver::StreamInfo;
  using Driver::VideoImagePtr;
  using Driver::VinImage;
  using Driver::VinImagePtr;
  using Driver::WaitResult;
  using Driver::WaitResultTuple;
  using Driver::GenDCPartType;
  using Driver::ComponentId;
  using Driver::GenDcDescriptorFlag;
  using Driver::GenDcDescriptorVariableField;
  using Driver::GenDcComponentFlags;
  using Driver::GenDcPartFlags;
  using Driver::H264Flags;
 
  namespace NodeMapID = Driver::NodeMapID;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb