audio_stream 1.5.0 → 2.0.0

data/lib/audio_stream/fx/equalizer_2band.rb

@@ -1,16 +1,14 @@
 module AudioStream
   module Fx
     class Equalizer2band
-      include BangProcess
-
       def initialize(soundinfo, lowfreq: 400.0, lowgain:, highfreq: 4000.0, highgain:)
-        @low_filter = LowShelfFilter.create(soundinfo, freq: lowfreq, q: 1.0/Math.sqrt(2.0), gain: lowgain)
-        @high_filter = HighShelfFilter.create(soundinfo, freq: highfreq, q: 1.0/Math.sqrt(2.0), gain: highgain)
+        @low_filter = LowShelfFilter.create(soundinfo, freq: lowfreq, q: BiquadFilter::DEFAULT_Q, gain: lowgain)
+        @high_filter = HighShelfFilter.create(soundinfo, freq: highfreq, q: BiquadFilter::DEFAULT_Q, gain: highgain)
       end
 
-      def process!(input)
-        @low_filter.process!(input)
-        @high_filter.process!(input)
+      def process(input)
+        input = @low_filter.process(input)
+        input = @high_filter.process(input)
       end
 
       def plot(width=500)

data/lib/audio_stream/fx/equalizer_3band.rb

@@ -1,18 +1,16 @@
 module AudioStream
   module Fx
     class Equalizer3band
-      include BangProcess
-
       def initialize(soundinfo, lowfreq: 400.0, lowgain:, midfreq: 1000.0, midgain:, highfreq: 4000.0, highgain:)
-        @low_filter = LowShelfFilter.create(soundinfo, freq: lowfreq, q: 1.0/Math.sqrt(2.0), gain: lowgain)
-        @mid_filter = PeakingFilter.create(soundinfo, freq: midfreq, bandwidth: 1.0/Math.sqrt(2.0), gain: midgain)
-        @high_filter = HighShelfFilter.create(soundinfo, freq: highfreq, q: 1.0/Math.sqrt(2.0), gain: highgain)
+        @low_filter = LowShelfFilter.create(soundinfo, freq: lowfreq, q: BiquadFilter::DEFAULT_Q, gain: lowgain)
+        @mid_filter = PeakingFilter.create(soundinfo, freq: midfreq, bandwidth: 1.0, gain: midgain)
+        @high_filter = HighShelfFilter.create(soundinfo, freq: highfreq, q: BiquadFilter::DEFAULT_Q, gain: highgain)
       end
 
-      def process!(input)
-        @low_filter.process!(input)
-        @mid_filter.process!(input)
-        @high_filter.process!(input)
+      def process(input)
+        input = @low_filter.process(input)
+        input = @mid_filter.process(input)
+        input = @high_filter.process(input)
       end
 
       def plot(width=500)

data/lib/audio_stream/fx/graphic_equalizer.rb

@@ -1,23 +1,21 @@
 module AudioStream
   module Fx
     class GraphicEqualizer
-      include BangProcess
-
       def initialize(soundinfo)
         @soundinfo = soundinfo
         @filters = []
       end
 
-      def add(freq:, bandwidth: nil, gain:)
-        bandwidth ||= 1.0/Math.sqrt(2.0)
+      def add(freq:, bandwidth: 1.0, gain:)
         @filters << PeakingFilter.create(@soundinfo, freq: freq, bandwidth: bandwidth, gain: gain)
         self
       end
 
-      def process!(input)
+      def process(input)
         @filters.each {|filter|
-          filter.process!(input)
+          input = filter.process(input)
         }
+        input
       end
 
       def plot(width=500)

data/lib/audio_stream/fx/hanning_window.rb

@@ -2,28 +2,21 @@ module AudioStream
   module Fx
     class HanningWindow
       include Singleton
-      include BangProcess
 
-      def process!(input)
-        window_size = input.size
-        window_max = input.size - 1
+      def process(input)
+        window_size = input.window_size
+        window_max = input.window_size - 1
         channels = input.channels
 
         period = 2 * Math::PI / window_max
 
