detail_stream.hpp

#pragma once
 
#include "../../global.hpp"
 
#include "../../_decl/decl_device.hpp"
 
#include "../_decl/decl_stream.hpp"
 
#include "../_decl/decl_buffer_image.hpp"
#include "../_decl/decl_ring_buffer.hpp"
#include "../_decl/decl_ring_buffer_image.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace Driver
  {
 
    inline Stream::Stream(const DevicePtr &device)
        : StreamBase(device)
    {
      SetAcquisitionInterface(AcquisitionEngine::GetBestAcquisitionInterface(*device));
 
      if (CExports::CanGrab2(Parent()->Handle()))
        StreamStats::CreateGrab2(*Parent()).swap(statistics_);
      else
        StreamStats::CreateNo(*Parent()).swap(statistics_);
    }
 
    template <class Rep, class Period>
    inline StreamImagePtr Stream::WaitFor(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitStatus)
    {
      acquisitionEngine_->WaitFor(timeSpan, waitStatus);
      if (waitStatus != WaitStatus::Ok)
        return std::unique_ptr<StreamImage>();
 
      auto image = MakeStreamImage();
      Parent()->OnImageAcquired();
      return image;
    }
    inline StreamImagePtr Stream::WaitFor(const std::chrono::duration<Rep, Period> &timeSpan, WaitStatus &waitStatus) {…}
 
    template <class Rep, class Period>
    inline StreamImagePtr Stream::GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan,
                                                   WaitStatus &waitStatus)
    {
      acquisitionEngine_->GetTimedSnapshot(timeSpan, waitStatus);
      if (waitStatus != WaitStatus::Ok)
        return std::unique_ptr<StreamImage>();
 
      auto image = MakeSnapshotImage();
      Parent()->OnImageAcquired();
      return image;
    }
    inline StreamImagePtr Stream::GetTimedSnapshot(const std::chrono::duration<Rep, Period> &timeSpan, {…}
 
    inline Cvb::Driver::AcquisitionInterface
    Stream::AcquisitionEngine::GetBestAcquisitionInterface(const Device &device)
    {
      if (CExports::CanGrab2(device.Handle()))
        return Cvb::Driver::AcquisitionInterface::Grab2;
      else if (CExports::CanGrabber(device.Handle()))
        return Cvb::Driver::AcquisitionInterface::Grabber;
      else
        throw std::runtime_error("no suitable acquisition interface available");
    }
 
    inline void Stream::AcquisitionEngine::SetTimeout(uint32_t msTimeSpan)
    {
      if (lastTimeout_ == msTimeSpan)
        return;
 
      auto result = CExports::SetTimeout(device_.Handle(), msTimeSpan);
      if (result < 0)
        CvbException::FromCvbResult(result, "failed to set timeout");
      lastTimeout_ = msTimeSpan;
    }
 
    inline void *Stream::AcquisitionEngine::Handle() const noexcept
    {
      return device_.Handle();
    }
 
    inline Stream::Grab::Grab(const Device &device)
        : AcquisitionEngine(device)
        , isRunning_(false)
    {
      if (!CExports::CanGrabber(device.Handle()))
        throw std::runtime_error("no IGrabber");
    }
 
    inline int Stream::Grab::TryWaitFor(uint32_t msTineSpan)
    {
      SetTimeout(msTineSpan);
      return CExports::Snap(Handle());
    }
 
    inline int Stream::Grab::TryGetTimedSnapshot(uint32_t msTineSpan)
    {
      SetTimeout(msTineSpan);
      return CExports::Snap(Handle());
    }
 
    inline Stream::Grab2::Grab2(const Device &device)
        : AcquisitionEngine(device)
    {
      if (!CExports::CanGrab2(device.Handle()))
        throw std::runtime_error("no IGrab2");
    }
 
    inline void Stream::Grab2::Start()
    {
      auto result = CExports::G2Grab(Handle());
      if (result < 0)
        std::rethrow_exception(CvbException::FromCvbResult(result, "failed to start acquisition with G2Grab"));
    }
 
    inline bool Stream::Grab2::TryStop() noexcept
    {
      auto result = CExports::G2Freeze(Handle(), false);
      return (result >= 0);
    }
 
    inline bool Stream::Grab2::TryAbort() noexcept
    {
      auto result = CExports::G2Freeze(Handle(), true);
      return (result >= 0);
    }
 
    inline bool Stream::Grab2::IsRunning() const noexcept
    {
      double active = 0.0;
      CExports::G2GetGrabStatus(Handle(), CExports::GRAB_INFO_GRAB_ACTIVE, active);
      return active != 0.0;
    }
 
    inline int Stream::Grab2::TryWaitFor(uint32_t msTineSpan)
    {
      SetTimeout(msTineSpan);
      return CExports::G2Wait(Handle());
    }
 
    inline int Stream::Grab2::TryGetTimedSnapshot(uint32_t msTineSpan)
    {
      SetTimeout(msTineSpan);
      return CExports::Snap(Handle());
    }
 
    inline bool Stream::Grab2Stats::TryGetValue(StreamInfo query, double &value) const noexcept
    {
      auto result = CExports::G2GetGrabStatus(Handle(), static_cast<CExports::GRAB_INFO_CMD>(query), value);
      return result >= 0;
    }
 
    inline void *Stream::StreamStats::Handle() const noexcept
    {
      return device_.Handle();
    }
 
  }  // namespace Driver
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb