Vital
Loading...
Searching...
No Matches
reorderable_effect_chain.cpp
Go to the documentation of this file.
2
3#include "chorus_module.h"
4#include "compressor_module.h"
5#include "delay_module.h"
6#include "distortion_module.h"
7#include "equalizer_module.h"
8#include "flanger_module.h"
9#include "filter_module.h"
10#include "phaser_module.h"
11#include "reverb_module.h"
12#include "synth_strings.h"
13
14namespace vital {
15
21 class FilterFxModule : public SynthModule {
22 public:
27 enum {
31 };
32
39 filter_ = new FilterModule("filter_fx");
40 filter_->setCreateOnValue(false);
41 filter_->setMono(true);
42 addSubmodule(filter_);
43 addProcessor(filter_);
44 filter_->useOutput(output());
45 filter_->plug(&input_, FilterModule::kAudio);
46 filter_->plug(keytrack, FilterModule::kKeytrack);
47 }
48
55 void processWithInput(const poly_float* audio_in, int num_samples) override {
56 utils::copyBuffer(input_.buffer, audio_in, num_samples);
57 filter_->process(num_samples);
58 }
59
65 void setOversampleAmount(int oversampling) override {
66 input_.ensureBufferSize(kMaxBufferSize * oversampling);
68 }
69
70 private:
71 FilterModule* filter_;
72 Output input_;
73 };
74
81 ReorderableEffectChain::ReorderableEffectChain(const Output* beats_per_second, const Output* keytrack) :
82 vital::SynthModule(kNumInputs, 1),
83 equalizer_memory_(nullptr),
84 beats_per_second_(beats_per_second),
85 keytrack_(keytrack),
86 last_order_(0.0f) {
87 for (int i = 0; i < constants::kNumEffects; ++i) {
88 SynthModule* effect_module = createEffectModule(i);
89 VITAL_ASSERT(effect_module);
90
91 addSubmodule(effect_module);
92 addProcessor(effect_module);
94 effects_[i] = effect_module;
95 effect_order_[i] = i;
96 }
97
98 // Encode the initial order into a float for easy comparison and storage.
100 }
101
109 switch(index) {
113 return new CompressorModule();
115 return new DelayModule(beats_per_second_);
117 return new DistortionModule();
118 case constants::kEq: {
121 return eq;
122 }
126 return new FilterFxModule(keytrack_);
130 return new ReverbModule();
131 default:
132 return nullptr;
133 }
134 }
135
143 void ReorderableEffectChain::process(int num_samples) {
144 const poly_float* audio_in = input(kAudio)->source->buffer;
145 processWithInput(audio_in, num_samples);
146 }
147
157 void ReorderableEffectChain::processWithInput(const poly_float* audio_in, int num_samples) {
158 mono_float float_order = std::round(input(kOrder)->at(0)[0]);
159 if (float_order != last_order_)
161 last_order_ = float_order;
162
163 for (int i = 0; i < constants::kNumEffects; ++i) {
164 VITAL_ASSERT(utils::isFinite(audio_in, num_samples));
165
166 int index = effect_order_[i];
167 bool on = effects_on_[index]->value();
168 bool enabled = effects_[index]->enabled();
169 if (on != enabled)
170 effects_[index]->enable(on);
171
172 if (on) {
173 effects_[index]->processWithInput(audio_in, num_samples);
174 audio_in = effects_[index]->output(0)->buffer;
175 }
176 }
177
178 VITAL_ASSERT(utils::isFinite(audio_in, num_samples));
179 utils::copyBuffer(output()->buffer, audio_in, num_samples);
180 }
181
186 for (int i = 0; i < constants::kNumEffects; ++i)
187 effects_[i]->hardReset();
188 }
189
196 for (int i = 0; i < constants::kNumEffects; ++i)
197 effects_[i]->correctToTime(seconds);
198 }
199} // namespace vital
A chorus effect module that modulates delayed signals to create thickening and widening of the sound.
Definition chorus_module.h:18
A multiband compressor module that splits the input signal into multiple bands, applies compression t...
Definition compressor_module.h:18
A stereo delay effect module providing adjustable delay times, feedback, filtering,...
Definition delay_module.h:16
A module that applies distortion and optional filtering to an audio signal.
Definition distortion_module.h:18
A multiband equalizer module that provides low, mid, and high frequency shaping.
Definition equalizer_module.h:16
const StereoMemory * getAudioMemory()
Retrieves the internal stereo memory used for storing audio samples.
Definition equalizer_module.h:75
A wrapper module that hosts a filter effect. This is a specialized module for filter effects in the c...
Definition reorderable_effect_chain.cpp:21
@ kNumInputs
Definition reorderable_effect_chain.cpp:30
@ kAudio
Definition reorderable_effect_chain.cpp:28
@ kKeytrack
Definition reorderable_effect_chain.cpp:29
FilterFxModule(const Output *keytrack)
Constructs the FilterFxModule.
Definition reorderable_effect_chain.cpp:38
void processWithInput(const poly_float *audio_in, int num_samples) override
Processes a block of samples from a given input buffer through the filter effect.
Definition reorderable_effect_chain.cpp:55
void setOversampleAmount(int oversampling) override
Sets the oversampling amount for this module.
Definition reorderable_effect_chain.cpp:65
A versatile filter module supporting multiple filter models and mixing options.
Definition filter_module.h:25
@ kKeytrack
Definition filter_module.h:38
@ kAudio
Definition filter_module.h:36
void setMono(bool mono)
Configures the FilterModule to be mono or polyphonic.
Definition filter_module.cpp:260
void process(int num_samples) override
Processes a block of samples, applying the selected filter model and mixing the result.
Definition filter_module.cpp:231
void setCreateOnValue(bool create_on_value)
Sets whether a "on/off" value control should be created.
Definition filter_module.h:66
A flanger effect module using a modulated delay line to produce comb-filter-like sweeps.
Definition flanger_module.h:15
A module that provides a phaser effect for audio signals.
Definition phaser_module.h:18
virtual void setOversampleAmount(int oversample)
Sets the oversampling amount and updates the effective sample rate.
Definition processor.h:293
void useOutput(Output *output)
Uses an existing Output object as this Processor's first output.
Definition processor.cpp:138
force_inline Input * input(unsigned int index=0) const
Retrieves the Input pointer at a given index.
Definition processor.h:587
force_inline bool enabled() const
Checks if this Processor is enabled.
Definition processor.h:310
void plug(const Output *source)
Connects an external Output to this Processor's first input.
Definition processor.cpp:79
force_inline Output * output(unsigned int index=0) const
Retrieves the Output pointer at a given index.
Definition processor.h:616
virtual void processWithInput(const poly_float *audio_in, int num_samples)
An optional processing function taking explicit input buffer. Fallback is an assertion failure (not s...
Definition processor.h:252
virtual void addProcessor(Processor *processor)
Adds a Processor to be managed by this router.
Definition processor_router.cpp:121
SynthModule * createEffectModule(int index)
Creates an effect module based on a given index.
Definition reorderable_effect_chain.cpp:108
virtual void hardReset() override
Performs a hard reset on all effects in the chain.
Definition reorderable_effect_chain.cpp:185
Value * effects_on_[constants::kNumEffects]
Definition reorderable_effect_chain.h:107
virtual void process(int num_samples) override
Processes a block of audio samples using the configured effect chain order.
Definition reorderable_effect_chain.cpp:143
virtual void correctToTime(double seconds) override
Corrects the timing of all effects to a given playback time.
Definition reorderable_effect_chain.cpp:195
float last_order_
Definition reorderable_effect_chain.h:109
ReorderableEffectChain(const Output *beats_per_second, const Output *keytrack)
Constructs a ReorderableEffectChain.
Definition reorderable_effect_chain.cpp:81
const Output * keytrack_
Definition reorderable_effect_chain.h:105
@ kOrder
Definition reorderable_effect_chain.h:25
@ kAudio
Definition reorderable_effect_chain.h:24
int effect_order_[constants::kNumEffects]
Definition reorderable_effect_chain.h:108
const StereoMemory * equalizer_memory_
Definition reorderable_effect_chain.h:103
SynthModule * effects_[constants::kNumEffects]
Definition reorderable_effect_chain.h:106
const Output * beats_per_second_
Definition reorderable_effect_chain.h:104
virtual void processWithInput(const poly_float *audio_in, int num_samples) override
Processes a block of samples from a given input buffer.
Definition reorderable_effect_chain.cpp:157
A module that applies a reverb effect to an audio signal.
Definition reverb_module.h:17
A ProcessorRouter that encapsulates a cohesive unit of functionality in the synthesizer.
Definition synth_module.h:129
Value * createBaseControl(std::string name, bool audio_rate=false, bool smooth_value=false)
Creates a simple control processor for a given parameter name.
Definition synth_module.cpp:22
void addSubmodule(SynthModule *module)
Adds a submodule to this SynthModule.
Definition synth_module.h:289
virtual void enable(bool enable) override
Enables or disables this SynthModule and its owned processors.
Definition synth_module.cpp:516
force_inline mono_float value() const
Returns the current mono_float value of the first lane.
Definition value.h:60
#define VITAL_ASSERT(x)
Definition common.h:11
const std::string kEffectOrder[]
Defines the processing order of various effects.
Definition synth_strings.h:225
@ kCompressor
Definition synth_constants.h:179
@ kEq
Definition synth_constants.h:182
@ kDistortion
Definition synth_constants.h:181
@ kReverb
Definition synth_constants.h:186
@ kNumEffects
Definition synth_constants.h:187
@ kPhaser
Definition synth_constants.h:185
@ kFlanger
Definition synth_constants.h:184
@ kDelay
Definition synth_constants.h:180
@ kFilterFx
Definition synth_constants.h:183
@ kChorus
Definition synth_constants.h:178
force_inline bool isFinite(poly_float value)
Checks if all lanes in a poly_float are finite.
Definition poly_utils.h:610
void decodeFloatToOrder(int *order, mono_float float_code, int size)
Decodes a float-encoded permutation back into order.
Definition utils.cpp:55
mono_float encodeOrderToFloat(int *order, int size)
Encodes a permutation (stored in order) into a single float.
Definition utils.cpp:32
force_inline void copyBuffer(mono_float *dest, const mono_float *source, int size)
Copies data from a source mono buffer to a destination mono buffer.
Definition poly_utils.h:586
Contains classes and functions used within the Vital synthesizer framework.
constexpr int kMaxBufferSize
Maximum buffer size for processing.
Definition common.h:39
float mono_float
Definition common.h:33
const Output * source
The output from which this input reads samples.
Definition processor.h:134
Holds and manages a buffer of samples (poly_float) for a Processor's output.
Definition processor.h:35
poly_float * buffer
Pointer to the output buffer.
Definition processor.h:110
void ensureBufferSize(int new_max_buffer_size)
Ensures the buffer is large enough to hold new_max_buffer_size samples. This will reallocate if neces...
Definition processor.h:98
Represents a vector of floating-point values using SIMD instructions.
Definition poly_values.h:600