engine.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2018-2023 Alexandros Theodotou <alex@zrythm.org>
// SPDX-FileCopyrightText: © 2020 Ryan Gonzalez <rymg19 at gmail dot com>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __AUDIO_ENGINE_H__
#define __AUDIO_ENGINE_H__
 
#include "zrythm-config.h"
 
#include "dsp/control_room.h"
#include "dsp/exporter.h"
#include "dsp/ext_port.h"
#include "dsp/hardware_processor.h"
#include "dsp/pan.h"
#include "dsp/pool.h"
#include "dsp/sample_processor.h"
#include "dsp/transport.h"
#include "utils/types.h"
 
#include "zix/sem.h"
 
#ifdef HAVE_JACK
#  include "weak_libjack.h"
#endif
 
#ifdef HAVE_PULSEAUDIO
#  include <pulse/pulseaudio.h>
#endif
 
#ifdef HAVE_PORT_AUDIO
#  include <portaudio.h>
#endif
 
#ifdef HAVE_ALSA
#  include <alsa/asoundlib.h>
#endif
 
#ifdef HAVE_SDL
#  include <SDL2/SDL_audio.h>
#endif
 
#ifdef HAVE_RTAUDIO
#  include <rtaudio_c.h>
#endif
 
typedef struct StereoPorts       StereoPorts;
typedef struct Port              Port;
typedef struct Channel           Channel;
typedef struct Plugin            Plugin;
typedef struct Tracklist         Tracklist;
typedef struct ExtPort           ExtPort;
typedef struct MidiMappings      MidiMappings;
typedef struct WindowsMmeDevice  WindowsMmeDevice;
typedef struct Router            Router;
typedef struct Metronome         Metronome;
typedef struct Project           Project;
typedef struct HardwareProcessor HardwareProcessor;
typedef struct ObjectPool        ObjectPool;
typedef struct MPMCQueue         MPMCQueue;
 
#define BLOCK_LENGTH 4096  // should be set by backend
#define MIDI_BUF_SIZE 1024 // should be set by backend
 
#define MIDI_IN_NUM_EVENTS AUDIO_ENGINE->midi_in->midi_events->num_events
 
#define AUDIO_ENGINE (PROJECT->audio_engine)
#define MANUAL_PRESS_EVENTS \
  (AUDIO_ENGINE->midi_editor_manual_press->midi_events)
 
#define DENORMAL_PREVENTION_VAL(engine_) (engine_->denormal_prevention_val)
 
#define engine_is_in_active_project(self) (self->project == PROJECT)
 
#define engine_set_run(engine, _run) g_atomic_int_set (&(engine)->run, _run)
#define engine_get_run(engine) g_atomic_int_get (&(engine)->run)
 
#define engine_has_handled_buffer_size_change(engine) \
  ((engine)->audio_backend != AudioBackend::AUDIO_BACKEND_JACK || ((engine)->audio_backend == AudioBackend::AUDIO_BACKEND_JACK && g_atomic_int_get (&(engine)->handled_jack_buffer_size_change) == 1))
 
#define ENGINE_MAX_EVENTS 100
 
#define engine_queue_push_back_event(q, x) mpmc_queue_push_back (q, (void *) x)
 
#define engine_queue_dequeue_event(q, x) mpmc_queue_dequeue (q, (void **) x)
 
#define ENGINE_EVENTS_PUSH(et, _arg, _uint_arg, _float_arg) \
  if (true) \
    { \
      AudioEngineEvent * _ev = \
        (AudioEngineEvent *) object_pool_get (AUDIO_ENGINE->ev_pool); \
      _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; \
      if (zrythm_app->gtk_thread == g_thread_self ()) \
        { \
          _ev->backtrace = backtrace_get ("", 40, false); \
          g_debug ( \
            "pushing engine event " #et " (%s:%d) uint: %u | float: %f", \
            __func__, __LINE__, _uint_arg, _float_arg); \
        } \
      engine_queue_push_back_event (AUDIO_ENGINE->ev_queue, _ev); \
    }
 
