rsynth 0.0.1.alpha0

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/setup"
+Bundler::GemHelper.install_tasks

data/lib/rsynth/combiner.rb

@@ -0,0 +1,18 @@
+module RSynth
+  class Combiner
+    include RSynth::Functions
+    attr_accessor :a, :b
+
+    def initialize(a, b, proc=nil)
+      proc = Proc.new{|a,b| yield a, b} if block_given?
+      raise 'No block or proc given' if proc.nil?
+      @proc = proc
+      @a = a
+      @b = b
+    end
+
+    def value_at(time)
+      @proc.call(@a.value_at(time), @b.value_at(time))
+    end
+  end
+end

data/lib/rsynth/functions.rb

@@ -0,0 +1,91 @@
+module RSynth
+  module Functions
+    def combine(type, other)
+      case type
+        when :add, :plus
+          RSynth::Combiner.new(self, other) { |a, b| a + b }
+        when :sub, :subtract, :minus
+          RSynth::Combiner.new(self, other) { |a, b| a - b }
+        when :div, :divide
+          RSynth::Combiner.new(self, other) { |a, b| a / b }
+        when :mul, :multiply, :times
+          RSynth::Combiner.new(self, other) { |a, b| a * b }
+        when :exp, :exponent, :pow, :power
+          RSynth::Combiner.new(self, other) { |a, b| a ** b }
+        when :mod, :modulo, :rem, :remainder
+          RSynth::Combiner.new(self, other) { |a, b| a % b }
+        when :mix
+          RSynth::Combiner.new(self, other) do |a, b|
+            # Normalise between 0 and 1
+            a = (a + 1) / 2
+            b = (b + 1) / 2
+            z = (a < 0.5 and b < 0.5)? 2*a*b : 2*(a+b) - (2*a*b) - 1
+            # Convert back
+            (z * 2) - 1
+          end
+        else
+          raise "Unknown combiner type: #{type}"
+      end
+    end
+
+    def phase_shift(offset=nil)
+      offset = Proc.new{ |time| yield time } if block_given?
+      raise 'No offset or block given' if offset.nil?
+      RSynth::PhaseShifer.new(self, offset)
+    end
+
+    # won't work for numeric or proc (unless we override but there'd be a huge performance hit)
+    def +(other)
+      combine(:add, other)
+    end
+
+    def -(other)
+      combine(:sub, other)
+    end
+
+    def /(other)
+      combine(:div, other)
+    end
+
+    def *(other)
+      combine(:mul, other)
+    end
+
+    def **(other)
+      combine(:exp, other)
+    end
+
+    def %(other)
+      combine(:mod, other)
+    end
+
+    def &(other)
+      combine(:mix, other)
+    end
+
+    def <<(offset)
+      phase_shift(-offset)
+    end
+
+    def >>(offset)
+      phase_shift(offset)
+    end
+  end
+end
+
+class Proc
+  include RSynth::Functions
+
+  def value_at(time)
+    self.call(time)
+  end
+end
+
+# Add mixins to int and float :O
+class Numeric
+  include RSynth::Functions
+
+  def value_at(time)
+    self
+  end
+end

data/lib/rsynth/notes.rb

