deftones 0.1.0 → 1.0.0

data/lib/deftones/portaudio_support.rb

@@ -6,13 +6,18 @@ module Deftones
   module PortAudioSupport
     class << self
       def available?
+        load_backend!
         !!defined?(PortAudio)
       end
 
       def acquire!
         raise Deftones::MissingRealtimeBackendError, "PortAudio backend is unavailable" unless available?
 
-        PortAudio.init
+        mutex.synchronize do
+          PortAudio.init if ref_count.zero?
+          @ref_count = ref_count + 1
+        end
+        self
       rescue StandardError => error
         raise Deftones::MissingRealtimeBackendError, error.message
       end
@@ -20,17 +25,35 @@ module Deftones
       def release
         return unless available?
 
-        PortAudio.terminate
+        mutex.synchronize do
+          return self if ref_count.zero?
+
+          @ref_count = ref_count - 1
+          PortAudio.terminate if ref_count.zero?
+        end
+        self
       rescue StandardError
         nil
       end
 
-      def output_parameters(channels)
-        build_stream_parameters(direction: :output, channels: channels)
+      def output_parameters(channels, device_id: nil, label: nil, sample_rate: nil)
+        build_stream_parameters(
+          direction: :output,
+          channels: channels,
+          device_id: device_id,
+          label: label,
+          sample_rate: sample_rate
+        )
       end
 
-      def input_parameters(channels, device_id: nil, label: nil)
-        build_stream_parameters(direction: :input, channels: channels, device_id: device_id, label: label)
+      def input_parameters(channels, device_id: nil, label: nil, sample_rate: nil)
+        build_stream_parameters(
+          direction: :input,
+          channels: channels,
+          device_id: device_id,
+          label: label,
+          sample_rate: sample_rate
+        )
       end
 
       def check_error!(result, fallback: nil)
@@ -41,11 +64,29 @@ module Deftones
 
       private
 
-      def build_stream_parameters(direction:, channels:, device_id: nil, label: nil)
+      def load_backend!
+        return true if defined?(PortAudio)
+
+        require "portaudio"
+        true
+      rescue LoadError
+        false
+      end
+
+      def mutex
+        @mutex ||= Mutex.new
+      end
+
+      def ref_count
+        @ref_count ||= 0
+      end
+
+      def build_stream_parameters(direction:, channels:, device_id: nil, label: nil, sample_rate: nil)
         device =
           resolve_device(direction: direction, device_id: device_id, label: label)
 
         raise Deftones::MissingRealtimeBackendError, "No default #{direction} device available" unless device
