deftones 0.1.0 → 1.0.0

data/lib/deftones/source/tone_buffer_source.rb

@@ -47,15 +47,17 @@ module Deftones
       def process(_input_buffer, num_frames, start_frame, _cache)
         rates = @playback_rate.process(num_frames, start_frame)
         detunes = @detune.process(num_frames, start_frame)
-        return process_multichannel_buffer(num_frames, start_frame, rates, detunes) if multichannel_process?
+        effective_rates = effective_playback_rates(rates, detunes)
+        return process_multichannel_buffer(num_frames, start_frame, effective_rates) if multichannel_process?
+
+        sample_positions = sample_positions_for(num_frames, start_frame, effective_rates)
 
         Array.new(num_frames) do |index|
           current_time = (start_frame + index).to_f / context.sample_rate
           notify_ended(current_time) if @stop_time && current_time >= @stop_time
           next 0.0 unless active_at?(current_time)
 
-          rate = rates[index] * detune_ratio(detunes[index])
-          sample_position = sample_position_for(current_time, rate)
+          sample_position = sample_positions[index]
           if sample_position.negative?
             @stop_time ||= current_time
             notify_ended(current_time)
@@ -68,16 +70,16 @@ module Deftones
 
       private
 
-      def process_multichannel_buffer(num_frames, start_frame, rates, detunes)
+      def process_multichannel_buffer(num_frames, start_frame, effective_rates)
         output = Array.new(@buffer.channels) { Array.new(num_frames, 0.0) }
+        sample_positions = sample_positions_for(num_frames, start_frame, effective_rates)
 
         num_frames.times do |index|
           current_time = (start_frame + index).to_f / context.sample_rate
           notify_ended(current_time) if @stop_time && current_time >= @stop_time
           next unless active_at?(current_time)
 
-          rate = rates[index] * detune_ratio(detunes[index])
-          sample_position = sample_position_for(current_time, rate)
+          sample_position = sample_positions[index]
           if sample_position.negative?
             @stop_time ||= current_time
             notify_ended(current_time)
@@ -93,6 +95,10 @@ module Deftones
         Core::AudioBlock.from_channel_data(output)
       end
 
+      def effective_playback_rates(rates, detunes)
+        rates.each_with_index.map { |rate, index| rate * detune_ratio(detunes[index]) }
+      end
+
       def detune_ratio(cents)
         2.0**(cents.to_f / 1200.0)
       end

data/lib/deftones/source/tone_oscillator_node.rb

@@ -32,7 +32,7 @@ module Deftones
       end
 
       def process(_input_buffer, num_frames, start_frame, _cache)
-        generator = GENERATORS.fetch(send(:normalize_type, @type))
+        oscillator_type = send(:normalize_type, @type)
         frequencies = @frequency.process(num_frames, start_frame)
         detunes = @detune.process(num_frames, start_frame)
 
@@ -41,9 +41,10 @@ module Deftones
           notify_ended(current_time) if @stop_time && current_time >= @stop_time
           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

data/lib/deftones/source/user_media.rb

@@ -20,6 +20,9 @@ module Deftones
         @label = label
         @channels = normalize_channel_count(channels)
         @sample_cursor = 0
+        @provider_exhausted = false
+        @underflow_count = 0
+        @overflow_count = 0
         @opened = false
       end
 
@@ -54,6 +57,7 @@ module Deftones
 
       def rewind
         @sample_cursor = 0
+        @provider_exhausted = false
         @provider.rewind if @provider.respond_to?(:rewind)
         @capture_backend&.rewind if @capture_backend.respond_to?(:rewind)
         self
@@ -67,11 +71,34 @@ module Deftones
         @opened
       end
 
+      def provider_exhausted?
+        @provider_exhausted
+      end
+
+      def underflow_count
+        @underflow_count + backend_stat(:underflow_count)
+      end
+
+      def overflow_count
+        @overflow_count + backend_stat(:overflow_count)
+      end
+
+      def reset_stats
+        @underflow_count = 0
+        @overflow_count = 0
+        @capture_backend.reset_stats if @capture_backend.respond_to?(:reset_stats)
+        self
+      end
+
       def permission_state
         self.class.permission_state
       end
 
       alias permissionState permission_state
