midi-fx 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39c028b4fc0b5db17aad8a24058ef3ac94f130f3
+  data.tar.gz: 46e4cdeda5efaf2dce5eb69b26ecc7d6de418652
+SHA512:
+  metadata.gz: 64e9f0fa4e52b8689ec27cf3ce54717cc261fc70ea7c93da463bf25be50fbae7d8bce62671302de72508ac3f67468d9ead56e5c6bf4bd546445c85986bb34982
+  data.tar.gz: c8c96e53af97c3e4746a0d10569524d28e33e1e7470b49d7ca37cbeb6e8f5078c1698f32dc7094636629204cbf2f0c7205740ccbf4c34b85dc23a912433f87e7

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2011-2014 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,13 @@
+# MIDI-FX
+
+MIDI effects in Ruby
+
+## Author
+
+* [Ari Russo](http://github.com/arirusso) <ari.russo at gmail.com>
+
+## License
+
+Apache 2.0, See the file LICENSE
+
+Copyright (c) 2011-2014 Ari Russo

data/lib/midi-fx.rb

@@ -0,0 +1,37 @@
+#
+# midi-fx
+#
+# MIDI effects in Ruby
+#
+# (c)2011-2014 Ari Russo
+# Apache 2.0 License
+# 
+
+# libs
+require "midi-message"
+
+# classes
+require "midi-fx/filter"
+require "midi-fx/limit"
+require "midi-fx/transpose"
+
+module MIDIFX
+
+  VERSION = "0.1"
+
+  MAP = {
+    :filter => Filter,
+    :limit => Limit, 
+    :transpose => Transpose
+  }
+
+  def self.method_missing(method, *args, &block)
+    if MAP.keys.include?(method)
+      message = args.shift
+      MAP[method].new(*args).process(message, &block)
+    else
+      super
+    end
+  end
+
+end

data/lib/midi-fx/filter.rb

@@ -0,0 +1,55 @@
+module MIDIFX
+
+  # Use the Filter superclass when you need a multi-band filter
+  class Filter
+
+    attr_reader :bandwidth, :property, :reject
+
+    def initialize(property, bandwidth, options = {})
+      @bandwidth = [bandwidth].flatten
+      @property = property
+      @reject = options[:reject] || false
+      @name = options[:name]
+    end
+
+    def process(message)
+      val = message.send(@property)
+      result = @bandwidth.map do |bw| 
+        case bw
+        when Range then val >= bw.min && val <= bw.max ? message : nil
+        when Numeric then val == bw ? message : nil
+        end
+      end
+      result.include?(message) ^ @reject ? message : nil
+    end
+
+  end
+
+  class LowPassFilter < Filter
+    def initialize(prop, max, options = {})
+      super(prop, (0..max), options)
+    end
+  end
+
+  class HighPassFilter < Filter
+    def initialize(prop, min, options = {})
+      super(prop, (min..127), options)
+    end
+  end
+
+  class BandPassFilter < Filter
+    def initialize(prop, accept_range, options = {})
+      options[:reject] = false
+      super(prop, accept_range, options)
+    end
+  end
+
+  class BandRejectFilter < Filter
+    def initialize(prop, reject_range, options = {})
+      options[:reject] = true
+      super(prop, reject_range, options)
+    end
+  end
+  NotchFilter = BandRejectFilter
+
+end

data/lib/midi-fx/limit.rb

@@ -0,0 +1,27 @@
+module MIDIFX
+
+  class Limit
+
+    attr_reader :property, :limit_to
+    alias_method :range, :limit_to
+
+    def initialize(property, limit_to, options = {})
+      @limit_to = limit_to
+      @property = property
+      @name = options[:name]
+    end
+
+    def process(message)
+      val = message.send(@property)
+      if @limit_to.kind_of?(Range)
+        message.send("#{@property}=", @limit_to.min) if val < @limit_to.min
+        message.send("#{@property}=", @limit_to.max) if val > @limit_to.max
+      elsif @limit_to.kind_of?(Numeric)
+        message.send("#{@property}=", @limit_to)
+      end
+      message
+    end
+
+  end
+
+end

data/lib/midi-fx/transpose.rb

@@ -0,0 +1,21 @@
+module MIDIFX
+
+  class Transpose
+
+    attr_reader :factor, :property
+
+    def initialize(property, factor, options = {})
+      @factor = factor
+      @property = property
+      @name = options[:name]
+    end
+
+    def process(message)
+      val = message.send(@property)
+      message.send("#{@property}=", val + @factor)
+      message
+    end
+
+  end
+
+end

data/test/filter_test.rb

@@ -0,0 +1,109 @@
+require "helper"
+
+class MIDIFX::FilterTest < Test::Unit::TestCase
+
+  def test_high_pass_note_reject
+    message = MIDIMessage::NoteOn["C0"].new(0, 100)
+    assert_equal(12, message.note)
+    output = MIDIFX::HighPassFilter.new(:note, 20).process(message)
+    assert_equal(nil, output)
+  end
+
+  def test_high_pass_note_accept
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::HighPassFilter.new(:note, 20).process(message)
+    assert_equal(message, output)
+  end
+
+  def test_low_pass_note_reject
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::LowPassFilter.new(:note, 50).process(message)
+    assert_equal(nil, output)
+  end
+
+  def test_low_pass_note_accept
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::LowPassFilter.new(:note, 100).process(message)
+    assert_equal(message, output)
+  end
+
+  def test_band_pass_note_reject
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::BandPassFilter.new(:note, (20..50)).process(message)
+    assert_equal(nil, output)
+  end
+
+  def test_band_pass_note_accept
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::BandPassFilter.new(:note, (20..100)).process(message)
+    assert_equal(message, output)
+  end
+  
+  def test_band_reject_note_reject
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::NotchFilter.new(:note, (20..70)).process(message)
+    assert_equal(nil, output)
+  end
+
+  def test_band_reject_note_accept
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::NotchFilter.new(:note, (20..50)).process(message)
+    assert_equal(message, output)
+  end
+  
+  def test_multiband_note_reject
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::Filter.new(:note, [(20..30), (40..50)]).process(message)
+    assert_equal(nil, output)
+  end
+
+  def test_multiband_note_accept
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::Filter.new(:note, [(20..30), (50..70)]).process(message)
+    assert_equal(message, output)
+  end
+  
+  def test_multinotch_note_reject
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::Filter.new(:note, [(20..30), (55..65)], :reject => true).process(message)
+    assert_equal(nil, output)
+  end
+
+  def test_multinotch_note_accept
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    output = MIDIFX::Filter.new(:note, [(20..30), (40..50)], :reject => true).process(message)
+    assert_equal(message, output)
+  end
+  
+  def test_numeric_note_accept
+    message1 = MIDIMessage::NoteOn["C4"].new(0, 100)
+    message2 = MIDIMessage::NoteOn["C5"].new(0, 100)
+    f = MIDIFX::Filter.new(:note, 60)
+    output = f.process(message1)
+    assert_equal(message1, output)
+    output = f.process(message2)
+    assert_equal(nil, output)
+  end
+  
+  def test_numeric_note_reject
+    message1 = MIDIMessage::NoteOn["C4"].new(0, 100)
+    message2 = MIDIMessage::NoteOn["C5"].new(0, 100)
+    f = MIDIFX::Filter.new(:note, 60, :reject => true)
+    output = f.process(message1)
+    assert_equal(nil, output)
+    output = f.process(message2)
+    assert_equal(message2, output)
+  end
+  
+end

data/test/helper.rb

@@ -0,0 +1,5 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + "/../lib"
+
+require "test/unit"
+require "midi-fx"

data/test/limit_test.rb

@@ -0,0 +1,40 @@
+require "helper"
+
+class MIDIFX::LimitTest < Test::Unit::TestCase
+  
+  def test_numeric_range
+    message = MIDIMessage::NoteOn["C0"].new(0, 100)
+    assert_equal(12, message.note)
+    MIDIFX::Limit.new(:note, 30).process(message)
+    assert_equal(30, message.note)    
+  end
+
+  def test_low_note
+    message = MIDIMessage::NoteOn["C0"].new(0, 100)
+    assert_equal(12, message.note)
+    MIDIFX::Limit.new(:note, (20..50)).process(message)
+    assert_equal(20, message.note)
+  end
+
+  def test_high_note
+    message = MIDIMessage::NoteOn["C6"].new(0, 100)
+    assert_equal(84, message.note)
+    MIDIFX::Limit.new(:note, (20..50)).process(message)
+    assert_equal(50, message.note)
+  end
+
+  def test_low_velocity
+    message = MIDIMessage::NoteOn["C0"].new(0, 10)
+    assert_equal(10, message.velocity)
+    MIDIFX::Limit.new(:velocity, (30..110)).process(message)
+    assert_equal(30, message.velocity)
+  end
+
+  def test_high_velocity
+    message = MIDIMessage::NoteOn["C6"].new(0, 120)
+    assert_equal(120, message.velocity)
+    MIDIFX::Limit.new(:velocity, (25..75)).process(message)
+    assert_equal(75, message.velocity)
+  end
+  
+end

data/test/module_test.rb

@@ -0,0 +1,13 @@
+require "helper"
+
+class MIDIFX::ModuleTest < Test::Unit::TestCase
+
+  def test_class_method
+    msg = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, msg.note)
+    MIDIFX.transpose(msg, :note, 5)
+    assert_equal(65, msg.note)
+  end
+
+
+end