+        detect_sample_rate_mismatch!(device, sample_rate) if sample_rate
 
         {
           device: device,
@@ -101,11 +142,29 @@ module Deftones
         candidates = []
         candidates << device.label if device.respond_to?(:label)
         candidates << device.name if device.respond_to?(:name)
-        candidates.compact.any? { |candidate| candidate.to_s == label.to_s }
+        matcher = label.is_a?(Regexp) ? label : Regexp.new(Regexp.escape(label.to_s), Regexp::IGNORECASE)
+        candidates.compact.any? { |candidate| candidate.to_s.match?(matcher) }
       end
 
       def suggested_latency(device, direction)
-        direction == :input ? device.default_low_input_latency : device.default_low_output_latency
+        method_name = direction == :input ? :default_low_input_latency : :default_low_output_latency
+        return device.public_send(method_name) if device.respond_to?(method_name)
+
+        0.05
+      end
+
+      def detect_sample_rate_mismatch!(device, requested_sample_rate)
+        device_sample_rate =
+          if device.respond_to?(:default_sample_rate)
+            device.default_sample_rate
+          elsif device.respond_to?(:sample_rate)
+            device.sample_rate
+          end
+        return unless device_sample_rate
+        return if device_sample_rate.to_f == requested_sample_rate.to_f
+
+        raise Deftones::MissingRealtimeBackendError,
+              "PortAudio device sample rate #{device_sample_rate} does not match requested #{requested_sample_rate}"
       end
     end
   end

data/lib/deftones/source/fat_oscillator.rb

@@ -3,21 +3,32 @@
 module Deftones
   module Source
     class FatOscillator < Core::Source
-      attr_reader :frequency
-      attr_accessor :count, :spread, :type
+      attr_reader :count, :frequency, :spread, :type
 
       def initialize(type: :sawtooth, frequency: 440.0, count: 3, spread: 20.0, context: Deftones.context)
         super(context: context)
-        @type = type.to_sym
         @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
-        @count = count.to_i
-        @spread = spread.to_f
-        @phases = Array.new(@count, 0.0)
+        @phases = []
+        self.type = type
+        self.count = count
+        self.spread = spread
+      end
+
+      def count=(value)
+        @count = [value.to_i, 1].max
+        @phases = Array.new(@count, 0.0) if @phases.length != @count
+      end
+
+      def spread=(value)
+        @spread = value.to_f
+      end
+
+      def type=(value)
+        @type = normalize_type(value)
       end
 
       def process(_input_buffer, num_frames, start_frame, _cache)
         frequencies = @frequency.process(num_frames, start_frame)
-        generator = Oscillator::GENERATORS.fetch(@type) { Oscillator::GENERATORS[:sawtooth] }
 
         Array.new(num_frames) do |index|
           current_time = (start_frame + index).to_f / context.sample_rate
@@ -25,8 +36,9 @@ module Deftones
 
           detuned = detune_frequencies(frequencies[index])
           samples = @phases.each_with_index.map do |phase, voice_index|
-            sample = generator.call(phase)
-            @phases[voice_index] = (phase + (detuned[voice_index] / context.sample_rate)) % 1.0
+            phase_increment = detuned[voice_index] / context.sample_rate
+            sample = Oscillator.sample(@type, phase, phase_increment)
+            @phases[voice_index] = (phase + phase_increment) % 1.0
             sample
           end
           samples.sum / samples.length.to_f
@@ -44,6 +56,13 @@ module Deftones
         @phases = Array.new(@count, 0.0) if @phases.length != @count
         offsets
       end
+
+      def normalize_type(type)
+        normalized = type.to_sym
+        return normalized if Oscillator::TYPES.include?(normalized)
+
+        raise ArgumentError, "Unsupported oscillator type: #{type}"
+      end
     end
   end
 end

data/lib/deftones/source/grain_player.rb

@@ -3,21 +3,33 @@
 module Deftones
   module Source
     class GrainPlayer < Player
+      WINDOWS = %i[linear hann hamming blackman].freeze
+
       attr_reader :detune
       attr_accessor :grain_size, :overlap, :jitter
+      attr_reader :window
 
-      def initialize(grain_size: 0.05, overlap: 0.5, jitter: 0.002, detune: 0.0, **options)
+      def initialize(grain_size: 0.05, overlap: 0.5, jitter: 0.002, detune: 0.0,
+                     window: :linear, jitter_seed: nil, rng: nil, **options)
         super(**options)
         @grain_size = grain_size.to_f
         @overlap = overlap.to_f
         @jitter = jitter.to_f
         @detune = Core::Signal.new(value: detune, units: :number, context: context)
+        @window = normalize_window(window)
+        @jitter_seed = jitter_seed
+        @rng = rng
+        @grain_random_cache = {}
       end
 
       def detune=(value)
         @detune.value = value
       end
 
+      def window=(value)
+        @window = normalize_window(value)
+      end
+
       def process(_input_buffer, num_frames, start_frame, _cache)
         rates = @playback_rate.process(num_frames, start_frame)
         detunes = @detune.process(num_frames, start_frame)
@@ -156,10 +168,35 @@ module Deftones
       end
 
       def grain_random(grain_index)
-        Math.sin((grain_index + 1) * 12_989.0).abs % 1.0
+        return @grain_random_cache[grain_index] if @grain_random_cache.key?(grain_index)
+
+        @grain_random_cache[grain_index] =
+          if @rng
+            @rng.rand
+          elsif @jitter_seed
+            Random.new(@jitter_seed.to_i + grain_index).rand
+          else
+            Math.sin((grain_index + 1) * 12_989.0).abs % 1.0
+          end
       end
 
       def grain_window_gain(grain_elapsed, grain_duration, overlap_duration)
+        return overlapped_linear_gain(grain_elapsed, grain_duration, overlap_duration) if @window == :linear
+
+        progress = (grain_elapsed / grain_duration).clamp(0.0, 1.0)
+        case @window
+        when :hann
+          0.5 - (0.5 * Math.cos(2.0 * Math::PI * progress))
+        when :hamming
+          0.54 - (0.46 * Math.cos(2.0 * Math::PI * progress))
+        when :blackman
+          0.42 - (0.5 * Math.cos(2.0 * Math::PI * progress)) + (0.08 * Math.cos(4.0 * Math::PI * progress))
+        else
+          overlapped_linear_gain(grain_elapsed, grain_duration, overlap_duration)
+        end
+      end
+
+      def overlapped_linear_gain(grain_elapsed, grain_duration, overlap_duration)
         return 1.0 if overlap_duration <= 0.0
 
         fade_in = (grain_elapsed / overlap_duration).clamp(0.0, 1.0)
@@ -167,6 +204,16 @@ module Deftones
         [fade_in, fade_out].min
       end
 
+      def normalize_window(window)
+        normalized = window.to_sym
+        return normalized if WINDOWS.include?(normalized)
+
+        raise ArgumentError, "Unsupported grain window: #{window}"
+      end
+
+      alias grainWindow window
+      alias grainWindow= window=
+
       def naturally_finished?(current_time, playback_rate, grain_duration)
         return false if @loop
         return false unless playback_rate.positive?

data/lib/deftones/source/noise.rb

@@ -5,17 +5,18 @@ module Deftones
     class Noise < Core::Source
       TYPES = %i[white pink brown].freeze
 
-      attr_accessor :type, :fade_in, :fade_out
-      attr_reader :playback_rate
+      attr_accessor :fade_in, :fade_out
+      attr_reader :playback_rate, :type
 
-      def initialize(type: :white, playback_rate: 1.0, fade_in: 0.0, fade_out: 0.0, context: Deftones.context)
+      def initialize(type: :white, playback_rate: 1.0, fade_in: 0.0, fade_out: 0.0, seed: nil, rng: nil,
+                     context: Deftones.context)
         super(context: context)
-        @type = normalize_type(type)
         @playback_rate = playback_rate.to_f
         @fade_in = fade_in.to_f
         @fade_out = fade_out.to_f
-        @pink_state = 0.0
-        @brown_state = 0.0
+        @rng = rng || (seed.nil? ? Random : Random.new(seed))
+        reset_colored_state
+        self.type = type
         @held_sample = next_noise_sample
         @playback_phase = 0.0
       end
@@ -24,6 +25,15 @@ module Deftones
         @playback_rate = value.to_f
       end
 
+      def type=(value)
+        normalized = normalize_type(value)
+        return @type = normalized if @type == normalized
+
+        @type = normalized
+        reset_colored_state
+        @held_sample = next_noise_sample if defined?(@held_sample)
+      end
+
       def process(_input_buffer, num_frames, start_frame, _cache)
         Array.new(num_frames) do |index|
           current_time = (start_frame + index).to_f / context.sample_rate
@@ -72,19 +82,41 @@ module Deftones
       end
 
       def next_noise_sample
-        white = (rand * 2.0) - 1.0
+        white = (@rng.rand * 2.0) - 1.0
 
         case normalize_type(@type)
         when :white
           white
         when :pink
-          @pink_state = (0.98 * @pink_state) + (0.02 * white)
-          @pink_state * 3.5
+          pink_noise_sample(white)
         when :brown
-          @brown_state = Deftones::DSP::Helpers.clamp(@brown_state + (white * 0.02), -1.0, 1.0)
+          brown_noise_sample(white)
         end
       end
 
+      def pink_noise_sample(white)
+        @pink_state[0] = (0.99886 * @pink_state[0]) + (white * 0.0555179)
+        @pink_state[1] = (0.99332 * @pink_state[1]) + (white * 0.0750759)
+        @pink_state[2] = (0.96900 * @pink_state[2]) + (white * 0.1538520)
+        @pink_state[3] = (0.86650 * @pink_state[3]) + (white * 0.3104856)
+        @pink_state[4] = (0.55000 * @pink_state[4]) + (white * 0.5329522)
+        @pink_state[5] = (-0.7616 * @pink_state[5]) - (white * 0.0168980)
+
+        sample = @pink_state[0..6].sum + (white * 0.5362)
+        @pink_state[6] = white * 0.115926
+        Deftones::DSP::Helpers.clamp(sample * 0.11, -1.0, 1.0)
+      end
+
+      def brown_noise_sample(white)
+        @brown_state = (@brown_state + (0.02 * white)) / 1.02
+        Deftones::DSP::Helpers.clamp(@brown_state * 3.5, -1.0, 1.0)
+      end
+
+      def reset_colored_state
+        @pink_state = Array.new(7, 0.0)
+        @brown_state = 0.0
+      end
+
       def normalize_type(type)
         normalized = type.to_sym
         return normalized if TYPES.include?(normalized)

data/lib/deftones/source/omni_oscillator.rb

@@ -29,8 +29,7 @@ module Deftones
         fat: FatOscillator
       }.freeze
 