@@ -0,0 +1,101 @@
+module RSynth
+  class Note
+    ChromaticInterval = 2**(1.0/12)
+    ChromaticNotes = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
+    IntervalMap = [
+        %w(perfect_unison unison P1 diminished_second d2),
+        %w(minor_second m2 augmented_unison A1 semitone S),
+        %w(major_second M2 diminished_third d3 tone whole_tone T),
+        %w(minor_third m3 augmented_second A2),
+        %w(major_third M3 diminished_fourth d4),
+        %w(perfect_fourth fourth P4 augmented_third A3),
+        %w(tritone diminished_fifth d5 augmented_fourth A4 TT),
+        %w(perfect_fifth fifth P5 diminished_sixth d6),
+        %w(minor_sixth m6 augmented_fifth A5),
+        %w(major_sixth M6 diminished_seventh d7),
+        %w(minor_seventh m7 augmented_sixth A6),
+        %w(major_seventh M7 diminished_octave d8),
+        %w(perfect_octave octave P8 augmented_seventh A7)
+    ]
+    include RSynth::Functions
+
+    attr_reader :note, :octave, :freq
+
+    def initialize(note, octave)
+      @note = note.upcase
+      @octave = octave
+      raise "Invalid note value: #{note}" unless ChromaticNotes.include?(@note)
+      raise "Invalid octave: #{octave}, must be >= 0" if octave < 0
+
+      # Calculate frequency (notes are relative to A4 (440Hz))
+      rn = -(ChromaticNotes.index('A') - ChromaticNotes.index(@note))
+      ro = @octave - 4
+      steps = (ro * 12) + rn
+      @freq = 440*(ChromaticInterval**steps)
+    end
+
+    def value_at(time)
+      @freq
+    end
+
+    def next
+      transpose(1)
+    end
+
+    def previous
+      transpose(-1)
+    end
+
+    def previous_octave
+      transpose(-12)
+    end
+
+    def transpose(count=1)
+      oct = @octave
+      ni = ChromaticNotes.index(@note)
+      ni += count
+      while ni >= ChromaticNotes.length
+        oct += 1
+        ni -= ChromaticNotes.length
+      end
+      while ni < 0
+        oct -= 1
+        ni += ChromaticNotes.length
+      end
+      Note.retrieve(ChromaticNotes[ni], oct)
+    end
+
+    def to_s
+      "#@note#@octave"
+    end
+
+    def <=>(note)
+      os = @octave <=> note.octave
+      return os unless os == 0
+      ChromaticNotes.index(@note) <=> ChromaticNotes.index(note.note)
+    end
+
+    def self.retrieve(note, octave)
+      note.upcase!
+      name = "#{note.sub('#', 'Sharp')}#{octave}"
+      RSynth.const_set(name, Note.new(note, octave)) unless RSynth.const_defined?(name)
+      RSynth.const_get(name)
+    end
+
+    # Define the interval methods...
+    IntervalMap.each_with_index do |names, interval|
+      names.each do |name|
+        define_method(name.to_sym) do
+          self.transpose(interval)
+        end
+      end
+    end
+  end
+
+  # Define the chromatic scale at octaves 0-9
+  9.times do |o|
+    Note::ChromaticNotes.each do |n|
+      Note.retrieve(n, o)
+    end
+  end
+end

data/lib/rsynth/oscillator.rb

@@ -0,0 +1,32 @@
+module RSynth
+  class Oscillator
+    PI2 = Math::PI*2
+    TableLength = 1024
+    SinTable = TableLength.times.map{|i| Math.sin((PI2 * i) / TableLength)}
+    CosTable = TableLength.times.map{|i| Math.cos((PI2 * i) / TableLength)}
+
+    include RSynth::Functions
+
+    attr_accessor :freq, :func
+
+    def initialize(func, freq)
+      @freq = freq
+      @func = func
+      @phase = 0
+    end
+
+    def value_at(time)
+      f = @freq.value_at(time)
+      i = @phase
+      @phase = (@phase + (f.to_f / RSynth::SampleRate)) % 1.0
+      case @func
+        when :sin, :sine then SinTable[(i*TableLength).to_i]
+        when :cos, :cosine then CosTable[(i*TableLength).to_i]
+        when :sq, :square then i <= 0.5? 1: -1
+        when :tri, :triangle then i <= 0.25? (i * 4): i <= 0.5? (1 - (i - 0.25) * 4): i <= 0.75? (0 - (i - 0.5) * 4): (i - 0.75) * 4 - 1
+        when :saw, :sawtooth then i * 2 - 1
+        else @func.value_at(@phase)
+      end
+    end
+  end
+end

data/lib/rsynth/phase_shifter.rb

@@ -0,0 +1,17 @@
+module RSynth
+  class PhaseShifter
+    include RSynth::Functions
+    attr_accessor :source, :offset
+
+    def initialize(source, offset=nil)
+      offset = Proc.new {|time| yield time} if block_given?
+      raise 'No offset or block defined' if offset.nil?
+      @source = source
+      @offset = offset
+    end
+
+    def value_at(time)
+      @source.value_at(time + @offset.value_at(time))
+    end
+  end
+end

data/lib/rsynth/pipe/pipeline.rb

