midilib 2.0.2 → 3.0.1

data/lib/midilib/io/seqwriter.rb

@@ -1,153 +1,157 @@
 # Writes MIDI files.
 
-require 'midilib/event'
-require 'midilib/utils'
+require_relative '../event'
+require_relative '../utils'
 
 module MIDI
-
-module IO
-
-class SeqWriter
-
-    def initialize(seq, proc = nil) # :yields: num_tracks, index
-	@seq = seq
-	@update_block = block_given?() ? Proc.new() : proc
-    end
-
-    # Writes a MIDI format 1 file.
-    def write_to(io)
-	@io = io
-	@bytes_written = 0
-	write_header()
-	@update_block.call(nil, @seq.tracks.length, 0) if @update_block
-	@seq.tracks.each_with_index { | track, i |
-	    write_track(track)
-	    @update_block.call(track, @seq.tracks.length, i) if @update_block
-	}
-    end
-
-    def write_header
-	@io.print 'MThd'
-	write32(6)
-	write16(1)		# Ignore sequence format; write as format 1
-	write16(@seq.tracks.length)
-	write16(@seq.ppqn)
-    end
-
-    def write_track(track)
-	@io.print 'MTrk'
-	track_size_file_pos = @io.tell()
-	write32(0)		# Dummy byte count; overwritten later
-	@bytes_written = 0	# Reset after previous write
-
-	write_instrument(track.instrument)
-
-	prev_event = nil
-	prev_status = 0
-	track.events.each { | event |
-	    if !event.kind_of?(Realtime)
-		write_var_len(event.delta_time)
-	    end
-
-	    data = event.data_as_bytes()
-	    status = data[0] # status byte plus channel number, if any
-
-	    # running status byte
-	    status = possibly_munge_due_to_running_status_byte(data,
-							       prev_status)
-
-	    @bytes_written += write_bytes(data)
-
-	    prev_event = event
-	    prev_status = status
-	}
-
-	# Write track end event.
-	event = MetaEvent.new(META_TRACK_END)
-	write_var_len(0)
-	@bytes_written += write_bytes(event.data_as_bytes())
-
-	# Go back to beginning of track data and write number of bytes,
-	# then come back here to end of file.
-	@io.seek(track_size_file_pos)
-	write32(@bytes_written)
-	@io.seek(0, ::IO::SEEK_END)
+  module IO
+    class SeqWriter
+      def initialize(seq, midi_format = 1, &block) # :yields: num_tracks, index
+        @seq = seq
+        @midi_format = midi_format || 1
+        @update_block = block
+      end
+
+      # Writes a MIDI format 1 file.
+      def write_to(io)
+        if @midi_format == 0
+          # merge tracks before writing
+          merged_seq = Sequence.new
+          merged_track = Track.new(merged_seq)
+          merged_seq.tracks << merged_track
+          @seq.each do |track|
+            merged_track.merge(track.events)
+          end
+          @seq = merged_seq # replace
+        end
+
+        @io = io
+        @bytes_written = 0
+        write_header
+        @update_block.call(nil, @seq.tracks.length, 0) if @update_block
+        @seq.tracks.each_with_index do |track, i|
+          write_track(track)
+          @update_block.call(track, @seq.tracks.length, i) if @update_block
+        end
+      end
+
+      def write_header
+        @io.print 'MThd'
+        write32(6)
+        write16(@midi_format) # Ignore sequence format; write as format 1 or 0, default 1
+        write16(@seq.tracks.length)
+        write16(@seq.ppqn)
+      end
+
+      def write_track(track)
+        @io.print 'MTrk'
+        track_size_file_pos = @io.tell
+        write32(0)                # Dummy byte count; overwritten later
+        @bytes_written = 0        # Reset after previous write
+
+        write_instrument(track.instrument)
+
+        prev_status = 0
+        track.events.each do |event|
+          write_var_len(event.delta_time) unless event.is_a?(Realtime)
+
+          data = event.data_as_bytes
+          status = data[0] # status byte plus channel number, if any
+
+          # running status byte
+          status = possibly_munge_due_to_running_status_byte(data, prev_status)
+
+          @bytes_written += write_bytes(data)
+
+          prev_status = status
+        end
+
+        # Write track end event.
+        event = MetaEvent.new(META_TRACK_END)
+        write_var_len(0)
+        @bytes_written += write_bytes(event.data_as_bytes)
+
+        # Go back to beginning of track data and write number of bytes,
+        # then come back here to end of file.
+        @io.seek(track_size_file_pos)
+        write32(@bytes_written)
+        @io.seek(0, ::IO::SEEK_END)
+      end
+
+      # If we can use a running status byte, delete the status byte from
+      # the given data. Return the status to remember for next time as the
+      # running status byte for this event.
+      def possibly_munge_due_to_running_status_byte(data, prev_status)
+        status = data[0]
+        return status if status >= 0xf0 || prev_status >= 0xf0
+
+        chan = (status & 0x0f)
+        return status if chan != (prev_status & 0x0f)
+
+        status = (status & 0xf0)
+        prev_status = (prev_status & 0xf0)
+
+        # Both events are on the same channel. If the two status bytes are
+        # exactly the same, the rest is trivial. If it's note on/note off,
+        # we can combine those further.
+        if status == prev_status
+          data[0, 1] = [] # delete status byte from data
+          status + chan
+        elsif status == NOTE_OFF && data[2] == 64
+          # If we see a note off and the velocity is 64, we can store
+          # a note on with a velocity of 0. If the velocity isn't 64
+          # then storing a note on would be bad because the would be
+          # changed to 64 when reading the file back in.
+          data[2] = 0 # set vel to 0; do before possible shrinking
+          status = NOTE_ON + chan
+          if prev_status == NOTE_ON
+            data[0, 1] = [] # delete status byte
+          else
+            data[0] = status
+          end
+          status
+        else
+          # Can't compress data
+          status + chan
+        end
+      end
+
+      def write_instrument(instrument)
+        return if instrument.nil?
+
+        event = MetaEvent.new(META_INSTRUMENT, instrument)
+        write_var_len(0)
+        data = event.data_as_bytes
+        @bytes_written += write_bytes(data)
+      end
+
+      def write_var_len(val)
+        buffer = Utils.as_var_len(val)
+        @bytes_written += write_bytes(buffer)
+      end
+
+      def write16(val)
+        val = (-val | 0x8000) if val < 0
+
+        @io.putc((val >> 8) & 0xff)
+        @io.putc(val & 0xff)
+        @bytes_written += 2
+      end
+
+      def write32(val)
+        val = (-val | 0x80000000) if val < 0
+
+        @io.putc((val >> 24) & 0xff)
+        @io.putc((val >> 16) & 0xff)
+        @io.putc((val >> 8) & 0xff)
+        @io.putc(val & 0xff)
+        @bytes_written += 4
+      end
+
+      def write_bytes(bytes)
+        bytes.each { |b| @io.putc(b) }
+        bytes.length
+      end
     end
