audio_stream 1.5.0 → 2.0.0

data/lib/audio_stream/fx.rb

@@ -21,8 +21,6 @@ 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

data/lib/audio_stream/fx/a_gain.rb

@@ -1,25 +1,19 @@
 module AudioStream
   module Fx
     class AGain
-      include BangProcess
-
       def initialize(level: 1.0)
         @level = level
       end
 
-      def process!(input)
-        return if @level==1.0
+      def process(input)
+        return input 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}
+        streams = input.streams.map {|stream|
+          stream.map {|f|
+            f * @level
           }
-        end
+        }
+        Buffer.new(*streams)
       end
     end
   end

data/lib/audio_stream/fx/biquad_filter.rb

@@ -1,8 +1,6 @@
 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)
@@ -11,6 +9,8 @@ module AudioStream
 
       FilterCoef = Struct.new("FilterCoef", :a0, :a1, :a2, :b0, :b1, :b2)
 
+      DEFAULT_Q = 1.0 / Math.sqrt(2.0)
+
       def initialize(soundinfo)
         @samplerate = soundinfo.samplerate.to_f
         init_buffer
@@ -21,40 +21,30 @@ module AudioStream
       end
 
       def update_coef(*args, **kwargs)
-        raise Error, "#{self.class.name}.filter_coef is not implemented"
+        raise Error, "#{self.class.name}.update_coef is not implemented"
       end
 
-      def process!(input)
-        window_size = input.size
+      def process(input)
+        window_size = input.window_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 = input[i]
-            input[i] = [
-              process_one(input_i[0], @filter_bufs[0]),
-              process_one(input_i[1], @filter_bufs[1]),
-            ]
+        streams = input.streams.map.with_index {|stream, i|
+          b = @filter_bufs[i]
+          stream.map {|f|
+            process_one(f, b)
           }
-        end
-
-        input
+        }
+        Buffer.new(*streams)
       end
 
       def process_mono(in0)
         process_one(in0, @filter_bufs[0])
       end
 
-      def process_stereo(inp)
+      def process_stereo(in0, in1)
         [
-          process_one(inp[0], @filter_bufs[0]),
-          process_one(inp[1], @filter_bufs[1])
+          process_one(in0, @filter_bufs[0]),
+          process_one(in1, @filter_bufs[1])
         ]
       end
 
@@ -70,7 +60,7 @@ module AudioStream
         out0
       end
 
-      def plot_data(width=1000)
+      def plot_data(width=500)
         c = @filter_coef
 
         b0 = c.b0 / c.a0

data/lib/audio_stream/fx/chorus.rb

@@ -1,54 +1,46 @@
 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)
+        @delaybufs = [
+          RingBuffer.new(@depth * 3, 0.0),
+          RingBuffer.new(@depth * 3, 0.0)
+        ]
 
         @phase = 0
         @speed = (2.0 * Math::PI * @rate) / @soundinfo.samplerate
       end
 
-      def process!(input)
-        window_size = input.size
+      def process(input)
+        window_size = input.window_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
+        streams = channels.times.map {|ch|
+          delaybuf = @delaybufs[ch]
+          input.streams[ch].map.with_index {|f, i|
+            tau = @depth * (Math.sin(@speed * (@phase + i)) + 1)
+            t = i - tau
+
+            m = t.floor
+            delta = t - m
+
+            wet = delta * delaybuf[i-m+1] + (1.0 - delta) * delaybuf[i-m]
+            f = (f + wet) * 0.5
+
+            delaybuf.current = f
+            delaybuf.rotate
+
+            f
+          }
         }
         @phase = (@phase + window_size) % (window_size / @speed)
+
+        Buffer.new(*streams)
       end
 
       def lerp(start, stop, step)

data/lib/audio_stream/fx/compressor.rb

@@ -1,40 +1,24 @@
 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|
+      def process(input)
+        streams = input.streams.map {|stream|
+          stream.map {|f|
             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
-            }
+            @zoom * f * sign
           }
-        end
+        }
+        Buffer.new(*streams)
       end
     end
   end

data/lib/audio_stream/fx/convolution_reverb.rb

@@ -1,38 +1,22 @@
 module AudioStream
   module Fx
     class ConvolutionReverb
-      include BangProcess
-
-      def initialize(impulse, dry: 0.5, wet: 0.5, window: nil)
+      def initialize(impulse, dry: 0.5, wet: 0.5)
         impulse_bufs = impulse.to_a
         @impulse_size = impulse_bufs.size
         @channels = impulse_bufs[0].channels
-        @window_size = impulse_bufs[0].size
+        @window_size = impulse_bufs[0].window_size
         @dry_gain = dry
         @wet_gain = wet
