audio_stream 1.0.0

data/examples/tuner.rb

@@ -0,0 +1,77 @@
+require 'audio_stream/core_ext'
+
+include AudioStream
+include AudioStream::Fx
+
+
+soundinfo = SoundInfo.new(
+  channels: 2,
+  samplerate: 44100,
+  window_size: 1024,
+  format: RubyAudio::FORMAT_WAV|RubyAudio::FORMAT_PCM_16
+)
+
+# Track
+
+#track1 = AudioInput.sin(454.0, 100, 2048, soundinfo: soundinfo)
+track1 = AudioInput.device(1024*2*2*2)
+
+
+# Audio FX
+
+tuner = Tuner.new(soundinfo)
+
+
+# Bus
+
+stereo_out = AudioOutput.device(soundinfo: soundinfo)
+
+
+# Mixer
+
+track1
+  .stream
+  .fx(tuner)
+  .subscribe_on_next {|tone|
+    width = 30
+    if tone.diff
+      diff = (tone.diff * width / 100).round
+      bar = ""
+      if diff.negative?
+        diff = diff.abs
+        if width/2<diff
+          diff = width/2
+        end
+        bar += "_" * (width/2 - diff)
+        bar += "#" * diff
+        bar += "@"
+        bar += "_" * (width/2)
+      else
+        if width/2<diff
+          diff = width/2
+        end
+        bar += "_" * (width/2)
+        bar += "@"
+        bar += "#" * diff
+        bar += "_" * (width/2 - diff)
+      end
+      print "\r% 4.3fhz % 5s% 2d %s % 2.3f" % [tone.freq, tone.note, tone.octave, bar, tone.diff]
+
+    else
+      print "\r ---.---hz NOINPUT"
+    end
+  }
+
+#track1
+#  .stream
+#  .send_to(stereo_out)
+
+
+# start
+
+conductor = Conductor.new(
+  input: track1,
+  output: nil
+)
+conductor.connect
+conductor.join

data/lib/audio_stream.rb

@@ -0,0 +1,30 @@
+require 'ruby-audio'
+require 'coreaudio'
+require 'numru/fftw3'
+require 'rx'
+require 'rbplotly'
+
+require 'audio_stream/version'
+require 'audio_stream/error'
+require 'audio_stream/sound_info'
+require 'audio_stream/buffer'
+require 'audio_stream/ring_buffer'
+require 'audio_stream/sync'
+require 'audio_stream/conductor'
+require 'audio_stream/audio_input'
+require 'audio_stream/audio_input_file'
+require 'audio_stream/audio_input_device'
+require 'audio_stream/audio_input_buffer'
+require 'audio_stream/audio_input_sin'
+require 'audio_stream/audio_input_metronome'
+require 'audio_stream/audio_bus'
+require 'audio_stream/audio_output'
+require 'audio_stream/audio_output_file'
+require 'audio_stream/audio_output_device'
+require 'audio_stream/fx'
+require 'audio_stream/plot'
+require 'audio_stream/utils'
+
+module AudioStream
+  include NumRu
+end

data/lib/audio_stream/audio_bus.rb

@@ -0,0 +1,28 @@
+module AudioStream
+  class AudioBus < Rx::Subject
+    def initialize
+      super
+      @observables = []
+      @zip_observable = nil
+      @detach = nil
+    end
+
+    def add(observable, gain:, pan:)
+      if gain && gain!=1.0
+        observable = observable.map(&Fx::AGain.new(level: gain).method(:process))
+      end
+
+      if pan && pan!=0.0
+        observable = observable.map(&Fx::Panning.new(pan: pan).method(:process))
+      end
+
+      @observables << observable
+      if @detach
+        @detach.unsubscribe
+      end
+
+      @zip_observable = Rx::Observable.zip(*@observables).map{|a| a.inject(:+)}
+      @detach = @zip_observable.subscribe(self)
+    end
+  end
+end

data/lib/audio_stream/audio_input.rb

