RenderClock.hpp

#pragma once
#include <score_plugin_gfx_export.h>
 
#include <QMetaObject>
#include <QObject>
 
#include <atomic>
#include <functional>
#include <thread>
#include <vector>
 
namespace score
{
class Timers;
class HighResolutionTimer;
}
 
namespace score::gfx
{
class OutputNode;
 
class SCORE_PLUGIN_GFX_EXPORT RenderClock
{
public:
  enum class Kind
  {
    Timer,           //< shared wall-timer at manualRenderingRate (the default)
    DisplayVSync,    //< display swap-chain vsync callback (push)
    ExternalGenlock  //< hardware genlock, e.g. a card's VBI
  };
 
  virtual ~RenderClock();
 
  virtual Kind kind() const noexcept = 0;
 
  virtual void start(std::function<void()> tick) = 0;
 
  virtual void stop() = 0;
};
 
class SCORE_PLUGIN_GFX_EXPORT TimerClock final : public RenderClock
{
public:
  TimerClock(score::Timers& timers, QObject* owner, double frequencyHz);
  ~TimerClock() override;
 
  Kind kind() const noexcept override { return Kind::Timer; }
 
  double frequency() const noexcept { return m_frequency; }
 
  // Coalesced set of outputs driven by this clock's shared timer.
  void addOutput(OutputNode* o);
  void removeOutput(OutputNode* o);
  bool empty() const noexcept { return m_outputs.empty(); }
  const std::vector<OutputNode*>& outputs() const noexcept { return m_outputs; }
 
  void start(std::function<void()> tick) override;
  void stop() override;
 
private:
  score::Timers& m_timers;
  QObject* m_owner{};
  double m_frequency{};
  score::HighResolutionTimer* m_timer{};
  QMetaObject::Connection m_conn;
  std::function<void()> m_tick;
  std::vector<OutputNode*> m_outputs;
 
  // Receiver context for the queued timeout connection. Destroying this (a
  // member, so torn down with the TimerClock) removes any already-posted
  // queued timeout events targeting it — QObject::disconnect() alone does not,
  // which let a pending tick fire the lambda on this freed TimerClock during
  // shutdown (heap-use-after-free, RenderClock.cpp `if(m_tick)`). Lives on the
  // same (render) thread as m_owner since TimerClocks are built there, so the
  // tick is still delivered on that thread.
  QObject m_receiver;
};
 
class SCORE_PLUGIN_GFX_EXPORT DisplayVSyncClock final : public RenderClock
{
public:
  explicit DisplayVSyncClock(OutputNode& output);
  ~DisplayVSyncClock() override;
 
  Kind kind() const noexcept override { return Kind::DisplayVSync; }
 
  void start(std::function<void()> tick) override;
  void stop() override;
 
private:
  OutputNode& m_output;
};
 
class SCORE_PLUGIN_GFX_EXPORT ExternalGenlockClock final : public RenderClock
{
public:
  ExternalGenlockClock(QObject* owner, std::function<bool()> waitForNextTick);
  ~ExternalGenlockClock() override;
 
  Kind kind() const noexcept override { return Kind::ExternalGenlock; }
 
  void start(std::function<void()> tick) override;
  void stop() override;
 
private:
  void run();
 
  QObject* m_owner{};
  std::function<bool()> m_waitForNextTick;
  std::function<void()> m_tick;
  std::thread m_thread;
  std::atomic<bool> m_running{false};
  std::atomic<bool> m_exited{false};
};
}