jack-ruby 0.1.0

data/lib/jack/ffi/lib_jack.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Jack
+  module FFI
+    module LibJack
+      extend ::FFI::Library
+
+      LIBRARY_NAMES = case RbConfig::CONFIG["host_os"]
+                      when /linux/
+                        ["libjack.so.0", "libjack.so"]
+                      when /darwin/
+                        ["libjack.0.dylib", "libjack.dylib",
+                         "/opt/homebrew/lib/libjack.0.dylib",
+                         "/opt/homebrew/lib/libjack.dylib",
+                         "/opt/homebrew/opt/jack/lib/libjack.0.dylib",
+                         "/opt/homebrew/opt/jack/lib/libjack.dylib",
+                         "/usr/local/opt/jack/lib/libjack.0.dylib",
+                         "/usr/local/lib/libjack.dylib",
+                         "/usr/local/opt/jack/lib/libjack.dylib",
+                         "/usr/local/lib/libjack.0.dylib"]
+                      when /mswin|mingw/
+                        ["libjack64.dll", "libjack.dll"]
+                      else
+                        ["libjack.so.0", "libjack.so"]
+                      end
+
+      def self.load_library
+        library_names = ENV["JACK_LIB_PATH"] ? [ENV["JACK_LIB_PATH"]] : LIBRARY_NAMES
+        last_error = nil
+
+        library_names.each do |library_name|
+          ffi_lib library_name
+          return
+        rescue LoadError => e
+          last_error = e
+        end
+
+        raise last_error if last_error
+      rescue LoadError => e
+        raise Jack::Error,
+              "libjack not found. Please install JACK: #{e.message}"
+      end
+
+      def self.function_available?(name)
+        ffi_libraries.any? do |lib|
+          !lib.find_function(name.to_s).nil?
+        end
+      rescue StandardError
+        false
+      end
+
+      def self.attach_optional(name, args, ret)
+        if function_available?(name)
+          attach_function name, args, ret
+          true
+        else
+          define_singleton_method(name) { |*| raise Jack::NotImplementedError, "#{name} is not available" }
+          false
+        end
+      end
+
+      include Types
+      Types.apply_to(self)
+
+      begin
+        load_library
+        @library_loaded = true
+        @load_error = nil
+      rescue Jack::Error => e
+        @library_loaded = false
+        @load_error = e
+      end
+
+      def self.library_loaded?
+        @library_loaded
+      end
+
+      def self.ensure_loaded!
+        return if @library_loaded
+
+        raise(@load_error || Jack::Error.new("libjack not found. Please install JACK or set JACK_LIB_PATH"))
+      end
+
+      def self.method_missing(name, *args, &block)
+        if name.to_s.start_with?("jack_") && !@library_loaded
+          ensure_loaded!
+        else
+          super
+        end
+      end
+
+      def self.respond_to_missing?(name, include_private = false)
+        (name.to_s.start_with?("jack_") && !@library_loaded) || super
+      end
+
+      if @library_loaded # rubocop:disable Style/IfUnlessModifier
+
+      # === Client management (jack.h) ===
+      attach_function :jack_client_open, [:string, :int, :pointer, :varargs], :jack_client_t
+      attach_optional :jack_client_new, [:string], :jack_client_t
+      attach_function :jack_client_close, [:jack_client_t], :int
+      attach_function :jack_client_name_size, [], :int
+      attach_optional :jack_get_version, [:pointer, :pointer, :pointer, :pointer], :void
+      attach_optional :jack_get_version_string, [], :string
+      attach_function :jack_get_client_name, [:jack_client_t], :string
+      attach_function :jack_get_uuid_for_client_name, [:jack_client_t, :string], :string
+      attach_function :jack_get_client_name_by_uuid, [:jack_client_t, :string], :string
+      attach_function :jack_activate, [:jack_client_t], :int
+      attach_function :jack_deactivate, [:jack_client_t], :int
+      attach_optional :jack_get_client_pid, [:string], :int
+      attach_function :jack_client_thread_id, [:jack_client_t], :ulong
+      attach_function :jack_is_realtime, [:jack_client_t], :int
+      attach_optional :jack_set_error_function, [:JackMessageCallback], :void
+      attach_optional :jack_set_info_function, [:JackMessageCallback], :void
+
+      # === Callback registration (jack.h) ===
+      attach_function :jack_set_process_callback, [:jack_client_t, :JackProcessCallback, :pointer], :int
+      attach_function :jack_set_thread_init_callback, [:jack_client_t, :JackThreadInitCallback, :pointer], :int
+      attach_function :jack_on_shutdown, [:jack_client_t, :JackShutdownCallback, :pointer], :void
+      attach_function :jack_on_info_shutdown, [:jack_client_t, :JackInfoShutdownCallback, :pointer], :void
+      attach_function :jack_set_freewheel_callback, [:jack_client_t, :JackFreewheelCallback, :pointer], :int
+      attach_function :jack_set_buffer_size_callback, [:jack_client_t, :JackBufferSizeCallback, :pointer], :int
+      attach_function :jack_set_sample_rate_callback, [:jack_client_t, :JackSampleRateCallback, :pointer], :int
+      attach_function :jack_set_client_registration_callback, [:jack_client_t, :JackClientRegistrationCallback, :pointer], :int
+      attach_function :jack_set_port_registration_callback, [:jack_client_t, :JackPortRegistrationCallback, :pointer], :int
+      attach_optional :jack_set_port_rename_callback, [:jack_client_t, :JackPortRenameCallback, :pointer], :int
+      attach_function :jack_set_port_connect_callback, [:jack_client_t, :JackPortConnectCallback, :pointer], :int
+      attach_function :jack_set_graph_order_callback, [:jack_client_t, :JackGraphOrderCallback, :pointer], :int
+      attach_function :jack_set_xrun_callback, [:jack_client_t, :JackXRunCallback, :pointer], :int
+      attach_function :jack_set_latency_callback, [:jack_client_t, :JackLatencyCallback, :pointer], :int
+
+      # === Non-Callback API (jack.h) ===
+      attach_function :jack_set_process_thread, [:jack_client_t, :JackThreadCallback, :pointer], :int
+      attach_optional :jack_thread_wait, [:jack_client_t, :int], :uint32
+      attach_function :jack_cycle_wait, [:jack_client_t], :uint32
+      attach_function :jack_cycle_signal, [:jack_client_t, :int], :void
+
+      # === Server control (jack.h) ===
+      attach_optional :jack_engine_takeover_timebase, [:jack_client_t], :int
+      attach_function :jack_set_freewheel, [:jack_client_t, :int], :int
+      attach_function :jack_set_buffer_size, [:jack_client_t, :uint32], :int
+      attach_function :jack_get_sample_rate, [:jack_client_t], :uint32
+      attach_function :jack_get_buffer_size, [:jack_client_t], :uint32
+      attach_function :jack_cpu_load, [:jack_client_t], :float
+
+      # === Port functions (jack.h) ===
+      attach_function :jack_port_register, [:jack_client_t, :string, :string, :ulong, :ulong], :jack_port_t
+      attach_function :jack_port_unregister, [:jack_client_t, :jack_port_t], :int
+      attach_function :jack_port_get_buffer, [:jack_port_t, :uint32], :pointer
+      attach_function :jack_port_uuid, [:jack_port_t], :uint64
+      attach_function :jack_port_name, [:jack_port_t], :string
+      attach_function :jack_port_short_name, [:jack_port_t], :string
+      attach_function :jack_port_flags, [:jack_port_t], :int
+      attach_function :jack_port_type, [:jack_port_t], :string
+      attach_function :jack_port_type_id, [:jack_port_t], :uint32
+      attach_function :jack_port_is_mine, [:jack_client_t, :jack_port_t], :int
+      attach_function :jack_port_connected, [:jack_port_t], :int
+      attach_function :jack_port_connected_to, [:jack_port_t, :string], :int
+      attach_function :jack_port_get_connections, [:jack_port_t], :pointer
+      attach_function :jack_port_get_all_connections, [:jack_client_t, :jack_port_t], :pointer
+      attach_optional :jack_port_tie, [:jack_port_t, :jack_port_t], :int
+      attach_optional :jack_port_untie, [:jack_port_t], :int
+      attach_optional :jack_port_rename, [:jack_client_t, :jack_port_t, :string], :int
+      attach_optional :jack_port_set_name, [:jack_port_t, :string], :int
+      attach_function :jack_port_set_alias, [:jack_port_t, :string], :int
+      attach_function :jack_port_unset_alias, [:jack_port_t, :string], :int
+      attach_function :jack_port_get_aliases, [:jack_port_t, :pointer], :int
+      attach_function :jack_port_request_monitor, [:jack_port_t, :int], :int
+      attach_function :jack_port_request_monitor_by_name, [:jack_client_t, :string, :int], :int
+      attach_function :jack_port_ensure_monitor, [:jack_port_t, :int], :int
+      attach_function :jack_port_monitoring_input, [:jack_port_t], :int
+      attach_function :jack_connect, [:jack_client_t, :string, :string], :int
+      attach_function :jack_disconnect, [:jack_client_t, :string, :string], :int
+      attach_function :jack_port_disconnect, [:jack_client_t, :jack_port_t], :int
+      attach_function :jack_port_name_size, [], :int
+      attach_function :jack_port_type_size, [], :int
+      attach_function :jack_port_type_get_buffer_size, [:jack_client_t, :string], :size_t
+
+      # === Latency (jack.h) ===
+      attach_optional :jack_port_set_latency, [:jack_port_t, :uint32], :void
+      attach_function :jack_port_set_latency_range, [:jack_port_t, :int, :pointer], :void
+      attach_optional :jack_port_get_latency, [:jack_port_t], :uint32
+      attach_function :jack_port_get_latency_range, [:jack_port_t, :int, :pointer], :void
+      attach_optional :jack_port_get_total_latency, [:jack_client_t, :jack_port_t], :uint32
+      attach_function :jack_recompute_total_latencies, [:jack_client_t], :int
+      attach_optional :jack_recompute_total_latency, [:jack_client_t, :jack_port_t], :int
+
+      # === Port searching (jack.h) ===
+      attach_function :jack_get_ports, [:jack_client_t, :string, :string, :ulong], :pointer
+      attach_function :jack_port_by_name, [:jack_client_t, :string], :jack_port_t
+      attach_function :jack_port_by_id, [:jack_client_t, :uint32], :jack_port_t
+
+      # === Time functions (jack.h) ===
+      attach_function :jack_frames_since_cycle_start, [:jack_client_t], :uint32
+      attach_function :jack_frame_time, [:jack_client_t], :uint32
+      attach_function :jack_last_frame_time, [:jack_client_t], :uint32
+      attach_function :jack_get_cycle_times, [:jack_client_t, :pointer, :pointer, :pointer, :pointer], :int
+      attach_function :jack_frames_to_time, [:jack_client_t, :uint32], :uint64
+      attach_function :jack_time_to_frames, [:jack_client_t, :uint64], :uint32
+      attach_function :jack_get_time, [], :uint64
+
+      # === Memory (jack.h) ===
+      attach_function :jack_free, [:pointer], :void
+
+      # === MIDI API (midiport.h) ===
+      attach_function :jack_midi_get_event_count, [:pointer], :uint32
+      attach_function :jack_midi_event_get, [:pointer, :pointer, :uint32], :int
+      attach_function :jack_midi_clear_buffer, [:pointer], :void
+      attach_optional :jack_midi_reset_buffer, [:pointer], :void
+      attach_function :jack_midi_max_event_size, [:pointer], :size_t
+      attach_function :jack_midi_event_reserve, [:pointer, :uint32, :size_t], :pointer
+      attach_function :jack_midi_event_write, [:pointer, :uint32, :pointer, :size_t], :int
+      attach_function :jack_midi_get_lost_event_count, [:pointer], :uint32
+
+      # === Transport API (transport.h) ===
+      attach_function :jack_release_timebase, [:jack_client_t], :int
+      attach_function :jack_set_sync_callback, [:jack_client_t, :JackSyncCallback, :pointer], :int
+      attach_function :jack_set_sync_timeout, [:jack_client_t, :uint64], :int
+      attach_function :jack_set_timebase_callback, [:jack_client_t, :int, :JackTimebaseCallback, :pointer], :int
+      attach_function :jack_transport_locate, [:jack_client_t, :uint32], :int
+      attach_function :jack_transport_query, [:jack_client_t, :pointer], :int
+      attach_optional :jack_get_transport_info, [:jack_client_t, :pointer], :void
+      attach_function :jack_get_current_transport_frame, [:jack_client_t], :uint32
+      attach_optional :jack_set_transport_info, [:jack_client_t, :pointer], :void
+      attach_function :jack_transport_reposition, [:jack_client_t, :pointer], :int
+      attach_function :jack_transport_start, [:jack_client_t], :void
+      attach_function :jack_transport_stop, [:jack_client_t], :void
+
+      # === Session API (session.h) ===
+      attach_optional :jack_set_session_callback, [:jack_client_t, :JackSessionCallback, :pointer], :int
+      attach_optional :jack_session_reply, [:jack_client_t, :pointer], :int
+      attach_optional :jack_session_event_free, [:pointer], :void
+      attach_function :jack_client_get_uuid, [:jack_client_t], :string
+      attach_optional :jack_session_notify, [:jack_client_t, :string, :int, :string], :pointer
+      attach_optional :jack_session_commands_free, [:pointer], :void
+      attach_optional :jack_reserve_client_name, [:jack_client_t, :string, :string], :int
+      attach_optional :jack_client_has_session_callback, [:jack_client_t, :string], :int
+
+      # === Internal client API (intclient.h) ===
+      attach_optional :jack_get_internal_client_name, [:jack_client_t, :jack_intclient_t], :pointer
+      attach_optional :jack_internal_client_handle, [:jack_client_t, :string, :pointer], :jack_intclient_t
+      attach_optional :jack_internal_client_load, [:jack_client_t, :string, :int, :pointer, :varargs], :jack_intclient_t
+      attach_optional :jack_internal_client_unload, [:jack_client_t, :jack_intclient_t], :int
+      attach_optional :jack_internal_client_new, [:string, :string, :string], :int
+      attach_optional :jack_internal_client_close, [:string], :void
+
+      # === RingBuffer API (ringbuffer.h) ===
+      attach_function :jack_ringbuffer_create, [:size_t], :pointer
+      attach_function :jack_ringbuffer_free, [:pointer], :void
+      attach_function :jack_ringbuffer_get_read_vector, [:pointer, :pointer], :void
+      attach_function :jack_ringbuffer_get_write_vector, [:pointer, :pointer], :void
+      attach_function :jack_ringbuffer_read, [:pointer, :pointer, :size_t], :size_t
+      attach_function :jack_ringbuffer_peek, [:pointer, :pointer, :size_t], :size_t
+      attach_function :jack_ringbuffer_read_advance, [:pointer, :size_t], :void
+      attach_function :jack_ringbuffer_read_space, [:pointer], :size_t
+      attach_function :jack_ringbuffer_mlock, [:pointer], :int
+      attach_function :jack_ringbuffer_reset, [:pointer], :void
+      attach_optional :jack_ringbuffer_reset_size, [:pointer, :size_t], :void
+      attach_function :jack_ringbuffer_write, [:pointer, :pointer, :size_t], :size_t
+      attach_function :jack_ringbuffer_write_advance, [:pointer, :size_t], :void
+      attach_function :jack_ringbuffer_write_space, [:pointer], :size_t
+
+      # === Metadata API (metadata.h) - JACK2 only ===
+      attach_optional :jack_set_property, [:jack_client_t, :uint64, :string, :string, :string], :int
+      attach_optional :jack_get_property, [:uint64, :string, :pointer, :pointer], :int
+      attach_optional :jack_free_description, [:pointer, :int], :void
+      attach_optional :jack_get_properties, [:uint64, :pointer], :int
+      attach_optional :jack_get_all_properties, [:pointer], :int
+      attach_optional :jack_remove_property, [:jack_client_t, :uint64, :string], :int
+      attach_optional :jack_remove_properties, [:jack_client_t, :uint64], :int
+      attach_optional :jack_remove_all_properties, [:jack_client_t], :int
+      attach_optional :jack_set_property_change_callback, [:jack_client_t, :JackPropertyChangeCallback, :pointer], :int
+
+      # === Statistics API (statistics.h) ===
+      attach_optional :jack_get_max_delayed_usecs, [:jack_client_t], :float
+      attach_optional :jack_get_xrun_delayed_usecs, [:jack_client_t], :float
+      attach_optional :jack_reset_max_delayed_usecs, [:jack_client_t], :void
+      attach_optional :jack_max_cpu_load, [:jack_client_t], :float
+
+      # === Thread API (thread.h) ===
+      attach_optional :jack_client_real_time_priority, [:jack_client_t], :int
+      attach_optional :jack_client_max_real_time_priority, [:jack_client_t], :int
+      attach_optional :jack_acquire_real_time_scheduling, [:ulong, :int], :int
+      attach_optional :jack_drop_real_time_scheduling, [:ulong], :int
+      attach_optional :jack_client_create_thread, [:jack_client_t, :pointer, :int, :int, :JackThreadCallback, :pointer], :int
+      attach_optional :jack_client_stop_thread, [:jack_client_t, :ulong], :int
+      attach_optional :jack_client_kill_thread, [:jack_client_t, :ulong], :int
+      attach_optional :jack_set_thread_creator, [:pointer], :void
+
+      # === UUID API (uuid.h) ===
+      attach_function :jack_client_uuid_generate, [], :jack_uuid_t
+      attach_function :jack_port_uuid_generate, [:uint32], :jack_uuid_t
+      attach_function :jack_uuid_to_index, [:jack_uuid_t], :uint32
+      attach_function :jack_uuid_compare, [:jack_uuid_t, :jack_uuid_t], :int
+      attach_function :jack_uuid_copy, [:pointer, :jack_uuid_t], :void
+      attach_function :jack_uuid_clear, [:pointer], :void
+      attach_function :jack_uuid_parse, [:string, :pointer], :int
+      attach_function :jack_uuid_unparse, [:jack_uuid_t, :pointer], :void
+      attach_function :jack_uuid_empty, [:jack_uuid_t], :int
+
+      end # if @library_loaded
+    end
+  end
+end