@@ -0,0 +1,48 @@
+module AudioStream
+
+  module AudioInput
+    include Enumerable
+
+    attr_reader :connection
+
+    def sync
+      @sync ||= Sync.new
+    end
+
+    def connect
+      @connection = Thread.start {
+        stream.connect
+      }
+    end
+
+    def stream
+      @stream ||= Rx::Observable.create do |observer|
+        each {|buf|
+          sync.resume_wait
+          observer.on_next(buf)
+          sync.yield
+        }
+        sync.resume_wait
+        sync.finish
+        observer.on_completed
+      end.publish
+    end
+
+
+    def self.file(fname, soundinfo:)
+      AudioInputFile.new(fname, soundinfo: soundinfo)
+    end
+
+    def self.buffer(buf)
+      AudioInputBuffer.new(buf)
+    end
+
+    def self.device(soundinfo:)
+      AudioInputDevice.default_device(soundinfo: soundinfo)
+    end
+
+    def self.sin(hz, repeat, soundinfo:)
+      AudioInputSin.new(hz, repeat, soundinfo: soundinfo)
+    end
+  end
+end

data/lib/audio_stream/audio_input_buffer.rb

@@ -0,0 +1,21 @@
+module AudioStream
+  class AudioInputBuffer
+    include AudioInput
+
+    def initialize(buffers)
+      @buffers = [buffers].flatten.compact
+    end
+
+    def name
+      "Buffer"
+    end
+
+    def each(&block)
+      Enumerator.new do |y|
+        @buffers.each {|buf|
+          y << buf
+        }
+      end.each(&block)
+    end
+  end
+end

data/lib/audio_stream/audio_input_device.rb

@@ -0,0 +1,50 @@
+module AudioStream
+  class AudioInputDevice
+    include AudioInput
+
+    attr_reader :dev
+
+    def initialize(dev, soundinfo:)
+      @dev = dev
+      @soundinfo = soundinfo
+    end
+
+    def name
+      @dev.name
+    end
+
+    def each(&block)
+      Enumerator.new do |y|
+        @inbuf = @dev.input_buffer(@soundinfo.window_size)
+        @inbuf.start
+
+        channels = @dev.input_stream.channels
+        buf = Buffer.float(@soundinfo.window_size, channels)
+
+        loop {
+          na = @inbuf.read(@soundinfo.window_size)
+          @soundinfo.window_size.times {|i|
+            buf[i] = na[(na.dim*i)...(na.dim*(i+1))].to_a.map{|s| s / 0x7FFF.to_f}
+          }
+
+          y << buf.clone
+        }
+      end.each(&block)
+    end
+
+    def self.default_device(soundinfo:)
+      dev = CoreAudio.default_input_device
+      new(dev, soundinfo: soundinfo)
+    end
+
+    def self.devices(soundinfo:)
+      CoreAudio.devices
+        .select{|dev|
+          0<dev.input_stream.channels
+        }
+        .map {|dev|
+          new(dev, soundinfo: soundinfo)
+        }
+    end
+  end
+end

data/lib/audio_stream/audio_input_file.rb

@@ -0,0 +1,30 @@
+module AudioStream
+  class AudioInputFile
+    include AudioInput
+
+    def initialize(path, soundinfo:)
+      @path = path
+      @sound = RubyAudio::Sound.open(path)
+      @soundinfo = soundinfo
+    end
+
+    def name
+      @path
+    end
+
+    def seek(frames, whence=IO::SEEK_SET)
+      @sound.seek(frames, whence)
+      self
+    end
+
+    def each(&block)
+      Enumerator.new do |y|
+        buf = Buffer.float(@soundinfo.window_size, @sound.info.channels)
+        while @sound.read(buf)!=0
+          buf.real_size = buf.size
+          y << buf.clone
+        end
+      end.each(&block)
+    end
+  end
+end

data/lib/audio_stream/audio_input_metronome.rb

