audio_stream 1.0.0

data/lib/audio_stream/fx/convolution_reverb.rb

@@ -0,0 +1,107 @@
+module AudioStream
+  module Fx
+    class ConvolutionReverb
+      include BangProcess
+
+      def initialize(impulse, dry: 0.5, wet: 0.5, window: nil)
+        impulse_bufs = impulse.to_a
+        @impulse_size = impulse_bufs.size
+        @channels = impulse_bufs[0].channels
+        @window_size = impulse_bufs[0].size
+        @dry_gain = dry
+        @wet_gain = wet
+        @window = window || HanningWindow.new
+
+        zero_buf = Buffer.float(@window_size, @channels)
+        if @channels==1
+          zero_buf.size.times {|i| zero_buf[i] = 0}
+        else
+          zero_buf.size.times {|i| zero_buf[i] = Array.new(@channels, 0)}
+        end
+
+        impulse_bufs = [zero_buf.clone] + impulse_bufs
+
+        @impulse_ffts = []
+        @impulse_size.times {|i|
+          na = NArray.float(@channels, @window_size*2)
+
+          buf1 = impulse_bufs[i]
+          buf1_flat = buf1.to_a.flatten
+          na[0...buf1_flat.size] = buf1_flat
+
+          buf2 = impulse_bufs[i+1]
+          buf2_flat = buf2.to_a.flatten
+          na[buf1.size...(buf1.size+buf2_flat.size)] = buf2_flat
+
+          @impulse_ffts << FFTW3.fft(na, FFTW3::FORWARD) / na.length
+        }
+
+        @impulse_max_gain =  @impulse_ffts.map{|c| c.real**2 + c.imag**2}.map(&:sum).max / @channels
+
+        @wet_ffts = RingBuffer.new(@impulse_size) {
+          Array.new(@impulse_size, NArray.float(@channels, @window_size*2))
+        }
+
+        @prev_input = zero_buf.clone
+      end
+
+      def process!(input)
+        if @window_size!=input.size
+          raise "window size is not match: impulse.size=#{@window_size} input.size=#{input.size}"
+        end
+        if @channels!=input.channels
+          raise "channels is not match: impulse.channels=#{@channels} input.channels=#{input.channels}"
+        end
+
+        # current dry to wet
+        na = NArray.float(@channels, @window_size*2)
+
+        prev_flat = @prev_input.to_a.flatten
+        na[0...prev_flat.size] = prev_flat
+
+        input_flat = input.to_a.flatten
+        na[@prev_input.size...(@prev_input.size+input_flat.size)] = input_flat
+
+        na = @window.process!(Buffer.from_na(na)).to_na
+        input_fft = FFTW3.fft(na, FFTW3::FORWARD) / na.length
+
+        @wet_ffts.current = @impulse_ffts.map {|impulse_fft|
+          input_fft * impulse_fft
+        }
+        @wet_ffts.rotate
+        @prev_input = input.clone
+
+        # calc wet matrix sum
+        wet_fft = NArray.complex(@channels, @window_size*2)
+        @wet_ffts.each_with_index {|wet, i|
+          wet_fft += wet[@impulse_size-i-1]
+        }
+
+        wet_na = FFTW3.fft(wet_fft, FFTW3::BACKWARD)[(@channels*@window_size)...(@channels*@window_size*2)] * (@wet_gain / @impulse_max_gain)
+
+        # current dry + wet matrix sum
+        case @channels
+        when 1
+          @window_size.times {|i|
+            dry = input[i] * @dry_gain
+            wet = wet_na[i].real
+            input[i] = dry + wet
+          }
+        when 2
+          @window_size.times {|i|
+            # dry
+            dry  = input[i]
+            dry1 = dry[0] * @dry_gain
+            dry2 = dry[1] * @dry_gain
+
+            # wet
+            wet1 = wet_na[i*2].real
+            wet2 = wet_na[(i*2)+1].real
+
+            input[i] = [dry1 + wet1, dry2 + wet2]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/delay.rb

@@ -0,0 +1,45 @@
+module AudioStream
+  module Fx
+    class Delay
+      include BangProcess
+
+      def initialize(soundinfo, time:, level:, feedback:)
+        @time = time
+        @level = level
+        @feedback = feedback
+
+        @delaysample = soundinfo.samplerate * time / 1000.0
+        @delaybuf0 = Array.new(@delaysample, 0.0)
+        @delaybuf1 = Array.new(@delaysample, 0.0)
+        @seek = 0
+      end
+
+      def process!(input)
+        window_size = input.size
+        channels = input.channels
+
+        case channels
+        when 1
+          input.each_with_index {|f, i|
+            tmp0 = input[i] + @level * @delaybuf0[@seek]
+            @delaybuf0[@seek] = input[i] + @feedback * @delaybuf0[@seek]
+            input[i] = tmp0
+            @seek = (@seek + 1) % @delaysample
+          }
+        when 2
+          input.each_with_index {|fa, i|
+            tmp0 = input[i][0] + @level * @delaybuf0[@seek]
+            tmp1 = input[i][1] + @level * @delaybuf1[@seek]
+
+            @delaybuf0[@seek] = input[i][0] + @feedback * @delaybuf0[@seek]
+            @delaybuf1[@seek] = input[i][1] + @feedback * @delaybuf1[@seek]
+
+            input[i] = [tmp0, tmp1]
+
+            @seek = (@seek + 1) % @delaysample
+          }
+        end
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/distortion.rb

@@ -0,0 +1,42 @@
+module AudioStream
+  module Fx
+    class Distortion
+      include BangProcess
+
+      def initialize(gain: 100, level: 0.1)
+        @gain = gain
+        @level = level
+      end
+
+      def process!(input)
+        window_size = input.size
+        channels = input.channels
+
+        case channels
+        when 1
+          input.each_with_index {|f, i|
+            val = input[i] * @gain
+            if 1.0 < val
+              val = 1.0
+            elsif val < -1.0
+              val = -1.0
+            end
+            input[i] = val * @level
+          }
+        when 2
+          input.each_with_index {|fa, i|
+            input[i] = fa.map {|f|
+              val = f * @gain
+              if 1.0 < val
+                val = 1.0
+              elsif val < -1.0
+                val = -1.0
+              end
+              val * @level
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/equalizer_2band.rb

@@ -0,0 +1,23 @@
+module AudioStream
+  module Fx
+    class Equalizer2band
+      include BangProcess
+
+      def initialize(soundinfo, lowgain:, highgain:)
+        @lowfreq = 400.0
+        @lowgain = lowgain
+
+        @highfreq = 4000.0
+        @highgain = highgain
+
+        @low_filter = LowShelfFilter.new(soundinfo, freq: @lowfreq, q: 1.0/Math.sqrt(2.0), gain: @lowgain)
+        @high_filter = HighShelfFilter.new(soundinfo, freq: @highfreq, q: 1.0/Math.sqrt(2.0), gain: @highgain)
+      end
+
+      def process!(input)
+        @low_filter.process!(input)
+        @high_filter.process!(input)
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/equalizer_3band.rb

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

data/lib/audio_stream/fx/hanning_window.rb

@@ -0,0 +1,29 @@
+module AudioStream
+  module Fx
+    class HanningWindow
+      include BangProcess
+
+      def process!(input)
+        window_size = input.size
+        window_max = input.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)
+          }
+        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
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/high_pass_filter.rb

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

data/lib/audio_stream/fx/high_shelf_filter.rb

@@ -0,0 +1,32 @@
+module AudioStream
+  module Fx
+    class HighShelfFilter < BiquadFilter
+
+      def initialize(soundinfo, freq:, q: nil, gain: 1.0)
+        super()
+        @samplerate = soundinfo.samplerate.to_f
+        @freq = freq
+        @q = q || 1.0 / Math.sqrt(2)
+        @gain = gain
+
+        filter_coef
+      end
+
+      def filter_coef
+        omega = 2.0 * Math::PI * @freq / @samplerate
+        alpha = Math.sin(omega) / (2.0 * @q)
+        a = 10.0 ** (@gain / 40.0)
+        beta = Math.sqrt(a) / @q
+
+        a0 = (a+1) - (a-1) * Math.cos(omega) + beta * Math.sin(omega)
+        a1 = 2.0 * ((a-1) - (a+1) * Math.cos(omega))
+        a2 = (a+1) - (a-1) * Math.cos(omega) - beta * Math.sin(omega)
+        b0 = a * ((a+1) + (a-1) * Math.cos(omega) + beta * Math.sin(omega))
+        b1 = -2.0 * a * ((a-1) + (a+1) * Math.cos(omega))
+        b2 = a * ((a+1) + (a-1) * Math.cos(omega) - beta * Math.sin(omega))
+
+        @filter_coef = FilterCoef.new(a0, a1, a2, b0, b1, b2)
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/low_pass_filter.rb

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

data/lib/audio_stream/fx/low_shelf_filter.rb

@@ -0,0 +1,32 @@
+module AudioStream
+  module Fx
+    class LowShelfFilter < BiquadFilter
+
+      def initialize(soundinfo, freq:, q: nil, gain: 1.0)
+        super()
+        @samplerate = soundinfo.samplerate.to_f
+        @freq = freq
+        @q = q || 1.0 / Math.sqrt(2)
+        @gain = gain
+
+        filter_coef
+      end
+
+      def filter_coef
+        omega = 2.0 * Math::PI * @freq / @samplerate
+        alpha = Math.sin(omega) / (2.0 * @q)
+        a = 10.0 ** (@gain / 40.0)
+        beta = Math.sqrt(a) / @q
+
+        a0 = (a+1) + (a-1) * Math.cos(omega) + beta * Math.sin(omega)
+        a1 = -2.0 * ((a-1) + (a+1) * Math.cos(omega))
+        a2 = (a+1) + (a-1) * Math.cos(omega) - beta * Math.sin(omega)
+        b0 = a * ((a+1) - (a-1) * Math.cos(omega) + beta * Math.sin(omega))
+        b1 = 2.0 * a * ((a-1) - (a+1) * Math.cos(omega))
+        b2 = a * ((a+1) - (a-1) * Math.cos(omega) - beta * Math.sin(omega))
+
+        @filter_coef = FilterCoef.new(a0, a1, a2, b0, b1, b2)
+      end
+    end
+  end
+end

data/lib/audio_stream/fx/mono_to_stereo.rb

@@ -0,0 +1,18 @@
+module AudioStream
+  module Fx
+    class MonoToStereo
+      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/noise_gate.rb

@@ -0,0 +1,47 @@
+module AudioStream
+  module Fx
+    class NoiseGate
+      include BangProcess
+
+      def initialize(threshold: 0.01)
+        @threshold = threshold
+        @window = HanningWindow.new
+      end
+
+      def process!(input)
+        window_size = input.size
+        channels = input.channels
+
+        # fft
+        @window.process!(input)
+        na = NArray.float(channels, window_size)
+        na[0...na.size] = input.to_a.flatten
+        fft = FFTW3.fft(na, FFTW3::FORWARD) / na.length
+
+        fft.size.times {|i|
+          if fft[i].abs < @threshold
+            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
+      end
+    end
+  end
+
+  NArray.include Enumerable
+end