jmtk 0.0.3.3-java

data/lib/mtk/events/event.rb

@@ -0,0 +1,119 @@
+module MTK
+
+  module Events
+
+    # An abstract musical event
+    # @abstract
+    class Event
+
+      # The type of event: :note, :control, :pressure, :bend, or :program
+      attr_reader :type
+
+      # The specific element effected by this type of event, when applicable.
+      # Depends on the event type. For example, the number of a :note type Event is the pitch,
+      # and the number of a :control type Event is the controller (CC) number.
+      # This value is nil for inapplicable event types.
+      attr_accessor :number
+
+      # The value of event.
+      # Depends on event type. For example, the value of a :note type Event is the intensity,
+      # and the value of a :control type Event is the controller (CC) value.
+      attr_accessor :value
+
+      # Duration of the Event in beats (e.g. 1.0 is a quarter note in 4/4 time signatures)
+      # @see length
+      # @see rest?
+      # @see instantaneous?
+      # @see duration_in_pulses
+      attr_reader :duration
+
+      def duration= duration
+        @duration = duration
+        @duration = ::MTK::Core::Duration[@duration || 0] unless @duration.is_a? ::MTK::Core::Duration
+        @duration
+      end
+
+      # The channel of the event, for multi-tracked events.
+      attr_accessor :channel
+
+
+      def initialize(type, options={})
+        @type = type
+        @value = options[:value]
+        @number = options[:number]
+        @duration = options.fetch(:duration, 0)
+        @duration = ::MTK::Core::Duration[@duration] unless @duration.is_a? ::MTK::Core::Duration
+        @channel = options[:channel]
+      end
+
+      def self.from_h(hash)
+        new(hash[:type], hash)
+      end
+
+      def to_h
+        hash = {:type => @type}
+        hash[:value] = @value unless @value.nil?
+        hash[:duration] = @duration unless @duration.nil?
+        hash[:number] = @number unless @number.nil?
+        hash[:channel] = @channel unless @channel.nil?
+        hash
+      end
+
+      def midi_value
+        if @value and @value.respond_to? :to_midi
+          @value.to_midi
+        else
+          value = @value
+          midi_value = (127 * (value || 0)).round
+          midi_value = 0 if midi_value < 0
+          midi_value = 127 if midi_value > 127
+          midi_value
+        end
+      end
+
+      def midi_value= value
+        @value = value/127.0
+      end
+
+      # The magnitude (absolute value) of the duration.
+      # Indicate the "real" duration for rests.
+      # @see rest?
+      def length
+        @duration.length
+      end
+
+      # By convention, any events with negative durations are a rest
+      def rest?
+        @duration.rest?
+      end
+
+      # By convention, any events with 0 duration are instantaneous
+      def instantaneous?
+        @duration.nil? or @duration == 0
+      end
+
+      # Convert duration to an integer number of MIDI pulses, given the pulses_per_beat
+      def duration_in_pulses(pulses_per_beat)
+        (length.to_f * pulses_per_beat).round
+      end
+
+      def == other
+        other.respond_to? :type and @type == other.type and
+        other.respond_to? :number and @number == other.number and
+        other.respond_to? :value and @value == other.value and
+        other.respond_to? :duration and @duration == other.duration and
+        other.respond_to? :channel and @channel == other.channel
+      end
+
+      def to_s
+        "Event(#@type" + (@number ? "[#@number]" : '') + ", #{sprintf '%.2f',@value}, #{sprintf '%.2f',@duration})"
+      end
+
+      def inspect
+        "Event(#@type" + (@number ? "[#@number]" : '') + ", #@value, #{@duration.to_f})"
+      end
+
+    end
+
+  end
+end

data/lib/mtk/events/note.rb

@@ -0,0 +1,112 @@
+module MTK
+
+  module Events
+
+    # A musical {Event} defined by a {Pitch}, intensity, and duration
+    class Note < Event
+
+      DEFAULT_DURATION  = MTK::Core::Duration[1]
+      DEFAULT_INTENSITY = MTK::Core::Intensity[0.75]
+
+      # Frequency of the note as a {Pitch}.
+      alias :pitch :number
+      alias :pitch= :number=
+
+      # Intensity of the note as a value in the range 0.0 - 1.0.
+      alias :intensity :value
+      alias :intensity= :value=
+
+      # intensity scaled to the MIDI range 0-127
+      alias :velocity :midi_value
+      alias :velocity= :midi_value=
+
+      def initialize(pitch, duration=DEFAULT_DURATION, intensity=DEFAULT_INTENSITY, channel=nil)
+        super :note, number:pitch, duration:duration, value:intensity, channel:channel
+      end
+
+      def self.from_h(hash)
+        new(hash[:pitch]||hash[:number], hash[:duration], hash[:intensity]||hash[:value], hash[:channel])
+      end
+
+      def to_h
+        super.merge({ pitch: @number, intensity: @value })
+      end
+
+      def self.from_midi(pitch, velocity, duration_in_beats, channel=0)
+        new( MTK::Lang::Pitches::PITCHES[pitch.to_i], MTK::Core::Duration[duration_in_beats], MTK::Core::Intensity[velocity/127.0], channel )
+      end
+
+      def midi_pitch
+        pitch.to_i
+      end
+
+      def transpose(interval)
+        self.pitch += interval
+        self
+      end
+
+      def invert(around_pitch)
+        self.pitch = self.pitch.invert(around_pitch)
+        self
+      end
+
+      def ==(other)
+        ( other.respond_to? :pitch and pitch == other.pitch and
+          other.respond_to? :intensity and intensity == other.intensity and
+          other.respond_to? :duration and duration == other.duration
+        ) or super
+      end
+
+      def to_s
+        "Note(#{@number}, #{@duration}, #{@value.to_percent}%)"
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} @pitch=#{@number.inspect}, @duration=#{@duration.inspect}, @intensity=#{@value.inspect}>"
+      end
+
+    end
+  end
+
+  # Construct a {Events::Note} from a list of any supported type for the arguments: pitch, intensity, duration, channel
+  def Note(*anything)
+    anything = anything.first if anything.size == 1
+    case anything
+      when MTK::Events::Note then anything
+
+      when MTK::Core::Pitch then MTK::Events::Note.new(anything)
+
+      when Array
+        pitch = nil
+        duration = nil
+        intensity = nil
+        channel = nil
+        unknowns = []
+        anything.each do |item|
+          case item
+            when MTK::Core::Pitch then pitch = item
+            when MTK::Core::Duration then duration = item
+            when MTK::Core::Intensity then intensity = item
+            else unknowns << item
+          end
+        end
+
+        pitch = MTK.Pitch(unknowns.shift) if pitch.nil? and not unknowns.empty?
+        raise "MTK::Note() couldn't find a pitch in arguments: #{anything.inspect}" if pitch.nil?
+
+        duration  = MTK.Duration(unknowns.shift)  if duration.nil?  and not unknowns.empty?
+        intensity = MTK.Intensity(unknowns.shift) if intensity.nil? and not unknowns.empty?
+        channel = unknowns.shift.to_i if channel.nil? and not unknowns.empty?
+
+        duration  ||= MTK::Events::Note::DEFAULT_DURATION
+        intensity ||= MTK::Events::Note::DEFAULT_INTENSITY
+
+        MTK::Events::Note.new( pitch, duration, intensity, channel )
+
+      else
+        raise "MTK::Note() doesn't understand #{anything.class}"
+    end
+  end
+  module_function :Note
+
+end

data/lib/mtk/events/parameter.rb

@@ -0,0 +1,54 @@
+module MTK
+
+  module Events
+
+    class Parameter < Event
+
+      def self.from_midi(status, data1, data2)
+        if status.is_a? Array
+          type,channel = *status
+        else
+          type,channel = status & 0xF0, status & 0x0F
+        end
+        type, number, value = *(
+          case type
+            when 0xA0,:poly_pressure    then [:pressure, data1, data2]
+            when 0xB0,:control_change   then [:control, data1, data2]
+            when 0xC0,:program_change   then [:program, data1]
+            when 0xD0,:channel_pressure then [:pressure, nil, data1] # no number means all notes on channel
+            when 0xE0,:pitch_bend       then [:bend, nil, (data1 + (data2 << 7))]
+            else [:unknown, data1, data2]
+          end
+        )
+        if type == :bend
+          if value == 16383
+            value = 1.0 # special case since the math doesn't quite work out to convert to -1..1 for all values
+          else
+            value = (value / 8192.0) - 1.0
+          end
+        elsif value.is_a? Numeric
+          value /= 127.0
+        end
+        new type, :number => number, :value => value, :channel => channel
+      end
+
+      def midi_value
+        if @type == :bend
+          (16383*(@value+1)/2).round
+        else
+          super
+        end
+      end
+
+      def to_s
+        "Parameter(#@type" + (@number ? "[#@number], " : ', ') + "#{sprintf '%.2f', @value || Float::NAN})"
+      end
+
+      def inspect
+        "Parameter(#@type" + (@number ? "[#@number], " : ', ') + "#@value)"
+      end
+
+    end
+
+  end
+end

data/lib/mtk/events/timeline.rb