-      attr_reader :source
-      attr_accessor :type
+      attr_reader :source, :type
 
       def initialize(type: :sine, context: Deftones.context, **options)
         super(context: context)

data/lib/deftones/source/oscillator.rb

@@ -3,27 +3,82 @@
 module Deftones
   module Source
     class Oscillator < Core::Source
+      TYPES = %i[sine square sawtooth triangle].freeze
       GENERATORS = {
-        sine: lambda { |phase|
-          Math.sin(2.0 * Math::PI * phase)
-        },
-        square: lambda { |phase|
-          phase < 0.5 ? 1.0 : -1.0
-        },
-        sawtooth: lambda { |phase|
-          (2.0 * phase) - 1.0
-        },
-        triangle: lambda { |phase|
-          (4.0 * (phase < 0.5 ? phase : 1.0 - phase)) - 1.0
-        }
+        sine: ->(phase) { Math.sin(2.0 * Math::PI * phase) },
+        square: ->(phase) { phase < 0.5 ? 1.0 : -1.0 },
+        sawtooth: ->(phase) { (2.0 * phase) - 1.0 },
+        triangle: ->(phase) { (4.0 * (phase < 0.5 ? phase : 1.0 - phase)) - 1.0 }
       }.freeze
 
-      attr_reader :frequency, :detune
-      attr_accessor :type
+      class << self
+        def sample(type, phase, phase_increment = 0.0)
+          case type
+          when :sine
+            Math.sin(2.0 * Math::PI * phase)
+          when :square
+            bandlimited_square(phase, phase_increment)
+          when :sawtooth
+            bandlimited_sawtooth(phase, phase_increment)
+          when :triangle
+            bandlimited_triangle(phase, phase_increment)
+          end
+        end
+
+        private
+
+        def bandlimited_square(phase, phase_increment)
+          sample = phase < 0.5 ? 1.0 : -1.0
+          sample += poly_blep(phase, phase_increment)
+          sample -= poly_blep((phase + 0.5) % 1.0, phase_increment)
+          sample
+        end
+
+        def bandlimited_sawtooth(phase, phase_increment)
+          ((2.0 * phase) - 1.0) - poly_blep(phase, phase_increment)
+        end
+
+        def bandlimited_triangle(phase, phase_increment)
+          return naive_triangle(phase) unless phase_increment.positive?
+
+          max_harmonic = (0.5 / phase_increment.abs).floor
+          return naive_triangle(phase) if max_harmonic < 1
+
+          sum = 0.0
+          harmonic = 1
+          while harmonic <= max_harmonic
+            sum += Math.cos(2.0 * Math::PI * harmonic * phase) / (harmonic * harmonic)
+            harmonic += 2
+          end
+          -(8.0 / (Math::PI * Math::PI)) * sum
+        end
+
+        def naive_triangle(phase)
+          (4.0 * (phase < 0.5 ? phase : 1.0 - phase)) - 1.0
+        end
+
+        def poly_blep(phase, phase_increment)
+          increment = [phase_increment.abs, 1.0e-9].max
+          return poly_blep_start(phase / increment) if phase < increment
+          return poly_blep_end((phase - 1.0) / increment) if phase > 1.0 - increment
+
+          0.0
+        end
+
+        def poly_blep_start(t)
+          (t + t) - (t * t) - 1.0
+        end
+
+        def poly_blep_end(t)
+          (t * t) + (t + t) + 1.0
+        end
+      end
+
+      attr_reader :detune, :frequency, :type
 
       def initialize(type: :sine, frequency: 440.0, detune: 0.0, phase: 0.0, context: Deftones.context)
         super(context: context)
