zgomot 1.0.0 → 1.0.1

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.0.1

data/lib/zgomot/comp/chord.rb

@@ -91,8 +91,8 @@ module Zgomot::Comp
     def channel=(chan)
       notes.each{|n| n.channel = chan}
     end
-    def offset_time=(time)
-      notes.each{|n| n.offset_time = time}
+    def offset=(time)
+      notes.each{|n| n.offset = time}
     end
     def time=(time)
       @clock = Zgomot::Midi::Clock.new

data/lib/zgomot/comp/progression.rb

@@ -87,8 +87,8 @@ module Zgomot::Comp
     def to_midi
       notes.map{|n| n.to_midi}
     end
-    def offset_time=(t)
-      notes.each{|n| n.offset_time = t}
+    def offset=(t)
+      notes.each{|n| n.offset = t}
     end
     def notes
       @notes ||= item.notes(self)

data/lib/zgomot/config.rb

@@ -3,7 +3,6 @@ module Zgomot
   class Error < Exception; end
 
   VERSION = "0.0.0"
-  PLAY_DELAY = 1.0
   DISPATCHER_POLL = 1.133
 
   DEFAULT_CONFIG = {

data/lib/zgomot/main.rb

@@ -30,7 +30,7 @@ include Zgomot::Delegator
 at_exit do
   unless Zgomot.live
     Zgomot::Boot.boot
-    Zgomot::Midi::Stream.streams.each{|s| s.thread.join unless s.thread.nil?}
+    Zgomot::Midi::Stream.streams.values.each{|s| s.thread.join unless s.thread.nil?}
     loop do
       break if Zgomot::Midi::Dispatcher.done?
       sleep(Zgomot::DISPATCHER_POLL)

data/lib/zgomot/midi/channel.rb

@@ -24,10 +24,10 @@ module Zgomot::Midi
 
     end
 
-    attr_reader :number, :clock, :pattern, :length_to_sec
+    attr_reader :number, :clock, :pattern, :length_to_sec, :offset
 
     def initialize(num)
-      @number, @pattern = num, []
+      @number, @pattern, @offset = num, [], nil
       set_clock
     end
 
@@ -46,15 +46,16 @@ module Zgomot::Midi
     end
 
     def method_missing(meth, *args, &blk )
-      pattern.send(meth, *args, &blk); reset_pattern_time; self
+      pattern.send(meth, *args, &blk); reset_pattern_time;self
     end
 
-    def time_shift(secs)
-      pattern.each{|p| p.offset_time= secs}; self
+    def set_clock
+      @offset, @clock = nil, Clock.new
     end
 
-    def set_clock
-      @clock = Clock.new
+    def offset=(time)
+      @offset ||= time
+      pattern.each{|p| p.offset = offset}; self
     end
 
   end

data/lib/zgomot/midi/clock.rb

@@ -4,12 +4,12 @@ module Zgomot::Midi
 
     attr_reader :measure, :beat, :tick, :seconds
 
-    def initialize(arg=nil)
-      if arg.kind_of?(Hash)
+    def initialize(args=nil)
+      if args.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
+        init_with_measure_beat_tick(args)
+      elsif args.nil?; init_with_nil
+      elsif args.kind_of?(Float); init_with_seconds(args); end
     end
     def to_s
       "%d:%d:%d" % [measure, beat, tick]
@@ -17,6 +17,16 @@ module Zgomot::Midi
     def to_f
       seconds
     end
+    def +(add_time)
+      add_sec = if add_time.kind_of?(Float)
+                  add_time
+                elsif add_time.kind_of?(Zgomot::Midi::Time)
+                  add_time.to_f
+                else
+                  raise(Zgomot::Error, "#{add_time.class.name} is invalid. Must be Float or Zgomot::Midi::Time")
+                end
+      self.class.new(seconds+add_sec)
+    end
   private
     def init_with_seconds(sec)
       @seconds = sec
@@ -36,12 +46,14 @@ module Zgomot::Midi
   class Clock
     class << self
       attr_accessor :beat_note, :beats_per_measure, :beats_per_minute, :resolution,
-                    :beat_sec, :whole_note_sec, :measure_sec, :tick_sec, :time_signature
+                    :beat_sec, :whole_note_sec, :measure_sec, :tick_sec, :time_signature,
+                    :ticks_per_beat
       def set_config(config)
         @time_signature = config[:time_signature] || '4/4'
         @beats_per_minute = (config[:beats_per_minute] || '120').to_f
         @resolution = (config[:resolution] || '1/32').split('/').last.to_f
         @beats_per_measure, @beat_note = @time_signature.split('/').map{|v| v.to_f}
+        @ticks_per_beat = @resolution/@beats_per_measure
         @beat_sec= 60.0/@beats_per_minute
         @whole_note_sec = @beat_sec*@beat_note
         @measure_sec = @beat_sec*@beats_per_measure
@@ -49,13 +61,30 @@ module Zgomot::Midi
       end
     end
     set_config(Zgomot.config)
-    attr_reader :current_time
+    attr_reader :current_time, :created_at
     def initialize
-      @current_time = Time.new
+      @current_time, @created_at = Time.new, ::Time.now
     end
     def to_s
       @current_time.to_s
     end
+    def +(add_clock)
+      @current_time + if add_clock.knd_of(Float) or add_time.kind_of?(Zgomot::Midi::Time)
+                        add_clock
+                      elsif add_time.kind_of?(Zgomot::Midi::Clock)
+                        add_clock.current_time
+                      else
+                        raise(Zgomot::Error, "#{add_clock.class.name} is invalid. Must be Float, Zgomot::Midi::Time or Zgomot::Midi::Clock")
+                      end
+    end
+    def absolute_sec
+      @current_time + created_at
+    end
+    def ceil
+      Time.new(:measure => @current_time.measure + 1,
+               :beat    => 0,
+               :tick    => 0)
+    end
     def update(time=nil)
       csecs = if time.kind_of?(Float)
                 current_time.to_f + time

data/lib/zgomot/midi/dispatcher.rb

@@ -3,73 +3,63 @@ module Zgomot::Midi
   class Dispatcher
 
     @queue, @playing = [], []
-    @qmutex, @qdispatch = Mutex.new, Mutex.new
+    @qmutex = Mutex.new
 
     @clock = Clock.new
     @tick = Clock.tick_sec
 
     class << self
 
-      attr_reader :resolution, :queue, :thread, :clock, :tick, :qmutex, :qdispatch, :playing, :last_time
+      attr_reader :resolution, :queue, :thread, :clock, :tick, :qmutex, :qdispatch, :playing
 
       def clk
         clock.to_s
       end
 
-      def flush
-        @queue.clear
-      end
-
-      def done?
-        qdispatch.synchronize{queue.empty? and playing.empty?}
-      end
-
       def enqueue(ch)
+        ch.offset = clock.ceil
         qmutex.synchronize do
-          @queue += ch.pattern.map{|p| p.to_midi}.flatten.compact.select{|n| not n.pitch_class.eql?(:R)}
+          pattern = ch.pattern.map{|p| p.to_midi}.flatten.compact.select{|n| not n.pitch_class.eql?(:R)}
+          @queue += pattern
         end
       end
 
-      def dequeue(time)
+      def dequeue
         qmutex.synchronize do
-          queue.partition{|n| n.play_at <= time}
+          queue.partition{|n| n.note_on.to_f <= clock.current_time.to_f}
         end
       end
 
-      def dispatch(now)
-        qdispatch.synchronize do
-          ready, @queue = dequeue(now)
-          notes_off(now)
+      private
+
+        def dispatch
+          ready, @queue = dequeue
+          notes_off
           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}"
