Device.hpp

Go to the documentation of this file.

#pragma once
 
// std
#include <chrono>
#include <condition_variable>
#include <deque>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
 
// project
#include "DataQueue.hpp"
#include "depthai/device/DeviceBase.hpp"
 
namespace dai {
class Device : public DeviceBase {
   public:
    using DeviceBase::DeviceBase;  // inherit the ctors
 
    explicit Device(const Pipeline& pipeline);
 
    template <typename T, std::enable_if_t<std::is_same<T, bool>::value, bool> = true>
    [[deprecated("Use constructor taking 'UsbSpeed' instead")]] Device(const Pipeline& pipeline, T usb2Mode);
 
    Device(const Pipeline& pipeline, UsbSpeed maxUsbSpeed);
 
    Device(const Pipeline& pipeline, const dai::Path& pathToCmd);
 
    Device(const Pipeline& pipeline, const DeviceInfo& devInfo);
 
    template <typename T, std::enable_if_t<std::is_same<T, bool>::value, bool> = true>
    [[deprecated("Use constructor taking 'UsbSpeed' instead")]] Device(const Pipeline& pipeline, const DeviceInfo& devInfo, T usb2Mode);
 
    Device(const Pipeline& pipeline, const DeviceInfo& devInfo, UsbSpeed maxUsbSpeed);
 
    Device(const Pipeline& pipeline, const DeviceInfo& devInfo, const dai::Path& pathToCmd);
 
    Device();
 
    ~Device() override;
 
    static constexpr std::size_t EVENT_QUEUE_MAXIMUM_SIZE{2048};
 
    std::shared_ptr<DataOutputQueue> getOutputQueue(const std::string& name);
 
    std::shared_ptr<DataOutputQueue> getOutputQueue(const std::string& name, unsigned int maxSize, bool blocking = true);
 
    std::vector<std::string> getOutputQueueNames() const;
 
    std::shared_ptr<DataInputQueue> getInputQueue(const std::string& name);
 
    std::shared_ptr<DataInputQueue> getInputQueue(const std::string& name, unsigned int maxSize, bool blocking = true);
 
    std::vector<std::string> getInputQueueNames() const;
 
    // void setCallback(const std::string& name, std::function<std::shared_ptr<RawBuffer>(std::shared_ptr<RawBuffer>)> cb);
 
    std::vector<std::string> getQueueEvents(const std::vector<std::string>& queueNames,
                                            std::size_t maxNumEvents = std::numeric_limits<std::size_t>::max(),
                                            std::chrono::microseconds timeout = std::chrono::microseconds(-1));
    std::vector<std::string> getQueueEvents(const std::initializer_list<std::string>& queueNames,
                                            std::size_t maxNumEvents = std::numeric_limits<std::size_t>::max(),
                                            std::chrono::microseconds timeout = std::chrono::microseconds(-1));
 
    std::vector<std::string> getQueueEvents(std::string queueName,
                                            std::size_t maxNumEvents = std::numeric_limits<std::size_t>::max(),
                                            std::chrono::microseconds timeout = std::chrono::microseconds(-1));
 
    std::vector<std::string> getQueueEvents(std::size_t maxNumEvents = std::numeric_limits<std::size_t>::max(),
                                            std::chrono::microseconds timeout = std::chrono::microseconds(-1));
 
    std::string getQueueEvent(const std::vector<std::string>& queueNames, std::chrono::microseconds timeout = std::chrono::microseconds(-1));
    std::string getQueueEvent(const std::initializer_list<std::string>& queueNames, std::chrono::microseconds timeout = std::chrono::microseconds(-1));
 
    std::string getQueueEvent(std::string queueName, std::chrono::microseconds timeout = std::chrono::microseconds(-1));
 
    std::string getQueueEvent(std::chrono::microseconds timeout = std::chrono::microseconds(-1));
 
   private:
    std::unordered_map<std::string, std::shared_ptr<DataOutputQueue>> outputQueueMap;
    std::unordered_map<std::string, std::shared_ptr<DataInputQueue>> inputQueueMap;
    std::unordered_map<std::string, DataOutputQueue::CallbackId> callbackIdMap;
 
    // Event queue
    std::mutex eventMtx;
    std::condition_variable eventCv;
    std::deque<std::string> eventQueue;
 
    bool startPipelineImpl(const Pipeline& pipeline) override;
    void closeImpl() override;
};
 
}  // namespace dai