easy_audio 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40a26cab3088ab5982f88fcdae9d10b1f89adbba
+  data.tar.gz: 96c4ec815952cc8dca68bd8392612a6654a61d3c
+SHA512:
+  metadata.gz: a5aafb3994e2f8775cf7df6759e0ca8bf8d3e353afb6879892a40fb6e4bd9bea34f640d73d47f98dcb00d93e3b0049a5d190072bcb27f8c4d7c394a956429f1b
+  data.tar.gz: 9cb68b967815c5e07abcea57239d25ed5fef403e223a0e1d5c2e3db789ed6ff9b77ef72508a1ada2d77bba753c9818c59f5d309398ae490c240873aedb46d92a

data/.gitignore

@@ -0,0 +1,3 @@
+.yardoc
+doc
+*.gem

data/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2014, Loren Segal
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the copyright holder nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL LOREN SEGAL BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,57 @@
+# EasyAudio
+
+EasyAudio is a simplified wrapper for the [portaudio][portaudio] library, which
+allows to you play or record audio directly from your sound card.
+
+## Installing
+
+```sh
+$ gem install easy_audio
+```
+
+Note: if you are on a Linux or Windows machine you will need to manually
+install portaudio to a location in your library paths. The gem will attempt
+to install this automatically on OS X through [Homebrew][brew].
+
+## Usage
+
+Here's how you can easily play a sine wave at 440hz:
+
+```ruby
+require 'easy_audio'
+
+EasyAudio.easy_open(&EasyAudio::Waveforms::SINE)
+sleep 2 # play for 2 seconds
+```
+
+Here's a triangle wave that increases its frequency over 3 seconds:
+
+```ruby
+require 'easy_audio'
+
+stream = EasyAudio.easy_open(freq: 220, &EasyAudio::Waveforms::TRIANGLE)
+Thread.new { loop { stream.frequency += 50; sleep 0.2 } }
+sleep 3
+```
+
+Record audio from your microphone and play it back a second later:
+
+```ruby
+require 'easy_audio'
+
+EasyAudio.easy_open(in: true, out: true, latency: 1.0) { current_sample }
+sleep 10 # for 10 seconds
+```
+
+## Documentation
+
+See the API documentation on [rubydoc.info][docs].
+
+## License
+
+EasyAudio is copyright © 2014 by Loren Segal and licensed under the BSD
+license. See the LICENSE file for more information.
+
+[portaudio]: http://portaudio.com
+[brew]: http://brew.sh
+[docs]: http://rubydoc.info/gems/easy_audio/frames

data/Rakefile

@@ -0,0 +1,35 @@
+task :default => :install
+
+task :install do
+  have_portaudio = false
+  print "Checking for portaudio..."
+  begin
+    require "ffi-portaudio"
+    have_portaudio = true
+    puts " yes."
+  rescue LoadError
+    puts "no."
+  end
+
+  if !have_portaudio
+    success = false
+    puts "Portaudio is missing, attempting to install..."
+
+    if RbConfig::CONFIG['host_os'].match(/darwin/)
+      puts "Detected Mac OS X, installing with Homebrew..."
+      begin
+        sh "brew install portaudio"
+        success = true if $? == 0
+      rescue
+        puts "Could not install portaudio. Do you have Homebrew installed?"
+      end
+    else
+      puts "Only OS X installation currently supported. Install portaudio " +
+           "from http://portaudio.com and reinstall."
+    end
+
+    if success
+      puts "Installed portaudio. Continuing installation of easy_audio..."
+    end
+  end
+end

data/easy_audio.gemspec

