engine.h

// SPDX-FileCopyrightText: © 2018-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-FileCopyrightText: © 2020 Ryan Gonzalez <rymg19 at gmail dot com>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "zrythm-config.h"
 
#include "dsp/panning.h"
#include "gui/backend/channel.h"
#include "gui/dsp/audio_port.h"
#include "gui/dsp/control_room.h"
#include "gui/dsp/ext_port.h"
#include "gui/dsp/hardware_processor.h"
#include "gui/dsp/midi_port.h"
#include "gui/dsp/pool.h"
#include "gui/dsp/sample_processor.h"
#include "gui/dsp/transport.h"
#include "utils/audio.h"
#include "utils/backtrace.h"
#include "utils/concurrency.h"
#include "utils/object_pool.h"
#include "utils/types.h"
 
#ifdef HAVE_JACK
#  include "weakjack/weak_libjack.h"
#endif
 
#if HAVE_PULSEAUDIO
#  include <pulse/pulseaudio.h>
#endif
 
#ifdef HAVE_PORT_AUDIO
#  include <portaudio.h>
#endif
 
#if HAVE_RTAUDIO
#  include <rtaudio_c.h>
#endif
 
namespace zrythm::gui::old_dsp::plugins
{
class Plugin;
}
class Tracklist;
class ExtPort;
class MidiMappings;
class Router;
class Metronome;
class Project;
class HardwareProcessor;

 
// should be set by backend
constexpr int BLOCK_LENGTH = 4096;
 
// should be set by backend
constexpr int MIDI_BUF_SIZE = 1024;
 
#define AUDIO_ENGINE (AudioEngine::get_active_instance ())
#define AUDIO_POOL (AUDIO_ENGINE->pool_)
 
#define DENORMAL_PREVENTION_VAL(engine_) ((engine_)->denormal_prevention_val_)
 
constexpr int ENGINE_MAX_EVENTS = 128;

#define ENGINE_EVENTS_PUSH(et, _arg, _uint_arg, _float_arg) \
  { \
    auto _ev = AUDIO_ENGINE->ev_pool_.acquire (); \
    _ev->file_ = __FILE__; \
    _ev->func_ = __func__; \
    _ev->lineno_ = __LINE__; \
    _ev->type_ = et; \
    _ev->arg_ = (void *) _arg; \
    _ev->uint_arg_ = _uint_arg; \
    _ev->float_arg_ = _float_arg; \
    AUDIO_ENGINE->ev_queue_.push_back (_ev); \
  }
 
enum class AudioBackend
{
  AUDIO_BACKEND_DUMMY,
  AUDIO_BACKEND_DUMMY_LIBSOUNDIO,
  AUDIO_BACKEND_ALSA,
  AUDIO_BACKEND_ALSA_LIBSOUNDIO,
  AUDIO_BACKEND_ALSA_RTAUDIO,
  AUDIO_BACKEND_JACK,
  AUDIO_BACKEND_JACK_LIBSOUNDIO,
  AUDIO_BACKEND_JACK_RTAUDIO,
  AUDIO_BACKEND_PULSEAUDIO,
  AUDIO_BACKEND_PULSEAUDIO_LIBSOUNDIO,
  AUDIO_BACKEND_PULSEAUDIO_RTAUDIO,
  AUDIO_BACKEND_COREAUDIO_LIBSOUNDIO,
  AUDIO_BACKEND_COREAUDIO_RTAUDIO,
  AUDIO_BACKEND_SDL,
  AUDIO_BACKEND_WASAPI_LIBSOUNDIO,
  AUDIO_BACKEND_WASAPI_RTAUDIO,
  AUDIO_BACKEND_ASIO_RTAUDIO,
};
 