-        @window = window || HanningWindow.instance
-
-        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
 
+        zero_buf = Buffer.create(@window_size, @channels)
         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_bufs[i].to_float_na(na, 0)
+          impulse_bufs[i+1].to_float_na(na, @window_size)
           @impulse_ffts << FFTW3.fft(na, FFTW3::FORWARD) / na.length
         }
 
@@ -45,9 +29,9 @@ module AudioStream
         @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}"
+      def process(input)
+        if @window_size!=input.window_size
+          raise "window size is not match: impulse.size=#{@window_size} input.size=#{input.window_size}"
         end
         if @channels!=input.channels
           raise "channels is not match: impulse.channels=#{@channels} input.channels=#{input.channels}"
@@ -55,14 +39,9 @@ module AudioStream
 
         # current dry to wet
         na = NArray.float(@channels, @window_size*2)
+        @prev_input.to_float_na(na, 0)
+        input.to_float_na(na, @window_size)
 
-        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|
@@ -80,27 +59,39 @@ module AudioStream
         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
+        src0 = input.streams[0]
+        src1 = input.streams[1]
+
         case @channels
         when 1
+          output = Buffer.create_mono(@window_size)
+          dst0 = output.streams[0]
+
           @window_size.times {|i|
-            dry = input[i] * @dry_gain
+            dry = src0[i] * @dry_gain
             wet = wet_na[i].real
-            input[i] = dry + wet
+            dst0[i] = dry + wet
           }
         when 2
+          output = Buffer.create_stereo(@window_size)
+          dst0 = output.streams[0]
+          dst1 = output.streams[1]
+
           @window_size.times {|i|
             # dry
-            dry  = input[i]
-            dry1 = dry[0] * @dry_gain
-            dry2 = dry[1] * @dry_gain
+            dry0 = src0[i] * @dry_gain
+            dry1 = src1[i] * @dry_gain
 
             # wet
-            wet1 = wet_na[i*2].real
-            wet2 = wet_na[(i*2)+1].real
+            wet0 = wet_na[i*2].real
+            wet1 = wet_na[(i*2)+1].real
 
-            input[i] = [dry1 + wet1, dry2 + wet2]
+            dst0[i] = dry0 + wet0
+            dst1[i] = dry1 + wet1
           }
         end
+
+        output
       end
     end
   end

data/lib/audio_stream/fx/delay.rb

@@ -1,8 +1,6 @@
 module AudioStream
   module Fx
     class Delay
-      include BangProcess
-
       def initialize(soundinfo, time:, level:, feedback:)
         @time = time
         @level = level
@@ -14,30 +12,43 @@ module AudioStream
         @seek = 0
       end
 
-      def process!(input)
-        window_size = input.size
+      def process(input)
+        window_size = input.window_size
         channels = input.channels
 
+        src0 = input.streams[0]
+        src1 = input.streams[1]
+
         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
+          output = Buffer.create_mono(window_size)
+          dst0 = output.streams[0]
+
+          src0.each_with_index {|f, i|
+            tmp0 = f + @level * @delaybuf0[@seek]
+            @delaybuf0[@seek] = f + @feedback * @delaybuf0[@seek]
+            dst0[i] = tmp0
             @seek = (@seek + 1) % @delaysample
           }
+          output
         when 2
-          input.each_with_index {|fa, i|
-            tmp0 = input[i][0] + @level * @delaybuf0[@seek]
-            tmp1 = input[i][1] + @level * @delaybuf1[@seek]
+          output = Buffer.create_stereo(window_size)
+          dst0 = output.streams[0]
+          dst1 = output.streams[1]
+
+          window_size.times {|i|
+            tmp0 = src0[i] + @level * @delaybuf0[@seek]
+            tmp1 = src1[i] + @level * @delaybuf1[@seek]
 
-            @delaybuf0[@seek] = input[i][0] + @feedback * @delaybuf0[@seek]
-            @delaybuf1[@seek] = input[i][1] + @feedback * @delaybuf1[@seek]
+            @delaybuf0[@seek] = src0[i] + @feedback * @delaybuf0[@seek]
+            @delaybuf1[@seek] = src1[i] + @feedback * @delaybuf1[@seek]
 
-            input[i] = [tmp0, tmp1]
+            dst0[i] = tmp0
+            dst1[i] = tmp1
 
             @seek = (@seek + 1) % @delaysample
           }
+          output
         end
       end
     end

data/lib/audio_stream/fx/distortion.rb

@@ -1,41 +1,24 @@
 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
+      def process(input)
+        streams = input.streams.map {|stream|
+          stream.map {|f|
+            val = f * @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
-            }
+            val * @level
           }
-        end
+        }
+        Buffer.new(*streams)
       end
     end
   end