shmidi 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3597c4286b7e19268aa340d94bc77346a045a75
+  data.tar.gz: be66d51d451f14247d77b2f2e792b39d23a3c860
+SHA512:
+  metadata.gz: 758e82429e48ac2659b5021e89344ee2f1d3e7d0f6ea0e8c59e2dde76450316efbe95f54b1695344f92f2458dd7f29c6b47097c57ee43fade65d7649e2f60802
+  data.tar.gz: bdf94aad7c06e4c9d825292a8ba9b3dd15e68d022d9d08d7c7f8d7c1f9b6df74c4b5ab3b3debbcb56f9d0df9c53c24e9e6e3bd2f931a62fa6115d3eed7bcf2a2

data/.gitignore

@@ -0,0 +1,23 @@
+*~
+~*
+.DS_Store
+._.DS_Store
+thumbs.db
+*.log
+*.pid
+*.dump
+*.profile
+*.profile.gif
+*.profile.dot
+*.profile.symbols
+.svn/
+.hg/
+*.sublime-workspace
+.env
+.rbenv-version
+.ruby-version
+Gemfile.lock
+core
+*.gem
+/doc/
+/var/

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/HISTORY.md

@@ -0,0 +1,2 @@
+# 3.0.RC-1 Complete rebuild
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+MIT License, http://opensource.org/licenses/MIT
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,17 @@
+# shmidi
+Midi experiments
+
+## Installation
+`gem install shmidi` as usual.
+
+## Usage by example
+TODO
+
+## Documentation
+This README is all i could say in a rush. No other documentation provided at this moment, see the sources.
+
+## If you've found a bug or drawback
+Don't hesistate to leave a report.
+
+## License
+MIT for now.

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+
+task :build do
+  system('gem build shmidi.gemspec')
+end
+
+task :default => :build

data/bin/shmidi

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+require 'shmidi'
+require 'io/console'
+
+if Shmidi::PROFILE
+  begin
+    require 'perftools'
+    PerfTools::CpuProfiler.start 'test.profile'
+    at_exit { PerfTools::CpuProfiler.stop }
+  rescue LoadError
+    Shmidi.ON_EXCEPTION
+  end
+end
+
+@ctl = Shmidi::Controller.new('xonek1-ledtest')
+trap('INT') do
+  @ctl.reset
+  puts(@ctl.inspect)
+  exit(0)
+end
+
+case ARGV.shift
+when 'list'
+  Shmidi::Socket.print_device_list
+when 'ledtest'
+  if ARGV.size == 1
+    @ctl = Shmidi.JSON_PARSE(File.read(ARGV.shift))
+  else
+    @sock = 'xone'
+    @ctl.sockets << Shmidi::Socket.new(@sock, ARGV.shift, ARGV.shift)
+    @chan = 15
+    @ctl.controls['led'] = Shmidi::RGYLed.new(
+      Shmidi::Led.new(@sock, @chan, 'C0'),
+      Shmidi::Led.new(@sock, @chan, 'G#0'),
+      Shmidi::Led.new(@sock, @chan, 'E0', true)
+    )
+  end
+  sleep(0.15)
+  loop do
+    @ctl.controls['led'].turn_on('red')
+    sleep(0.15)
+    @ctl.controls['led'].turn_on('green')
+    sleep(0.15)
+    @ctl.controls['led'].turn_on('yellow')
+    sleep(0.15)
+    @ctl.controls['led'].turn_off
+    sleep(0.15)
+  end
+else
+  puts('NOOP')
+end

data/lib/shmidi/base.rb

@@ -0,0 +1,90 @@
+module Shmidi
+  module Base
+    CTYPE = :ABS
+    attr_accessor :_id
+    attr_accessor :_rev
+    attr_accessor :_deleted
+    attr_accessor :_attachments
+    attr_accessor :version
+
+    def to_hash
+      hash = {JSON_CREATE_ID => self.class.name}
+      instance_variables.each do |var|
+        hvar = var[1..-1]
+        next if hvar =~ /^__/
+        hash[hvar] = instance_variable_get(var)
+      end
+      hash
+    end
+
+    def init
+      # ABSTRACT
+    end
+
+    def reset
+      # ABSTRACT
+    end
+
+    def to_s
+      dump
+    end
+
+    def dump
+      Shmidi::DUMP(to_hash)
+    end
+
+    def inspect
+      Shmidi::PRETTY(self)
+    end
+
+    def [](arg)
+      send arg.to_sym
+    end
+    def []=(arg, value)
+      send "#{arg}=".to_sym, value
+    end
+
+    def clone
+      self.class.ensure(dump)
+    end
+
+    def etag
+      "\"#{_rev}\""
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def ensure(obj)
+        # ------
+        m = if obj.kind_of?(self)
+          obj
+        elsif obj.kind_of?(Hash)
+          self.json_create(obj)
+        elsif obj.kind_of?(String)
+          self.ensure(Shmidi::JSON_PARSE(obj))
+        else
+          nil
+        end
+        (block_given? && m) ? yield(m) : m
+      end
+
+      def json_create(hash = {})
+        obj = allocate
+        hash.each do |key, value|
+          begin
+            obj.instance_variable_set("@#{key}", value)
+          rescue Exception
+            Shmidi::ON_EXCEPTION
+          end
+        end
+        obj.version ||= 0
+        obj.init
+        obj.reset
+        return obj
+      end
+    end
+  end
+end

