webmidi 0.1.0

data/lib/webmidi/smf/writer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+module Webmidi
+  module SMF
+    module Writer
+      module_function
+
+      def write(sequence, path_or_io, **options)
+        binary = to_binary(sequence, **options)
+        if path_or_io.respond_to?(:write)
+          path_or_io.write(binary)
+        else
+          File.binwrite(path_or_io, binary)
+        end
+      end
+
+      def to_binary(sequence, running_status: false)
+        validate_sequence!(sequence)
+        out = StringIO.new(String.new(encoding: Encoding::ASCII_8BIT))
+        write_header(out, sequence)
+        sequence.each { |track| write_track(out, track, running_status: running_status) }
+        out.string
+      end
+
+      def write_header(out, sequence)
+        out.write("MThd")
+        write_uint32(out, 6)
+        write_uint16(out, sequence.format)
+        write_uint16(out, sequence.size)
+        write_uint16(out, sequence.ppqn)
+      end
+
+      def write_track(out, track, running_status: false)
+        track_data = StringIO.new(String.new(encoding: Encoding::ASCII_8BIT))
+        has_end_of_track = false
+        last_status = nil
+
+        track.each do |event|
+          write_vlq(track_data, event.delta_time)
+
+          case event
+          when MetaEvent
+            track_data.putc(0xFF)
+            track_data.putc(event.type)
+            write_vlq(track_data, event.data.size)
+            event.data.each { |b| track_data.putc(b) }
+            has_end_of_track = true if event.type == MetaEvent::META_TYPES[:end_of_track]
+            last_status = nil
+          when SysExEvent
+            data = (event.data.last == 0xF7) ? event.data : [*event.data, 0xF7]
+            track_data.putc(0xF0)
+            write_vlq(track_data, data.size)
+            data.each { |b| track_data.putc(b) }
+            last_status = nil
+          when MIDIEvent
+            bytes = event.to_bytes
+            if running_status && channel_status?(bytes[0]) && last_status == bytes[0]
+              bytes[1..].each { |b| track_data.putc(b) }
+            else
+              bytes.each { |b| track_data.putc(b) }
+              last_status = channel_status?(bytes[0]) ? bytes[0] : nil
+            end
+          end
+        end
+
+        unless has_end_of_track
+          write_vlq(track_data, 0)
+          track_data.putc(0xFF)
+          track_data.putc(0x2F)
+          write_vlq(track_data, 0)
+        end
+
+        track_bytes = track_data.string
+        out.write("MTrk")
+        write_uint32(out, track_bytes.bytesize)
+        out.write(track_bytes)
+      end
+
+      def write_uint16(out, value)
+        out.putc((value >> 8) & 0xFF)
+        out.putc(value & 0xFF)
+      end
+
+      def write_uint32(out, value)
+        out.putc((value >> 24) & 0xFF)
+        out.putc((value >> 16) & 0xFF)
+        out.putc((value >> 8) & 0xFF)
+        out.putc(value & 0xFF)
+      end
+
+      def write_vlq(out, value)
+        unless value.is_a?(Integer) && value.between?(0, 0x0FFF_FFFF)
+          raise InvalidSMFError, "VLQ value must be between 0 and 0x0FFFFFFF, got #{value.inspect}"
+        end
+
+        bytes = [value & 0x7F]
+        value >>= 7
+        while value > 0
+          bytes.unshift((value & 0x7F) | 0x80)
+          value >>= 7
+        end
+        bytes.each { |b| out.putc(b) }
+      end
+
+      def validate_sequence!(sequence)
+        if sequence.format.zero? && sequence.size != 1
+          raise InvalidSMFError, "SMF format 0 must contain exactly one track"
+        end
+      end
+
+      def channel_status?(status)
+        status < 0xF0
+      end
+
+      private_class_method :write_header, :write_track, :write_uint16, :write_uint32, :write_vlq,
+        :validate_sequence!, :channel_status?
+    end
+  end
+end

data/lib/webmidi/smf.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "smf/event"
+require_relative "smf/track"
+require_relative "smf/tempo_map"
+require_relative "smf/sequence"
+require_relative "smf/reader"
+require_relative "smf/writer"
+
+module Webmidi
+  module SMF
+  end
+end

