Commitok összehasonlítása
3 Commit-ok
| Szerző | SHA1 | Dátum | |
|---|---|---|---|
|
35cf01a163 | ||
|
|
aa546c7357 | ||
|
|
9c5b5a3957 |
@@ -1,5 +1,5 @@
|
||||
cmake_minimum_required(VERSION 3.22)
|
||||
project(InstaLPEQ VERSION 1.1.3)
|
||||
project(InstaLPEQ VERSION 1.3.2)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
@@ -35,6 +35,7 @@ target_sources(InstaLPEQ
|
||||
Source/EQCurveDisplay.cpp
|
||||
Source/FIREngine.cpp
|
||||
Source/NodeParameterPanel.cpp
|
||||
Source/SignalChainPanel.cpp
|
||||
)
|
||||
|
||||
target_compile_definitions(InstaLPEQ
|
||||
|
||||
144
README.md
144
README.md
@@ -4,26 +4,42 @@ Free, open-source linear phase EQ plugin built with JUCE. Available as VST3, AU
|
||||
|
||||
      
|
||||
|
||||
## Why Linear Phase EQ?
|
||||
|
||||
Traditional (minimum phase) EQs alter the **phase** of the signal at the frequencies they boost or cut. This causes:
|
||||
- **Phase smearing** — transients lose their shape, especially on drums and percussive material
|
||||
- **Asymmetric waveforms** — the signal before and after the EQ change point don't align in time
|
||||
- **Coloration** — even subtle EQ moves can change the character of the sound beyond the intended frequency adjustment
|
||||
|
||||
A **linear phase EQ** applies the exact same time delay to all frequencies. This means:
|
||||
- **Zero phase distortion** — the waveform shape is perfectly preserved
|
||||
- **Pristine transients** — drums, plucks, and attacks stay tight and punchy
|
||||
- **Transparent tonal shaping** — only the frequency balance changes, nothing else
|
||||
- **Perfect for mastering** — no cumulative phase artifacts when stacking multiple EQ moves
|
||||
- **Ideal for parallel processing** — EQ'd and dry signals stay perfectly time-aligned when summed
|
||||
|
||||
The trade-off is a small amount of latency (automatically compensated by the DAW), which makes linear phase EQ unsuitable for live monitoring but perfect for mixing and mastering.
|
||||
|
||||
## Download
|
||||
|
||||
**[Latest Release: v1.1](https://github.com/hariel1985/InstaLPEQ/releases/tag/v1.1)**
|
||||
**[Latest Release: v1.3](https://github.com/hariel1985/InstaLPEQ/releases/tag/v1.3)**
|
||||
|
||||
### Windows
|
||||
| File | Description |
|
||||
|------|-------------|
|
||||
| [InstaLPEQ-VST3-Win64.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.1/InstaLPEQ-VST3-Win64.zip) | VST3 plugin — copy to `C:\Program Files\Common Files\VST3\` |
|
||||
| [InstaLPEQ-VST3-Win64.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.3/InstaLPEQ-VST3-Win64.zip) | VST3 plugin — copy to `C:\Program Files\Common Files\VST3\` |
|
||||
|
||||
### macOS (Universal Binary: Apple Silicon + Intel)
|
||||
| File | Description |
|
||||
|------|-------------|
|
||||
| [InstaLPEQ-VST3-macOS.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.1/InstaLPEQ-VST3-macOS.zip) | VST3 plugin — copy to `~/Library/Audio/Plug-Ins/VST3/` |
|
||||
| [InstaLPEQ-AU-macOS.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.1/InstaLPEQ-AU-macOS.zip) | Audio Unit — copy to `~/Library/Audio/Plug-Ins/Components/` |
|
||||
| [InstaLPEQ-VST3-macOS.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.3/InstaLPEQ-VST3-macOS.zip) | VST3 plugin — copy to `~/Library/Audio/Plug-Ins/VST3/` |
|
||||
| [InstaLPEQ-AU-macOS.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.3/InstaLPEQ-AU-macOS.zip) | Audio Unit — copy to `~/Library/Audio/Plug-Ins/Components/` |
|
||||
|
||||
### Linux (x64, built on Ubuntu 22.04)
|
||||
| File | Description |
|
||||
|------|-------------|
|
||||
| [InstaLPEQ-VST3-Linux-x64.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.1/InstaLPEQ-VST3-Linux-x64.zip) | VST3 plugin — copy to `~/.vst3/` |
|
||||
| [InstaLPEQ-LV2-Linux-x64.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.1/InstaLPEQ-LV2-Linux-x64.zip) | LV2 plugin — copy to `~/.lv2/` |
|
||||
| [InstaLPEQ-VST3-Linux-x64.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.3/InstaLPEQ-VST3-Linux-x64.zip) | VST3 plugin — copy to `~/.vst3/` |
|
||||
| [InstaLPEQ-LV2-Linux-x64.zip](https://github.com/hariel1985/InstaLPEQ/releases/download/v1.3/InstaLPEQ-LV2-Linux-x64.zip) | LV2 plugin — copy to `~/.lv2/` |
|
||||
|
||||
> **macOS note:** Builds are Universal Binary (Apple Silicon + Intel). Not code-signed — after copying the plugin, remove the quarantine flag in Terminal:
|
||||
> ```bash
|
||||
@@ -33,43 +49,97 @@ Free, open-source linear phase EQ plugin built with JUCE. Available as VST3, AU
|
||||
|
||||
## Features
|
||||
|
||||
### Linear Phase EQ
|
||||
### Linear Phase EQ Engine
|
||||
- True linear phase processing using symmetric FIR convolution
|
||||
- Zero phase distortion at any gain setting
|
||||
- 8192-tap FIR filter (configurable: 4096 / 8192 / 16384)
|
||||
- DAW-compensated latency (~93ms at 44.1kHz default)
|
||||
- Background thread FIR generation — glitch-free parameter changes
|
||||
- Zero phase distortion — the waveform shape is perfectly preserved at any gain setting
|
||||
- Mathematically transparent: only magnitude changes, phase stays untouched
|
||||
- FIR impulse response normalized for unity passthrough (0 dB at flat settings)
|
||||
- Background thread FIR generation — glitch-free, click-free parameter changes
|
||||
- DAW-compensated latency for seamless integration
|
||||
|
||||
### Configurable FIR Resolution
|
||||
Six quality levels to balance precision vs. latency:
|
||||
|
||||
| Taps | Latency (44.1 kHz) | Best for |
|
||||
|------|---------------------|----------|
|
||||
| 512 | ~6 ms | Low-latency monitoring |
|
||||
| 1024 | ~12 ms | Tracking |
|
||||
| **2048** | **~23 ms** | **Default — mixing** |
|
||||
| 4096 | ~46 ms | Detailed work |
|
||||
| 8192 | ~93 ms | Mastering |
|
||||
| 16384 | ~186 ms | Maximum precision |
|
||||
|
||||
Low tap counts have reduced accuracy below ~100 Hz — a warning is displayed when using 512 or 1024 taps.
|
||||
|
||||
### Interactive EQ Curve Display
|
||||
- Logarithmic frequency axis (20 Hz — 20 kHz)
|
||||
- Linear gain axis (-24 dB to +24 dB)
|
||||
- Click to add EQ nodes (up to 8 bands)
|
||||
- Drag nodes to adjust frequency and gain
|
||||
- Scroll wheel to adjust Q/bandwidth
|
||||
- Right-click for band type selection and delete
|
||||
- Double-click to reset band to 0 dB
|
||||
- Real-time frequency response curve with glow effect
|
||||
- Per-band curve overlay
|
||||
- Click anywhere to add an EQ node (up to 8 bands)
|
||||
- Drag nodes to adjust frequency and gain in real time
|
||||
- Scroll wheel over a node to adjust Q/bandwidth
|
||||
- Right-click a node for band type selection or delete
|
||||
- Double-click a node to reset it to 0 dB
|
||||
- Combined frequency response curve with glow effect
|
||||
- Individual per-band curve overlays (color-coded)
|
||||
- Real-time FFT spectrum analyzer behind the EQ curves (shows live audio content)
|
||||
|
||||
### Band Types
|
||||
- Peak (parametric)
|
||||
- Low Shelf
|
||||
- High Shelf
|
||||
- **Peak** (parametric) — boost or cut a specific frequency range
|
||||
- **Low Shelf** — boost or cut everything below a frequency
|
||||
- **High Shelf** — boost or cut everything above a frequency
|
||||
|
||||
### Auto Makeup Gain
|
||||
- Automatically compensates for the loudness change caused by EQ settings
|
||||
- Computed from the actual FIR frequency response (not theoretical) — accounts for FIR resolution limits
|
||||
- RMS-based calculation with linear frequency weighting (matches white noise / broadband signals)
|
||||
- Toggleable on/off — displays the current compensation value in dB
|
||||
- Mastering-safe: fixed value based on EQ curve, no signal-dependent gain changes
|
||||
|
||||
### Output Limiter
|
||||
- Brickwall limiter with 0 dB ceiling
|
||||
- Toggleable on/off
|
||||
- Prevents clipping when applying large EQ boosts
|
||||
- 50 ms release time
|
||||
|
||||
### Drag-and-Drop Signal Chain
|
||||
- Reorderable processing chain at the bottom of the GUI
|
||||
- Three blocks: **Master Gain**, **Limiter**, **Auto Gain**
|
||||
- Drag blocks to change processing order (e.g., put limiter before or after gain)
|
||||
- Visual arrows show signal flow direction
|
||||
- Chain order saved/restored with DAW session
|
||||
|
||||
### Controls
|
||||
- Per-band: Frequency, Gain, Q knobs
|
||||
- Master gain (+/- 24 dB)
|
||||
- Bypass toggle
|
||||
- State save/restore (DAW session recall)
|
||||
- **Per-band:** Frequency, Gain, Q knobs with 3D metal styling
|
||||
- **Master Gain:** +/- 24 dB output level control
|
||||
- **Bypass:** global bypass toggle
|
||||
- **New Band:** button to add a new EQ node at 1 kHz / 0 dB
|
||||
- **FIR Quality:** dropdown to select tap count / latency
|
||||
- All knobs reset to default on double-click
|
||||
|
||||
### GUI
|
||||
- Dark modern UI matching InstaDrums visual style
|
||||
- 3D metal knobs with glow effects (orange for EQ, blue for Q)
|
||||
- Dark modern UI with InstaDrums visual style
|
||||
- 3D metal knobs with multi-layer glow effects (orange for frequency/gain, blue for Q)
|
||||
- Carbon fiber background texture
|
||||
- Rajdhani custom font
|
||||
- Fully resizable window with proportional scaling
|
||||
- Animated toggle switches
|
||||
- Rajdhani custom font (embedded)
|
||||
- Fully resizable window (700x450 — 1920x1080) with proportional scaling
|
||||
- Animated toggle switches with smooth lerp
|
||||
- Color-coded EQ bands (8 distinct colors)
|
||||
- All fonts and UI elements scale with window size
|
||||
- State save/restore — all settings recalled with DAW session
|
||||
|
||||
## How It Works
|
||||
|
||||
InstaLPEQ uses a **FIR-based linear phase** approach:
|
||||
|
||||
1. Each EQ band's target magnitude response is computed from IIR filter coefficients (Peak, Low Shelf, or High Shelf)
|
||||
2. All band magnitudes are multiplied together to form the combined target frequency response
|
||||
3. An inverse FFT converts the magnitude-only spectrum (zero phase) into a symmetric time-domain impulse response
|
||||
4. A Blackman-Harris window is applied to minimize truncation artifacts
|
||||
5. The FIR is normalized so a flat spectrum produces exactly 0 dB passthrough
|
||||
6. The FIR filter is applied via JUCE's efficient FFT-based partitioned `Convolution` engine
|
||||
7. Auto makeup gain is computed from the actual FIR frequency response (forward FFT of the final filter)
|
||||
|
||||
This ensures **mathematically perfect phase linearity** — the only thing that changes is the frequency balance. The original waveform shape, transient character, and stereo image are completely preserved.
|
||||
|
||||
## Building
|
||||
|
||||
@@ -105,22 +175,10 @@ Output:
|
||||
- AU: `build/InstaLPEQ_artefacts/Release/AU/InstaLPEQ.component` (macOS)
|
||||
- LV2: `build/InstaLPEQ_artefacts/Release/LV2/InstaLPEQ.lv2`
|
||||
|
||||
## How It Works
|
||||
|
||||
InstaLPEQ uses a **FIR-based linear phase** approach:
|
||||
|
||||
1. Each EQ band's target magnitude response is computed from IIR filter coefficients (Peak, Low Shelf, or High Shelf)
|
||||
2. All band magnitudes are multiplied together to form the combined target response
|
||||
3. An inverse FFT converts the magnitude-only spectrum into a symmetric time-domain impulse response
|
||||
4. A Blackman-Harris window is applied to minimize truncation artifacts
|
||||
5. The FIR filter is applied via JUCE's efficient FFT-based `Convolution` engine
|
||||
|
||||
This ensures **zero phase distortion** regardless of EQ settings — ideal for mastering, surgical corrections, and transparent tonal shaping.
|
||||
|
||||
## Tech Stack
|
||||
|
||||
- **Language:** C++17
|
||||
- **Framework:** JUCE 8
|
||||
- **Build:** CMake + MSVC / Xcode / GCC
|
||||
- **Audio DSP:** juce::dsp (FFT, Convolution, IIR coefficient design)
|
||||
- **Audio DSP:** juce::dsp (FFT, Convolution, IIR coefficient design, Limiter)
|
||||
- **Font:** Rajdhani (SIL Open Font License)
|
||||
|
||||
@@ -17,6 +17,13 @@ void EQCurveDisplay::setMagnitudeResponse (const std::vector<float>& magnitudesD
|
||||
repaint();
|
||||
}
|
||||
|
||||
void EQCurveDisplay::setSpectrum (const float* data, int numBins, double sampleRate, int fftSize)
|
||||
{
|
||||
spectrumDb.assign (data, data + numBins);
|
||||
spectrumSampleRate = sampleRate;
|
||||
spectrumFftSize = fftSize;
|
||||
}
|
||||
|
||||
void EQCurveDisplay::setSelectedBand (int index)
|
||||
{
|
||||
if (selectedBand != index)
|
||||
@@ -93,6 +100,7 @@ void EQCurveDisplay::paint (juce::Graphics& g)
|
||||
g.drawRoundedRectangle (bounds, 4.0f, 1.0f);
|
||||
|
||||
drawGrid (g);
|
||||
drawSpectrum (g);
|
||||
drawPerBandCurves (g);
|
||||
drawResponseCurve (g);
|
||||
drawNodes (g);
|
||||
@@ -140,6 +148,55 @@ void EQCurveDisplay::drawGrid (juce::Graphics& g)
|
||||
}
|
||||
}
|
||||
|
||||
void EQCurveDisplay::drawSpectrum (juce::Graphics& g)
|
||||
{
|
||||
if (spectrumDb.empty())
|
||||
return;
|
||||
|
||||
auto area = getPlotArea();
|
||||
int numBins = (int) spectrumDb.size();
|
||||
|
||||
juce::Path specPath;
|
||||
specPath.startNewSubPath (area.getX(), area.getBottom());
|
||||
bool hasPoints = false;
|
||||
|
||||
for (float px = area.getX(); px <= area.getRight(); px += 1.5f)
|
||||
{
|
||||
float freq = xToFreq (px);
|
||||
if (freq < 1.0f || freq > spectrumSampleRate * 0.5)
|
||||
continue;
|
||||
|
||||
float binFloat = freq * (float) spectrumFftSize / (float) spectrumSampleRate;
|
||||
int bin = (int) binFloat;
|
||||
float frac = binFloat - (float) bin;
|
||||
|
||||
if (bin < 0 || bin >= numBins - 1)
|
||||
continue;
|
||||
|
||||
float dbVal = spectrumDb[bin] * (1.0f - frac) + spectrumDb[bin + 1] * frac;
|
||||
// Map dB range: -100 dB = bottom, 0 dB = top area
|
||||
// Shift up so typical audio is visible
|
||||
float mapped = juce::jmap (dbVal, -80.0f, 0.0f, minDb, maxDb);
|
||||
mapped = juce::jlimit (minDb - 6.0f, maxDb, mapped);
|
||||
float yPos = dbToY (mapped);
|
||||
|
||||
specPath.lineTo (px, yPos);
|
||||
hasPoints = true;
|
||||
}
|
||||
|
||||
if (! hasPoints)
|
||||
return;
|
||||
|
||||
specPath.lineTo (area.getRight(), area.getBottom());
|
||||
specPath.closeSubPath();
|
||||
|
||||
// Fill with subtle gradient
|
||||
juce::ColourGradient specGrad (juce::Colour (0xff4488ff).withAlpha (0.12f), 0, area.getY(),
|
||||
juce::Colour (0xff4488ff).withAlpha (0.03f), 0, area.getBottom(), false);
|
||||
g.setGradientFill (specGrad);
|
||||
g.fillPath (specPath);
|
||||
}
|
||||
|
||||
void EQCurveDisplay::drawResponseCurve (juce::Graphics& g)
|
||||
{
|
||||
if (magnitudeResponseDb.empty())
|
||||
|
||||
@@ -19,6 +19,7 @@ public:
|
||||
void setListener (Listener* l) { listener = l; }
|
||||
void setBands (const std::vector<EQBand>& bands);
|
||||
void setMagnitudeResponse (const std::vector<float>& magnitudesDb, double sampleRate, int fftSize);
|
||||
void setSpectrum (const float* data, int numBins, double sampleRate, int fftSize);
|
||||
int getSelectedBandIndex() const { return selectedBand; }
|
||||
void setSelectedBand (int index);
|
||||
|
||||
@@ -32,6 +33,9 @@ public:
|
||||
private:
|
||||
std::vector<EQBand> bands;
|
||||
std::vector<float> magnitudeResponseDb;
|
||||
std::vector<float> spectrumDb;
|
||||
double spectrumSampleRate = 44100.0;
|
||||
int spectrumFftSize = 2048;
|
||||
double responseSampleRate = 44100.0;
|
||||
int responseFftSize = 8192;
|
||||
int selectedBand = -1;
|
||||
@@ -62,6 +66,7 @@ private:
|
||||
float yToDb (float y) const;
|
||||
|
||||
void drawGrid (juce::Graphics& g);
|
||||
void drawSpectrum (juce::Graphics& g);
|
||||
void drawResponseCurve (juce::Graphics& g);
|
||||
void drawPerBandCurves (juce::Graphics& g);
|
||||
void drawNodes (juce::Graphics& g);
|
||||
|
||||
@@ -124,11 +124,11 @@ juce::AudioBuffer<float> FIREngine::generateFIR (const std::vector<EQBand>& band
|
||||
magnitudes[i] *= bandMag[i];
|
||||
}
|
||||
|
||||
// Store magnitude in dB for display
|
||||
// Store theoretical magnitude in dB for display (from IIR target curve)
|
||||
{
|
||||
std::vector<float> magDb (numBins);
|
||||
for (int i = 0; i < numBins; ++i)
|
||||
magDb[i] = (float) juce::Decibels::gainToDecibels (magnitudes[i], -60.0);
|
||||
magDb[i] = (float) juce::Decibels::gainToDecibels ((float) magnitudes[i], -60.0f);
|
||||
|
||||
const juce::SpinLock::ScopedLockType lock (magLock);
|
||||
magnitudeDb = std::move (magDb);
|
||||
@@ -168,5 +168,94 @@ juce::AudioBuffer<float> FIREngine::generateFIR (const std::vector<EQBand>& band
|
||||
juce::dsp::WindowingFunction<float> window (fftSize, juce::dsp::WindowingFunction<float>::blackmanHarris);
|
||||
window.multiplyWithWindowingTable (firData, fftSize);
|
||||
|
||||
// Normalize: ensure flat spectrum → unity DC gain
|
||||
// Without this, IFFT scaling + windowing cause incorrect base level
|
||||
float dcGain = 0.0f;
|
||||
for (int i = 0; i < fftSize; ++i)
|
||||
dcGain += firData[i];
|
||||
|
||||
if (std::abs (dcGain) > 1e-6f)
|
||||
{
|
||||
float normFactor = 1.0f / dcGain;
|
||||
for (int i = 0; i < fftSize; ++i)
|
||||
firData[i] *= normFactor;
|
||||
}
|
||||
|
||||
// Compute auto makeup from the ACTUAL final FIR frequency response
|
||||
// (includes windowing + normalization effects)
|
||||
{
|
||||
std::vector<float> analysisBuf (fftSize * 2, 0.0f);
|
||||
std::copy (firData, firData + fftSize, analysisBuf.data());
|
||||
|
||||
juce::dsp::FFT analysisFft (order);
|
||||
analysisFft.performRealOnlyForwardTransform (analysisBuf.data());
|
||||
|
||||
// Extract actual magnitude from FFT result
|
||||
// Format: [DC_real, Nyquist_real, bin1_real, bin1_imag, bin2_real, bin2_imag, ...]
|
||||
// Evaluate at log-spaced frequencies (equal weight per octave)
|
||||
// This matches musical content much better than linear spacing
|
||||
// (linear gives 77% weight to 5k-22k where music has little energy)
|
||||
const int numPoints = 512;
|
||||
double powerSum = 0.0;
|
||||
double binRes = sr / (double) fftSize; // Hz per bin
|
||||
|
||||
for (int p = 0; p < numPoints; ++p)
|
||||
{
|
||||
// Log-spaced 20 Hz — 20 kHz
|
||||
double freq = 20.0 * std::pow (1000.0, (double) p / (double) (numPoints - 1));
|
||||
|
||||
// Interpolate magnitude from FFT bins
|
||||
double binFloat = freq / binRes;
|
||||
int bin = (int) binFloat;
|
||||
double frac = binFloat - (double) bin;
|
||||
|
||||
if (bin < 1 || bin >= fftSize / 2 - 1)
|
||||
continue;
|
||||
|
||||
float re0 = analysisBuf[bin * 2];
|
||||
float im0 = analysisBuf[bin * 2 + 1];
|
||||
float re1 = analysisBuf[(bin + 1) * 2];
|
||||
float im1 = analysisBuf[(bin + 1) * 2 + 1];
|
||||
|
||||
double mag0 = std::sqrt ((double) (re0 * re0 + im0 * im0));
|
||||
double mag1 = std::sqrt ((double) (re1 * re1 + im1 * im1));
|
||||
double mag = mag0 * (1.0 - frac) + mag1 * frac;
|
||||
|
||||
powerSum += mag * mag;
|
||||
}
|
||||
|
||||
if (numPoints > 0)
|
||||
{
|
||||
double avgPower = powerSum / (double) numPoints;
|
||||
float rmsGain = (float) std::sqrt (avgPower);
|
||||
float makeupDb = -20.0f * std::log10 (std::max (rmsGain, 1e-10f));
|
||||
autoMakeupDb.store (makeupDb);
|
||||
}
|
||||
|
||||
// (magnitudeDb stays as theoretical IIR curve for display)
|
||||
}
|
||||
|
||||
return firBuffer;
|
||||
}
|
||||
|
||||
// A-weighting curve (IEC 61672:2003)
|
||||
// Returns linear amplitude weighting factor for given frequency
|
||||
float FIREngine::aWeighting (float f)
|
||||
{
|
||||
if (f < 10.0f) return 0.0f;
|
||||
|
||||
double f2 = (double) f * (double) f;
|
||||
double f4 = f2 * f2;
|
||||
|
||||
double num = 12194.0 * 12194.0 * f4;
|
||||
double den = (f2 + 20.6 * 20.6)
|
||||
* std::sqrt ((f2 + 107.7 * 107.7) * (f2 + 737.9 * 737.9))
|
||||
* (f2 + 12194.0 * 12194.0);
|
||||
|
||||
double ra = num / den;
|
||||
|
||||
// Normalize so A(1000 Hz) = 1.0
|
||||
// A(1000) unnormalized ≈ 0.7943
|
||||
static const double norm = 1.0 / 0.7943282347;
|
||||
return (float) (ra * norm);
|
||||
}
|
||||
|
||||
@@ -27,6 +27,9 @@ public:
|
||||
int getFIRLength() const { return 1 << fftOrder.load(); }
|
||||
int getLatencySamples() const { return getFIRLength() / 2; }
|
||||
|
||||
// Auto makeup gain: A-weighted RMS loudness compensation (dB)
|
||||
float getAutoMakeupGainDb() const { return autoMakeupDb.load(); }
|
||||
|
||||
private:
|
||||
void run() override;
|
||||
juce::AudioBuffer<float> generateFIR (const std::vector<EQBand>& bands, double sr, int order);
|
||||
@@ -43,4 +46,7 @@ private:
|
||||
|
||||
std::vector<float> magnitudeDb;
|
||||
mutable juce::SpinLock magLock;
|
||||
|
||||
std::atomic<float> autoMakeupDb { 0.0f };
|
||||
static float aWeighting (float freq);
|
||||
};
|
||||
|
||||
@@ -92,6 +92,23 @@ InstaLPEQEditor::InstaLPEQEditor (InstaLPEQProcessor& p)
|
||||
limiterLabel.setJustificationType (juce::Justification::centred);
|
||||
addAndMakeVisible (limiterLabel);
|
||||
|
||||
// Auto makeup gain
|
||||
autoMakeupToggle.setToggleState (processor.autoMakeupEnabled.load(), juce::dontSendNotification);
|
||||
addAndMakeVisible (autoMakeupToggle);
|
||||
autoMakeupLabel.setFont (customLookAndFeel.getMediumFont (13.0f));
|
||||
autoMakeupLabel.setColour (juce::Label::textColourId, InstaLPEQLookAndFeel::textSecondary);
|
||||
autoMakeupLabel.setJustificationType (juce::Justification::centred);
|
||||
addAndMakeVisible (autoMakeupLabel);
|
||||
autoMakeupValue.setFont (customLookAndFeel.getRegularFont (12.0f));
|
||||
autoMakeupValue.setColour (juce::Label::textColourId, InstaLPEQLookAndFeel::accent);
|
||||
autoMakeupValue.setJustificationType (juce::Justification::centred);
|
||||
addAndMakeVisible (autoMakeupValue);
|
||||
|
||||
// Signal chain panel
|
||||
chainPanel.setListener (this);
|
||||
chainPanel.setOrder (processor.getChainOrder());
|
||||
addAndMakeVisible (chainPanel);
|
||||
|
||||
// Sizing
|
||||
constrainer.setMinimumSize (700, 450);
|
||||
constrainer.setMaximumSize (1920, 1080);
|
||||
@@ -154,7 +171,11 @@ void InstaLPEQEditor::resized()
|
||||
|
||||
newBandButton.setBounds (header.removeFromRight ((int) (90 * scale)).reduced (2));
|
||||
|
||||
// Bottom master row
|
||||
// Signal chain panel (bottom-most)
|
||||
int chainH = (int) std::max (28.0f, 36.0f * scale);
|
||||
chainPanel.setBounds (bounds.removeFromBottom (chainH).reduced (pad, 2));
|
||||
|
||||
// Master controls row (above chain)
|
||||
int masterH = (int) std::max (50.0f, 65.0f * scale);
|
||||
auto masterArea = bounds.removeFromBottom (masterH).reduced (pad, 2);
|
||||
|
||||
@@ -168,6 +189,13 @@ void InstaLPEQEditor::resized()
|
||||
limiterLabel.setBounds (masterArea.removeFromLeft (55));
|
||||
limiterToggle.setBounds (masterArea.removeFromLeft (40));
|
||||
|
||||
// Auto makeup gain toggle + value display
|
||||
autoMakeupLabel.setFont (customLookAndFeel.getMediumFont (std::max (11.0f, 14.0f * scale)));
|
||||
autoMakeupLabel.setBounds (masterArea.removeFromLeft (70));
|
||||
autoMakeupToggle.setBounds (masterArea.removeFromLeft (40));
|
||||
autoMakeupValue.setFont (customLookAndFeel.getRegularFont (std::max (10.0f, 12.0f * scale)));
|
||||
autoMakeupValue.setBounds (masterArea.removeFromLeft (60));
|
||||
|
||||
// Quality selector on the right side of master row
|
||||
qualityLabel.setFont (customLookAndFeel.getMediumFont (std::max (11.0f, 14.0f * scale)));
|
||||
auto qLabelArea = masterArea.removeFromRight (30);
|
||||
@@ -192,6 +220,20 @@ void InstaLPEQEditor::timerCallback()
|
||||
processor.bypassed.store (bypassToggle.getToggleState());
|
||||
processor.masterGainDb.store ((float) masterGainSlider.getValue());
|
||||
processor.limiterEnabled.store (limiterToggle.getToggleState());
|
||||
processor.autoMakeupEnabled.store (autoMakeupToggle.getToggleState());
|
||||
|
||||
// Update auto makeup display
|
||||
float mkDb = processor.getActiveAutoMakeupDb();
|
||||
juce::String mkStr = (mkDb >= 0 ? "+" : "") + juce::String (mkDb, 1) + " dB";
|
||||
autoMakeupValue.setText (mkStr, juce::dontSendNotification);
|
||||
|
||||
// Update spectrum analyzer
|
||||
{
|
||||
std::array<float, 1024> specData {};
|
||||
if (processor.getSpectrum (specData.data(), (int) specData.size()))
|
||||
curveDisplay.setSpectrum (specData.data(), (int) specData.size(),
|
||||
processor.getCurrentSampleRate(), 2048);
|
||||
}
|
||||
|
||||
// Update display with latest magnitude response
|
||||
auto magDb = processor.getFIREngine().getMagnitudeResponseDb();
|
||||
@@ -267,6 +309,11 @@ void InstaLPEQEditor::nodeDeleteRequested (int bandIndex)
|
||||
syncDisplayFromProcessor();
|
||||
}
|
||||
|
||||
void InstaLPEQEditor::chainOrderChanged (const std::array<InstaLPEQProcessor::ChainStage, InstaLPEQProcessor::numChainStages>& order)
|
||||
{
|
||||
processor.setChainOrder (order);
|
||||
}
|
||||
|
||||
void InstaLPEQEditor::syncDisplayFromProcessor()
|
||||
{
|
||||
auto currentBands = processor.getBands();
|
||||
|
||||
@@ -4,11 +4,13 @@
|
||||
#include "LookAndFeel.h"
|
||||
#include "EQCurveDisplay.h"
|
||||
#include "NodeParameterPanel.h"
|
||||
#include "SignalChainPanel.h"
|
||||
|
||||
class InstaLPEQEditor : public juce::AudioProcessorEditor,
|
||||
private juce::Timer,
|
||||
private EQCurveDisplay::Listener,
|
||||
private NodeParameterPanel::Listener
|
||||
private NodeParameterPanel::Listener,
|
||||
private SignalChainPanel::Listener
|
||||
{
|
||||
public:
|
||||
explicit InstaLPEQEditor (InstaLPEQProcessor& p);
|
||||
@@ -30,6 +32,9 @@ private:
|
||||
void nodeParameterChanged (int bandIndex, const EQBand& band) override;
|
||||
void nodeDeleteRequested (int bandIndex) override;
|
||||
|
||||
// SignalChainPanel::Listener
|
||||
void chainOrderChanged (const std::array<InstaLPEQProcessor::ChainStage, InstaLPEQProcessor::numChainStages>& order) override;
|
||||
|
||||
void syncDisplayFromProcessor();
|
||||
|
||||
InstaLPEQProcessor& processor;
|
||||
@@ -39,7 +44,7 @@ private:
|
||||
NodeParameterPanel nodePanel;
|
||||
|
||||
juce::Label titleLabel { {}, "INSTALPEQ" };
|
||||
juce::Label versionLabel { {}, "v1.1.3" };
|
||||
juce::Label versionLabel { {}, "v1.3.2" };
|
||||
juce::ToggleButton bypassToggle;
|
||||
juce::Label bypassLabel { {}, "BYPASS" };
|
||||
|
||||
@@ -52,6 +57,11 @@ private:
|
||||
juce::Label masterGainLabel { {}, "MASTER" };
|
||||
juce::ToggleButton limiterToggle;
|
||||
juce::Label limiterLabel { {}, "LIMITER" };
|
||||
juce::ToggleButton autoMakeupToggle;
|
||||
juce::Label autoMakeupLabel { {}, "AUTO GAIN" };
|
||||
juce::Label autoMakeupValue { {}, "0.0 dB" };
|
||||
|
||||
SignalChainPanel chainPanel;
|
||||
|
||||
juce::ComponentBoundsConstrainer constrainer;
|
||||
|
||||
|
||||
@@ -61,23 +61,89 @@ void InstaLPEQProcessor::processBlock (juce::AudioBuffer<float>& buffer, juce::M
|
||||
if (bypassed.load() || ! firLoaded)
|
||||
return;
|
||||
|
||||
// Process through convolution
|
||||
// Process through convolution (EQ)
|
||||
juce::dsp::AudioBlock<float> block (buffer);
|
||||
juce::dsp::ProcessContextReplacing<float> context (block);
|
||||
convolution.process (context);
|
||||
|
||||
// Apply master gain
|
||||
// Apply chain in configured order
|
||||
std::array<ChainStage, numChainStages> order;
|
||||
{
|
||||
const juce::SpinLock::ScopedTryLockType lock (chainLock);
|
||||
if (lock.isLocked())
|
||||
order = chainOrder;
|
||||
else
|
||||
order = { MasterGain, Limiter, MakeupGain };
|
||||
}
|
||||
|
||||
for (auto stage : order)
|
||||
{
|
||||
switch (stage)
|
||||
{
|
||||
case MasterGain:
|
||||
{
|
||||
float gain = juce::Decibels::decibelsToGain (masterGainDb.load());
|
||||
if (std::abs (gain - 1.0f) > 0.001f)
|
||||
buffer.applyGain (gain);
|
||||
|
||||
// Brickwall limiter (0 dB ceiling)
|
||||
break;
|
||||
}
|
||||
case Limiter:
|
||||
{
|
||||
if (limiterEnabled.load())
|
||||
{
|
||||
juce::dsp::AudioBlock<float> limBlock (buffer);
|
||||
juce::dsp::ProcessContextReplacing<float> limContext (limBlock);
|
||||
limiter.process (limContext);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MakeupGain:
|
||||
{
|
||||
if (autoMakeupEnabled.load())
|
||||
{
|
||||
float mkGain = juce::Decibels::decibelsToGain (firEngine.getAutoMakeupGainDb());
|
||||
if (std::abs (mkGain - 1.0f) > 0.001f)
|
||||
buffer.applyGain (mkGain);
|
||||
}
|
||||
break;
|
||||
}
|
||||
default: break;
|
||||
}
|
||||
}
|
||||
|
||||
// Feed spectrum analyzer (mono mix of output)
|
||||
const int numSamples = buffer.getNumSamples();
|
||||
const int numChannels = buffer.getNumChannels();
|
||||
for (int i = 0; i < numSamples; ++i)
|
||||
{
|
||||
float sample = 0.0f;
|
||||
for (int ch = 0; ch < numChannels; ++ch)
|
||||
sample += buffer.getSample (ch, i);
|
||||
sample /= (float) numChannels;
|
||||
|
||||
fifoBuffer[fifoIndex++] = sample;
|
||||
|
||||
if (fifoIndex >= spectrumFFTSize)
|
||||
{
|
||||
fifoIndex = 0;
|
||||
std::copy (fifoBuffer.begin(), fifoBuffer.end(), fftData.begin());
|
||||
std::fill (fftData.begin() + spectrumFFTSize, fftData.end(), 0.0f);
|
||||
spectrumWindow.multiplyWithWindowingTable (fftData.data(), spectrumFFTSize);
|
||||
spectrumFFT.performFrequencyOnlyForwardTransform (fftData.data());
|
||||
|
||||
{
|
||||
const juce::SpinLock::ScopedLockType lock (spectrumLock);
|
||||
for (int b = 0; b < spectrumFFTSize / 2; ++b)
|
||||
{
|
||||
float mag = fftData[b] / (float) spectrumFFTSize;
|
||||
float dbVal = juce::Decibels::gainToDecibels (mag, -100.0f);
|
||||
// Smooth: 70% old + 30% new
|
||||
spectrumMagnitude[b] = spectrumMagnitude[b] * 0.7f + dbVal * 0.3f;
|
||||
}
|
||||
}
|
||||
spectrumReady.store (true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================
|
||||
@@ -130,6 +196,37 @@ int InstaLPEQProcessor::getNumBands() const
|
||||
return (int) bands.size();
|
||||
}
|
||||
|
||||
bool InstaLPEQProcessor::getSpectrum (float* dest, int maxBins) const
|
||||
{
|
||||
if (! spectrumReady.load())
|
||||
return false;
|
||||
|
||||
const juce::SpinLock::ScopedTryLockType lock (spectrumLock);
|
||||
if (! lock.isLocked())
|
||||
return false;
|
||||
|
||||
int bins = std::min (maxBins, spectrumFFTSize / 2);
|
||||
std::copy (spectrumMagnitude.begin(), spectrumMagnitude.begin() + bins, dest);
|
||||
return true;
|
||||
}
|
||||
|
||||
float InstaLPEQProcessor::getActiveAutoMakeupDb() const
|
||||
{
|
||||
return autoMakeupEnabled.load() ? firEngine.getAutoMakeupGainDb() : 0.0f;
|
||||
}
|
||||
|
||||
std::array<InstaLPEQProcessor::ChainStage, InstaLPEQProcessor::numChainStages> InstaLPEQProcessor::getChainOrder() const
|
||||
{
|
||||
const juce::SpinLock::ScopedLockType lock (chainLock);
|
||||
return chainOrder;
|
||||
}
|
||||
|
||||
void InstaLPEQProcessor::setChainOrder (const std::array<ChainStage, numChainStages>& order)
|
||||
{
|
||||
const juce::SpinLock::ScopedLockType lock (chainLock);
|
||||
chainOrder = order;
|
||||
}
|
||||
|
||||
void InstaLPEQProcessor::updateFIR()
|
||||
{
|
||||
auto currentBands = getBands();
|
||||
@@ -153,6 +250,16 @@ void InstaLPEQProcessor::getStateInformation (juce::MemoryBlock& destData)
|
||||
xml.setAttribute ("bypass", bypassed.load());
|
||||
xml.setAttribute ("masterGain", (double) masterGainDb.load());
|
||||
xml.setAttribute ("limiter", limiterEnabled.load());
|
||||
xml.setAttribute ("autoMakeup", autoMakeupEnabled.load());
|
||||
|
||||
auto order = getChainOrder();
|
||||
juce::String chainStr;
|
||||
for (int i = 0; i < numChainStages; ++i)
|
||||
{
|
||||
if (i > 0) chainStr += ",";
|
||||
chainStr += juce::String ((int) order[i]);
|
||||
}
|
||||
xml.setAttribute ("chainOrder", chainStr);
|
||||
|
||||
auto currentBands = getBands();
|
||||
for (int i = 0; i < (int) currentBands.size(); ++i)
|
||||
@@ -177,6 +284,17 @@ void InstaLPEQProcessor::setStateInformation (const void* data, int sizeInBytes)
|
||||
bypassed.store (xml->getBoolAttribute ("bypass", false));
|
||||
masterGainDb.store ((float) xml->getDoubleAttribute ("masterGain", 0.0));
|
||||
limiterEnabled.store (xml->getBoolAttribute ("limiter", true));
|
||||
autoMakeupEnabled.store (xml->getBoolAttribute ("autoMakeup", true));
|
||||
|
||||
auto chainStr = xml->getStringAttribute ("chainOrder", "0,1,2");
|
||||
auto tokens = juce::StringArray::fromTokens (chainStr, ",", "");
|
||||
if (tokens.size() == numChainStages)
|
||||
{
|
||||
std::array<ChainStage, numChainStages> order;
|
||||
for (int i = 0; i < numChainStages; ++i)
|
||||
order[i] = static_cast<ChainStage> (tokens[i].getIntValue());
|
||||
setChainOrder (order);
|
||||
}
|
||||
|
||||
std::vector<EQBand> loadedBands;
|
||||
for (auto* bandXml : xml->getChildIterator())
|
||||
|
||||
@@ -40,10 +40,22 @@ public:
|
||||
void removeBand (int index);
|
||||
int getNumBands() const;
|
||||
|
||||
// Signal chain stages
|
||||
enum ChainStage { MasterGain = 0, Limiter, MakeupGain, NumStages };
|
||||
static constexpr int numChainStages = (int) NumStages;
|
||||
|
||||
// Settings
|
||||
std::atomic<bool> bypassed { false };
|
||||
std::atomic<float> masterGainDb { 0.0f };
|
||||
std::atomic<bool> limiterEnabled { true };
|
||||
std::atomic<bool> autoMakeupEnabled { true };
|
||||
|
||||
float getActiveAutoMakeupDb() const;
|
||||
float getMeasuredAutoMakeupDb() const { return measuredMakeupDb.load(); }
|
||||
|
||||
// Chain order (read/write from GUI, read from audio thread)
|
||||
std::array<ChainStage, numChainStages> getChainOrder() const;
|
||||
void setChainOrder (const std::array<ChainStage, numChainStages>& order);
|
||||
|
||||
void setQuality (int fftOrder);
|
||||
|
||||
@@ -58,10 +70,33 @@ private:
|
||||
juce::dsp::Convolution convolution;
|
||||
juce::dsp::Limiter<float> limiter;
|
||||
|
||||
// Spectrum analyzer
|
||||
static constexpr int spectrumFFTOrder = 11; // 2048-point FFT
|
||||
static constexpr int spectrumFFTSize = 1 << spectrumFFTOrder;
|
||||
juce::dsp::FFT spectrumFFT { spectrumFFTOrder };
|
||||
juce::dsp::WindowingFunction<float> spectrumWindow { spectrumFFTSize, juce::dsp::WindowingFunction<float>::hann };
|
||||
std::array<float, spectrumFFTSize> fifoBuffer {};
|
||||
int fifoIndex = 0;
|
||||
std::array<float, spectrumFFTSize * 2> fftData {};
|
||||
std::array<float, spectrumFFTSize / 2> spectrumMagnitude {};
|
||||
juce::SpinLock spectrumLock;
|
||||
std::atomic<bool> spectrumReady { false };
|
||||
|
||||
public:
|
||||
bool getSpectrum (float* dest, int maxBins) const;
|
||||
|
||||
double currentSampleRate = 44100.0;
|
||||
int currentBlockSize = 512;
|
||||
bool firLoaded = false;
|
||||
|
||||
// Signal-based auto makeup measurement
|
||||
double smoothedInputRms = 0.0;
|
||||
double smoothedOutputRms = 0.0;
|
||||
std::atomic<float> measuredMakeupDb { 0.0f };
|
||||
|
||||
std::array<ChainStage, numChainStages> chainOrder { MasterGain, Limiter, MakeupGain };
|
||||
juce::SpinLock chainLock;
|
||||
|
||||
void updateFIR();
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (InstaLPEQProcessor)
|
||||
|
||||
165
Source/SignalChainPanel.cpp
Normal file
165
Source/SignalChainPanel.cpp
Normal file
@@ -0,0 +1,165 @@
|
||||
#include "SignalChainPanel.h"
|
||||
#include "LookAndFeel.h"
|
||||
|
||||
SignalChainPanel::SignalChainPanel()
|
||||
{
|
||||
setMouseCursor (juce::MouseCursor::DraggingHandCursor);
|
||||
}
|
||||
|
||||
void SignalChainPanel::setOrder (const std::array<InstaLPEQProcessor::ChainStage, numBlocks>& order)
|
||||
{
|
||||
if (currentOrder != order)
|
||||
{
|
||||
currentOrder = order;
|
||||
repaint();
|
||||
}
|
||||
}
|
||||
|
||||
juce::String SignalChainPanel::getStageName (InstaLPEQProcessor::ChainStage stage) const
|
||||
{
|
||||
switch (stage)
|
||||
{
|
||||
case InstaLPEQProcessor::MasterGain: return "MASTER GAIN";
|
||||
case InstaLPEQProcessor::Limiter: return "LIMITER";
|
||||
case InstaLPEQProcessor::MakeupGain: return "AUTO GAIN";
|
||||
default: return "?";
|
||||
}
|
||||
}
|
||||
|
||||
juce::Colour SignalChainPanel::getStageColour (InstaLPEQProcessor::ChainStage stage) const
|
||||
{
|
||||
switch (stage)
|
||||
{
|
||||
case InstaLPEQProcessor::MasterGain: return juce::Colour (0xffff8833);
|
||||
case InstaLPEQProcessor::Limiter: return juce::Colour (0xffff4455);
|
||||
case InstaLPEQProcessor::MakeupGain: return juce::Colour (0xff44bbff);
|
||||
default: return InstaLPEQLookAndFeel::textSecondary;
|
||||
}
|
||||
}
|
||||
|
||||
juce::Rectangle<float> SignalChainPanel::getBlockRect (int index) const
|
||||
{
|
||||
auto bounds = getLocalBounds().toFloat().reduced (2);
|
||||
float gap = 6.0f;
|
||||
float blockW = (bounds.getWidth() - gap * (numBlocks - 1)) / numBlocks;
|
||||
float x = bounds.getX() + index * (blockW + gap);
|
||||
return { x, bounds.getY(), blockW, bounds.getHeight() };
|
||||
}
|
||||
|
||||
int SignalChainPanel::getBlockAtX (float x) const
|
||||
{
|
||||
for (int i = 0; i < numBlocks; ++i)
|
||||
{
|
||||
if (getBlockRect (i).contains (x, getHeight() * 0.5f))
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
void SignalChainPanel::paint (juce::Graphics& g)
|
||||
{
|
||||
auto bounds = getLocalBounds().toFloat();
|
||||
|
||||
// Background
|
||||
g.setColour (InstaLPEQLookAndFeel::bgDark.darker (0.3f));
|
||||
g.fillRoundedRectangle (bounds, 4.0f);
|
||||
g.setColour (InstaLPEQLookAndFeel::bgLight.withAlpha (0.2f));
|
||||
g.drawRoundedRectangle (bounds, 4.0f, 1.0f);
|
||||
|
||||
auto* lf = dynamic_cast<InstaLPEQLookAndFeel*> (&getLookAndFeel());
|
||||
|
||||
// Draw arrows between blocks (scale with height)
|
||||
float arrowScale = bounds.getHeight() / 30.0f;
|
||||
for (int i = 0; i < numBlocks - 1; ++i)
|
||||
{
|
||||
auto r1 = getBlockRect (i);
|
||||
auto r2 = getBlockRect (i + 1);
|
||||
float arrowX = (r1.getRight() + r2.getX()) * 0.5f;
|
||||
float arrowY = bounds.getCentreY();
|
||||
float aw = 5.0f * arrowScale;
|
||||
float ah = 6.0f * arrowScale;
|
||||
g.setColour (InstaLPEQLookAndFeel::textSecondary.withAlpha (0.5f));
|
||||
|
||||
juce::Path arrow;
|
||||
arrow.addTriangle (arrowX - aw, arrowY - ah, arrowX - aw, arrowY + ah, arrowX + aw, arrowY);
|
||||
g.fillPath (arrow);
|
||||
}
|
||||
|
||||
// Draw blocks
|
||||
for (int i = 0; i < numBlocks; ++i)
|
||||
{
|
||||
bool isDragged = (i == draggedIndex);
|
||||
auto rect = getBlockRect (i);
|
||||
|
||||
// If this block is being dragged, offset it
|
||||
if (isDragged)
|
||||
{
|
||||
float offset = dragCurrentX - dragOffsetX;
|
||||
rect = rect.withX (rect.getX() + offset);
|
||||
}
|
||||
|
||||
auto colour = getStageColour (currentOrder[i]);
|
||||
|
||||
// Block background
|
||||
g.setColour (isDragged ? colour.withAlpha (0.25f) : colour.withAlpha (0.12f));
|
||||
g.fillRoundedRectangle (rect, 4.0f);
|
||||
|
||||
// Block border
|
||||
g.setColour (isDragged ? colour.withAlpha (0.8f) : colour.withAlpha (0.4f));
|
||||
g.drawRoundedRectangle (rect, 4.0f, isDragged ? 2.0f : 1.0f);
|
||||
|
||||
// Label — scale with block height
|
||||
juce::Font font = lf ? lf->getBoldFont (std::max (12.0f, rect.getHeight() * 0.45f))
|
||||
: juce::Font (juce::FontOptions (14.0f));
|
||||
g.setFont (font);
|
||||
g.setColour (isDragged ? colour : colour.withAlpha (0.8f));
|
||||
g.drawText (getStageName (currentOrder[i]), rect.reduced (4), juce::Justification::centred, false);
|
||||
}
|
||||
|
||||
// "SIGNAL CHAIN" label on the left
|
||||
if (lf)
|
||||
{
|
||||
g.setFont (lf->getRegularFont (10.0f));
|
||||
g.setColour (InstaLPEQLookAndFeel::textSecondary.withAlpha (0.5f));
|
||||
}
|
||||
}
|
||||
|
||||
void SignalChainPanel::resized() {}
|
||||
|
||||
void SignalChainPanel::mouseDown (const juce::MouseEvent& e)
|
||||
{
|
||||
draggedIndex = getBlockAtX (e.position.x);
|
||||
if (draggedIndex >= 0)
|
||||
{
|
||||
dragOffsetX = e.position.x;
|
||||
dragCurrentX = e.position.x;
|
||||
}
|
||||
}
|
||||
|
||||
void SignalChainPanel::mouseDrag (const juce::MouseEvent& e)
|
||||
{
|
||||
if (draggedIndex < 0)
|
||||
return;
|
||||
|
||||
dragCurrentX = e.position.x;
|
||||
|
||||
// Check if we should swap with a neighbor
|
||||
int targetIndex = getBlockAtX (e.position.x);
|
||||
if (targetIndex >= 0 && targetIndex != draggedIndex)
|
||||
{
|
||||
std::swap (currentOrder[draggedIndex], currentOrder[targetIndex]);
|
||||
draggedIndex = targetIndex;
|
||||
dragOffsetX = e.position.x;
|
||||
|
||||
if (listener)
|
||||
listener->chainOrderChanged (currentOrder);
|
||||
}
|
||||
|
||||
repaint();
|
||||
}
|
||||
|
||||
void SignalChainPanel::mouseUp (const juce::MouseEvent&)
|
||||
{
|
||||
draggedIndex = -1;
|
||||
repaint();
|
||||
}
|
||||
46
Source/SignalChainPanel.h
Normal file
46
Source/SignalChainPanel.h
Normal file
@@ -0,0 +1,46 @@
|
||||
#pragma once
|
||||
#include <JuceHeader.h>
|
||||
#include "PluginProcessor.h"
|
||||
|
||||
class SignalChainPanel : public juce::Component
|
||||
{
|
||||
public:
|
||||
struct Listener
|
||||
{
|
||||
virtual ~Listener() = default;
|
||||
virtual void chainOrderChanged (const std::array<InstaLPEQProcessor::ChainStage, InstaLPEQProcessor::numChainStages>& order) = 0;
|
||||
};
|
||||
|
||||
SignalChainPanel();
|
||||
|
||||
void setListener (Listener* l) { listener = l; }
|
||||
void setOrder (const std::array<InstaLPEQProcessor::ChainStage, InstaLPEQProcessor::numChainStages>& order);
|
||||
std::array<InstaLPEQProcessor::ChainStage, InstaLPEQProcessor::numChainStages> getOrder() const { return currentOrder; }
|
||||
|
||||
void paint (juce::Graphics& g) override;
|
||||
void resized() override;
|
||||
void mouseDown (const juce::MouseEvent& e) override;
|
||||
void mouseDrag (const juce::MouseEvent& e) override;
|
||||
void mouseUp (const juce::MouseEvent& e) override;
|
||||
|
||||
private:
|
||||
static constexpr int numBlocks = InstaLPEQProcessor::numChainStages;
|
||||
std::array<InstaLPEQProcessor::ChainStage, numBlocks> currentOrder {
|
||||
InstaLPEQProcessor::MasterGain,
|
||||
InstaLPEQProcessor::Limiter,
|
||||
InstaLPEQProcessor::MakeupGain
|
||||
};
|
||||
|
||||
int draggedIndex = -1;
|
||||
float dragOffsetX = 0.0f;
|
||||
float dragCurrentX = 0.0f;
|
||||
|
||||
Listener* listener = nullptr;
|
||||
|
||||
juce::Rectangle<float> getBlockRect (int index) const;
|
||||
int getBlockAtX (float x) const;
|
||||
juce::String getStageName (InstaLPEQProcessor::ChainStage stage) const;
|
||||
juce::Colour getStageColour (InstaLPEQProcessor::ChainStage stage) const;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (SignalChainPanel)
|
||||
};
|
||||
Reference in New Issue
Block a user