-        case channels
-        when 1
-          input.each_with_index {|f, i|
-            input[i] *= 0.5 - 0.5 * Math.cos(i * period)
+        streams = input.streams.map {|stream|
+          stream.map.with_index {|f, i|
+            f * (0.5 - 0.5 * Math.cos(i * period))
           }
-        when 2
-          input.each_with_index {|fa, i|
-            gain = 0.5 - 0.5 * Math.cos(i * period)
-            input[i] = fa.map {|f| f * gain}
-          }
-        end
+        }
 
-        input
+        Buffer.new(*streams)
       end
     end
   end

data/lib/audio_stream/fx/high_pass_filter.rb

@@ -16,9 +16,7 @@ module AudioStream
         @filter_coef = FilterCoef.new(a0, a1, a2, b0, b1, b2)
       end
 
-      def self.create(soundinfo, freq:, q: nil)
-        q ||= 1.0 / Math.sqrt(2)
-
+      def self.create(soundinfo, freq:, q: DEFAULT_Q)
         filter = new(soundinfo)
         filter.update_coef(freq: freq, q: q)
 

data/lib/audio_stream/fx/high_shelf_filter.rb

@@ -18,9 +18,7 @@ module AudioStream
         @filter_coef = FilterCoef.new(a0, a1, a2, b0, b1, b2)
       end
 
-      def self.create(soundinfo, freq:, q: nil, gain: 1.0)
-        q ||= 1.0 / Math.sqrt(2)
-
+      def self.create(soundinfo, freq:, q: DEFAULT_Q, gain: 1.0)
         filter = new(soundinfo)
         filter.update_coef(freq: freq, q: q, gain: gain)
 

data/lib/audio_stream/fx/low_pass_filter.rb

@@ -16,9 +16,7 @@ module AudioStream
         @filter_coef = FilterCoef.new(a0, a1, a2, b0, b1, b2)
       end
 
-      def self.create(soundinfo, freq:, q: nil)
-        q ||= 1.0 / Math.sqrt(2)
-
+      def self.create(soundinfo, freq:, q: DEFAULT_Q)
         filter = new(soundinfo)
         filter.update_coef(freq: freq, q: q)
 

data/lib/audio_stream/fx/low_shelf_filter.rb

@@ -18,9 +18,7 @@ module AudioStream
         @filter_coef = FilterCoef.new(a0, a1, a2, b0, b1, b2)
       end
 
-      def self.create(soundinfo, freq:, q: nil, gain: 1.0)
-        q ||= 1.0 / Math.sqrt(2)
-
+      def self.create(soundinfo, freq:, q: DEFAULT_Q, gain: 1.0)
         filter = new(soundinfo)
         filter.update_coef(freq: freq, q: q, gain: gain)
 

data/lib/audio_stream/fx/noise_gate.rb

@@ -1,21 +1,18 @@
 module AudioStream
   module Fx
     class NoiseGate
-      include BangProcess
-
       def initialize(threshold: 0.01)
         @threshold = threshold
         @window = HanningWindow.instance
       end
 
-      def process!(input)
-        window_size = input.size
+      def process(input)
+        window_size = input.window_size
         channels = input.channels
 
         # fft
-        @window.process!(input)
-        na = NArray.float(channels, window_size)
-        na[0...na.size] = input.to_a.flatten
+        input = @window.process(input)
+        na = input.to_float_na
         fft = FFTW3.fft(na, FFTW3::FORWARD) / na.length
 
         fft.size.times {|i|
@@ -23,25 +20,10 @@ module AudioStream
             fft[i] = 0i
           end
         }
-
         wet_na = FFTW3.fft(fft, FFTW3::BACKWARD)
 
-        case channels
-        when 1
-          window_size.times {|i|
-            input[i] = wet_na[i].real
-          }
-        when 2
-          window_size.times {|i|
-            wet1 = wet_na[i*2].real
-            wet2 = wet_na[(i*2)+1].real
-
-            input[i] = [wet1, wet2]
-          }
-        end
+        Buffer.from_na(wet_na)
       end
     end
   end
-
-  NArray.include Enumerable
 end

data/lib/audio_stream/fx/panning.rb

@@ -1,8 +1,6 @@
 module AudioStream
   module Fx
     class Panning
-      include BangProcess
-
       def initialize(pan: 0.0)
         @pan = pan
 
@@ -23,18 +21,26 @@ module AudioStream
         @normalize = [1.0 - pan, 1.0 + pan].max
       end
 
-      def process!(input)
-        return if @pan==0.0
+      def process(input)
+        return input if @pan==0.0
 
-        case input.channels
-        when 1
-        when 2
-          input.each_with_index {|fa, i|
-            l = (fa[0] * @l_gain + fa[1] * @lr_gain) / @normalize
-            r = (fa[1] * @r_gain + fa[0] * @rl_gain) / @normalize
-            input[i] = [l, r]
-          }
-        end
+        input = input.stereo
+        src = input.streams
+        src0 = src[0]
+        src1 = src[1]
+
+        output = Buffer.create_stereo(input.window_size)
+        dst = output.streams
+        dst0 = dst[0]
+        dst1 = dst[1]
+
+        input.window_size.times {|i|
+          l = (src0[i] * @l_gain + src1[i] * @lr_gain) / @normalize
+          r = (src1[i] * @r_gain + src0[i] * @rl_gain) / @normalize
+          dst0[i] = l
+          dst1[i] = r
+        }
+        output
       end
     end
   end

data/lib/audio_stream/fx/tremolo.rb

@@ -1,8 +1,6 @@
 module AudioStream
   module Fx
     class Tremolo
-      include BangProcess
-
       def initialize(soundinfo, freq:, depth:)
         @samplerate = soundinfo.samplerate
         @freq = freq.to_f
@@ -10,24 +8,18 @@ module AudioStream
         @phase = 0
       end
 
-      def process!(input)
-        window_size = input.size
-        channels = input.channels
-
+      def process(input)
+        window_size = input.window_size
         period = 2 * Math::PI * @freq / @samplerate
 
-        case channels
-        when 1
-          input.each_with_index {|f, i|
-            input[i] *= 1.0 + @depth * Math.sin((i + @phase) * period)
+        streams = input.streams.map {|stream|
+          stream.map.with_index {|f, i|
+            f * (1.0 + @depth * Math.sin((i + @phase) * period))
           }
-        when 2
-          input.each_with_index {|fa, i|
-            gain = 1.0 + @depth * Math.sin((i + @phase) * period)
-            input[i] = fa.map {|f| f * gain}
-          }
-        end
+        }
         @phase = (@phase + window_size) % (window_size / period)
+
+        Buffer.new(*streams)
       end
     end
   end

data/lib/audio_stream/fx/tuner.rb

@@ -19,19 +19,19 @@ module AudioStream
       end
 
       def process(input)
-        window_size = input.size
+        window_size = input.window_size
 
         # mono window
-        input = StereoToMono.instance.process(input)
-        @window.process!(input)
+        input = input.mono
+        input = @window.process(input)
+        stream = input.streams[0]
 
-        gain = input.to_a.flatten.max
+        gain = stream.map(&:abs).max
         freq = nil
 
         if 0.01<gain
           # fft
-          na = NArray.float(1, window_size)
-          na[0...na.size] = input.to_a
+          na = input.to_float_na
           fft = FFTW3.fft(na, FFTW3::FORWARD) / na.length
 
           amp = fft.map {|c|
@@ -41,12 +41,12 @@ module AudioStream
           # peak
           i = amp.index(amp.max)
 
-          if window_size/2<i
-            j = window_size - i
-            if (amp[i]-amp[j]).abs<=0.0000001
-              i = j
-            end
-          end
+          #if window_size/2<i
+          #  j = window_size - i
+          #  if (amp[i]-amp[j]).abs<=0.0000001
+          #    i = j
+          #  end
+          #end
 
           # freq
           freq_rate = @samplerate / window_size

data/lib/audio_stream/version.rb

@@ -1,3 +1,3 @@
 module AudioStream
-  VERSION = "1.5.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: audio_stream
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Yoshida Tetsuya
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-04 00:00:00.000000000 Z
+date: 2019-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -142,7 +142,9 @@ files:
 - lib/audio_stream/audio_notification.rb
 - lib/audio_stream/audio_observable.rb
 - lib/audio_stream/audio_observable_fx.rb
+- lib/audio_stream/audio_observable_lambda.rb
 - lib/audio_stream/audio_observer.rb
+- lib/audio_stream/audio_observer_lambda.rb
 - lib/audio_stream/audio_output.rb
 - lib/audio_stream/audio_output_device.rb
 - lib/audio_stream/audio_output_file.rb
@@ -168,14 +170,11 @@ files:
 - lib/audio_stream/fx/high_shelf_filter.rb
 - lib/audio_stream/fx/low_pass_filter.rb
 - lib/audio_stream/fx/low_shelf_filter.rb
-- lib/audio_stream/fx/mono_to_stereo.rb
 - lib/audio_stream/fx/noise_gate.rb
 - lib/audio_stream/fx/panning.rb
 - lib/audio_stream/fx/peaking_filter.rb
-- lib/audio_stream/fx/stereo_to_mono.rb
 - lib/audio_stream/fx/tremolo.rb
 - lib/audio_stream/fx/tuner.rb
-- lib/audio_stream/plot.rb
 - lib/audio_stream/ring_buffer.rb
 - lib/audio_stream/sound_info.rb
 - lib/audio_stream/sync.rb

data/lib/audio_stream/fx/mono_to_stereo.rb

@@ -1,20 +0,0 @@
-module AudioStream
-  module Fx
-    class MonoToStereo
-      include Singleton
-
-      def process(input)
-        case input.channels
-        when 1
-          output = Buffer.float(input.size, 2)
-          input.each_with_index {|f, i|
-            output[i] = [f, f]
-          }
-          output
-        when 2
-          input.clone
-        end
-      end
-    end
-  end
-end

data/lib/audio_stream/fx/stereo_to_mono.rb

@@ -1,20 +0,0 @@
-module AudioStream
-  module Fx
-    class StereoToMono
-      include Singleton
-
-      def process(input)
-        case input.channels
-        when 1
-          input.clone
-        when 2
-          output = Buffer.float(input.size, 1)
-          input.each_with_index {|fa, i|
-            output[i] = fa.sum / 2.0
-          }
-          output
-        end
-      end
-    end
-  end
-end

data/lib/audio_stream/plot.rb

@@ -1,53 +0,0 @@
-module AudioStream
-  class Plot
-    def initialize(input, soundinfo=nil)
-      @input = input
-      if soundinfo
-        @samplerate = soundinfo.samplerate.to_f
-      end
-    end
-
-    def wave
-      buf_to_plot(@input)
-    end
-
-    def fft(window=nil)
-      window ||= HanningWindow.instance
-
-      na = window.process(@input).to_na
-      fft = FFTW3.fft(na, FFTW3::FORWARD) / na.length
-
-      buf = Buffer.from_na(fft)
-      buf_to_plot(buf, true)
-    end
-
-    def buf_to_plot(input, x_hz=false)
-      window_size = input.size
-      channels = input.channels
-      outputs = []
-
-      case channels
-      when 1
-        outputs << input.to_a
-      when 2
-        outputs << output_l = []
-        outputs << output_r = []
-        window_size.times {|i|
-          output_l << input[i][0]
-          output_r << input[i][1]
-        }
-      end
-
-      window_arr = window_size.times.to_a
-      if x_hz && @samplerate
-        window_arr.map!{|i| i * @samplerate / window_size}
-      end
-
-      traces = outputs.map {|output|
-        {x: window_arr, y: output}
-      }
-
-      Plotly::Plot.new(data: traces)
-    end
-  end
-end