-
-    # If we can use a running status byte, delete the status byte from
-    # the given data. Return the status to remember for next time as the
-    # running status byte for this event.
-    def possibly_munge_due_to_running_status_byte(data, prev_status)
-	status = data[0]
-	return status if status >= 0xf0 || prev_status >= 0xf0
-
-	chan = (status & 0x0f)
-	return status if chan != (prev_status & 0x0f)
-
-	status = (status & 0xf0)
-	prev_status = (prev_status & 0xf0)
-
-	# Both events are on the same channel. If the two status bytes are
-	# exactly the same, the rest is trivial. If it's note on/note off,
-	# we can combine those further.
-	if status == prev_status
-	    data[0,1] = []	# delete status byte from data
-	    return status + chan
-	elsif status == NOTE_OFF && data[2] == 64
-	    # If we see a note off and the velocity is 64, we can store
-	    # a note on with a velocity of 0. If the velocity isn't 64
-	    # then storing a note on would be bad because the would be
-	    # changed to 64 when reading the file back in.
-	    data[2] = 0		# set vel to 0; do before possible shrinking
-	    status = NOTE_ON + chan
-	    if prev_status == NOTE_ON
-		data[0,1] = []	# delete status byte
-	    else
-		data[0] = status
-	    end
-	    return status
-	else
-	    # Can't compress data
-	    return status + chan
-	end
-    end
-
-    def write_instrument(instrument)
-	event = MetaEvent.new(META_INSTRUMENT, instrument)
-	write_var_len(0)
-	data = event.data_as_bytes()
-	@bytes_written += write_bytes(data)
-    end
-
-    def write_var_len(val)
-	buffer = Utils.as_var_len(val)
-	@bytes_written += write_bytes(buffer)
-    end
-
-    def write16(val)
-	val = (-val | 0x8000) if val < 0
-
-	buffer = []
-	@io.putc((val >> 8) & 0xff)
-	@io.putc(val & 0xff)
-	@bytes_written += 2
-    end
-
-    def write32(val)
-	val = (-val | 0x80000000) if val < 0
-
-	@io.putc((val >> 24) & 0xff)
-	@io.putc((val >> 16) & 0xff)
-	@io.putc((val >> 8) & 0xff)
-	@io.putc(val & 0xff)
-	@bytes_written += 4
-    end
-
-    def write_bytes(bytes)
-	bytes.each { |b| @io.putc(b) }
-	bytes.length
-    end
-end
-
-end
+  end
 end