enum class AudioEngineEventType
{
  AUDIO_ENGINE_EVENT_BUFFER_SIZE_CHANGE,
  AUDIO_ENGINE_EVENT_SAMPLE_RATE_CHANGE,
};
 
typedef struct AudioEngineEvent
{
  AudioEngineEventType type;
  void *               arg;
  uint32_t             uint_arg;
  float                float_arg;
  const char *         file;
  const char *         func;
  int                  lineno;
  char *               backtrace;
} AudioEngineEvent;
 
enum class AudioEngineBufferSize
{
  AUDIO_ENGINE_BUFFER_SIZE_16,
  AUDIO_ENGINE_BUFFER_SIZE_32,
  AUDIO_ENGINE_BUFFER_SIZE_64,
  AUDIO_ENGINE_BUFFER_SIZE_128,
  AUDIO_ENGINE_BUFFER_SIZE_256,
  AUDIO_ENGINE_BUFFER_SIZE_512,
  AUDIO_ENGINE_BUFFER_SIZE_1024,
  AUDIO_ENGINE_BUFFER_SIZE_2048,
  AUDIO_ENGINE_BUFFER_SIZE_4096,
};
 
static const char * buffer_size_str[] = {
  "16",  "32",         "64",         "128",        "256",
  "512", N_ ("1,024"), N_ ("2,048"), N_ ("4,096"),
};
 
static inline const char *
engine_buffer_size_to_string (AudioEngineBufferSize buf_size)
{
  return buffer_size_str[static_cast<int> (buf_size)];
}
 
enum class AudioEngineSamplerate
{
  AUDIO_ENGINE_SAMPLERATE_22050,
  AUDIO_ENGINE_SAMPLERATE_32000,
  AUDIO_ENGINE_SAMPLERATE_44100,
  AUDIO_ENGINE_SAMPLERATE_48000,
  AUDIO_ENGINE_SAMPLERATE_88200,
  AUDIO_ENGINE_SAMPLERATE_96000,
  AUDIO_ENGINE_SAMPLERATE_192000,
};
 
static const char * sample_rate_str[] = {
  N_ ("22,050"), N_ ("32,000"), N_ ("44,100"),  N_ ("48,000"),
  N_ ("88,200"), N_ ("96,000"), N_ ("192,000"),
};
 
static inline const char *
engine_sample_rate_to_string (AudioEngineSamplerate sample_rate)
{
  return sample_rate_str[static_cast<int> (sample_rate)];
}
 
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;
}
 
__attribute__ ((unused)) static const char * audio_backend_str[] = {
  /* TRANSLATORS: Dummy backend */
  N_ ("Dummy"),           N_ ("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)",
};
 
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;
}
 
static const char * midi_backend_str[] = {
  /* TRANSLATORS: Dummy backend */
  N_ ("Dummy"),
  N_ ("ALSA Sequencer (not working)"),
  N_ ("ALSA Sequencer (rtmidi)"),
  "JACK MIDI",
  "JACK MIDI (rtmidi)",
  "Windows MME",
  "Windows MME (rtmidi)",
  "CoreMIDI (rtmidi)",
  "Windows UWP (rtmidi)",
};
 
enum class AudioEngineJackTransportType
{
  AUDIO_ENGINE_JACK_TIMEBASE_MASTER,
  AUDIO_ENGINE_JACK_TRANSPORT_CLIENT,
  AUDIO_ENGINE_NO_JACK_TRANSPORT,
};
 
typedef struct AudioEnginePositionInfo
{
  bool is_rolling;
 
  float bpm;
 
  double playhead_ticks;
 
  /* - below are used as cache to avoid re-calculations - */
 
  int32_t bar;
 
  int32_t beat;
 
  int32_t sixteenth;
 
  int32_t sixteenth_within_bar;
 
  int32_t sixteenth_within_song;
 
  double tick_within_beat;
 
  double tick_within_bar;
 
  int32_t ninetysixth_notes;
} AudioEnginePositionInfo;
 