@@ -0,0 +1,84 @@
+module RSynth
+  module Pipe
+    class Pipeline
+      NumBuffers = 2 # Number of buffers we keep in our ring buffer
+      FramesPerBuffer = 512 # How many bytes per buffer (higher is higher latency, obviously...)
+
+      attr_accessor :sequence, :source
+      attr_reader :time
+
+      def initialize(source, *sequence)
+        source = Proc.new { |time| yield time } if block_given?
+        raise 'No source or block given' if source.nil?
+        @sequence = sequence || []
+        @source = source
+        @stopped = true
+      end
+
+      def start(time=Float::INFINITY)
+        return unless @stopped
+        @stopped = false
+        @length = time
+        Thread.new {generate}
+      end
+
+      def stop
+        @stopped = true
+      end
+
+      def restart
+        stop
+        start
+      end
+
+      def consume(sequence)
+        sidx = @sequence.index(sequence) || @sequence.length
+        bidx = @seqpos[sidx] || 0
+        @generated[bidx]
+      end
+
+      def consumed(sequence)
+        sidx = @sequence.index(sequence) || @sequence.length
+        bidx = @seqpos[sidx] || 0
+        @seqpos[sidx] = bidx + 1 # increment this sequences buffer index entry...
+
+        # If all sequences have consumed the bottom buffer, release it
+        if @seqpos.all?{|s| s > 0}
+          @buffers.push(@generated.shift)
+          @seqpos.map!{|i| i - 1}
+          @time += FramesPerBuffer * RSynth::TimeStep
+        end
+      end
+
+      def generate
+        @time = 0
+        @generate_time = 0
+        timePerLoop = FramesPerBuffer * RSynth::TimeStep
+        @buffers = 10.times.map{Array.new(FramesPerBuffer)}
+        @generated = []
+        @seqpos = @sequence.length.times.map{0}
+        @sequence.each { |s| s.start(self) }
+        while not @stopped
+          if @generate_time < @length
+            sleep(RSynth::TimeStep) while (@buffers.length == 0 or @generated.length >= NumBuffers) and not @stopped
+            buf = @buffers.shift
+            len = @generate_time + timePerLoop > @length ? (@length - @generate_time) / RSynth::TimeStep : FramesPerBuffer
+            len.times do |i|
+              buf[i] = @source.value_at(@generate_time)
+              @generate_time += RSynth::TimeStep
+            end
+            (FramesPerBuffer - len).times do |i|
+              buf[i] = 0
+            end
+            @generated << buf
+          end
+        end
+        @sequence.each{ |s| s.stop }
+      end
+
+      def to_s
+        "RSynth::Pipe::Pipeline source=#{@source},seq=#{@sequence}"
+      end
+    end
+  end
+end

data/lib/rsynth/pipe/portaudio.rb

@@ -0,0 +1,93 @@
+require 'ffi-portaudio'
+
+module RSynth
+  module Pipe
+    class PortAudio
+      include ::FFI::PortAudio
+
+      def initialize
+        wrap_call('initialise portaudio') { | | API.Pa_Initialize() }
+        @buf = FFI::Buffer.new(:float, RSynth::Pipe::Pipeline::FramesPerBuffer, true) # Create our native buffer
+      end
+
+      def start(pipeline)
+        @source = pipeline
+        open_stream
+      end
+
+      def stop
+        close_stream
+        @source = nil
+      end
+
+      private
+      def process input, output, frame_count, time_info, status_flags, user_data
+        n = @source.consume(self)
+        return :pcComplete if n.nil?
+        output.write_array_of_float(n)
+        @source.consumed(self)
+        :paContinue
+      end
+
+      def open_stream
+        close_stream unless @stream.nil?
+        # Get the audio host
+        info = wrap_call('get default audio host') do | |
+          return idx if error?(idx = API.Pa_GetDefaultHostApi())
+          API.Pa_GetHostApiInfo(idx)
+        end
+
+        # Get the default device
+        inIdx = info[:defaultInputDevice] # Todo: add sampling for luls
+        outIdx = info[:defaultOutputDevice]
+        outDev = wrap_call 'get device info' do | |
+          API.Pa_GetDeviceInfo(outIdx)
+        end
+
+        # Create parameters for the output stream
+        outopts = API::PaStreamParameters.new
+        outopts[:device] = outIdx
+        outopts[:channelCount] = RSynth::Channels
+        outopts[:sampleFormat] = API::Float32
+        outopts[:suggestedLatency] = outDev[:defaultHighOutputLatency]
+        outopts[:hostApiSpecificStreamInfo] = nil
+
+        @stream = FFI::Buffer.new :pointer
+        @callback = method(:process)
+        wrap_call('open output stream') do | |
+          API.Pa_OpenStream(
+              @stream, # Stream
+              nil, # Input options
+              outopts, # Output options
+              RSynth::SampleRate, # the sample rate
+              RSynth::Pipe::Pipeline::FramesPerBuffer, # frames per buffer
+              API::PrimeOutputBuffersUsingStreamCallback, # flags
+              @callback, # Callback
+              nil # User data
+          )
+        end
+
+        # Start the stream playing
+        wrap_call('starting output stream') do | |
+          API.Pa_StartStream @stream.read_pointer
+        end
+      end
+
+      def close_stream
+        return if @stream.nil?
+        API.Pa_CloseStream(@stream.read_pointer)
+        @stream = nil
+      end
+
+      def error?(val)
+        (Symbol === val and val != :paNoError) or (Integer === val and val < 0)
+      end
+
+      def wrap_call(msg, &block)
+        ret = yield block
+        raise "Failed to #{msg}: #{API.Pa_GetErrorText(ret)}" if error?(ret)
+        return ret
+      end
+    end
+  end
+end