data/lib/webmidi/transport/adapter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Transport
+    module Adapter
+      REQUIRED_METHODS = %i[
+        available?
+        list_inputs
+        list_outputs
+        open_input
+        open_output
+      ].freeze
+
+      module_function
+
+      def validate!(transport)
+        missing = REQUIRED_METHODS.reject { |method| transport.respond_to?(method) }
+        return transport if missing.empty?
+
+        raise TransportNotAvailableError,
+          "Transport adapter #{transport.inspect} is missing: #{missing.join(", ")}"
+      end
+
+      def gem_name(name)
+        "webmidi-#{normalized_name(name).tr("_", "-")}"
+      end
+
+      def require_path(name)
+        "webmidi/transport/#{normalized_name(name)}"
+      end
+
+      def constant_name(name)
+        camel = normalized_name(name).split("_").map(&:capitalize).join
+        "Webmidi::Transport::#{camel}"
+      end
+
+      def constantize(path)
+        path.split("::").reduce(Object) { |namespace, const_name| namespace.const_get(const_name) }
+      end
+
+      def normalized_name(name)
+        name.to_s.tr("-", "_")
+      end
+    end
+  end
+end

data/lib/webmidi/transport/base.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Transport
+    class Base
+      def self.available?
+        false
+      end
+
+      def self.list_inputs
+        raise NotImplementedError
+      end
+
+      def self.list_outputs
+        raise NotImplementedError
+      end
+
+      def self.open_input(device_info)
+        raise NotImplementedError
+      end
+
+      def self.open_output(device_info)
+        raise NotImplementedError
+      end
+
+      def self.create_virtual_input(name)
+        raise NotImplementedError
+      end
+
+      def self.create_virtual_output(name)
+        raise NotImplementedError
+      end
+    end
+
+    module InputHandle
+      def read(timeout: nil)
+        raise NotImplementedError
+      end
+
+      def on_data(&block)
+        raise NotImplementedError
+      end
+
+      def close
+        raise NotImplementedError
+      end
+    end
+
+    module OutputHandle
+      def write(bytes)
+        raise NotImplementedError
+      end
+
+      def close
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/webmidi/transport/device_info.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Transport
+    DeviceInfo = Data.define(:id, :name, :manufacturer, :version)
+  end
+end

