deftones 0.1.0 → 1.0.0

data/lib/deftones/context.rb

@@ -6,31 +6,45 @@ module Deftones
     DEFAULT_BUFFER_SIZE = 256
     DEFAULT_CHANNELS = 2
 
-    attr_reader :sample_rate, :buffer_size, :channels, :stream_error, :latency_hint, :look_ahead
+    attr_reader :buffer_size, :channels, :draw, :latency_hint, :look_ahead, :output_device_id,
+                :output_device_label, :sample_rate, :stream_error, :stream_status_flags, :transport
+    attr_accessor :on_stream_error
 
     def initialize(sample_rate: DEFAULT_SAMPLE_RATE, buffer_size: DEFAULT_BUFFER_SIZE, channels: DEFAULT_CHANNELS,
-                   realtime_backend: nil, autostart: true, latency_hint: "interactive", look_ahead: nil)
+                   realtime_backend: nil, autostart: true, latency_hint: "interactive", look_ahead: nil,
+                   transport: nil, draw: nil, on_stream_error: nil, stream_error_mode: :abort,
+                   output_device_id: nil, output_device_label: nil)
       @sample_rate = sample_rate
       @buffer_size = buffer_size
       @channels = channels
+      @transport = transport || Event::Transport.new(clock: self)
+      @draw = draw || Draw.new
       @realtime_backend = realtime_backend
       @autostart = autostart
       @latency_hint = latency_hint
       @look_ahead = look_ahead || (buffer_size.to_f / sample_rate)
+      @output_device_id = output_device_id
+      @output_device_label = output_device_label
+      @on_stream_error = on_stream_error
+      @stream_error_mode = normalize_stream_error_mode(stream_error_mode)
       @output = Core::Gain.new(context: self, gain: 1.0)
       @running = false
       @closed = false
       @started_at = monotonic_time
       @stream = nil
       @rendered_frames = 0
+      @scheduler_position = 0.0
       @stream_error = nil
+      @stream_status_flags = []
     end
 
     def start(use_realtime: true)
       @closed = false
       @started_at = monotonic_time
       @rendered_frames = 0
+      @scheduler_position = 0.0
       @stream_error = nil
+      @stream_status_flags.clear
       @running = true
       start_realtime_stream if use_realtime
       self
@@ -101,11 +115,38 @@ module Deftones
       buffer_size.to_f / sample_rate
     end
 
+    def reset!
+      stop
+      @transport = Event::Transport.new(clock: self)
+      @draw = Draw.new
+      @stream_error = nil
+      @stream_status_flags.clear
+      @rendered_frames = 0
+      @scheduler_position = 0.0
+      self
+    end
+
     alias rawContext raw_context
     alias sampleTime sample_time
     alias blockTime block_time
     alias latencyHint latency_hint
     alias lookAhead look_ahead
+    alias outputDeviceId output_device_id
+    alias outputDeviceLabel output_device_label
+    alias onStreamError on_stream_error
+    alias onStreamError= on_stream_error=
+
+    def stream_error_mode
+      @stream_error_mode
+    end
+
+    def stream_error_mode=(value)
+      @stream_error_mode = normalize_stream_error_mode(value)
+    end
+
+    alias streamErrorMode stream_error_mode
+    alias streamErrorMode= stream_error_mode=
+    alias streamStatusFlags stream_status_flags
 
     private
 
@@ -138,12 +179,42 @@ module Deftones
 
     def pull_realtime_samples(frames)
       start_frame = @rendered_frames
+      next_frame = start_frame + frames
+      window_start = start_frame.to_f / sample_rate
+      window_end = next_frame.to_f / sample_rate
+      scheduler_end = window_end + look_ahead
+      scheduler_start = [@scheduler_position, window_start].max
+      @transport.prepare_render_window(scheduler_start, scheduler_end)
+      Deftones.transport.prepare_render_window(scheduler_start, scheduler_end) unless Deftones.transport.equal?(@transport)
       chunk = render_block_frames(frames, start_frame).fit_channels(@channels)
