irsol::server::frame_collector::FrameCollector Class Reference

Coordinates frame acquisition from a camera and distributes frames to registered clients. More...

#include <collector.hpp>

Public Types
using	frame_queue_t = ClientCollectionParams::frame_queue_t

Public Member Functions
	FrameCollector (irsol::camera::Interface &camera)
	Constructs a FrameCollector for the given camera interface.
	~FrameCollector ()
	Destructor. Stops any running threads and cleans up resources.
void	start ()
	Starts the frame collection and distribution thread.
void	stop ()
	Stops the frame collector and joins worker threads.
bool	isBusy () const
	Checks whether the collector is currently serving any clients.
void	registerClient (irsol::types::client_id_t clientId, double fps, std::shared_ptr< frame_queue_t > queue, int64_t frameCount=-1)
	Registers a client to receive frames at a specified frame rate.
void	deregisterClient (irsol::types::client_id_t clientId)
	Deregisters a client and stops frame delivery.

Static Public Member Functions
static std::shared_ptr< frame_queue_t >	makeQueuePtr ()
	Utility static function to create a shared pointer to a frame queue.

Static Public Attributes
static constexpr irsol::types::duration_t	SLACK = std::chrono::milliseconds(50)
	Slack window for batching frame delivery to clients.

Private Member Functions
void	run ()
	Runs the frame distribution loop in a background thread.
void	deregisterClientNonThreadSafe (irsol::types::client_id_t clientId)
	Deregisters a client and stops frame delivery (not thread-safe).
std::pair< std::vector< irsol::types::client_id_t >, std::vector< irsol::types::timepoint_t > >	collectReadyClients (irsol::types::timepoint_t now, irsol::types::duration_t slack) const
	Collects clients who are scheduled to receive a frame at the given time.
void	cleanUpSchedule (const std::vector< irsol::types::timepoint_t > schedules)
	Removes schedules from the schedule map.
std::optional< std::pair< FrameMetadata, std::vector< irsol::types::byte_t > > >	grabImageData () const
	Captures an image and returns it along with associated metadata.
bool	schedule (const irsol::types::client_id_t &clientId, irsol::types::timepoint_t nextFrameDue)
	Schedules the next frame delivery for a client.

Private Attributes
irsol::camera::Interface &	m_cam
	Reference to the camera interface used for capturing.
std::mutex	m_clientsMutex
	Protects access to m_clients and m_scheduleMap.
std::unordered_map< irsol::types::client_id_t, ClientCollectionParams >	m_clients
	Stores parameters for each registered client.
std::map< irsol::types::timepoint_t, std::vector< irsol::types::client_id_t > >	m_scheduleMap
	Maps timestamps to client IDs scheduled at that time.
std::condition_variable	m_scheduleCondition
	Signals when a new client is scheduled.
std::thread	m_distributorThread
	Thread responsible for frame distribution.
std::atomic< bool >	m_stop
	Indicates whether the collector is stopping due to an external request.

Detailed Description

Coordinates frame acquisition from a camera and distributes frames to registered clients.

The FrameCollector class is responsible for orchestrating the acquisition of frames from a camera device and distributing those frames to multiple registered clients. Each client can specify its desired frame rate and the number of frames it wishes to receive. The collector ensures that frames are delivered to clients according to their schedules, batching requests within a configurable "slack" window to optimize camera usage and minimize redundant captures. For instance, if multiple clients are scheduled to receive frames at similar times, a single frame image is requested from the camera and distributed to all those clients.

The collector maintains a background thread that monitors client schedules, captures frames just-in-time, and pushes them into client-specific irsol::utils::SafeQueue. Clients can consume frames from these queues at their own pace. When a client has received its requested number of frames, it is automatically deregistered and its queue is marked as complete.

The scheduling strategy is as follows:

• Each client registers with a desired frame rate (fps) and frame count.
• The collector maintains a schedule of when each client is next due to receive a frame.
• When the earliest scheduled time arrives (or is within the allowed slack), the collector captures a single frame and distributes it to all clients whose schedules fall within the slack window.
• This batching reduces redundant camera captures and ensures efficient resource usage.
• The collector supports dynamic registration and deregistration of clients at runtime.

Note

The current scheduling strategy can be extended or modified. For example, one might restrict allowed FPS values to multiples of 0.125s (i.e., FPS = 0.125, 0.25, 0.5, 1, 2, 4, 8, 16). In this approach, the FrameCollector would continuously capture frames at the highest frame rate required by any connected client, without scheduling individual capture times. A delivery selection mechanism could then be implemented to determine which captured frames are delivered to which clients, simplifying the scheduling logic and potentially improving efficiency.