+      alias providerExhausted provider_exhausted?
+      alias underflowCount underflow_count
+      alias overflowCount overflow_count
+      alias resetStats reset_stats
 
       def state(time = context.current_time)
         return :stopped unless @opened
@@ -319,7 +346,7 @@ module Deftones
           current_time = (start_frame + index).to_f / context.sample_rate
           next 0.0 unless active_at?(current_time)
 
-          @capture_backend.next_sample
+          next_capture_sample
         end
       end
 
@@ -347,12 +374,22 @@ module Deftones
         else
           @capture_backend.next_sample
         end
+        return mark_capture_frame_underflow! if frame.nil?
 
         frame = [frame] unless frame.is_a?(Array)
         normalized = frame.map(&:to_f)
         normalized.fill(0.0, normalized.length...capture_channels)
       end
 
+      def next_capture_sample
+        return 0.0 unless @capture_backend
+
+        sample = @capture_backend.next_sample
+        return mark_underflow! if sample.nil?
+
+        sample.to_f
+      end
+
       def next_provider_sample
         return 0.0 unless @provider
 
@@ -362,23 +399,48 @@ module Deftones
           next_enumerator_sample
         end
         @sample_cursor += 1
+        return mark_underflow! if sample.nil?
+
         sample.to_f
       end
 
       def next_enumerator_sample
         @provider.next
       rescue StopIteration
-        return 0.0 unless @loop && @provider.respond_to?(:rewind)
+        return mark_provider_exhausted! unless @loop && @provider.respond_to?(:rewind)
 
-        @provider.rewind
-        @provider.next
-      rescue StopIteration
+        begin
+          @provider.rewind
+          @provider.next
+        rescue StopIteration
+          mark_provider_exhausted!
+        end
+      end
+
+      def mark_provider_exhausted!
+        @provider_exhausted = true
         @opened = false
+        mark_underflow!
+      end
+
+      def mark_underflow!
+        @underflow_count += 1
         0.0
       end
 
+      def mark_capture_frame_underflow!
+        @underflow_count += 1
+        Array.new(capture_channels, 0.0)
+      end
+
+      def backend_stat(name)
+        return 0 unless @capture_backend.respond_to?(name)
+
+        @capture_backend.public_send(name).to_i
+      end
+
       class PortAudioCapture
-        attr_reader :channels, :device_id, :group_id, :label
+        attr_reader :channels, :device_id, :group_id, :label, :underflow_count, :overflow_count
 
         def initialize(sample_rate:, buffer_size:, channels: 1)
           @sample_rate = sample_rate
@@ -390,6 +452,8 @@ module Deftones
           @device_id = nil
           @group_id = nil
           @label = nil
+          @underflow_count = 0
+          @overflow_count = 0
         end
 
         def open(device_id: nil, group_id: nil, label: nil, channels: nil)
@@ -420,6 +484,12 @@ module Deftones
           self
         end
 
+        def reset_stats
+          @underflow_count = 0
+          @overflow_count = 0
+          self
+        end
+
         def close
           return self unless @stream
 
@@ -435,13 +505,12 @@ module Deftones
         def next_sample
           frame = next_frame
           frame.sum / [frame.length, 1].max.to_f
-        rescue ThreadError
-          0.0
         end
 
         def next_frame
           @queue.pop(true)
         rescue ThreadError
+          @underflow_count += 1
           Array.new(@channels, 0.0)
         end
 