typedef struct AudioEngine
{
  uint_fast64_t cycle;
 
#ifdef HAVE_JACK
  jack_client_t * client;
#else
  void * client;
#endif
 
  gint handled_jack_buffer_size_change;
 
  AudioEngineJackTransportType transport_type;
 
  AudioBackend audio_backend;
 
  MidiBackend midi_backend;
 
  nframes_t block_length;
 
  size_t midi_buf_size;
 
  sample_rate_t sample_rate;
 
  double frames_per_tick;
 
  double ticks_per_frame;
 
  int buf_size_set;
 
  Router * router;
 
  HardwareProcessor * hw_in_processor;
 
  HardwareProcessor * hw_out_processor;
 
  Port * midi_clock_in;
 
  Port * midi_clock_out;
 
  ControlRoom * control_room;
 
  AudioPool * pool;
 
  StereoPorts * dummy_input;
 
  StereoPorts * monitor_out;
 
  int trigger_midi_activity;
 
#if 0
  gint64            last_midi_activity;
#endif
 
  Port * midi_editor_manual_press;
 
  Port * midi_in;
 
  nframes_t nframes;
 
  ZixSem port_operation_lock;
 
  gint run;
 
  bool preparing_to_export;
 
  gint exporting;
 
  gint panic;
 
  // ZixSem             alsa_callback_start;
 
  /* ----------- ALSA --------------- */
#ifdef HAVE_ALSA
  snd_pcm_t *           playback_handle;
  snd_seq_t *           seq_handle;
  snd_pcm_hw_params_t * hw_params;
  snd_pcm_sw_params_t * sw_params;
 
  // MidiEvents         alsa_midi_events;
 
  // ZixSem             alsa_midi_events_sem;
#else
  void * playback_handle;
  void * seq_handle;
  void * hw_params;
  void * sw_params;
#endif
 
  float * alsa_out_buf;
 
  /* ------------------------------- */
 
  gint filled_stereo_out_bufs;
 
  gint preparing_for_process;
 
#ifdef HAVE_PORT_AUDIO
  PaStream * port_audio_stream;
#else
  void * port_audio_stream;
#endif
 
  float * port_audio_out_buf;
 
#ifdef _WIN32
  WindowsMmeDevice * mme_in_devs[1024];
  int                num_mme_in_devs;
  WindowsMmeDevice * mme_out_devs[1024];
  int                num_mme_out_devs;
#else
  void * mme_in_devs[1024];
  int    num_mme_in_devs;
  void * mme_out_devs[1024];
  int    num_mme_out_devs;
#endif
 
#ifdef HAVE_SDL
  SDL_AudioDeviceID dev;
#else
  uint32_t sdl_dev;
#endif
 
#ifdef HAVE_RTAUDIO
  rtaudio_t rtaudio;
#else
  void * rtaudio;
#endif
 
#ifdef HAVE_PULSEAUDIO
  pa_threaded_mainloop * pulse_mainloop;
  pa_context *           pulse_context;
  pa_stream *            pulse_stream;
#else
  void * pulse_mainloop;
  void * pulse_context;
  void * pulse_stream;
#endif
  gboolean pulse_notified_underflow;
 
  GThread * dummy_audio_thread;
 
  int stop_dummy_audio_thread;
 
  Transport * transport;
 
  /* note: these 2 are ignored at the moment */
  PanLaw pan_law;
  PanAlgorithm pan_algo;
 
  gint64 last_time_taken;
 
  gint64 max_time_taken;
 
  gint64 timestamp_start;
 
  gint64 timestamp_end;
 
  gint64 last_timestamp_start;
 
  gint64 last_timestamp_end;
 
  nframes_t remaining_latency_preroll;
 
  SampleProcessor * sample_processor;
 
  int capture_cc;
 
  midi_byte_t last_cc[3];
 
  gint64 last_xrun_notification;
 
  bool  denormal_prevention_val_positive;
  float denormal_prevention_val;
 
  /* --- trial version flags --- */
 
  gint64 zrythm_start_time;
 
  int limit_reached;
 
  /* --- end trial version flags --- */
 
  BounceMode bounce_mode;
 
  BounceStep bounce_step;
 
  bool bounce_with_parents;
 
  Metronome * metronome;
 
  /* --- events --- */
 
  MPMCQueue * ev_queue;
 
  ObjectPool * ev_pool;
 
  guint process_source_id;
 
  int processing_events;
 
  gint64 last_events_process_started;
 
  gint64 last_events_processed;
 
  /* --- end events --- */
 
  gint cycle_running;
 
  bool pre_setup;
 
  bool setup;
 
  bool activated;
 
  Project * project;
 
  bool updating_frames_per_tick;
 
  AudioEnginePositionInfo pos_nfo_before;
 
  AudioEnginePositionInfo pos_nfo_current;
 
  AudioEnginePositionInfo pos_nfo_at_end;
 
} AudioEngine;
 
