webmidi 0.1.0

data/lib/webmidi/port/map.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Port
+    class Map
+      include Enumerable
+
+      def initialize(ports = [], mutable: true)
+        @ports = {}
+        @mutable = mutable
+        @mutex = Mutex.new
+        ports.each { |port| @ports[port.id] = port }
+      end
+
+      def [](id_or_name)
+        @mutex.synchronize do
+          @ports[id_or_name] || @ports.values.find { |p| p.name == id_or_name }
+        end
+      end
+
+      def each(&block)
+        to_a.each(&block)
+      end
+
+      def size
+        @mutex.synchronize { @ports.size }
+      end
+
+      def add(port)
+        ensure_mutable!
+        @mutex.synchronize { @ports[port.id] = port }
+        self
+      end
+
+      def remove(port_or_id)
+        ensure_mutable!
+        id = port_or_id.is_a?(String) ? port_or_id : port_or_id.id
+        @mutex.synchronize { @ports.delete(id) }
+        self
+      end
+
+      def to_a
+        @mutex.synchronize { @ports.values.dup }
+      end
+
+      def to_h
+        @mutex.synchronize { @ports.dup }
+      end
+
+      def snapshot
+        self.class.new(to_a, mutable: false)
+      end
+
+      def empty?
+        @mutex.synchronize { @ports.empty? }
+      end
+
+      private
+
+      def ensure_mutable!
+        raise FrozenError, "Port::Map snapshot is read-only" unless @mutable
+      end
+    end
+  end
+end

data/lib/webmidi/port/output.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module Port
+    class Output < Base
+      def initialize(**kwargs)
+        super(**kwargs, type: :output)
+        @middleware_stack = nil
+        @scheduled_messages = []
+        @scheduler_mutex = Mutex.new
+        @scheduler_cv = ConditionVariable.new
+        @scheduler_thread = nil
+        @scheduler_shutdown = false
+      end
+
+      def send(message, timestamp: nil)
+        open unless open?
+        message = apply_middleware(message)
+        return self unless message
+
+        byte_messages = outbound_byte_messages(message)
+        byte_messages.each { |bytes| ensure_sysex_permitted!(bytes) }
+
+        if timestamp && timestamp > current_timestamp
+          schedule(byte_messages, timestamp)
+        else
+          byte_messages.each { |bytes| write_bytes(bytes) }
+        end
+        self
+      end
+
+      def clear
+        @scheduler_mutex.synchronize do
+          @scheduled_messages.clear
+          @scheduler_cv.broadcast
+        end
+        self
+      end
+
+      def note_on(note, velocity: 100, channel: 0)
+        send(Message.note_on(note, velocity: velocity, channel: channel))
+      end
+
+      def note_off(note, velocity: 0, channel: 0)
+        send(Message.note_off(note, velocity: velocity, channel: channel))
+      end
+
+      def control_change(cc, value, channel: 0)
+        send(Message.control_change(cc, value, channel: channel))
+      end
+
+      def program_change(program, channel: 0)
+        send(Message.program_change(program, channel: channel))
+      end
+
+      def pitch_bend(value, channel: 0)
+        send(Message.pitch_bend(value, channel: channel))
+      end
+
+      def all_notes_off(channel: nil)
+        if channel
+          send(Message.control_change(Message::Channel::ControlChange::ALL_NOTES_OFF, 0, channel: channel))
+        else
+          16.times { |ch| send(Message.control_change(Message::Channel::ControlChange::ALL_NOTES_OFF, 0, channel: ch)) }
+        end
+        self
+      end
+
+      def reset
+        send(Message.system_reset)
+        self
+      end
+
+      def <<(message)
+        send(message)
+      end
+
+      def use(middleware = nil, **options, &block)
+        require_relative "../middleware"
+
+        @middleware_stack ||= Middleware::Stack.new
+        if middleware.is_a?(Middleware::Stack) && options.empty? && !block
+          @middleware_stack = middleware
+        else
+          @middleware_stack.use(middleware || block, **options)
+        end
+        self
+      end
+
+      def send_all(*messages)
+        items = if messages.size == 1 && messages.first.is_a?(Array) &&
+            messages.first.all? { |message| message.is_a?(Message::Base) }
+          messages.first
+        else
+          messages
+        end
+        items.each { |msg| send(msg) }
+        self
+      end
+
+      def close
+        shutdown_scheduler
+        super
+      end
+
+      def disconnect
+        shutdown_scheduler
+        super
+      end
+
+      private
+
+      def apply_middleware(message)
+        return message unless @middleware_stack
+
+        @middleware_stack.call(message)
+      end
+
+      def outbound_byte_messages(message)
+        case message
+        when Message::Base
+          [message.to_bytes]
+        when Array
+          return Message.parse_many(message, normalize_note_on_zero: false).map(&:to_bytes) if message.all?(Integer)
+
+          message.compact.flat_map { |item| outbound_byte_messages(item) }
+        else
+          raise InvalidMessageError, "Expected Message or byte Array, got #{message.class}"
+        end
+      end
+
+      def ensure_sysex_permitted!(bytes)
+        return unless bytes[0] == 0xF0
+        return if sysex_enabled?
+
+        raise SysExNotPermittedError, "System exclusive messages require sysex: true"
+      end
+
+      def schedule(byte_messages, timestamp)
+        @scheduler_mutex.synchronize do
+          byte_messages.each { |bytes| @scheduled_messages << [timestamp, bytes] }
+          @scheduled_messages.sort_by!(&:first)
+          start_scheduler_locked
+          @scheduler_cv.broadcast
+        end
+      end
+
+      def start_scheduler_locked
+        return if @scheduler_thread&.alive?
+
+        @scheduler_shutdown = false
+        @scheduler_thread = Thread.new { scheduler_loop }
+      end
+
+      def scheduler_loop
+        loop do
+          item = next_scheduled_item
+          break unless item
+
+          write_bytes(item[1])
+        rescue PortClosedError
+          break
+        end
+      end
+
+      def next_scheduled_item
+        @scheduler_mutex.synchronize do
+          loop do
+            return nil if @scheduler_shutdown
+
+            if @scheduled_messages.empty?
+              @scheduler_cv.wait(@scheduler_mutex)
+              next
+            end
+
+            timestamp, bytes = @scheduled_messages.first
+            delay = timestamp - current_timestamp
+            if delay.positive?
+              @scheduler_cv.wait(@scheduler_mutex, delay)
+              next
+            end
+
+            @scheduled_messages.shift
+            return [timestamp, bytes]
+          end
+        end
+      end
+
+      def write_bytes(bytes)
+        @transport_handle.write(bytes)
+      end
+
+      def current_timestamp
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def shutdown_scheduler
+        thread = @scheduler_mutex.synchronize do
+          @scheduled_messages.clear
+          @scheduler_shutdown = true
+          @scheduler_cv.broadcast
+          @scheduler_thread
+        end
+        thread&.join
+      end
+    end
+  end
+end

