spcore 0.1.0

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.rdoc
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,10 @@
+Gemfile.lock
+
+# Gem artifacts
+pkg/
+vendor/cache/*.gem
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+

data/.yardopts

@@ -0,0 +1 @@
+--markup rdoc --title "spcore Documentation" --protected

data/ChangeLog.rdoc

@@ -0,0 +1,10 @@
+=== 0.1.0 / 2013-02-04
+
+* Initial release:
+** Delay line
+** Biquad filters
+** Envelope detector
+** Conversion from dB-linear and linear-dB
+** Linear interpolation
+** Oscillator with selectable wave type (sine, square, triangle, sawtooth)
+

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 James Tunnell
+
+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.rdoc

@@ -0,0 +1,34 @@
+= spcore
+
+* {Homepage}[https://rubygems.org/gems/spcore]
+* {Documentation}[http://rubydoc.info/gems/spcore/frames]
+* {Email}[mailto:jamestunnell at lavabit.com]
+
+== Description
+
+Contains core signal processing functions. 
+
+== Features
+
+Delay line
+Biquad filters
+Envelope detector
+Conversion from dB-linear and linear-dB
+Linear interpolation
+Oscillator with selectable wave type (sine, square, triangle, sawtooth)
+
+== Examples
+
+  require 'spcore'
+
+== Requirements
+
+== Install
+
+  $ gem install spcore
+
+== Copyright
+
+Copyright (c) 2013 James Tunnell
+
+See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard
+
+require "bundler/gem_tasks"

data/lib/spcore.rb

@@ -0,0 +1,19 @@
+require 'hashmake'
+require 'spcore/version'
+
+require 'spcore/core/limiters'
+require 'spcore/core/constants'
+
+require 'spcore/lib/interpolation'
+require 'spcore/lib/circular_buffer'
+require 'spcore/lib/delay_line'
+require 'spcore/lib/gain'
+require 'spcore/lib/oscillator'
+require 'spcore/lib/biquad_filter'
+require 'spcore/lib/cookbook_allpass_filter'
+require 'spcore/lib/cookbook_bandpass_filter'
+require 'spcore/lib/cookbook_highpass_filter'
+require 'spcore/lib/cookbook_lowpass_filter'
+require 'spcore/lib/cookbook_notch_filter'
+require 'spcore/lib/envelope_detector'
+require 'spcore/lib/saturation'

data/lib/spcore/core/constants.rb

@@ -0,0 +1,4 @@
+module SPCore
+  TWO_PI = Math::PI * 2.0
+  NEG_PI = -Math::PI
+end

data/lib/spcore/core/limiters.rb

@@ -0,0 +1,51 @@
+module SPCore
+class Limiters
+  def self.make_no_limiter
+    return lambda do |input|
+      return input
+    end
+  end
+    
+  def self.make_range_limiter range
+    return lambda do |input|
+      if input < range.first
+        return range.first
+      elsif input > range.last
+        return range.last
+      else
+        return input
+      end
+    end
+  end
+
+  def self.make_upper_limiter limit
+    return lambda do |input|
+      if input > limit
+        return limit
+      else
+        return input
+      end
+    end
+  end
+
+  def self.make_lower_limiter limit
+    return lambda do |input|
+      if input < limit
+        return limit
+      else
+        return input
+      end
+    end
+  end
+  
+  def self.make_enum_limiter good_values
+    return lambda do |input, current|
+      if good_values.include?(input)
+        return input
+      else
+        return current
+      end
+    end
+  end
+end
+end

data/lib/spcore/lib/biquad_filter.rb

@@ -0,0 +1,72 @@
+module SPCore
+
+# Based on the "simple implementation of Biquad filters" by Tom St Denis,
+# which is based on the work "Cookbook formulae for audio EQ biquad filter
+# coefficients" by Robert Bristow-Johnson, pbjrbj@viconet.com  a.k.a.
+# robert@audioheads.com. Available on the web at
+# http://www.smartelectronix.com/musicdsp/text/filters005.txt
+class BiquadFilter
+
+  # used in subclasses to calculate IIR filter coefficients
+  LN_2 = Math::log(2)
+
+  # this holds the data required to update samples thru a filter
+  Struct.new("BiquadState", :b0, :b1, :b2, :a0, :a1, :a2, :x1, :x2, :y1, :y2)
+
+  def initialize sample_rate
+    @sample_rate = sample_rate
+    @biquad = Struct::BiquadState.new(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0)
+    @critical_freq = 0.0
+    @bandwidth = 0.0
+  end
+
+  def set_critical_freq_and_bw critical_freq, bandwidth
+    raise NotImplementedError, "set_critical_freq_and_bW should be implemented in the derived class!"
+  end
+  
+  def critical_freq= critical_freq
+    set_critical_freq_and_bw(critical_freq, @bandwidth);
+  end
+
+  def bandwidth= bandwidth
+    set_critical_freq_and_bw(@critical_freq, bandwidth);
+  end
+  
+  # Calculate biquad output using Direct Form I:
+  #
+  # y[n] = (b0/a0)*x[n] + (b1/a0)*x[n-1] + (b2/a0)*x[n-2]
+  #                     - (a1/a0)*y[n-1] - (a2/a0)*y[n-2]
+  #
+  # Note: coefficients are already divided by a0 when they 
+  # are calculated. So that step is left out during processing.
+  #
+  def process_sample sample
+    # compute result
+    result = @biquad.b0 * sample + @biquad.b1 * @biquad.x1 + @biquad.b2 * @biquad.x2 -
+        @biquad.a1 * @biquad.y1 - @biquad.a2 * @biquad.y2;
+
+    # shift x1 to x2, sample to x1
+    @biquad.x2 = @biquad.x1;
+    @biquad.x1 = sample;
+
+    # shift y1 to y2, result to y1
+    @biquad.y2 = @biquad.y1;
+    @biquad.y1 = result;
+
+    return result
+  end
+
+  def get_freq_magnitude_response test_freq
+    # Method for determining freq magnitude response is from:
+    # http://rs-met.com/documents/dsp/BasicDigitalFilters.pdf
+    omega = 2.0 * Math::PI * test_freq / @sample_rate
+    b0, b1, b2 = @biquad.b0, @biquad.b1, @biquad.b2
+    a0, a1, a2 = 1, @biquad.a1, @biquad.a2
+    b = (b0**2) + (b1**2) + (b2**2) + (2 * (b0 * b1 + b1 * b2) * Math::cos(omega)) + (2 * b0 * b2 * Math::cos(2 * omega))
+    a = (a0**2) + (a1**2) + (a2**2) + (2 * (a0 * a1 + a1 * a2) * Math::cos(omega)) + (2 * a0 * a2 * Math::cos(2 * omega))
+    return Math::sqrt(b/a)
+  end
+
+end
+
+end

data/lib/spcore/lib/circular_buffer.rb

@@ -0,0 +1,148 @@
+module SPCore
+class CircularBuffer
+  
+  attr_accessor :fifo, :override_when_full
+  attr_reader :fill_count
+  
+  def initialize size, opts = {}
+    
+    opts = { :fifo => true, :override_when_full => true }.merge opts
+    
+    @buffer = Array.new(size)
+    @oldest = 0;
+    @newest = 0;
+    @fill_count = 0;
+
+    @fifo = opts[:fifo]
+    @override_when_full = opts[:override_when_full]
+  end
+  
+  def size
+    return @buffer.count
+  end
+  
+  def empty?
+    return @fill_count == 0
+  end
+  
+  def full?
+    return (@fill_count == size)
+  end
+
+  def resize size
+    rv = false
+    if(size != @buffer.count)
+      rv = true
+      @buffer = Array.new(size)
+      @oldest = 0
+      @newest = 0
+      @fill_count = 0
+    end
+    return rv
+  end
+  
+  def to_ary
+    if empty?
+      return []
+    end
+
+    # newest index is actually @newest - 1
+    newest_idx = @newest - 1;
+    if(newest_idx < 0)
+      newest_idx += @buffer.count;
+    end
+
+    if newest_idx >= @oldest
+      return @buffer[@oldest..newest_idx]
+    else
+      return @buffer[@oldest...@buffer.count] + @buffer[0..newest_idx]
+    end
+  end
+  
+  def push element
+    if full?
+      raise ArgumentError, "buffer is full, and override_when_full is false" unless @override_when_full
+      
+      @buffer[@newest] = element;
+      @newest += 1
+      @oldest += 1
+    else
+      @buffer[@newest] = element;
+      @newest += 1
+      @fill_count += 1      
+    end
+
+    if @oldest >= @buffer.count
+      @oldest = 0
+    end
+
+    if @newest >= @buffer.count
+      @newest = 0
+    end
+  end
+
+  def push_ary ary
+    ary.each do |element|
+      push element
+    end
+  end
+
+  def newest relative_index = 0
+    raise ArgumentError, "buffer is empty" if empty?
+    raise ArgumentError, "relative_index is greater or equal to @fill_count" if relative_index >= @fill_count
+
+    # newestIdx is actually @newest - 1
+    newestIdx = @newest - 1;
+    if(newestIdx < 0)
+      newestIdx += @buffer.count;
+    end
+
+    absIdx = newestIdx - relative_index;
+    if(absIdx < 0)
+      absIdx += @buffer.count;
+    end
+
+    return @buffer[absIdx];
+  end
+  
+  def oldest relative_index = 0
+    raise ArgumentError, "buffer is empty" if empty?
+    raise ArgumentError, "relative_index is greater or equal to @fill_count" if relative_index >= @fill_count
+    
+    absIdx = @oldest + relative_index;
+    if(absIdx >= @buffer.count)
+        absIdx -= @buffer.count;
+    end
+    
+    return @buffer[absIdx];
+  end
+
+  # Pop the oldest/newest element, depending on @fifo flag. When true, pop the oldest,
+  # otherwise pop the newest. Set to true by default, can override during initialize or
+  # later using fifo=.
+  def pop
+    raise ArgumentError, "buffer is empty" if empty?
+    
+    if @fifo
+      # FIFO - pop the oldest element
+      element = oldest
+      @oldest += 1
+      if(@oldest >= @buffer.count)
+        @oldest = 0
+      end
+      @fill_count -= 1
+      return element    
+    else
+      # FILO - pop the newest element
+      element = newest
+      if(@newest > 0)
+        @newest -= 1
+      else
+        @newest = @buffer.count - 1
+      end
+      @fill_count -= 1
+      return element      
+    end
+  end
+end
+end

data/lib/spcore/lib/cookbook_allpass_filter.rb

@@ -0,0 +1,38 @@
+module SPCore
+class CookbookAllpassFilter < BiquadFilter
+  def initialize sample_rate
+    super(sample_rate)
+  end
+  
+  def set_critical_freq_and_bw critical_freq, bandwidth
+    @critical_freq = critical_freq
+    @bandwidth = bandwidth
+
+    # setup variables
+    omega = 2.0 * Math::PI * @critical_freq / @sample_rate
+    sn = Math::sin(omega)
+    cs = Math::cos(omega)
+    alpha = sn * Math::sinh(BiquadFilter::LN_2 / 2.0 * @bandwidth * omega / sn)
+
+    b0 =  1.0 - alpha
+    b1 = -2.0 * cs
+    b2 =  1.0 + alpha
+    a0 =  1.0 + alpha
+    a1 = -2.0 * cs
+    a2 =  1.0 - alpha
+
+    # precompute the coefficients
+    @biquad.b0 = b0 / a0
+    @biquad.b1 = b1 / a0
+    @biquad.b2 = b2 / a0
+    @biquad.a0 = a0 / a0
+    @biquad.a1 = a1 / a0
+    @biquad.a2 = a2 / a0
+
+    ## zero initial samples
+    #@biquad.x1 = @biquad.x2 = 0
+    #@biquad.y1 = @biquad.y2 = 0
+  end
+
+end
+end