jack-ruby 0.1.0

data/lib/jack/client.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+module Jack
+  class Client
+    attr_reader :name, :handle, :sample_rate, :buffer_size, :callback_manager
+
+    def initialize(name, no_start_server: false, server_name: nil, session_id: nil)
+      options = FFI::Types::JackNullOption
+      options |= FFI::Types::JackNoStartServer if no_start_server
+      options |= FFI::Types::JackServerName if server_name
+      options |= FFI::Types::JackSessionID if session_id
+
+      status_ptr = ::FFI::MemoryPointer.new(:int)
+
+      varargs = []
+      varargs.push(:string, server_name) if server_name
+      varargs.push(:string, session_id) if session_id
+
+      @handle = FFI::LibJack.jack_client_open(name, options, status_ptr, *varargs)
+
+      status = status_ptr.read_int
+      if @handle.null?
+        raise ClientOpenFailed, status
+      end
+
+      @name = FFI::LibJack.jack_get_client_name(@handle)
+      @sample_rate = FFI::LibJack.jack_get_sample_rate(@handle)
+      @buffer_size = FFI::LibJack.jack_get_buffer_size(@handle)
+      @callback_manager = CallbackManager.new
+      @ports = []
+      @active = false
+      @closed = false
+    end
+
+    def self.open(name, **options)
+      client = new(name, **options)
+      return client unless block_given?
+
+      begin
+        yield client
+      ensure
+        client.close
+      end
+    end
+
+    def activate
+      result = FFI::LibJack.jack_activate(@handle)
+      raise Error, "Failed to activate client (code: #{result})" unless result.zero?
+
+      @active = true
+    end
+
+    def deactivate
+      result = FFI::LibJack.jack_deactivate(@handle)
+      raise Error, "Failed to deactivate client (code: #{result})" unless result.zero?
+
+      @active = false
+    end
+
+    def close
+      return if @closed
+
+      deactivate if @active
+      @callback_manager.clear
+      @ports.clear
+      FFI::LibJack.jack_client_close(@handle)
+      @closed = true
+    end
+
+    def active?
+      @active
+    end
+
+    def closed?
+      @closed
+    end
+
+    # --- Port operations ---
+
+    def register_audio_input(port_name)
+      register_port(port_name, FFI::Types::JACK_DEFAULT_AUDIO_TYPE,
+                    FFI::Types::JackPortIsInput, AudioPort)
+    end
+
+    def register_audio_output(port_name)
+      register_port(port_name, FFI::Types::JACK_DEFAULT_AUDIO_TYPE,
+                    FFI::Types::JackPortIsOutput, AudioPort)
+    end
+
+    def register_midi_input(port_name)
+      register_port(port_name, FFI::Types::JACK_DEFAULT_MIDI_TYPE,
+                    FFI::Types::JackPortIsInput, MidiPort)
+    end
+
+    def register_midi_output(port_name)
+      register_port(port_name, FFI::Types::JACK_DEFAULT_MIDI_TYPE,
+                    FFI::Types::JackPortIsOutput, MidiPort)
+    end
+
+    def unregister_port(port)
+      result = FFI::LibJack.jack_port_unregister(@handle, port.handle)
+      raise Error, "Failed to unregister port" unless result.zero?
+
+      @ports.delete(port)
+    end
+
+    def connect(source, destination)
+      result = FFI::LibJack.jack_connect(@handle, source, destination)
+      raise ConnectionFailed, "Failed to connect #{source} -> #{destination} (code: #{result})" unless result.zero?
+    end
+
+    def disconnect(source, destination)
+      result = FFI::LibJack.jack_disconnect(@handle, source, destination)
+      raise Error, "Failed to disconnect #{source} -> #{destination} (code: #{result})" unless result.zero?
+    end
+
+    # --- Port searching ---
+
+    def get_ports(pattern: nil, type: nil, flags: 0)
+      ptr = FFI::LibJack.jack_get_ports(@handle, pattern, type, flags)
+      return [] if ptr.null?
+
+      ports = []
+      offset = 0
+      loop do
+        str_ptr = ptr.get_pointer(offset)
+        break if str_ptr.null?
+
+        ports << str_ptr.read_string
+        offset += ::FFI::Pointer.size
+      end
+      FFI::LibJack.jack_free(ptr)
+      ports
+    end
+
+    def port_by_name(port_name)
+      port_handle = FFI::LibJack.jack_port_by_name(@handle, port_name)
+      return nil if port_handle.null?
+
+      port_type = FFI::LibJack.jack_port_type(port_handle)
+      klass = if port_type == FFI::Types::JACK_DEFAULT_MIDI_TYPE
+                MidiPort
+              else
+                AudioPort
+              end
+      klass.new(port_handle, self)
+    end
+
+    # --- Callback registration ---
+
+    def on_process(&block)
+      ffi_proc = proc { |nframes, _arg| block.call(nframes) }
+      @callback_manager.register(:process, block, ffi_proc)
+      FFI::LibJack.jack_set_process_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_shutdown(&block)
+      ffi_proc = proc { |code, reason, _arg| block.call(code, reason) }
+      @callback_manager.register(:shutdown, block, ffi_proc)
+      FFI::LibJack.jack_on_info_shutdown(@handle, ffi_proc, nil)
+    end
+
+    def on_sample_rate_change(&block)
+      ffi_proc = proc { |nframes, _arg| block.call(nframes); 0 }
+      @callback_manager.register(:sample_rate, block, ffi_proc)
+      FFI::LibJack.jack_set_sample_rate_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_buffer_size_change(&block)
+      ffi_proc = proc { |nframes, _arg| block.call(nframes); 0 }
+      @callback_manager.register(:buffer_size, block, ffi_proc)
+      FFI::LibJack.jack_set_buffer_size_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_xrun(&block)
+      ffi_proc = proc { |_arg| block.call; 0 }
+      @callback_manager.register(:xrun, block, ffi_proc)
+      FFI::LibJack.jack_set_xrun_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_port_connect(&block)
+      ffi_proc = proc { |a, b, connect, _arg| block.call(a, b, connect != 0) }
+      @callback_manager.register(:port_connect, block, ffi_proc)
+      FFI::LibJack.jack_set_port_connect_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_port_registration(&block)
+      ffi_proc = proc { |port_id, registered, _arg| block.call(port_id, registered != 0) }
+      @callback_manager.register(:port_registration, block, ffi_proc)
+      FFI::LibJack.jack_set_port_registration_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_port_rename(&block)
+      ffi_proc = proc { |port_id, old_name, new_name, _arg|
+        block.call(port_id, old_name, new_name)
+        0
+      }
+      @callback_manager.register(:port_rename, block, ffi_proc)
+      result = FFI::LibJack.jack_set_port_rename_callback(@handle, ffi_proc, nil)
+      raise Error, "Failed to register port rename callback (code: #{result})" unless result.zero?
+    end
+
+    def on_client_registration(&block)
+      ffi_proc = proc { |client_name, registered, _arg| block.call(client_name, registered != 0) }
+      @callback_manager.register(:client_registration, block, ffi_proc)
+      FFI::LibJack.jack_set_client_registration_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_graph_order(&block)
+      ffi_proc = proc { |_arg| block.call; 0 }
+      @callback_manager.register(:graph_order, block, ffi_proc)
+      FFI::LibJack.jack_set_graph_order_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_freewheel(&block)
+      ffi_proc = proc { |starting, _arg| block.call(starting != 0) }
+      @callback_manager.register(:freewheel, block, ffi_proc)
+      FFI::LibJack.jack_set_freewheel_callback(@handle, ffi_proc, nil)
+    end
+
+    def on_latency(&block)
+      ffi_proc = proc { |mode, _arg|
+        sym = mode.zero? ? :capture : :playback
+        block.call(sym)
+      }
+      @callback_manager.register(:latency, block, ffi_proc)
+      FFI::LibJack.jack_set_latency_callback(@handle, ffi_proc, nil)
+    end
+
+    # --- Server info ---
+
+    def realtime?
+      FFI::LibJack.jack_is_realtime(@handle) != 0
+    end
+
+    def cpu_load
+      FFI::LibJack.jack_cpu_load(@handle)
+    end
+
+    def max_cpu_load
+      FFI::LibJack.jack_max_cpu_load(@handle)
+    end
+
+    def thread_id
+      FFI::LibJack.jack_client_thread_id(@handle)
+    end
+
+    def max_delayed_usecs
+      FFI::LibJack.jack_get_max_delayed_usecs(@handle)
+    end
+
+    def xrun_delayed_usecs
+      FFI::LibJack.jack_get_xrun_delayed_usecs(@handle)
+    end
+
+    def reset_max_delayed_usecs
+      FFI::LibJack.jack_reset_max_delayed_usecs(@handle)
+    end
+
+    def real_time_priority
+      FFI::LibJack.jack_client_real_time_priority(@handle)
+    end
+
+    def max_real_time_priority
+      FFI::LibJack.jack_client_max_real_time_priority(@handle)
+    end
+
+    def acquire_real_time_scheduling(thread_id: self.thread_id, priority: real_time_priority)
+      result = FFI::LibJack.jack_acquire_real_time_scheduling(thread_id, priority)
+      raise Error, "Failed to acquire real-time scheduling (code: #{result})" unless result.zero?
+    end
+
+    def drop_real_time_scheduling(thread_id: self.thread_id)
+      result = FFI::LibJack.jack_drop_real_time_scheduling(thread_id)
+      raise Error, "Failed to drop real-time scheduling (code: #{result})" unless result.zero?
+    end
+
+    def stop_thread(thread_id)
+      result = FFI::LibJack.jack_client_stop_thread(@handle, thread_id)
+      raise Error, "Failed to stop client thread (code: #{result})" unless result.zero?
+    end
+
+    def kill_thread(thread_id)
+      result = FFI::LibJack.jack_client_kill_thread(@handle, thread_id)
+      raise Error, "Failed to kill client thread (code: #{result})" unless result.zero?
+    end
+
+    def freewheel=(enabled)
+      result = FFI::LibJack.jack_set_freewheel(@handle, enabled ? 1 : 0)
+      raise Error, "Failed to set freewheel mode" unless result.zero?
+    end
+
+    def buffer_size=(nframes)
+      result = FFI::LibJack.jack_set_buffer_size(@handle, nframes)
+      raise Error, "Failed to set buffer size" unless result.zero?
+
+      @buffer_size = nframes
+    end
+
+    # --- Transport ---
+
+    def transport
+      @transport ||= Transport.new(self)
+    end
+
+    # --- Session ---
+
+    def session
+      @session ||= Session.new(self)
+    end
+
+    # --- Metadata ---
+
+    def metadata
+      @metadata ||= Metadata.new(self)
+    end
+
+    # --- Internal clients ---
+
+    def internal_client_name(internal_client)
+      pointer = FFI::LibJack.jack_get_internal_client_name(@handle, internal_client)
+      return nil if pointer.null?
+
+      name = pointer.read_string
+      FFI::LibJack.jack_free(pointer)
+      name
+    end
+
+    def internal_client_handle(client_name)
+      status_ptr = ::FFI::MemoryPointer.new(:int)
+      internal_client = FFI::LibJack.jack_internal_client_handle(@handle, client_name, status_ptr)
+      raise Error, "Failed to get internal client handle for '#{client_name}'" if internal_client.zero?
+
+      internal_client
+    end
+
+    def load_internal_client(client_name, load_name: nil, load_init: nil)
+      options = FFI::Types::JackNullOption
+      options |= FFI::Types::JackLoadName if load_name
+      options |= FFI::Types::JackLoadInit if load_init
+
+      status_ptr = ::FFI::MemoryPointer.new(:int)
+      varargs = []
+      varargs.push(:string, load_name) if load_name
+      varargs.push(:string, load_init) if load_init
+
+      internal_client = FFI::LibJack.jack_internal_client_load(
+        @handle, client_name, options, status_ptr, *varargs
+      )
+      raise Error, "Failed to load internal client '#{client_name}'" if internal_client.zero?
+
+      internal_client
+    end
+
+    def unload_internal_client(internal_client)
+      result = FFI::LibJack.jack_internal_client_unload(@handle, internal_client)
+      raise Error, "Failed to unload internal client" unless result.zero?
+    end
+
+    private
+
+    def register_port(port_name, type, flags, klass)
+      port_handle = FFI::LibJack.jack_port_register(@handle, port_name, type, flags, 0)
+      raise PortRegistrationFailed, "Failed to register port '#{port_name}'" if port_handle.null?
+
+      port = klass.new(port_handle, self)
+      @ports << port
+      port
+    end
+  end
+end

