stretto 0.6.1

data/lib/stretto/music_elements/rest.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), 'music_element')
+
+module Stretto
+  module MusicElements
+
+    # Represents a rest.
+    #
+    # Is represented by an "R", followed by a duration modifier (see {Duration})
+    class Rest < MusicElement
+
+      include Duration
+
+      attr_reader :original_duration
+
+      def initialize(string_or_options, pattern = nil)
+        token = case string_or_options
+          when String then Stretto::Parser.parse_rest!(string_or_options)
+          else string_or_options
+        end
+        super(token[:text_value], pattern)
+        build_duration_from_token(token[:duration])
+      end
+
+    end
+  end
+end

data/lib/stretto/music_elements/tempo.rb

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), 'music_element')
+
+module Stretto
+  module MusicElements
+
+    # Tempo represents the bpm of the song.
+    #
+    # It is indicated by a +T+ followed by the value of the tempo.
+    # There are some predefined variables that define the most common tempos
+    # (see {Variables::TEMPO_VARIABLES}), and the default is _allegro_, that is,
+    # a tempo of +T120+ bpm
+    class Tempo < MusicElement
+
+      def initialize(string_or_options, pattern = nil)
+        token = case string_or_options
+          when String then Stretto::Parser.parse_tempo!(string_or_options)
+          else string_or_options
+        end
+        super(token[:text_value], pattern)
+        @original_value = token[:value]
+      end
+
+      def value=(value)
+         @value = value
+      end
+
+      def bpm
+        value
+      end
+
+      def value
+        @value || @original_value.to_i(@pattern)
+      end
+
+      def substitute_variables!
+        self.value = value
+      end
+
+    end
+
+  end
+end

data/lib/stretto/music_elements/timing.rb

@@ -0,0 +1,33 @@
+require File.join(File.dirname(__FILE__), 'music_element')
+
+module Stretto
+  module MusicElements
+
+    # Timing information places the elements at the specified position in time,
+    #
+    # This information is mostly used when reading a MIDI file or using it live,
+    # to synchronize with playback. The quantity is expressed in miliseconds.
+    class Timing < MusicElement
+
+      def initialize(string_or_options, pattern = nil)
+        token = case string_or_options
+          when String then Stretto::Parser.parse_timing!(string_or_options)
+          else string_or_options
+        end
+        super(token[:text_value], pattern)
+        @original_value = token[:value]
+      end
+
+      def value
+        @value || @original_value.to_i(@pattern)
+      end
+
+      # private
+        def substitute_variables!
+          @value = self.value
+        end
+
+    end
+
+  end
+end

data/lib/stretto/music_elements/variable.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'music_element')
+
+
+module Stretto
+  module MusicElements
+
+    # Holds a value, identified by a name, that can be used in some elements in the pattern.
+    #
+    # The syntax for setting a value is $_name_=_vaue_
+    #
+    # For example, in a pattern
+    #
+    #     $SOME_VARIABLE=80 [SOME_VARIABLE]
+    #
+    # the note will have a picth of 80, as defined by the variable _SOME_VARIABLE_
+    #
+    # Value can be either a numeric value or another variable. Note that predefined variables are
+    # not constants; they can be overriden at any time, and the elements after the new definition
+    # will take its most recent value.
+    #
+    # @see Value
+    class Variable < MusicElement
+
+      attr_reader :name, :value
+
+      def initialize(string_or_options, pattern = nil)
+        token = case string_or_options
+          when String then Stretto::Parser.parse_variable!(string_or_options)
+          else string_or_options
+        end
+        super(token[:text_value], pattern)
+        @value = token[:value]
+        @name  = token[:name]
+      end
+
+      # @return (see Value#to_i)
+      def to_i
+        @value.to_i(@pattern)
+      end
+
+      # @return (see Value#to_f)
+      def to_f
+        @value.to_f(@pattern)
+      end
+
+    end
+
+  end
+end

