webmidi 0.1.0

data/lib/webmidi/smf/reader.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module SMF
+    module Reader
+      module_function
+
+      def read(path_or_io, **options)
+        data = if path_or_io.respond_to?(:read)
+          path_or_io.read
+        else
+          File.binread(path_or_io)
+        end
+        parse(data, **options)
+      end
+
+      def parse(binary, skip_unknown_chunks: true, stop_at_end_of_track: true)
+        binary = binary.b if binary.encoding != Encoding::ASCII_8BIT
+        stream = StringStream.new(binary)
+
+        format, num_tracks, ppqn = read_header(stream)
+        sequence = Sequence.new(format: format, ppqn: ppqn)
+
+        num_tracks.times do
+          track = read_track(stream, skip_unknown_chunks: skip_unknown_chunks,
+            stop_at_end_of_track: stop_at_end_of_track)
+          sequence.add_track(track)
+        end
+
+        sequence
+      end
+
+      def read_header(stream)
+        chunk_id = stream.read_bytes(4)
+        raise InvalidSMFError, "Invalid SMF header: expected 'MThd'" unless chunk_id == "MThd"
+
+        chunk_size = stream.read_uint32
+        raise InvalidSMFError, "Invalid header size: #{chunk_size}" unless chunk_size == 6
+
+        format = stream.read_uint16
+        num_tracks = stream.read_uint16
+        division = stream.read_uint16
+        raise InvalidSMFError, "SMF format 0 must have exactly one track" if format.zero? && num_tracks != 1
+
+        if (division & 0x8000).zero?
+          ppqn = division
+        else
+          raise UnsupportedFormatError, "SMPTE time division is not supported"
+        end
+
+        [format, num_tracks, ppqn]
+      end
+
+      def read_track(stream, skip_unknown_chunks:, stop_at_end_of_track:) # rubocop:disable Metrics/MethodLength
+        loop do
+          chunk_id = stream.read_bytes(4)
+          chunk_size = stream.read_uint32
+
+          unless chunk_id == "MTrk"
+            raise InvalidSMFError, "Invalid track header: expected 'MTrk', got '#{chunk_id}'" unless skip_unknown_chunks
+
+            stream.skip(chunk_size)
+            next
+          end
+
+          track_end = stream.position + chunk_size
+          track = Track.new
+          running_status = nil
+          absolute_time = 0
+
+          stream.with_limit(track_end) do
+            while stream.position < track_end
+              delta_time = stream.read_vlq
+              absolute_time += delta_time
+
+              status_byte = stream.peek_byte
+
+              if status_byte >= 0x80
+                stream.read_byte
+                running_status = status_byte if status_byte < 0xF0
+              else
+                status_byte = running_status
+                raise InvalidSMFError, "No running status available" unless status_byte
+              end
+
+              event = parse_event(stream, status_byte, delta_time, absolute_time)
+              track << event if event
+              if stop_at_end_of_track && end_of_track?(event)
+                stream.skip(track_end - stream.position)
+                break
+              end
+            end
+          end
+
+          return track
+        end
+      end
+
+      def parse_event(stream, status_byte, delta_time, absolute_time)
+        case status_byte
+        when 0xFF
+          parse_meta_event(stream, delta_time, absolute_time)
+        when 0xF0, 0xF7
+          parse_sysex_event(stream, delta_time, absolute_time)
+        else
+          parse_midi_event(stream, status_byte, delta_time, absolute_time)
+        end
+      end
+
+      def parse_meta_event(stream, delta_time, absolute_time)
+        type = stream.read_byte
+        length = stream.read_vlq
+        data = stream.read_raw_bytes(length)
+        MetaEvent.new(type: type, data: data, delta_time: delta_time, absolute_time: absolute_time)
+      end
+
+      def parse_sysex_event(stream, delta_time, absolute_time)
+        length = stream.read_vlq
+        data = stream.read_raw_bytes(length)
+        SysExEvent.new(data: data, delta_time: delta_time, absolute_time: absolute_time)
+      end
+
+      def parse_midi_event(stream, status_byte, delta_time, absolute_time) # rubocop:disable Metrics/MethodLength
+        high = status_byte & 0xF0
+
+        bytes = case high
+        when 0xC0, 0xD0
+          [status_byte, stream.read_byte]
+        when 0x80, 0x90, 0xA0, 0xB0, 0xE0
+          [status_byte, stream.read_byte, stream.read_byte]
+        else
+          raise InvalidSMFError, "Unknown MIDI status: #{format("0x%02X", status_byte)}"
+        end
+
+        message = Message.from_bytes(bytes, normalize_note_on_zero: false)
+        MIDIEvent.new(message: message, delta_time: delta_time, absolute_time: absolute_time)
+      end
+
+      def end_of_track?(event)
+        event.is_a?(MetaEvent) && event.type == MetaEvent::META_TYPES[:end_of_track]
+      end
+
+      private_class_method :read_header, :read_track, :parse_event,
+        :parse_meta_event, :parse_sysex_event, :parse_midi_event,
+        :end_of_track?
+
+      class StringStream
+        attr_reader :position
+
+        def initialize(data)
+          @data = data
+          @position = 0
+        end
+
+        def read_bytes(n)
+          ensure_available!(n)
+          result = @data[@position, n]
+          @position += n
+          result
+        end
+
+        def read_raw_bytes(n)
+          ensure_available!(n)
+          result = @data[@position, n].bytes
+          @position += n
+          result
+        end
+
+        def read_byte
+          ensure_available!(1)
+          byte = @data.getbyte(@position)
+          @position += 1
+          byte
+        end
+
+        def peek_byte
+          ensure_available!(1)
+          @data.getbyte(@position)
+        end
+
+        def skip(n)
+          ensure_available!(n)
+          @position += n
+        end
+
+        def with_limit(limit)
+          @limits ||= []
+          @limits.push(limit)
+          yield
+        ensure
+          @limits.pop
+        end
+
+        def read_uint16
+          ensure_available!(2)
+          val = (@data.getbyte(@position) << 8) | @data.getbyte(@position + 1)
+          @position += 2
+          val
+        end
+
+        def read_uint32
+          ensure_available!(4)
+          val = (@data.getbyte(@position) << 24) |
+            (@data.getbyte(@position + 1) << 16) |
+            (@data.getbyte(@position + 2) << 8) |
+            @data.getbyte(@position + 3)
+          @position += 4
+          val
+        end
+
+        def read_vlq
+          value = 0
+          4.times do
+            byte = read_byte
+            value = (value << 7) | (byte & 0x7F)
+            return value unless (byte & 0x80) != 0
+          end
+
+          raise InvalidSMFError, "VLQ exceeds 4 bytes"
+        end
+
+        private
+
+        def ensure_available!(n)
+          limit = [@data.bytesize, current_limit].min
+          return if @position + n <= limit
+
+          raise InvalidSMFError, "Unexpected end of data at position #{@position}, need #{n} more bytes"
+        end
+
+        def current_limit
+          @limits&.last || @data.bytesize
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/smf/sequence.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module SMF
+    class Sequence
+      include Enumerable
+
+      attr_reader :format, :ppqn
+
+      def initialize(format: 1, ppqn: 480)
+        @tracks = []
+        self.format = format
+        self.ppqn = ppqn
+      end
+
+      def tracks
+        @tracks.dup
+      end
+
+      def add_track(track)
+        if @format == 0 && @tracks.any?
+          raise InvalidSMFError, "SMF format 0 supports exactly one track"
+        end
+
+        @tracks << track
+        self
+      end
+
+      def [](index)
+        @tracks[index]
+      end
+
+      def each(&block)
+        @tracks.each(&block)
+      end
+
+      def size
+        @tracks.size
+      end
+
+      def duration
+        return 0.0 if @tracks.empty?
+
+        tempo_map = tempo_map()
+        max_ticks = @tracks.map { |t| t.events.sum(&:delta_time) }.max || 0
+        tempo_map.ticks_to_seconds(max_ticks)
+      end
+
+      def format=(format)
+        unless [0, 1].include?(format)
+          raise UnsupportedFormatError, "Only SMF format 0 and 1 are supported, got #{format.inspect}"
+        end
+        if format.zero? && defined?(@tracks) && @tracks.size > 1
+          raise InvalidSMFError, "Cannot set format 0 on a sequence with multiple tracks"
+        end
+
+        @format = format
+      end
+
+      def ppqn=(ppqn)
+        unless ppqn.is_a?(Integer) && ppqn.between?(1, 0x7FFF)
+          raise InvalidSMFError, "PPQN must be between 1 and 32767, got #{ppqn.inspect}"
+        end
+
+        @ppqn = ppqn
+      end
+
+      def tempo_map
+        TempoMap.from_sequence(self)
+      end
+
+      def to_format0
+        sequence = self.class.new(format: 0, ppqn: @ppqn)
+        merged = Track.new
+        events_with_time = @tracks.flat_map do |track|
+          absolute = 0
+          track.events.map do |event|
+            absolute += event.delta_time
+            [absolute, event]
+          end
+        end.sort_by(&:first)
+
+        previous = 0
+        events_with_time.each do |absolute, event|
+          merged << duplicate_event(event, delta_time: absolute - previous, absolute_time: absolute)
+          previous = absolute
+        end
+        sequence.add_track(merged)
+      end
+
+      def to_format1
+        sequence = self.class.new(format: 1, ppqn: @ppqn)
+        @tracks.each do |track|
+          copy = Track.new(name: track.name, channel: track.channel)
+          track.each do |event|
+            copy << duplicate_event(event, delta_time: event.delta_time, absolute_time: event.absolute_time)
+          end
+          sequence.add_track(copy)
+        end
+        sequence
+      end
+
+      def self.read(path_or_io)
+        Reader.read(path_or_io)
+      end
+
+      def self.parse(binary)
+        Reader.parse(binary)
+      end
+
+      def write(path_or_io)
+        Writer.write(self, path_or_io)
+      end
+
+      def to_binary(**options)
+        Writer.to_binary(self, **options)
+      end
+
+      private
+
+      def duplicate_event(event, delta_time:, absolute_time:)
+        case event
+        when MIDIEvent
+          MIDIEvent.new(message: event.message, delta_time: delta_time, absolute_time: absolute_time)
+        when MetaEvent
+          MetaEvent.new(type: event.type, data: event.data, delta_time: delta_time, absolute_time: absolute_time)
+        when SysExEvent
+          SysExEvent.new(data: event.data, delta_time: delta_time, absolute_time: absolute_time)
+        else
+          raise InvalidSMFError, "Unknown SMF event type: #{event.class}"
+        end
+      end
+    end
+  end
+end

