engine_jack.h

// SPDX-FileCopyrightText: © 2018-2019, 2022, 2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "zrythm-config.h"
 
#include "engine/device_io/engine.h"
 
#ifdef HAVE_JACK
 
#  include <cstdlib>
 
#  define JACK_PORT_T(exp) (static_cast<jack_port_t *> (exp))
 
namespace zrythm::engine::device_io
{
class JackDriver : public AudioEngine::AudioDriver, public AudioEngine::MidiDriver
{
public:
  enum class TransportType : basic_enum_base_type_t
  {
    TimebaseMaster,
    TransportClient,
    NoJackTransport,
  };
 
  JackDriver (AudioEngine &engine) : engine_ (engine) { }
 
  utils::Utf8String get_driver_name () const override { return u8"JACK"; }
 
  // Audio driver implementation
  void set_buffer_size (uint32_t buf_size) override
  {
    jack_set_buffer_size (client_, buf_size);
    z_debug ("called jack_set_buffer_size");
  }
  bool buffer_size_change_handled () const override
  {
    return handled_jack_buffer_size_change_;
  }
  void handle_buf_size_change (uint32_t frames) override;
  void handle_sample_rate_change (uint32_t samplerate) override;
  bool setup_audio () override;
  bool activate_audio (bool activate) override;
  void tear_down_audio () override;
  void handle_start () override;
  void handle_stop () override;
  void prepare_process_audio () override;
  bool
  sanity_check_should_return_early (nframes_t total_frames_to_process) override;
  void                         handle_position_change () override;
  std::unique_ptr<PortBackend> create_audio_port_backend () const override
  {
    return std::make_unique<JackPortBackend> (*client_);
  }
  std::vector<ExtPort>
  get_ext_audio_ports (dsp::PortFlow flow, bool hw) const override;
 
  // MIDI driver implementation
  bool setup_midi () override;
  bool activate_midi (bool activate) override { /* noop */ return true; }
  void tear_down_midi () override { /* noop */ }
  std::unique_ptr<PortBackend> create_midi_port_backend () const override
  {
    return std::make_unique<JackPortBackend> (*client_);
  }
  std::vector<ExtPort>
  get_ext_midi_ports (dsp::PortFlow flow, bool hw) const override;
 
  jack_client_t * get_client () const { return client_; }
 
private:
  void rescan_ports ();

  void reconnect_monitor (bool left);

  void set_transport_type (TransportType type);

  void fill_out_bufs (const nframes_t nframes);
 
  void process_change_request ();

  static int sample_rate_cb (uint32_t nframes, void * data);

  static int buffer_size_cb (uint32_t nframes, void * data);
  static int process_cb (uint32_t nframes, void * data);
  static int xrun_cb (void * data);
 
  static void timebase_cb (
    jack_transport_state_t state,
    jack_nframes_t         nframes,
    jack_position_t *      pos,
    int                    new_pos,
    void *                 arg);
  static void shutdown_cb (void * arg);
  static void freewheel_cb (int starting, void * arg);
  static void
  port_registration_cb (jack_port_id_t port_id, int registered, void * arg);
  static void
  port_connect_cb (jack_port_id_t a, jack_port_id_t b, int connect, void * arg);

  bool is_pipewire () const;
 
  void get_ext_ports (
    dsp::PortType         type,
    dsp::PortFlow         flow,
    bool                  hw,
    std::vector<ExtPort> &ports) const;
 
private:
  AudioEngine &engine_;

  TransportType transport_type_{};

  std::atomic_bool handled_jack_buffer_size_change_ = false;

  jack_client_t * client_ = nullptr;
};
}
#endif // HAVE_JACK