@@ -0,0 +1,49 @@
+module AudioStream
+  class AudioInputMetronome
+    include AudioInput
+
+    def initialize(bpm, repeat=nil, soundinfo:)
+      @bpm = bpm
+      @repeat = repeat
+      @soundinfo = soundinfo
+    end
+
+    def name
+      "Metronome"
+    end
+
+    def each(&block)
+      Enumerator.new do |y|
+        period = @soundinfo.samplerate / @soundinfo.window_size * 60.0 / @bpm
+        count = 0
+
+        empty_buf = Buffer.float(@soundinfo.window_size, @soundinfo.channels)
+        phase = 440.0 / @soundinfo.samplerate * 2 * Math::PI
+        offset = 0
+
+        Range.new(0, @repeat).each {|_|
+          if count<1
+            buf = Buffer.float(@soundinfo.window_size, @soundinfo.channels)
+            case @soundinfo.channels
+            when 1
+              @soundinfo.window_size.times.each {|i|
+                buf[i] = Math.sin(phase * (i + offset))
+              }
+            when 2
+              @soundinfo.window_size.times.each {|i|
+                val = Math.sin(phase * (i + offset))
+                buf[i] = [val, val]
+              }
+            end
+            offset += @soundinfo.window_size
+
+            y << buf
+          else
+            y << empty_buf.clone
+          end
+          count = (count + 1) % period
+        }
+      end.each(&block)
+    end
+  end
+end

data/lib/audio_stream/audio_input_sin.rb

@@ -0,0 +1,41 @@
+module AudioStream
+  class AudioInputSin
+    include AudioInput
+
+    def initialize(hz, repeat=nil, soundinfo:)
+      @hz = hz
+      @repeat = repeat
+      @soundinfo = soundinfo
+    end
+
+    def name
+      "SinWave"
+    end
+
+    def each(&block)
+      Enumerator.new do |y|
+        buf = Buffer.float(@soundinfo.window_size, @soundinfo.channels)
+
+        phase = @hz.to_f / @soundinfo.samplerate * 2 * Math::PI
+        offset = 0
+
+        Range.new(0, @repeat).each {|_|
+          case @soundinfo.channels
+          when 1
+            @soundinfo.window_size.times.each {|i|
+              buf[i] = Math.sin(phase * (i + offset))
+            }
+          when 2
+            @soundinfo.window_size.times.each {|i|
+              val = Math.sin(phase * (i + offset))
+              buf[i] = [val, val]
+            }
+          end
+          offset += @soundinfo.window_size
+
+          y << buf.clone
+        }
+      end.each(&block)
+    end
+  end
+end

data/lib/audio_stream/audio_output.rb

@@ -0,0 +1,17 @@
+module AudioStream
+  class AudioOutput < AudioBus
+
+    def initialize
+      super()
+      @sync = Sync.new
+    end
+
+    def self.file(fname, soundinfo:)
+      AudioOutputFile.new(fname, soundinfo: soundinfo)
+    end
+
+    def self.device(window_size=1024)
+      AudioOutputDevice.default_device(window_size)
+    end
+  end
+end

data/lib/audio_stream/audio_output_device.rb

@@ -0,0 +1,65 @@
+module AudioStream
+  class AudioOutputDevice < AudioOutput
+    attr_reader :dev
+
+    def initialize(dev, soundinfo:)
+      super()
+      @dev = dev
+      @channels = dev.output_stream.channels
+      @buf = dev.output_buffer(soundinfo.window_size)
+    end
+
+    def connect
+      @buf.start
+    end
+
+    def disconnect
+      @buf.stop
+    end
+
+    def join
+      @sync.yield_wait
+    end
+
+    def on_next(input)
+      window_size = input.size
+      channels = input.channels
+
+      case @channels
+      when 1
+        input = Fx::StereoToMono.new.process(input)
+      when 2
+        input = Fx::MonoToStereo.new.process(input)
+      end
+
+      sint_a = input.to_a.flatten.map{|f| (f*0x7FFF).round}
+      na = NArray.sint(@channels, window_size)
+      na[0...sint_a.length] = sint_a
+      @buf << na
+    end
+
+    def on_error(error)
+      puts error
+      puts error.backtrace.join("\n")
+    end
+
+    def on_completed
+      @sync.finish
+    end
+
+    def self.default_device(soundinfo:)
+      dev = CoreAudio.default_output_device
+      new(dev, soundinfo: soundinfo)
+    end
+
+    def self.devices(soundinfo:)
+      CoreAudio.devices
+        .select{|dev|
+          0<dev.output_stream.channels
+        }
+        .map {|dev|
+          new(dev, soundinfo: soundinfo)
+        }
+    end
+  end
+end