data/test/transpose_test.rb

@@ -0,0 +1,33 @@
+require "helper"
+
+class MIDIFX::TransposeTest < Test::Unit::TestCase
+
+  def test_transpose_note_up
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    MIDIFX::Transpose.new(:note, 5).process(message)
+    assert_equal(65, message.note)
+  end
+
+  def test_transpose_velocity_up
+    message = MIDIMessage::NoteOn["C4"].new(0, 82)
+    assert_equal(82, message.velocity)
+    MIDIFX::Transpose.new(:velocity, 10).process(message)
+    assert_equal(92, message.velocity)
+  end
+
+  def test_transpose_note_down
+    message = MIDIMessage::NoteOn["C4"].new(0, 100)
+    assert_equal(60, message.note)
+    MIDIFX::Transpose.new(:note, -5).process(message)
+    assert_equal(55, message.note)
+  end
+
+  def test_transpose_velocity_down
+    message = MIDIMessage::NoteOn["C4"].new(0, 82)
+    assert_equal(82, message.velocity)
+    MIDIFX::Transpose.new(:velocity, -10).process(message)
+    assert_equal(72, message.velocity)
+  end
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: midi-fx
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: midi-message
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Process MIDI messages in Ruby
+email:
+- ari.russo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/midi-fx.rb
+- lib/midi-fx/filter.rb
+- lib/midi-fx/limit.rb
+- lib/midi-fx/transpose.rb
+- test/filter_test.rb
+- test/helper.rb
+- test/limit_test.rb
+- test/module_test.rb
+- test/transpose_test.rb
+homepage: http://github.com/arirusso/midi-fx
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: midi-eye
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: MIDI effects in Ruby
+test_files: []