zgomot 0.0.1

data/lib/zgomot/comp/progression.rb

@@ -0,0 +1,132 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Progression
+     
+    #.........................................................................................................
+    attr_reader :mode, :length, :velocity, :clock, :tonic, :items, :item
+  
+    #.........................................................................................................
+    def initialize(args)
+      @length, @velocity, @item = [args[:length]].flatten, [args[:velocity]].flatten, args[:item]
+      @items = (1..7).to_a
+      self.mode!(args[:mode])
+      @tonic = case args[:tonic]
+                 when Array then args[:tonic]
+                 when Symbol then [args[:tonic], 4]
+                 when nil then [:C,4]
+                 else raise(Zgomot::Error, "#{args[:tonic].inspect} is invalid tonic")
+               end
+    end
+
+    #.........................................................................................................
+    def pitches
+      last_pitch, octave = tonic; pitch = [last_pitch]
+      mode[0..-2].each_index{|i| pitch << PitchClass.next(tonic.first, sum(mode[0..i]))}
+      pitch[1..-1].map do |p|
+        octave += 1 if p < last_pitch; last_pitch = p.value; [last_pitch, octave]
+      end.unshift(tonic)
+    end
+
+    #.........................................................................................................
+    def new_respond_to?(meth, include_private=false)
+      old_respond_to?(meth) || (not notes.select{|n| n.respond_to?(meth)}.empty?)    
+    end
+    alias_method :old_respond_to?, :respond_to?
+    alias_method :respond_to?, :new_respond_to?
+      
+    #.........................................................................................................
+    def method_missing(meth, *args, &blk)
+      if not notes.select{|n| n.respond_to?(meth)}.empty?
+        @notes = notes.map do |n|
+                   n.respond_to?(meth) ? n.send(meth, *args, &blk) : n
+                 end
+      else
+        @notes = nil
+        items.send(meth, *args, &blk)
+      end
+      self
+    end
+
+    #.........................................................................................................
+    # transforms
+    #.........................................................................................................
+    def tonic!(v)
+      @notes = nil; @tonic = v; self
+    end
+
+    #.........................................................................................................
+    def mode!(v)
+      @notes = nil; @mode = v.kind_of?(Mode) ? v : Mode.new(v); self
+    end
+
+    #.........................................................................................................
+    def octave!(oct)
+      @notes = nil; @octave = oct; self
+    end
+    
+    #.........................................................................................................
+    def [](*args)
+      @items = args.flatten; self
+    end
+    
+    #.........................................................................................................
+    def velocity=(v)
+      notes.each{|n| n.velocity = v}
+    end
+
+    #.........................................................................................................
+    def length=(v)
+      notes.each{|n| n.length = v}
+    end
+
+    #.........................................................................................................
+    # midi interface
+    def length_to_sec
+      notes.inject(0.0){|s,n| s += n.length_to_sec}
+    end
+
+    #.........................................................................................................
+    def time=(time)
+      @clock = Zgomot::Midi::Clock.new
+      clock.update(time)
+      notes.each do |n|
+        n.time = clock.current_time
+        clock.update(n.length_to_sec)
+      end
+    end
+    
+    #.........................................................................................................
+    def channel=(c)
+      notes.each{|n| n.channel = c}
+    end
+    
+    #.........................................................................................................
+    def to_midi
+      notes.map{|n| n.to_midi}
+    end
+
+    #.........................................................................................................
+    def offset_time=(t)
+      notes.each{|n| n.offset_time = t}
+    end
+    
+    #.........................................................................................................
+    def notes
+      @notes ||= item.notes(self)
+    end
+  
+    #.........................................................................................................
+    def sum(a)
+      a.inject(0) {|s,n| s+n}
+    end
+  
+    #.........................................................................................................
+    private :sum
+  
+  #### Progression
+  end
+
+#### Zgomot::Comp 
+end

data/lib/zgomot/comp/scale.rb

@@ -0,0 +1,32 @@
+##############################################################################################################
+module Zgomot::Comp
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Scale
+    
+    #####-------------------------------------------------------------------------------------------------------
+    attr_reader :intervals, :shift, :scale
+  
+    #.........................................................................................................
+    def initialize(int, shift)
+      @intervals = int
+      @shift = shift - 1
+      @scale = int.clone
+      self.shift.times{self.next}
+    end
+
+    #.........................................................................................................
+    def next
+      scale.push(scale.shift) 
+    end
+    
+    #.........................................................................................................
+    def method_missing(method, *args, &blk )
+      scale.send(method, *args, &blk)
+    end
+      
+  #### Scale
+  end
+
+#### Zgomot::Comp 
+end