data/lib/stretto/music_elements/voice.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'layer')
+
+module Stretto
+
+  # Represent a _channel_ or _track_, according to the MIDI
+  # specification. Each voice has an individual key signature,
+  # instrument, and for some values, different controller variables
+  #
+  # The MIDI specification allows a pattern to have up to 16
+  # channels, being the channel 9 the percussion 1.
+  class Voice < Array
+
+    DEFAULT_LAYER_INDEX = 0
+
+    attr_reader :layers
+    attr_reader :index
+
+    def initialize(index, *args)
+      @layers = {}
+      @index = index
+      super(*args)
+    end
+
+    # Method intended to keep consistency between array-like structures
+    # @return [Array(MusicElement)] Its elements as an array
+    def elements
+      to_a
+    end
+
+    # Appends an element to the voice, creating an additional layer
+    # if necessary.
+    def <<(element)
+      if element.kind_of?(Stretto::MusicElements::LayerChange)
+        @current_layer = (@layers[element.index] ||= Layer.new)
+      else
+        @layers[DEFAULT_LAYER_INDEX] = @current_layer = Layer.new unless @current_layer
+        @current_layer << element
+      end
+      super(element)
+    end
+
+    # Accesor for the {Layer layer} in the specified +index+
+    def layer(index)
+      @layers[index]
+    end
+
+  end
+
+end

data/lib/stretto/music_elements/voice_change.rb

@@ -0,0 +1,39 @@
+require File.join(File.dirname(__FILE__), 'music_element')
+
+module Stretto
+  module MusicElements
+
+    class VoiceChange < MusicElement
+
+      MAX_VOICES = 15
+
+      attr_reader :index
+
+      def initialize(string_or_options, pattern = nil)
+        token = case string_or_options
+          when String then Stretto::Parser.parse_voice_change!(string_or_options)
+          else string_or_options
+        end
+        super(token[:text_value], pattern)
+        @original_value = token[:value]
+      end
+
+      def index
+        @index || @original_value.to_i(pattern)
+      end
+
+      def index=(index)
+        if index < 0 or index > MAX_VOICES
+          raise Exceptions::ValueOutOfBoundsException.new("Voice value should be in range 0..#{MAX_VOICES}")
+        end
+        @index = index
+      end
+
+      def substitute_variables!
+        self.index = index
+      end
+
+    end
+
+  end
+end

data/lib/stretto/parsers/exceptions.rb

@@ -0,0 +1,11 @@
+module Stretto
+  module Exceptions
+    class InvalidValueException       < StandardError; end
+    class ValueOutOfBoundsException   < StandardError; end
+    class NoteOutOfBoundsException    < StandardError; end
+    class ChordInversionsException    < StandardError; end
+    class VariableNotDefinedException < StandardError; end
+    class VariableContextException    < StandardError; end
+    class ParseError                  < StandardError; end
+  end
+end

data/lib/stretto/parsers/parser.rb