static inline bool
audio_backend_is_rtaudio (AudioBackend backend)
{
  return backend == AudioBackend::AUDIO_BACKEND_ALSA_RTAUDIO
         || backend == AudioBackend::AUDIO_BACKEND_JACK_RTAUDIO
         || backend == AudioBackend::AUDIO_BACKEND_PULSEAUDIO_RTAUDIO
         || backend == AudioBackend::AUDIO_BACKEND_COREAUDIO_RTAUDIO
         || backend == AudioBackend::AUDIO_BACKEND_WASAPI_RTAUDIO
         || backend == AudioBackend::AUDIO_BACKEND_ASIO_RTAUDIO;
}

enum class BounceMode
{
  BOUNCE_OFF,

  BOUNCE_ON,

  BOUNCE_INHERIT,
};
 
enum class MidiBackend
{
  MIDI_BACKEND_DUMMY,
  MIDI_BACKEND_ALSA,
  MIDI_BACKEND_ALSA_RTMIDI,
  MIDI_BACKEND_JACK,
  MIDI_BACKEND_JACK_RTMIDI,
  MIDI_BACKEND_WINDOWS_MME,
  MIDI_BACKEND_WINDOWS_MME_RTMIDI,
  MIDI_BACKEND_COREMIDI_RTMIDI,
  MIDI_BACKEND_WINDOWS_UWP_RTMIDI,
};
 
static inline bool
midi_backend_is_rtmidi (MidiBackend backend)
{
  return backend == MidiBackend::MIDI_BACKEND_ALSA_RTMIDI
         || backend == MidiBackend::MIDI_BACKEND_JACK_RTMIDI
         || backend == MidiBackend::MIDI_BACKEND_WINDOWS_MME_RTMIDI
         || backend == MidiBackend::MIDI_BACKEND_COREMIDI_RTMIDI
         || backend == MidiBackend::MIDI_BACKEND_WINDOWS_UWP_RTMIDI;
}

class AudioEngine final : public ICloneable<AudioEngine>, public IPortOwner
{
public:
  enum class JackTransportType
  {
    TimebaseMaster,
    TransportClient,
    NoJackTransport,
  };

  enum class SampleRate
  {
    SR_22050,
    SR_32000,
    SR_44100,
    SR_48000,
    SR_88200,
    SR_96000,
    SR_192000,
  };

  enum class AudioEngineEventType
  {
    AUDIO_ENGINE_EVENT_BUFFER_SIZE_CHANGE,
    AUDIO_ENGINE_EVENT_SAMPLE_RATE_CHANGE,
  };

  class Event
  {
  public:
    Event () : file_ (nullptr), func_ (nullptr) { }
 
  public:
    AudioEngineEventType type_ =
      AudioEngineEventType::AUDIO_ENGINE_EVENT_BUFFER_SIZE_CHANGE;
    void *            arg_ = nullptr;
    uint32_t          uint_arg_ = 0;
    float             float_arg_ = 0.0f;
    const char *      file_ = nullptr;
    const char *      func_ = nullptr;
    int               lineno_ = 0;
    utils::Utf8String backtrace_;
  };

  enum class BufferSize
  {
    _16,
    _32,
    _64,
    _128,
    _256,
    _512,
    _1024,
    _2048,
    _4096,
  };
 
  // TODO: check if pausing/resuming can be done with RAII
  struct State
  {
    bool running_;
    bool playing_;
    bool looping_;
  };
 
  struct PositionInfo
  {
    bool is_rolling_ = false;

    float bpm_ = 120.f;

    double playhead_ticks_ = 0.0;
 
    /* - below are used as cache to avoid re-calculations - */

    int32_t bar_ = 1;

    int32_t beat_ = 1;

    int32_t sixteenth_ = 1;

    int32_t sixteenth_within_bar_ = 1;

    int32_t sixteenth_within_song_ = 1;

    double tick_within_beat_ = 0.0;

    double tick_within_bar_ = 0.0;

    int32_t ninetysixth_notes_ = 0;
  };
 
public:
  AudioEngine (Project * project = nullptr);

  ~AudioEngine () override;
 