Thread safety: All public methods are thread-safe unless otherwise noted.

Definition at line 69 of file collector.hpp.

Member Typedef Documentation

frame_queue_t

using irsol::server::frame_collector::FrameCollector::frame_queue_t = ClientCollectionParams::frame_queue_t

Definition at line 72 of file collector.hpp.

Constructor & Destructor Documentation

FrameCollector()

irsol::server::frame_collector::FrameCollector::FrameCollector

(

irsol::camera::Interface &

camera

)

Constructs a FrameCollector for the given camera interface.

Parameters

camera

Reference to a camera interface for capturing frames.

Definition at line 21 of file collector.cpp.

                                                          : m_cam(camera)
{
  start();
}

~FrameCollector()

irsol::server::frame_collector::FrameCollector::~FrameCollector

(

)

Destructor. Stops any running threads and cleans up resources.

Definition at line 26 of file collector.cpp.

{
  stop();
}

Member Function Documentation

cleanUpSchedule()

void irsol::server::frame_collector::FrameCollector::cleanUpSchedule ( const std::vector< irsol::types::timepoint_t >  schedules )

private

Removes schedules from the schedule map.

Parameters

schedules

Vector of schedule times to clean up.

Definition at line 342 of file collector.cpp.

{
  // Erase all the schedules in the input vector
  for(auto schedule : schedules) {
    m_scheduleMap.erase(schedule);
  }
}

collectReadyClients()

std::pair< std::vector< irsol::types::client_id_t >, std::vector< irsol::types::timepoint_t > > irsol::server::frame_collector::FrameCollector::collectReadyClients ( irsol::types::timepoint_t  now, irsol::types::duration_t  slack  ) const

private

Collects clients who are scheduled to receive a frame at the given time.

Parameters

now	Current timestamp.
slack	Allowed slack between now and client's schedule for considering a client to be ready for receiving data.

Returns

A pair of vectors: the first is a list of ready client IDs, the second contains the actual schedule times of the returned clients.

Definition at line 314 of file collector.cpp.

{
  IRSOL_NAMED_LOG_DEBUG(
    "frame_collector",
    "Collecting clients for time {}, with slack of {}",
    irsol::utils::timestampToString(now),
    irsol::utils::durationToString(slack));
  std::vector<irsol::types::client_id_t> readyClients;
  std::vector<irsol::types::timepoint_t> clientsSchedule;
 
  for(const auto& [scheduleTime, clients] : m_scheduleMap) {
    // As soon as the scheduleTime of the client is above now+slack, break the loop.
    // We can break early, as m_scheduleMap is an ordered container, that is iterated over
    // in a way that smaller keys (scheduledTimes) are always iterated over at the beginning.
    if(scheduleTime > now + slack) {
      break;
    }
    for(const auto& client : clients) {
      readyClients.push_back(client);
      clientsSchedule.push_back(scheduleTime);
    }
  }
 
  return {readyClients, clientsSchedule};
}

deregisterClient()

void irsol::server::frame_collector::FrameCollector::deregisterClient

(

irsol::types::client_id_t

clientId

)

Deregisters a client and stops frame delivery.

Parameters

clientId

The client's unique identifier.

Note

Removes all state registered associated with the client in the collector.

This method is thread-safe.

Definition at line 106 of file collector.cpp.

{
  std::scoped_lock<std::mutex> lock(m_clientsMutex);
  deregisterClientNonThreadSafe(clientId);
}

deregisterClientNonThreadSafe()

void irsol::server::frame_collector::FrameCollector::deregisterClientNonThreadSafe ( irsol::types::client_id_t  clientId )

private

Deregisters a client and stops frame delivery (not thread-safe).

Parameters

clientId

The client's unique identifier.

Note

Removes all state registered associated with the client in the collector.

This method is NOT thread-safe and should only be called with appropriate locking.

Definition at line 264 of file collector.cpp.