@@ -452,7 +521,8 @@ module Deftones
           input_parameters = Deftones::PortAudioSupport.input_parameters(
             @channels,
             device_id: @device_id,
-            label: @label
+            label: @label,
+            sample_rate: @sample_rate
           )
           assign_device_metadata(input_parameters[:device])
           @stream = PortAudio::Stream.new(
@@ -503,7 +573,10 @@ module Deftones
         end
 
         def trim_queue!
-          @queue.pop(true) while @queue.size > @max_frames
+          while @queue.size > @max_frames
+            @queue.pop(true)
+            @overflow_count += 1
+          end
         rescue ThreadError
           nil
         end

data/lib/deftones/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Deftones
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/lib/deftones.rb

@@ -1,20 +1,25 @@
 # frozen_string_literal: true
 
-begin
-  require "portaudio"
-rescue LoadError
-  nil
-end
+module Deftones
+  class Error < StandardError; end
+  class MissingRealtimeBackendError < Error; end
+  class MissingCodecBackendError < Error; end
+  class CodecCommandError < Error
+    attr_reader :command, :stdout, :stderr, :status
 
-begin
-  require "wavify/errors"
-  require "wavify/core/format"
-  require "wavify/core/duration"
-  require "wavify/core/sample_buffer"
-  require "wavify/codecs/base"
-  require "wavify/codecs/wav"
-rescue LoadError
-  nil
+    def initialize(message, command:, stdout:, stderr:, status:)
+      super(message)
+      @command = command
+      @stdout = stdout
+      @stderr = stderr
+      @status = status
+    end
+  end
+  class MissingMidiBackendError < Error; end
+  class UnsupportedAudioFormatError < Error; end
+  class InvalidNoteError < ArgumentError; end
+  class InvalidFrequencyError < ArgumentError; end
+  class InvalidTimeError < ArgumentError; end
 end
 
 require_relative "deftones/version"
@@ -111,6 +116,7 @@ require_relative "deftones/analysis/analyser"
 require_relative "deftones/analysis/meter"
 require_relative "deftones/analysis/dc_meter"
 require_relative "deftones/effect/modulation_control"
+require_relative "deftones/effect/oversampling"
 require_relative "deftones/effect/distortion"
 require_relative "deftones/effect/bit_crusher"
 require_relative "deftones/effect/chebyshev"
@@ -142,9 +148,6 @@ require_relative "deftones/instrument/sampler"
 require_relative "deftones/instrument/poly_synth"
 
 module Deftones
-  class Error < StandardError; end
-  class MissingRealtimeBackendError < Error; end
-
   class << self
     def context
       @context ||= Context.new
@@ -208,31 +211,41 @@ module Deftones
     end
 
     def render(duration:, sample_rate: Context::DEFAULT_SAMPLE_RATE, channels: 2,
-               buffer_size: Context::DEFAULT_BUFFER_SIZE, &block)
+               buffer_size: Context::DEFAULT_BUFFER_SIZE, seed: nil, metadata: false,
+               progress: nil, cancel: nil, &block)
       ctx = OfflineContext.new(
         duration: duration,
         sample_rate: sample_rate,
         channels: channels,
         buffer_size: buffer_size
       )
-      block&.call(ctx)
-      ctx.render
+      with_random_seed(seed) do
+        block&.call(ctx)
+        ctx.render(metadata: metadata, progress: progress, cancel: cancel)
+      end
     end
 
     def offline(duration:, sample_rate: Context::DEFAULT_SAMPLE_RATE, channels: 2,
-                buffer_size: Context::DEFAULT_BUFFER_SIZE, &block)
-      render(duration: duration, sample_rate: sample_rate, channels: channels, buffer_size: buffer_size, &block)
+                buffer_size: Context::DEFAULT_BUFFER_SIZE, **render_options, &block)
+      render(duration: duration, sample_rate: sample_rate, channels: channels, buffer_size: buffer_size,
+             **render_options, &block)
     end
 
     def Offline(duration:, sample_rate: Context::DEFAULT_SAMPLE_RATE, channels: 2,
-                buffer_size: Context::DEFAULT_BUFFER_SIZE, &block)
-      offline(duration: duration, sample_rate: sample_rate, channels: channels, buffer_size: buffer_size, &block)
+                buffer_size: Context::DEFAULT_BUFFER_SIZE, **render_options, &block)
+      offline(duration: duration, sample_rate: sample_rate, channels: channels, buffer_size: buffer_size,
+              **render_options, &block)
     end
 
