audio_stream 1.0.0

data/lib/audio_stream/audio_output_file.rb

@@ -0,0 +1,35 @@
+module AudioStream
+  class AudioOutputFile < AudioOutput
+    def initialize(fname, soundinfo:)
+      super()
+      @fname = fname
+      @soundinfo = soundinfo
+    end
+
+    def connect
+      @sound = RubyAudio::Sound.open(@fname, "w", @soundinfo)
+    end
+
+    def disconnect
+    end
+
+    def join
+      @sync.yield_wait
+    end
+
+    def on_next(input)
+      @sound.write(input)
+    end
+
+    def on_error(error)
+      puts error
+      puts error.backtrace.join("\n")
+      @sound.close
+    end
+
+    def on_completed
+      @sound.close
+      @sync.finish
+    end
+  end
+end

data/lib/audio_stream/buffer.rb

@@ -0,0 +1,84 @@
+module AudioStream
+  class Buffer < RubyAudio::Buffer
+    def plot(soundinfo=nil)
+      Plot.new(self, soundinfo)
+    end
+
+    def +(other)
+      unless RubyAudio::Buffer===other
+        raise Error, "right operand is not Buffer: #{other}"
+      end
+      if self.size!=other.size
+        raise Error, "Buffer.size is not match: self.size=#{self.size} other.size=#{other.size}"
+      end
+
+      channels = [self.channels, other.channels].max
+      window_size = self.size
+
+      buf = Buffer.float(window_size, channels)
+
+      case channels
+      when 1
+        [self, other].each {|x|
+          x.size.times.each {|i|
+            buf[i] += x[i]
+          }
+        }
+      when 2
+        m2s = Fx::MonoToStereo.new
+        a = [
+          m2s.process(self),
+          m2s.process(other),
+        ]
+        a.each {|x|
+          x.size.times.each {|i|
+            buf[i] = buf[i].zip(x[i]).map {|a| a[0] + a[1]}
+          }
+        }
+      end
+
+      buf
+    end
+
+    def to_na
+      window_size = self.size
+      channels = self.channels
+
+      na = NArray.float(channels, window_size)
+      na[0...na.size] = self.to_a.flatten
+
+      na
+    end
+
+    def self.from_na(na)
+      channels = na.shape[0]
+      window_size = na.size / channels
+
+      buf = self.float(window_size, channels)
+
+      case channels
+      when 1
+        window_size.times {|i|
+          buf[i] = na[i].real
+        }
+      when 2
+        window_size.times {|i|
+          ch1 = na[i*2].real
+          ch2 = na[(i*2)+1].real
+
+          buf[i] = [ch1, ch2]
+        }
+      end
+
+      buf
+    end
+
+    [:short, :int, :float, :double].each do |type|
+      eval "def self.#{type}(frames, channels=1)
+              buf = self.new(:#{type}, frames, channels)
+              buf.real_size = buf.size
+              buf
+            end"
+    end
+  end
+end

data/lib/audio_stream/conductor.rb

@@ -0,0 +1,38 @@
+module AudioStream
+  class Conductor
+    def initialize(input:, output:)
+      @inputs = Set[*[input].flatten.compact]
+      @outputs = Set[*[output].flatten.compact]
+    end
+
+    def connect
+      @outputs.map(&:connect)
+      @input_connections = @inputs.map(&:connect)
+
+      @sync_thread = Thread.start {
+        loop {
+          @inputs.each {|t|
+            t.sync.resume
+          }
+
+          @inputs.each {|t|
+            stat = t.sync.yield_wait
+            if stat==Sync::COMPLETED
+              @inputs.delete(t)
+            end
+          }
+
+          if @inputs.length==0
+            break
+          end
+        }
+      }
+    end
+
+    def join
+      @outputs.map(&:join)
+      @input_connections.map(&:join)
+      @sync_thread.join
+    end
+  end
+end

data/lib/audio_stream/core_ext.rb

@@ -0,0 +1,13 @@
+require 'audio_stream'
+
+module Rx::Observable
+  def fx(effector)
+    #map(&effector.:process)
+    map(&effector.method(:process))
+  end
+
+  def send_to(bus, gain: nil, pan: nil)
+    bus.add(self, gain: gain, pan: pan)
+    self
+  end
+end

data/lib/audio_stream/error.rb

@@ -0,0 +1,4 @@
+module AudioStream
+  class Error < StandardError
+  end
+end

data/lib/audio_stream/fx.rb

@@ -0,0 +1,30 @@
+require 'audio_stream/fx/bang_process'
+
+require 'audio_stream/fx/a_gain'
+require 'audio_stream/fx/panning'
+require 'audio_stream/fx/distortion'
+require 'audio_stream/fx/noise_gate'
+require 'audio_stream/fx/compressor'
+require 'audio_stream/fx/biquad_filter'
+require 'audio_stream/fx/low_pass_filter'
+require 'audio_stream/fx/high_pass_filter'
+require 'audio_stream/fx/band_pass_filter'
+require 'audio_stream/fx/low_shelf_filter'
+require 'audio_stream/fx/high_shelf_filter'
+require 'audio_stream/fx/peaking_filter'
+require 'audio_stream/fx/equalizer_2band'
+require 'audio_stream/fx/equalizer_3band'
+require 'audio_stream/fx/tremolo'
+require 'audio_stream/fx/delay'
+require 'audio_stream/fx/chorus'
+require 'audio_stream/fx/convolution_reverb'
+require 'audio_stream/fx/hanning_window'
+
+require 'audio_stream/fx/stereo_to_mono'
+require 'audio_stream/fx/mono_to_stereo'
+require 'audio_stream/fx/tuner'
+
+module AudioStream
+  module Fx
+  end
+end

data/lib/audio_stream/fx/a_gain.rb

@@ -0,0 +1,26 @@
+module AudioStream
+  module Fx
+    class AGain
+      include BangProcess
+
+      def initialize(level: 1.0)
+        @level = level
+      end
+
+      def process!(input)
+        return if @level==1.0
+
+        case input.channels
+        when 1
+          input.each_with_index {|f, i|
+            input[i] = f * @level
+          }
+        when 2
+          input.each_with_index {|fa, i|
+            input[i] = fa.map {|f| f * @level}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/band_pass_filter.rb

@@ -0,0 +1,29 @@
+module AudioStream
+  module Fx
+    class BandPassFilter < BiquadFilter
+
+      def initialize(soundinfo, freq:, bandwidth: 1.0)
+        super()
+        @samplerate = soundinfo.samplerate.to_f
+        @freq = freq
+        @bandwidth = bandwidth
+
+        filter_coef
+      end
+
+      def filter_coef
+        omega = 2.0 * Math::PI * @freq / @samplerate
+        alpha = Math.sin(omega) * Math.sinh(Math.log(2.0) / 2.0 * @bandwidth * omega / Math.sin(omega))
+
+        a0 = 1.0 + alpha
+        a1 = -2.0 * Math.cos(omega)
+        a2 = 1.0 - alpha
+        b0 = alpha
+        b1 = 0.0
+        b2 = -alpha
+
+        @filter_coef = FilterCoef.new(a0, a1, a2, b0, b1, b2)
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/bang_process.rb

@@ -0,0 +1,11 @@
+module AudioStream
+  module Fx
+    module BangProcess
+      def process(input)
+        output = input.clone
+        process!(output)
+        output
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/biquad_filter.rb

@@ -0,0 +1,58 @@
+module AudioStream
+  module Fx
+    class BiquadFilter
+      include BangProcess
+
+      FilterBuffer = Struct.new("FilterBuffer", :in1, :in2, :out1, :out2) do
+        def self.create
+          new(0.0, 0.0, 0.0, 0.0)
+        end
+      end
+
+      FilterCoef = Struct.new("FilterCoef", :a0, :a1, :a2, :b0, :b1, :b2)
+
+      def initialize
+        @filter_bufs = [FilterBuffer.create, FilterBuffer.create]
+      end
+
+      def filter_coef
+        raise Error, "#{self.class.name}.filter_coef is not implemented"
+      end
+
+      def process!(input)
+        window_size = input.size
+        channels = input.channels
+
+        case channels
+        when 1
+          b = @filter_bufs[0]
+          window_size.times {|i|
+            input[i] = process_one(input[i], b)
+          }
+        when 2
+          window_size.times {|i|
+            input[i] = channels.times.map {|j|
+              b = @filter_bufs[j]
+              in0 = input[i][j]
+              process_one(in0, b)
+            }
+          }
+        end
+
+        input
+      end
+
+      def process_one(in0, b)
+        c = @filter_coef
+        out0 = c.b0/c.a0 * in0 + c.b1/c.a0 * b.in1 + c.b2/c.a0 * b.in2 - c.a1/c.a0 * b.out1 - c.a2/c.a0 * b.out2
+
+        b.in2 = b.in1
+        b.in1 = in0
+        b.out2 = b.out1
+        b.out1 = out0
+
+        out0
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/chorus.rb

@@ -0,0 +1,59 @@
+module AudioStream
+  module Fx
+    class Chorus
+      include BangProcess
+
+      def initialize(soundinfo, depth: 100, rate: 0.25)
+        @soundinfo = soundinfo
+
+        @depth = depth
+        @rate = rate
+
+        @delaybuf0 = RingBuffer.new(@depth * 3, 0.0)
+        @delaybuf1 = RingBuffer.new(@depth * 3, 0.0)
+
+        @phase = 0
+        @speed = (2.0 * Math::PI * @rate) / @soundinfo.samplerate
+      end
+
+      def process!(input)
+        window_size = input.size
+        channels = input.channels
+
+        window_size.times {|i|
+          tau = @depth * (Math.sin(@speed * (@phase + i)) + 1)
+          t = i - tau
+
+          m = t.floor
+          delta = t - m
+
+          case channels
+          when 1
+            wet = delta * @delaybuf0[i-m+1] + (1.0 - delta) * @delaybuf0[i-m]
+            input[i] = (input[i] + wet) * 0.5
+          when 2
+            wet0 = delta * @delaybuf0[i-m+1] + (1.0 - delta) * @delaybuf0[i-m]
+            wet1 = delta * @delaybuf1[i-m+1] + (1.0 - delta) * @delaybuf1[i-m]
+            input[i] = [(input[i][0] + wet0) * 0.5, (input[i][1] + wet1) * 0.5]
+          end
+
+          case channels
+          when 1
+            @delaybuf0.current = input[i]
+            @delaybuf0.rotate
+          when 2
+            @delaybuf0.current = input[i][0]
+            @delaybuf1.current = input[i][1]
+            @delaybuf0.rotate
+            @delaybuf1.rotate
+          end
+        }
+        @phase = (@phase + window_size) % (window_size / @speed)
+      end
+
+      def lerp(start, stop, step)
+        (stop * step) + (start * (1.0 - step))
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/compressor.rb

@@ -0,0 +1,41 @@
+module AudioStream
+  module Fx
+    class Compressor
+      include BangProcess
+
+      def initialize(threshold: 0.5, ratio: 0.5)
+        @threshold = threshold
+        @ratio = ratio
+        @zoom = 1.0 / (@ratio * (1.0 - @threshold) + @threshold)
+      end
+
+      def process!(input)
+        window_size = input.size
+        channels = input.channels
+
+        case channels
+        when 1
+          input.each_with_index {|f, i|
+            sign = f.negative? ? -1 : 1
+            f = f.abs
+            if @threshold<f
+              f = (f - @threshold) * @ratio + @threshold
+            end
+            input[i] = @zoom * f * sign
+          }
+        when 2
+          input.each_with_index {|fa, i|
+            input[i] = fa.map {|f|
+              sign = f.negative? ? -1 : 1
+              f = f.abs
+              if @threshold<f
+                f = (f - @threshold) * @ratio + @threshold
+              end
+              @zoom * f * sign
+            }
+          }
+        end
+      end
+    end
+  end
+end