{
  // Mark the client's queue as finished, so the client is notified that
  // no more data will be pushed to him
  IRSOL_NAMED_LOG_INFO("frame_collector", "Deregistering client {}", clientId);
 
  if(m_clients.find(clientId) == m_clients.end()) {
    IRSOL_NAMED_LOG_WARN(
      "frame_collector", "Client {} was already deregistered, ignoring request.", clientId);
    return;
  }
  auto& clientParams = m_clients.at(clientId);
  clientParams.queue->producerFinished();
 
  // Removes the client from the storage
  auto dueNext = clientParams.nextFrameDue;
 
  m_clients.erase(clientId);
  IRSOL_NAMED_LOG_DEBUG(
    "frame_collector", "Removed client {}, now remaining  {} clients", clientId, m_clients.size());
 
  if(m_scheduleMap.find(dueNext) == m_scheduleMap.end()) {
    IRSOL_NAMED_LOG_WARN(
      "frame_collector",
      "Scheduled time {} was already deregistered. Ignoring request.",
      irsol::utils::timestampToString(dueNext));
    return;
  }
  auto& clientsAtDue = m_scheduleMap.at(dueNext);
 
  IRSOL_NAMED_LOG_DEBUG(
    "frame_collector",
    "Deregistering client {} from next schedule at {}",
    clientId,
    irsol::utils::timestampToString(dueNext));
  clientsAtDue.erase(
    std::remove(clientsAtDue.begin(), clientsAtDue.end(), clientId), clientsAtDue.end());
 
  if(clientsAtDue.empty()) {
    IRSOL_NAMED_LOG_DEBUG(
      "frame_collector",
      "No more clients for schedule {}. Removing schedule.",
      irsol::utils::timestampToString(dueNext));
    m_scheduleMap.erase(dueNext);
  }
 
  m_scheduleCondition.notify_one();
}

grabImageData()

std::optional< std::pair< FrameMetadata, std::vector< irsol::types::byte_t > > > irsol::server::frame_collector::FrameCollector::grabImageData ( ) const

private

Captures an image and returns it along with associated metadata.

Returns

A pair containing frame metadata and the image data buffer if image acquisition was successful, std::nullopt otherwise.

Definition at line 351 of file collector.cpp.

{
  // Capture the frame just-in-time
  IRSOL_MAYBE_UNUSED auto t0    = irsol::types::clock_t::now();
  auto                    image = m_cam.captureImage();
  IRSOL_MAYBE_UNUSED auto t1    = irsol::types::clock_t::now();
  IRSOL_NAMED_LOG_DEBUG(
    "frame_collector",
    "Capture image: start: {}, stop: {}, duration: {}",
    irsol::utils::timestampToString(t0),
    irsol::utils::timestampToString(t1),
    irsol::utils::durationToString(t1 - t0));
 
  // Extract the image data from the image buffer, and copy it into an
  // owning structure. In this way, when `image` is destroyed at the end of the
  // execution of this function, it can return into the pool of NeoAPI::Images
  // for next frames to be written to the buffer.
  auto* imageData = image.GetImageData();
  auto  numBytes  = image.GetSize();
 
  if(numBytes == 0) {
    return std::nullopt;
  }
 
  std::vector<irsol::types::byte_t> rawData(numBytes);
  std::memcpy(rawData.data(), imageData, numBytes);
 
  return std::make_pair<FrameMetadata, std::vector<irsol::types::byte_t>>(
    {irsol::types::clock_t::now(), image.GetImageID(), image.GetHeight(), image.GetWidth()},
    std::move(rawData));
}

isBusy()

bool irsol::server::frame_collector::FrameCollector::isBusy

(

)

const

Checks whether the collector is currently serving any clients.

Returns

true if at least one client is registered, false otherwise.

Definition at line 52 of file collector.cpp.

{
  return !m_clients.empty();
}

makeQueuePtr()

std::shared_ptr< FrameCollector::frame_queue_t > irsol::server::frame_collector::FrameCollector::makeQueuePtr ( )

static

Utility static function to create a shared pointer to a frame queue.

Clients may use this to obtain a queue prior to registering with the collector.

Returns

Shared pointer to a new frame queue.

See also

irsol::utils::SafeQueue

irsol::server::handlers::CommandGIHandler

irsol::server::handlers::CommandGISHandler

Definition at line 16 of file collector.cpp.

{
  return std::make_shared<FrameCollector::frame_queue_t>();
}

registerClient()

void irsol::server::frame_collector::FrameCollector::registerClient	(	irsol::types::client_id_t	clientId,
		double	fps,
		std::shared_ptr< frame_queue_t >	queue,
		int64_t	frameCount = -1
	)

Registers a client to receive frames at a specified frame rate.

Parameters

clientId	Unique identifier for the client.
fps	Desired frame rate (frames per second). If fps <= 0 and frameCount == 1, the client will receive a single frame immediately. Tipically used in gi command

See also

irsol::server::handlers::CommandGIHandler.

