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 <juce_audio_basics/juce_audio_basics.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,
    std::optional<juce::AudioWorkgroup>        workgroup = std::nullopt);

  void recalc_graph (bool soft);

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

  units::sample_u32_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 dsp::graph::EngineProcessTimeInfo &time_nfo) noexcept
    [[clang::nonblocking]];
 
private:
  std::unique_ptr<graph::IGraphBuilder> graph_builder_;
  const IHardwareAudioInterface        &hw_interface_;
  std::optional<juce::AudioWorkgroup>   workgroup_;

  RunFunctionWithEngineLock run_function_with_engine_lock_;

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

  units::sample_u32_t max_route_playback_latency_;

  units::sample_u32_t global_offset_;

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