  auto          &get_port_registry () { return *port_registry_; }
  auto          &get_port_registry () const { return *port_registry_; }
  TrackRegistry &get_track_registry ();
  TrackRegistry &get_track_registry () const;
 
  bool has_handled_buffer_size_change () const
  {
    return audio_backend_ != AudioBackend::AUDIO_BACKEND_JACK
           || (audio_backend_ == AudioBackend::AUDIO_BACKEND_JACK && handled_jack_buffer_size_change_.load());
  }
 
  bool is_in_active_project () const override;
 
  void set_port_metadata_from_owner (dsp::PortIdentifier &id, PortRange &range)
    const override;
 
  utils::Utf8String
  get_full_designation_for_port (const dsp::PortIdentifier &id) const override;

  void wait_for_pause (State &state, bool force_pause, bool with_fadeout);
 
  void realloc_port_buffers (nframes_t buf_size);

  [[gnu::cold]] void init_loaded (Project * project);
 
  void resume (State &state);

  void wait_n_cycles (int n);
 
  void append_ports (std::vector<Port *> &ports);

  void pre_setup ();

  void setup ();
 
  static AudioEngine * get_active_instance ();

  [[gnu::cold]] void activate (bool activate);

  void update_frames_per_tick (
    int           beats_per_bar,
    bpm_t         bpm,
    sample_rate_t sample_rate,
    bool          thread_check,
    bool          update_from_ticks,
    bool          bpm_change);

  bool process_events ();

  [[gnu::hot]] bool process_prepare (
    nframes_t                                         nframes,
    SemaphoreRAII<moodycamel::LightweightSemaphore> * sem = nullptr);

  [[gnu::hot]] int process (nframes_t total_frames_to_process);

  [[gnu::hot]] void post_process (nframes_t roll_nframes, nframes_t nframes);

  void fill_out_bufs (nframes_t nframes);

  static int buffer_size_enum_to_int (BufferSize buffer_size);

  static int samplerate_enum_to_int (SampleRate samplerate);

  void set_buffer_size (uint32_t buf_size);

  void reset_bounce_mode ();

  static void set_default_backends (bool reset_to_dummy);
 
  void init_after_cloning (const AudioEngine &other, ObjectCloneType clone_type)
    override;
 
  std::pair<AudioPort &, AudioPort &> get_monitor_out_ports ();
  std::pair<AudioPort &, AudioPort &> get_dummy_input_ports ();
 
private:
  static constexpr auto kTransportTypeKey = "transportType"sv;
  static constexpr auto kSampleRateKey = "sampleRate"sv;
  static constexpr auto kFramesPerTickKey = "framesPerTick"sv;
  static constexpr auto kMonitorOutLKey = "monitorOutL"sv;
  static constexpr auto kMonitorOutRKey = "monitorOutR"sv;
  static constexpr auto kMidiEditorManualPressKey = "midiEditorManualPress"sv;
  static constexpr auto kMidiInKey = "midiIn"sv;
  static constexpr auto kPoolKey = "pool"sv;
  static constexpr auto kControlRoomKey = "controlRoom"sv;
  static constexpr auto kSampleProcessorKey = "sampleProcessor"sv;
  static constexpr auto kHwInProcessorKey = "hwInProcessor"sv;
  static constexpr auto kHwOutProcessorKey = "hwOutProcessor"sv;
  friend void           to_json (nlohmann::json &j, const AudioEngine &engine)
  {
    j = nlohmann::json{
      { kTransportTypeKey,         engine.transport_type_           },
      { kSampleRateKey,            engine.sample_rate_              },
      { kFramesPerTickKey,         engine.frames_per_tick_          },
      { kMonitorOutLKey,           engine.monitor_out_left_         },
      { kMonitorOutRKey,           engine.monitor_out_right_        },
      { kMidiEditorManualPressKey, engine.midi_editor_manual_press_ },
      { kMidiInKey,                engine.midi_in_                  },
      { kPoolKey,                  engine.pool_                     },
      { kControlRoomKey,           engine.control_room_             },
      { kSampleProcessorKey,       engine.sample_processor_         },
      { kHwInProcessorKey,         engine.hw_in_processor_          },
      { kHwOutProcessorKey,        engine.hw_out_processor_         },
    };
  }
  friend void from_json (const nlohmann::json &j, AudioEngine &engine);

