xi-lang 0.1.4 → 0.1.5

data/lib/xi/stream.rb

@@ -3,7 +3,7 @@ require 'set'
 
 module Xi
   class Stream
-    attr_reader :clock, :opts, :source, :state, :event_duration, :gate
+    attr_reader :clock, :opts, :source, :state, :delta, :gate
 
     DEFAULT_PARAMS = {
       degree: 0,
@@ -25,16 +25,18 @@ module Xi
       @state = {}
       @changed_params = [].to_set
       @playing_sound_objects = {}
-      @prev_end = {}
+      @prev_ts = {}
+      @prev_delta = {}
 
       self.clock = clock
     end
 
-    def set(event_duration: nil, gate: nil, **source)
+    def set(delta: nil, gate: nil, **source)
       @mutex.synchronize do
         @source = source
         @gate = gate if gate
-        @event_duration = event_duration if event_duration
+        @delta = delta if delta
+        @reset = true unless @playing
         update_internal_structures
       end
       play
@@ -42,9 +44,9 @@ module Xi
     end
     alias_method :call, :set
 
-    def event_duration=(new_value)
+    def delta=(new_value)
       @mutex.synchronize do
-        @event_duration = new_value
+        @delta = new_value
         update_internal_structures
       end
     end
@@ -83,6 +85,8 @@ module Xi
       @mutex.synchronize do
         @playing = false
         @state.clear
+        @prev_ts.clear
+        @prev_delta.clear
         @clock.unsubscribe(self)
       end
       self
@@ -103,7 +107,8 @@ module Xi
       @mutex.synchronize do
         @changed_params.clear
 
-        forward_enums(now, cps) if @must_forward
+        update_all_state if @reset
+
         gate_off = gate_off_old_sound_objects(now)
         gate_on = play_enums(now, cps)
 
@@ -131,36 +136,15 @@ module Xi
       @state.select { |k, _| @changed_params.include?(k) }
     end
 
-    def forward_enums(now, cps)
-      @enums.each do |p, (enum, total_dur)|
-        next if total_dur == 0
-
-        cur_pos = (now * cps) % total_dur
-        start_ts = now - (cur_pos / cps)
-
-        loop do
-          next_ev = enum.peek
-          distance = (cur_pos - next_ev.start) % total_dur
-
-          @prev_end[p] = @clock.init_ts + start_ts + (next_ev.end / cps)
-          enum.next
-
-          break if distance <= next_ev.duration
-        end
-      end
-
-      @must_forward = false
-    end
-
     def gate_off_old_sound_objects(now)
       gate_off = []
 
       # Check if there are any currently playing sound objects that
       # must be gated off
-      @playing_sound_objects.dup.each do |end_pos, h|
+      @playing_sound_objects.dup.each do |start_pos, h|
         if now + @clock.init_ts >= h[:at] - latency_sec
           gate_off << h
-          @playing_sound_objects.delete(end_pos)
+          @playing_sound_objects.delete(start_pos)
         end
       end
 
@@ -170,43 +154,50 @@ module Xi
     def play_enums(now, cps)
       gate_on = []
 
-      @enums.each do |p, (enum, total_dur)|
-        next if total_dur == 0
+      @enums.each do |p, enum|
+        next unless enum.next?
+
+        n_value, n_start, n_dur = enum.peek
 
-        cur_pos = (now * cps) % total_dur
-        start_ts = now - (cur_pos / cps)
+        @prev_ts[p]    ||= n_start / cps
+        @prev_delta[p] ||= n_dur
 
-        next_ev = enum.peek
+        next_start = @prev_ts[p] + (@prev_delta[p] / cps)
 
-        # Do we need to play next event now? If not, skip this parameter
-        if (@prev_end[p].nil? || now + @clock.init_ts >= @prev_end[p]) &&
-            cur_pos >= next_ev.start - latency_sec
+        # Do we need to play next event? If not, skip this parameter value
+        if now >= next_start - latency_sec
+          # If it is too late to play this event, skip it
+          if now < next_start
+            starts_at = @clock.init_ts + next_start
 
-          # Update state based on pattern value
-          # TODO: Pass as parameter exact time (start_ts + next_ev.start)
-          update_state(p, next_ev.value)
-          transform_state
+            # Update state based on pattern value
+            # TODO: Pass as parameter exact time: starts_at
+            update_state(p, n_value)
+            transform_state
 
-          # If a gate parameter changed, create a new sound object
-          if p == @gate
-            new_so_ids = Array(next_ev.value)
-              .size.times.map { new_sound_object_id }
+            # If a gate parameter changed, create a new sound object
+            if p == @gate
+              # If these sounds objects are new,
+              # consider them as new "gate on" events.
+              unless @playing_sound_objects.key?(n_start)
+                new_so_ids = Array(n_value)
+                  .size.times.map { new_sound_object_id }
 
-            gate_on << {
-              so_ids: new_so_ids,
-              at: @clock.init_ts + start_ts + (next_ev.start / cps),
-            }
+                gate_on << {so_ids: new_so_ids, at: starts_at}
+                @playing_sound_objects[n_start] = {so_ids: new_so_ids}
+              end
 
-            @playing_sound_objects[rand(100000)] = {
-              so_ids: new_so_ids,
-              duration: total_dur,
-              at: @clock.init_ts + start_ts + (next_ev.end / cps),
-            }
+              # Set (or update) ends_at timestamp
+              ends_at = @clock.init_ts + next_start + (n_dur / cps)
+              @playing_sound_objects[n_start][:at] = ends_at
+            end
           end
 
+          @prev_ts[p]    = next_start
+          @prev_delta[p] = n_dur
+
           # Because we already processed event, advance enumerator
-          next_ev = enum.next
-          @prev_end[p] = @clock.init_ts + start_ts + (next_ev.end / cps)
+          enum.next
         end
       end
 
@@ -250,11 +241,8 @@ module Xi
     end
 
     def update_internal_structures
-      @must_forward = true
-      @enums = @source.map { |k, v|
-        pat = v.p(@event_duration)
-        [k, [enum_for(:loop_events, pat), pat.total_duration]]
-      }.to_h
+      cycle = @clock.current_cycle
+      @enums = @source.map { |k, v| [k, v.p(@delta).each_event(cycle)] }.to_h
     end
 
     def do_gate_on_change(ss)
@@ -285,8 +273,12 @@ module Xi
       !@changed_params.empty?
     end
 
-    def loop_events(pattern)
-      loop { pattern.each_event { |e| yield e } }
+    def update_all_state
+      @enums.each do |p, enum|
+        n_value, _ = enum.peek
+        update_state(p, n_value)
+      end
+      @reset = false
     end
 
     def latency_sec

data/lib/xi/tidal_clock.rb

@@ -111,7 +111,8 @@ module Xi
     end
 
     def update_clock_from_server_data(h)
-      @init_ts = h[:ts].to_f
+      # Do not set @init_ts for now
+      #@init_ts = h[:ts].to_f
       @cps = h[:cps]
     end
   end

data/lib/xi/version.rb

@@ -1,3 +1,3 @@
 module Xi
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/lib/xi.rb

@@ -1,9 +1,10 @@
 require "xi/version"
 require 'xi/core_ext'
 require 'xi/pattern'
-require 'xi/event'
 require 'xi/stream'
 require 'xi/clock'
+require 'xi/bjorklund'
+require 'xi/step_sequencer'
 
 def inf
   Float::INFINITY
@@ -37,11 +38,19 @@ module Xi
     end
 
     def peek(pattern, *args)
+      pattern.peek_values(*args)
+    end
+
+    def peek_events(pattern, limit=10, *args)
       pattern.peek(*args)
     end
 
-    def peek_events(pattern, *args)
-      pattern.peek_events(*args)
+    def e(n, m, value=nil)
+      Bjorklund.new([n, m].min, [n, m].max, value)
+    end
+
+    def s(str, *values)
+      StepSequencer.new(str, *values)
     end
 
     def method_missing(method, backend=nil, **opts)

data/xi.gemspec

@@ -30,5 +30,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "guard-minitest"
 
   spec.add_dependency 'pry'
-  spec.add_dependency 'websocket'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xi-lang
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Damián Silvani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-19 00:00:00.000000000 Z
+date: 2017-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,20 +108,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: websocket
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: |-
   A musical pattern language inspired in Tidal and SuperCollider
                             for building higher-level musical constructs easily.
@@ -142,22 +128,25 @@ files:
 - Rakefile
 - bin/xi
 - lib/xi.rb
+- lib/xi/bjorklund.rb
 - lib/xi/clock.rb
 - lib/xi/core_ext.rb
+- lib/xi/core_ext/array.rb
 - lib/xi/core_ext/enumerable.rb
+- lib/xi/core_ext/enumerator.rb
 - lib/xi/core_ext/fixnum.rb
 - lib/xi/core_ext/numeric.rb
 - lib/xi/core_ext/object.rb
-- lib/xi/core_ext/simple.rb
+- lib/xi/core_ext/scalar.rb
 - lib/xi/core_ext/string.rb
 - lib/xi/error_log.rb
-- lib/xi/event.rb
 - lib/xi/logger.rb
 - lib/xi/pattern.rb
 - lib/xi/pattern/generators.rb
 - lib/xi/pattern/transforms.rb
 - lib/xi/repl.rb
 - lib/xi/scale.rb
+- lib/xi/step_sequencer.rb
 - lib/xi/stream.rb
 - lib/xi/tidal_clock.rb
 - lib/xi/version.rb

data/lib/xi/core_ext/simple.rb

@@ -1,15 +0,0 @@
-require 'xi/pattern'
-
-module Xi
-  module Pattern::Simple
-    def p(dur=nil, **metadata)
-      [self].p(dur, metadata)
-    end
-  end
-end
-
-class Fixnum;   include Xi::Pattern::Simple; end
-class Float;    include Xi::Pattern::Simple; end
-class String;   include Xi::Pattern::Simple; end
-class Symbol;   include Xi::Pattern::Simple; end
-class Rational; include Xi::Pattern::Simple; end

data/lib/xi/event.rb

@@ -1,82 +0,0 @@
-module Xi
-  # An Event is an object that represents a scalar +value+ of some type, and
-  # has a +start+ position or onset, and +duration+ in time.
-  #
-  # Both +start+ and +duration+ are in terms of cycles.
-  #
-  # Usually you don't create events, they are created by a Pattern when
-  # assigned to a Stream, or by some transformation methods on Pattern, so you
-  # don't need to worry about them.  Most of the time, you will manually build
-  # Patterns from values and let the Pattern handle when values are applied in
-  # time, based on its default event duration, for example.
-  #
-  # You can instantiate an Event using {.[]}, like this
-  #
-  #   Event.new(42, 0, 2) #=> E[42,0,2]
-  #   Event[:a, 1, 1/2]   #=> E[:a,1,1/2]
-  #
-  # E is an alias of Event, so you can build them using E instead.  Note that
-  # the string representation of the object can be used to build the same event
-  # again (almost the same ignoring whitespace between constructor arguments).
-  #
-  #   E[:a, 1, 1/4]       #=> E[:a,1,1/4]
-  #
-  class Event
-    attr_reader :value, :start, :duration
-
-    # Creates a new Event with +value+, with both +start+ position and
-    # +duration+ in cycles 
-    #
-    # @param value [Object]
-    # @param start [Numeric] default: 0
-    # @param duration [Numeric] default: 1
-    # @return [Event]
-    #
-    def initialize(value, start=0, duration=1)
-      @value = value
-      @start = start
-      @duration = duration
-    end
-
-    # @see #initialize
-    def self.[](*args)
-      new(*args)
-    end
-
-    def ==(o)
-      self.class == o.class &&
-        value == o.value &&
-        start == o.start &&
-        duration == o.duration
-    end
-
-    # Return the end position in cycles
-    # 
-    # @return [Numeric]
-    #
-    def end
-      @start + @duration
-    end
-
-    # Creates a Pattern that only yields this event
-    #
-    # @param dur [Numeric, #each] event duration
-    # @param metadata [Hash]
-    # @return [Pattern]
-    #
-    def p(dur=nil, **metadata)
-      [self].p(dur, metadata)
-    end
-
-    def inspect
-      "E[#{@value.inspect},#{@start}" \
-        "#{",#{@duration}" if @duration != 1}]"
-    end
-
-    def to_s
-      inspect
-    end
-  end
-end
-
-E = Xi::Event