Parameters

queue	Shared pointer to the client's frame queue. The collector will push frame data into this queue at the schedule defined by the client.
frameCount	Number of frames to deliver; -1 means unlimited. After the last frame has been pushed to the client, the client is automatically deregistered and its queue marked as complete.

Note

This method is thread-safe.

Definition at line 58 of file collector.cpp.

{
 
  std::scoped_lock<std::mutex> lock(m_clientsMutex);
 
  std::chrono::microseconds interval;
  bool                      immediate = false;
  if(frameCount == 1 && fps <= 0.0) {
    // Client is requesting a single frame immediately
    interval   = std::chrono::microseconds(1);
    immediate  = true;
    frameCount = 1;
    fps        = 0.0;
  } else {
    interval = std::chrono::microseconds(static_cast<uint64_t>(1000000.0 / fps));
    IRSOL_NAMED_LOG_INFO(
      "frame_collector",
      "registering client with interval of {}",
      irsol::utils::durationToString(interval));
  }
 
  // Registers the client so that the next due time is in SLACK ms.
  // This is to allow the collector thread to batch multiple clients, that desire a frame at a
  // specific timestamp, but all within the SLACK duration and to serve them all with the same frame
  // image.
  auto nextDue = irsol::types::clock_t::now() + FrameCollector::SLACK;
 
  IRSOL_NAMED_LOG_INFO(
    "frame_collector",
    "Registering client {} with frame rate {} fps (interval {}), "
    "next frame due at {} #frames {}, immediate {}",
    clientId,
    fps,
    irsol::utils::durationToString(interval),
    irsol::utils::timestampToString(nextDue),
    frameCount,
    immediate);
 
  m_clients.emplace(
    clientId, ClientCollectionParams(fps, interval, nextDue, queue, frameCount, immediate));
  schedule(clientId, nextDue);
}

run()

void irsol::server::frame_collector::FrameCollector::run ( )

private

Runs the frame distribution loop in a background thread.

This method monitors client schedules, captures frames as needed, and distributes them to all clients whose scheduled delivery times fall within the current slack window. It also handles automatic deregistration of clients who have received their requested number of frames.

Definition at line 113 of file collector.cpp.