@@ -0,0 +1,15 @@
+Gem::Specification.new do |s|
+  s.name          = "easy_audio"
+  s.summary       = "EasyAudio is a simplified wrapper for the portaudio library."
+  s.description   = "EasyAudio allows you to play or record from your sound card."
+  s.version       = File.read("lib/easy_audio.rb")[/VERSION = "(.+?)"/, 1]
+  s.author        = "Loren Segal"
+  s.email         = "lsegal@soen.ca"
+  s.homepage      = "http://github.com/lsegal/easy_audio"
+  s.platform      = Gem::Platform::RUBY
+  s.files         = `git ls-files`.split(/\s+/)
+  s.extensions    = ["Rakefile"]
+  s.license       = "BSD"
+
+  s.add_runtime_dependency "ffi-portaudio", "~> 0.0"
+end

data/examples/increase_frequency.rb

@@ -0,0 +1,7 @@
+# A triangle wave that increases in frequency over 3 seconds
+require_relative '../lib/easy_audio'
+
+stream = EasyAudio.easy_open(freq: 220, &EasyAudio::Waveforms::TRIANGLE)
+
+Thread.new { loop { stream.frequency += 50; sleep 0.2 } }
+sleep 3

data/examples/one_second_sine.rb

@@ -0,0 +1,5 @@
+# Play a one second sine wave at 440hz (A note)
+require_relative '../lib/easy_audio'
+
+EasyAudio.easy_open(&EasyAudio::Waveforms::SINE)
+sleep 1

data/examples/record_microphone_delay.rb

@@ -0,0 +1,6 @@
+# Record data from the microphone and
+# play it back on output with a 1 second delay
+require_relative '../lib/easy_audio'
+
+EasyAudio.easy_open(in: true, out: true, latency: 1.0) { current_sample }
+sleep 10 # for 10 seconds

data/lib/easy_audio.rb