-        @type = normalize_type(type)
+        self.type = type
         @frequency = Core::Signal.new(value: frequency, units: :frequency, context: context)
         @detune = Core::Signal.new(value: detune, units: :number, context: context)
         self.phase = phase
@@ -41,8 +96,12 @@ module Deftones
         @phase = value.to_f % 1.0
       end
 
+      def type=(value)
+        @type = normalize_type(value)
+      end
+
       def process(_input_buffer, num_frames, start_frame, _cache)
-        generator = GENERATORS.fetch(normalize_type(@type))
+        oscillator_type = normalize_type(@type)
         frequencies = @frequency.process(num_frames, start_frame)
         detunes = @detune.process(num_frames, start_frame)
 
@@ -50,22 +109,27 @@ module Deftones
           current_time = (start_frame + index).to_f / context.sample_rate
           next 0.0 unless active_at?(current_time)
 
-          sample = generator.call(@phase)
           frequency = frequencies[index] * detune_ratio(detunes[index])
-          @phase = (@phase + (frequency / context.sample_rate)) % 1.0
+          phase_increment = frequency / context.sample_rate
+          sample = sample_for(oscillator_type, @phase, phase_increment)
+          @phase = (@phase + phase_increment) % 1.0
           sample
         end
       end
 
       private
 