data/lib/webmidi/port.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "port/base"
+require_relative "port/input"
+require_relative "port/output"
+require_relative "port/map"
+
+module Webmidi
+  module Port
+  end
+end

data/lib/webmidi/smf/event.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module SMF
+    class Event
+      attr_reader :delta_time, :absolute_time
+
+      def initialize(delta_time: 0, absolute_time: 0)
+        validate_time!(delta_time, "Delta time")
+        validate_time!(absolute_time, "Absolute time")
+        @delta_time = delta_time
+        @absolute_time = absolute_time
+      end
+
+      def absolute_time=(time)
+        validate_time!(time, "Absolute time")
+        @absolute_time = time
+      end
+
+      def delta_time=(time)
+        validate_time!(time, "Delta time")
+        @delta_time = time
+      end
+
+      private
+
+      def validate_time!(time, name)
+        return if time.is_a?(Integer) && time >= 0
+
+        raise InvalidSMFError, "#{name} must be a non-negative integer, got #{time.inspect}"
+      end
+    end
+
+    class MIDIEvent < Event
+      attr_reader :message
+
+      def initialize(message:, **kwargs)
+        super(**kwargs)
+        @message = message
+      end
+
+      def to_bytes
+        @message.to_bytes
+      end
+    end
+
+    class MetaEvent < Event
+      attr_reader :type, :data
+
+      META_TYPES = {
+        sequence_number: 0x00,
+        text: 0x01,
+        copyright: 0x02,
+        track_name: 0x03,
+        instrument_name: 0x04,
+        lyric: 0x05,
+        marker: 0x06,
+        cue_point: 0x07,
+        channel_prefix: 0x20,
+        end_of_track: 0x2F,
+        tempo: 0x51,
+        smpte_offset: 0x54,
+        time_signature: 0x58,
+        key_signature: 0x59,
+        sequencer_specific: 0x7F
+      }.freeze
+
+      def initialize(type:, data: [], **kwargs)
+        super(**kwargs)
+        validate_type!(type)
+        validate_data!(data)
+        @type = type
+        @data = data.frozen? ? data : data.dup.freeze
+      end
+
+      def text(encoding: Encoding::UTF_8)
+        return nil unless text_event?
+
+        @data.pack("C*").force_encoding(encoding)
+      end
+
+      def text_event?
+        @type.between?(0x01, 0x07)
+      end
+
+      def tempo
+        return nil unless @type == META_TYPES[:tempo]
+        return nil unless @data.size == 3
+
+        (@data[0] << 16) | (@data[1] << 8) | @data[2]
+      end
+
+      def bpm
+        t = tempo
+        return nil unless t
+
+        60_000_000.0 / t
+      end
+
+      def self.tempo(bpm, **kwargs)
+        raise InvalidSMFError, "Tempo BPM must be positive, got #{bpm.inspect}" unless bpm.is_a?(Numeric) && bpm.positive?
+
+        microseconds = (60_000_000.0 / bpm).round
+        data = [
+          (microseconds >> 16) & 0xFF,
+          (microseconds >> 8) & 0xFF,
+          microseconds & 0xFF
+        ]
+        new(type: META_TYPES[:tempo], data: data, **kwargs)
+      end
+
+      def self.text(value, type: :text, encoding: Encoding::UTF_8, **kwargs)
+        meta_type = type.is_a?(Symbol) ? META_TYPES.fetch(type) : type
+        new(type: meta_type, data: value.encode(encoding).bytes, **kwargs)
+      end
+
+      def self.track_name(name, encoding: Encoding::UTF_8, **kwargs)
+        text(name, type: :track_name, encoding: encoding, **kwargs)
+      end
+
+      def self.end_of_track(**kwargs)
+        new(type: META_TYPES[:end_of_track], data: [], **kwargs)
+      end
+
+      def self.time_signature(numerator: 4, denominator: 4, clocks_per_click: 24, notes_per_quarter: 8, **kwargs)
+        unless numerator.is_a?(Integer) && numerator.positive?
+          raise InvalidSMFError, "Time signature numerator must be positive, got #{numerator.inspect}"
+        end
+        unless denominator.is_a?(Integer) && denominator.positive? && (denominator & (denominator - 1)).zero?
+          raise InvalidSMFError, "Time signature denominator must be a power of two, got #{denominator.inspect}"
+        end
+        [clocks_per_click, notes_per_quarter].each do |value|
+          raise InvalidSMFError, "Time signature values must be bytes" unless value.is_a?(Integer) && value.between?(0, 255)
+        end
+
+        dd = Math.log2(denominator).to_i
+        new(type: META_TYPES[:time_signature], data: [numerator, dd, clocks_per_click, notes_per_quarter], **kwargs)
+      end
+
+      def self.key_signature(key: 0, scale: 0, **kwargs)
+        raise InvalidSMFError, "Key signature must be between -7 and 7, got #{key.inspect}" unless key.is_a?(Integer) && key.between?(-7, 7)
+
+        scale = case scale
+        when :major then 0
+        when :minor then 1
+        else scale
+        end
+        raise InvalidSMFError, "Key signature scale must be 0/:major or 1/:minor" unless [0, 1].include?(scale)
+
+        sf = (key < 0) ? (256 + key) : key
+        new(type: META_TYPES[:key_signature], data: [sf, scale], **kwargs)
+      end
+
+      private
+
+      def validate_type!(type)
+        return if type.is_a?(Integer) && type.between?(0, 127)
+
+        raise InvalidSMFError, "Meta event type must be between 0 and 127, got #{type.inspect}"
+      end
+
+      def validate_data!(data)
+        unless data.respond_to?(:each)
+          raise InvalidSMFError, "Meta event data must be enumerable, got #{data.class}"
+        end
+
+        data.each_with_index do |byte, index|
+          next if byte.is_a?(Integer) && byte.between?(0, 255)
+
+          raise InvalidSMFError, "Meta event data byte #{index} must be between 0 and 255, got #{byte.inspect}"
+        end
+      end
+    end
+
+    class SysExEvent < Event
+      attr_reader :data
+
+      def initialize(data:, **kwargs)
+        super(**kwargs)
+        bytes = normalize_data(data)
+        @data = bytes.frozen? ? bytes : bytes.dup.freeze
+      end
+
+      def to_bytes
+        (@data.last == 0xF7) ? [0xF0, *@data] : [0xF0, *@data, 0xF7]
+      end
+
+      private
+
+      def normalize_data(data)
+        unless data.respond_to?(:each)
+          raise InvalidSMFError, "SysEx event data must be enumerable, got #{data.class}"
+        end
+
+        bytes = data.to_a
+        bytes = bytes[1..] if bytes.first == 0xF0
+        bytes.each_with_index do |byte, index|
+          next if byte.is_a?(Integer) && byte.between?(0, 255)
+
+          raise InvalidSMFError, "SysEx event data byte #{index} must be between 0 and 255, got #{byte.inspect}"
+        end
+        bytes
+      end
+    end
+  end
+end