data/lib/webmidi/transport/null.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Webmidi
+  module Transport
+    class Null < Base
+      def self.available?
+        true
+      end
+
+      def self.list_inputs
+        []
+      end
+
+      def self.list_outputs
+        []
+      end
+
+      def self.create_virtual_input(name)
+        info = DeviceInfo.new(id: generate_id("input"), name: name, manufacturer: "Null", version: "0")
+        NullInputHandle.new(info)
+      end
+
+      def self.create_virtual_output(name)
+        info = DeviceInfo.new(id: generate_id("output"), name: name, manufacturer: "Null", version: "0")
+        NullOutputHandle.new(info)
+      end
+
+      def self.generate_id(type)
+        "null-#{type}-#{SecureRandom.uuid}"
+      end
+      private_class_method :generate_id
+
+      class NullInputHandle
+        include InputHandle
+
+        attr_reader :device_info
+
+        def initialize(device_info)
+          @device_info = device_info
+        end
+
+        def read(timeout: nil)
+          nil
+        end
+
+        def on_data(&block)
+          # no-op
+        end
+
+        def close
+          # no-op
+        end
+      end
+
+      class NullOutputHandle
+        include OutputHandle
+
+        attr_reader :device_info
+
+        def initialize(device_info)
+          @device_info = device_info
+          @sent_messages = []
+        end
+
+        def write(bytes)
+          @sent_messages << bytes
+        end
+
+        def sent_messages
+          @sent_messages.dup
+        end
+
+        def close
+          # no-op
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/transport/virtual.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Webmidi
+  module Transport
+    class Virtual < Base
+      @ports = {}
+      @mutex = Mutex.new
+
+      def self.available?
+        true
+      end
+
+      def self.list_inputs
+        @mutex.synchronize { @ports.values.select { |p| p.is_a?(VirtualInputHandle) && !p.closed? }.map(&:device_info) }
+      end
+
+      def self.list_outputs
+        @mutex.synchronize { @ports.values.select { |p| p.is_a?(VirtualOutputHandle) && !p.closed? }.map(&:device_info) }
+      end
+
+      def self.create_virtual_input(name)
+        info = DeviceInfo.new(id: generate_id, name: name, manufacturer: "Webmidi Virtual", version: "1.0")
+        handle = VirtualInputHandle.new(info, on_close: -> { unregister(info.id) })
+        @mutex.synchronize { @ports[info.id] = handle }
+        handle
+      end
+
+      def self.create_virtual_output(name)
+        info = DeviceInfo.new(id: generate_id, name: name, manufacturer: "Webmidi Virtual", version: "1.0")
+        handle = VirtualOutputHandle.new(info, on_close: -> { unregister(info.id) })
+        @mutex.synchronize { @ports[info.id] = handle }
+        handle
+      end
+
+      def self.open_input(device_info)
+        handle = find_handle(device_info.id, VirtualInputHandle)
+        return handle if handle
+
+        raise PortNotFoundError, "Virtual input not found: #{device_info.id}"
+      end
+
+      def self.open_output(device_info)
+        handle = find_handle(device_info.id, VirtualOutputHandle)
+        return handle if handle
+
+        raise PortNotFoundError, "Virtual output not found: #{device_info.id}"
+      end
+
+      def self.create_loopback(name)
+        input = create_virtual_input(name)
+        output = create_virtual_output(name)
+        output.connect(input)
+        [input, output]
+      end
+
+      def self.reset!
+        handles = @mutex.synchronize { @ports.values.dup }
+        handles.each(&:close)
+        @mutex.synchronize { @ports.clear }
+      end
+
+      def self.generate_id
+        "virtual-#{SecureRandom.uuid}"
+      end
+
+      def self.unregister(id)
+        @mutex.synchronize { @ports.delete(id) }
+      end
+
+      def self.find_handle(id, handle_class)
+        @mutex.synchronize do
+          handle = @ports[id]
+          handle if handle.is_a?(handle_class) && !handle.closed?
+        end
+      end
+      private_class_method :generate_id
+      private_class_method :find_handle
+
+      class VirtualInputHandle
+        include InputHandle
+
+        attr_reader :device_info
+
+        def initialize(device_info, on_close: nil)
+          @device_info = device_info
+          @on_close = on_close
+          @queue = Thread::Queue.new
+          @callbacks = []
+          @mutex = Mutex.new
+          @closed = false
+        end
+
+        def read(timeout: nil)
+          return nil if @closed
+
+          if timeout
+            @queue.pop(timeout: timeout)
+          else
+            begin
+              @queue.pop(true)
+            rescue
+              nil
+            end
+          end
+        end
+
+        def on_data(&block)
+          @mutex.synchronize { @callbacks << block }
+        end
+
+        def receive(bytes)
+          return if @closed
+
+          @queue.push(bytes)
+          @mutex.synchronize { @callbacks.dup }.each { |cb| cb.call(bytes) }
+        end
+
+        def close
+          return if @closed
+
+          @closed = true
+          @queue.close
+          @on_close&.call
+        end
+
+        def closed?
+          @closed
+        end
+      end
+
+      class VirtualOutputHandle
+        include OutputHandle
+
+        attr_reader :device_info
+
+        def initialize(device_info, on_close: nil)
+          @device_info = device_info
+          @on_close = on_close
+          @connected_inputs = []
+          @mutex = Mutex.new
+          @closed = false
+          @sent_messages = []
+        end
+
+        def write(bytes)
+          raise PortClosedError, "Port is closed" if @closed
+
+          connected_inputs = @mutex.synchronize do
+            @sent_messages << bytes
+            @connected_inputs.dup
+          end
+          connected_inputs.each { |input| input.receive(bytes) }
+        end
+
+        def connect(input_handle)
+          @mutex.synchronize do
+            @connected_inputs << input_handle unless @connected_inputs.include?(input_handle)
+          end
+        end
+
+        def disconnect(input_handle)
+          @mutex.synchronize { @connected_inputs.delete(input_handle) }
+        end
+
+        def sent_messages
+          @mutex.synchronize { @sent_messages.dup }
+        end
+
+        def close
+          return if @closed
+
+          @closed = true
+          @on_close&.call
+        end
+
+        def closed?
+          @closed
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/transport.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "transport/device_info"
+require_relative "transport/base"
+require_relative "transport/adapter"
+require_relative "transport/virtual"
+require_relative "transport/null"
+
+module Webmidi
+  module Transport
+    @registered_transports = []
+    @registry_mutex = Mutex.new
+
+    module_function
+
+    def register(transport)
+      Adapter.validate!(transport)
+      @registry_mutex.synchronize do
+        @registered_transports << transport unless @registered_transports.include?(transport)
+      end
+      transport
+    end
+
+    def unregister(transport)
+      @registry_mutex.synchronize { @registered_transports.delete(transport) }
+      transport
+    end
+
+    def registered
+      @registry_mutex.synchronize { @registered_transports.dup.freeze }
+    end
+
+    def load_adapter(name, require_path: Adapter.require_path(name), constant: Adapter.constant_name(name))
+      require require_path if require_path
+      register(Adapter.constantize(constant))
+    rescue LoadError => e
+      raise TransportNotAvailableError, "Could not load #{Adapter.gem_name(name)}: #{e.message}"
+    rescue NameError => e
+      raise TransportNotAvailableError, "Could not find transport adapter #{constant}: #{e.message}"
+    end
+
+    def auto_detect(transport: Webmidi.configuration.transport,
+      fallback_transport: Webmidi.configuration.fallback_transport,
+      candidates: default_candidates)
+      return resolve_transport!(transport) unless transport == :auto
+
+      detected = candidates.find { |candidate| candidate.respond_to?(:available?) && candidate.available? }
+      detected || resolve_transport!(fallback_transport)
+    end
+
+    def resolve_transport!(transport)
+      case transport
+      when :auto
+        auto_detect(transport: :auto, fallback_transport: :null)
+      when :virtual
+        available_transport!(Virtual)
+      when :null, nil
+        Null
+      else
+        unless transport.respond_to?(:available?)
+          raise TransportNotAvailableError, "Unknown transport: #{transport.inspect}"
+        end
+
+        available_transport!(transport)
+      end
+    end
+
+    def available_transport!(transport)
+      return transport unless transport.respond_to?(:available?) && !transport.available?
+
+      raise TransportNotAvailableError, "Transport is not available: #{transport}"
+    end
+
+    def default_candidates
+      registered + [Virtual]
+    end
+
+    private_class_method :resolve_transport!, :available_transport!, :default_candidates
+  end
+end