data/lib/midilib/measure.rb

@@ -1,80 +1,78 @@
-require 'midilib/consts'
-
-module MIDI
-
-# The Measure class contains information about a measure from the sequence.
-# The measure data is based on the time signature information from the sequence
-# and is not stored in the sequence itself
-class Measure 
-  # The numerator (top digit) for the measure's time signature
-  attr_reader :numerator
-  # The denominator for the measure's time signature
-  attr_reader :denominator
-  # Start clock tick for the measure
-  attr_reader :start
-  # End clock tick for the measure (inclusive)
-  attr_reader :end
-  # The measure number (1-based)
-  attr_reader :measure_number
-  # The metronome tick for the measure
-  attr_reader :metronome_ticks
-  
-  # Constructor
-  def initialize(meas_no, start_time, duration, numer, denom, met_ticks)
-     @measure_number = meas_no
-     @start = start_time
-     @end = start_time + duration - 1
-     @numerator = numer     
-     @denominator = denom
-     @metronome_ticks = met_ticks
-  end
-  
-  # Returns a detailed string with information about the measure
-  def to_s
-    t = "#{@numerator}/#{2**@denominator}"
-    m = @metronome_ticks.to_f / 24
-    "measure #{@measure_number}  #{@start}-#{@end}  #{t}   #{m} qs metronome"
-  end
-  
-  # Returns +true+ if the event is in the measure
-  def contains_event?(e)
-     (e.time_from_start >= @start) && (e.time_from_start <= @end)
-  end
-end
-
-# A specialized container for MIDI::Measure objects, which can be use to map
-# event times to measure numbers. Please note that this object has to be remade
-# when events are deleted/added in the sequence.
-class Measures < Array  
-   # The highest event time in the sequence (at the time when the
-   # object was created)
-   attr_reader :max_time
-   
-   # The ppqd from the sequence
-   attr_reader :ppqd
-  
-   # Constructor
-   def initialize(max_time, ppqd)
-      super(0)
-      @max_time = max_time
-      @ppqd = ppqd
-   end
-   
-   # Returns the MIDI::Measure object where the event is located.
-   # Returns +nil+ if the event isn't found in the container (should
-   # never happen if the MIDI::Measures object is up to date).
-   def measure_for_event(e)
-     detect { | m | m.contains_event?(e) }
-   end
-   
-   # Returns the event's time as a formatted MBT string (Measure:Beat:Ticks)
-   # as found in MIDI sequencers.
-   def to_mbt(e)      
-      m = measure_for_event(e)      
-      b = (e.time_from_start.to_f - m.start.to_f) / @ppqd      
-      b *= 24 / m.metronome_ticks      
-      sprintf("%d:%02d:%03d", m.measure_number, b.to_i + 1, (b - b.to_i) * @ppqd)      
-   end
-end
-
-end
+require_relative 'consts'
+
+module MIDI
+  # The Measure class contains information about a measure from the sequence.
+  # The measure data is based on the time signature information from the sequence
+  # and is not stored in the sequence itself
+  class Measure
+    # The numerator (top digit) for the measure's time signature
+    attr_reader :numerator
+    # The denominator for the measure's time signature
+    attr_reader :denominator
+    # Start clock tick for the measure
+    attr_reader :start
+    # End clock tick for the measure (inclusive)
+    attr_reader :end
+    # The measure number (1-based)
+    attr_reader :measure_number
+    # The metronome tick for the measure
+    attr_reader :metronome_ticks
+
+    # Constructor
+    def initialize(meas_no, start_time, duration, numer, denom, met_ticks)
+      @measure_number = meas_no
+      @start = start_time
+      @end = start_time + duration - 1
+      @numerator = numer
+      @denominator = denom
+      @metronome_ticks = met_ticks
+    end
+
+    # Returns a detailed string with information about the measure
+    def to_s
+      t = "#{@numerator}/#{2**@denominator}"
+      m = @metronome_ticks.to_f / 24
+      "measure #{@measure_number}  #{@start}-#{@end}  #{t}   #{m} qs metronome"
+    end
+
+    # Returns +true+ if the event is in the measure
+    def contains_event?(e)
+      (e.time_from_start >= @start) && (e.time_from_start <= @end)
+    end
+  end
+
+  # A specialized container for MIDI::Measure objects, which can be use to map
+  # event times to measure numbers. Please note that this object has to be remade
+  # when events are deleted/added in the sequence.
+  class Measures < Array
+    # The highest event time in the sequence (at the time when the
+    # object was created)
+    attr_reader :max_time
+
+    # The ppqd from the sequence
+    attr_reader :ppqd
+
+    # Constructor
+    def initialize(max_time, ppqd)
+      super(0)
+      @max_time = max_time
+      @ppqd = ppqd
+    end
+
+    # Returns the MIDI::Measure object where the event is located.
+    # Returns +nil+ if the event isn't found in the container (should
+    # never happen if the MIDI::Measures object is up to date).
+    def measure_for_event(e)
+      detect { |m| m.contains_event?(e) }
+    end
+
+    # Returns the event's time as a formatted MBT string (Measure:Beat:Ticks)
+    # as found in MIDI sequencers.
+    def to_mbt(e)
+      m = measure_for_event(e)
+      b = (e.time_from_start.to_f - m.start.to_f) / @ppqd
+      b *= 24 / m.metronome_ticks
+      format('%d:%02d:%03d', m.measure_number, b.to_i + 1, (b - b.to_i) * @ppqd)
+    end
+  end
+end

