jack-ruby 0.1.0

data/lib/jack/midi_port.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Jack
+  class MidiPort < Port
+    def event_count(nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      FFI::LibJack.jack_midi_get_event_count(buf)
+    end
+
+    def read_event(index, nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      event = FFI::Structs::JackMidiEvent.new
+      result = FFI::LibJack.jack_midi_event_get(event, buf, index)
+      return nil unless result.zero?
+
+      data = event[:buffer].read_array_of_uint8(event[:size])
+      Midi::Event.new(event[:time], data)
+    end
+
+    def read_all_events(nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      count = FFI::LibJack.jack_midi_get_event_count(buf)
+      events = []
+      event_struct = FFI::Structs::JackMidiEvent.new
+
+      count.times do |i|
+        next unless FFI::LibJack.jack_midi_event_get(event_struct, buf, i).zero?
+
+        data = event_struct[:buffer].read_array_of_uint8(event_struct[:size])
+        events << Midi::Event.new(event_struct[:time], data)
+      end
+
+      events
+    end
+
+    def clear_buffer(nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      FFI::LibJack.jack_midi_clear_buffer(buf)
+    end
+
+    def reset_buffer(nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      FFI::LibJack.jack_midi_reset_buffer(buf)
+    rescue Jack::NotImplementedError
+      FFI::LibJack.jack_midi_clear_buffer(buf)
+    end
+
+    def reserve_event(time, data_size, nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      FFI::LibJack.jack_midi_event_reserve(buf, time, data_size)
+    end
+
+    def write_event(time, data, nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      data_bytes = data.is_a?(Array) ? data : data.bytes
+      ptr = ::FFI::MemoryPointer.new(:uint8, data_bytes.size)
+      ptr.write_array_of_uint8(data_bytes)
+      FFI::LibJack.jack_midi_event_write(buf, time, ptr, data_bytes.size)
+    end
+
+    def max_event_size(nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      FFI::LibJack.jack_midi_max_event_size(buf)
+    end
+
+    def lost_event_count(nframes)
+      buf = FFI::LibJack.jack_port_get_buffer(@handle, nframes)
+      FFI::LibJack.jack_midi_get_lost_event_count(buf)
+    end
+  end
+end

data/lib/jack/port.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+module Jack
+  class Port
+    attr_reader :handle, :client
+
+    def initialize(handle, client)
+      @handle = handle
+      @client = client
+    end
+
+    def name
+      FFI::LibJack.jack_port_name(@handle)
+    end
+
+    def short_name
+      FFI::LibJack.jack_port_short_name(@handle)
+    end
+
+    def full_name
+      name
+    end
+
+    def type
+      FFI::LibJack.jack_port_type(@handle)
+    end
+
+    def flags
+      FFI::LibJack.jack_port_flags(@handle)
+    end
+
+    def uuid
+      FFI::LibJack.jack_port_uuid(@handle)
+    end
+
+    def input?
+      (flags & FFI::Types::JackPortIsInput) != 0
+    end
+
+    def output?
+      (flags & FFI::Types::JackPortIsOutput) != 0
+    end
+
+    def physical?
+      (flags & FFI::Types::JackPortIsPhysical) != 0
+    end
+
+    def mine?
+      FFI::LibJack.jack_port_is_mine(@client.handle, @handle) != 0
+    end
+
+    def connections
+      ptr = FFI::LibJack.jack_port_get_connections(@handle)
+      return [] if ptr.null?
+
+      result = read_string_array(ptr)
+      FFI::LibJack.jack_free(ptr)
+      result
+    end
+
+    def connected_to?(port_name)
+      FFI::LibJack.jack_port_connected_to(@handle, port_name) != 0
+    end
+
+    def connected_count
+      FFI::LibJack.jack_port_connected(@handle)
+    end
+
+    def tie(other_port)
+      result = FFI::LibJack.jack_port_tie(@handle, other_port.handle)
+      raise Error, "Failed to tie port" unless result.zero?
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Port tying is not available on this JACK installation"
+    end
+
+    def untie
+      result = FFI::LibJack.jack_port_untie(@handle)
+      raise Error, "Failed to untie port" unless result.zero?
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Port untying is not available on this JACK installation"
+    end
+
+    def rename(new_name)
+      result = begin
+        FFI::LibJack.jack_port_rename(@client.handle, @handle, new_name)
+      rescue Jack::NotImplementedError
+        FFI::LibJack.jack_port_set_name(@handle, new_name)
+      end
+
+      raise Error, "Failed to rename port" unless result.zero?
+
+      new_name
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Port rename is not available on this JACK installation"
+    end
+
+    def aliases
+      ptr1 = ::FFI::MemoryPointer.new(:pointer, 2)
+      buf1 = ::FFI::MemoryPointer.new(:char, FFI::LibJack.jack_port_name_size)
+      buf2 = ::FFI::MemoryPointer.new(:char, FFI::LibJack.jack_port_name_size)
+      ptr1.put_pointer(0, buf1)
+      ptr1.put_pointer(::FFI::Pointer.size, buf2)
+
+      count = FFI::LibJack.jack_port_get_aliases(@handle, ptr1)
+      result = []
+      result << buf1.read_string if count >= 1
+      result << buf2.read_string if count >= 2
+      result
+    end
+
+    def set_alias(alias_name)
+      result = FFI::LibJack.jack_port_set_alias(@handle, alias_name)
+      raise Error, "Failed to set alias" unless result.zero?
+    end
+
+    def unset_alias(alias_name)
+      result = FFI::LibJack.jack_port_unset_alias(@handle, alias_name)
+      raise Error, "Failed to unset alias" unless result.zero?
+    end
+
+    def capture_latency_range
+      range = FFI::Structs::JackLatencyRange.new
+      FFI::LibJack.jack_port_get_latency_range(@handle, 0, range)
+      { min: range[:min], max: range[:max] }
+    end
+
+    def playback_latency_range
+      range = FFI::Structs::JackLatencyRange.new
+      FFI::LibJack.jack_port_get_latency_range(@handle, 1, range)
+      { min: range[:min], max: range[:max] }
+    end
+
+    def set_capture_latency_range(min:, max:)
+      range = FFI::Structs::JackLatencyRange.new
+      range[:min] = min
+      range[:max] = max
+      FFI::LibJack.jack_port_set_latency_range(@handle, 0, range)
+    end
+
+    def latency
+      FFI::LibJack.jack_port_get_latency(@handle)
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Legacy port latency is not available on this JACK installation"
+    end
+
+    def latency=(nframes)
+      FFI::LibJack.jack_port_set_latency(@handle, nframes)
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Legacy port latency is not available on this JACK installation"
+    end
+
+    def total_latency
+      FFI::LibJack.jack_port_get_total_latency(@client.handle, @handle)
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Legacy total port latency is not available on this JACK installation"
+    end
+
+    def recompute_total_latency
+      result = FFI::LibJack.jack_recompute_total_latency(@client.handle, @handle)
+      raise Error, "Failed to recompute port latency" unless result.zero?
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Legacy total port latency recomputation is not available on this JACK installation"
+    end
+
+    def set_playback_latency_range(min:, max:)
+      range = FFI::Structs::JackLatencyRange.new
+      range[:min] = min
+      range[:max] = max
+      FFI::LibJack.jack_port_set_latency_range(@handle, 1, range)
+    end
+
+    def request_monitor(enabled)
+      FFI::LibJack.jack_port_request_monitor(@handle, enabled ? 1 : 0)
+    end
+
+    def monitoring_input?
+      FFI::LibJack.jack_port_monitoring_input(@handle) != 0
+    end
+
+    def unregister
+      result = FFI::LibJack.jack_port_unregister(@client.handle, @handle)
+      raise Error, "Failed to unregister port" unless result.zero?
+    end
+
+    private
+
+    def read_string_array(ptr)
+      result = []
+      offset = 0
+      loop do
+        str_ptr = ptr.get_pointer(offset)
+        break if str_ptr.null?
+
+        result << str_ptr.read_string
+        offset += ::FFI::Pointer.size
+      end
+      result
+    end
+  end
+end

data/lib/jack/ring_buffer.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Jack
+  class RingBuffer
+    def initialize(size)
+      @handle = FFI::LibJack.jack_ringbuffer_create(size)
+      raise Error, "Failed to create ring buffer" if @handle.null?
+    end
+
+    def read(count)
+      buf = ::FFI::MemoryPointer.new(:char, count)
+      bytes_read = FFI::LibJack.jack_ringbuffer_read(@handle, buf, count)
+      buf.read_string(bytes_read)
+    end
+
+    def write(data)
+      ptr = ::FFI::MemoryPointer.from_string(data)
+      FFI::LibJack.jack_ringbuffer_write(@handle, ptr, data.bytesize)
+    end
+
+    def peek(count)
+      buf = ::FFI::MemoryPointer.new(:char, count)
+      bytes_read = FFI::LibJack.jack_ringbuffer_peek(@handle, buf, count)
+      buf.read_string(bytes_read)
+    end
+
+    def read_space
+      FFI::LibJack.jack_ringbuffer_read_space(@handle)
+    end
+
+    def write_space
+      FFI::LibJack.jack_ringbuffer_write_space(@handle)
+    end
+
+    def read_advance(count)
+      FFI::LibJack.jack_ringbuffer_read_advance(@handle, count)
+    end
+
+    def write_advance(count)
+      FFI::LibJack.jack_ringbuffer_write_advance(@handle, count)
+    end
+
+    def reset
+      FFI::LibJack.jack_ringbuffer_reset(@handle)
+    end
+
+    def reset_size(size)
+      FFI::LibJack.jack_ringbuffer_reset_size(@handle, size)
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Ring buffer resizing is not available on this JACK installation"
+    end
+
+    def mlock
+      result = FFI::LibJack.jack_ringbuffer_mlock(@handle)
+      raise Error, "Failed to mlock ring buffer" unless result.zero?
+    end
+
+    def read_vector
+      vec = ::FFI::MemoryPointer.new(FFI::Structs::RingBufferData, 2)
+      FFI::LibJack.jack_ringbuffer_get_read_vector(@handle, vec)
+      2.times.map do |i|
+        data = FFI::Structs::RingBufferData.new(vec + (i * FFI::Structs::RingBufferData.size))
+        { pointer: data[:buf], length: data[:len] }
+      end
+    end
+
+    def write_vector
+      vec = ::FFI::MemoryPointer.new(FFI::Structs::RingBufferData, 2)
+      FFI::LibJack.jack_ringbuffer_get_write_vector(@handle, vec)
+      2.times.map do |i|
+        data = FFI::Structs::RingBufferData.new(vec + (i * FFI::Structs::RingBufferData.size))
+        { pointer: data[:buf], length: data[:len] }
+      end
+    end
+
+    def free
+      return unless @handle
+
+      FFI::LibJack.jack_ringbuffer_free(@handle)
+      @handle = nil
+    end
+  end
+end

data/lib/jack/session.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Jack
+  class Session
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def on_session(&block)
+      ffi_proc = proc { |event_ptr, _arg|
+        block.call(event_ptr)
+      }
+      @client.callback_manager.register(:session, block, ffi_proc)
+      FFI::LibJack.jack_set_session_callback(@client.handle, ffi_proc, nil)
+    end
+
+    def reply(event_ptr)
+      result = FFI::LibJack.jack_session_reply(@client.handle, event_ptr)
+      raise Error, "Failed to reply to session event" unless result.zero?
+    end
+
+    def uuid
+      FFI::LibJack.jack_client_get_uuid(@client.handle)
+    end
+
+    def notify(target: nil, type: :save, path:)
+      type_val = case type
+                 when :save then 1
+                 when :save_and_quit then 2
+                 when :save_template then 3
+                 else type
+                 end
+
+      ptr = FFI::LibJack.jack_session_notify(@client.handle, target, type_val, path)
+      return [] if ptr.null?
+
+      commands = []
+      offset = 0
+      cmd_size = FFI::Structs::JackSessionCommand.size
+      loop do
+        cmd = FFI::Structs::JackSessionCommand.new(ptr + offset)
+        break if cmd[:uuid].nil?
+
+        commands << { uuid: cmd[:uuid], name: cmd[:name], command: cmd[:command], flags: cmd[:flags] }
+        offset += cmd_size
+      end
+
+      FFI::LibJack.jack_session_commands_free(ptr)
+      commands
+    end
+
+    def reserve_name(name, uuid)
+      result = FFI::LibJack.jack_reserve_client_name(@client.handle, name, uuid)
+      raise Error, "Failed to reserve client name" unless result.zero?
+    end
+
+    def client_has_callback?(name)
+      FFI::LibJack.jack_client_has_session_callback(@client.handle, name) != 0
+    end
+  end
+end

data/lib/jack/transport.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Jack
+  class Transport
+    STATES = {
+      0 => :stopped,
+      1 => :rolling,
+      2 => :looping,
+      3 => :starting
+    }.freeze
+    STATE_VALUES = STATES.invert.freeze
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def state
+      pos = FFI::Structs::JackPosition.new
+      state_val = FFI::LibJack.jack_transport_query(@client.handle, pos)
+      STATES[state_val] || :unknown
+    end
+
+    def query
+      pos = FFI::Structs::JackPosition.new
+      state_val = FFI::LibJack.jack_transport_query(@client.handle, pos)
+      {
+        state: STATES[state_val] || :unknown,
+        frame: pos[:frame],
+        frame_rate: pos[:frame_rate],
+        usecs: pos[:usecs],
+        valid: pos[:valid],
+        bar: pos[:bar],
+        beat: pos[:beat],
+        tick: pos[:tick],
+        bar_start_tick: pos[:bar_start_tick],
+        beats_per_bar: pos[:beats_per_bar],
+        beat_type: pos[:beat_type],
+        ticks_per_beat: pos[:ticks_per_beat],
+        beats_per_minute: pos[:beats_per_minute]
+      }
+    end
+
+    def legacy_info
+      info = FFI::Structs::JackTransportInfo.new
+      FFI::LibJack.jack_get_transport_info(@client.handle, info)
+
+      {
+        frame_rate: info[:frame_rate],
+        usecs: info[:usecs],
+        valid: info[:valid],
+        transport_state: STATES[info[:transport_state]] || :unknown,
+        frame: info[:frame],
+        loop_start: info[:loop_start],
+        loop_end: info[:loop_end],
+        smpte_offset: info[:smpte_offset],
+        smpte_frame_rate: info[:smpte_frame_rate],
+        bar: info[:bar],
+        beat: info[:beat],
+        tick: info[:tick],
+        bar_start_tick: info[:bar_start_tick],
+        beats_per_bar: info[:beats_per_bar],
+        beat_type: info[:beat_type],
+        ticks_per_beat: info[:ticks_per_beat],
+        beats_per_minute: info[:beats_per_minute]
+      }
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Legacy transport info is not available on this JACK installation"
+    end
+
+    def legacy_info=(values)
+      info = FFI::Structs::JackTransportInfo.new
+      values.each do |key, value|
+        next unless info.members.include?(key)
+
+        info[key] = key == :transport_state && value.is_a?(Symbol) ? STATE_VALUES.fetch(value, value) : value
+      end
+      FFI::LibJack.jack_set_transport_info(@client.handle, info)
+    rescue Jack::NotImplementedError
+      raise Jack::NotImplementedError, "Legacy transport info is not available on this JACK installation"
+    end
+
+    def frame
+      FFI::LibJack.jack_get_current_transport_frame(@client.handle)
+    end
+
+    def start
+      FFI::LibJack.jack_transport_start(@client.handle)
+    end
+
+    def stop
+      FFI::LibJack.jack_transport_stop(@client.handle)
+    end
+
+    def locate(frame_pos)
+      result = FFI::LibJack.jack_transport_locate(@client.handle, frame_pos)
+      raise Error, "Failed to locate transport" unless result.zero?
+    end
+
+    def reposition(position_hash)
+      pos = FFI::Structs::JackPosition.new
+      position_hash.each do |key, value|
+        pos[key] = value if pos.members.include?(key)
+      end
+      result = FFI::LibJack.jack_transport_reposition(@client.handle, pos)
+      raise Error, "Failed to reposition transport" unless result.zero?
+    end
+
+    def on_sync(&block)
+      ffi_proc = proc { |state, pos_ptr, _arg|
+        block.call(STATES[state] || :unknown, pos_ptr) ? 1 : 0
+      }
+      @client.callback_manager.register(:sync, block, ffi_proc)
+      FFI::LibJack.jack_set_sync_callback(@client.handle, ffi_proc, nil)
+    end
+
+    def sync_timeout=(usecs)
+      FFI::LibJack.jack_set_sync_timeout(@client.handle, usecs)
+    end
+
+    def set_timebase(conditional: false, &block)
+      ffi_proc = proc { |state, nframes, pos_ptr, new_pos, _arg|
+        block.call(STATES[state] || :unknown, nframes, pos_ptr, new_pos != 0)
+      }
+      @client.callback_manager.register(:timebase, block, ffi_proc)
+      result = FFI::LibJack.jack_set_timebase_callback(
+        @client.handle, conditional ? 1 : 0, ffi_proc, nil
+      )
+      raise Error, "Failed to set timebase callback" unless result.zero?
+    end
+
+    def release_timebase
+      result = FFI::LibJack.jack_release_timebase(@client.handle)
+      raise Error, "Failed to release timebase" unless result.zero?
+    end
+  end
+end

data/lib/jack/uuid.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Jack
+  module UUID
+    module_function
+
+    def generate_client
+      FFI::LibJack.jack_client_uuid_generate
+    end
+
+    def generate_port(port_id)
+      FFI::LibJack.jack_port_uuid_generate(port_id)
+    end
+
+    def to_index(uuid)
+      FFI::LibJack.jack_uuid_to_index(uuid)
+    end
+
+    def compare(left, right)
+      FFI::LibJack.jack_uuid_compare(left, right)
+    end
+
+    def copy(uuid)
+      pointer = ::FFI::MemoryPointer.new(:uint64)
+      FFI::LibJack.jack_uuid_copy(pointer, uuid)
+      pointer.read_uint64
+    end
+
+    def clear(uuid)
+      pointer = ::FFI::MemoryPointer.new(:uint64)
+      pointer.write_uint64(uuid)
+      FFI::LibJack.jack_uuid_clear(pointer)
+      pointer.read_uint64
+    end
+
+    def parse(value)
+      pointer = ::FFI::MemoryPointer.new(:uint64)
+      result = FFI::LibJack.jack_uuid_parse(value, pointer)
+      raise Error, "Failed to parse UUID '#{value}'" unless result.zero?
+
+      pointer.read_uint64
+    end
+
+    def unparse(uuid)
+      pointer = ::FFI::MemoryPointer.new(:char, FFI::Types::JACK_UUID_STRING_SIZE)
+      FFI::LibJack.jack_uuid_unparse(uuid, pointer)
+      pointer.read_string
+    end
+
+    def empty?(uuid)
+      FFI::LibJack.jack_uuid_empty(uuid) != 0
+    end
+  end
+end

data/lib/jack/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Jack
+  VERSION = "0.1.0"
+end

data/lib/jack.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+require_relative "jack/version"
+require_relative "jack/error"
+require_relative "jack/ffi/types"
+require_relative "jack/ffi/structs"
+require_relative "jack/ffi/lib_jack"
+require_relative "jack/callback_manager"
+require_relative "jack/port"
+require_relative "jack/audio_port"
+require_relative "jack/midi/event"
+require_relative "jack/midi_port"
+require_relative "jack/transport"
+require_relative "jack/session"
+require_relative "jack/ring_buffer"
+require_relative "jack/metadata"
+require_relative "jack/uuid"
+require_relative "jack/client"
+
+module Jack
+  # Re-export commonly used constants for convenience
+  JackPortIsInput    = FFI::Types::JackPortIsInput
+  JackPortIsOutput   = FFI::Types::JackPortIsOutput
+  JackPortIsPhysical = FFI::Types::JackPortIsPhysical
+  JackPortCanMonitor = FFI::Types::JackPortCanMonitor
+  JackPortIsTerminal = FFI::Types::JackPortIsTerminal
+
+  JACK_DEFAULT_AUDIO_TYPE = FFI::Types::JACK_DEFAULT_AUDIO_TYPE
+  JACK_DEFAULT_MIDI_TYPE  = FFI::Types::JACK_DEFAULT_MIDI_TYPE
+
+  class << self
+    def version
+      pointers = Array.new(4) { ::FFI::MemoryPointer.new(:int) }
+      FFI::LibJack.jack_get_version(*pointers)
+
+      {
+        major: pointers[0].read_int,
+        minor: pointers[1].read_int,
+        micro: pointers[2].read_int,
+        protocol: pointers[3].read_int
+      }
+    end
+
+    def version_string
+      FFI::LibJack.jack_get_version_string
+    end
+
+    def client_pid(name)
+      FFI::LibJack.jack_get_client_pid(name)
+    end
+
+    def on_error(&block)
+      @error_callback = block && proc { |message| block.call(message) }
+      FFI::LibJack.jack_set_error_function(@error_callback)
+    end
+
+    def on_info(&block)
+      @info_callback = block && proc { |message| block.call(message) }
+      FFI::LibJack.jack_set_info_function(@info_callback)
+    end
+  end
+end