data/lib/jack/ffi/structs.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Jack
+  module FFI
+    module Structs
+      class JackLatencyRange < ::FFI::Struct
+        layout :min, :uint32,
+               :max, :uint32
+      end
+
+      class JackPosition < ::FFI::Struct
+        layout :unique_1,          :uint64,
+               :usecs,             :uint64,
+               :frame_rate,        :uint32,
+               :frame,             :uint32,
+               :valid,             :int,
+               :bar,               :int32,
+               :beat,              :int32,
+               :tick,              :int32,
+               :bar_start_tick,    :double,
+               :beats_per_bar,     :float,
+               :beat_type,         :float,
+               :ticks_per_beat,    :double,
+               :beats_per_minute,  :double,
+               :frame_time,        :double,
+               :next_time,         :double,
+               :bbt_offset,        :uint32,
+               :audio_frames_per_video_frame, :float,
+               :video_offset,      :uint32,
+               :tick_double,       :double,
+               :padding,           [:int32, 5],
+               :unique_2,          :uint64
+      end
+
+      class JackTransportInfo < ::FFI::Struct
+        layout :frame_rate,        :uint32,
+               :usecs,             :uint64,
+               :valid,             :int,
+               :transport_state,   :int,
+               :frame,             :uint32,
+               :loop_start,        :uint32,
+               :loop_end,          :uint32,
+               :smpte_offset,      :long,
+               :smpte_frame_rate,  :float,
+               :bar,               :int,
+               :beat,              :int,
+               :tick,              :int,
+               :bar_start_tick,    :double,
+               :beats_per_bar,     :float,
+               :beat_type,         :float,
+               :ticks_per_beat,    :double,
+               :beats_per_minute,  :double
+      end
+
+      class JackMidiEvent < ::FFI::Struct
+        layout :time,   :uint32,
+               :size,   :size_t,
+               :buffer, :pointer
+      end
+
+      class JackSessionCommand < ::FFI::Struct
+        layout :uuid,    :string,
+               :name,    :string,
+               :command, :string,
+               :flags,   :int
+      end
+
+      class RingBufferData < ::FFI::Struct
+        layout :buf, :pointer,
+               :len, :size_t
+      end
+    end
+  end
+end