  int clean_duplicate_events_and_copy (std::array<Event *, 100> &ret);
 
  [[gnu::cold]] void init_common ();
 
  void update_position_info (PositionInfo &pos_nfo, nframes_t frames_to_add);

  void clear_output_buffers (nframes_t nframes);
 
  void receive_midi_events (uint32_t nframes);

  void stop_events ();
 
private:
  OptionalRef<PortRegistry> port_registry_;
 
public:
  Project * project_ = nullptr;

  std::atomic_uint64_t cycle_ = 0;
 
#ifdef HAVE_JACK
  jack_client_t * client_ = nullptr;
#else
  void * client_ = nullptr;
#endif

  std::atomic_bool handled_jack_buffer_size_change_ = false;

  JackTransportType transport_type_ = (JackTransportType) 0;

  AudioBackend audio_backend_ = (AudioBackend) 0;

  MidiBackend midi_backend_ = (MidiBackend) 0;

  nframes_t block_length_ = 0;

  size_t midi_buf_size_ = 0;

  sample_rate_t sample_rate_ = 0;

  dsp::FramesPerTick frames_per_tick_;

  dsp::TicksPerFrame ticks_per_frame_;

  int buf_size_set_ = 0;

  std::unique_ptr<Router> router_;

  std::unique_ptr<HardwareProcessor> hw_in_processor_;

  std::unique_ptr<HardwareProcessor> hw_out_processor_;

  std::unique_ptr<MidiPort> midi_clock_in_;

  std::unique_ptr<MidiPort> midi_clock_out_;

  std::unique_ptr<ControlRoom> control_room_;

  std::unique_ptr<AudioPool> pool_;

  std::optional<PortUuidReference> dummy_left_input_;
  std::optional<PortUuidReference> dummy_right_input_;

  std::optional<PortUuidReference> monitor_out_left_;
  std::optional<PortUuidReference> monitor_out_right_;

  std::atomic_bool trigger_midi_activity_{ false };

  std::unique_ptr<MidiPort> midi_editor_manual_press_;

  std::unique_ptr<MidiPort> midi_in_;

  nframes_t nframes_ = 0;

  moodycamel::LightweightSemaphore port_operation_lock_{ 1 };

  std::atomic_bool run_{ false };

  bool preparing_to_export_ = false;

  std::atomic_bool exporting_{ false };

  std::atomic_bool panic_{ false };
 
#ifdef HAVE_PORT_AUDIO
  PaStream * port_audio_stream_ = nullptr;
#else
  void * port_audio_stream_ = nullptr;
#endif

  float * port_audio_out_buf_ = nullptr;
 
#if HAVE_RTAUDIO
  rtaudio_t rtaudio_ = nullptr;
#else
  void * rtaudio_ = nullptr;
#endif
 
#if HAVE_PULSEAUDIO
  pa_threaded_mainloop * pulse_mainloop_ = nullptr;
  pa_context *           pulse_context_ = nullptr;
  pa_stream *            pulse_stream_ = nullptr;
#else
  void * pulse_mainloop_ = nullptr;
  void * pulse_context_ = nullptr;
  void * pulse_stream_ = nullptr;
#endif
  std::atomic_bool pulse_notified_underflow_{ false };

  std::unique_ptr<juce::Thread> dummy_audio_thread_;
 
  /* note: these 2 are ignored at the moment */
  dsp::PanLaw pan_law_ = {};
  dsp::PanAlgorithm pan_algo_ = {};

  // SteadyDuration last_time_taken_;

  RtDuration max_time_taken_{};

  RtTimePoint timestamp_start_{};

  // SteadyTimePoint timestamp_end_{};

  RtTimePoint last_timestamp_start_{};

