zgomot 0.1.3 → 1.0.0

data/lib/zgomot/midi/clock.rb

@@ -1,86 +1,61 @@
-##############################################################################################################
 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     
+        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}"
+      "%d:%d:%d" % [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
+      attr_accessor :beat_note, :beats_per_measure, :beats_per_minute, :resolution,
+                    :beat_sec, :whole_note_sec, :measure_sec, :tick_sec, :time_signature
+      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}
+        @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);nil
+      end
     end
-    
-    #...........................................................................................................
+    set_config(Zgomot.config)
     attr_reader :current_time
-    
-    #...........................................................................................................
     def initialize
       @current_time = Time.new
     end
-
-    #...........................................................................................................
+    def to_s
+      @current_time.to_s
+    end
     def update(time=nil)
       csecs = if time.kind_of?(Float)
                 current_time.to_f + time
@@ -89,13 +64,11 @@ module Zgomot::Midi
               elsif time.nil?
                 current_time.to_f + Clock.tick_sec
               else
-                raise(Zgomot::Error, "argument must by of type Float or Zgomot::Midi::Time") 
+                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

@@ -1,92 +1,79 @@
-##############################################################################################################
 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 clk
+        clock.to_s
+      end
+
       def flush
         @queue.clear
       end
-      #.........................................................................................................
+
       def done?
         qdispatch.synchronize{queue.empty? and playing.empty?}
       end
 
-      #.........................................................................................................
-      def enqueue(ch)        
+      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 
+        qdispatch.synchronize do
           ready, @queue = dequeue(now)
           notes_off(now)
           notes_on(ready)
         end
       end
 
-      #.........................................................................................................
       def notes_on(notes)
-        notes.each do |n| 
+        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)
         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| 
+        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)
         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)       
+        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/note.rb

@@ -1,10 +1,7 @@
-##############################################################################################################
 module Zgomot::Midi
 
-  #####-------------------------------------------------------------------------------------------------------
   class Note
-    
-    #.........................................................................................................
+
     PITCH_CLASS = {
       :C  => 0,  :Bs => 0,
       :Cs => 1,  :Db => 1,
@@ -13,38 +10,32 @@ module Zgomot::Midi
       :E  => 4,  :Fd => 4,
       :F  => 5,  :Es => 5,
       :Fs => 6,  :Gb => 6,
-      :G  => 7, 
+      :G  => 7,
       :Gs => 8,  :Ab => 8,
       :A  => 9,
       :As => 10, :Bb => 10,
-      :B  => 11, :Cb => 11, 
-      :R  => -1, 
+      :B  => 11, :Cb => 11,
+      :R  => -1,
     }
 
-    #.........................................................................................................
     LENGTH = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024].select{|d| d <= Clock.resolution}
 
-    #.........................................................................................................
     OCTAVE = (-1..9).to_a
 
-    #####-------------------------------------------------------------------------------------------------------
     class << self
 
-    #### self  
     end
-    
-    #.........................................................................................................
+
     attr_reader :pitch_class, :octave, :midi, :time_scale
     attr_accessor :time, :offset_time, :channel, :velocity, :length
-  
-    #.........................................................................................................
+
     def initialize(args)
       @pitch_class, @octave = case args[:pitch]
                                 when Array then args[:pitch]
                                 when Symbol then [args[:pitch], 4]
                                 else raise(Zgomot::Error, "#{args[:pitch].inspect} is invalid pitch")
                               end
-      @length, @velocity = args[:length], args[:velocity] 
+      @length, @velocity = args[:length], args[:velocity]
       @midi = pitch_to_midi(pitch_class, octave)
       @time_scale = 1.0
       raise(Zgomot::Error, "#{octave} is invalid octave") unless OCTAVE.include?(octave)
@@ -53,52 +44,38 @@ module Zgomot::Midi
       raise(Zgomot::Error, "#{velocity} is invalid velocity") unless velocity < 1.0
     end
 
-    #.........................................................................................................
     def to_s
       "[#{pitch_class.to_s},#{octave}].#{length}.#{midi}.#{velocity}"
     end
 
-    #.........................................................................................................
-    # transforms
-    #.........................................................................................................
     def bpm!(bpm)
       @time_scale = 1.0/bpm.to_f; self
     end
 
-    #.........................................................................................................
     def octave!(oct)
       @octave = oct; self
     end
-    
-    #.........................................................................................................
-    # channel and dispatch interface
-    #.........................................................................................................
+
     def play_at
       time.to_f + offset_time.to_f
     end
-    
-    #.........................................................................................................
+
     def length_to_sec
       time_scale*Clock.whole_note_sec/length
     end
 
-    #.........................................................................................................
     def to_midi
       self
     end
-      
-    #.........................................................................................................
+
     def pitch_to_midi(pitch_class, octave)
       if PITCH_CLASS[pitch_class]
         (midi = 12*(octave+1)+PITCH_CLASS[pitch_class]) <= 127 ? midi : nil
       end
     end
 