@@ -0,0 +1,237 @@
+require 'ffi-portaudio'
+
+# Easy Audio is a library to simplify the Portaudio interface
+# @see http://portaudio.com
+module EasyAudio
+  VERSION = "0.1.0"
+
+  # Represents a single buffer passed to the {Stream} process block
+  class StreamPacket < Struct.new(:samples, :num_samples, :time_info, :status_info, :user_data)
+  end
+
+  # Represents a single audio input/output stream. See {#initialize} for usage
+  # examples.
+  class Stream < FFI::PortAudio::Stream
+    include FFI::PortAudio
+
+    # @!method start
+    #   Starts processing the stream.
+
+    # @!method stop
+    #   Stops processing the stream.
+
+    # Creates a new stream for processing audio. Call {#start} to start
+    # processing.
+    #
+    # @option opts :sample_rate [Fixnum] (44100) the sample rate to play at.
+    # @option opts :frame_size [Fixnum] (256) the number of frames per buffer.
+    # @option opts :in [Boolean] whether to use the default input device.
+    # @option opts :out [Boolean] whether to use the default output device.
+    # @option opts :in_chans [Fixnum] (2) the number of channels to process from
+    #   the input device.
+    # @option opts :out_chans [Fixnum] (2) the number of channels to process
+    #   from the output device.
+    # @option opts :latency [Float] (0.0) the default latency for processing.
+    # @yield [buffer] runs the provided block against the sample buffer data
+    # @yieldparam buffer [StreamPacket] the sample data to process
+    # @yieldreturn [Array<Float>] return an array of interlaced floating points
+    #   for each channel in {#output_channels}.
+    # @example Process audio from input (microphone) and playback on output
+    #   EasyAudio::Stream.new(in: true, out: true) do |buffer|
+    #     buffer.samples # echos the stream to output
+    #   end
+    # @see #start
+    def initialize(opts = {}, &block)
+      pa_start
+
+      @fn = block
+      @sample_rate = opts[:sample_rate] || 44100
+      @frame_size = opts[:frame_size] || 256
+      @input_channels = opts[:in_chans] || 1
+      @output_channels = opts[:out_chans] || 1
+      @latency = opts[:latency] || 0.01
+
+      input, output = nil, nil
+      if opts[:in] || opts[:in_chans]
+        device = API.Pa_GetDefaultInputDevice
+        input = stream_for(device, @input_channels, @latency)
+      end
+
+      if opts[:out] || opts[:out_chans] || !input
+        device = API.Pa_GetDefaultOutputDevice
+        output = stream_for(device, @output_channels, @latency)
+      end
+
+      open(input, output, @sample_rate, @frame_size)
+    end
+
+    attr_accessor :fn, :sample_rate, :frame_size
+    attr_reader :input_channels, :output_channels, :latency
+
+    private
+
+    # Don't override this function. Pass in a `process` Proc object to
+    # {#initialize} instead.
+    def process(input, output, frames, time_info, status, user_data)
+      result = run_process(input, output, frames, time_info, status, user_data)
+      unless Array === result
+        result = Array.new(frames * @output_channels).map {0}
+      end
+
+      output.write_array_of_float(result)
+      :paContinue
+    rescue => e
+      puts e.message + "\n  " + e.backtrace.join("\n  ")
+      :paAbort
+    end
+
+    def run_process(input, output, frames, time_info, status, user_data)
+      inbuf = nil
+      if input.address != 0
+        inbuf = input.read_array_of_float(frames * @input_channels)
+      end
+
+      buffer = StreamPacket.new(inbuf, frames, time_info, status, user_data)
+      @fn ? @fn.call(buffer) : nil
+    end
+
+    def stream_for(device, channels, latency)
+      API::PaStreamParameters.new.tap do |stream|
+        info = API.Pa_GetDeviceInfo(device)
+        stream[:device] = device
+        stream[:suggestedLatency] = latency
+        stream[:hostApiSpecificStreamInfo] = nil
+        stream[:channelCount] = channels
+        stream[:sampleFormat] = API::Float32
+      end
+    end
+
+    def pa_start
+      return if @@stream_started
+      API.Pa_Initialize
+      at_exit { API.Pa_Terminate }
+      @@stream_started = true
+    end
+
+    @@stream_started = false
+  end
+
+  # A simplified {Stream} class whose processor block only processes a single
+  # frame at a time. See {Waveforms} for a set of pre-fabricated EasyStream
+  # processor blocks for examples of how to process a single stream.
+  #
+  # Note that instead of passing state information as an argument to the block,
+  # state is instead stored in the class itself, and the block is instance
+  # evaluated. This makes it a bit slower to process, but much more convenient
+  # for creating blocks.
+  #
+  # See {#initialize} for usage examples.
+  class EasyStream < Stream
+
+    # {include:Stream#initialize}
+    #
+    # @option (see Stream#initialize)
+    # @option opts :freq [Float] (440.0) the frequency to generate {#step}
+    #   values at.
+    # @option opts :amp [Float] (1.0) the amplitude to scale values to.
+    # @yield a process block that processes one frame at a time.
+    # @yieldreturn [Array<Float>] return an array of interlaced floating points
+    #   for each channel in {#output_channels}.
+    # @example Process audio from input (microphone) and playback on output
+    #   EasyAudio::EasyStream.new(in: true, out: true) { current_sample }.start
+    # @example Play a sine wave.
+    #   EasyAudio::EasyStream.new(&EasyAudio::Waveforms::SINE).start
+    # @example Play a square wave.
+    #   EasyAudio::EasyStream.new(&EasyAudio::Waveforms::SQUARE).start
+    def initialize(opts = {}, &block)
+      @frequency = opts[:freq] || 440.0
+      @amp = opts[:amp] || 1.0
+      @frame = 0
+      @channel = 0
+
+      super(opts, &block)
+    end
+
+    attr_accessor :amp, :frequency, :frame
+    attr_reader :step, :channel, :samples, :num_frames
+    attr_reader :time_info, :status_info, :user_data, :i, :current_sample
+
+    private
+
+    def run_process(input, output, frames, time_info, status, user_data)
+      @samples = nil
+      if input.address != 0
+        @samples = input.read_array_of_float(frames * @input_channels)
+      end
+
+      @current_sample = nil
+      @num_frames = frames
+      @time_info = time_info
+      @status_info = status
+      @user_data = user_data
+
+      result = Array.new(frames * @output_channels)
+      if @fn
+        @i = 0
+        frames.times do
+          @step = @frame * (@frequency / @sample_rate.to_f) % 1.0
+          @output_channels.times do |ch|
+            @channel = ch
+            @current_sample = @samples[@i] if @samples
+            result[@i] = @amp.to_f * (instance_exec(&@fn) || 0.0)
+            @i += 1
+          end
+          @frame = (@frame + 1) % 1000000
+        end
+      else
+        result = result.map {0}
+      end
+
+      result
+    end
+  end
+
+  module_function
+
+  # Quickly opens a {Stream} and calls {Stream#start}.
+  #
+  # @option (see Stream#initialize)
+  # @yield (see Stream#initialize)
+  # @yieldparam (see Stream#initialize)
+  # @yieldreturn (see Stream#initialize)
+  def open(opts = {}, &block)
+    Stream.new(opts, &block).tap {|s| s.start }
+  end
+
+  # Quickly opens an {EasyStream} and calls {Stream#start}.
+  #
+  # @option (see EasyStream#initialize)
+  # @yield (see EasyStream#initialize)
+  # @yieldreturn (see EasyStream#initialize)
+  # @example Process audio from input (microphone) and playback on output
+  #   EasyAudio.easy_open(in: true, out: true) { current_sample }
+  # @example Play a sine wave.
+  #   EasyAudio.easy_open(&EasyAudio::Waveforms::SINE)
+  # @example Play a square wave.
+  #   EasyAudio.easy_open(&EasyAudio::Waveforms::SQUARE)
+  # @see EasyStream#initialize
+  def easy_open(opts = {}, &block)
+    EasyStream.new(opts, &block).tap {|s| s.start }
+  end
+
+  # A collection of pre-fabricated waveforms that can be plugged into
+  # {EasyStream} or {easy_open}.
+  module Waveforms
+    # Generates a sine wave
+    SINE = -> { Math.sin(2 * Math::PI * step) }
+
+    # Generates a square wave
+    SQUARE = -> { step < 0.5 ? -1 : 1 }
+
+    # Generates a triangle wave
+    TRIANGLE = -> { 1 - 4 * (step.round - step).abs }
+
+    # Generates a sawtooth wave
+    SAW = -> { 2 * (step - step.round) }
+  end
+end

