engine.h

// SPDX-FileCopyrightText: © 2018-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <optional>
 
#include "dsp/audio_callback.h"
#include "dsp/audio_input_processor.h"
#include "dsp/audio_port.h"
#include "dsp/graph_dispatcher.h"
#include "dsp/hardware_audio_interface.h"
#include "dsp/hardware_midi_interface.h"
#include "dsp/midi_input_processor.h"
#include "dsp/midi_panic_processor.h"
#include "dsp/midi_port.h"
#include "dsp/transport.h"
#include "utils/concurrency.h"
#include "utils/object_registry.h"
 
namespace zrythm::dsp
{

class AudioEngine : public QObject
{
  Q_OBJECT
  Q_PROPERTY (int sampleRate READ sampleRate NOTIFY sampleRateChanged)
  Q_PROPERTY (int blockLength READ blockLength NOTIFY blockLengthChanged)
  QML_ELEMENT
  QML_UNCREATABLE ("")
 
public:
  enum class State : std::uint8_t
  {
    Uninitialized,
    Initialized,
    Active,
  };
 
  // TODO: check if pausing/resuming can be done with RAII
  struct EngineState
  {
    bool running_;
    bool playing_;
    bool looping_;
  };
 
public:
  AudioEngine (
    dsp::Transport          &transport,
    IHardwareAudioInterface &hw_interface,
    IHardwareMidiInterface  &midi_interface,
    dsp::DspGraphDispatcher &graph_dispatcher,
    const dsp::TempoMap     &tempo_map,
    QObject *                parent = nullptr);

  ~AudioEngine () override;
 
  // =========================================================
  // QML interface
  // =========================================================
 
  Q_INVOKABLE int xRunCount () const { return load_measurer_.getXRunCount (); }
  Q_INVOKABLE double loadPercentage () const
  {
    return load_measurer_.getLoadAsPercentage ();
  }

  int sampleRate () const;
  int blockLength () const;
 
  Q_SIGNAL void sampleRateChanged (int sampleRate);
  Q_SIGNAL void blockLengthChanged (int blockLength);
 
  // =========================================================

  units::sample_rate_t sample_rate () const;
  units::sample_u32_t block_length () const;
  utils::Utf8String device_name () const;

  void wait_for_pause (EngineState &state, bool force_pause, bool with_fadeout);
 
  void resume (const EngineState &state);

  Q_INVOKABLE void activate ();

  Q_INVOKABLE void deactivate ();

  [[gnu::hot]] bool process_prepare (
    dsp::Transport::TransportSnapshot               &transport_snapshot,
    units::sample_u32_t                              nframes,
    SemaphoreRAII<moodycamel::LightweightSemaphore> &sem) noexcept
    [[clang::nonblocking]];
 
  enum class ProcessReturnStatus : std::uint8_t
  {
    // Process completed normally
    ProcessCompleted,
    // Process skipped (e.g., when recalculating the graph)
    ProcessSkipped,
    // Process failed for some reason
    ProcessFailed,
  };

  [[gnu::hot]] auto process (
    const dsp::PlayheadProcessingGuard &playhead_guard,
    units::sample_u32_t total_frames_to_process) noexcept [[clang::nonblocking]]
  -> ProcessReturnStatus;

  [[gnu::hot]] void advance_playhead_after_processing (
    dsp::Transport::TransportSnapshot  &transport_snapshot,
    const dsp::PlayheadProcessingGuard &playhead_guard,
    units::sample_u32_t                 roll_nframes,
    units::sample_u32_t nframes) noexcept [[clang::nonblocking]];
 
  void set_monitor_out_source (dsp::AudioPort &port)
  {
    assert (!audio_callback_active_);
    monitor_out_source_ = &port;
  }
 
  auto * midi_panic_processor () const { return midi_panic_processor_.get (); }

  auto * audio_input_processor () const
  {
    return audio_input_processor_.get ();
  }
 
  const auto &midi_input_processors () const { return midi_input_processors_; }

  void panic_all ();
 
  bool  activated () const { return state_ == State::Active; }
  bool  running () const { return run_.load (); }
  void  set_running (bool run) { run_.store (run); }
  auto &graph_dispatcher () { return graph_dispatcher_; }
 
  bool exporting () const { return exporting_; }
  void set_exporting (bool exporting) { exporting_.store (exporting); }
 
  auto get_processing_lock () [[clang::blocking]]
  {
    return SemaphoreRAII (process_lock_, true);
  }

  void execute_function_with_paused_processing_synchronously (
    const std::function<void ()> &func,
    bool                          recalculate_graph);
 
private:
  void activate_impl (bool activate);

  void update_midi_processors (
    const IHardwareMidiInterface::BufferMap &active_buffers);
 
private:
  utils::ObjectRegistry local_registry_;
 
  dsp::Transport &transport_;

  const dsp::TempoMap &tempo_map_;

  dsp::DspGraphDispatcher &graph_dispatcher_;
 
  IHardwareAudioInterface &hw_interface_;
  IHardwareMidiInterface  &midi_interface_;

  std::atomic_uint64_t cycle_{ 0 };

  dsp::AudioPort * monitor_out_source_ = nullptr;

  std::unique_ptr<dsp::MidiPort> midi_in_;

  moodycamel::LightweightSemaphore process_lock_{ 1 };

  std::atomic_bool run_{ false };

  std::atomic_bool exporting_{ false };
 
  juce::AudioProcessLoadMeasurer load_measurer_;

  units::sample_u32_t remaining_latency_preroll_;

  std::atomic_bool capture_cc_{ false };

  std::array<midi_byte_t, 3> last_cc_captured_{};
 
  std::atomic<State> state_{ State::Uninitialized };
  static_assert (decltype (state_)::is_always_lock_free);
 
  std::optional<dsp::AudioDeviceInfo> cached_device_info_;
 
  utils::QObjectUniquePtr<dsp::MidiPanicProcessor> midi_panic_processor_;
 
  std::unique_ptr<AudioCallback> audio_callback_;
 
  utils::QObjectUniquePtr<AudioInputProcessor> audio_input_processor_;
 
  std::map<utils::Utf8String, utils::QObjectUniquePtr<MidiInputProcessor>>
    midi_input_processors_;

  std::span<const float * const> current_hw_input_;

  bool audio_callback_active_{};

  units::precise_second_t block_start_time_;
};
}