data/lib/jack/error.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Jack
+  class Error < StandardError; end
+
+  class ServerNotRunning < Error; end
+
+  class ClientOpenFailed < Error
+    attr_reader :status
+
+    def initialize(status)
+      @status = status
+      super(decode_status(status))
+    end
+
+    private
+
+    def decode_status(status)
+      messages = []
+      messages << "Failure" if (status & FFI::Types::JackFailure) != 0
+      messages << "Invalid option" if (status & FFI::Types::JackInvalidOption) != 0
+      messages << "Name not unique" if (status & FFI::Types::JackNameNotUnique) != 0
+      messages << "Server started" if (status & FFI::Types::JackServerStarted) != 0
+      messages << "Server failed" if (status & FFI::Types::JackServerFailed) != 0
+      messages << "Server error" if (status & FFI::Types::JackServerError) != 0
+      messages << "No such client" if (status & FFI::Types::JackNoSuchClient) != 0
+      messages << "Load failure" if (status & FFI::Types::JackLoadFailure) != 0
+      messages << "Init failure" if (status & FFI::Types::JackInitFailure) != 0
+      messages << "SHM failure" if (status & FFI::Types::JackShmFailure) != 0
+      messages << "Version error" if (status & FFI::Types::JackVersionError) != 0
+      messages << "Backend error" if (status & FFI::Types::JackBackendError) != 0
+      messages << "Client zombie" if (status & FFI::Types::JackClientZombie) != 0
+      "Failed to open JACK client: #{messages.join(", ")} (status: 0x#{status.to_s(16)})"
+    end
+  end
+
+  class PortRegistrationFailed < Error; end
+  class ConnectionFailed < Error; end
+  class InvalidOperation < Error; end
+  class NotImplementedError < Error; end
+end