data/lib/zgomot/comp.rb

@@ -0,0 +1,11 @@
+require 'zgomot/comp/pattern'
+require 'zgomot/comp/chord'
+require 'zgomot/comp/note'
+require 'zgomot/comp/scale'
+require 'zgomot/comp/mode'
+require 'zgomot/comp/perc'
+require 'zgomot/comp/progression'
+require 'zgomot/comp/pitch_class'
+require 'zgomot/comp/markov'
+
+

data/lib/zgomot/config.rb

@@ -0,0 +1,51 @@
+##############################################################################################################
+module Zgomot
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Error < Exception; end
+
+  #.........................................................................................................
+  VERSION = "0.0.0"
+  PLAY_DELAY = 1.0
+  DISPATCHER_POLL = 1.133
+
+  #.........................................................................................................
+  DEFAULT_CONFIG = {
+    :beats_per_minute => 120,
+    :time_signature   => '4/4',
+    :resolution       => '1/32'
+  }
+
+  #.........................................................................................................
+  @config_file = "zgomot.yml"
+  @app_path = File.dirname($0)
+  @log_file = STDOUT
+  @live = false
+  
+  ####......................................................................................................
+  class << self
+
+    #.......................................................................................................
+    attr_accessor :config_file, :app_path, :log_file, :config, :live
+
+    #.......................................................................................................
+    def logger; @logger ||= Logger.new(STDOUT); end
+    def logger=(logger); @logger = logger; end
+
+    #.......................................................................................................
+    def add_path(dir)
+      File.join(Zgomot.app_path, dir)
+    end
+
+  #### self
+  end
+
+  #.......................................................................................................
+  @config_file = add_path(config_file)
+  user_config = if File.exist?(config_file)
+                  (c = File.open(config_file) {|yf| YAML::load(yf)}) ? c : {}
+                else; {}; end
+  @config = DEFAULT_CONFIG.inject({}){|r,(k,v)| r.update(k => (user_config[k.to_s] || v))}         
+                          
+end
+

data/lib/zgomot/main.rb

@@ -0,0 +1,51 @@
+##############################################################################################################
+module Zgomot
+  
+  #####-------------------------------------------------------------------------------------------------------
+  module Delegator 
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+
+      #.........................................................................................................
+      def delegate(del, *methods)
+        methods.each do |method_name|
+          class_eval <<-RUBY
+            def #{method_name.to_s}(*args, &blk)
+              ::#{del}.send(#{method_name.inspect}, *args, &blk)
+            end
+          RUBY
+        end
+      end
+
+    #### self
+    end
+
+    delegate Zgomot::Boot, :before_start
+    delegate Zgomot::Midi::Stream, :str, :play, :streams
+    delegate Zgomot::Midi::Channel, :ch
+    delegate Zgomot::Midi::Dispatcher, :clock
+    delegate Zgomot::Comp::Pattern, :np, :cp, :c, :n, :pr
+    delegate Zgomot::Comp::Markov, :mark
+
+  #### Delegator 
+  end
+    
+#### AgentXmpp 
+end
+
+##############################################################################################################
+include Zgomot::Delegator
+
+##############################################################################################################
+at_exit do 
+  unless Zgomot.live
+    Zgomot::Boot.boot
+    Zgomot::Midi::Stream.streams.each{|s| s.thread.join}
+    loop do     
+      break if Zgomot::Midi::Dispatcher.done?
+      sleep(Zgomot::DISPATCHER_POLL)
+    end
+  end
+  Zgomot.logger.info "ZGOMOT IS FINISHED"    
+end

data/lib/zgomot/midi/channel.rb