data/lib/shmidi/clock.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+module Shmidi
+  class Event
+    attr_accessor :destination
+  end
+
+  class Clock
+    def initialize(socket, delay = 0.25)
+      @socket = socket
+      @delay = delay
+      @buffer = []
+      @thread = Thread.new do
+        loop do
+          begin
+            buf = filter
+            Socket[@socket].push(buf)
+            buf.each do |event|
+              event.destination.push(true)
+            end
+            wait
+          rescue
+            Shmidi.ON_EXCEPTION
+          end
+        end
+      end
+    end
+
+    def sync(event)
+      event.destination = Queue.new
+      @buffer << event
+      event.destination.pop
+    end
+
+    protected
+
+    def filter
+      b = @buffer
+      @buffer = []
+      b
+    end
+
+    def wait
+      sleep(@delay)
+    end
+  end
+end

data/lib/shmidi/composite/rgy_led.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+module Shmidi
+  class RGYLed
+    include Base
+    CTYPE = :RGY
+    attr_reader :leds
+
+    def initialize(red, green, yellow)
+      @leds = {'red' => red, 'green' => green, 'yellow' => yellow}
+    end
+
+    def reset
+      @leds.values.each {|led| led.reset}
+    end
+
+    def on?
+      @leds.each {|color, led| return color if led.turned_on?}
+      false
+    end
+
+    def turn_on(color = 'yellow', clock = nil)
+      @leds.each do |c, led|
+        next if c == color
+        led.turn_off
+      end
+      @leds[color].turn_on(clock)
+    end
+
+    def turn_off(clock = nil)
+      @leds.values.each {|led| led.turn_off(clock)}
+    end
+
+  end
+end

data/lib/shmidi/control.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+module Shmidi
+  class Control
+    include Base
+    attr_accessor :channel, :note
+
+    def socket
+      Socket[@socket]
+    end
+
+    def initialize(socket, channel, note)
+      @socket = socket
+      @channel = channel
+      @note = note
+    end
+
+    def id
+      "#{@channel}:#{@note}"
+    end
+  end
+end

data/lib/shmidi/controller.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+module Shmidi
+  class Controller
+    include Base
+    attr_accessor :internals
+    attr_reader :name
+    def initialize(name)
+      @name = name
+      @internals = [[], {}]
+    end
+
+    def reset
+      controls.values.each {|control| control.reset}
+    end
+
+    def sockets
+      @internals.first
+    end
+
+    def controls
+      @internals.last
+    end
+  end
+end

data/lib/shmidi/controls/button.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+module Shmidi
+  class Button < Control
+    CTYPE = :BUT
+
+    attr_reader :counter
+
+    def initialize(socket, channel, note, pressed = false)
+      super(socket, channel, note)
+      @pressed = pressed
+      init
+    end
+
+    def init
+      @counter = 0
+      @__on_press = []
+      socket.on_event(channel, :on, note) do |event|
+        @pressed = true
+        @counter += 1 # intentionaly before handlers
+        Shmidi.TRACE("#{CTYPE}\t#{id}\tPRESSED\t#{event.value}")
+        @__on_press.each { |b| b.call(self) }
+      end
+
+      @on_release = []
+      socket.on_event(channel, :off, note) do |event|
+        @pressed = false
+        Shmidi.TRACE("#{CTYPE}\t#{id}\tRELEASE\t#{event.value}")
+        @on_release.each { |b| b.call(self) }
+        @counter += 1 # intentionaly after handlers
+      end
+    end
+
+    def reset
+      @pressed = false
+    end
+
+    def pressed?
+      !!@pressed
+    end
+    def on_press(&block)
+      @__on_press << block
+    end
+
+    def released?
+      !@pressed
+    end
+    def on_release(&block)
+      @on_release << block
+    end
+
+  end
+end

data/lib/shmidi/controls/encoder.rb

@@ -0,0 +1,10 @@
+# coding: utf-8
+module Shmidi
+  class Encoder < Knob
+    CTYPE = :ENC
+
+    def increasing?
+      @value == 1
+    end
+  end
+end

data/lib/shmidi/controls/fader.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+module Shmidi
+  class Fader < Knob
+    CTYPE = :FAD
+  end
+end

data/lib/shmidi/controls/knob.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+module Shmidi
+  class Knob < Control
+    CTYPE = :KNO
+    attr_reader :value
+
+    def initialize(socket, channel, note, value = 0)
+      super(socket, channel, note)
+      init(value)
+    end
+
+    def init(value = 0)
+      @prev_value = value
+      @value = value
+      @__on_value = []
+      socket.on_event(channel, :cc, note) do |event|
+        reset(event.value)
+        Shmidi.TRACE("#{CTYPE}\t#{id}\t#{@value}")
+        @__on_value.each { |b| b.call(self) }
+      end
+    end
+
+    def reset(new_value=0)
+      @prev_value = @value
+      @value = 0
+    end
+
+    def on_value(&block)
+      @__on_value << block
+    end
+  end
+end

data/lib/shmidi/controls/led.rb

@@ -0,0 +1,37 @@
+# coding: utf-8
+module Shmidi
+  class Led < Control
+    CTYPE = :LED
+
+    def initialize(socket, channel, note, turned_on = false)
+      super(socket, channel, note)
+      init(turned_on)
+    end
+
+    def init(turned_on = false)
+      @turned_on = false
+      @__turn_on_event = Event.new_on(@channel, @note)
+      @__turn_off_event = Event.new_off(@channel, @note)
+      turn_on if turned_on
+    end
+
+    def reset
+      turn_off
+    end
+
+    def on?
+      !!@turned_on
+    end
+
+    def turn_on(clock = nil)
+      (clock && clock.sync(@__turn_on_event)) || socket.push(@__turn_on_event)
+      @turned_on = true
+    end
+
+    def turn_off(clock = nil)
+      (clock && clock.sync(@__turn_off_event)) || socket.push(@__turn_off_event)
+      @turned_on = false
+    end
+
+  end
+end

data/lib/shmidi/event.rb

@@ -0,0 +1,102 @@
+# coding: utf-8
+module Shmidi
+  class Event
+    #TODO: eat symbols and strings as needed for shmidi piping
+    attr_reader :source
+    attr_reader :data, :timestamp
+    attr_reader :channel, :message_int, :note_int, :value
+    attr_reader :message, :note
+
+    MESSAGES ||= begin
+      h = { 8  => :off,
+            9   => :on,
+            11  => :cc,
+            14  => :pitch}
+      h.keys.each {|k| h[h[k]] = k}
+      h
+    end
+
+    def octave
+      return nil unless @note.kind_of?(String)
+      (@note_int / 12) - 1
+    end
+
+    def initialize(h)
+      @source     = h[:source]
+      @timestamp  = (h[:timestamp] || 0).floor
+      @data       = h[:data].clone if h[:data]
+      if @data
+        @channel    = (@data[0] & 0x0f) + 1
+        @message_int= @data[0] >> 4
+        @message    = @message_int
+        @message    = MESSAGES[@message_int] || @message_int
+        @note_int   = @data[1]
+        @note       = @note_int
+        parse_note_int if [:on, :off].include?(@message)
+        @value      = @data[2]
+      else # no numeric data array
+        @message_int = h[:message_int] || MESSAGES[h[:message]] || h[:message]
+        @message = MESSAGES[@message_int]
+        @value = h[:value] || 0
+        @channel = h[:channel] || 1
+        @note = h[:note]
+        @note_int = h[:note]
+        if h[:note].kind_of?(Numeric) && [:on, :off].include?(@message)
+          parse_note_int
+        elsif h[:note].kind_of?(String)
+          @note = h[:note]
+          #@note += h[:note][1] if h[:note][1] == '#'
+          h[:note] =~ /^(.#?)(-?\d+)$/
+          @note_int = ($2.to_i + 1) * 12 + 'C C#D D#E F F#G G#A A#B '.index($1) / 2
+        end
+        @data = [0,0,0]
+        @data[1] = @note_int
+        @data[2] = @value
+        @data[0] = (@message_int << 4) + (@channel - 1)
+      end
+    end
+
+    def self.new_on(channel, note, value = 127)
+      Event.new(
+        :channel  => channel,
+        :message  => :on,
+        :note     => note,
+        :value    => value)
+    end
+
+    def self.new_off(channel, note, value = 0)
+      Event.new(
+        :channel  => channel,
+        :message  => :off,
+        :note     => note,
+        :value    => value)
+    end
+
+    def self.new_cc(channel, cc, value)
+      Event.new(
+        :channel  => channel,
+        :message  => :cc,
+        :note     => cc,
+        :value    => value)
+    end
+
+    def to_s
+      "CH:#{@channel}\t#{@message}\t#{@note}\t=#{@value}"
+    end
+
+    def to_hash
+      hash = {}
+      instance_variables.each do |var|
+        hash[var[1..-1].to_sym] = instance_variable_get(var)
+      end
+      hash
+    end
+
+    private
+
+    def parse_note_int
+      @note     = 'C C#D D#E F F#G G#A A#B '[((@note_int % 12) * 2), 2].strip
+      @note += "#{octave}"
+    end
+  end
+end