data/samus.json

@@ -0,0 +1,44 @@
+{
+  "actions": [
+    {
+      "action": "fs-sedfiles",
+      "files": ["lib/easy_audio.rb"],
+      "arguments": {
+        "search": "VERSION = ['\"](.+?)['\"]",
+        "replace": "VERSION = \"$version\""
+      }
+    },
+    {
+      "action": "git-commit",
+      "files": ["lib/easy_audio.rb"]
+    },
+    {
+      "action": "git-merge",
+      "arguments": {
+        "branch": "master"
+      }
+    },
+    {
+      "action": "archive-git-full",
+      "files": ["git.tgz"],
+      "publish": [{
+        "action": "git-push",
+        "arguments": {
+          "remotes": "origin",
+          "refs": "master v$version"
+        }
+      }]
+    },
+    {
+      "action": "gem-build",
+      "files": ["*.gemspec"],
+      "publish": [
+        {
+          "action": "gem-push",
+          "files": ["*.gem"],
+          "credentials": "lsegal.rubygems"
+        }
+      ]
+    }
+  ]
+}

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: easy_audio
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Loren Segal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi-portaudio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+description: EasyAudio allows you to play or record from your sound card.
+email: lsegal@soen.ca
+executables: []
+extensions:
+- Rakefile
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE
+- README.md
+- Rakefile
+- easy_audio.gemspec
+- examples/increase_frequency.rb
+- examples/one_second_sine.rb
+- examples/record_microphone_delay.rb
+- lib/easy_audio.rb
+- samus.json
+homepage: http://github.com/lsegal/easy_audio
+licenses:
+- BSD
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: EasyAudio is a simplified wrapper for the portaudio library.
+test_files: []
+has_rdoc: