PacedFramePump.hpp

Go to the documentation of this file.

#pragma once
 
#include <score_plugin_gfx_export.h>
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <memory>
#include <semaphore>
#include <thread>
#include <vector>
 
namespace score::gfx::interop
{
 
class SCORE_PLUGIN_GFX_EXPORT PacedFramePump
{
public:
  struct Hooks
  {
    std::function<bool()> waitForTick;
    std::function<bool()> canAccept;
    std::function<bool(void* framePtr)> submit;
    std::function<void(void* framePtr)> discard;
  };
 
  explicit PacedFramePump(Hooks hooks, int ringDepth = 3);
  ~PacedFramePump();
 
  PacedFramePump(const PacedFramePump&) = delete;
  PacedFramePump& operator=(const PacedFramePump&) = delete;
 
  void start();
  void stop();
 
  bool push(void* framePtr);
 
  uint64_t goodXfers() const { return m_goodXfers.load(std::memory_order_relaxed); }
  uint64_t drops() const { return m_drops.load(std::memory_order_relaxed); }
  uint64_t underruns() const { return m_underruns.load(std::memory_order_relaxed); }
 
private:
  void run();
 
  Hooks m_hooks;
  const int m_depth;
 
  // Slot stores a frame pointer. nullptr = empty. A non-null write followed by
  // a writeIdx release-bump publishes it; the consumer reads with acquire.
  std::vector<std::atomic<void*>> m_slots;
  std::atomic<uint32_t> m_writeIdx{0};
  std::atomic<uint32_t> m_readIdx{0};
 
  // One permit per successfully push()ed frame; the consumer blocks here (not
  // in waitForTick) while idle. Drained-ahead frames return their permits via
  // try_acquire so the count tracks the ring.
  std::counting_semaphore<> m_framesAvail{0};
 
  std::thread m_thread;
  std::atomic<bool> m_running{false};
 
  std::atomic<uint64_t> m_goodXfers{0};
  std::atomic<uint64_t> m_drops{0};
  std::atomic<uint64_t> m_underruns{0};
};
 
} // namespace score::gfx::interop