-          Zgomot::Drivers::Mgr.note_on(n.midi, n.channel, (127*n.velocity).to_i)
+        def notes_on(notes)
+          @playing += notes
+          notes.each do |n|
+            Zgomot.logger.info "NOTE ON: #{n.channel} : #{n.to_s} - #{n.time.to_s} - #{n.note_on.to_s} - #{clock.current_time.to_s}"
+            Zgomot::Drivers::Mgr.note_on(n.midi, n.channel, (127*n.velocity).to_i)
+          end
         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}"
-          Zgomot::Drivers::Mgr.note_off(n.midi, n.channel, (127*n.velocity).to_i)
+        def notes_off
+          turn_off, @playing = playing.partition{|n| n.note_off.to_f <= clock.current_time.to_f}
+          turn_off.each do |n|
+            Zgomot.logger.info "NOTE OFF:#{n.channel} : #{n.to_s} - #{n.time.to_s} - #{n.note_off.to_s} - #{clock.current_time.to_s}"
+            Zgomot::Drivers::Mgr.note_off(n.midi, n.channel, (127*n.velocity).to_i)
+          end
         end
-      end
-
-      private :dispatch, :notes_on, :notes_off
 
     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
+        dispatch
+        clock.update(tick)
         sleep(tick)
       end
     end

data/lib/zgomot/midi/note.rb

@@ -27,7 +27,7 @@ module Zgomot::Midi
     end
 
     attr_reader :pitch_class, :octave, :midi, :time_scale
