frame_grabber.h

/*
 * Copyright 2022-present ifm electronic, gmbh
 
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef IFM3D_FG_FRAMEGRABBER_H
#define IFM3D_FG_FRAMEGRABBER_H
#pragma once
 
#include <chrono>
#include <cstdint>
#include <future>
#include <ifm3d/device/device.h>
#include <ifm3d/device/err.h>
#include <ifm3d/device/pcic_command.h>
#include <ifm3d/fg/buffer.h>
#include <ifm3d/fg/frame.h>
#include <ifm3d/fg/module_frame_grabber.h>
#include <ifm3d/fg/organizer.h>
#include <memory>
#include <optional>
#include <variant>
#include <vector>
 
namespace ifm3d
{
  class IFM3D_EXPORT FrameGrabber
  {
  public:
    using Ptr = std::shared_ptr<FrameGrabber>;
    using NewFrameCallback = std::function<void(Frame::Ptr)>;
    using AsyncErrorCallback = std::function<void(int, const std::string&)>;
    using AsyncNotificationCallback =
      std::function<void(const std::string&, const std::string&)>;
    using ErrorCallback = std::function<void(const ifm3d::Error&)>;
    using BufferList =
      std::vector<std::variant<std::uint64_t, int, ifm3d::buffer_id>>;
    using PCICCommandResponse =
      std::variant<std::monostate, std::string, std::vector<std::uint8_t>>;
 
    FrameGrabber(ifm3d::Device::Ptr cam,
                 std::optional<std::uint16_t> pcic_port = std::nullopt);
 
    virtual ~FrameGrabber();
 
    // disable copy/move semantics
    FrameGrabber(FrameGrabber&&) = delete;
    FrameGrabber& operator=(FrameGrabber&&) = delete;
    FrameGrabber(FrameGrabber&) = delete;
    FrameGrabber& operator=(const FrameGrabber&) = delete;
 
    std::shared_future<void> SWTrigger();
 
    void OnNewFrame(NewFrameCallback callback = nullptr);
 
    std::shared_future<void> Start(
      const BufferList& buffers,
      const std::optional<json>& schema = std::nullopt);
 
    std::shared_future<void> Stop();
 
    bool IsRunning();
 
    void SetHeartbeatInterval(std::chrono::milliseconds interval);
 
    std::shared_future<Frame::Ptr> WaitForFrame();
 
    void SetOrganizer(std::unique_ptr<Organizer> organizer);
 
    void OnAsyncError(AsyncErrorCallback callback = nullptr);
 
    void OnAsyncNotification(AsyncNotificationCallback callback = nullptr);
 
    void OnError(ErrorCallback callback = nullptr);
 
    void SetMasking(bool mask);
 
    bool IsMasking();
 
    std::shared_future<PCICCommandResponse> SendCommand(
      const PCICCommand& command);
 
  private:
    class Impl;
    std::unique_ptr<Impl> _impl;
 
  }; // end: class FrameGrabber
 
} // end: namespace ifm3d
 
#endif // IFM3D_FG_FRAMEGRABBER_H