-    #.........................................................................................................
     private :pitch_to_midi
-  
-  #### Note
+
   end
 
-#### Zgomot::Midi 
 end

data/lib/zgomot/midi/stream.rb

@@ -1,76 +1,115 @@
-##############################################################################################################
 module Zgomot::Midi
 
-  #####-------------------------------------------------------------------------------------------------------
   class Stream
 
-    #.........................................................................................................
     @streams = []
 
-    #####-------------------------------------------------------------------------------------------------------
     class << self
-      
-      #.........................................................................................................
       attr_reader :streams
-
-      #.........................................................................................................
       def str(name, pattern=nil, opts={}, &blk)
-        strm = new(name, blk.arity, pattern, opts[:lim])
-        strm.define_meta_class_method(:play, &blk) 
+        strm = new(name, blk.arity, pattern, opts)
+        strm.define_meta_class_method(:play, &blk)
         @streams << strm
       end
-
-      #.........................................................................................................
-      def play 
-        streams.each{|s| s.dispatch(::Time.now.truncate_to(Clock.tick_sec) + Zgomot::PLAY_DELAY) if s.status.eql?(:new)}
+      def play(name=nil)
+        start_time = ::Time.now.truncate_to(Clock.tick_sec) + Zgomot::PLAY_DELAY
+        if name.nil?
+          streams.reduce([]) do |a, s|
+            if s.status_eql?(:paused)
+              s.dispatch(start_time + s.delay)
+              a << s.name
+            end; a
+          end
+        else
+          apply_to_stream(name){|stream|
+            stream.status_eql?(:paused) ? (stream.dispatch(start_time + stream.delay); name) : nil}
+        end
+      end
+      alias_method :run, :play
+      def pause(name=nil)
+        if name.nil?
+          streams.each do |stream|
+            stream.update_status(:paused)
+          end; true
+        else
+          apply_to_stream(name) do |stream|
+            stream.update_status(:paused)
+            name
+          end
+        end
+      end
+      alias_method :stop, :pause
+      def tog(name)
+        apply_to_stream(name) do |stream|
+          stream.status_eql?(:playing) ? pause(name) : play(name)
+        end
+      end
+      def apply_to_stream(name)
+        stream = streams.find{|s| s.name == name.to_s}
+        if stream
+          yield stream
+        else
+          Zgomot.logger.error "STREAM '#{name}' NOT FOUND"; nil
+        end
       end
-      
-    #### self
     end
-    
-    #####-------------------------------------------------------------------------------------------------------
-    attr_reader :patterns, :times, :status, :count, :thread, :limit, :name, :play_meth
-    
-    #.........................................................................................................
-    def initialize(name, arity, pattern, limit)
-      @patterns, @times = [Zgomot::Comp::Pattern.new(pattern)], [Time.new]
-      @limit, @name, @count, @thread, @status = limit || :inf, name, 0, nil, :new
+
+    attr_accessor :count
+    attr_reader :patterns, :status, :thread, :limit, :name, :play_meth,
+                :delay, :ch
+
+    def initialize(name, arity, pattern, opts)
+      @patterns = [Zgomot::Comp::Pattern.new(pattern)]
+      @delay = (opts[:del].to_f * 60.0/ Zgomot.config[:beats_per_minute].to_f).to_i || 0
+      @limit, @name, @thread, @status, @count = opts[:lim] || :inf, name, nil, :paused, 0
+      @ch = Zgomot::Midi::Channel.ch(opts[:ch] || 0)
       @play_meth = "play#{arity.eql?(-1) ? 0 : arity}".to_sym
+      @status_mutex = Mutex.new
     end
-
-    #.........................................................................................................
-    def dispatch(start_time)  
-      ch_time, @status = 0.0, :playing 
+    def update_status(new_status)
+      @status_mutex.synchronize do
+        @status = new_status
+      end
+    end
+    def status_eql?(test_status)
+      @status_mutex.synchronize do
+        @status == test_status
+      end
+    end
+    def info
+      [name, status, ch.number, ch.clock, count, limit, delay].map(&:to_s)
+    end
+    def dispatch(start_time)
+      @count = 0
+      ch.set_clock
+      update_status(:playing)
       @thread = Thread.new do
-                  loop 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 (chan = self.send(play_meth)).kind_of?(Zgomot::Midi::Channel) 
-                        Dispatcher.enqueue(chan.time_shift(start_time+ch_time))
+                    if self.respond_to?(play_meth, true)
+                      if pattern = self.send(play_meth)
+                        ch << pattern
+                        Dispatcher.enqueue(ch.time_shift(start_time))
                       else; break; end
                     else
                       raise(Zgomot::Error, 'str block arity not supported')
                     end
                     Zgomot.logger.info "STREAM:#{count}:#{name}"