data/lib/webmidi/version.rb

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

data/lib/webmidi/virtual/loopback.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Virtual
+    class Loopback
+      attr_reader :input, :output
+
+      def self.create(name: "Loopback")
+        new(name: name)
+      end
+
+      def initialize(name:)
+        @name = name
+        input_handle, output_handle = Transport::Virtual.create_loopback(name)
+
+        @input = Webmidi::Port::Input.new(
+          id: input_handle.device_info.id,
+          name: input_handle.device_info.name,
+          manufacturer: input_handle.device_info.manufacturer,
+          version: input_handle.device_info.version,
+          transport_handle: input_handle
+        )
+        @input.open
+
+        @output = Webmidi::Port::Output.new(
+          id: output_handle.device_info.id,
+          name: output_handle.device_info.name,
+          manufacturer: output_handle.device_info.manufacturer,
+          version: output_handle.device_info.version,
+          transport_handle: output_handle
+        )
+
+        # Wire up: when data comes in from transport, dispatch to input port
+        input_handle.on_data do |bytes|
+          @input.dispatch(bytes)
+        end
+      end
+
+      def close
+        @input&.disconnect
+        @output&.disconnect
+      end
+    end
+  end
+end

data/lib/webmidi/virtual/port.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Virtual
+    class Port
+      attr_reader :input, :output
+
+      def self.create(name:, direction: :bidirectional)
+        new(name: name, direction: direction)
+      end
+
+      def initialize(name:, direction: :bidirectional)
+        @name = name
+        @direction = direction
+        transport = Transport::Virtual
+
+        case direction
+        when :bidirectional, :input
+          input_handle = transport.create_virtual_input(name)
+          @input = Webmidi::Port::Input.new(
+            id: input_handle.device_info.id,
+            name: input_handle.device_info.name,
+            manufacturer: input_handle.device_info.manufacturer,
+            version: input_handle.device_info.version,
+            transport_handle: input_handle
+          )
+        end
+
+        case direction
+        when :bidirectional, :output
+          output_handle = transport.create_virtual_output(name)
+          @output = Webmidi::Port::Output.new(
+            id: output_handle.device_info.id,
+            name: output_handle.device_info.name,
+            manufacturer: output_handle.device_info.manufacturer,
+            version: output_handle.device_info.version,
+            transport_handle: output_handle
+          )
+        end
+      end
+
+      def close
+        @input&.disconnect
+        @output&.disconnect
+      end
+    end
+  end
+end

data/lib/webmidi/virtual.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "virtual/port"
+require_relative "virtual/loopback"
+
+module Webmidi
+  module Virtual
+  end
+end