@@ -0,0 +1,89 @@
+require File.dirname(__FILE__) + '/exceptions'
+
+Treetop.load File.join(File.dirname(__FILE__), "../grammar/stretto_grammar")
+
+module Stretto
+  class Parser
+
+    attr_reader :parser, :parsed_elements
+
+    def initialize(music_string)
+      @music_string = music_string
+      @parser       = StrettoGrammarParser.new
+    end
+
+    def to_stretto(pattern = nil)
+      parsed_string.to_stretto(pattern)
+    end
+
+    def valid?
+      not parsed_string.nil?
+    end
+
+    def error_on
+      @last_error_on
+    end
+
+    private
+
+      def parsed_string
+        parsed_string = @parser.parse(@music_string)
+        if parsed_string
+          @last_error_on = nil
+        else
+          @last_error_on = @parser.max_terminal_failure_index
+        end
+        parsed_string
+      end
+
+    class << self
+
+      private
+        def parse_music_element!(klass, music_string, expected_element)
+          klass.new.parse(music_string) ||
+              raise(Exceptions::ParseError.new("Invalid #{expected_element}: #{music_string}"))
+        end
+
+      public
+
+      elements = {
+        :channel_pressure     => ChannelPressureGrammarParser,
+        :chord                => ChordGrammarParser,
+        :controller_change    => ControllerChangeGrammarParser,
+        :harmony              => HarmonyGrammarParser,
+        :harmonic_chord       => HarmonicChordGrammarParser,
+        :instrument           => InstrumentGrammarParser,
+        :key_signature        => KeySignatureGrammarParser,
+        :layer_change         => LayerChangeGrammarParser,
+        :measure              => MeasureGrammarParser,
+        :note                 => NoteGrammarParser,
+        :pitch_bend           => PitchBendGrammarParser,
+        :polyphonic_pressure  => PolyphonicPressureGrammarParser,
+        :rest                 => RestGrammarParser,
+        :timing               => TimingGrammarParser,
+        :tempo                => TempoGrammarParser,
+        :variable             => VariableGrammarParser,
+        :voice_change         => VoiceChangeGrammarParser
+      }
+      elements.each do |element, klass|
+        define_method "parse_#{element}!" do |music_element|
+          parse_music_element!(klass, music_element, element.to_s.gsub('_', ' '))
+        end
+      end
+
+      def parse_element!(element, klass)
+        send(:"parse_#{elementize(klass)}!", element)
+      end
+
+      def elementize(str)
+        str.to_s.split('::').last.
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+
+    end
+
+  end
+end

data/lib/stretto/renderers/midiator/player.rb

@@ -0,0 +1,200 @@
+module Stretto
+
+  # Stretto default Player uses MIDIator for MIDI output.
+  class Player
+    attr_reader :midi
+    attr_accessor :bpm
+
+    #TODO: can time signature be set?
+    DEFAULT_BEAT = 4 # each beat is a quarter note
+
+    # @param options [Hash] An array of options to initialize the MIDI driver
+    #   Pass `:driver => :autodetect` to let MIDIator select the most appropiate driver based on the OS
+    # @example
+    #   Stretto::Player.new(:driver => :dls_synth)
+    def initialize(options = {:driver => :autodetect})
+      @midi = ::MIDIator::Interface.new
+      if options[:driver] == :autodetect
+        @midi.autodetect_driver
+      else
+        # TODO: exceptions for unhandled drivers
+        @midi.use options[:driver]
+      end
+    end
+
+    # Plays the passed music string (or a File object containing a music string)
+    #
+    # @param music_string_or_file [String, File] The stretto music string
+    # @example
+    #   Stretto::Player.new.play("C D E F G A B C6")
+    #
+    def play(music_string_or_file)
+      @pattern = Stretto::Pattern.new(music_string_or_file)
+
+      set_default_tempo
+      layer_threads = []
+      @pattern.voices.each_value do |voice|
+        voice.layers.each_value do |layer|
+          layer_threads << Thread.new(layer) do |l|
+            l.each { |e| play_element(e, voice.index) }
+          end
+
+        end
+      end
+      layer_threads.each { |t| t.join}
+    end
+
+   private
+
+    def play_element(element, channel = 0)
+      case element
+        when Stretto::MusicElements::Note
+          play_note(element, channel)
+        when Stretto::MusicElements::Rest
+          play_rest(element)
+        when Stretto::MusicElements::Chord
+          play_chord(element, channel)
+        when Stretto::MusicElements::Melody
+          play_melody(element, channel)
+        when Stretto::MusicElements::Measure
+          play_measure(element)
+        when Stretto::MusicElements::Variable
+          play_variable(element)
+        when Stretto::MusicElements::VoiceChange
+          play_voice_change(element)
+        when Stretto::MusicElements::LayerChange
+          play_layer_change(element)
+        when Stretto::MusicElements::KeySignature
+          play_key_signature(element)
+        when Stretto::MusicElements::Tempo
+          play_tempo(element)
+        when Stretto::MusicElements::Harmony
+          play_harmony(element, channel)
+        when Stretto::MusicElements::ChannelPressure
+          play_channel_pressure(element, channel)
+        when Stretto::MusicElements::PolyphonicPressure
+          play_polyphonic_pressure(element, channel)
+        when Stretto::MusicElements::Instrument
+          play_instrument(element, channel)
+        when Stretto::MusicElements::PitchBend
+          play_pitch_bend(element, channel)
+        when Stretto::MusicElements::ControllerChange
+          play_controller_change(element, channel)
+        when Stretto::MusicElements::Timing
+          play_timing(element, channel)
+        else
+          raise "element of class #{element.class} not yet handled by player"
+      end
+    end
+
+    def play_note(note, channel)
+      unless note.end_of_tie?
+        duration = 60.0 / bpm * note.tied_duration * DEFAULT_BEAT
+        @midi.note_on(note.pitch, channel, note.attack)
+        @midi.rest(duration)
+        @midi.note_off(note.pitch, channel, note.decay)
+      end
+    end
+
+    def play_rest(rest)
+      unless rest.end_of_tie?
+        duration = 60.0 / bpm * rest.tied_duration * DEFAULT_BEAT
+        @midi.rest(duration)
+      end
+    end
+
+    def play_chord(chord, channel)
+      unless chord.end_of_tie?
+        duration = 60.0 / bpm * chord.tied_duration * DEFAULT_BEAT
+        chord.notes.each do |note|
+          @midi.note_on(note.pitch, channel, note.attack)
+        end
+        @midi.rest(duration)
+        chord.notes.each do |note|
+          @midi.note_off(note.pitch, channel, note.decay)
+        end
+      end
+    end
+
+    def play_melody(melody, channel)
+      melody.elements.each do |element|
+        case element
+        when Stretto::MusicElements::Note
+          play_note(element, channel)
+        when Stretto::MusicElements::Rest
+          play_rest(element)
+        when Stretto::MusicElements::Chord
+          play_chord(element, channel)
+        end
+      end
+    end
+
+    def play_harmony(harmony, channel)
+      harmony_threads = []
+      harmony.elements.each do |element|
+        harmony_threads << Thread.new(element) { |e| play_element(e, channel) }
+      end
+      harmony_threads.each { |t| t.join }
+    end
+
+    def play_tempo(tempo)
+      @bpm = tempo.bpm
+    end
+
+    def play_channel_pressure(channel_pressure, channel)
+      @midi.channel_aftertouch(channel, channel_pressure.value)
+    end
+
+    def play_polyphonic_pressure(polyphonic_pressure, channel)
+      @midi.aftertouch(polyphonic_pressure.pitch, channel, polyphonic_pressure.value)
+    end
+
+    def set_default_tempo
+      unless @pattern.first.is_a?(Stretto::MusicElements::Tempo)
+        play_element(Stretto::MusicElements::Tempo.new("T[Allegro]"))
+      end
+    end
+
+    def play_instrument(instrument, channel)
+      @midi.program_change(channel, instrument.value)
+    end
+
+    def play_pitch_bend(pitch_bend, channel)
+      @midi.pitch_bend(channel, pitch_bend.value)
+    end
+
+    def play_key_signature(key_signature)
+      # noop
+      # TODO, NOTE:
+      #   MIDI specification allows for a meta message key-signature event.
+      #   While this is useful for some tools, it does not affect the playback.
+      # TODO: Add meta-event key signature
+    end
+
+    def play_measure(measure)
+      # noop
+    end
+
+    def play_variable(variable)
+      # noop
+    end
+
+    def play_voice_change(voice_change)
+      # noop
+    end
+
+    def play_layer_change(layer_change)
+      # noop
+    end
+
+    def play_controller_change(controller_change, channel)
+      @midi.control_change(channel, controller_change.controller, controller_change.value)
+    end
+
+    def play_timing(timing, channel)
+      # TODO: Implement
+    end
+
+  end
+end
+