Module_SignalProcessing_Effects - vorcyc/Vorcyc.Mathematics GitHub Wiki

Location: Home / Signal processing / Audio effects

Signal Processing Module

Audio Effects

The Vorcyc.Mathematics.SignalProcessing.Effects namespace includes base classes AudioEffect and WetDryMixer, stereo effects such as BinauralPanEffect, ItdIldPanEffect, and StereoDelayEffect, and effects including AutowahEffect, BitCrusherEffect, ChorusEffect, DelayEffect, DistortionEffect, EchoEffect, FlangerEffect, MorphEffect, PhaserEffect, PitchShiftEffect, PitchShiftVocoderEffect, RobotEffect, TremoloEffect, TubeDistortionEffect, VibratoEffect, WahwahEffect, and WhisperEffect.

Root namespace for the types below:Vorcyc.Mathematics.SignalProcessing.Effects

:ledger: Contents

All types below are in namespace:Vorcyc.Mathematics.SignalProcessing.Effects

Vorcyc.Mathematics.SignalProcessing.Effects.Base.AudioEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.Base.AudioEffect is an abstract base class for audio effects, inheriting WetDryMixer and implementing IFilter and IOnlineFilter.

Methods

1. Process

  • public abstract float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

2. Reset

  • public abstract void Reset()
    • Resets the effect.

3. ApplyTo

  • public virtual Signal ApplyTo(Signal signal, FilteringMethod method = FilteringMethod.Auto)
    • Apply effect to entire signal，and returns a new processed signal.
    • Parameters:
      • signal: Signal.
      • method: Filtering method; default FilteringMethod.Auto.
    • Returns: Processed Signal.