void
engine_realloc_port_buffers (AudioEngine * self, nframes_t buf_size);
 
COLD NONNULL_ARGS (1) bool engine_init_loaded (
  AudioEngine * self,
  Project *     project,
  GError **     error);
 
COLD WARN_UNUSED_RESULT AudioEngine *
engine_new (Project * project);
 
typedef struct EngineState
{
  int running;
  bool playing;
  bool looping;
} EngineState;
 
void
engine_wait_for_pause (
  AudioEngine * self,
  EngineState * state,
  bool          force_pause,
  bool          with_fadeout);
 
void
engine_resume (AudioEngine * self, EngineState * state);
 
void
engine_wait_n_cycles (AudioEngine * self, int n);
 
void
engine_append_ports (AudioEngine * self, GPtrArray * ports);
 
void
engine_pre_setup (AudioEngine * self);
 
void
engine_setup (AudioEngine * self);
 
COLD void
engine_activate (AudioEngine * self, bool activate);
 
void
engine_update_frames_per_tick (
  AudioEngine *       self,
  const int           beats_per_bar,
  const bpm_t         bpm,
  const sample_rate_t sample_rate,
  bool                thread_check,
  bool                update_from_ticks,
  bool                bpm_change);
 
int
engine_process_events (AudioEngine * self);
 
NONNULL HOT bool
engine_process_prepare (AudioEngine * self, nframes_t nframes);
 
NONNULL HOT int
engine_process (AudioEngine * self, const nframes_t total_frames_to_process);
 
NONNULL HOT void
engine_post_process (
  AudioEngine *   self,
  const nframes_t roll_nframes,
  const nframes_t nframes);
 
NONNULL void
engine_fill_out_bufs (AudioEngine * self, const nframes_t nframes);
 
int
engine_buffer_size_enum_to_int (AudioEngineBufferSize buffer_size);
 
int
engine_samplerate_enum_to_int (AudioEngineSamplerate samplerate);
 
void
engine_set_buffer_size (AudioEngine * self, uint32_t buf_size);
 
#define engine_is_port_own(self, port) \
  (port == MONITOR_FADER->stereo_in->l || port == MONITOR_FADER->stereo_in->r \
   || port == MONITOR_FADER->stereo_out->l \
   || port == MONITOR_FADER->stereo_out->r)
 
const char *
engine_audio_backend_to_string (AudioBackend backend);
 
AudioBackend
engine_audio_backend_from_string (const char * str);
 
static inline const char *
engine_midi_backend_to_string (MidiBackend backend)
{
  return midi_backend_str[static_cast<int> (backend)];
}
 
MidiBackend
engine_midi_backend_from_string (const char * str);
 
void
engine_reset_bounce_mode (AudioEngine * self);
 
void
engine_set_default_backends (bool reset_to_dummy);
 
COLD NONNULL AudioEngine *
engine_clone (const AudioEngine * src);
 
COLD NONNULL void
engine_free (AudioEngine * self);
 
#endif