@@ -0,0 +1,92 @@
+##############################################################################################################
+module Zgomot::Midi
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Channel
+
+    #.........................................................................................................
+    @channels = []
+    
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+      
+      #.........................................................................................................
+      attr_reader :channels
+
+      #.........................................................................................................
+      def ch(num=0, opts={})
+        (channels << new(is_valid(num), opts)).last
+      end
+
+      #.........................................................................................................
+      def is_valid(num)
+        nums = [num].flatten
+        valid = nums.select{|n| 0 <= n and n <= 15}
+        valid.length.eql?(nums.length) ? num : raise(Zgomot::Error, "channel number invalid: 1<= channel <= 16")
+      end
+
+      #.........................................................................................................
+      def release(chan)
+        channels.delete_if{|c| c.eql?(chan)}
+      end
+
+    #### self
+    end
+    
+    #####-------------------------------------------------------------------------------------------------------
+    attr_reader :number, :clock, :pattern
+    
+    #.........................................................................................................
+    def initialize(num, opts={})
+      @number = num
+      @clock = Clock.new
+      @pattern = []
+    end
+
+    #.........................................................................................................
+    def <<(pat)
+      pat = Zgomot::Comp::Pattern.new(pat) unless pat.kind_of?(Zgomot::Comp::Pattern)
+      pat.seq.each do |p| 
+        p.time = clock.current_time
+        p.channel = number
+        @pattern << p.clone
+        clock.update(p.length_to_sec)
+      end; self
+    end
+
+    #.........................................................................................................
+    def method_missing(meth, *args, &blk )
+      pattern.send(meth, *args, &blk); reset_pattern_time; self
+    end
+
+    #.........................................................................................................
+    def length_to_sec
+      clock.current_time.to_f
+    end
+
+    #.........................................................................................................
+    # transforms
+    #.........................................................................................................
+    def time_shift(secs)
+      pattern.each{|p| p.offset_time=secs}; self
+    end
+    
+    #.........................................................................................................
+    # pattern
+    #.........................................................................................................
+    def reset_pattern_time
+      @clock = Clock.new
+      pattern.each do |pat| 
+        pat.time = clock.current_time
+        clock.update(pat.length_to_sec)
+      end
+    end
+    
+    #.........................................................................................................
+    private :reset_pattern_time
+    
+  #### Channel
+  end
+
+#### Zgomot::Midi 
+end

data/lib/zgomot/midi/clock.rb

@@ -0,0 +1,101 @@
+##############################################################################################################
+module Zgomot::Midi
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Time
+
+    #.........................................................................................................
+    attr_reader :measure, :beat, :tick, :seconds
+  
+    #.........................................................................................................
+    def initialize(arg=nil)
+      if arg.kind_of?(Hash)
+        [:measure, :beat, :tick].each{|a| raise(Zgomot::Error, "#{a} is a required argument") unless args.include?(a)}
+        init_with_measure_beat_tick(arg) 
+      elsif arg.nil?; init_with_nil     
+      elsif arg.kind_of?(Float); init_with_seconds(arg); end
+    end
+
+    #.........................................................................................................
+    def to_s
+      "#{measure}.#{beat}.#{tick}"
+    end
+
+    #.........................................................................................................
+    def to_f
+      seconds
+    end
+    
+  private
+  
+    #.........................................................................................................
+    def init_with_seconds(sec)
+      @seconds = sec
+      @measure = (sec/Clock.measure_sec).to_i
+      @beat = ((sec % Clock.measure_sec)/Clock.beat_sec).to_i
+      @tick = ((sec - measure*Clock.measure_sec - beat*Clock.beat_sec)/Clock.tick_sec).to_i
+    end
+
+    #.........................................................................................................
+    def init_with_measure_beat_tick(args)
+      @measure, @beat, @tick = args[:measure], args[:beat], args[:tick]
+      @seconds = (measure*Clock.measure_sec + beat*Clock.beat_sec + tick*Clock.tick_sec).to_f
+    end
+
+    #.........................................................................................................
+    def init_with_nil
+      @measure, @beat, @tick, @seconds = 0, 0, 0, 0.0
+    end
+    
+  #### Time
+  end
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Clock
+
+    #.........................................................................................................
+    @beats_per_measure, @beat_note = Zgomot.config[:time_signature].split('/').map{|v| v.to_f}
+    @beats_per_minute = Zgomot.config[:beats_per_minute].to_f
+    @resolution = Zgomot.config[:resolution].split('/').last.to_f
+    @beat_sec= 60.0/@beats_per_minute
+    @whole_note_sec = @beat_sec*@beat_note
+    @measure_sec = @beat_sec*@beats_per_measure
+    @tick_sec = @whole_note_sec/(@resolution)
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+
+      #.........................................................................................................
+      attr_accessor :beat_note, :beats_per_measure, :beats_per_minute, :resolution, 
+                    :beat_sec, :whole_note_sec, :measure_sec, :tick_sec
+          
+    #### self
+    end
+    
+    #...........................................................................................................
+    attr_reader :current_time
+    
+    #...........................................................................................................
+    def initialize
+      @current_time = Time.new
+    end
+
+    #...........................................................................................................
+    def update(time=nil)
+      csecs = if time.kind_of?(Float)
+                current_time.to_f + time
+              elsif time.kind_of?(Zgomot::Midi::Time)
+                current_time.to_f + time.to_f
+              elsif time.nil?
+                current_time.to_f + Clock.tick_sec
+              else
+                raise(Zgomot::Error, "argument must by of type Float or Zgomot::Midi::Time") 
+              end
+      @current_time = Time.new(csecs)
+    end
+
+  #### Clock
+  end
+
+#### Zgomot ::Midi
+end