data/lib/midilib/mergesort.rb

@@ -0,0 +1,39 @@
+# This code was originally taken from
+# http://github.com/adamjmurray/cosy/blob/master/lib/cosy/helper/midi_file_renderer_helper.rb
+# with permission from Adam Murray, who originally suggested this fix.
+# See http://wiki.github.com/adamjmurray/cosy/midilib-notes for details.
+
+# A stable sorting algorithm that maintains the relative order of equal
+# elements.
+#
+# This code used to be in a new subclass of Array, but that started causing
+# problems in Ruby 3.0, apparently due to the return type of the `[]`
+# operator which was the parent Array class.
+#
+# This code borrowed from 'Moser' http://codesnippets.joyent.com/posts/show/1699
+def mergesort(arr, &cmp)
+  cmp = ->(a, b) { a <=> b } if cmp.nil?
+  if arr.size <= 1
+    arr.dup
+  else
+    halves = mergesort_split(arr).map { |half| mergesort(half, &cmp) }
+    mergesort_merge(*halves, &cmp)
+  end
+end
+
+def mergesort_split(arr)
+  n = (arr.length / 2).floor - 1
+  [arr[0..n], arr[n + 1..-1]]
+end
+
+def mergesort_merge(first, second, &predicate)
+  result = []
+  until first.empty? || second.empty?
+    result << if predicate.call(first.first, second.first) <= 0
+                first.shift
+              else
+                second.shift
+              end
+  end
+  result.concat(first).concat(second)
+end