+      def sample_for(type, phase, phase_increment)
+        Oscillator.sample(type, phase, phase_increment)
+      end
+
       def detune_ratio(cents)
         2.0**(cents.to_f / 1200.0)
       end
 
       def normalize_type(type)
         normalized = type.to_sym
-        return normalized if GENERATORS.key?(normalized)
+        return normalized if TYPES.include?(normalized)
 
         raise ArgumentError, "Unsupported oscillator type: #{type}"
       end

data/lib/deftones/source/player.rb

@@ -79,6 +79,7 @@ module Deftones
 
       def process(_input_buffer, num_frames, start_frame, _cache)
         rates = @playback_rate.process(num_frames, start_frame)
+        sample_positions = sample_positions_for(num_frames, start_frame, rates)
         return process_multichannel_buffer(num_frames, start_frame, rates) if multichannel_process?
 
         Array.new(num_frames) do |index|
@@ -86,7 +87,7 @@ module Deftones
           notify_stop(current_time) if @stop_time && current_time >= @stop_time
           next 0.0 unless active_at?(current_time)
 
-          sample_position = sample_position_for(current_time, rates[index])
+          sample_position = sample_positions[index]
           if sample_position.negative?
             @stop_time ||= current_time
             notify_stop(current_time)
@@ -161,13 +162,14 @@ module Deftones
 
       def process_multichannel_buffer(num_frames, start_frame, rates)
         output = Array.new(@buffer.channels) { Array.new(num_frames, 0.0) }
+        sample_positions = sample_positions_for(num_frames, start_frame, rates)
 
         num_frames.times do |index|
           current_time = (start_frame + index).to_f / context.sample_rate
           notify_stop(current_time) if @stop_time && current_time >= @stop_time
           next unless active_at?(current_time)
 
