detail_device_factory.hpp

#pragma once
 
#include "../_cexports/c_driver.h"
#include "../_cexports/c_img.h"
 
#include "../global.hpp"
 
#include "../_decl/decl_device_factory.hpp"
 
#include "../driver/_decl/decl_vin_device.hpp"
#include "../driver/_decl/decl_emu_device.hpp"
#include "../driver/_decl/decl_video_device.hpp"
#include "../driver/_decl/decl_genicam_device.hpp"
 
#include "../driver/non_streaming_device.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  inline HandleGuard<Device> DeviceFactory::LoadAsGenTL(const String &provider, AcquisitionStack acquisitionStack)
  {
    CExports::DEVOBJ obj = nullptr;
    if (AllowFallback(acquisitionStack))
    {
      CVB_CALL_CAPI(CVDCreateOrGetDeviceObjectTyped(provider.c_str(), obj));
    }
    else
    {
      CVB_CALL_CAPI_CHECKED(CVDCreateOrGetDeviceObjectTyped(provider.c_str(), obj));
    }
    return HandleGuard<Device>(obj);
  }
 
  inline HandleGuard<Device> DeviceFactory::LoadAsVin(const String &provider, AcquisitionStack acquisitionStack)
  {
    CExports::IMG img = nullptr;
    if (AllowFallback(acquisitionStack))
    {
      CVB_CALL_CAPI(LoadImageFileTyped(provider.c_str(), img));
    }
    else
    {
      CVB_CALL_CAPI_CHECKED(LoadImageFileTyped(provider.c_str(), img));
    }
    return HandleGuard<Device>(img);
  }
 
  inline HandleGuard<Device> DeviceFactory::LoadAsNonStreaming(const String &provider)
  {
    CExports::DEVOBJ obj = nullptr;
    CVB_CALL_CAPI_CHECKED(LoadDeviceObjectTyped(provider.c_str(), obj));
    return HandleGuard<Device>(obj);
  }
 
  inline DevicePtr DeviceFactory::CreateDeviceByDriverGUID(const Cvb::String &provider,
                                                           Cvb::HandleGuard<Cvb::Device> &&guard) noexcept
  {
    using namespace Cvb;
    CExports::cvbguid_t deviceGuid = {0};
    CVB_CALL_CAPI_CHECKED(GetDriverID(guard.Handle(), deviceGuid));
 
    if (Cvb::CExports::operator==(deviceGuid, DeviceFactory::AviMpgGuid()))
      return Device::FromHandle<VideoDevice>(std::move(guard), provider);
    else if (Cvb::CExports::operator==(deviceGuid, DeviceFactory::EmuGuid()))
      return Device::FromHandle<EmuDevice>(std::move(guard), provider);
    else
      return Device::FromHandle<VinDevice>(std::move(guard), provider);
  }
 
  inline DevicePtr DeviceFactory::Open(const String &provider,
                                       AcquisitionStack acquisitionStack /*= AcquisitionStack::PreferVin*/)
  {
    std::unique_lock<std::mutex> lock(LockAnchor());
    switch (acquisitionStack)
    {
      case AcquisitionStack::Vin:
        return CreateDeviceByDriverGUID(provider, LoadAsVin(provider, acquisitionStack));
 
      case AcquisitionStack::PreferVin:
      {
        auto vinGuard = LoadAsVin(provider, acquisitionStack);
        if (vinGuard.Handle())
          return CreateDeviceByDriverGUID(provider, std::move(vinGuard));
        return Device::FromHandle<NonStreamingDevice>(LoadAsNonStreaming(provider), provider);
      }
 
      case AcquisitionStack::GenTL:
        return Device::FromHandle<GenICamDevice>(LoadAsGenTL(provider, acquisitionStack), provider);
 
      case AcquisitionStack::PreferGenTL:
      default:
      {
        auto gentlGuard = LoadAsGenTL(provider, acquisitionStack);
        if (gentlGuard.Handle())
          return Device::FromHandle<GenICamDevice>(std::move(gentlGuard), provider);
        auto vinGuard = LoadAsVin(provider, acquisitionStack);
        if (vinGuard.Handle())
          return CreateDeviceByDriverGUID(provider, std::move(vinGuard));
        return Device::FromHandle<NonStreamingDevice>(LoadAsNonStreaming(provider), provider);
      }
    }
  }
 
  inline DevicePtr DeviceFactory::Open(const DiscoveryInformation &info, AcquisitionStack acquisitionStack)
  {
    return Open(info.AccessToken(), acquisitionStack);
  }
 
  template <class Rep, class Period>
  inline std::vector<Driver::DiscoveryInformation>
  DeviceFactory::Discover(const String &accessToken, Driver::DiscoverFlags flags,
                          const std::chrono::duration<Rep, Period> &timeSpan)
  {
#ifdef max
#  undef max
#endif
 
    auto msTimeSpan = std::chrono::duration_cast<std::chrono::milliseconds>(timeSpan).count();
    if (msTimeSpan > std::chrono::milliseconds::max().count())
      throw std::overflow_error("discover timeout must fit to std::chrono::duration in ms");
 
    CExports::ATLIST handle = nullptr;
    auto discoverResult = CExports::DODiscoverTyped(accessToken.c_str(), static_cast<CExports::cvbuint64_t>(flags), 0,
                                                    handle, static_cast<size_t>(msTimeSpan));
    if (discoverResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(discoverResult, "failed to discover"));
 
    Driver::DiscoveryInformation::List listHandle(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); });
 
    std::size_t numEntries = 0;
    auto numEntriesResult  = CExports::DOGetNumEntries(listHandle.get(), numEntries);
    if (numEntriesResult < 0)
      std::rethrow_exception(
          CvbException::FromCvbResult(numEntriesResult, "failed to get number of entries for device object"));
 
    std::vector<Driver::DiscoveryInformation> discoveryInformationVector;
    discoveryInformationVector.reserve(numEntries);
 
    for (size_t i = 0; i < numEntries; ++i)
      discoveryInformationVector.emplace_back(Driver::DiscoveryInformation(listHandle, static_cast<int>(i)));
 
    return discoveryInformationVector;
  }
 
  inline void DeviceFactory::ChangeBoard(DevicePtr &device, int board)
  {
    if (CExports::CanBoardSelect2(device->Handle()))
    {
      std::unique_lock<std::mutex> lock(LockAnchor());
      ChangeBoard2(device, board);
    }
    else if (CExports::CanBoardSelect(device->Handle()))
    {
      std::unique_lock<std::mutex> lock(LockAnchor());
      ChangeBoard1(device, board);
    }
    else
    {
      if (board == 0)
        return;
      else
        std::rethrow_exception(CvbException::FromCvbResult(ErrorCodes::CVB_ERROR, "no IBoardSelect or IBoardSelect2"));
    }
  }
 
  inline void DeviceFactory::ChangeBoard1(DevicePtr &device, int board)
  {
    CExports::cvbval_t currentBoard = 0;
    auto getBoardResult             = CExports::GetBoard(device->Handle(), &currentBoard);
    if (getBoardResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(getBoardResult, "no current board"));
    if (static_cast<int>(currentBoard) == board)
      return;
 
    auto setBoardResult = CExports::SetBoard(device->Handle(), static_cast<CExports::cvbval_t>(board));
    if (setBoardResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(setBoardResult, "failed to set board"));
  }
 
  inline void DeviceFactory::ChangeBoard2(DevicePtr &device, int board)
  {
    CExports::cvbval_t currentBoard = 0;
    auto getBoardResult             = CExports::BS2GetBoard(device->Handle(), currentBoard);
    if (getBoardResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(getBoardResult, "no current board"));
    if (static_cast<int>(currentBoard) == board)
      return;
    CExports::cvbval_t numBoards = 0;
    auto numBoardsResult         = CExports::BS2GetNumBoards(device->Handle(), numBoards);
    if (numBoardsResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(numBoardsResult, "no number of boards"));
    if (board >= static_cast<int>(numBoards))
      throw std::out_of_range("board out of range");
 
    CExports::IMG newImg = nullptr;
    auto setBoardResult  = CExports::BS2SetBoard(device->Handle(), board, newImg);
    if (setBoardResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(setBoardResult, "failed to set board"));
 
    HandleGuard<Device> guard(newImg);
    device = Device::FromHandle<Driver::VinDevice>(std::move(guard), device->ResourceLocator());
  }
 
  inline void DeviceFactory::ChangePort(DevicePtr &device, int port)
  {
    if (CExports::CanCameraSelect2(device->Handle()))
    {
      std::unique_lock<std::mutex> lock(LockAnchor());
      ChangePort2(device, port);
    }
    else if (CExports::CanCameraSelect(device->Handle()))
    {
      std::unique_lock<std::mutex> lock(LockAnchor());
      ChangePort1(device, port);
    }
    else
    {
      if (port == 0)
        return;
      else
        std::rethrow_exception(
            CvbException::FromCvbResult(ErrorCodes::CVB_ERROR, "no ICameraSelect or ICameraSelect2"));
    }
  }
 
  inline void DeviceFactory::ChangePort1(DevicePtr &device, int port)
  {
    CExports::cvbval_t currentPort = 0;
    auto getPortResult             = CExports::GetCamPort(device->Handle(), currentPort);
    if (getPortResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(getPortResult, "no current port"));
    if (static_cast<int>(currentPort) == port)
      return;
    CExports::cvbval_t numPorts = 0;
    auto numPortsResult         = CExports::GetNumPorts(device->Handle(), numPorts);
    if (numPortsResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(numPortsResult, "no number of ports"));
    if (port >= static_cast<int>(numPorts))
      throw std::out_of_range("port out of range");
 
    auto setPortResult = CExports::SetCamPort(device->Handle(), static_cast<CExports::cvbval_t>(port), 0);
    if (setPortResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(setPortResult, "failed to set port"));
  }
 
  inline void DeviceFactory::ChangePort2(DevicePtr &device, int port)
  {
    CExports::cvbval_t currentPort = 0;
    auto getPortResult             = CExports::CS2GetCamPort(device->Handle(), currentPort);
    if (getPortResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(getPortResult, "no current port"));
    if (static_cast<int>(currentPort) == port)
      return;
    CExports::cvbval_t numPorts = 0;
    auto numPortsResult         = CExports::CS2GetNumPorts(device->Handle(), numPorts);
    if (numPortsResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(numPortsResult, "no number of ports"));
    if (port >= static_cast<int>(numPorts))
      throw std::out_of_range("port out of range");
 
    CExports::IMG newImg = nullptr;
    auto setPortResult   = CExports::CS2SetCamPort(device->Handle(), static_cast<CExports::cvbval_t>(port), 0, newImg);
    if (setPortResult < 0)
      std::rethrow_exception(CvbException::FromCvbResult(setPortResult, "failed to set port"));
 
    HandleGuard<Device> guard(newImg);
    device = Device::FromHandle<Driver::VinDevice>(std::move(guard), device->ResourceLocator());
  }
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb