MultiSenseMultiChannel.hh

Go to the documentation of this file.

 
#pragma once
 
#include <condition_variable>
#include <deque>
#include <mutex>
 
#include "MultiSenseChannel.hh"
 
namespace multisense {
 
MULTISENSE_API bool frames_synchronized(const std::vector<ImageFrame> &frames, const std::chrono::nanoseconds &tolerance);
 
class MULTISENSE_API MultiChannelSynchronizer {
public:
 
   explicit MultiChannelSynchronizer(std::vector<std::unique_ptr<Channel>> channels,
                                     const std::chrono::nanoseconds &tolerance,
                                     size_t max_queue_size = 0):
        m_owned_channels(std::move(channels)),
        m_tolerance(tolerance),
        m_max_queue_size(max_queue_size)
    {
        for (auto &channel : m_owned_channels)
        {
            const auto config = channel->get_config();
 
            if (!config.time_config || !config.time_config->ptp_enabled)
            {
                throw std::runtime_error("Creating a MultiChannelSynchronizer with PTP disabled");
            }
 
            m_channels.push_back(channel.get());
        }
 
        m_active_frames.resize(m_channels.size());
        add_user_callbacks();
    }
 
   explicit MultiChannelSynchronizer(std::vector<Channel*> channels,
                                     const std::chrono::nanoseconds &tolerance,
                                     size_t max_queue_size = 0):
        m_channels(std::move(channels)),
        m_tolerance(tolerance),
        m_max_queue_size(max_queue_size)
    {
        m_active_frames.resize(m_channels.size());
        add_user_callbacks();
    }
 
    ~MultiChannelSynchronizer() = default;
 
    Channel& channel(size_t index)
    {
        if (index >= m_channels.size())
        {
            throw std::runtime_error("Invalid multi-channel access");
        }
 
        return *m_channels.at(index);
    }
 
    std::optional<std::vector<ImageFrame>> get_synchronized_frame()
    {
        return get_synchronized_frame(std::nullopt);
    }
 
    std::optional<std::vector<ImageFrame>> get_synchronized_frame(const std::optional<std::chrono::nanoseconds> &timeout);
 
private:
 
    void add_user_callbacks();
 
    std::vector<Channel*> m_channels{};
 
    std::vector<std::unique_ptr<Channel>> m_owned_channels{};
 
    std::vector<ImageFrame> m_active_frames{};
 
    std::chrono::nanoseconds m_tolerance{};
 
    size_t m_max_queue_size = 0;
 
    std::mutex m_frame_mutex;
 
    std::condition_variable m_frame_cv;
 
    std::deque<std::vector<ImageFrame>> m_ready_frames{};
};
 
}