-          sample_position = sample_position_for(current_time, rates[index])
+          sample_position = sample_positions[index]
           if sample_position.negative?
             @stop_time ||= current_time
             notify_stop(current_time)
@@ -183,10 +185,26 @@ module Deftones
         Core::AudioBlock.from_channel_data(output)
       end
 
-      def sample_position_for(current_time, rate)
-        elapsed_frames = (current_time - @start_time) * @buffer.sample_rate * rate
-        base_position = @seek_position + elapsed_frames
-        resolve_buffer_position(base_position)
+      def sample_positions_for(num_frames, start_frame, rates)
+        return Array.new(num_frames, -1.0) if @start_time.infinite?
+
+        ratio = @buffer.sample_rate.to_f / context.sample_rate
+        base_position = integrated_position_at_frame(start_frame)
+
+        Array.new(num_frames) do |index|
+          position = resolve_buffer_position(base_position)
+          base_position += rates[index].to_f * ratio
+          position
+        end
+      end
+
+      def integrated_position_at_frame(frame_index)
+        start_frame = (@start_time * context.sample_rate).floor
+        frames_to_integrate = [frame_index - start_frame, 0].max
+        return @seek_position if frames_to_integrate.zero?
+
+        rates = @playback_rate.process(frames_to_integrate, start_frame)
+        @seek_position + (rates.sum * (@buffer.sample_rate.to_f / context.sample_rate))
       end
 
       def resolve_buffer_position(base_position)

data/lib/deftones/source/players.rb

@@ -7,7 +7,7 @@ module Deftones
 
       class VolumeProxy
         attr_reader :players
-        attr_accessor :value
+        attr_reader :value
 
         def initialize(players, value: 0.0)
           @players = players
@@ -19,13 +19,29 @@ module Deftones
           players.send(:apply_controls!)
         end
 
-        def ramp_to(target_value, _duration = nil)
-          self.value = target_value
+        def ramp_to(target_value, duration = nil)
+          @value = target_value.to_f
+          players.each { |player| player.volume.ramp_to(@value, duration) }
           self
         end
 
-        alias linear_ramp_to ramp_to
-        alias exponential_ramp_to ramp_to
+        def set_value_at_time(target_value, time)
+          @value = target_value.to_f
+          players.each { |player| player.volume.set_value_at_time(@value, time) }
+          self
+        end
+
+        def linear_ramp_to(target_value, duration = nil)
+          ramp_to(target_value, duration)
+        end
+
+        def exponential_ramp_to(target_value, duration = nil)
+          ramp_to(target_value, duration)
+        end
+
+        alias setValueAtTime set_value_at_time
+        alias linearRampTo linear_ramp_to
+        alias exponentialRampTo exponential_ramp_to
       end
 
       attr_reader :volume
@@ -41,6 +57,8 @@ module Deftones
       end
 
       def add(name, buffer)
+        raise Deftones::Error, "cannot add player to disposed Players" if @disposed
+
         player = Player.new(buffer: buffer, context: @context)
         player.volume.value = @volume.value
         player.mute = @mute
@@ -93,11 +111,25 @@ module Deftones
         @volume.value = value
       end
 
-      def stop_all(time = nil)
+      def stop_all(time = nil, dispose: false)
         @players.each_value { |player| player.stop(time) }
+        self.dispose if dispose
         self
       end
 
+      def stop_all_and_dispose(time = nil)
+        stop_all(time)
+        dispose
+      end
+
+      def stopped?(time = @context.current_time)
+        state(time: time).values.all? { |entry| entry == :stopped }
+      end
+
+      def disposed?
+        @disposed
+      end
+
       def state(name = nil, time: @context.current_time)
         return get(name)&.state(time) if name
 
@@ -118,6 +150,7 @@ module Deftones
       end
 
       alias stopAll stop_all
+      alias stopAllAndDispose stop_all_and_dispose
 
       private