graph_dispatcher.h

// SPDX-FileCopyrightText: © 2019-2021, 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "dsp/graph_builder.h"
#include "dsp/graph_scheduler.h"
#include "dsp/hardware_audio_interface.h"
#include "utils/rt_thread_id.h"
#include "utils/types.h"
 
namespace zrythm::dsp
{

class DspGraphDispatcher final
{
public:
  using RunFunctionWithEngineLock = std::function<void (std::function<void ()>)>;
 
  DspGraphDispatcher (
    std::unique_ptr<graph::IGraphBuilder>      graph_builder,
    std::vector<graph::IProcessable *>         terminal_processables,
    const IHardwareAudioInterface             &hw_interface,
    RunFunctionWithEngineLock                  run_function_with_engine_lock,
    graph::GraphScheduler::RunOnMainThreadFunc run_on_main_thread);

  void recalc_graph (bool soft);

  void start_cycle (
    const dsp::ITransport &current_transport_state,
    EngineProcessTimeInfo  time_nfo,
    nframes_t              remaining_latency_preroll,
    bool                   realtime_context,
    const dsp::TempoMap   &tempo_map) noexcept [[clang::nonblocking]];

  nframes_t get_max_route_playback_latency ();

  [[nodiscard, gnu::hot]] bool is_processing_kickoff_thread () const
  {
    return process_kickoff_thread_.has_value ()
             ? current_thread_id.get () == process_kickoff_thread_.value ()
             : false;
  }

  [[nodiscard, gnu::hot]] bool is_processing_thread () const
  {
    /* this is called too often so use this optimization */
    static thread_local bool have_result = false;
    static thread_local bool is_processing_thread = false;
 
    if (have_result) [[likely]]
      {
        return is_processing_thread;
      }
 
    if (!scheduler_) [[unlikely]]
      {
        have_result = false;
        is_processing_thread = false;
        return false;
      }
 
    if (scheduler_->contains_thread (current_thread_id.get ()))
      {
        is_processing_thread = true;
        have_result = true;
        return true;
      }
 
    have_result = true;
    is_processing_thread = false;
    return false;
  }

  auto &current_trigger_nodes () const
  {
    return scheduler_->get_nodes ().trigger_nodes_;
  }
 
private:
  void
  preprocess_at_start_of_cycle (const EngineProcessTimeInfo &time_nfo) noexcept
    [[clang::nonblocking]];
 
private:
  std::unique_ptr<graph::IGraphBuilder> graph_builder_;
  const IHardwareAudioInterface        &hw_interface_;

  RunFunctionWithEngineLock run_function_with_engine_lock_;

  std::vector<graph::IProcessable *> terminal_processables_;
 
  std::unique_ptr<graph::GraphScheduler> scheduler_;

  nframes_t max_route_playback_latency_ = 0;

  nframes_t global_offset_ = 0;

  std::optional<unsigned int> process_kickoff_thread_;
 
  graph::GraphScheduler::RunOnMainThreadFunc run_on_main_thread_;
};
 
}