data/lib/webmidi/smf/tempo_map.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module SMF
+    class TempoMap
+      DEFAULT_TEMPO = 500_000
+
+      attr_reader :entries, :ppqn
+
+      def self.from_sequence(sequence)
+        tempo_events = []
+        sequence.each do |track|
+          tick = 0
+          track.each do |event|
+            tick += event.delta_time
+            if event.is_a?(MetaEvent) && event.type == MetaEvent::META_TYPES[:tempo]
+              tempo_events << {tick: tick, tempo: event.tempo}
+            end
+          end
+        end
+        new(tempo_events, ppqn: sequence.ppqn)
+      end
+
+      def initialize(entries = [], ppqn:)
+        raise InvalidSMFError, "PPQN must be positive" unless ppqn.is_a?(Integer) && ppqn.positive?
+
+        @ppqn = ppqn
+        @entries = entries.map { |entry| normalize_entry(entry) }.sort_by { |entry| entry[:tick] }
+        @entries.unshift({tick: 0, tempo: DEFAULT_TEMPO}) if @entries.empty? || @entries.first[:tick] != 0
+        freeze_entries!
+      end
+
+      def ticks_to_seconds(ticks)
+        validate_non_negative_number!(ticks, "Ticks")
+        seconds = 0.0
+        current_tick = 0
+
+        @entries.each_with_index do |entry, index|
+          next_tick = if index + 1 < @entries.size
+            [@entries[index + 1][:tick], ticks].min
+          else
+            ticks
+          end
+          break if current_tick >= ticks
+
+          seconds += ticks_segment_to_seconds(next_tick - current_tick, entry[:tempo])
+          current_tick = next_tick
+        end
+
+        seconds
+      end
+
+      def seconds_to_ticks(seconds)
+        validate_non_negative_number!(seconds, "Seconds")
+        remaining = seconds.to_f
+        current_tick = 0
+
+        @entries.each_with_index do |entry, index|
+          next_tick = (index + 1 < @entries.size) ? @entries[index + 1][:tick] : nil
+          segment_ticks = next_tick ? next_tick - current_tick : nil
+          seconds_per_tick = entry[:tempo] / 1_000_000.0 / @ppqn
+
+          if segment_ticks.nil?
+            return current_tick + (remaining / seconds_per_tick).round
+          end
+
+          segment_seconds = segment_ticks * seconds_per_tick
+          return current_tick + (remaining / seconds_per_tick).round if remaining <= segment_seconds
+
+          remaining -= segment_seconds
+          current_tick = next_tick
+        end
+      end
+
+      def tempo_at(ticks)
+        validate_non_negative_number!(ticks, "Ticks")
+        @entries.rfind { |entry| entry[:tick] <= ticks }[:tempo]
+      end
+
+      private
+
+      def normalize_entry(entry)
+        tick = entry.fetch(:tick)
+        tempo = entry.fetch(:tempo)
+        raise InvalidSMFError, "Tempo map tick must be non-negative" unless tick.is_a?(Integer) && tick >= 0
+        raise InvalidSMFError, "Tempo must be positive" unless tempo.is_a?(Integer) && tempo.positive?
+
+        {tick: tick, tempo: tempo}
+      end
+
+      def freeze_entries!
+        @entries.each(&:freeze)
+        @entries.freeze
+      end
+
+      def ticks_segment_to_seconds(ticks, tempo)
+        (ticks.to_f / @ppqn) * (tempo / 1_000_000.0)
+      end
+
+      def validate_non_negative_number!(value, name)
+        return if value.is_a?(Numeric) && value >= 0
+
+        raise InvalidSMFError, "#{name} must be non-negative, got #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/webmidi/smf/track.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Webmidi
+  module SMF
+    class Track
+      include Enumerable
+
+      NoteSpan = Struct.new(:note, :channel, :start_time, :end_time, :duration, :note_on, :note_off, keyword_init: true)
+
+      attr_accessor :name, :channel
+
+      def initialize(name: nil, channel: nil)
+        @name = name
+        @channel = channel
+        @events = []
+      end
+
+      def events
+        @events.dup
+      end
+
+      def add_event(event)
+        @events << event
+        self
+      end
+
+      def <<(event)
+        add_event(event)
+      end
+
+      def each(&block)
+        @events.each(&block)
+      end
+
+      def size
+        @events.size
+      end
+
+      def notes
+        @events.lazy.select { |e| e.is_a?(MIDIEvent) && note_event?(e.message) }
+      end
+
+      def note_spans
+        active = Hash.new { |hash, key| hash[key] = [] }
+        spans = []
+        use_delta_time = @events.all? { |event| event.absolute_time.zero? }
+        tick = 0
+
+        @events.each do |event|
+          tick += event.delta_time
+          next unless event.is_a?(MIDIEvent) && note_event?(event.message)
+
+          time = use_delta_time ? tick : event.absolute_time
+          message = event.message
+          key = [message.channel, message.note]
+
+          if message.is_a?(Message::Channel::NoteOn) && message.velocity.positive?
+            active[key] << [event, time]
+          elsif (started = active[key].shift)
+            start_event, start_time = started
+            spans << NoteSpan.new(
+              note: message.note,
+              channel: message.channel,
+              start_time: start_time,
+              end_time: time,
+              duration: time - start_time,
+              note_on: start_event,
+              note_off: event
+            )
+          end
+        end
+
+        spans
+      end
+
+      def control_changes
+        @events.lazy.select { |e| e.is_a?(MIDIEvent) && e.message.is_a?(Message::Channel::ControlChange) }
+      end
+
+      def tempo_changes
+        @events.lazy.select { |e| e.is_a?(MetaEvent) && e.type == MetaEvent::META_TYPES[:tempo] }
+      end
+
+      def transpose(semitones)
+        new_track = Track.new(name: @name, channel: @channel)
+        @events.each do |event|
+          if event.is_a?(MIDIEvent) && note_event?(event.message)
+            msg = event.message
+            new_note = (msg.note + semitones).clamp(0, 127)
+            new_msg = msg.with(note: new_note)
+            new_track << MIDIEvent.new(message: new_msg, delta_time: event.delta_time, absolute_time: event.absolute_time)
+          else
+            new_track << event
+          end
+        end
+        new_track
+      end
+
+      def sort_by_absolute_time!
+        @events.sort_by!(&:absolute_time)
+        self
+      end
+
+      def recalculate_delta_times!
+        sort_by_absolute_time!
+        previous = 0
+        @events.each do |event|
+          event.delta_time = event.absolute_time - previous
+          previous = event.absolute_time
+        end
+        self
+      end
+
+      def quantize!(grid)
+        raise InvalidSMFError, "Quantize grid must be a positive integer, got #{grid.inspect}" unless grid.is_a?(Integer) && grid.positive?
+
+        @events.each do |event|
+          event.absolute_time = ((event.absolute_time.to_f / grid).round * grid).to_i
+        end
+        recalculate_delta_times!
+      end
+
+      private
+
+      def note_event?(message)
+        message.is_a?(Message::Channel::NoteOn) || message.is_a?(Message::Channel::NoteOff)
+      end
+    end
+  end
+end