data/lib/jack/ffi/types.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Jack
+  module FFI
+    module Types
+      TYPEDEFS = {
+        jack_nframes_t: :uint32,
+        jack_time_t: :uint64,
+        jack_uuid_t: :uint64,
+        jack_client_t: :pointer,
+        jack_port_t: :pointer,
+        jack_intclient_t: :uint64,
+        jack_midi_data_t: :uchar,
+        jack_default_audio_sample_t: :float
+      }.freeze
+
+      LATENCY_CALLBACK_MODE = [
+        :JackCaptureLatency, 0,
+        :JackPlaybackLatency, 1
+      ].freeze
+
+      TRANSPORT_STATE = [
+        :JackTransportStopped, 0,
+        :JackTransportRolling, 1,
+        :JackTransportLooping, 2,
+        :JackTransportStarting, 3
+      ].freeze
+
+      SESSION_EVENT_TYPE = [
+        :JackSessionSave, 1,
+        :JackSessionSaveAndQuit, 2,
+        :JackSessionSaveTemplate, 3
+      ].freeze
+
+      CALLBACKS = {
+        JackProcessCallback: [[:jack_nframes_t, :pointer], :int],
+        JackShutdownCallback: [[:pointer], :void],
+        JackInfoShutdownCallback: [[:int, :string, :pointer], :void],
+        JackSampleRateCallback: [[:jack_nframes_t, :pointer], :int],
+        JackBufferSizeCallback: [[:jack_nframes_t, :pointer], :int],
+        JackXRunCallback: [[:pointer], :int],
+        JackPortRegistrationCallback: [[:uint32, :int, :pointer], :void],
+        JackClientRegistrationCallback: [[:string, :int, :pointer], :void],
+        JackPortConnectCallback: [[:uint32, :uint32, :int, :pointer], :void],
+        JackPortRenameCallback: [[:uint32, :string, :string, :pointer], :int],
+        JackFreewheelCallback: [[:int, :pointer], :void],
+        JackGraphOrderCallback: [[:pointer], :int],
+        JackThreadInitCallback: [[:pointer], :void],
+        JackLatencyCallback: [[:jack_latency_callback_mode_t, :pointer], :void],
+        JackThreadCallback: [[:pointer], :pointer],
+        JackSyncCallback: [[:jack_transport_state_t, :pointer, :pointer], :int],
+        JackTimebaseCallback: [[:jack_transport_state_t, :jack_nframes_t, :pointer, :int, :pointer], :void],
+        JackSessionCallback: [[:pointer, :pointer], :void],
+        JackPropertyChangeCallback: [[:jack_uuid_t, :string, :int, :pointer], :void],
+        JackMessageCallback: [[:string], :void]
+      }.freeze
+
+      def self.apply_to(target)
+        TYPEDEFS.each do |name, native_type|
+          target.typedef(native_type, name)
+        end
+
+        target.enum(:jack_latency_callback_mode_t, LATENCY_CALLBACK_MODE)
+        target.enum(:jack_transport_state_t, TRANSPORT_STATE)
+        target.enum(:jack_session_event_type_t, SESSION_EVENT_TYPE)
+
+        CALLBACKS.each do |name, (params, return_type)|
+          target.callback(name, params, return_type)
+        end
+      end
+
+      JACK_UUID_SIZE = 36
+      JACK_UUID_STRING_SIZE = JACK_UUID_SIZE + 1
+
+      # jack_options_t (bit flags)
+      JackNullOption    = 0x00
+      JackNoStartServer = 0x01
+      JackUseExactName  = 0x02
+      JackServerName    = 0x04
+      JackLoadName      = 0x08
+      JackLoadInit      = 0x10
+      JackSessionID     = 0x20
+
+      # jack_status_t (bit flags)
+      JackFailure       = 0x01
+      JackInvalidOption = 0x02
+      JackNameNotUnique = 0x04
+      JackServerStarted = 0x08
+      JackServerFailed  = 0x10
+      JackServerError   = 0x20
+      JackNoSuchClient  = 0x40
+      JackLoadFailure   = 0x80
+      JackInitFailure   = 0x100
+      JackShmFailure    = 0x200
+      JackVersionError  = 0x400
+      JackBackendError  = 0x800
+      JackClientZombie  = 0x1000
+
+      # JackPortFlags
+      JackPortIsInput    = 0x1
+      JackPortIsOutput   = 0x2
+      JackPortIsPhysical = 0x4
+      JackPortCanMonitor = 0x8
+      JackPortIsTerminal = 0x10
+
+      # jack_position_bits_t
+      JackPositionBBT       = 0x10
+      JackPositionTimecode  = 0x20
+      JackBBTFrameOffset    = 0x40
+      JackAudioVideoRatio   = 0x80
+      JackVideoFrameOffset  = 0x100
+      JackTickDouble        = 0x200
+
+      # jack_session_flags_t
+      JackSessionSaveError    = 0x01
+      JackSessionNeedTerminal = 0x02
+
+      # Port type constants
+      JACK_DEFAULT_AUDIO_TYPE = "32 bit float mono audio"
+      JACK_DEFAULT_MIDI_TYPE  = "8 bit raw midi"
+    end
+  end
+end