{
  std::unique_lock<std::mutex> lock(m_clientsMutex);
 
  while(!m_stop) {
    if(m_scheduleMap.empty()) {
      // Wait until at least one new client is registered in the map, or if a stop request has
      // arrived.
      m_scheduleCondition.wait(lock, [this]() {
        IRSOL_NAMED_LOG_DEBUG(
          "frame_collector",
          "Waiting until a client is scheduled (clients size: {}, schedule size: {})",
          m_clients.size(),
          m_scheduleMap.size());
        return m_stop || !m_scheduleMap.empty();
      });
    }
 
    if(m_stop.load()) {
      IRSOL_NAMED_LOG_INFO("frame_collector", "Requested frame-collection stop");
      break;
    }
 
    // Retrieve the nextDue time from the schedule map.
    // This map is always sorted from small to high, as it's an ordered container.
    irsol::types::timepoint_t nextDue = m_scheduleMap.begin()->first;
    IRSOL_NAMED_LOG_DEBUG(
      "frame_collector",
      "Running for frame collection due at {}",
      irsol::utils::timestampToString(nextDue));
 
    // Wait at most until the `nextDue` time.
    // Allow for early break in case of:
    // - m_stop is set to true due to a stop-request
    // - a new client is registered with a nextDue time that is smaller than the current nextDue
    // time
    m_scheduleCondition.wait_until(lock, nextDue, [this, currentNextDue = nextDue]() {
      if(m_stop.load()) {
        // stopped externally, exit the wait
        return true;
      }
      if(m_scheduleMap.empty()) {
        // Don't wake up early unnecessarily, as there's no schedules in the map
        return false;
      }
 
      // Check if a new schedule has been inserted into the map, which happens
      // earlier than the due time we captured prior to sleeping.
      auto newNextDue = m_scheduleMap.begin()->first;
 
      IRSOL_NAMED_LOG_DEBUG(
        "frame_collector",
        "Current first timestamp in the map: {}, current nextDue: {}",
        irsol::utils::timestampToString(newNextDue),
        irsol::utils::timestampToString(currentNextDue));
      return newNextDue < currentNextDue;
    });
 
    if(m_stop.load()) {
      IRSOL_NAMED_LOG_INFO(
        "frame_collector", "Frame collection stop request received, breaking loop");
      return;
    }
 
    // Refresh the nextDue, as the above condition might have finished due to a new client being
    // registered earlier than the 'nextDue' time that was initially selected.
    nextDue = m_scheduleMap.begin()->first;
 
    // Clients due now or earlier
    irsol::types::timepoint_t now = irsol::types::clock_t::now();
    IRSOL_NAMED_LOG_DEBUG(
      "frame_collector",
      "Woken up at timestamp {}, with next due at {}",
      irsol::utils::timestampToString(now),
      irsol::utils::timestampToString(nextDue));
 
    const auto slack = m_clients.size() == 1 ? std::chrono::milliseconds(0) : FrameCollector::SLACK;
    auto [readyClients, clientsSchedules] = collectReadyClients(now, slack);
    IRSOL_NAMED_LOG_DEBUG(
      "frame_collector", "Found {} clients that need an image now!", readyClients.size());
    {
      auto uniqueSchedules =
        std::set<irsol::types::timepoint_t>(clientsSchedules.begin(), clientsSchedules.end());
      for(auto uniqueSchedule : uniqueSchedules) {
        auto numClientsWithSchedule = std::count_if(
          clientsSchedules.begin(),
          clientsSchedules.end(),
          [&uniqueSchedule](const auto& schedule) { return schedule == uniqueSchedule; });
 
        if(uniqueSchedule != nextDue) {
          IRSOL_NAMED_LOG_WARN(
            "frame_collector_slack",
            "Actual schedule: {}, also considering {} clients with schedule {} due to allowed "
            "slack of {}",
            irsol::utils::timestampToString(nextDue),
            numClientsWithSchedule,
            irsol::utils::timestampToString(uniqueSchedule),
            irsol::utils::durationToString(slack));
        }
      }
    }
    cleanUpSchedule(clientsSchedules);
    IRSOL_NAMED_LOG_DEBUG(
      "frame_collector",
      "After schedule cleanup, there are still {} schedules",
      m_scheduleMap.size());
 
    auto grabResult = grabImageData();
    if(!grabResult) {
      IRSOL_NAMED_LOG_WARN("frame_collector", "Image acquisition failed.");
      continue;
    }
    auto& [frameMetadata, imageRawBuffer] = *grabResult;
 
    // Deliver the frame to clients
    std::vector<irsol::types::client_id_t> finishedClient;
    for(auto clientId : readyClients) {
      IRSOL_NAMED_LOG_DEBUG("frame_collector", "Notifying client {} for new image data", clientId);
      auto& clientParams = m_clients.at(clientId);
      // Push a new frame created on the fly to the current client's queue.
      // This creates a copy of the image data into the queue, and this is wanted, so that if a
      // consumer modifies the image, it doesn't affect other clients.
      clientParams.queue->push(std::make_unique<Frame>(
        frameMetadata,
        irsol::protocol::ImageBinaryData(
          {imageRawBuffer.begin(), imageRawBuffer.end()},
          {frameMetadata.height, frameMetadata.width},
          {irsol::protocol::BinaryDataAttribute("imageId", static_cast<int>(frameMetadata.frameId)),
           irsol::protocol::BinaryDataAttribute(
             "timestamp", irsol::utils::timestampToString(frameMetadata.timestamp))})));
 
      // Try to schedule the client, if no longer needed, register it in the finishedClients
      if(!schedule(clientId, clientParams.nextFrameDue + clientParams.interval)) {
        finishedClient.push_back(clientId);
      }
    }
 
    // Unlock the clients so we can remove finished clients
    for(const auto& clientId : finishedClient) {
      IRSOL_NAMED_LOG_DEBUG(
        "frame_collector",
        "Deregistering client {}, as it has consumed all the frames it needed.",
        clientId);
      deregisterClientNonThreadSafe(clientId);
    }
 
    IRSOL_NAMED_LOG_DEBUG("frame_collector", "Loop finished, restarting loop");
  }
}

schedule()

bool irsol::server::frame_collector::FrameCollector::schedule ( const irsol::types::client_id_t &  clientId, irsol::types::timepoint_t  nextFrameDue  )

private

Schedules the next frame delivery for a client.

Parameters

clientId	The client to schedule.
nextFrameDue	The next timestamp when the client should receive a frame.

Returns

true if successfully scheduled, false if the client is no longer active and can later be removed from the frame collector.

Definition at line 384 of file collector.cpp.