data/lib/zgomot/midi/dispatcher.rb

@@ -0,0 +1,92 @@
+##############################################################################################################
+module Zgomot::Midi
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Dispatcher
+
+    #.........................................................................................................
+    @queue, @playing = [], []
+    @qmutex, @qdispatch = Mutex.new, Mutex.new
+    
+    #.........................................................................................................
+    @clock = Clock.new
+    @tick = Clock.tick_sec
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+      
+      #.........................................................................................................
+      attr_reader :resolution, :queue, :thread, :clock, :tick, :qmutex, :qdispatch, :playing, :last_time
+
+      #.........................................................................................................
+      def flush
+        @queue.clear
+      end
+      #.........................................................................................................
+      def done?
+        qdispatch.synchronize{queue.empty? and playing.empty?}
+      end
+
+      #.........................................................................................................
+      def enqueue(ch)        
+        qmutex.synchronize do
+          @queue += ch.pattern.map{|p| p.to_midi}.flatten.compact.select{|n| not n.pitch_class.eql?(:R)}
+        end
+      end
+        
+      #.........................................................................................................
+      def dequeue(time)
+        qmutex.synchronize do
+          queue.partition{|n| n.play_at <= time}
+        end
+      end
+
+      #.........................................................................................................
+      def dispatch(now)
+        qdispatch.synchronize do 
+          ready, @queue = dequeue(now)
+          notes_off(now)
+          notes_on(ready)
+        end
+      end
+
+      #.........................................................................................................
+      def notes_on(notes)
+        notes.each do |n| 
+          Zgomot.logger.info "NOTE ON: #{n.channel} : #{n.to_s} : #{n.time.to_s} : #{clock.current_time.to_s}"
+          Interface.driver.note_on(n.midi, n.channel, (127*n.velocity).to_i)
+        end
+        @playing += notes
+      end
+
+      #.........................................................................................................
+      def notes_off(time)
+        turn_off, @playing = playing.partition{|n| (n.play_at+n.length_to_sec) <= time}
+        turn_off.each do |n| 
+          Zgomot.logger.info "NOTE OFF:#{n.channel} : #{n.to_s} : #{n.time.to_s} : #{clock.current_time.to_s}"
+          Interface.driver.note_off(n.midi, n.channel, (127*n.velocity).to_i)
+        end
+      end
+
+      #.........................................................................................................
+      private :dispatch, :notes_on, :notes_off
+
+    #### self
+    end
+
+    #.........................................................................................................
+    @thread = Thread.new do
+      loop do
+        now = ::Time.now.truncate_to(Clock.tick_sec)
+        dispatch(now)       
+        clock.update(last_time.nil? ? tick : now-last_time)
+        @last_time = now
+        sleep(tick)
+      end
+    end
+
+  #### Dispatcher
+  end
+
+#### Zgomot::Midi 
+end

data/lib/zgomot/midi/interface.rb

@@ -0,0 +1,29 @@
+##############################################################################################################
+module Zgomot::Midi
+
+  #####-------------------------------------------------------------------------------------------------------
+  class Interface
+
+    #####-------------------------------------------------------------------------------------------------------
+    class << self
+
+      #.........................................................................................................
+      attr_reader :driver
+    
+      #.........................................................................................................
+      def method_missing(method, *args, &blk )
+        @driver.send(method, *args, &blk)
+      end
+
+    #### self
+    end
+    
+    #.........................................................................................................
+    @driver = MIDIator::Interface.new
+    driver.autodetect_driver
+    
+  #### Interface
+  end
+
+#### Zgomot::Midi 
+end