data/lib/jack/metadata.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Jack
+  class Metadata
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def set_property(subject, key, value, type = "")
+      result = FFI::LibJack.jack_set_property(@client.handle, subject, key, value, type)
+      raise Error, "Failed to set property" unless result.zero?
+    end
+
+    def get_property(subject, key)
+      value_ptr = ::FFI::MemoryPointer.new(:pointer)
+      type_ptr = ::FFI::MemoryPointer.new(:pointer)
+      result = FFI::LibJack.jack_get_property(subject, key, value_ptr, type_ptr)
+      return nil unless result.zero?
+
+      value = value_ptr.read_pointer.read_string
+      type = type_ptr.read_pointer.read_string
+      { value: value, type: type }
+    end
+
+    def remove_property(subject, key)
+      result = FFI::LibJack.jack_remove_property(@client.handle, subject, key)
+      raise Error, "Failed to remove property" unless result.zero?
+    end
+
+    def remove_properties(subject)
+      result = FFI::LibJack.jack_remove_properties(@client.handle, subject)
+      raise Error, "Failed to remove properties" unless result.zero?
+    end
+
+    def remove_all_properties
+      result = FFI::LibJack.jack_remove_all_properties(@client.handle)
+      raise Error, "Failed to remove all properties" unless result.zero?
+    end
+
+    def on_property_change(&block)
+      ffi_proc = proc { |subject, key, change, _arg|
+        block.call(subject, key, change)
+      }
+      @client.callback_manager.register(:property_change, block, ffi_proc)
+      FFI::LibJack.jack_set_property_change_callback(@client.handle, ffi_proc, nil)
+    end
+  end
+end