{
  IRSOL_ASSERT_ERROR(
    m_clients.find(clientId) != m_clients.end(), "Impossible to schedule an unregistered client.");
  // Update the parameters of the client.
  auto& clientParams = m_clients.at(clientId);
  if(clientParams.remainingFrames-- == 0 && clientParams.remainingFrames < 0) {
    // Client no longer expects frames.
    // This handles also clients that are listening forever, as their 'remainingFrames' is negative
    // so this¨ condition is never fully met.
    IRSOL_NAMED_LOG_DEBUG(
      "frame_collector", "Client {} had no longer frames to produce.", clientId);
    return false;
  }
 
  if(clientParams.nextFrameDue == nextFrameDue) {
    // This has been called the first time for client-registration
    IRSOL_NAMED_LOG_DEBUG(
      "frame_collector",
      "Client {} has been scheduled for timestamp {}.",
      clientId,
      irsol::utils::timestampToString(clientParams.nextFrameDue));
  } else {
 
    IRSOL_NAMED_LOG_DEBUG(
      "frame_collector",
      "(Rescheduling client {} for next frame, previous due: {}, next due {}, # count {}",
      clientId,
      irsol::utils::timestampToString(clientParams.nextFrameDue),
      irsol::utils::timestampToString(nextFrameDue),
      clientParams.remainingFrames);
  }
 
  // Updates the parameters of the client
  clientParams.nextFrameDue = nextFrameDue;
 
  // Registers the client for the scheduled timestamp.
  m_scheduleMap[nextFrameDue].push_back(clientId);
 
  // Notify the condition variable, that a new client has been scheduled
  m_scheduleCondition.notify_one();
  return true;
}

start()

void irsol::server::frame_collector::FrameCollector::start

(

)

Starts the frame collection and distribution thread.

If the collector is already running, this call is ignored.

Definition at line 32 of file collector.cpp.

{
  if(m_stop.load()) {
    IRSOL_NAMED_LOG_WARN(
      "frame_collector", "Collector was requested to stop already. Ignoring re-start request");
    return;
  }
  m_distributorThread = std::thread(&FrameCollector::run, this);
}

stop()

void irsol::server::frame_collector::FrameCollector::stop

(

)

Stops the frame collector and joins worker threads.

After calling stop(), no further frames will be delivered to clients.

Definition at line 43 of file collector.cpp.

{
  m_stop.store(true);
  m_scheduleCondition.notify_all();
  if(m_distributorThread.joinable())
    m_distributorThread.join();
}

Member Data Documentation

m_cam

irsol::camera::Interface& irsol::server::frame_collector::FrameCollector::m_cam

private

Reference to the camera interface used for capturing.

Definition at line 214 of file collector.hpp.

m_clients

std::unordered_map<irsol::types::client_id_t, ClientCollectionParams> irsol::server::frame_collector::FrameCollector::m_clients

private

Stores parameters for each registered client.

Definition at line 218 of file collector.hpp.

m_clientsMutex

std::mutex irsol::server::frame_collector::FrameCollector::m_clientsMutex

private

Protects access to m_clients and m_scheduleMap.

Definition at line 216 of file collector.hpp.

m_distributorThread

std::thread irsol::server::frame_collector::FrameCollector::m_distributorThread

private

Thread responsible for frame distribution.

Definition at line 223 of file collector.hpp.

m_scheduleCondition

std::condition_variable irsol::server::frame_collector::FrameCollector::m_scheduleCondition

private

Signals when a new client is scheduled.

Definition at line 222 of file collector.hpp.

m_scheduleMap

std::map<irsol::types::timepoint_t, std::vector<irsol::types::client_id_t> > irsol::server::frame_collector::FrameCollector::m_scheduleMap

private

Maps timestamps to client IDs scheduled at that time.

Definition at line 220 of file collector.hpp.

m_stop

std::atomic<bool> irsol::server::frame_collector::FrameCollector::m_stop

private

Initial value:

{
    false}

Indicates whether the collector is stopping due to an external request.

Definition at line 225 of file collector.hpp.

                        {
    false};  

SLACK

constexpr irsol::types::duration_t irsol::server::frame_collector::FrameCollector::SLACK = std::chrono::milliseconds(50)

staticconstexpr

Slack window for batching frame delivery to clients.

Clients whose scheduled delivery times fall within this window of a captured frame will all receive the same frame. This reduces redundant captures and improves efficiency.

Definition at line 91 of file collector.hpp.

---

The documentation for this class was generated from the following files:

• src/irsol/include/irsol/server/image_collector/collector.hpp
• src/irsol/lib/irsol/server/image_collector/collector.cpp