xi-lang 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3feae76d4f61becebc296554b3628ee870aa429
-  data.tar.gz: cc3ad564f9d0b4559f136dfb9f1ce93c26c01efb
+  metadata.gz: c7ee847da08f4dd79a890c7586a6c410d49994b5
+  data.tar.gz: 098aa22714b668efef3e238a8bb7abac2be2476a
 SHA512:
-  metadata.gz: a7a6f4fea97a1600b38eaf844c847b8a34efc7fa6d21f33244aabd9a4dc6603528ba92651440db11510b40196dd835f04695c5ea83f22e30dfaeb3fd708702c9
-  data.tar.gz: 209c7db3b0e7cb2cd3c512756817ce7b0692bf4662658c436b9f6513651345d211dfa177732892a375d45e98ccbe6ad640ef437faf93d56c6a2cd692f96c0142
+  metadata.gz: 72f6b2715e0753723b848a9dc1b3a7754d7417bac71ac96cfa9869dc5c0f8ce0d497b7d76897e41af6c5f903a7166eeff90f8993adbf2e4fd29c52cb15437800
+  data.tar.gz: fc8186a9b0685c9ee1045424c3cafb1ecd171c4de2b3e6fb156570ad4c40f1cce144c6ab1fe1ae1fbf8cff4213e929ce8252d392b44d8d9ee23034eae3df6293

data/README.md