  // SteadyTimePoint last_timestamp_end_{};

  nframes_t remaining_latency_preroll_ = 0;
 
  std::unique_ptr<SampleProcessor> sample_processor_;

  std::atomic_bool capture_cc_{ false };

  std::array<midi_byte_t, 3> last_cc_captured_{};

  SteadyTimePoint last_xrun_notification_;

  bool  denormal_prevention_val_positive_ = true;
  float denormal_prevention_val_ = 1e-12f;

  BounceMode bounce_mode_ = BounceMode::BOUNCE_OFF;

  utils::audio::BounceStep bounce_step_ = {};

  bool bounce_with_parents_ = false;

  std::unique_ptr<Metronome> metronome_;
 
  /* --- events --- */

  MPMCQueue<Event *> ev_queue_{ ENGINE_MAX_EVENTS };

  ObjectPool<Event> ev_pool_{ ENGINE_MAX_EVENTS };

  // sigc::scoped_connection process_source_id_;

  bool processing_events_ = false;

  SteadyTimePoint last_events_process_started_;

  SteadyTimePoint last_events_processed_;
 
  /* --- end events --- */

  std::atomic_bool cycle_running_{ false };

  bool pre_setup_ = false;

  bool setup_ = false;

  bool activated_ = false;

  bool destroying_ = false;

  bool updating_frames_per_tick_ = false;

  PositionInfo pos_nfo_before_ = {};

  PositionInfo pos_nfo_current_ = {};

  PositionInfo pos_nfo_at_end_ = {};
};
 
DEFINE_ENUM_FORMATTER (
  AudioBackend,
  AudioBackend,
  /* TRANSLATORS: Dummy backend */
  QT_TR_NOOP_UTF8 ("Dummy"),
  QT_TR_NOOP_UTF8 ("Dummy (libsoundio)"),
  "ALSA (not working)",
  "ALSA (libsoundio)",
  "ALSA (rtaudio)",
  "JACK",
  "JACK (libsoundio)",
  "JACK (rtaudio)",
  "PulseAudio",
  "PulseAudio (libsoundio)",
  "PulseAudio (rtaudio)",
  "CoreAudio (libsoundio)",
  "CoreAudio (rtaudio)",
  "SDL",
  "WASAPI (libsoundio)",
  "WASAPI (rtaudio)",
  "ASIO (rtaudio)")
 
DEFINE_ENUM_FORMATTER (
  MidiBackend,
  MidiBackend,
  /* TRANSLATORS: Dummy backend */
  QT_TR_NOOP_UTF8 ("Dummy"),
  QT_TR_NOOP_UTF8 ("ALSA Sequencer (not working)"),
  QT_TR_NOOP_UTF8 ("ALSA Sequencer (rtmidi)"),
  "JACK MIDI",
  "JACK MIDI (rtmidi)",
  "Windows MME",
  "Windows MME (rtmidi)",
  "CoreMIDI (rtmidi)",
  "Windows UWP (rtmidi)")
 
DEFINE_ENUM_FORMATTER (
  AudioEngine::SampleRate,
  AudioEngine_SampleRate,
  QT_TR_NOOP_UTF8 ("22,050"),
  QT_TR_NOOP_UTF8 ("32,000"),
  QT_TR_NOOP_UTF8 ("44,100"),
  QT_TR_NOOP_UTF8 ("48,000"),
  QT_TR_NOOP_UTF8 ("88,200"),
  QT_TR_NOOP_UTF8 ("96,000"),
  QT_TR_NOOP_UTF8 ("192,000"))
 
DEFINE_ENUM_FORMATTER (
  AudioEngine::BufferSize,
  AudioEngine_BufferSize,
  "16",
  "32",
  "64",
  "128",
  "256",
  "512",
  QT_TR_NOOP_UTF8 ("1,024"),
  QT_TR_NOOP_UTF8 ("2,048"),
  QT_TR_NOOP_UTF8 ("4,096"))