-    attr_accessor :time, :offset_time, :channel, :velocity, :length
+    attr_accessor :time, :offset, :global_offset, :channel, :velocity, :length
 
     def initialize(args)
       @pitch_class, @octave = case args[:pitch]
@@ -56,14 +56,18 @@ module Zgomot::Midi
       @octave = oct; self
     end
 
-    def play_at
-      time.to_f + offset_time.to_f
+    def note_on
+      time + offset
     end
 
     def length_to_sec
       time_scale*Clock.whole_note_sec/length
     end
 
+    def note_off
+      note_on + length_to_sec
+    end
+
     def to_midi
       self
     end

data/lib/zgomot/midi/stream.rb

@@ -2,33 +2,32 @@ module Zgomot::Midi
 
   class Stream
 
-    @streams = []
+    @streams = {}
 
     class << self
       attr_reader :streams
       def str(name, pattern=nil, opts={}, &blk)
         strm = new(name, blk.arity, pattern, opts)
         strm.define_meta_class_method(:play, &blk)
-        @streams << strm
+        @streams[name] = strm
       end
       def play(name=nil)
-        start_time = ::Time.now.truncate_to(Clock.tick_sec) + Zgomot::PLAY_DELAY
         if name.nil?
-          streams.reduce([]) do |a, s|
+          streams.values.reduce([]) do |a, s|
             if s.status_eql?(:paused)
-              s.dispatch(start_time + s.delay)
+              s.dispatch
               a << s.name
             end; a
           end
         else
           apply_to_stream(name){|stream|
-            stream.status_eql?(:paused) ? (stream.dispatch(start_time + stream.delay); name) : nil}
+            stream.status_eql?(:paused) ? (stream.dispatch; name) : nil}
         end
       end
       alias_method :run, :play
       def pause(name=nil)
         if name.nil?
-          streams.each do |stream|
+          streams.values.each do |stream|
             stream.update_status(:paused)
           end; true
         else
@@ -45,7 +44,7 @@ module Zgomot::Midi
         end
       end
       def apply_to_stream(name)
-        stream = streams.find{|s| s.name == name.to_s}
+        stream = streams.values.find{|s| s.name == name.to_s}
         if stream
           yield stream
         else
@@ -79,26 +78,25 @@ module Zgomot::Midi
     def info
       [name, status, ch.number, ch.clock, count, limit, delay].map(&:to_s)
     end
-    def dispatch(start_time)
+    def dispatch
       @count = 0
       ch.set_clock
       update_status(:playing)
       @thread = Thread.new do
                   while(status_eql?(:playing)) do
                     @count += 1
-                    loop_time = ::Time.now
                     break if not limit.eql?(:inf) and count > limit
                     if self.respond_to?(play_meth, true)
                       if pattern = self.send(play_meth)
                         ch << pattern
-                        Dispatcher.enqueue(ch.time_shift(start_time))
+                        Dispatcher.enqueue(ch)
                       else; break; end
                     else
                       raise(Zgomot::Error, 'str block arity not supported')
                     end
                     Zgomot.logger.info "STREAM:#{count}:#{name}"
                     patterns << Zgomot::Comp::Pattern.new(ch.pattern)
-                    sleep(ch.length_to_sec) if count > 1
+                    sleep(ch.length_to_sec)
                   end
         Zgomot.logger.info "STREAM FINISHED:#{name}"
         update_status(:paused)

data/lib/zgomot/ui/output.rb

@@ -44,7 +44,7 @@ module Zgomot::UI
         end
         def format_streams(name=nil)
           if name.nil?
-            stream_mgr.streams.map{|stream| format_stream_info(stream)}
+            stream_mgr.streams.values.map{|stream| format_stream_info(stream)}
           else
             [stream_mgr.apply_to_stream(name.to_s){|stream| stream_info(stream)}]
           end

data/lib/zgomot/ui/windows.rb

@@ -207,7 +207,7 @@ module Zgomot::UI
         end
       end
       def streams
-        Zgomot::Midi::Stream.streams
+        Zgomot::Midi::Stream.streams.values
       end
   end
 

data/lib/zgomot_sh.rb

@@ -5,4 +5,4 @@ begin
   load ENV['HOME'] + '/.zgomot'
 rescue LoadError; end
 Zgomot::Boot.boot
-Pry.config.prompt_name = "\e[38;5;199mzgomot\e[0m\002"
+Pry.config.prompt_name = "zgomot"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zgomot
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-03 00:00:00.000000000 Z
+date: 2013-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi