niki 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in niki.gemspec
+gemspec
+
+gem 'unimidi'
+# gem 'midiator', :path => '../midiator'

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    niki (0.0.1)
+      midilib
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ffi (1.0.9)
+    ffi-coremidi (0.0.8)
+      ffi (>= 1.0)
+    midilib (2.0.0)
+    unimidi (0.2.1)
+      ffi-coremidi
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  niki!
+  unimidi

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/Readme.md

@@ -0,0 +1,55 @@
+# Niki
+
+Niki is a Ruby DSL to describe and play musical pieces.
+
+It leverages Giles Bowkett's [Archaeopteryx](
+https://github.com/gilesbowkett/archaeopteryx) to send MIDI output to other
+programs accepting MIDI inputs (Ableton Live, Reason, Garage Band...), which
+will actually play the song.
+
+To see what the DSL looks like, take a look at the [example song](https://github.com/txus/niki/blob/master/examples/my_song.rb)
+
+https://github.com/gilesbowkett/archaeopteryx/blob/master/db_drum_definition.rb
+
+## Caveats
+
+* It runs only in Ruby 1.8.7 (due to the dependency on Archaeopteryx) :(
+* I've tested this only in Snow Leopard, but it should run in more platforms.
+  If your platform is not supported it's because Archaeopteryx
+  doesn't support it yet.
+
+## Run the example song
+
+First of all, get the example song files (both the Reason file and the Ruby file)
+
+    $ curl -o my_song.rns https://raw.github.com/txus/niki/master/examples/my_song.rns
+    $ curl -o my_song.rb https://raw.github.com/txus/niki/master/examples/my_song.rb
+
+Now [download a demo version](
+http://www.propellerheads.se/download/index.cfm?fuseaction=get_article&article=reason) of Propellerhead's
+Reason 5 and open up `my_song.rns`.
+
+### Configuring the midi interface
+
+This is how you configure the midi interface in Mac OSX (it should not be
+difficult in other operating systems):
+
+* Make sure the IAC driver is activated in Mac OSX's Audio/MIDI Setup (inside the
+MIDI section) (activate the "Device is online" checkbox if it is not)
+* In this section, make sure at least one port is created (under the Ports
+section). If not, add one clicking the + button.
+* Go to the Reason options panel, go to Advanced, and set your first
+MIDI bus (Bus A) to "IAC Driver IAC Bus 1" (the port you just created).
+
+### Install the gem and run!
+
+Now you should install the gem and run the example!
+
+    $ gem install niki
+    $ ruby my_song.rb
+
+# TODO
+
+* Tests + refactor
+* Documentation
+* Expand this README

data/examples/my_song.rb

@@ -0,0 +1,267 @@
+require 'rubygems'
+require 'niki'
+
+song = Niki::Song.new :tempo => 127 do
+
+  # Configure midi channels
+  channel :basses, 1
+  channel :drums, 10
+  channel :chords, 2
+  channel :melodies, 3
+
+  configure :drums do |drums|
+    drums[:kick]  = c1
+    drums[:snare] = c1.sharp
+    drums[:hh]    = g1
+    drums[:ohh]   = g1.sharp
+  end
+
+  part :intro do
+    # Drums
+    2.times do
+      drum [:kick, :hh], 8
+      drum :hh, 8
+      drum [:snare, :hh], 8
+      drum :hh, 8
+
+      drum [:kick, :hh], 8
+      drum :hh, 8
+      drum [:snare, :hh], 8
+      drum [:kick, :hh], 8
+
+      drum :hh, 16
+      drum :hh, 16
+      drum :hh, 16
+      drum :hh, 16
+      drum [:snare, :hh], 8
+      drum :hh, 8
+
+      drum [:kick, :hh], 8
+      drum [:kick, :hh], 8
+      drum [:snare, :hh], 8
+      drum :ohh, 8
+    end
+
+    # Bass
+    bass f2, 4
+
+    bass f2, 8
+    bass e2, 8
+    bass f2, 8
+    bass e2, 8
+    bass f2, 8
+
+    bass e3, 4
+    bass c3, 4
+    bass b2, 8
+    bass c2, 8
+    bass c2, 8
+    bass g2, 4
+
+    bass a2, 4
+
+    bass a2, 8
+    bass g2, 8
+    bass a2, 8
+    bass g2, 8
+    bass a2, 8
+
+    bass e3, 4
+    bass c3, 4
+    bass b2, 8
+    bass c2, 8
+    bass c2, 8
+    bass g2, 4
+  end
+
+  part :intro_ending do
+    # Drums
+    drum [:kick, :hh], 8
+    drum :hh, 8
+    drum [:snare, :hh], 8
+    drum :hh, 8
+
+    drum [:kick, :hh], 8
+    drum :hh, 8
+    drum [:snare, :hh], 8
+    drum [:kick, :hh], 8
+
+    drum :hh, 16
+    drum :hh, 16
+    drum :hh, 16
+    drum :hh, 16
+    drum [:snare, :hh], 8
+    drum :hh, 8
+
+    drum [:kick, :hh], 8
+    drum [:kick, :hh], 8
+    drum [:snare, :hh], 8
+    drum :ohh, 8
+
+    # Drum break
+    drum [:kick, :hh], 8
+    drum :hh, 8
+    drum [:kick, :hh], 8
+    drum :hh, 8
+    drum [:kick, :hh], 8
+    drum :hh, 8
+    drum [:kick, :hh], 8
+    drum :hh, 8
+
+    drum [:snare, :ooh], 4
+    drum [:snare, :ooh], 4
+    drum :snare, 16
+    drum :snare, 16
+    drum :kick, 16
+    drum :kick, 16
+    drum :snare, 16
+    drum :snare, 16
+    drum [:snare, :ooh], 16
+    drum :snare, 16
+
+    # Bass
+    bass f2, 4
+
+    bass f2, 8
+    bass e2, 8
+    bass f2, 8
+    bass e2, 8
+    bass f2, 8
+
+    bass e3, 4
+    bass c3, 4
+    bass b2, 8
+    bass c2, 8
+    bass c2, 8
+    bass g2, 4
+
+    bass a2, 4
+    bass a2, 4
+    bass a2, 4
+    bass a2, 4
+
+    bass b2, 8
+    bass b2, 8
+    bass b2, 8
+    bass c2, 8
+    bass c2, 8
+    bass c2, 8
+    bass d3, 8
+    bass e3, 8
+  end
+
+  part :pre_chorus do
+    bass :from => :intro
+    drum :from => :intro
+
+    melody a2, 4
+    melody a2, 4
+    melody f3, 8
+    melody g3, 8
+    melody a3, 8
+    melody g3, 4
+    melody f3, 8
+    melody e3, 8
+    melody d3, 4
+    melody c3, 8
+    melody e3, 4
+
+    melody a2, 2
+    melody a2, 8
+    melody g2, 4
+    melody c2, 4
+
+    melody c3, 8
+    melody d3, 8
+    melody e3, 8
+    melody f3, 8
+    melody e3, 8
+    melody d3, 8
+    melody c3, 8
+  end
+
+  repeat :pre_chorus
+
+  part :chorus do
+    melody :from => :pre_chorus
+
+    # Bass
+    2.times do
+      bass f2, 8
+      bass f3, 8
+      bass f2, 8
+      bass f3, 8
+    end
+    bass c2, 8
+    bass c3, 8
+    bass c2, 8
+    bass c3, 8
+
+    bass g2, 8
+    bass g3, 8
+    bass f2, 8
+    bass d2, 8
+
+    2.times do
+      bass a1, 8
+      bass a2, 8
+      bass a1, 8
+      bass a2, 8
+    end
+    bass c1, 8
+    bass c2, 8
+    bass c1, 8
+    bass c2, 8
+
+    bass g1, 8
+    bass g2, 8
+    bass f1, 8
+    bass d2, 8
+
+    # Drums
+    7.times do
+      drum [:kick, :hh], 8
+      drum :hh, 8
+      drum [:snare, :kick, :hh], 8
+      drum :hh, 8
+    end
+    drum :kick, 8
+    drum :hh, 16
+    drum :hh, 16
+    drum [:snare, :kick], 16
+    drum :snare, 16
+    drum [:kick, :ohh], 8
+
+    # Chords
+    chord a3MIN(2), 2, :base => f3
+    chord a3MIN(2), 8, :base => f3
+    chord a3MIN(2), 8, :base => f3
+    chord a3MIN(2), 8, :base => f3
+    chord c3MAJ, 4
+    chord c3MAJ, 4
+    chord c3MAJ, 8
+    chord g3MAJ, 2
+    chord [a3, b3, e4]
+    chord c3MAJ, 4
+    chord c3MAJ, 4
+    chord g3MAJ, 8
+    chord g3MAJ, 8
+    chord g3MAJ, 8, :base => f4
+    chord g3MAJ, 8, :base => e4
+  end
+
+  repeat :chorus
+
+  part :outro do
+    drum :from => :intro
+    bass :from => :intro
+    chord :from => :chorus
+  end
+
+  part :outro_ending do
+    bass :from => :intro
+    chord :from => :chorus
+  end
+end
+
+song.play

data/lib/core_ext/array.rb

@@ -0,0 +1,13 @@
+class Array
+  def sharp
+    map do |element|
+      element + 1
+    end
+  end
+
+  def flat
+    map do |element|
+      element - 1
+    end
+  end
+end

data/lib/core_ext/fixnum.rb

@@ -0,0 +1,8 @@
+class Fixnum
+  def sharp
+    self + 1
+  end
+  def flat
+    self - 1
+  end
+end

data/lib/niki.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../vendor/archaeopteryx/archaeopteryx"
+require 'core_ext/fixnum'
+require 'core_ext/array'
+require 'niki/chords'
+require 'niki/part'
+require 'niki/song'
+
+module Niki
+end

data/lib/niki/chords.rb

@@ -0,0 +1,44 @@
+module Niki
+  module Chords
+
+    (1..5).to_a.each do |octave|
+
+      %w(c d e f g a b).each_with_index do |c, idx|
+        rest = 0
+        if idx > 2
+          rest = 1
+        end
+        base = 24 + (12 * octave) + (idx * 2) - rest
+
+        define_method("#{c}#{octave}") do
+          base
+        end
+
+        define_method("#{c}#{octave}MAJ") do |*args|
+          inversion = args.first || 1
+          case inversion
+          when 1
+            [base, base + 4, base + 7]
+          when 2
+            [base + 4, base + 7, base + 12]
+          when 3
+            [base + 7, base + 12, base + 16]
+          end
+        end
+
+        define_method("#{c}#{octave}MIN") do |*args|
+          inversion = args.first || 1
+          case inversion
+          when 1
+            [base, base + 3, base + 7]
+          when 2
+            [base + 3, base + 7, base + 12]
+          when 3
+            [base + 7, base + 12, base + 15]
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/niki/part.rb

@@ -0,0 +1,69 @@
+module Niki
+  class Part
+    attr_reader :name, :chords, :drums, :basses, :melodies
+
+    include Niki::Chords
+
+    def initialize(name, song, &block)
+      @name = name
+      @song = song
+      @drum_notes = @song.drum_notes
+      @chords = []
+      @drums = []
+      @basses = []
+      @melodies = []
+      self.instance_eval(&block)
+    end
+
+    def chord note, duration = 1, options = {}
+      if note.is_a?(Hash) && note[:from]
+        copy_from_part(note[:from], :chords)
+        return
+      end
+
+      note.push options[:base]
+      @chords << [note, calculate_duration(duration)]
+    end
+
+    def drum note, duration = 1, options = {}
+      if note.is_a?(Hash) && note[:from]
+        copy_from_part(note[:from], :drums)
+        return
+      end
+
+      drum_note = [note].flatten.map do |n|
+        @drum_notes[n]
+      end
+      @drums << [drum_note, calculate_duration(duration)]
+    end
+
+    def bass note = nil, duration = 1, options = {}
+      if note.is_a?(Hash) && note[:from]
+        copy_from_part(note[:from], :basses)
+        return
+      end
+
+      @basses << [[note], calculate_duration(duration)]
+    end
+
+    def melody note = nil, duration = 1, options = {}
+      if note.is_a?(Hash) && note[:from]
+        copy_from_part(note[:from], :melodies)
+        return
+      end
+
+      @melodies << [[note], calculate_duration(duration)]
+    end
+
+    private
+
+    def calculate_duration(duration)
+      1.to_f / ((@song.tempo.to_f/120) * duration/2)
+    end
+
+    def copy_from_part(name, type)
+      part = @song.get_part(name)
+      instance_variable_set(:"@#{type}", part.send(type))
+    end
+  end
+end

data/lib/niki/song.rb

@@ -0,0 +1,81 @@
+module Niki
+  class Song
+    attr_reader :tempo, :drum_notes
+
+    include Niki::Chords
+
+    def initialize(options, &block)
+      @clock = Archaeopteryx::Midi::Clock.new(options[:tempo] || 127)
+
+      @midi = Archaeopteryx::Midi::PracticalRubyProjects::LiveMIDI.new(:clock => @clock )
+
+      @parts = []
+      @channel = {}
+      @drum_notes = {}
+      @tempo = options[:tempo]
+      self.instance_eval &block
+    end
+
+    def channel(instrument, number)
+      @channel[instrument] = number - 1
+    end
+
+    def part(name, &block)
+      raise "#{name} is already defined!" if has_part?(name)
+      @parts << Part.new(name, self, &block)
+    end
+
+    def configure(instrument, &block)
+      case instrument
+      when :drums
+        block.call @drum_notes
+      end
+    end
+
+    def repeat(name, options = {})
+      (options[:times] || 1).times do
+        @parts << get_part(name)
+      end
+    end
+
+    def play
+      @parts.each do |part|
+        [:basses, :chords, :melodies, :drums].map do |instrument_name|
+          Thread.start do
+            play_part(part, instrument_name)
+          end
+        end.map { |thread| thread.join }
+      end
+    end
+
+    def play_part(part, instrument_name)
+      part.send(instrument_name).each do |instrument|
+        notes = [instrument.first].flatten.compact.map do |note|
+          Archaeopteryx::Midi::Note.create(
+            :channel => @channel[instrument_name],
+            :number => note,
+            :duration => instrument.last,
+            :velocity => 127)
+        end
+        notes.each do |note|
+          @midi.note_on(note)
+        end
+        sleep(instrument.last)
+        notes.each do |note|
+          @midi.note_off(note)
+        end
+      end
+    end
+
+    def get_part(name)
+      @parts.detect {|p| p.name == name }
+    end
+
+    private
+
+    def has_part?(name)
+      !!@parts.map(&:name).detect {|part_name| part_name == name }
+    end
+
+  end
+end

data/lib/niki/version.rb

@@ -0,0 +1,3 @@
+module Niki
+  VERSION = "0.0.1"
+end

data/niki.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "niki/version"
+
+Gem::Specification.new do |s|
+  s.name        = "niki"
+  s.version     = Niki::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Josep M. Bach"]
+  s.email       = ["josep.m.bach@gmail.com"]
+  s.homepage    = "http://github.com/txus/niki"
+  s.summary     = %q{A DSL to describe and play structured musical pieces, i.e. songs}
+  s.description = %q{A DSL to describe and play structured musical pieces, i.e. songs}
+
+  s.rubyforge_project = "niki"
+
+  s.add_runtime_dependency 'midilib'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib", "vendor"]
+end

data/vendor/archaeopteryx/archaeopteryx.rb

@@ -0,0 +1,28 @@
+alias :L :lambda
+
+%w{rubygems midilib/sequence midilib/consts}.each {|lib| require lib}
+
+%w{archaeopteryx/core_ext/struct
+   archaeopteryx/core_ext/array
+
+   archaeopteryx/loop
+   archaeopteryx/drum
+   archaeopteryx/rhythm
+   archaeopteryx/mix
+
+   archaeopteryx/live_hacks
+   archaeopteryx/track
+   archaeopteryx/clip
+
+   archaeopteryx/midi/note
+   archaeopteryx/midi/clock
+
+   archaeopteryx/midi/file_output/file_midi
+
+   archaeopteryx/midi/practical_ruby_projects/no_midi_destinations
+   archaeopteryx/midi/practical_ruby_projects/core_midi
+   archaeopteryx/midi/practical_ruby_projects/core_foundation
+   archaeopteryx/midi/practical_ruby_projects/live_midi
+   archaeopteryx/midi/practical_ruby_projects/timer}.each do |archaeopteryx|
+     require File.expand_path(File.dirname(__FILE__)) + "/../#{archaeopteryx}"
+   end

data/vendor/archaeopteryx/clip.rb

@@ -0,0 +1,37 @@
+module Archaeopteryx
+  class Clip
+    attr_accessor :measures
+    def initialize(attributes)
+      @message = Message.create(attributes.merge(:midi_channel => 0,
+                                                 :value => 127))
+      @measures = attributes[:measures]
+    end
+    def notes(measure)
+      []
+    end
+    def messages(measure)
+      0 == measure % @measures ? [@message] : []
+      # if 0 == @relative_measure % @measures
+      #   [@message]
+      # else
+      #   []
+      #   @relative_measure += 1
+      # end
+    end
+    def mutate(measure)
+    end
+    # def choose
+    #   relative_measure = 1
+    #   etc.
+    # end
+    def complete?
+      [true, false][rand(2)]
+      # current_measure == final_measure
+      # BUT! these need to be relative measures in this Clip, not absolute measures in the overall Loop
+      # possible that Loop should be called Engine or some crazy shit
+      # I guess relative_measure is really @current_measure
+    end
+  end
+end
+
+# probably rename this to make it drum-specific

data/vendor/archaeopteryx/core_ext/array.rb

@@ -0,0 +1,11 @@
+class Array
+  def random
+    self[rand(self.size)]
+  end
+end
+
+# the weird thing is, sometimes this method works and sometimes it doesn't. it happens with other
+# libs as well as this one. wtf is going on there? gotta investigate that shit.
+
+# oh fuck I think I know why. I require ActiveSupport in my IRB so I'm assuming Array#rand from
+# AS is part of Ruby itself. ooops.

data/vendor/archaeopteryx/core_ext/struct.rb

@@ -0,0 +1,7 @@
+# this allows you to create Structs and Struct subclasses with pseudo-keyword options hashes
+# rather than with long sequences of unnamed args. written by Michael Fellinger.
+class Struct
+  def self.create(hash)
+    new(*hash.values_at(*members.map{|member| member.to_sym}))
+  end
+end

data/vendor/archaeopteryx/drum.rb

@@ -0,0 +1,24 @@
+module Archaeopteryx
+  class Drum
+    attr_accessor :note, :probabilities, :when, :next, :number_generator
+    def initialize(attributes)
+      %w{note probabilities when next number_generator}.each do |attribute|
+        eval("@#{attribute} = attributes[:#{attribute}]")
+      end
+      @queue = [attributes[:when]]
+      generate
+    end
+    def play?(beat)
+      @when[beat]
+    end
+    def generate
+      beats_on_which_to_play = []
+      @probabilities.each_with_index do |probability, index|
+        beats_on_which_to_play << index if @number_generator[] <= probability
+      end
+      @queue << L{|beat| beats_on_which_to_play.include? beat}
+      @when = @next[@queue]
+    end
+    alias :mutate :generate
+  end
+end

data/vendor/archaeopteryx/live_hacks.rb

@@ -0,0 +1,8 @@
+class Message < Struct.new(:midi_channel, :controller_number, :value)
+end
+
+class TapTempo
+  def midi_channel; 15 ; end
+  def controller_number ; 7 ; end
+  def value ; 127 ; end
+end

data/vendor/archaeopteryx/loop.rb

@@ -0,0 +1,32 @@
+module Archaeopteryx
+  class Loop
+    attr_reader :midi
+    def initialize(attributes)
+      %w{generator
+         measures
+         beats
+         clock
+         midi
+         evil_timer_offset_wtf
+         infinite}.each do |option|
+        eval("@#{option} = attributes[:#{option}]")
+      end
+    end
+    def generate_beats
+      (1..@measures).each do |measure|
+        @generator.mutate(measure)
+        (0..(@beats - 1)).each do |beat|
+          play @generator.notes(beat)
+          @clock.tick
+        end
+      end
+      if @midi.infinite?
+        @midi.timer.at((@clock.start + @clock.time) - @evil_timer_offset_wtf,
+                       &(L{generate_beats}))
+      end
+    end
+    def play(music)
+      music.each {|note| @midi.play(note)}
+    end
+  end
+end

data/vendor/archaeopteryx/midi/clock.rb

@@ -0,0 +1,23 @@
+# get singleton from std lib
+module Archaeopteryx
+  module Midi
+    class Clock
+      attr_reader :time, :interval, :start
+      def initialize(bpm)
+       # assumes 16-step step sequencer, 4/4 beat, etc.
+        self.bpm = bpm
+        @start = Time.now.to_f
+        @time = 0
+      end
+      def bpm=(bpm)
+        seconds_in_a_minute = 60.0
+        beats_in_a_measure = 4.0
+        @interval = seconds_in_a_minute / bpm.to_f / beats_in_a_measure
+      end
+      def tick
+        @time += @interval
+        @time
+      end
+    end
+  end
+end

data/vendor/archaeopteryx/midi/file_output/file_midi.rb

@@ -0,0 +1,44 @@
+# a quick note about FAIL. FileMIDI is actually of the same unspecified superclass as LiveMIDI. both
+# need new, clearer names, but the nonexistent abstract superclass is just a class which takes options
+# for args and has a method called play() which takes a note argument.
+
+include MIDI
+
+# christ this should probably live in some kind of module or something
+
+class FileMIDI
+  attr_accessor :filename
+  def initialize(options)
+    raise :hell unless options.is_a? Hash
+    @filename = options[:filename]
+    @clock = options[:clock]
+    @events = []
+    
+    @sequence = MIDI::Sequence.new
+    @sequence.tracks << (@track = MIDI::Track.new(@sequence))
+    @track.events << Tempo.new(Tempo.bpm_to_mpq(options[:tempo])) if options[:tempo]
+    @track.events << MetaEvent.new(META_SEQ_NAME, options[:name]) if options[:name]
+    
+    # I'm not sure if this is actually necessary (?)
+    @track.events << Controller.new(0, CC_VOLUME, 127)
+    @track.events << ProgramChange.new(0, 1, 0)
+  end
+  def infinite?
+    false
+  end
+  def midilib_delta
+    # figuring this shit out was an epic fucking nightmare and to be honest I still have no idea why it works
+    ((@sequence.note_to_delta("16th") / @clock.interval) * @clock.time).to_i
+  end
+  def play(note)
+    @track.merge [NoteOnEvent.new(note.channel,
+                                  note.number,
+                                  note.velocity,
+                                  midilib_delta)]
+  end
+  def write
+    File.open(@filename, 'wb') do |file|
+      @sequence.write(file)
+    end
+  end
+end

data/vendor/archaeopteryx/midi/note.rb

@@ -0,0 +1,9 @@
+module Archaeopteryx
+  module Midi
+    class Note < Struct.new(:channel, :number, :duration, :velocity)
+      def to_code
+        "Note.new(#{self.channel}, #{self.number}, #{self.duration}, #{self.velocity})"
+      end
+    end
+  end
+end

data/vendor/archaeopteryx/midi/practical_ruby_projects/core_foundation.rb

@@ -0,0 +1,7 @@
+module CoreFoundation
+  require 'dl/import'
+  extend DL::Importable
+  dlload '/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation'
+
+  extern "void * CFStringCreateWithCString (void *, char *, int)"
+end

data/vendor/archaeopteryx/midi/practical_ruby_projects/core_midi.rb

@@ -0,0 +1,16 @@
+module CoreMIDI
+  require 'dl/import'
+  extend DL::Importable
+
+  dlload '/System/Library/Frameworks/CoreMIDI.framework/Versions/Current/CoreMIDI'
+
+  extern "int MIDIClientCreate(void *, void *, void *, void *)"
+  extern "int MIDIClientDispose(void *)"
+  extern "int MIDIGetNumberOfDestinations()"
+  extern "void * MIDIGetDestination(int)"
+  extern "int MIDIOutputPortCreate(void *, void *, void *)"
+  extern "void * MIDIPacketListInit(void *)"
+  # http://groups.google.com/group/ruby-midi/browse_thread/thread/85de6ea9373c57a4
+  extern "void * MIDIPacketListAdd(void *, int, void *, int, int, void*)"
+  extern "int MIDISend(void *, void *, void *)"
+end

data/vendor/archaeopteryx/midi/practical_ruby_projects/live_midi.rb

@@ -0,0 +1,117 @@
+module Archaeopteryx
+  module Midi
+    module PracticalRubyProjects
+      class LiveMIDI
+
+        # this object is a gateway between the Objective-C extern-ed functions from the CoreMIDI API
+        # and good old-fashioned Ruby. As such some of the code gets weird. This is nearly all from
+        # Topher Cyll's wicked book referenced in the MIT license file (practical_ruby_projects.rb),
+        # but with some refactoring and modification.
+
+        include CoreMIDI
+        include CoreFoundation
+
+        attr_reader :interval # this is a totally misleading variable name! real interval lives on Clock
+        attr_reader :timer
+        ON = 0x90
+        OFF = 0x80
+        PC = 0xC0 # program change, I think; not actually useable in Propellerhead Reason v3
+        CONTROLLER = 0xB0 # arbitrary controller message
+
+        def infinite?
+          true
+        end
+
+        def to_code
+          "LiveMIDI.new(:clock => @clock = attributes[:clock], :logging => false)"
+        end
+
+        def initialize(options)
+          @clock = options[:clock]
+          @logging = options[:logging]
+          @midi_destination = options[:midi_destination] || 0
+          if @logging
+            puts <<LOG_PLAYBACK
+require 'lib/archaeopteryx'
+@midi = #{self.to_code}
+LOG_PLAYBACK
+          end
+          @interval = 60.0/120 # this is just a polling interval for the Thread - not a musical one
+          @timer = Timer.new(@interval/1000)
+          open
+        end
+
+        def play(midi_note, on_time = @clock.time)
+          if @logging
+            puts "@midi.play(#{midi_note.to_code}, #{on_time})"
+          end
+          on_time += @clock.start
+          @timer.at(on_time) {note_on(midi_note)}
+          @timer.at(on_time + midi_note.duration) {note_off(midi_note)}
+        end
+
+        def send(message)
+          send_controller_message(message.midi_channel, message.controller_number, message.value)
+        end
+        def send_controller_message(midi_channel, controller_number, value, on_time = @clock.time)
+          on_time += @clock.start
+          puts "scheduling #{controller_number} for #{on_time}" if @logging
+          @timer.at(on_time) do
+            control(midi_channel, controller_number, value)
+          end
+        end
+
+        def open
+          client_name = CoreFoundation.cFStringCreateWithCString(nil, "RubyMIDI", 0)
+          @client = DL::PtrData.new(nil)
+          CoreMIDI.mIDIClientCreate(client_name, nil, nil, @client.ref)
+
+          port_name = CoreFoundation.cFStringCreateWithCString(nil, "Output", 0)
+          @outport = DL::PtrData.new(nil)
+          CoreMIDI.mIDIOutputPortCreate(@client, port_name, @outport.ref)
+
+          number_of_destinations = CoreMIDI.mIDIGetNumberOfDestinations()
+          raise NoMIDIDestinations if number_of_destinations < 1
+          @destination = CoreMIDI.mIDIGetDestination(@midi_destination)
+        end
+
+        def close
+          CoreMIDI.mIDIClientDispose(@client)
+        end
+
+        def clear
+          @timer.flush
+        end
+
+        def message(*args)
+          format = "C" * args.size
+          bytes = args.pack(format).to_ptr
+          packet_list = DL.malloc(256)
+          packet_ptr = CoreMIDI.mIDIPacketListInit(packet_list)
+          # http://groups.google.com/group/ruby-midi/browse_thread/thread/85de6ea9373c57a4
+          packet_ptr = CoreMIDI.mIDIPacketListAdd(packet_list, 256, packet_ptr, 0, args.size, bytes)
+          CoreMIDI.mIDISend(@outport, @destination, packet_list)
+        end
+
+        def note_on(midi_note)
+          message(ON | midi_note.channel, midi_note.number, midi_note.velocity)
+        end
+
+        def note_off(midi_note)
+          message(OFF | midi_note.channel, midi_note.number, midi_note.velocity)
+        end
+
+        def program_change(channel, preset)
+          message(PC | channel, preset)
+        end
+
+        def pulse(channel, controller_id, value)
+          # puts "sending now: #{Time.now.to_f}" if @logging
+          # puts "#{[channel, controller_id, value].inspect}" if @logging
+          message(CONTROLLER | channel, controller_id, value)
+        end
+        alias :control :pulse
+      end
+    end
+  end
+end

data/vendor/archaeopteryx/midi/practical_ruby_projects/no_midi_destinations.rb

@@ -0,0 +1,8 @@
+module Archaeopteryx
+  module Midi
+    module PracticalRubyProjects
+      class NoMIDIDestinations < Exception
+      end
+    end
+  end
+end

data/vendor/archaeopteryx/midi/practical_ruby_projects/practical_ruby_projects.rb

@@ -0,0 +1,30 @@
+module Archaeopteryx
+  module Midi
+    # most of this code comes from "Practical Ruby Projects" by Topher Cyll, published by
+    # APress, which is a pretty bad-ass book. here's the license:
+    # 
+    # The MIT License
+    # 
+    # Copyright (c) 2006, 2007 Topher Cyll
+    # 
+    # 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.
+    module PracticalRubyProjects
+    end
+  end
+end

data/vendor/archaeopteryx/midi/practical_ruby_projects/timer.rb

@@ -0,0 +1,35 @@
+module Archaeopteryx
+  module Midi
+    module PracticalRubyProjects
+      class Timer
+        def initialize(resolution)
+          @resolution = resolution
+          @queue = []
+
+          Thread.new do
+            while true
+              dispatch
+              sleep(@resolution)
+            end
+          end
+        end
+        
+        def flush
+          @queue = []
+        end
+
+        def at(time, &block)
+          time = time.to_f if time.kind_of?(Time)
+          @queue.push [time, block]
+        end
+
+        private
+        def dispatch
+          now = Time.now.to_f
+          ready, @queue = @queue.partition {|time, proc| time <= now}
+          ready.each {|time, proc| proc.call(time)}
+        end
+      end
+    end
+  end
+end

data/vendor/archaeopteryx/mix.rb

@@ -0,0 +1,27 @@
+module Archaeopteryx
+  class Mix
+    attr_accessor :rhythms
+    def initialize(attributes)
+      @rhythms = attributes[:rhythms]
+    end
+    def notes(beat)
+      notes = []
+      @rhythms.each do |rhythm|
+        notes << rhythm.notes(beat)
+      end
+      notes.flatten
+    end
+    def messages(measure) # obviously these should be refactored to inject()s
+      messages = []
+      @rhythms.each do |rhythm|
+        messages << rhythm.messages(measure)
+      end
+      messages.flatten
+    end
+    def mutate(measure)
+      @rhythms.each {|rhythm| rhythm.mutate(measure)}
+    end
+  end
+end
+
+# Mix nearly identical to Rhythm

data/vendor/archaeopteryx/rhythm.rb

@@ -0,0 +1,29 @@
+module Archaeopteryx
+  class Rhythm
+    def initialize(attributes)
+      @mutation = attributes[:mutation]
+      @drumfile = attributes[:drumfile]
+      reload
+    end
+    def reload
+      puts "\a" # flash the screen ; only valid on my box and similarly configured machines!
+      @drums = eval(File.read(@drumfile))
+    end
+    def notes(beat)
+      (@drums.collect do |drum|
+        drum.note if drum.play? beat
+      end).compact
+    end
+    def messages(beat)
+      []
+    end
+    def mutate(measure)
+      if @mutation[measure]
+        reload # reloading can kill mutations!
+        @drums.each {|drum| drum.mutate}
+      end
+    end
+  end
+end
+
+# probably rename this to make it drum-specific

data/vendor/archaeopteryx/track.rb

@@ -0,0 +1,16 @@
+module Archaeopteryx
+  class Track < Mix
+    attr_accessor :current
+    def initialize(attributes)
+      @rhythms = attributes[:rhythms]
+      @measure = 1
+      new_clip
+    end
+    def new_clip
+      @current = @rhythms.random
+    end
+    def messages(measure)
+      @current.messages(measure)
+    end
+  end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: niki
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Josep M. Bach
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: midilib
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: A DSL to describe and play structured musical pieces, i.e. songs
+email: 
+- josep.m.bach@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- Readme.md
+- examples/my_song.rb
+- examples/my_song.rns
+- lib/core_ext/array.rb
+- lib/core_ext/fixnum.rb
+- lib/niki.rb
+- lib/niki/chords.rb
+- lib/niki/part.rb
+- lib/niki/song.rb
+- lib/niki/version.rb
+- niki.gemspec
+- vendor/archaeopteryx/archaeopteryx.rb
+- vendor/archaeopteryx/clip.rb
+- vendor/archaeopteryx/core_ext/array.rb
+- vendor/archaeopteryx/core_ext/struct.rb
+- vendor/archaeopteryx/drum.rb
+- vendor/archaeopteryx/live_hacks.rb
+- vendor/archaeopteryx/loop.rb
+- vendor/archaeopteryx/midi/clock.rb
+- vendor/archaeopteryx/midi/file_output/file_midi.rb
+- vendor/archaeopteryx/midi/note.rb
+- vendor/archaeopteryx/midi/practical_ruby_projects/core_foundation.rb
+- vendor/archaeopteryx/midi/practical_ruby_projects/core_midi.rb
+- vendor/archaeopteryx/midi/practical_ruby_projects/live_midi.rb
+- vendor/archaeopteryx/midi/practical_ruby_projects/no_midi_destinations.rb
+- vendor/archaeopteryx/midi/practical_ruby_projects/practical_ruby_projects.rb
+- vendor/archaeopteryx/midi/practical_ruby_projects/timer.rb
+- vendor/archaeopteryx/mix.rb
+- vendor/archaeopteryx/rhythm.rb
+- vendor/archaeopteryx/track.rb
+homepage: http://github.com/txus/niki
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+- vendor
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: niki
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A DSL to describe and play structured musical pieces, i.e. songs
+test_files: []
+