-      @rendered_frames += frames
-      Deftones.draw.advance_to(@rendered_frames.to_f / sample_rate)
+      @rendered_frames = next_frame
+      @scheduler_position = scheduler_end
+      @draw.advance_to(scheduler_end)
+      Deftones.draw.advance_to(scheduler_end) unless Deftones.draw.equal?(@draw)
       chunk.interleaved
     end
 
+    def handle_stream_error(error)
+      @stream_error ||= error
+      @on_stream_error&.call(error)
+      @stream_error_mode == :continue ? :continue : :abort
+    end
+
+    def record_stream_status_flags(status_flags)
+      return self if status_flags.nil?
+      return self if status_flags.respond_to?(:zero?) && status_flags.zero?
+
+      @stream_status_flags << status_flags
+      self
+    end
+
+    def normalize_stream_error_mode(value)
+      normalized = value.to_sym
+      return normalized if %i[abort continue].include?(normalized)
+
+      raise ArgumentError, "Unsupported stream error mode: #{value}"
+    end
+
     def monotonic_time
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
@@ -152,6 +223,7 @@ module Deftones
       def initialize(context:)
         @context = context
         @stream = nil
+        @silence_cache = {}
       end
 
       def start
@@ -190,7 +262,12 @@ module Deftones
       def open_stream
         Deftones::PortAudioSupport.acquire!
         @stream = PortAudio::Stream.new(
-          output: Deftones::PortAudioSupport.output_parameters(@context.channels),
+          output: Deftones::PortAudioSupport.output_parameters(
+            @context.channels,
+            device_id: @context.output_device_id,
+            label: @context.output_device_label,
+            sample_rate: @context.sample_rate
+          ),
           sample_rate: @context.sample_rate.to_f,
           frames_per_buffer: @context.buffer_size,
           &method(:process)
@@ -200,13 +277,17 @@ module Deftones
         raise
       end
 
-      def process(_input, output, frame_count, _time_info, _status_flags, _user_data)
+      def process(_input, output, frame_count, _time_info, status_flags, _user_data)
+        @context.send(:record_stream_status_flags, status_flags)
         output.write_array_of_float(@context.send(:pull_realtime_samples, frame_count))
         :continue
       rescue StandardError => error
-        @context.instance_variable_set(:@stream_error, error) if @context.stream_error.nil?
-        output.write_array_of_float(Array.new(frame_count * @context.channels, 0.0)) unless output.null?
-        :abort
+        output.write_array_of_float(silence_for(frame_count)) unless output.null?
+        @context.send(:handle_stream_error, error)
+      end
+
+      def silence_for(frame_count)
+        @silence_cache[frame_count] ||= Array.new(frame_count * @context.channels, 0.0).freeze
       end
     end
   end

data/lib/deftones/core/audio_block.rb

@@ -19,6 +19,23 @@ module Deftones
         from_channel_data(Array.new([channels.to_i, 1].max) { normalized.dup })
       end
 
+      def self.from_interleaved(samples, channels:)
+        channel_count = [channels.to_i, 1].max
+        normalized = Array(samples).map(&:to_f)
+        frame_count = (normalized.length.to_f / channel_count).ceil
+        from_channel_data(
+          Array.new(channel_count) do |channel_index|
+            Array.new(frame_count) do |frame_index|
+              normalized[(frame_index * channel_count) + channel_index] || 0.0
+            end
+          end
+        )
+      end
+
+      def self.from_packed_float32(payload, channels:)
+        from_interleaved(payload.unpack("e*"), channels: channels)
+      end
+
       def initialize(channel_data)
         @channel_data = channel_data
       end
@@ -52,31 +69,73 @@ module Deftones
         end
       end
 
+      def packed_float32
+        interleaved.pack("e*")
+      end
+
+      def packed_float64
+        interleaved.pack("E*")
+      end
+
       def channel(index)
         @channel_data[index] || Array.new(num_frames, 0.0)
       end
 
-      def fit_channels(target_channels)
+      def fit_channels(target_channels, downmix: :average, upmix: :wrap)
         target = [target_channels.to_i, 1].max
         return dup if target == channels
-        return self.class.from_channel_data([mono]) if target == 1
+        return self.class.from_channel_data([downmixed_channel(downmix)]) if target == 1
 
         if channels == 1
           return self.class.from_channel_data(Array.new(target) { @channel_data.first.dup })
         end
 
-        self.class.from_channel_data(Array.new(target) { |index| channel(index % channels).dup })
+        self.class.from_channel_data(Array.new(target) { |index| upmixed_channel(index, upmix) })
       end
 
-      def mix!(other)
+      def mix!(other, headroom: :sum, gain: 1.0)
         incoming = other.fit_channels(channels)
         channels.times do |channel_index|
           num_frames.times do |frame_index|
-            @channel_data[channel_index][frame_index] += incoming.channel_data[channel_index][frame_index]
+            mixed = @channel_data[channel_index][frame_index] + (incoming.channel_data[channel_index][frame_index] * gain)
+            @channel_data[channel_index][frame_index] = apply_headroom(mixed, headroom)
           end
         end
         self
       end
+
+      private
+
+      def downmixed_channel(policy)
+        case policy
+        when :average then mono
+        when :sum
+          Array.new(num_frames) { |frame_index| @channel_data.sum { |channel| channel[frame_index] } }
+        when :first
+          channel(0).dup
+        else
+          raise ArgumentError, "Unsupported downmix policy: #{policy}"
+        end
+      end
+
+      def upmixed_channel(index, policy)
+        case policy
+        when :wrap then channel(index % channels).dup
+        when :silence then index < channels ? channel(index).dup : Array.new(num_frames, 0.0)
+        when :duplicate then channel([index, channels - 1].min).dup
+        else
+          raise ArgumentError, "Unsupported upmix policy: #{policy}"
+        end
+      end
+
+      def apply_headroom(sample, policy)
+        case policy
+        when :sum then sample
+        when :clamp then sample.clamp(-1.0, 1.0)
+        else
+          raise ArgumentError, "Unsupported headroom policy: #{policy}"
+        end
+      end
     end
   end
 end

data/lib/deftones/core/audio_node.rb

@@ -18,12 +18,14 @@ module Deftones
       end
 
       def connect(destination, output_index: 0, input_index: 0)
-        _ = output_index
-        _ = input_index
         raise ArgumentError, "destination is required" if destination.nil?
 
-        destination_node = destination.respond_to?(:input) ? destination.input : destination
-        output.attach_destination(destination_node)
+        source_node = output_for_connection(output_index)
+        destination_node = destination_for_connection(destination, input_index)
+        validate_connectable!(source_node, destination_node)
+        raise ArgumentError, "connection would create a cycle" if destination_node.send(:reaches_node?, source_node)
+
+        source_node.attach_destination(destination_node)
         self
       end
 
@@ -52,6 +54,21 @@ module Deftones
         self
       end
 
+      def inputs
+        @sources.dup
+      end
+
+      def outputs
+        @destinations.dup
+      end
+
+      def connected?(destination = nil)
+        return @destinations.any? if destination.nil?
+
+        destination_node = destination.respond_to?(:input) ? destination.input : destination
+        @destinations.include?(destination_node)
+      end
+
       def to_output
         connect(context.output)
         self
@@ -121,7 +138,10 @@ module Deftones
         1
       end
 
-      def set(**params)
+      def set(strict: false, **params)
+        unknown = params.keys.reject { |key| respond_to?(:"#{key}=") }
+        raise ArgumentError, "Unknown parameter(s): #{unknown.join(', ')}" if strict && unknown.any?
+
         params.each do |key, value|
           writer = :"#{key}="
           public_send(writer, value) if respond_to?(writer)
@@ -129,11 +149,19 @@ module Deftones
         self
       end
 
-      def get(*keys)
-        keys.flatten.each_with_object({}) do |key, values|
+      def get(*keys, strict: false)
+        unknown = []
+        values = keys.flatten.each_with_object({}) do |key, collected|
           reader = key.to_sym
-          values[reader] = public_send(reader) if respond_to?(reader)
+          if respond_to?(reader)
+            collected[reader] = public_send(reader)
+          else
+            unknown << reader
+          end
         end
+        raise ArgumentError, "Unknown parameter(s): #{unknown.join(', ')}" if strict && unknown.any?
+
+        values
       end
 
       def name
@@ -157,6 +185,7 @@ module Deftones
       alias channelInterpretation channel_interpretation
       alias numberOfInputs number_of_inputs
       alias numberOfOutputs number_of_outputs
+      alias connected connected?
       alias toString to_s
 
       def dispose
@@ -177,7 +206,21 @@ module Deftones
 
       protected
 
+      def output_for_index(index)
+        raise_connection_index_error!(:output_index, index, number_of_outputs) unless index.zero?
+
+        output
+      end
+
+      def input_for_index(index)
+        raise_connection_index_error!(:input_index, index, number_of_inputs) unless index.zero?
+
+        input
+      end
+
       def render_block(num_frames, start_frame = 0, cache = {})
+        raise Deftones::Error, "cannot render disposed node: #{name}" if disposed?
+
         cache_key = [object_id, :block, start_frame, num_frames]
         return cache.fetch(cache_key).dup if cache.key?(cache_key)
 
@@ -257,6 +300,53 @@ module Deftones
       def default_output_channels
         default_input_channels
       end
+
+      def reaches_node?(target, visited = {})
+        return true if equal?(target)
+        return false if visited[object_id]
+
+        visited[object_id] = true
+        @destinations.any? { |destination| destination.send(:reaches_node?, target, visited) }
+      end
+
+      def raise_connection_index_error!(name, index, count)
+        raise ArgumentError, "#{name} #{index} is out of range for #{count} #{count == 1 ? 'port' : 'ports'}"
+      end
+
+      private
+
+      def output_for_connection(index)
+        normalized_index = normalize_connection_index(index, :output_index)
+        output_for_index(normalized_index)
+      end
+
+      def destination_for_connection(destination, index)
+        normalized_index = normalize_connection_index(index, :input_index)
+        if destination.respond_to?(:input_for_index)
+          destination.input_for_index(normalized_index)
+        else
+          destination_node = destination.respond_to?(:input) ? destination.input : destination
+          validate_connection_index!(normalized_index, destination_node.number_of_inputs, :input_index)
+          destination_node
+        end
+      end
+
+      def normalize_connection_index(index, name)
+        Integer(index).tap do |normalized|
+          raise ArgumentError, "#{name} must be greater than or equal to 0" if normalized.negative?
+        end
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "#{name} must be an integer"
+      end
+
+      def validate_connection_index!(index, count, name)
+        raise_connection_index_error!(name, index, count) if index >= count
+      end
+
+      def validate_connectable!(source_node, destination_node)
+        raise Deftones::Error, "cannot connect disposed source node" if source_node.disposed?
+        raise Deftones::Error, "cannot connect disposed destination node" if destination_node.disposed?
+      end
     end
   end
 end

data/lib/deftones/core/gain.rb

@@ -14,14 +14,6 @@ module Deftones
         @gain.value = value
       end
 
-      def process(input_buffer, num_frames, start_frame, _cache)
-        gain_values = @gain.process(num_frames, start_frame)
-
-        Array.new(num_frames) do |index|
-          input_buffer[index] * gain_values[index]
-        end
-      end
-
       def multichannel_process?
         true
       end

data/lib/deftones/core/instrument.rb

@@ -5,7 +5,7 @@ module Deftones
     class Instrument < AudioNode
       class VolumeProxy
         attr_reader :instrument
-        attr_accessor :value
+        attr_reader :value
 
         def initialize(instrument, value: 0.0)
           @instrument = instrument
@@ -17,17 +17,48 @@ module Deftones
           instrument.apply_volume!
         end
 
-        def ramp_to(target_value, _duration = nil)
-          self.value = target_value
+        def ramp_to(target_value, duration = nil)
+          return assign_immediately(target_value) if duration.nil?
+
+          resolved_duration = Deftones::Music::Time.parse(duration)
+          return assign_immediately(target_value) if resolved_duration <= 0.0
+
+          @value = target_value.to_f
+          instrument.output.gain.linear_ramp_to_value_at_time(
+            instrument.mute? ? 0.0 : Deftones.db_to_gain(@value),
+            instrument.context.current_time + resolved_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
+          instrument.output.gain.set_value_at_time(instrument.mute? ? 0.0 : Deftones.db_to_gain(@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
+
+        private
+
+        def assign_immediately(target_value)
+          self.value = target_value
+          self
+        end
       end
 
       attr_reader :output, :volume
-      attr_accessor :mute
+      attr_reader :mute
 
       def initialize(context: Deftones.context)
         super(context: context)
@@ -58,7 +89,10 @@ module Deftones
         @mute
       end
 
-      def set(**params)
+      def set(strict: false, **params)
+        unknown = params.keys.reject { |key| respond_to?(:"#{key}=") }
+        raise ArgumentError, "Unknown parameter(s): #{unknown.join(', ')}" if strict && unknown.any?
+
         params.each do |key, value|
           writer = :"#{key}="
           public_send(writer, value) if respond_to?(writer)
@@ -66,12 +100,20 @@ module Deftones
         self
       end
 
-      def get(*keys)
+      def get(*keys, strict: false)
         requested = keys.flatten
-        requested.each_with_object({}) do |key, values|
+        unknown = []
+        values = requested.each_with_object({}) do |key, collected|
           reader = key.to_sym
-          values[reader] = public_send(reader) if respond_to?(reader)
+          if respond_to?(reader)
+            collected[reader] = public_send(reader)
+          else
+            unknown << reader
+          end
         end
+        raise ArgumentError, "Unknown parameter(s): #{unknown.join(', ')}" if strict && unknown.any?
+
+        values
       end
 
       def release_all(time = nil)

data/lib/deftones/core/param.rb

@@ -3,11 +3,13 @@
 module Deftones
   module Core
     class Param < Signal
-      attr_reader :lfo
+      attr_reader :lfo, :audio_source, :modulation_amount
 
       def initialize(**options)
         super
         @lfo = nil
+        @audio_source = nil
+        @modulation_amount = 1.0
       end
 
       def set_param(param)
@@ -25,7 +27,55 @@ module Deftones
         @lfo = source
       end
 
+      def connect_audio(source, amount: 1.0)
+        raise ArgumentError, "audio source is required" if source.nil?
+        raise ArgumentError, "audio source must render or process samples" unless modulation_source?(source)
+
+        @audio_source = source
+        @modulation_amount = amount.to_f
+        self
+      end
+
+      def disconnect_audio(source = nil)
+        return self if source && source != @audio_source
+
+        @audio_source = nil
+        @modulation_amount = 1.0
+        self
+      end
+
+      def audio_rate?
+        !@audio_source.nil?
+      end
+
+      def process(num_frames, start_frame = 0)
+        values = super
+        return values unless @audio_source
+
+        modulation = modulation_samples(num_frames, start_frame)
+        values.zip(modulation).map { |base, sample| base + (sample.to_f * @modulation_amount) }
+      end
+
       alias setParam set_param
+      alias connectAudio connect_audio
+      alias disconnectAudio disconnect_audio
+      alias audioRate audio_rate?
+
+      private
+
+      def modulation_source?(source)
+        source.respond_to?(:values) || source.respond_to?(:process) || source.respond_to?(:render)
+      end
+
+      def modulation_samples(num_frames, start_frame)
+        if @audio_source.respond_to?(:values)
+          @audio_source.values(num_frames, start_frame)
+        elsif @audio_source.respond_to?(:render)
+          @audio_source.render(num_frames, start_frame)
+        else
+          @audio_source.process(num_frames, start_frame)
+        end
+      end
     end
   end
 end