-    def render_to_file(path, duration:, format: nil, **options, &block)
-      ctx = OfflineContext.new(duration: duration, **options)
-      block&.call(ctx)
-      ctx.render_to_file(path, format: format)
+    def render_to_file(path, duration:, format: nil, streaming: false, **options, &block)
+      file_options = options.slice(:bit_depth, :dither, :dither_rng)
+      render_options = options.slice(:seed, :metadata, :progress, :cancel)
+      context_options = options.reject { |key, _| render_options.key?(key) || file_options.key?(key) }
+      ctx = OfflineContext.new(duration: duration, **context_options)
+      with_random_seed(render_options.delete(:seed)) do
+        block&.call(ctx)
+        ctx.render_to_file(path, format: format, streaming: streaming, **file_options, **render_options)
+      end
     end
 
     def loaded
@@ -261,11 +274,47 @@ module Deftones
     end
 
     def wavify_available?
-      !!defined?(Wavify::Core::SampleBuffer) && !!defined?(Wavify::Codecs::Wav)
+      load_wavify!
     end
 
-    def supported?
-      true
+    def midi_available?
+      Deftones::Music::Midi.available?
+    end
+
+    def compressed_audio_available?
+      Deftones::IO::Buffer.compressed_audio_available?
+    end
+
+    def capabilities
+      {
+        offline: true,
+        wav: wavify_available?,
+        compressed_audio: compressed_audio_available?,
+        realtime: portaudio_available?,
+        midi: midi_available?
+      }
+    end
+
+    def supported?(feature = nil)
+      return true if feature.nil?
+
+      normalized = feature.to_sym
+      available = capabilities
+      raise ArgumentError, "Unknown capability: #{feature}" unless available.key?(normalized)
+
+      available.fetch(normalized)
+    end
+
+    def feature_supported?(feature)
+      supported?(feature)
+    end
+
+    def supported_features
+      capabilities.select { |_feature, supported| supported }.keys
+    end
+
+    def unsupported_features
+      capabilities.reject { |_feature, supported| supported }.keys
     end
 
     def connect_series(*nodes)
@@ -381,8 +430,36 @@ module Deftones
       Music::TransportTime.new(value, transport: transport)
     end
 
+    def with_random_seed(seed)
+      return yield if seed.nil?
+
+      previous_seed = srand(seed)
+      yield
+    ensure
+      srand(previous_seed) unless seed.nil?
+    end
+
+    def load_wavify!
+      return true if defined?(Wavify::Core::SampleBuffer) && defined?(Wavify::Codecs::Wav)
+
+      require "wavify/errors"
+      require "wavify/core/format"
+      require "wavify/core/duration"
+      require "wavify/core/sample_buffer"
+      require "wavify/codecs/base"
+      require "wavify/codecs/wav"
+      true
+    rescue LoadError
+      false
+    end
+
     alias wavefile_available? wavify_available?
+    alias compressedAudioAvailable compressed_audio_available?
+    alias midi_available midi_available?
     alias supported supported?
+    alias featureSupported feature_supported?
+    alias supportedFeatures supported_features
+    alias unsupportedFeatures unsupported_features
     alias dbToGain db_to_gain
     alias gainToDb gain_to_db
     alias getContext get_context

metadata

@@ -1,56 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deftones
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Yudai Takada
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: portaudio
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: wavify
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: unimidi
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+dependencies: []
 description: Deftones provides a flexible node graph, synth voices, effects, transport
   scheduling, sample playback, analysis, and offline or realtime audio hooks.
 email:
@@ -138,6 +96,7 @@ files:
 - lib/deftones/effect/frequency_shifter.rb
 - lib/deftones/effect/jc_reverb.rb
 - lib/deftones/effect/modulation_control.rb
+- lib/deftones/effect/oversampling.rb
 - lib/deftones/effect/phaser.rb
 - lib/deftones/effect/ping_pong_delay.rb
 - lib/deftones/effect/pitch_shift.rb