-                    patterns << Zgomot::Comp::Pattern.new(chan.pattern)
-                    ch_time += chan.length_to_sec; times << Time.new(ch_time)
-                    sleep(0.80*(start_time+ch_time-::Time.now.truncate_to(Clock.tick_sec)))
+                    patterns << Zgomot::Comp::Pattern.new(ch.pattern)
+                    sleep(ch.length_to_sec) if count > 1
                   end
         Zgomot.logger.info "STREAM FINISHED:#{name}"
-        @status = :finished          
-      end         
+        update_status(:paused)
+      end
     end
-  
-    #.........................................................................................................
+
     def play0;play;end
     def play1;play(Marshal.load(Marshal.dump(patterns.last)));end
 
-    #.........................................................................................................
     private :play0, :play1
-    
-  #### Stream
+
   end
 
-#### Zgomot::Midi 
 end

data/lib/zgomot/midi.rb

@@ -3,3 +3,4 @@ require 'zgomot/midi/note'
 require 'zgomot/midi/channel'
 require 'zgomot/midi/stream'
 require 'zgomot/midi/dispatcher'
+require 'zgomot/midi/cc'

data/lib/zgomot/ui/output.rb

@@ -0,0 +1,67 @@
+module Zgomot::UI
+  class Output
+    @stream_mgr = Zgomot::Midi::Stream
+    @cc_mgr = Zgomot::Midi::CC
+    @clk_mgr = Zgomot::Midi::Clock
+    HEADER_COLOR = '#666666'
+    STREAM_OUTPUT_FORMAT_WIDTHS = [30, 9, 6, 11, 9, 8, 7]
+    STREAM_HEADER = %w(Name Status Chan Time Count Limit Delay)
+    STREAM_STATUS_PLAY_COLOR = '#19D119'
+    STREAM_STATUS_PAUSE_COLOR = '#EAC117'
+    CC_OUTPUT_FORMAT_WIDTHS = [30, 10, 8, 8, 8, 8, 8]
+    CC_HEADER = %w(Name Value CC Chan Type Max Min)
+    CC_COLOR = '#EAC117'
+    CONFIG_COLOR = '#EAC117'
+    class << self
+      attr_reader :stream_mgr, :cc_mgr, :clk_mgr
+      def lstr(name=nil)
+        puts format_for_color(STREAM_OUTPUT_FORMAT_WIDTHS, HEADER_COLOR) % color(STREAM_HEADER, HEADER_COLOR)
+        format_streams(name).each{|stream| puts stream}; nil
+      end
+      def lcc(name=nil)
+        puts format_for_color(CC_OUTPUT_FORMAT_WIDTHS, HEADER_COLOR) % color(CC_HEADER, HEADER_COLOR)
+        format_ccs(name).each{|cc| puts cc}; nil
+      end
+      def lconfig
+        format = '%-35s %-25s'
+        puts format % ['Time Signature'.foreground(HEADER_COLOR), clk_mgr.time_signature.foreground(CONFIG_COLOR)]
+        puts format % ['Beats/Minute'.foreground(HEADER_COLOR), clk_mgr.beats_per_minute.to_i.to_s.foreground(CONFIG_COLOR)]
+        puts format % ['Resolution'.foreground(HEADER_COLOR), "1/#{clk_mgr.resolution.to_i}".foreground(CONFIG_COLOR)]
+        puts format % ['Seconds/Beat'.foreground(HEADER_COLOR), clk_mgr.beat_sec.to_s.foreground(CONFIG_COLOR)]
+      end
+      private
+        def color(string, color)
+          Array(string).map{|s| s.to_s.foreground(color)}
+        end
+        def format_for_color(widths, color)
+          color_offset = "".color(color).length
+          widths.map{|width| "%-#{width+color_offset}s"}.join(" ")
+        end
+        def format_stream_info(stream)
+          stream_output = stream.info
+          value_color = stream.status_eql?(:playing) ? STREAM_STATUS_PLAY_COLOR : STREAM_STATUS_PAUSE_COLOR
+          format_for_color(STREAM_OUTPUT_FORMAT_WIDTHS, value_color) % color(stream_output, value_color)
+        end
+        def format_streams(name=nil)
+          if name.nil?
+            stream_mgr.streams.map{|stream| format_stream_info(stream)}
+          else
+            [stream_mgr.apply_to_stream(name.to_s){|stream| stream_info(stream)}]
+          end
+        end
+        def format_cc_config(config)
+          format_for_color(CC_OUTPUT_FORMAT_WIDTHS, CC_COLOR) % color(config, CC_COLOR)
+        end
+        def format_cc_info(name)
+          cc_mgr.info(name).map{|config| format_cc_config(config)}
+        end
+        def format_ccs(name=nil)
+          if name.nil?
+            cc_mgr.cc_names.reduce([]){|ccs, cc_name| ccs + format_cc_info(cc_name)}
+          else
+            format_cc_info(name.to_sym)
+          end
+        end
+    end
+  end
+end