@@ -0,0 +1,232 @@
+module MTK
+  module Events
+
+    # A collection of timed events. The core data structure used to interface with input and output.
+    #
+    # Maps sorted floating point times to lists of events.
+    #
+    # Enumerable as [time,event_list] pairs.
+    #
+    class Timeline
+      include Enumerable
+
+      def initialize()
+        @timeline = {}
+      end
+
+      class << self
+        def from_a(enumerable)
+          new.merge enumerable
+        end
+        alias from_h from_a
+      end
+
+      def merge enumerable
+        enumerable.each do |time,events|
+          add(time,events)
+        end
+        self
+      end
+
+      def clear
+        @timeline.clear
+        self
+      end
+
+      def to_h
+        @timeline
+      end
+
+      def == other
+        other = other.to_h unless other.is_a? Hash
+        @timeline == other
+      end
+
+      def [](time)
+        @timeline[time.to_f]
+      end
+
+      def []=(time, events)
+        time = time.to_f unless time.is_a? Numeric
+        case events
+          when nil?
+            @timeline.delete time.to_f
+          when Array
+            @timeline[time.to_f] = events
+          else
+            @timeline[time.to_f] = [events]
+        end
+      end
+
+      def add(time, event)
+        events = @timeline[time.to_f]
+        if events
+          if event.is_a? Array
+            events.concat event
+          else
+            events << event
+          end
+        else
+           self[time] = event
+        end
+      end
+
+      def delete(time)
+        @timeline.delete(time.to_f)
+      end
+
+      def has_time? time
+        @timeline.has_key? time.to_f
+      end
+
+      def times
+        @timeline.keys.sort
+      end
+
+      def length
+        last_time = times.last
+        events = @timeline[last_time]
+        last_time + events.map{|event| event.duration }.max
+      end
+
+      def empty?
+        @timeline.empty?
+      end
+
+      def events
+        times.map{|t| @timeline[t] }.flatten
+      end
+
+      def each
+        # this is similar to @timeline.each, but by iterating over #times, we yield the events in chronological order
+        times.each do |time|
+          yield time, @timeline[time]
+        end
+      end
+
+      # the original Enumerable#map implementation, which returns an Array
+      alias enumerable_map map
+
+      # Constructs a new Timeline by mapping each [time,event_list] pair
+      # @see #map!
+      def map &block
+        self.class.from_a enumerable_map(&block)
+      end
+
+      # Perform #map in place
+      # @see #map
+      def map! &block
+        mapped = enumerable_map(&block)
+        clear
+        merge mapped
+      end
+
+      # Map every individual event, without regard for the time at which is occurs
+      def map_events
+        mapped_timeline = Timeline.new
+        self.each do |time,events|
+          mapped_timeline[time] = events.map{|event| yield event }
+        end
+        mapped_timeline
+      end
+
+      # Map every individual event in place, without regard for the time at which is occurs
+      def map_events!
+        each do |time,events|
+          self[time] = events.map{|event| yield event }
+        end
+      end
+
+      def clone
+        self.class.from_h(to_h)
+      end
+
+      def compact!
+        @timeline.delete_if {|t,events| events.empty? }
+      end
+
+      def flatten
+        flattened = Timeline.new
+        self.each do |time,events|
+          events.each do |event|
+            if event.is_a? Timeline
+              event.flatten.each do |subtime,subevent|
+                flattened.add(time+subtime, subevent)
+              end
+            else
+              flattened.add(time,event)
+            end
+          end
+        end
+        flattened
+      end
+
+      # @return a new Timeline where all times have been quantized to multiples of the given interval
+      # @example timeline.quantize(0.5)  # quantize to eight notes (assuming the beat is a quarter note)
+      # @see quantize!
+      def quantize interval
+        map{|time,events| [self.class.quantize_time(time,interval), events] }
+      end
+
+      def quantize! interval
+        map!{|time,events| [self.class.quantize_time(time,interval), events] }
+      end
+
+      # shifts all times by the given amount
+      # @see #shift!
+      # @see #shift_to
+      def shift time_delta
+        map{|time,events| [time+time_delta, events] }
+      end
+
+      # shifts all times in place by the given amount
+      # @see #shift
+      # @see #shift_to!
+      def shift! time_delta
+        map!{|time,events| [time+time_delta, events] }
+      end
+
+      # shifts the times so that the start of the timeline is at the given time
+      # @see #shift_to!
+      # @see #shift
+      def shift_to absolute_time
+        start = times.first
+        if start
+          shift absolute_time - start
+        else
+          clone
+        end
+      end
+
+      # shifts the times in place so that the start of the timeline is at the given time
+      # @see #shift_to
+      # @see #shift!
+      def shift_to! absolute_time
+        start = times.first
+        if start
+          shift! absolute_time - start
+        end
+        self
+      end
+
+      def to_s
+        times = self.times
+        last = times.last
+        width = sprintf("%d",last).length + 3 # nicely align the '=>' against the longest number
+        times.map{|t| sprintf("%#{width}.2f",t)+" => #{@timeline[t].join ', '}" }.join "\n"
+      end
+
+      def inspect
+        @timeline.inspect
+      end
+
+      def self.quantize_time time, interval
+        upper = interval * (time.to_f/interval).ceil
+        lower = upper - interval
+        (time - lower) < (upper - time) ? lower : upper
+      end
+
+    end
+
+  end
+end