@@ -9,18 +9,58 @@ Xi is only a patterns library, but can talk to different backends:
 - [SuperCollider](https://github.com/supercollider/supercollider)
 - MIDI devices
 
+*NOTE*: Be advised that this project is in very early alpha stages. There are a
+multiple known bugs, missing features, documentation and tests.
+
+## Example
+
+```ruby
+k = MIDI::Stream.new
+
+k.set degree: [0, 3, 5, 7],
+      octave: [1, 2],
+      scale: [Scale.egyptian],
+      voice: (0..6).p.scale(0, 6, 0, 127),
+      vel: [30, 25, 20].p + 20,
+      cutoff: P.sin1(32, 2) * 128,
+      delay_feedback: 1/2 * 128,
+      delay_time: [0, 0x7f].p(1/16)
+```
+
 ## Installation
 
+### Quickstart
+
 You will need Ruby 2.1+ installed on your system.  Check by running `ruby
--v`.  You will also need Bundler.  Install with `gem install bundler`.
+-v`.  To install Xi you must install the core libraries and REPL, and then one
+or more backends.
+
+If you want to use Xi with SuperCollider:
+
+    $ gem install xi-lang xi-supercollider
+
+Or with MIDI:
+
+    $ gem install xi-lang xi-midi
+
+Then run Xi REPL with:
+
+    $ xi
+
+There is a configuration file that is written automatically for you when run
+for the first time at `~/.config/xi/init.rb`. You can add require lines and
+define all the function helpers you want.
+
+### Repository
 
-Becase Xi is still in **alpha** stage, you will have to checkout this
-repository using Git:
+Becase Xi is still in **alpha** stage, you might want to clone the repository
+using Git instead:
 
-    $ git clone https://github.com/munshkr/xi
+    $ git clone https://github.com/xi-livecode/xi
 
 After that, change into the new directory and install gem dependencies with
-Bundler:
+Bundler.  If you don't have Bundler installed, run `gem install bundler` first.
+Then:
 
     $ cd xi
     $ bundle install
@@ -41,9 +81,9 @@ git commits and tags, and push the `.gem` file to
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at
-https://github.com/munshkr/xi. This project is intended to be a safe, welcoming
-space for collaboration, and contributors are expected to adhere to the
-[Contributor Covenant](http://contributor-covenant.org) code of conduct.
+https://github.com/xi-livecode/xi. This project is intended to be a safe,
+welcoming space for collaboration, and contributors are expected to adhere to
+the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 

data/lib/xi/clock.rb

@@ -7,7 +7,7 @@ Thread.abort_on_exception = true
 module Xi
   class Clock
     DEFAULT_CPS  = 1.0
-    INTERVAL_SEC = 10 / 1000.0
+    INTERVAL_SEC = 20 / 1000.0
 
     def initialize(cps: DEFAULT_CPS)
       @mutex = Mutex.new
@@ -41,6 +41,10 @@ module Xi
       !playing?
     end
 
+    def now
+      Time.now.to_f * cps
+    end
+
     def play
       @mutex.synchronize { @playing = true }
       self
@@ -53,6 +57,14 @@ module Xi
     end
     alias_method :pause, :play
 
+    def seconds_per_cycle
+      @mutex.synchronize { 1.0 / @cps }
+    end
+
+    def at(cycle_pos)
+      Time.at(cycle_pos * seconds_per_cycle)
+    end
+
     def inspect
       "#<#{self.class.name}:#{"0x%014x" % object_id} cps=#{cps.inspect} #{playing? ? :playing : :stopped}>"
     end

data/lib/xi/pattern/transforms.rb

@@ -12,9 +12,12 @@ module Xi
       # @return [Pattern]
       #
       def -@
-        Pattern.new(self) do |y|
-          each { |v| y << (v.respond_to?(:-@) ? -v : v) }
-        end
+        Pattern.new(self) { |y|
+          each_event { |e|
+            v = e.value
+            y << E[(v.respond_to?(:-@) ? -v : v), e.start, e.duration]
+          }
+        }
       end
 
       # Concatenate +object+ pattern or perform a scalar sum with +object+
@@ -36,14 +39,17 @@ module Xi
       #
       def +(object)
         if object.is_a?(Pattern)
-          Pattern.new(self, size: size + object.size) do |y|
+          Pattern.new(self, size: size + object.size) { |y|
             each { |v| y << v }
             object.each { |v| y << v }
-          end
+          }
         else
-          Pattern.new(self) do |y|
-            each { |v| y << (v.respond_to?(:+) ? v + object : v) }
-          end
+          Pattern.new(self) { |y|
+            each_event { |e|
+              v = e.value
+              y << E[(v.respond_to?(:+) ? v + object : v), e.start, e.duration]
+            }
+          }
         end
       end
 
@@ -60,9 +66,12 @@ module Xi
       # @return [Pattern]
       #
       def -(numeric)
-        Pattern.new(self) do |y|
-          each { |v| y << (v.respond_to?(:-) ? v - numeric : v) }
-        end
+        Pattern.new(self) { |y|
+          each_event { |e|
+            v = e.value
+            y << E[(v.respond_to?(:-) ? v - numeric : v), e.start, e.duration]
+          }
+        }
       end
 
       # Performs a scalar multiplication with +numeric+
@@ -78,9 +87,12 @@ module Xi
       # @return [Pattern]
       #
       def *(numeric)
-        Pattern.new(self) do |y|
-          each { |v| y << (v.respond_to?(:*) ? v * numeric : v) }
-        end
+        Pattern.new(self) { |y|
+          each_event { |e|
+            v = e.value
+            y << E[(v.respond_to?(:*) ? v * numeric : v), e.start, e.duration]
+          }
+        }
       end
 
       # Performs a scalar division by +numeric+
@@ -96,9 +108,12 @@ module Xi
       # @return [Pattern]
       #
       def /(numeric)
-        Pattern.new(self) do |y|
-          each { |v| y << (v.respond_to?(:/) ? v / numeric : v) }
-        end
+        Pattern.new(self) { |y|
+          each_event { |e|
+            v = e.value
+            y << E[(v.respond_to?(:/) ? v / numeric : v), e.start, e.duration]
+          }
+        }
       end
 
       # Performs a scalar modulo against +numeric+
@@ -114,9 +129,12 @@ module Xi
       # @return [Pattern]
       #
       def %(numeric)
-        Pattern.new(self) do |y|
-          each { |v| y << (v.respond_to?(:%) ? v % numeric : v) }
-        end
+        Pattern.new(self) { |y|
+          each_event { |e|
+            v = e.value
+            y << E[(v.respond_to?(:%) ? v % numeric : v), e.start, e.duration]
+          }
+        }
       end
 
       # Raises each value to the power of +numeric+, which may be negative or
@@ -132,9 +150,12 @@ module Xi
       # @return [Pattern]
       #
       def **(numeric)
-        Pattern.new(self) do |y|
-          each { |v| y << (v.respond_to?(:**) ? v ** numeric : v) }
-        end
+        Pattern.new(self) { |y|
+          each_event { |e|
+            v = e.value
+            y << E[(v.respond_to?(:**) ? v ** numeric : v), e.start, e.duration]
+          }
+        }
       end
       alias_method :^, :**
 
@@ -218,9 +239,12 @@ module Xi
       # @return [Pattern]
       #
       def normalize(min, max)
-        Pattern.new(self) do |y|
-          each { |v| y << (v.respond_to?(:-) ? (v - min) / (max - min) : v) }
-        end
+        Pattern.new(self) { |y|
+          each_event { |e|
+            v = e.value
+            y << E[(v.respond_to?(:-) ? (v - min) / (max - min) : v), e.start, e.duration]
+          }
+        }
       end
 
       # Scales a pattern of normalized values (0..1) to a custom range
@@ -240,9 +264,12 @@ module Xi
       # @return [Pattern]
       #
       def denormalize(min, max)
-        Pattern.new(self) do |y|
-          each { |v| y << (v.respond_to?(:*) ? (max - min) * v + min : v) }
-        end
+        Pattern.new(self) { |y|
+          each_event { |e|
+            v = e.value
+            y << E[(v.respond_to?(:*) ? (max - min) * v + min : v), e.start, e.duration]
+          }
+        }
       end
 
       # Scale from one range of values to another range of values
@@ -262,16 +289,16 @@ module Xi
 
       # TODO Document
       def decelerate(num)
-        Pattern.new(self) do |y|
+        Pattern.new(self) { |y|
           each_event { |e| y << E[e.value, e.start * num, e.duration * num] }
-        end
+        }
       end
 
       # TODO Document
       def accelerate(num)
-        Pattern.new(self) do |y|
+        Pattern.new(self) { |y|
           each_event { |e| y << E[e.value, e.start / num, e.duration / num] }
-        end
+        }
       end
 
       # Based on +probability+, it yields original value or nil

data/lib/xi/pattern.rb

@@ -16,24 +16,26 @@ module Xi
 
     def_delegators :@source, :size
 
-    def initialize(enum=nil, size: nil, **metadata)
-      size ||= enum.size if enum.respond_to?(:size)
+    def initialize(source=nil, size: nil, **metadata)
+      if source.nil? && !block_given?
+        fail ArgumentError, 'must provide source or block'
+      end
+
+      size ||= source.size if source.respond_to?(:size)
 
       @source = if block_given?
         Enumerator.new(size) { |y| yield y }
-      elsif enum
-        enum
       else
-        fail ArgumentError, 'must provide source or block'
+        source
       end
 
       @is_infinite = @source.size.nil? || @source.size == Float::INFINITY
 
       @event_duration = metadata.delete(:dur) || metadata.delete(:event_duration)
-      @event_duration ||= enum.event_duration if enum.respond_to?(:event_duration)
+      @event_duration ||= source.event_duration if source.respond_to?(:event_duration)
       @event_duration ||= 1
 
-      @metadata = enum.respond_to?(:metadata) ? enum.metadata : {}
+      @metadata = source.respond_to?(:metadata) ? source.metadata : {}
       @metadata.merge!(metadata)
 
       if @is_infinite
@@ -65,7 +67,7 @@ module Xi
 
     def p(dur=nil, **metadata)
       Pattern.new(@source, dur: dur || @event_duration,
-                  **@metadata.merge(metadata))
+                  size: size, **@metadata.merge(metadata))
     end
 
     def each_event
@@ -114,19 +116,19 @@ module Xi
 
     def map_events
       return enum_for(__method__) unless block_given?
-      Pattern.new(dur: dur, **metadata) { |y| each_event { |e| y << yield(e) } }
+      Pattern.new(self) { |y| each_event { |e| y << yield(e) } }
     end
     alias_method :collect_events, :map_events
 
     def select_events
       return enum_for(__method__) unless block_given?
-      Pattern.new { |y| each_event { |e| y << e if yield(e) } }
+      Pattern.new(self) { |y| each_event { |e| y << e if yield(e) } }
     end
     alias_method :find_all_events, :select_events
 
     def reject_events
       return enum_for(__method__) unless block_given?
-      Pattern.new { |y| each_event { |e| y << e unless yield(e) } }
+      Pattern.new(self) { |y| each_event { |e| y << e unless yield(e) } }
     end
 
     def to_events

data/lib/xi/stream.rb

@@ -2,16 +2,16 @@ require 'set'
 
 module Xi
   class Stream
-    WINDOW_SEC = 0.05
-
     attr_reader :clock, :source, :source_patterns, :state, :event_duration, :gate
 
     def initialize(clock)
       @mutex = Mutex.new
       @playing = false
+      @last_sound_object_id = 0
       @state = {}
-      @new_sound_object_id = 0
       @changed_params = [].to_set
+      @playing_sound_objects = {}
+      @prev_end = {}
 
       self.clock = clock
     end
@@ -76,7 +76,8 @@ module Xi
     alias_method :pause, :play
 
     def inspect
-      "#<#{self.class.name}:#{"0x%014x" % object_id} clock=#{@clock.inspect} #{playing? ? :playing : :stopped}>"
+      "#<#{self.class.name}:#{"0x%014x" % object_id} " \
+        "clock=#{@clock.inspect} #{playing? ? :playing : :stopped}>"
     rescue => err
       logger.error(err)
     end
@@ -106,15 +107,19 @@ module Xi
     def forward_enums(now)
       @enums.each do |p, (enum, total_dur)|
         cur_pos = now % total_dur
-        next_ev = enum.peek
+        start_pos = now - cur_pos
+
+        loop do
+          next_ev = enum.peek
+          distance = (cur_pos - next_ev.start) % total_dur
 
-        while distance = (cur_pos - next_ev.start) % total_dur do
+          @prev_end[p] = start_pos + next_ev.end
           enum.next
 
           break if distance <= next_ev.duration
-          next_ev = enum.peek
         end
       end
+
       @must_forward = false
     end
 
@@ -124,48 +129,62 @@ module Xi
 
       @enums.each do |p, (enum, total_dur)|
         cur_pos = now % total_dur
-        next_ev = enum.peek
+        start_pos = now - cur_pos
 
         # Check if there are any currently playing sound objects that
         # must be gated off
-        @playing_sound_objects.dup.each do |end_pos, so_ids|
-          if (cur_pos - end_pos) % total_dur <= WINDOW_SEC
-            gate_off = so_ids
+        @playing_sound_objects.dup.each do |end_pos, h|
+          if now >= h[:at] - latency_sec
+            gate_off << h
             @playing_sound_objects.delete(end_pos)
           end
         end
 
+        next_ev = enum.peek
+
         # Do we need to play next event now? If not, skip this parameter
-        if (cur_pos - next_ev.start) % total_dur <= WINDOW_SEC
+        if (@prev_end[p].nil? || now >= @prev_end[p]) && cur_pos >= next_ev.start - latency_sec
+          #logger.info "cur_pos=#{cur_pos} >= next_ev.start=#{next_ev.start}"
           # Update state based on pattern value
+          # TODO: Pass as parameter exact time (start_ts + next_ev.start)
           update_state(p, next_ev.value)
 
           # If this parameter is a gate, mark it as gate on as
           # a new sound object
           if p == @gate
-            new_so_ids = Array(next_ev.value).size.times.map do
-              so_id = @new_sound_object_id
-              @new_sound_object_id += 1
-              so_id
-            end
-            gate_on = new_so_ids
-            @playing_sound_objects[next_ev.end] = new_so_ids
+            new_so_ids = Array(next_ev.value)
+              .size.times.map { new_sound_object_id }
+
+            gate_on << {
+              so_ids: new_so_ids,
+              at: start_pos + next_ev.start
+            }
+
+            @playing_sound_objects[rand(100000)] = {
+              so_ids: new_so_ids,
+              duration: total_dur,
+              at: start_pos + next_ev.end,
+            }
           end
 
           # Because we already processed event, advance enumerator
-          enum.next
+          next_ev = enum.next
+          @prev_end[p] = start_pos + next_ev.end
         end
       end
 
       [gate_on, gate_off]
     end
 
+    def new_sound_object_id
+      @last_sound_object_id += 1
+    end
+
     def update_internal_structures
-      @playing_sound_objects ||= {}
       @must_forward = true
       @enums = @source.map { |k, v|
         pat = v.p(@event_duration)
-        [k, [infinite_enum(pat), pat.total_duration]]
+        [k, [enum_for(:loop_events, pat), pat.total_duration]]
       }.to_h
     end
 
@@ -178,21 +197,28 @@ module Xi
     end
 
     def do_state_change
-      logger.info "State change: #{@state.select { |k, v| @changed_params.include?(k) }.to_h}"
+      logger.info "State change: #{@state
+        .select { |k, v| @changed_params.include?(k) }.to_h}"
     end
 
     def update_state(p, v)
-      logger.debug "Update state of :#{p}: #{v}"
-      @changed_params << p if v != @state[p]
-      @state[p] = v
+      if v != @state[p]
+        logger.debug "Update state of :#{p}: #{v}"
+        @changed_params << p
+        @state[p] = v
+      end
     end
 
     def state_changed?
       !@changed_params.empty?
     end
 
-    def infinite_enum(p)
-      Enumerator.new { |y| loop { p.each_event { |e| y << e } } }
+    def loop_events(pattern)
+      loop { pattern.each_event { |e| yield e } }
+    end
+
+    def latency_sec
+      0.05
     end
 
     def logger

data/lib/xi/version.rb

@@ -1,3 +1,3 @@
 module Xi
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/xi.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Musical pattern language for livecoding}
   spec.description   = %q{A musical pattern language inspired in Tidal and SuperCollider
                           for building higher-level musical constructs easily.}
-  spec.homepage      = "https://github.com/munshkr/xi"
+  spec.homepage      = "https://github.com/xi-livecode/xi"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xi-lang
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Damián Silvani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-13 00:00:00.000000000 Z
+date: 2017-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -143,7 +143,7 @@ files:
 - lib/xi/stream.rb
 - lib/xi/version.rb
 - xi.gemspec
-homepage: https://github.com/munshkr/xi
+homepage: https://github.com/xi-livecode/xi
 licenses:
 - MIT
 metadata: {}