data/lib/jack/midi/event.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Jack
+  module Midi
+    class Event
+      attr_reader :time, :data
+
+      def initialize(time, data)
+        @time = time
+        @data = data.is_a?(Array) ? data : data.bytes
+      end
+
+      def status
+        @data[0]
+      end
+
+      def channel
+        return nil if sysex?
+
+        status & 0x0F
+      end
+
+      def note_on?
+        (status & 0xF0) == 0x90 && velocity > 0
+      end
+
+      def note_off?
+        (status & 0xF0) == 0x80 || ((status & 0xF0) == 0x90 && velocity.zero?)
+      end
+
+      def control_change?
+        (status & 0xF0) == 0xB0
+      end
+
+      def program_change?
+        (status & 0xF0) == 0xC0
+      end
+
+      def pitch_bend?
+        (status & 0xF0) == 0xE0
+      end
+
+      def aftertouch?
+        (status & 0xF0) == 0xA0
+      end
+
+      def channel_pressure?
+        (status & 0xF0) == 0xD0
+      end
+
+      def sysex?
+        status == 0xF0
+      end
+
+      def note
+        @data[1]
+      end
+
+      def velocity
+        @data[2] || 0
+      end
+
+      def controller
+        @data[1]
+      end
+
+      def cc_value
+        @data[2]
+      end
+
+      def pitch_bend_value
+        return nil unless pitch_bend?
+
+        ((@data[2] << 7) | @data[1]) - 8192
+      end
+
+      def to_bytes
+        @data.dup
+      end
+    end
+  end
+end