data/lib/rsynth/rsynth.rb

@@ -0,0 +1,14 @@
+require_relative 'pipe/pipeline'
+require_relative 'pipe/portaudio'
+require_relative 'functions'
+require_relative 'combiner'
+require_relative 'phase_shifter'
+require_relative 'oscillator'
+require_relative 'notes'
+require_relative 'scales'
+
+module RSynth
+  SampleRate = 22050
+  TimeStep = 1.0/SampleRate
+  Channels = 1
+end

data/lib/rsynth/scales.rb

@@ -0,0 +1,41 @@
+module RSynth
+  class Note
+    # Add some methods to the note class :O
+    def major_scale
+      DiatonicScale.new(self, :ionian)
+    end
+  end
+
+  # A diatonic scale :O
+  class DiatonicScale < Array
+    Degrees = %w(tonic supertonic mediant subdominant dominant submediant leading_tone octave).map(&:to_sym)
+    Modes = %w(ionian dorian phyrgian lydian aeolian locrian).map(&:to_sym)
+    Pattern = %w(2 2 1 2 2 2 1).map(&:to_i)
+
+    def initialize(key, mode)
+      @key = key
+      @mode = mode
+
+      # Define degrees...
+      pat = Pattern.rotate(Modes.index(mode))
+      semitones = 0
+      Degrees.each_with_index do |name, i|
+        idx = Degrees.index(name)
+        self << @key.transpose(pat.take(idx).inject(:+) || 0)
+        semitones += pat[i] unless i >= pat.length
+      end
+    end
+
+    Modes.each do |name|
+      define_method name do
+        DiatonicScale.new(@key, name)
+      end
+    end
+
+    Degrees.each_with_index do |name, i|
+      define_method name do
+        self[i]
+      end
+    end
+  end
+end

data/lib/rsynth/version.rb

@@ -0,0 +1,3 @@
+module RSynth
+  VERSION = '0.0.1.alpha0'
+end

data/rsynth.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'rsynth/version'
+
+Gem::Specification.new do |s|
+  s.name        = "rsynth"
+  s.version     = RSynth::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = %w(James Lawrence)
+  s.email       = %w(james@kukee.co.uk)
+
+  s.summary = "Rsynth aims to be a simple to use audio synthesis library for use in ruby"
+
+  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) } # Stolen from github gem, uses git to list files, very nice!
+  s.require_paths = %w(lib)
+
+  s.add_dependency "ffi-portaudio", "~>0.1"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~>1.3.1"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: rsynth
+version: !ruby/object:Gem::Version
+  version: 0.0.1.alpha0
+  prerelease: 6
+platform: ruby
+authors:
+- James
+- Lawrence
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-portaudio
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+description: 
+email:
+- james@kukee.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Rakefile
+- lib/rsynth/combiner.rb
+- lib/rsynth/functions.rb
+- lib/rsynth/notes.rb
+- lib/rsynth/oscillator.rb
+- lib/rsynth/phase_shifter.rb
+- lib/rsynth/pipe/pipeline.rb
+- lib/rsynth/pipe/portaudio.rb
+- lib/rsynth/rsynth.rb
+- lib/rsynth/scales.rb
+- lib/rsynth/version.rb
+- rsynth.gemspec
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rsynth aims to be a simple to use audio synthesis library for use in ruby
+test_files: []