4. Apply

  • public virtual void Apply(Signal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies effect to entire signal (in-place).
    • Parameters:
      • signal: Signal.
      • method: Filtering method; default FilteringMethod.Auto.

Code example

The following example uses AudioEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects.Base;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class CustomAudioEffect : AudioEffect
{
    public override float Process(float sample)
    { // Custom processing logic
        return sample * 0.5f;
    }
    public override void Reset()
    {
        // Custom reset logic
    }
}
public class AudioEffectExample
{
    public static void Main()
    {
        // Define signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 1000);

        // Create custom audio effect instance
        var effect = new CustomAudioEffect();

        // Apply effect to entire signal
        var processedSignal = effect.ApplyTo(signal);

        // Output processed signal samples
        Console.WriteLine("Processed Signal:");
        foreach (var sample in processedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.Base.WetDryMixer class

Vorcyc.Mathematics.SignalProcessing.Effects.Base.WetDryMixer is a base class implementing wet/dry mixing logic and IMixable.

Properties

1. Wet

  • public float Wet { get; set; } = 1f
    • Gets or setsWet gain (default 1).

2. Dry

  • public float Dry { get; set; } = 0f
    • Gets or setsDry gain (default 0).

Methods

1. WetDryMix

  • public void WetDryMix(float mix, MixingRule mixingRule = MixingRule.Linear)
    • Sets wet/dry mix (range [0..1]).
    • Parameters:
      • mix: Wet/dry mix ratio.
      • mixingRule: Mixing rule; default MixingRule.Linear.

2. WetDryDb

  • public void WetDryDb(float wetDb, float dryDb)
    • Sets wet/dry gain (dB) and applies linear mixing rule.
    • Parameters:
      • wetDb: Wet gain (dB).
      • dryDb: Dry gain (dB).

Code example

The following example uses WetDryMixer with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects.Base;

public class CustomWetDryMixer : WetDryMixer
{
    public void ApplyEffect(float[] samples)
    {
        for (int i = 0; i < samples.Length; i++)
        {
            samples[i] = Wet * samples[i] + Dry * samples[i];
        }
    }
}
public class WetDryMixerExample
{
    public static void Main()
    { // Define signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };

        // Create custom wet/dry mixer instance
        var mixer = new CustomWetDryMixer();

        // Set wet/dry mix ratio
        mixer.WetDryMix(0.7f, MixingRule.Sin3Db);

        // Apply effect
        mixer.ApplyEffect(samples);

        // Output processed signal samples
        Console.WriteLine("Processed Signal:");
        foreach (var sample in samples)
        {
            Console.WriteLine(sample);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.BinauralPanEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.BinauralPanEffect is a binaural panning effect with HRIR/BRIR interpolation and optional crossover filters.

Properties

1. Azimuth

  • public float Azimuth { get; set; }
    • Gets or setsAzimuth (theta).

2. Elevation

  • public float Elevation { get; set; }
    • Gets or setsElevation (phi).

Methods

1. BinauralPanEffect constructor

  • public BinauralPanEffect(float[] azimuths, float[] elevations, float[][][] leftHrirs, float[][][] rightHrirs)
    • Constructs BinauralPanEffect instance.
    • Parameters:
      • azimuths: Azimuth array (must be sorted ascending).
      • elevations: Elevation array (must be sorted ascending).
      • leftHrirs: Left-ear HRIR set.
      • rightHrirs: Right-ear HRIR set.

2. UseCrossover

  • public void UseCrossover(bool useCrossover)
    • Enables or disables crossover filtering.
    • Parameters:
      • useCrossover: Whether to use crossover filtering.

3. SetCrossoverParameters

  • public void SetCrossoverParameters(float freq, int samplingRate)
    • Updates crossover filter frequency (BiQuadFilters only).
    • Parameters:
      • freq: Frequency.
      • samplingRate: Sampling rate.

4. SetCrossoverFilters

  • public void SetCrossoverFilters(IOnlineFilter lowpassLeft, IOnlineFilter highpassLeft, IOnlineFilter lowpassRight, IOnlineFilter highpassRight)
    • Sets custom crossover filters.
    • Parameters:
      • lowpassLeft: Left-channel lowpass filter.
      • highpassLeft: Left-channel highpass filter.
      • lowpassRight: Right-channel lowpass filter.
      • highpassRight: Right-channel highpass filter.

5. UpdateHrir

  • protected void UpdateHrir(float azimuth, float elevation)
    • Updates HRIR (interpolated from HRIR table).
    • Parameters:
      • azimuth: Azimuth (theta).
      • elevation: Elevation (phi).

6. Process

  • public override void Process(ref float left, ref float right)
    • Processes one sample per channel: [in L, in R] -> [out L, out R].
    • Parameters:
      • left: left-channel Input sample.
      • right: right-channel Input sample.

7. Reset

  • public override void Reset()
    • Resets binaural pan effect.

Code example

The following example uses BinauralPanEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects.Stereo;

public class BinauralPanEffectExample
{
    public static void Main()
    {
        // Define HRIR data
        float[] azimuths = { -80, -65, -55, -45, -40, -35, -30, -25, -20, -15, -10, -5, 0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 55, 65, 80 };
        float[] elevations = { -45, -39, -34, -28, -23, -17, -11, -6, 0, 6, 11, 17, 23, 28, 34, 39, 45, 51, 56, 62, 68, 73, 79, 84, 90, 96, 101, 107, 113, 118, 124, 129, 135, 141, 146, 152, 158, 163, 169, 174, 180, 186, 191, 197, 203, 208, 214, 219, 225, 231 };
        float[][][] leftHrirs = new float[azimuths.Length][][];
        float[][][] rightHrirs = new float[azimuths.Length][][];

        // Initialize HRIR data (example)
        for (int i = 0; i < azimuths.Length; i++)
        {
            leftHrirs[i] = new float[elevations.Length][];
            rightHrirs[i] = new float[elevations.Length][];
            for (int j = 0; j < elevations.Length; j++)
            {
                leftHrirs[i][j] = new float[128]; // example length
                rightHrirs[i][j] = new float[128]; // example length
            }
        }

        // Create BinauralPanEffect instance
        var binauralPanEffect = new BinauralPanEffect(azimuths, elevations, leftHrirs, rightHrirs);

        // Set azimuth and elevation
        binauralPanEffect.Azimuth = 30;
        binauralPanEffect.Elevation = 45;

        // Enable crossover filtering
        binauralPanEffect.UseCrossover(true);

        // Process sample
        float leftSample = 0.5f;
        float rightSample = 0.6f;
        binauralPanEffect.Process(ref leftSample, ref rightSample);

        // Output processed sample
        Console.WriteLine($"Processed Left Sample: {leftSample}");
        Console.WriteLine($"Processed Right Sample: {rightSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.ItdIldPanEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.ItdIldPanEffect is a stereo panning effect based on ITD-ILD (interaural time/level difference).

Properties

1. HeadRadius

  • public float HeadRadius { get; }
    • Gets Head radius.

2. Pan

  • public float Pan { get; set; }
    • Gets or setsPan.

Methods

1. ItdIldPanEffect constructor

  • public ItdIldPanEffect(int samplingRate, float pan, InterpolationMode interpolationMode = InterpolationMode.Linear, double reserveDelay = 0.005, float headRadius = 8.5e-2f)
    • Constructs ItdIldPanEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • pan: Pan.
      • interpolationMode: Fractional delay line interpolation; default InterpolationMode.Linear.
      • reserveDelay: Maximum reserved delay time (seconds); default 0.005 s.
      • headRadius: Head radius; default 8.5e-2f.

2. Process

  • public override void Process(ref float left, ref float right)
    • Processes one sample per channel: [in L, in R] -> [out L, out R].
    • Parameters:
      • left: left-channel Input sample.
      • right: right-channel Input sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses ItdIldPanEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects.Stereo;

public class ItdIldPanEffectExample
{
    public static void Main()
    {
        // Create ItdIldPanEffect instance
        var itdIldPanEffect = new ItdIldPanEffect(44100, 0.5f);

        // Set pan
        itdIldPanEffect.Pan = 0.8f;

        // Process sample
        float leftSample = 0.5f;
        float rightSample = 0.6f;
        itdIldPanEffect.Process(ref leftSample, ref rightSample);

        // Output processed sample
        Console.WriteLine($"Processed Left Sample: {leftSample}");
        Console.WriteLine($"Processed Right Sample: {rightSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.PanEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.PanEffect is a stereo panning audio effect.

Properties

1. Pan

  • public float Pan { get; set; }
    • Gets or setsPan (range [-1..1]).

2. PanRule

  • public PanRule PanRule { get; set; }
    • Gets or setsPan rule (pan law).

Methods

1. PanEffect constructor

  • public PanEffect(float pan, PanRule panRule)
    • Constructs PanEffect instance.
    • Parameters:
      • pan: Pan.
      • panRule: Pan rule (pan law).

2. Process

  • public override void Process(ref float left, ref float right)
    • Processes one sample per channel: [in L, in R] -> [out L, out R].
    • Parameters:
      • left: left-channel Input sample.
      • right: right-channel Input sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses PanEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects.Stereo;

public class PanEffectExample
{
    public static void Main()
    {
        // Create PanEffect instance
        var panEffect = new PanEffect(0.5f, PanRule.ConstantPower);

        // Set pan
        panEffect.Pan = -0.3f;

        // Process sample
        float leftSample = 0.5f;
        float rightSample = 0.6f;
        panEffect.Process(ref leftSample, ref rightSample);

        // Output processed sample
        Console.WriteLine($"Processed Left Sample: {leftSample}");
        Console.WriteLine($"Processed Right Sample: {rightSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.PingPongDelayEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.PingPongDelayEffect is a stereo ping-pong delay effect.

Properties

1. Pan

  • public float Pan { get; set; }
    • Gets or setsPan.

2. Delay

  • public float Delay { get; set; }
    • Gets or setsDelay time (seconds).

3. Feedback

  • public float Feedback { get; set; }
    • Gets or setsFeedback coefficient.

Methods

1. PingPongDelayEffect constructor

  • public PingPongDelayEffect(int samplingRate, float pan, float delay, float feedback = 0.5f, InterpolationMode interpolationMode = InterpolationMode.Nearest, float reserveDelay = 0)
    • Constructs PingPongDelayEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • pan: Pan.
      • delay: Delay time (seconds).
      • feedback: Feedback coefficient; default 0.5.
      • interpolationMode: Fractional delay interpolation; default InterpolationMode.Nearest.
      • reserveDelay: Maximum reserved delay; default 0 s.

2. Process

  • public override void Process(ref float left, ref float right)
    • Processes one sample per channel: [in L, in R] -> [out L, out R].
    • Parameters:
      • left: left-channel Input sample.
      • right: right-channel Input sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses PingPongDelayEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects.Stereo;

public class PingPongDelayEffectExample
{
    public static void Main()
    {
        // Create PingPongDelayEffect instance
        var pingPongDelayEffect = new PingPongDelayEffect(44100, 0.5f, 0.3f, 0.6f);

        // Set pan and delay
        pingPongDelayEffect.Pan = 0.8f;
        pingPongDelayEffect.Delay = 0.4f;
        pingPongDelayEffect.Feedback = 0.7f;

        // Process sample
        float leftSample = 0.5f;
        float rightSample = 0.6f;
        pingPongDelayEffect.Process(ref leftSample, ref rightSample);

        // Output processed sample
        Console.WriteLine($"Processed Left Sample: {leftSample}");
        Console.WriteLine($"Processed Right Sample: {rightSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.StereoDelayEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.StereoDelayEffect is a stereo delay effect.

Properties

1. DelayLeft

  • public float DelayLeft { get; set; }
    • Gets or setsleft-channel Delay time (seconds).

2. DelayRight

  • public float DelayRight { get; set; }
    • Gets or setsright-channel Delay time (seconds).

3. FeedbackLeft

  • public float FeedbackLeft { get; set; }
    • Gets or setsleft-channel Feedback coefficient.

4. FeedbackRight

  • public float FeedbackRight { get; set; }
    • Gets or setsright-channel Feedback coefficient.

5. Pan

  • public float Pan { get; set; }
    • Gets or setsPan.

Methods

1. StereoDelayEffect constructor

  • public StereoDelayEffect(int samplingRate, float pan, float delayLeft, float delayRight, float feedbackLeft = 0.5f, float feedbackRight = 0.5f, InterpolationMode interpolationMode = InterpolationMode.Nearest, float reserveDelay = 0)
    • Constructs StereoDelayEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • pan: Pan.
      • delayLeft: left-channel Delay time (seconds).
      • delayRight: right-channel Delay time (seconds).
      • feedbackLeft: left-channel Feedback coefficient; default 0.5.
      • feedbackRight: right-channel Feedback coefficient; default 0.5.
      • interpolationMode: Fractional delay interpolation; default InterpolationMode.Nearest.
      • reserveDelay: Maximum reserved delay; default 0 s.

2. Process

  • public override void Process(ref float left, ref float right)
    • Processes one sample per channel: [in L, in R] -> [out L, out R].
    • Parameters:
      • left: left-channel Input sample.
      • right: right-channel Input sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses StereoDelayEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects.Stereo;

public class StereoDelayEffectExample
{
    public static void Main()
    {
        // Create StereoDelayEffect instance
        var stereoDelayEffect = new StereoDelayEffect(44100, 0.5f, 0.3f, 0.4f, 0.6f, 0.7f);

      // Set pan and delay
        stereoDelayEffect.Pan = 0.8f;
        stereoDelayEffect.DelayLeft = 0.4f;
        stereoDelayEffect.DelayRight = 0.5f;
        stereoDelayEffect.FeedbackLeft = 0.7f;
        stereoDelayEffect.FeedbackRight = 0.8f;

        // Process sample
        float leftSample = 0.5f;
        float rightSample = 0.6f;
        stereoDelayEffect.Process(ref leftSample, ref rightSample);

        // Output processed sample
        Console.WriteLine($"Processed Left Sample: {leftSample}");
        Console.WriteLine($"Processed Right Sample: {rightSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.StereoEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.Stereo.StereoEffect is an abstract base class for stereo audio effects, inheriting WetDryMixer.

Methods

1. Process

  • public abstract void Process(ref float left, ref float right)
    • Processes one sample per channel: [in L, in R] -> [out L, out R].
    • Parameters:
      • left: left-channel Input sample.
      • right: right-channel Input sample.

2. Process

  • public virtual void Process(float sample, out float left, out float right)
    • Processes mono sample: input -> [out L, out R].
    • Parameters:
      • sample: mono Input sample.
      • left: left-channel output sample.
      • right: right-channel output sample.

3. Process

  • public virtual void Process(float[] inputLeft, float[] inputRight, float[] outputLeft, float[] outputRight, int count = 0, int inputPos = 0, int outputPos = 0)
    • Processes sample blocks per channel: [in L, in R] -> [out L, out R].
    • Parameters:
      • inputLeft: Left-channel input block.
      • inputRight: Right-channel input block.
      • outputLeft: Left-channel output block.
      • outputRight: Right-channel output block.
      • count: Number of samples to process; default 0.
      • inputPos: Input start index; default 0.
      • outputPos: Output start index; default 0.

4. Process

  • public virtual void Process(float[] input, float[] outputLeft, float[] outputRight, int count = 0, int inputPos = 0, int outputPos = 0)
    • Processes mono block: [input] -> [out L, out R].
    • Parameters:
      • input: Mono input block.
      • outputLeft: Left-channel output block.
      • outputRight: Right-channel output block.
      • count: Number of samples to process; default 0.
      • inputPos: Input start index; default 0.
      • outputPos: Output start index; default 0.

5. ApplyTo

  • public virtual (Signal, Signal) ApplyTo(Signal signal)
    • Apply effect to entire signal，and returns output signal tuple [left signal，right signal]。
    • Parameters:
      • signal: input signal.

6. ApplyTo

  • public virtual (Signal, Signal) ApplyTo(Signal leftSignal, Signal rightSignal)
    • Applies effect to left/right signals; returns tuple [left, right] outputs.
    • Parameters:
      • leftSignal: left-channel input signal.
      • rightSignal: right-channel input signal.

7. Reset

  • public abstract void Reset()
    • Resets the effect.

Code example

The following example uses StereoEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects.Stereo;

public class CustomStereoEffect : StereoEffect
{
    public override void Process(ref float left, ref float right)
    {
        // Custom processing logic
        left *= 0.5f;
        right *= 0.5f;
    }
    public override void Reset()
    {
        // Custom reset logic
    }
}
public class StereoEffectExample
{
    public static void Main()
    {
        // Create CustomStereoEffect instance
        var stereoEffect = new CustomStereoEffect();
        // Process sample
        float leftSample = 0.5f;
        float rightSample = 0.6f;
        stereoEffect.Process(ref leftSample, ref rightSample);

        // Output processed sample
        Console.WriteLine($"Processed Left Sample: {leftSample}");
        Console.WriteLine($"Processed Right Sample: {rightSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.AutowahEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.AutowahEffect is an autowah effect combining envelope follower and wah.

Properties

1. Q

  • public float Q { get; set; }
    • Gets or sets Q factor (quality factor / resonance).

2. MinFrequency

  • public float MinFrequency { get; set; }
    • Gets or setsMinimum LFO frequency (Hz).

3. MaxFrequency

  • public float MaxFrequency { get; set; }
    • Gets or setsMaximum LFO frequency (Hz).

4. AttackTime

  • public float AttackTime { get; set; }
    • Gets or setsAttack time (seconds).

5. ReleaseTime

  • public float ReleaseTime { get; set; }
    • Gets or setsRelease time (seconds).

Methods

1. AutowahEffect constructor

  • public AutowahEffect(int samplingRate, float minFrequency = 30, float maxFrequency = 2000, float q = 0.5f, float attackTime = 0.01f, float releaseTime = 0.05f)
    • Constructs AutowahEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • minFrequency: Minimum LFO frequency (Hz); default 30 Hz.
      • maxFrequency: Maximum LFO frequency (Hz); default 2000 Hz.
      • q: Q factor; default 0.5.
      • attackTime: Attack time (seconds); default 0.01 s.
      • releaseTime: Release time (seconds); default 0.05 s.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses AutowahEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class AutowahEffectExample
{
    public static void Main()
    {
        // Create AutowahEffect instance
        var autowahEffect = new AutowahEffect(44100, 30, 2000, 0.5f, 0.01f, 0.05f);

        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Process sample
        foreach (var sample in signal.Samples)
        {
            var processedSample = autowahEffect.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.BitCrusherEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.BitCrusherEffect is a bit-crusher distortion effect, inheriting AudioEffect.

Properties

1. BitDepth

  • public int BitDepth { get; set; }
    • Gets or setsBit depth (bits).

Methods

1. BitCrusherEffect constructor

  • public BitCrusherEffect(int bitDepth)
    • Constructs BitCrusherEffect instance.
    • Parameters:
      • bitDepth: Bit depth (bits).

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses BitCrusherEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;
public class BitCrusherEffectExample
{
    public static void Main()
    {
        // Create BitCrusherEffect instance
        var bitCrusherEffect = new BitCrusherEffect(8);

        // Set bit depth
        bitCrusherEffect.BitDepth = 6;

        // Process sample
        float sample = 0.5f;
        float processedSample = bitCrusherEffect.Process(sample);

        // Output processed sample
        Console.WriteLine($"Processed Sample: {processedSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.ChorusEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.ChorusEffect is a chorus effect, inheriting AudioEffect.

Properties

1. Widths

  • public float[] Widths { get; set; }
    • Gets or setsWidth per voice (max delay, seconds).

2. LfoFrequencies

  • public float[] LfoFrequencies { get; set; }
    • Gets or sets LFO frequency per voice.

Methods

1. ChorusEffect constructor

  • public ChorusEffect(int samplingRate, float[] lfoFrequencies, float[] widths)
    • Constructs ChorusEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfoFrequencies: LFO frequency per voice.
      • widths: Width per voice (max delay, seconds).

2. ChorusEffect constructor

  • public ChorusEffect(int samplingRate, ISampleGenerator[] lfos, float[] widths)
    • Constructs ChorusEffect from LFO.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfos: LFOs as sample generators.
      • widths: Width per voice (max delay, seconds).

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

4. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses ChorusEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;

public class ChorusEffectExample
{
    public static void Main()
    {
        // Create ChorusEffect instance
        float[] lfoFrequencies = { 0.25f, 0.3f, 0.35f };
        float[] widths = { 0.002f, 0.003f, 0.004f };
        var chorusEffect = new ChorusEffect(44100, lfoFrequencies, widths);

        // Process sample
        float sample = 0.5f;
        float processedSample = chorusEffect.Process(sample);

        // Output processed sample
        Console.WriteLine($"Processed Sample: {processedSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.DelayEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.DelayEffect is a delay effect, inheriting AudioEffect.

Properties

1. Delay

  • public float Delay { get; set; }
    • Gets or setsDelay time (seconds).

2. Feedback

  • public float Feedback { get; set; }
    • Gets or setsFeedback parameter.

Methods

1. DelayEffect constructor

  • public DelayEffect(int samplingRate, float delay, float feedback = 0.5f, InterpolationMode interpolationMode = InterpolationMode.Nearest, float reserveDelay = 0f)
    • Constructs DelayEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • delay: Delay time (seconds).
      • feedback: Feedback; default 0.5.
      • interpolationMode: Fractional delay interpolation; default InterpolationMode.Nearest.
      • reserveDelay: Maximum reserved delay; default 0 s.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses DelayEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;

public class DelayEffectExample
{
    public static void Main()
    {
        // Create DelayEffect instance
        var delayEffect = new DelayEffect(44100, 0.5f, 0.6f);

        // Set delay and feedback
        delayEffect.Delay = 0.4f;
        delayEffect.Feedback = 0.7f;

        // Process sample
        float sample = 0.5f;
        float processedSample = delayEffect.Process(sample);

        // Output processed sample
        Console.WriteLine($"Processed Sample: {processedSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.DistortionEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.DistortionEffect is a distortion effect, inheriting AudioEffect.

Properties

1. Mode

  • public DistortionMode Mode { get; set; }
    • Gets or setsDistortion mode (soft/hard clipping, exponential, full/half-wave rectification).

2. InputGain

  • public float InputGain { get; set; }
    • Gets or setsInput gain (dB).

3. OutputGain

  • public float OutputGain { get; set; }
    • Gets or setsOutput gain (dB).

Methods

1. DistortionEffect constructor

  • public DistortionEffect(DistortionMode mode, float inputGain = 12f, float outputGain = -12f)
    • Constructs DistortionEffect instance.
    • Parameters:
      • mode: Distortion mode.
      • inputGain: Input gain (dB); default 12 dB.
      • outputGain: Output gain (dB); default -12 dB.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses DistortionEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;

public class DistortionEffectExample
{
    public static void Main()
    {
        // Create DistortionEffect instance
        var distortionEffect = new DistortionEffect(DistortionMode.HardClipping, 12f, -12f);

        // Set distortion mode and gain
        distortionEffect.Mode = DistortionMode.SoftClipping;
        distortionEffect.InputGain = 10f;
        distortionEffect.OutputGain = -10f;

        // Process sample
        float sample = 0.5f;
        float processedSample = distortionEffect.Process(sample);

        // Output processed sample
        Console.WriteLine($"Processed Sample: {processedSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.EchoEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.EchoEffect is an echo effect, inheriting AudioEffect.

Properties

1. Delay

  • public float Delay { get; set; }
    • Gets or setsDelay time (seconds).

2. Feedback

  • public float Feedback { get; set; }
    • Gets or setsFeedback parameter.

Methods

1. EchoEffect constructor

  • public EchoEffect(int samplingRate, float delay, float feedback = 0.5f, InterpolationMode interpolationMode = InterpolationMode.Nearest, float reserveDelay = 0f)
    • Constructs EchoEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • delay: Delay time (seconds).
      • feedback: Feedback; default 0.5.
      • interpolationMode: Fractional delay interpolation; default InterpolationMode.Nearest.
      • reserveDelay: Maximum reserved delay; default 0 s.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses EchoEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;

public class EchoEffectExample
{
    public static void Main()
    {
        // Create EchoEffect instance
        var echoEffect = new EchoEffect(44100, 0.5f, 0.6f);

        // Set delay and feedback
        echoEffect.Delay = 0.4f;
        echoEffect.Feedback = 0.7f;

        // Process sample
        float sample = 0.5f;
        float processedSample = echoEffect.Process(sample);

        // Output processed sample
        Console.WriteLine($"Processed Sample: {processedSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.FlangerEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.FlangerEffect is a flanger effect, inheriting AudioEffect.

Properties

1. Width

  • public float Width { get; set; }
    • Gets or setsWidth (seconds).

2. LfoFrequency

  • public float LfoFrequency { get; set; }
    • Gets or sets LFO frequency (Hz).

3. Lfo

  • public ISampleGenerator Lfo { get; set; }
    • Gets or sets LFO sample generator.

4. Depth

  • public float Depth { get; set; }
    • Gets or setsDepth.

5. Feedback

  • public float Feedback { get; set; }
    • Gets or setsFeedback parameter.

6. Inverted

  • public bool Inverted { get; set; }
    • Gets or setsInverted mode flag.

7. InterpolationMode

  • public InterpolationMode InterpolationMode { get; set; }
    • Gets or setsInterpolation mode.

Methods

1. FlangerEffect constructor

  • public FlangerEffect(int samplingRate, float lfoFrequency = 1f, float width = 0.003f, float depth = 0.5f, float feedback = 0, bool inverted = false, InterpolationMode interpolationMode = InterpolationMode.Linear, float reserveWidth = 0f)
    • Constructs FlangerEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfoFrequency: LFO frequency (Hz); default 1 Hz.
      • width: Width (seconds); default 0.003 s.
      • depth: Depth; default 0.5.
      • feedback: Feedback; default 0.
      • inverted: Inverted mode; default false.
      • interpolationMode: Fractional delay line interpolation; default InterpolationMode.Linear.
      • reserveWidth: Maximum reserved width; default 0 s.

2. FlangerEffect constructor

  • public FlangerEffect(int samplingRate, ISampleGenerator lfo, float width = 0.003f, float depth = 0.5f, float feedback = 0, bool inverted = false, InterpolationMode interpolationMode = InterpolationMode.Linear, float reserveWidth = 0f)
    • Constructs FlangerEffect from LFO.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfo: LFO sample generator.
      • width: Width (seconds); default 0.003 s.
      • depth: Depth; default 0.5.
      • feedback: Feedback; default 0.
      • inverted: Inverted mode; default false.
      • interpolationMode: Fractional delay line interpolation; default InterpolationMode.Linear.
      • reserveWidth: Maximum reserved width; default 0 s.

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

4. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses FlangerEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;
public class FlangerEffectExample
{
    public static void Main()
    {
        // Create FlangerEffect instance
        var flangerEffect = new FlangerEffect(44100, 0.25f, 0.003f, 0.5f, 0.6f, false);

        // Set parameters
        flangerEffect.Width = 0.004f;
        flangerEffect.LfoFrequency = 0.5f;
        flangerEffect.Depth = 0.7f;
        flangerEffect.Feedback = 0.8f;
        flangerEffect.Inverted = true;

        // Process sample
        float sample = 0.5f;
        float processedSample = flangerEffect.Process(sample);

        // Output processed sample
        Console.WriteLine($"Processed Sample: {processedSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.MorphEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.MorphEffect is a morph effect mixing two signals, inheriting AudioEffect.

Properties

No public properties.

Methods

1. MorphEffect constructor

  • public MorphEffect(int hopSize, int fftSize = 0)
    • Constructs MorphEffect instance.
    • Parameters:
      • hopSize: Hop size (samples).
      • fftSize: FFT size; default 0.

2. Process

  • public float Process(float sample, float mix)
    • Processes one input sample and one mix sample.
    • Parameters:
      • sample: input signalSample.
      • mix: Mix signal sample.
    • Returns: processed sample.

3. ProcessFrame

  • protected void ProcessFrame()
    • Processes one frame (block).

4. Reset

  • public override void Reset()
    • Resets the effect.

5. ApplyTo

  • public Signal ApplyTo(Signal signal, Signal mix)
    • Applies effect to entire input and mix signals.
    • Parameters:
      • signal: input signal.
      • mix: Signal to mix with input.
    • Returns: Processed Signal.

6. Process

  • public override float Process(float sample)
    • Processes one sample. Not implemented in MorphEffect.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

Code example

The following example uses MorphEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class MorphEffectExample
{
    public static void Main()
    {
        // Create MorphEffect instance
        var morphEffect = new MorphEffect(256, 1024);
        // Define input and mix signals
        float[] inputSamples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        float[] mixSamples = { 0.4f, 0.5f, 0.45f, 0.6f, 0.55f };
        var inputSignal = Signal.FromCopy(inputSamples, 44100);
        var mixSignal = Signal.FromCopy(mixSamples, 44100);

        // Apply effect to entire signal
        var processedSignal = morphEffect.ApplyTo(inputSignal, mixSignal);

        // Output processed signal samples
        Console.WriteLine("Processed Signal:");
        foreach (var sample in processedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.PhaserEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.PhaserEffect is a phaser effect, inheriting AudioEffect.

Properties

1. Q

  • public float Q { get; set; }
    • Gets or sets Q factor (quality factor / resonance).

2. LfoFrequency

  • public float LfoFrequency { get; set; }
    • Gets or sets LFO frequency (Hz).

3. MinFrequency

  • public float MinFrequency { get; set; }
    • Gets or setsMinimum LFO frequency (Hz).

4. MaxFrequency

  • public float MaxFrequency { get; set; }
    • Gets or setsMaximum LFO frequency (Hz).

5. Lfo

  • public ISampleGenerator Lfo { get; set; }
    • Gets or sets LFO sample generator.

Methods

1. PhaserEffect constructor

  • public PhaserEffect(int samplingRate, float lfoFrequency = 1.0f, float minFrequency = 300, float maxFrequency = 3000, float q = 0.5f)
    • Constructs PhaserEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfoFrequency: LFO frequency (Hz); default 1.0 Hz.
      • minFrequency: Minimum LFO frequency (Hz); default 300 Hz.
      • maxFrequency: Maximum LFO frequency (Hz); default 3000 Hz.
      • q: Q factor; default 0.5.

2. PhaserEffect constructor

  • public PhaserEffect(int samplingRate, ISampleGenerator lfo, float q = 0.5f)
    • Constructs PhaserEffect from LFO.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfo: LFO sample generator.
      • q: Q factor; default 0.5.

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

4. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses PhaserEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing.Effects;

public class PhaserEffectExample
{
    public static void Main()
    {
        // Create PhaserEffect instance
        var phaserEffect = new PhaserEffect(44100, 0.5f, 300, 3000, 0.7f);
        // Set parameters
        phaserEffect.LfoFrequency = 0.8f;
        phaserEffect.MinFrequency = 200;
        phaserEffect.MaxFrequency = 4000;
        phaserEffect.Q = 0.6f;

        // Process sample
        float sample = 0.5f;
        float processedSample = phaserEffect.Process(sample);

        // Output processed sample
        Console.WriteLine($"Processed Sample: {processedSample}");
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.PitchShiftEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.PitchShiftEffect is an offline pitch-shift effect using TSM algorithms and linear interpolation. Does not support online Process(float).

Properties

1. Shift

  • public float Shift { get; set; }
    • Gets or setsPitch shift ratio.

2. Tsm

  • public TsmAlgorithm Tsm { get; set; }
    • Gets or setsTime-scale modification algorithm.

3. WindowSize

  • public int WindowSize { get; set; }
    • Gets or setsWindow size (frame length).

4. HopSize

  • public int HopSize { get; set; }
    • Gets or setsHop size.

Methods

1. PitchShiftEffect constructor

  • public PitchShiftEffect(float shift, int windowSize = 1024, int hopSize = 128, TsmAlgorithm tsm = TsmAlgorithm.PhaseVocoderPhaseLocking)
    • Constructs PitchShiftEffect instance.
    • Parameters:
      • shift: Pitch shift ratio.
      • windowSize: Window size; default 1024.
      • hopSize: Hop size; default 128.
      • tsm: TSM algorithm; default TsmAlgorithm.PhaseVocoderPhaseLocking.

2. ApplyTo

  • public override Signal ApplyTo(Signal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies effect to entire signal; returns pitch-shifted signal.
    • Parameters:
      • signal: input signal.
      • method: Filtering method; default FilteringMethod.Auto.
    • Returns: Processed Signal.

3. Apply

  • public override void Apply(Signal signal, FilteringMethod method = FilteringMethod.Auto)
    • Applies effect to entire signal (in-place).
    • Parameters:
      • signal: input signal.
      • method: Filtering method; default FilteringMethod.Auto.

4. Process

  • public override float Process(float sample)
    • Processes one sample. Not implemented in PitchShiftEffect.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

5. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses PitchShiftEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class PitchShiftEffectExample
{
    public static void Main()
    {
        // Create PitchShiftEffect instance
        var pitchShiftEffect = new PitchShiftEffect(1.2f, 1024, 128, TsmAlgorithm.PhaseVocoderPhaseLocking);
        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Apply effect to entire signal
        var processedSignal = pitchShiftEffect.ApplyTo(signal);

        // Output processed signal samples
        Console.WriteLine("Processed Signal:");
        foreach (var sample in processedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.PitchShiftVocoderEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.PitchShiftVocoderEffect is a pitch-shift vocoder effect via overlap-add, inheriting OverlapAddFilter.

Properties

1. Shift

  • public float Shift { get; set; }
    • Gets or setsPitch shift ratio.

Methods

1. PitchShiftVocoderEffect constructor

  • public PitchShiftVocoderEffect(int samplingRate, float shift, int fftSize = 1024, int hopSize = 64)
    • Constructs PitchShiftVocoderEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • shift: Pitch shift ratio.
      • fftSize: FFT size; default 1024.
      • hopSize: Hop size; default 64.

2. ProcessSpectrum

  • protected override void ProcessSpectrum(float[] re, float[] im, float[] filteredRe, float[] filteredIm)
    • Processes one spectrum per overlap-add STFT step.
    • Parameters:
      • re: Real part of input spectrum.
      • im: Imaginary part of input spectrum.
      • filteredRe: Real part of output spectrum.
      • filteredIm: Imaginary part of output spectrum.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses PitchShiftVocoderEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class PitchShiftVocoderEffectExample
{
    public static void Main()
    {
        // Create PitchShiftVocoderEffect instance
        var pitchShiftVocoderEffect = new PitchShiftVocoderEffect(44100, 1.2f, 1024, 64);
        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Apply effect to entire signal
        var processedSignal = pitchShiftVocoderEffect.ApplyTo(signal);

        // Output processed signal samples
        Console.WriteLine("Processed Signal:");
        foreach (var sample in processedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.RobotEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.RobotEffect is a robot voice effect, inheriting OverlapAddFilter.

Methods

1. RobotEffect constructor

  • public RobotEffect(int hopSize, int fftSize = 0)
    • Constructs RobotEffect instance.
    • Parameters:
      • hopSize: Hop size (samples).
      • fftSize: FFT size; default 0.

2. ProcessSpectrum

  • protected override void ProcessSpectrum(float[] re, float[] im, float[] filteredRe, float[] filteredIm)
    • Processes spectrum per overlap-add STFT step (sets phase to 0).
    • Parameters:
      • re: Real part of input spectrum.
      • im: Imaginary part of input spectrum.
      • filteredRe: Real part of output spectrum.
      • filteredIm: Imaginary part of output spectrum.

Code example

The following example uses RobotEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class RobotEffectExample
{
    public static void Main()
    {
        // Create RobotEffect instance
        var robotEffect = new RobotEffect(256, 1024);
        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Apply effect to entire signal
        var processedSignal = robotEffect.ApplyTo(signal);

        // Output processed signal samples
        Console.WriteLine("Processed Signal:");
        foreach (var sample in processedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.TremoloEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.TremoloEffect is a tremolo effect, inheriting AudioEffect.

Properties

1. Depth

  • public float Depth { get; set; }
    • Gets or setsDepth.

2. Frequency

  • public float Frequency { get; set; }
    • Gets or setsTremolo frequency (modulation rate) (Hz).

3. Index

  • public float Index { get; set; }
    • Gets or setsTremolo index (modulation index).

4. Lfo

  • public ISampleGenerator Lfo { get; set; }
    • Gets or sets LFO sample generator.

Methods

1. TremoloEffect constructor

  • public TremoloEffect(int samplingRate, float depth = 0.5f, float frequency = 10f, float tremoloIndex = 0.5f)
    • Constructs TremoloEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • depth: Depth; default 0.5.
      • frequency: Tremolo frequency (Hz); default 10 Hz.
      • tremoloIndex: Tremolo index; default 0.5.

2. TremoloEffect constructor

  • public TremoloEffect(ISampleGenerator lfo, float depth = 0.5f)
    • Constructs TremoloEffect from LFO.
    • Parameters:
      • lfo: LFO sample generator.
      • depth: Depth; default 0.5.

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

4. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses TremoloEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class TremoloEffectExample
{
    public static void Main()
    {
        // Create TremoloEffect instance
        var tremoloEffect = new TremoloEffect(44100, 0.5f, 10f, 0.5f);
        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Process sample
        foreach (var sample in signal.Samples)
        {
            var processedSample = tremoloEffect.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.TubeDistortionEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.TubeDistortionEffect is a tube distortion effect, inheriting AudioEffect.

Properties

1. InputGain

  • public float InputGain { get; set; }
    • Gets or setsInput gain (dB).

2. OutputGain

  • public float OutputGain { get; set; }
    • Gets or setsOutput gain (dB).

3. Q

  • public float Q { get; set; }
    • Gets or sets Q factor (operating point). Controls linearity at low input levels; more negative is more linear.

4. Dist

  • public float Dist { get; set; }
    • Gets or setsDistortion character; higher values yield harder distortion.

5. Rh

  • public float Rh { get; }
    • Gets Filter coefficient (near 1.0) for highpass pole position (DC removal).

6. Rl

  • public float Rl { get; }
    • Gets Filter coefficient [0,1] for lowpass pole (tube amp capacitance model).

Methods

1. TubeDistortionEffect constructor

  • public TubeDistortionEffect(float inputGain = 20f, float outputGain = -12f, float q = -0.2f, float dist = 5, float rh = 0.995f, float rl = 0.5f)
    • Constructs TubeDistortionEffect instance.
    • Parameters:
      • inputGain: Input gain (dB); default 20 dB.
      • outputGain: Output gain (dB); default -12 dB.
      • q: Q factor; default -0.2.
      • dist: Distortion character; default 5.
      • rh: Highpass coefficient; default 0.995.
      • rl: Lowpass coefficient; default 0.5.

2. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

3. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses TubeDistortionEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;
public class TubeDistortionEffectExample
{
    public static void Main()
    {
        // Create TubeDistortionEffect instance
        var tubeDistortionEffect = new TubeDistortionEffect(20f, -12f, -0.2f, 5, 0.995f, 0.5f);
        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Process sample
        foreach (var sample in signal.Samples)
        {
            var processedSample = tubeDistortionEffect.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.VibratoEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.VibratoEffect is a tremolo effect, inheriting AudioEffect.

Properties

1. Width

  • public float Width { get; set; }
    • Gets or setsWidth (seconds).

2. LfoFrequency

  • public float LfoFrequency { get; set; }
    • Gets or sets LFO frequency (Hz).

3. Lfo

  • public ISampleGenerator Lfo { get; set; }
    • Gets or sets LFO sample generator.

4. InterpolationMode

  • public InterpolationMode InterpolationMode { get; set; }
    • Gets or setsInterpolation mode.

Methods

1. VibratoEffect constructor

  • public VibratoEffect(int samplingRate, float lfoFrequency = 1f, float width = 0.003f, InterpolationMode interpolationMode = InterpolationMode.Linear, float reserveWidth = 0f)
    • Constructs VibratoEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfoFrequency: LFO frequency (Hz); default 1 Hz.
      • width: Width (seconds); default 0.003 s.
      • interpolationMode: Interpolation mode; default InterpolationMode.Linear.
      • reserveWidth: Maximum reserved width; default 0 s.

2. VibratoEffect constructor

  • public VibratoEffect(int samplingRate, ISampleGenerator lfo, float width = 0.003f, InterpolationMode interpolationMode = InterpolationMode.Linear, float reserveWidth = 0f)
    • Constructs VibratoEffect from LFO.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfo: LFO sample generator.
      • width: Width (seconds); default 0.003 s.
      • interpolationMode: Interpolation mode; default InterpolationMode.Linear.
      • reserveWidth: Maximum reserved width; default 0 s.

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

4. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses VibratoEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class VibratoEffectExample
{
    public static void Main()
    {
        // Create VibratoEffect instance
        var vibratoEffect = new VibratoEffect(44100, 1f, 0.003f, InterpolationMode.Linear, 0f);
        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Process sample
        foreach (var sample in signal.Samples)
        {
            var processedSample = vibratoEffect.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.WahwahEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.WahwahEffect is a wah-wah effect, inheriting AudioEffect.

Properties

1. LfoFrequency

  • public float LfoFrequency { get; set; }
    • Gets or sets LFO frequency (Hz).

2. MinFrequency

  • public float MinFrequency { get; set; }
    • Gets or setsMinimum LFO frequency (Hz).

3. MaxFrequency

  • public float MaxFrequency { get; set; }
    • Gets or setsMaximum LFO frequency (Hz).

4. Q

  • public float Q { get; set; }
    • Gets or sets Q factor (quality factor / resonance).

5. Lfo

  • public ISampleGenerator Lfo { get; set; }
    • Gets or sets LFO sample generator.

Methods

1. WahwahEffect constructor

  • public WahwahEffect(int samplingRate, float lfoFrequency = 1.0f, float minFrequency = 300, float maxFrequency = 1500, float q = 0.5f)
    • Constructs WahwahEffect instance.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfoFrequency: LFO frequency (Hz); default 1.0 Hz.
      • minFrequency: Minimum LFO frequency (Hz); default 300 Hz.
      • maxFrequency: Maximum LFO frequency (Hz); default 1500 Hz.
      • q: Q factor; default 0.5.

2. WahwahEffect constructor

  • public WahwahEffect(int samplingRate, ISampleGenerator lfo, float q = 0.5f)
    • Constructs WahwahEffect from LFO.
    • Parameters:
      • samplingRate: Sampling rate.
      • lfo: LFO sample generator.
      • q: Q factor; default 0.5.

3. Process

  • public override float Process(float sample)
    • Processes one sample.
    • Parameters:
      • sample: Input sample.
    • Returns: processed sample.

4. Reset

  • public override void Reset()
    • Resets the effect.

Code example

The following example uses WahwahEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class WahwahEffectExample
{
    public static void Main()
    {
        // Create WahwahEffect instance
        var wahwahEffect = new WahwahEffect(44100, 1.0f, 300, 1500, 0.5f);
        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Process sample
        foreach (var sample in signal.Samples)
        {
            var processedSample = wahwahEffect.Process(sample);
            Console.WriteLine($"Processed Sample: {processedSample}");
        }
    }
}

Vorcyc.Mathematics.SignalProcessing.Effects.WhisperEffect class

Vorcyc.Mathematics.SignalProcessing.Effects.WhisperEffect is a whisper voice effect, inheriting OverlapAddFilter.

Methods

1. WhisperEffect constructor

  • public WhisperEffect(int hopSize, int fftSize = 0)
    • Constructs WhisperEffect instance.
    • Parameters:
      • hopSize: Hop size (samples).
      • fftSize: FFT size; default 0.

2. ProcessSpectrum

  • protected override void ProcessSpectrum(float[] re, float[] im, float[] filteredRe, float[] filteredIm)
    • Processes one spectrum per overlap-add STFT step.
    • Parameters:
      • re: Real part of input spectrum.
      • im: Imaginary part of input spectrum.
      • filteredRe: Real part of output spectrum.
      • filteredIm: Imaginary part of output spectrum.

Code example

The following example uses WhisperEffect with comments:

using System;
using Vorcyc.Mathematics.SignalProcessing;
using Vorcyc.Mathematics.SignalProcessing.Effects;
using Vorcyc.Mathematics.SignalProcessing.Signals;

public class WhisperEffectExample
{
    public static void Main()
    {
        // Create WhisperEffect instance        
        var whisperEffect = new WhisperEffect(256, 1024);
        // Define input signal
        float[] samples = { 0.5f, 0.6f, 0.55f, 0.7f, 0.65f };
        var signal = Signal.FromCopy(samples, 44100);

        // Apply effect to entire signal
        var processedSignal = whisperEffect.ApplyTo(signal);

        // Output processed signal samples
        Console.WriteLine("Processed Signal:");
        foreach (var sample in processedSignal.Samples)
        {
            Console.WriteLine(sample);
        }
    }
}