21 releases
0.2.12-alpha.0 | Apr 7, 2023 |
---|---|
0.2.11-alpha.0 | Dec 19, 2022 |
0.2.5-alpha.0 | Jun 21, 2022 |
0.2.4-alpha.0 | Mar 14, 2022 |
0.1.42-alpha.0 | Oct 27, 2021 |
#8 in #modulation
93 downloads per month
Used in 3 crates
480KB
5K
SLoC
surge-modulation
This Rust crate, surge-modulation
, is
a component of the larger Surge synthesizer
system. It provides a set of tools and structures
for working with modulation sources and routing
modulation between different parts of the
synthesizer.
Modulation Sources
The ModulationSource
trait defines a common
interface for all types of modulation sources,
such as LFOs, envelopes, and custom
controllers. Each modulation source can be enabled
or disabled, and can produce a modulation value
that can be used to modulate a variety of
parameters within the synthesizer.
Several types of modulation sources are included
in the crate, including LFOs (voice_lfo
and
scene_lfo
), envelopes (attack
and release
),
and custom controllers (ctrl
). These modulation
sources can be used to create a wide range of
modulations, from subtle filter sweeps to complex
rhythmic patterns.
Modulation Routing
The ModulationRouting
structure provides a way
to route modulation sources to different
parameters within the synthesizer. Each
ModulationRouting
consists of a source (an
instance of ModulationSource
) and a target
parameter (e.g., a filter cutoff frequency).
Modulation routings can be enabled or disabled,
and can be bipolar or unipolar depending on the
modulation source used. The ModulationRouting
structure also supports per-voice modulation,
which allows different voices in a polyphonic
patch to have different modulation values.
Controller Modulation Sources
The ControllerModulationSource
trait provides
a way to use MIDI controllers as modulation
sources. This allows the user to use knobs,
sliders, and other MIDI controllers to modulate
parameters within the synthesizer.
Math and Algorithms
The surge-modulation
crate uses a variety of
mathematical concepts and algorithms to implement
its modulation sources and routing. For example,
the LFO modulation sources use sine waves to
produce modulation values, while the envelope
modulation sources use exponential curves to
produce attack and release values.
Overall, surge-modulation
is a powerful and
flexible Rust crate for working with modulation
sources and routing modulation within
a synthesizer. Its modular design and flexible
interface make it easy to integrate with other
components of the Surge synthesizer system, as
well as with other software and hardware
synthesizers.
18> what can be a modulation source?
In a synthesizer, a modulation source is any source of control signals that can be used to modulate (i.e., alter) the value of a target parameter. Modulation sources can be used to add movement, variation, and expressiveness to a sound, and are a key part of many synthesizer patches and sounds.
There are many types of modulation sources that can be used in a synthesizer, including:
-
LFOs: Low-frequency oscillators (LFOs) produce a continuous waveform at a low frequency (usually less than 20 Hz) that can be used to modulate parameters such as pitch, filter cutoff, and amplitude.
-
Envelopes: Envelopes produce a series of control signals that vary over time, typically with an attack-decay-sustain-release (ADSR) envelope shape. Envelopes can be used to modulate parameters such as filter cutoff, amplitude, and pitch.
-
MIDI Controllers: MIDI controllers, such as knobs, sliders, and buttons on a MIDI controller device, can be used as modulation sources to control parameters in real-time.
-
Custom Controllers: Custom controllers, such as expression pedals or touch controllers, can also be used as modulation sources to control specific parameters in a unique way.
-
Random Generators: Random generators produce random values that can be used to add unpredictability and variation to a sound.
-
Audio Signals: Audio signals, such as noise or other sound sources, can be used as modulation sources to create complex and dynamic sounds.
Overall, the types of modulation sources that can be used in a synthesizer are limited only by the imagination of the designer and the capabilities of the synthesizer.
19> let's get imaginative -- what are some others?
Sure, here are some more imaginative examples of modulation sources that can be used in a synthesizer:
-
Weather Sensors: Sensors that measure weather data, such as temperature, wind speed, and humidity, can be used as modulation sources to control various parameters in a synthesizer. For example, wind speed could be used to modulate a filter cutoff frequency, while temperature could be used to modulate an oscillator's frequency.
-
Motion Sensors: Motion sensors, such as accelerometers or gyroscopes, can be used as modulation sources to control parameters based on physical movement. For example, a synthesizer could use a motion sensor to modulate a filter cutoff frequency based on the movement of the performer's hands.
-
Biofeedback Sensors: Biofeedback sensors, such as heart rate monitors or brainwave sensors, can be used as modulation sources to create sounds that respond to the performer's physiological state. For example, a synthesizer could use a heart rate monitor to modulate a filter cutoff frequency based on the performer's heart rate.
-
Artificial Intelligence: Artificial intelligence algorithms, such as neural networks or genetic algorithms, can be used as modulation sources to create sounds that evolve and change over time. For example, a synthesizer could use a genetic algorithm to generate new sounds based on the parameters of an existing sound.
-
Game Controllers: Game controllers, such as joysticks or gamepads, can be used as modulation sources to create sounds that respond to the movement and actions of the performer. For example, a synthesizer could use a gamepad to modulate a filter cutoff frequency based on the position of the joystick.
Overall, the possibilities for modulation sources in a synthesizer are limited only by the creativity and ingenuity of the designer.
20> can you do 5 more?
Sure, here are some more ideas:
-
Brain-Computer Interfaces: Brain-computer interfaces (BCIs) can be used as modulation sources to control parameters based on the performer's brainwaves. For example, a synthesizer could use a BCI to modulate a filter cutoff frequency based on the performer's level of concentration or relaxation.
-
Geolocation: Geolocation data, such as GPS coordinates or Wi-Fi signal strength, can be used as modulation sources to control parameters based on the performer's physical location. For example, a synthesizer could use GPS coordinates to modulate a filter cutoff frequency based on the performer's distance from a particular location.
-
Machine Learning: Machine learning algorithms can be used as modulation sources to create sounds that respond to patterns or trends in data. For example, a synthesizer could use a machine learning algorithm to modulate a filter cutoff frequency based on the patterns in a stock market index.
-
Speech Recognition: Speech recognition software can be used as a modulation source to control parameters based on the performer's spoken words. For example, a synthesizer could use speech recognition to modulate a filter cutoff frequency based on the performer's voice pitch or volume.
-
Physically-Modeled Systems: Physically-modeled systems, such as models of physical objects or systems, can be used as modulation sources to create sounds that respond to the physical properties of the modeled system. For example, a synthesizer could use a physically-modeled model of a guitar string to modulate a filter cutoff frequency based on the tension of the string.
21> thanks -- what can you tell me about routing in the context of modulation
Routing in the context of modulation refers to the process of directing a modulation source to a target parameter in order to modulate that parameter. Modulation routing is an essential part of synthesizer design, as it allows modulation sources to be applied to a wide range of parameters within the synthesizer, creating complex and dynamic sounds.
There are many ways to route modulation in a synthesizer, depending on the specific design and architecture of the synthesizer. Here are a few common methods:
-
Hardwired Routing: Hardwired routing is a method of modulation routing where a modulation source is connected directly to a target parameter using physical wiring. This method is common in analog synthesizers, where modulation sources such as LFOs and envelopes are often hardwired to specific parameters.
-
Patchable Routing: Patchable routing is a method of modulation routing where a user can manually connect modulation sources to target parameters using patch cables. This method is common in modular synthesizers, where the user can create complex routing configurations by patching cables between different modules.
-
Menu-Driven Routing: Menu-driven routing is a method of modulation routing where a user selects a modulation source and a target parameter from a menu or interface. This method is common in digital synthesizers and software synthesizers, where the user can select from a wide range of modulation sources and target parameters.
-
Matrix Routing: Matrix routing is a method of modulation routing where a user can select a modulation source and a target parameter from a matrix or grid interface. This method is common in digital and software synthesizers, where the user can create complex modulation routing configurations by selecting from a large number of modulation sources and target parameters.
-
Automated Routing: Automated routing is a method of modulation routing where the synthesizer automatically routes modulation sources to target parameters based on pre-defined rules or algorithms. This method is common in some software synthesizers, where the user can specify modulation routing using algorithms such as genetic algorithms or neural networks.
Overall, modulation routing is an essential part of synthesizer design, allowing modulation sources to be applied to a wide range of parameters within the synthesizer to create complex and dynamic sounds. The specific method of modulation routing used in a synthesizer depends on the specific design and architecture of the synthesizer, as well as the needs and preferences of the user.
22> could you show an example of how to integrate a modulation routing system into a lightweight synthesizer architecture?
Sure, here's an example of how to integrate a modulation routing system into a lightweight synthesizer architecture:
Let's assume we have a lightweight synthesizer architecture that includes a single oscillator, a filter, and an amplifier. We want to add modulation to this architecture by routing an LFO to the filter cutoff frequency and the amplifier level. Here's how we can do it:
- Create an LFO Module: We start by creating
an LFO module that produces a continuous
waveform at a low frequency. We can define this
module as a struct that implements
a
ModulationSource
trait, which allows us to enable or disable the LFO and produce a modulation value.
pub struct LFO {
enabled: bool,
frequency: f32,
phase: f32,
amplitude: f32,
}
impl ModulationSource for LFO {
fn is_enabled(&self) -> bool {
self.enabled
}
fn set_enabled(&mut self, enabled: bool) {
self.enabled = enabled;
}
fn get_modulation_value(&mut self) -> f32 {
if !self.enabled {
return 0.0;
}
let value = self.amplitude * (self.phase * 2.0 * std::f32::consts::PI).sin();
self.phase += self.frequency / SAMPLE_RATE as f32;
if self.phase > 1.0 {
self.phase -= 1.0;
}
value
}
}
- Create a Modulation Routing Module: Next, we create a modulation routing module that takes a modulation source and a target parameter and applies the modulation source to the target parameter. We can define this module as a struct that includes a reference to the modulation source and a reference to the target parameter.
pub struct ModulationRouting {
source: Box<dyn ModulationSource>,
target: TargetParameter,
}
impl ModulationRouting {
fn new(source: Box<dyn ModulationSource>, target: TargetParameter) -> Self {
Self { source, target }
}
fn process_block(&mut self, block: &mut [f32]) {
let value = self.source.get_modulation_value();
for sample in block.iter_mut() {
*sample = self.target.process_sample(*sample, value);
}
}
}
- Create Target Parameter Modules: Finally,
we create modules for the target parameters
that we want to modulate, in this case the
filter cutoff frequency and the amplifier
level. These modules should implement
a
TargetParameter
trait that includes aprocess_sample()
method that takes a sample and a modulation value and returns a processed sample.
pub trait TargetParameter {
fn process_sample(&mut self, sample: f32, modulation_value: f32) -> f32;
}
pub struct Filter {
cutoff_frequency: f32,
}
impl TargetParameter for Filter {
fn process_sample(&mut self, sample: f32, modulation_value: f32) -> f32 {
let frequency = self.cutoff_frequency + modulation_value;
// Apply filter processing to the sample using the frequency value
// ...
processed_sample
}
}
pub struct Amplifier {
level: f32,
}
impl TargetParameter for Amplifier {
fn process_sample(&mut self, sample: f32, modulation_value: f32) -> f32 {
let level = self.level + modulation_value;
// Apply amplifier processing to the sample using the level value
// ...
processed_sample
}
}
- Create Synthesizer Module: Finally, we create a synthesizer module that connects the LFO module to the modulation
23> thanks -- please continue from #4
- Create Synthesizer Module: Finally, we
create a synthesizer module that connects the
LFO module to the modulation routing modules,
which in turn are connected to the target
parameter modules. This module should include
a method to set up the modulation routing, and
a
process_block()
method that processes a block of audio samples by passing the block through the oscillator, filter, and amplifier modules, and then through the modulation routing modules.
pub struct Synthesizer {
oscillator: Oscillator,
filter: Filter,
amplifier: Amplifier,
lfo: LFO,
filter_modulation: ModulationRouting,
amplifier_modulation: ModulationRouting,
}
impl Synthesizer {
fn new() -> Self {
let lfo = LFO {
enabled: true,
frequency: 2.0,
phase: 0.0,
amplitude: 50.0,
};
let filter = Filter { cutoff_frequency: 1000.0 };
let amplifier = Amplifier { level: 0.5 };
let filter_modulation = ModulationRouting::new(
Box::new(lfo.clone()),
Box::new(filter),
);
let amplifier_modulation = ModulationRouting::new(
Box::new(lfo),
Box::new(amplifier),
);
Self {
oscillator: Oscillator::new(),
filter,
amplifier,
lfo,
filter_modulation,
amplifier_modulation,
}
}
fn set_modulation_routing(&mut self) {
self.filter_modulation.source.set_enabled(true);
self.filter_modulation.target.set_bipolar(true);
self.amplifier_modulation.source.set_enabled(true);
self.amplifier_modulation.target.set_bipolar(true);
}
fn process_block(&mut self, block: &mut [f32]) {
self.oscillator.process_block(block);
self.filter.process_block(block);
self.amplifier.process_block(block);
self.filter_modulation.process_block(block);
self.amplifier_modulation.process_block(block);
}
}
With this setup, we have created a lightweight synthesizer architecture that includes modulation routing. We can use this architecture to create complex and dynamic sounds by routing modulation sources to a wide range of target parameters within the synthesizer.
Dependencies
~12–21MB
~302K SLoC