diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 000000000..b2932458c
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,3 @@
+# Keep the user's original layered SVG byte-identical on Windows and Linux.
+# Reformatting line endings would invalidate the asset QA SHA256 contract.
+assets/fx/graphic-eq31/slider_eq_grp.svg -text
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7d3fad01c..6b3c9ec7f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -332,10 +332,14 @@ endforeach()
juce_add_binary_data(ARMixAssets SOURCES
"${ARMIX_APPROVED_GUI_DIR}/index.html" ${ARMIX_APPROVED_GUI_BINARIES}
${ARMIX_GUITAR_SKIN_PNGS}
+ "${CMAKE_CURRENT_SOURCE_DIR}/assets/fx/graphic-eq31/slider_eq_grp.svg"
${ARMIX_LEGAL_RESOURCE_FILES}
"${ARMIX_BRAND_DIR}/arsonmix-256.png"
${ARMIX_IMERSIB_SCENE_PNG_SOURCES})
target_include_directories(ARMixConsole PRIVATE "${ARMIX_APPROVED_GUI_DIR}")
+# Only the production GUI embeds the owner's complete grouped EQ31 SVG; isolated native
+# FX tests use the procedural fallback without depending on BinaryData.
+target_compile_definitions(ARMixConsole PRIVATE ARMIX_GEQ31_VECTOR_ASSET=1)
target_sources(ARMixConsole PRIVATE src/Main.cpp src/LiveAudioEngine.h engine/builtin_fx/HarmonyDsp.h engine/builtin_fx/HarmonyMusicKey.h engine/builtin_fx/ChannelHarmonyProcessor.h engine/builtin_fx/SonKuSpatialProcessor.h engine/builtin_fx/sonku/SonKuSpatialCore.h engine/builtin_fx/sonku/SonKuMeasuredHrir.h src/VstOrbitController.h engine/core/MixerRoutingPlan.h engine/core/ChannelRoutingContract.h engine/core/ChannelSendPlan.h engine/core/AuxBusPlan.h engine/core/PreparedMixerBlock.h engine/core/MasterOutputMonoPolicy.h engine/core/LiveChannelFxGraph.h engine/core/PreparedNativeMixerSession.h engine/core/NativeDryRouteCommand.h engine/core/RealtimeRoutePublisher.h engine/device/LiveInputPortRegistry.h src/LiveDryRoutingLab.h engine/core/OrbitPhase.h engine/core/OrbitControlPolicy.h engine/core/OrbitMotion.h engine/core/OrbitDistanceMapping.h engine/core/DearVrPolarPolicy.h src/PluginCatalog.h src/NativeFxParameterHotkey.h src/NativeHotkeyCommandPlan.h src/FactoryFxRegistry.h src/PluginVault.h src/PortableWorkspace.h src/StudioBackup.h src/DiagnosticsRecorder.h src/StereoPan.h src/NativePresetArchive.h src/NativeShowSchema.h src/NativeDryShowRecall.h src/VstBusLayout.h src/LiveGraphHandoff.h src/DiagnosticTone.h engine/core/RealtimeHealthHistogram.h engine/core/CallbackCadenceEvidence.h engine/diagnostics/CrackleEvidenceWindow.h engine/device/AdaptiveClockBridge.h engine/device/AudioProfilePolicy.h engine/device/PeriodCapabilityEvidence.h engine/device/SessionLifecycle.h engine/device/WasapiCapabilityProbe.h engine/device/JuceIndependentClockDevice.h engine/device/LiveSecondaryOutputDevice.h engine/device/LiveSecondaryCaptureDevice.h engine/device/SecondaryCaptureClockStream.h engine/core/LiveOutputRouteGate.h engine/device/ClockBridgeSizing.h engine/device/IndependentStreamFormatFence.h engine/device/DirectRestoreBackoff.h engine/device/IndependentStreamWatchdog.h engine/device/BridgeContinuityGate.h engine/device/EndpointIdentityPolicy.h engine/device/WasapiEndpointIdentityGuard.h engine/device/AsioStartupPolicy.h engine/device/AsioPriorityDeviceManager.h engine/device/JuceActivePortSnapshot.h engine/device/AsioRegistrationPolicy.h engine/device/AsioRegistryIdentityProbe.h engine/device/DirectRouteFence.h)
# Explicit UTF-8 source decoding: native channel icons are Unicode, and
@@ -1611,6 +1615,16 @@ if(BUILD_TESTING)
add_test(NAME NativePEQEightBandsRTAndFrequencyResponse COMMAND ARMixNativeChannelEqTests)
add_dependencies(ARMixMixerRoutingTests ARMixNativeChannelEqTests)
+ # Graphic EQ 31: ISO one-third-octave centres, stereo PCM, Nyquist and RT ramps.
+ add_executable(ARMixGraphicEq31CoreTests tests/graphic_eq31_core_test.cpp
+ engine/builtin_fx/GraphicEq31Core.h)
+ target_compile_features(ARMixGraphicEq31CoreTests PRIVATE cxx_std_20)
+ add_test(NAME GraphicEq31FrequencyResponseAndRealtimeStability
+ COMMAND ARMixGraphicEq31CoreTests)
+ add_test(NAME GraphicEq31OriginalSvgLayersAndDynamicThumb
+ COMMAND "${Python3_EXECUTABLE}" "${CMAKE_CURRENT_SOURCE_DIR}/tests/graphic_eq31_svg_layers_test.py")
+ add_dependencies(ARMixMixerRoutingTests ARMixGraphicEq31CoreTests)
+
# Zero-lookahead native compressor DSP: zero PDC, stereo-linked peak,
# soft knee, dry/wet, parameter validation and variable sample rates.
add_executable(ARMixNativeCompressorTests tests/builtin_channel_compressor_test.cpp
diff --git a/assets/fx/graphic-eq31/KNOB-EQ.svg b/assets/fx/graphic-eq31/KNOB-EQ.svg
new file mode 100644
index 000000000..512da2154
--- /dev/null
+++ b/assets/fx/graphic-eq31/KNOB-EQ.svg
@@ -0,0 +1,39 @@
+
\ No newline at end of file
diff --git a/assets/fx/graphic-eq31/slider_eq_grp.svg b/assets/fx/graphic-eq31/slider_eq_grp.svg
new file mode 100644
index 000000000..386777fec
--- /dev/null
+++ b/assets/fx/graphic-eq31/slider_eq_grp.svg
@@ -0,0 +1,150 @@
+
\ No newline at end of file
diff --git a/docs/fx/GRAPHIC_EQ31_NATIVE.md b/docs/fx/GRAPHIC_EQ31_NATIVE.md
new file mode 100644
index 000000000..059376d44
--- /dev/null
+++ b/docs/fx/GRAPHIC_EQ31_NATIVE.md
@@ -0,0 +1,45 @@
+# Graphic EQ 31 — Native built-in FX integration
+
+**Implementation branch:** `feat/graphic-eq31-native-fx`
+**Native catalog:** `armix.builtin.graphic-eq31.v1`
+**Operator name:** **Graphic EQ 31**
+**Delivery:** JUCE native insert under the existing ArSonMix FX Rack, **not** a standalone app, external VST3 or FactoryFX.
+
+## What is owned where
+
+- `engine/builtin_fx/GraphicEq31Core.h` owns the fixed 31-frequency stereo signal path. 31 matched second-order peaking sections are directly cascaded without adding a callback or allocation. Nominal centres are the ISO/dbx-style 1/3-octave series from 20 Hz to 20 kHz; Q is fixed at 4.318473, so adjacent bands overlap.
+- `engine/builtin_fx/GraphicEq31Processor.h` is a native JUCE `AudioProcessor`, controlled by `band0`…`band30` only. The input/output trim parameters were fully removed from DSP and editor; legacy saved states migrate safely.
+- `src/NativeBuiltInFx.h` registers one catalog descriptor. Existing `FxInstance`, per-ChannelId ordering, per-insert bypass, lifecycle, `.smix` binary storage, device switching and generic owned editor remain the exclusive authorities.
+- `web/approved-native-bridge.js` adds a discovery fallback until native `arMixCatalog` returns the canonical descriptor. **No second GUI or WebAudio processing** is introduced.
+- `assets/fx/graphic-eq31/slider_eq_grp.svg` is the owner's **byte-exact original 33,354-byte SVG** (`SHA256 aeaf02b8904a667724f34774a692da39a5a466bae302611f347fae4d9fd14dba`). Its three authored children `Track`, `Text`, and `THUMB` are preserved. The production JUCE binary embeds the entire SVG including the original raster/vector THUMB. The editor changes only the `Text` frequency tspan while parsing each band **once** on the UI thread; afterwards it holds the original authored `THUMB` Drawable and applies a simple affine Y transform on parameter changes (no XML reparse, PNG decode, or allocation in the drag path). There are **no JUCE-painted substitute tracks or silver thumbs**; invalid SVG displays a visible error. No BinaryData means the graphical layer cannot render, rather than silently showing a fake substitute.
+
+## Frequencies
+
+```text
+ 20 25 31.5 40 50 63 80 100 125 160 200
+ 250 315 400 500 630 800 1k 1.25k 1.6k 2k 2.5k
+ 3.15k 4k 5k 6.3k 8k 10k 12.5k 16k 20k
+```
+
+- 31 fixed dbx/ISO nominal one-third-octave centres, each **±12 dB**, linked stereo gains with independent L/R filter history. Zero additional delay/lookahead and normal host bypass.
+- **No input or output gain control** and no hidden input/output gain multiplication. Flat with zero bands is unity; peak metering is post-EQ.
+- **GEQ1 v3** state stores 31 bands only (**132 bytes**). Historic **v1 140-byte** and **v2 136-byte** states are validated entirely and imported, discarding obsolete input/output trim values. Invalid state fails closed; published graph state is not mutated.
+- GUI: authentic owner `slider_eq_grp.svg` remains byte-identical (original `Track`, `Text`, `THUMB` groups). The JUCE editor creates 31 independent Drawables once on the UI thread and moves each vector `THUMB` by Y translation. The duplicate raster use `_Image3` (dark rectangular shadow) is **omitted from the render clone**, not deleted from the source. The duplicate per-band `Hz` group is also hidden in each render clone to declutter the UI. Frequency labels remain within the original `Text` group, switched to Inter.
+- **50 px pitch** (31 × 50 = 1550 px) rather than the unreadable previous 37 px. The editor defaults to **1610 × 391 px** and can be resized horizontally from **850 to 1900 px**; smaller windows scroll horizontally with LOW/MID/HIGH jump controls. The source `viewBox` stays unchanged; only the UI clone is cropped horizontally (`60 0 352 2042`) to use screen real estate efficiently.
+- One uninterrupted neutral EQ background. **No per-fader shadow blocks, additional cards, gain knob, knob asset in production binary, or second GUI host.** `KNOB-EQ.svg` may remain archived in the repository but is no longer included in CMake BinaryData.
+- The only mixer interface authority remains the existing ArSonMix FX Rack and mixer-owned JUCE editor; no extra PCM path or WebView is added.
+- The screenshot/HTML design preview is a source-derived Chromium rendering, **not** evidence that the JUCE Windows native build has passed.
+
+## State and safety
+
+The versioned state loader validates magic, version, exact byte length, every per-band value, and any legacy trims **before changing any parameters**. Live audio coefficients use existing realtime-safe smoothing; no allocation, file IO, locks, or JSON parsing is performed on the realtime callback.
+
+## Verification evidence and release boundary
+
+- Static/pure-C++ checks: `ARMixGraphicEq31CoreTests` / `GraphicEq31FrequencyResponseAndRealtimeStability` (frequency response, invalid gains, stereo isolation, low-rate Nyquist and automation stress). Its 29 explicit `GEQ_CHECK` predicates remain executable in Release (`NDEBUG`) builds, including setup calls that used to disappear inside standard `assert`.
+- Source-artwork regression: `GraphicEq31OriginalSvgLayersAndDynamicThumb` validates the owner's byte-exact SVG, original `Track`/`Text`/`THUMB` structure, shadow removal on the UI clone, CMake BinaryData, 50px fader pitch, Inter, and absence of both gain trims.
+- Shared host registration: `ARMixNativeFxExtensionTests` (catalog, state roundtrip, bad binary reject, PCM finite, published restore reject).
+- Follow the current exact-SHA Windows `native` GitHub CI workflow before merge. A CI success proves compilation and automated tests, not physical sound quality.
+- **Still requires owner equipment FAT**: audition all 31 faders at representative rates, verify Flat unity (0dB trims), inspect bypass/restore and `.smix`, open/close editor while live ASIO runs, verify CPU/XRUN and confirm headroom/clipping at ±12dB in a complete music mix.
+
+No claim is made that this is a hardware-accurate proprietary dbx transfer function: frequency centres and classic panel controls are matched, while the original JUCE biquad implementation is independently authored.
diff --git a/engine/builtin_fx/GraphicEq31Core.h b/engine/builtin_fx/GraphicEq31Core.h
new file mode 100644
index 000000000..2121fb4aa
--- /dev/null
+++ b/engine/builtin_fx/GraphicEq31Core.h
@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+#pragma once
+#include
+#include
+#include
+#include
+#include
+
+namespace armix::builtin_fx {
+
+// IEC/ISO one-third-octave nominal centres, as used on dbx 31-band consoles.
+// Fixed frequencies are an immutable DSP contract, independent of GUI labels.
+inline constexpr std::array graphicEq31Hz {{
+ 20.,25.,31.5,40.,50.,63.,80.,100.,125.,160.,200.,250.,
+ 315.,400.,500.,630.,800.,1000.,1250.,1600.,2000.,2500.,
+ 3150.,4000.,5000.,6300.,8000.,10000.,12500.,16000.,20000.
+}};
+inline constexpr std::array graphicEq31Labels {{
+ "20","25","31.5","40","50","63","80","100","125","160","200",
+ "250","315","400","500","630","800","1k","1.25k","1.6k",
+ "2k","2.5k","3.15k","4k","5k","6.3k","8k","10k",
+ "12.5k","16k","20k"
+}};
+
+class GraphicEq31Core final {
+public:
+ static constexpr std::size_t bandCount=graphicEq31Hz.size();
+ static constexpr double maximumDb=12.;
+ static constexpr double nominalQ=4.318473; // one-third-octave bandwidth
+
+ bool prepare(double rate) noexcept {
+ ready_=std::isfinite(rate)&&rate>=8000.&&rate<=384000.;
+ if(!ready_)return false;
+ rate_=rate;
+ rampFrames_=std::max(32,static_cast(std::round(rate_*0.005)));
+ for(std::size_t i=0;i=bandCount||!std::isfinite(db)||db < -maximumDb||db>maximumDb)
+ return false;
+ auto& b=bands_[i];
+ if(std::abs(b.db-db)<1e-5)return true;
+ b.db=db;
+ if(!ready_)return true;
+ b.target=coefficients(i,db,rate_);
+ const double inv=1./static_cast(rampFrames_);
+ b.step={
+ (b.target.b0-b.current.b0)*inv,
+ (b.target.b1-b.current.b1)*inv,
+ (b.target.b2-b.current.b2)*inv,
+ (b.target.a1-b.current.a1)*inv,
+ (b.target.a2-b.current.a2)*inv
+ };
+ b.frames=rampFrames_;
+ return true;
+ }
+ // Per-band, in-place stereo cascade: the active band processes the
+ // entire buffer before the next band. Flat EQ skips all 31 biquads,
+ // avoiding work in the default zero-gain state without extra buffers.
+ // The coefficient ramp is sample-accurate and remains click-free.
+ void processStereo(float* left,float* right,std::size_t frames) noexcept {
+ if(!ready_||!left||!right)return;
+ for(auto& b:bands_) {
+ if(b.frames==0 && b.db==0.) {
+ // Flush stale IIR memories after a completed ramp-to-unity,
+ // so re-enabling a band never exposes a frozen old history.
+ b.l1=b.l2=b.r1=b.r2=0.;
+ continue;
+ }
+ for(std::size_t n=0;n0) {
+ b.current.b0+=b.step.b0;b.current.b1+=b.step.b1;
+ b.current.b2+=b.step.b2;b.current.a1+=b.step.a1;
+ b.current.a2+=b.step.a2;
+ if(--b.frames==0)b.current=b.target;
+ }
+ const auto& co=b.current;
+ const double l=left[n],r=right[n];
+ const double yl=co.b0*l+b.l1;
+ b.l1=co.b1*l-co.a1*yl+b.l2;
+ b.l2=co.b2*l-co.a2*yl;
+ const double yr=co.b0*r+b.r1;
+ b.r1=co.b1*r-co.a1*yr+b.r2;
+ b.r2=co.b2*r-co.a2*yr;
+ left[n]=static_cast(yl);
+ right[n]=static_cast(yr);
+ }
+ }
+ }
+ void reset() noexcept {
+ for(auto& b:bands_)b.l1=b.l2=b.r1=b.r2=0.;
+ }
+private:
+ struct Coeff {
+ double b0=1.,b1=0.,b2=0.,a1=0.,a2=0.;
+ };
+ struct Band {
+ double db=0.;
+ Coeff current{},target{},step{};
+ int frames=0;
+ double l1=0.,l2=0.,r1=0.,r2=0.;
+ };
+ static Coeff coefficients(std::size_t i,double db,double rate) noexcept {
+ // Bands over the physical Nyquist guard are transparent at low sample
+ // rates. Preserve the operator's saved dB setting for a future rate.
+ const double hz=graphicEq31Hz[i];
+ if(std::abs(db)<1e-5 || hz>=rate*0.45)return {};
+ constexpr double pi=3.1415926535897932384626433832795;
+ const double omega=2.*pi*hz/rate;
+ const double cs=std::cos(omega);
+ const double alpha=std::sin(omega)/(2.*nominalQ);
+ const double a=std::pow(10.,db/40.);
+ const double norm=1./(1.+alpha/a);
+ return {(1.+alpha*a)*norm,(-2.*cs)*norm,
+ (1.-alpha*a)*norm,(-2.*cs)*norm,
+ (1.-alpha/a)*norm};
+ }
+ std::array bands_{};
+ double rate_=0.;
+ int rampFrames_=240;
+ bool ready_=false;
+};
+} // namespace armix::builtin_fx
diff --git a/engine/builtin_fx/GraphicEq31Processor.h b/engine/builtin_fx/GraphicEq31Processor.h
new file mode 100644
index 000000000..454e83c99
--- /dev/null
+++ b/engine/builtin_fx/GraphicEq31Processor.h
@@ -0,0 +1,371 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+#pragma once
+#include "GraphicEq31Core.h"
+#include "../core/RealtimeNativeFxControl.h"
+#include
+#include
+#if defined(ARMIX_GEQ31_VECTOR_ASSET) && ARMIX_GEQ31_VECTOR_ASSET
+#include
+#endif
+#include
+#include
+#include
+#include
+#include
+#include
+
+namespace armix::builtin_fx {
+
+class GraphicEq31Processor final : public juce::AudioProcessor,
+ public armix::mixer::RealtimeNativeFxControl {
+public:
+ static constexpr const char* catalogIdentity="armix.builtin.graphic-eq31.v1";
+ static constexpr int stateMagic=0x47455131; // GEQ1, independent of PEQ
+ GraphicEq31Processor()
+ : juce::AudioProcessor(BusesProperties()
+ .withInput("Input",juce::AudioChannelSet::stereo(),true)
+ .withOutput("Output",juce::AudioChannelSet::stereo(),true)),
+ params_(*this,nullptr,"GEQ31",makeParameters()) {
+ for(std::size_t i=0;i(bandValues_[i]->load(std::memory_order_relaxed)));
+ peak_.store(0.f,std::memory_order_relaxed);
+ }
+ void releaseResources() override {ready_=false;}
+ bool isReady() const noexcept {return ready_;}
+ void consumeRealtimeEdits() noexcept override {
+ // Parameters are JUCE atomic floats. Coefficients are computed at
+ // most once per changed band per block; no allocation or mutex.
+ if(!ready_)return;
+ for(std::size_t i=0;iload(std::memory_order_relaxed));
+ }
+ void sealForRealtime() noexcept override {published_=true;}
+ // No pending control mailbox: JUCE publishes each target atomically.
+ bool stateSnapshotQuiescent() const noexcept override {return true;}
+ void processBlock(juce::AudioBuffer& pcm,juce::MidiBuffer&) override {
+ juce::ScopedNoDenormals noDenormals;
+ if(!ready_||pcm.getNumChannels()<2||pcm.getNumSamples()<=0)return;
+ consumeRealtimeEdits();
+ const auto count=pcm.getNumSamples();
+ auto* l=pcm.getWritePointer(0);
+ auto* r=pcm.getWritePointer(1);
+ // Graphic EQ 31 has only the 31 band controls. No invisible
+ // input/output gain, and no extra multiplier in the realtime path.
+ core_.processStereo(l,r,static_cast(count));
+ float peak=0.f;
+ // Output gain was removed from Graphic EQ 31: meter post-EQ PCM,
+ // without a hidden output trim altering levels or headroom.
+ for(int n=0;n&,juce::MidiBuffer&) override {}
+ void getStateInformation(juce::MemoryBlock& destination) override {
+ // CONTROL thread. Only one fixed-size, versioned state per insert.
+ juce::MemoryOutputStream out(destination,false);
+ // GEQ1 v3: 31 band gains, no hidden trim (132 bytes).
+ // Restore supports legacy v1/v2 and discards old input/output trims.
+ out.writeInt(stateMagic);out.writeInt(3);
+ for(auto* p:bandValues_)out.writeFloat(p->load(std::memory_order_acquire));
+ }
+ bool restoreUnpublishedState(const void* bytes,int length) {
+ constexpr int bandBytes=static_cast(GraphicEq31Core::bandCount)*4;
+ constexpr int v1Bytes=8+bandBytes+8; // band + input + output
+ constexpr int v2Bytes=8+bandBytes+4; // band + input
+ constexpr int v3Bytes=8+bandBytes; // band only
+ if(published_||!bytes||
+ (length!=v1Bytes&&length!=v2Bytes&&length!=v3Bytes))return false;
+ juce::MemoryInputStream input(bytes,static_cast(length),false);
+ if(input.readInt()!=stateMagic)return false;
+ const int version=input.readInt();
+ if((version==1&&length!=v1Bytes)||
+ (version==2&&length!=v2Bytes)||
+ (version==3&&length!=v3Bytes)||
+ (version!=1&&version!=2&&version!=3))return false;
+ std::array bands{};
+ for(auto& value:bands) {
+ value=input.readFloat();
+ if(!std::isfinite(value)||value < -12.f||value>12.f)return false;
+ }
+ // Strictly validate legacy trims before any state mutation, then
+ // discard them. Hidden gain must NEVER survive a UI migration.
+ for(int i=0;i<(version==1?2:version==2?1:0);++i) {
+ const auto obsoleteTrim=input.readFloat();
+ if(!std::isfinite(obsoleteTrim)||
+ obsoleteTrim < -12.f||obsoleteTrim>12.f)return false;
+ }
+ if(!input.isExhausted())return false;
+ for(std::size_t i=0;i=-12.f&&db<=12.f)
+ setParameter(paramId(index),db);
+ }
+ void setFlatFromUi() {
+ for(std::size_t i=0;i(i));
+ }
+ static juce::AudioProcessorValueTreeState::ParameterLayout makeParameters() {
+ juce::AudioProcessorValueTreeState::ParameterLayout result;
+ for(std::size_t i=0;i(
+ juce::ParameterID{paramId(i),1},
+ juce::String(graphicEq31Labels[i])+" Hz",
+ juce::NormalisableRange(-12.f,12.f,.1f),0.f));
+ return result;
+ }
+ void setParameter(const juce::String& id,float db) {
+ if(auto* p=dynamic_cast(params_.getParameter(id))) {
+ p->beginChangeGesture();
+ p->setValueNotifyingHost(p->convertTo0to1(db));
+ p->endChangeGesture();
+ }
+ }
+ juce::AudioProcessorValueTreeState params_;
+ GraphicEq31Core core_;
+ std::array*,GraphicEq31Core::bandCount> bandValues_{};
+ std::atomic peak_{0.f};
+ bool published_=false,ready_=false;
+};
+
+class GraphicEq31Editor final : public juce::AudioProcessorEditor, private juce::Timer {
+public:
+ explicit GraphicEq31Editor(GraphicEq31Processor& processor)
+ : juce::AudioProcessorEditor(processor), processor_(processor) {
+ setLookAndFeel(&skin_);
+ // The existing ArSonMix rack/ChannelId owns this JUCE editor window.
+ // The owner's original grouped SVG provides EVERY track and thumb.
+ for(std::size_t i=0;i(i)));
+ slider.setSliderStyle(juce::Slider::LinearVertical);
+ slider.setTextBoxStyle(juce::Slider::NoTextBox,false,0,0);
+ slider.setDoubleClickReturnValue(true,0.);
+ slider.setTooltip(juce::String(graphicEq31Labels[i])+
+ " Hz | -12 ... +12 dB | Double-click: 0 dB");
+ bandSurface_.addAndMakeVisible(slider);
+ attachments_.emplace_back(std::make_unique(
+ processor_.parameters(),"band"+juce::String(static_cast(i)),slider));
+ }
+ viewport_.setViewedComponent(&bandSurface_,false);
+ viewport_.setScrollBarsShown(false,true);
+ viewport_.setScrollBarThickness(7);
+ addAndMakeVisible(viewport_);
+
+ flat_.setButtonText("Flat");
+ flat_.onClick=[this]{processor_.setFlatFromUi();};
+ addAndMakeVisible(flat_);
+ smile_.setButtonText("Smile");
+ smile_.onClick=[this]{
+ for(std::size_t i=0;i4500.?2.5f:-1.f));
+ }
+ };
+ addAndMakeVisible(smile_);
+ for(int i=0;i<3;++i) {
+ jump_[i].setButtonText(i==0?"LOW":i==1?"MID":"HIGH");
+ jump_[i].onClick=[this,i]{
+ viewport_.setViewPosition(i==0?0:(i==1?11:22)*bandCellWidth,0);
+ };
+ addAndMakeVisible(jump_[i]);
+ }
+ peakLabel_.setJustificationType(juce::Justification::centred);
+ peakLabel_.setFont(inter(10.f));
+ addAndMakeVisible(peakLabel_);
+ setResizable(true,true);
+ setResizeLimits(850,391,1900,391);
+ setSize(1610,391);
+ startTimerHz(20);
+ }
+
+ ~GraphicEq31Editor() override {stopTimer();setLookAndFeel(nullptr);}
+
+ void paint(juce::Graphics& g) override {
+ // One uninterrupted control panel. No per-band card or shadow.
+ g.fillAll(juce::Colour::fromRGB(246,247,247));
+ g.setColour(juce::Colour::fromRGB(212,219,221));
+ g.drawRect(getLocalBounds().reduced(1),1);
+ g.setColour(juce::Colour::fromRGB(52,67,73));
+ g.setFont(inter(18.f));
+ g.drawText("Graphic EQ 31",20,15,300,32,juce::Justification::centredLeft);
+ g.setColour(juce::Colour::fromRGB(128,143,148));
+ g.setFont(inter(10.5f));
+ g.drawText("ARSONMIX / 1/3 OCTAVE / 20 Hz - 20 kHz",
+ 213,24,400,20,juce::Justification::centredLeft);
+ g.setColour(juce::Colour::fromRGB(226,231,232));
+ g.drawHorizontalLine(53,0.f,static_cast(getWidth()));
+ g.setFont(inter(10.f));
+ g.setColour(juce::Colour::fromRGB(112,126,131));
+ g.drawText("+12",5,86,36,16,juce::Justification::centredRight);
+ g.drawText("0",5,195,36,16,juce::Justification::centredRight);
+ g.drawText("-12",5,307,36,16,juce::Justification::centredRight);
+ g.setColour(juce::Colour::fromRGB(143,155,159));
+ g.drawText("31 BANDS / +/-12 dB",53,366,
+ juce::jmax(0,getWidth()-70),17,juce::Justification::centredLeft);
+ }
+ void resized() override {
+ constexpr int x0=46;
+ viewport_.setBounds(x0,66,juce::jmax(1,getWidth()-x0-12),297);
+ bandSurface_.setSize(static_cast(GraphicEq31Core::bandCount)*bandCellWidth,287);
+ for(std::size_t i=0;i(i)*bandCellWidth,0,
+ bandCellWidth,286);
+ const int controlX=juce::jmax(440,getWidth()-415);
+ flat_.setBounds(controlX,17,64,27);
+ smile_.setBounds(controlX+71,17,64,27);
+ for(int j=0;j<3;++j)
+ jump_[j].setBounds(controlX+156+j*74,17,69,27);
+ peakLabel_.setBounds(5,352,39,20);
+ }
+private:
+ static juce::Font inter(float size) {return juce::Font("Inter",size,juce::Font::plain);}
+ class EqSkin final : public juce::LookAndFeel_V4 {
+ public:
+ EqSkin() {
+#if defined(ARMIX_GEQ31_VECTOR_ASSET) && ARMIX_GEQ31_VECTOR_ASSET
+ originalSvg_=juce::String::fromUTF8(BinaryData::slider_eq_grp_svg,
+ static_cast(BinaryData::slider_eq_grp_svgSize));
+#endif
+ lastGain_.fill(std::numeric_limits::quiet_NaN());
+ thumbGroups_.fill(nullptr);
+ setColour(juce::TextButton::buttonColourId,juce::Colour::fromRGB(231,237,237));
+ setColour(juce::TextButton::textColourOffId,juce::Colour::fromRGB(65,77,79));
+ }
+ juce::Font getTextButtonFont(juce::TextButton&,int) override {
+ return GraphicEq31Editor::inter(11.f);
+ }
+ juce::Font getLabelFont(juce::Label&) override {
+ return GraphicEq31Editor::inter(11.f);
+ }
+ void drawLinearSlider(juce::Graphics& g,int x,int y,int width,int height,
+ float,float,float,juce::Slider::SliderStyle,
+ juce::Slider& slider) override {
+ const auto id=slider.getComponentID();
+ if(!id.startsWith("geq31-band-"))return;
+ const int index=id.fromFirstOccurrenceOf("geq31-band-",false,false).getIntValue();
+ if(index<0||index>=static_cast(GraphicEq31Core::bandCount))return;
+ const auto band=static_cast(index);
+ if(!drawables_[band])createBandArtwork(band);
+ if(auto* art=drawables_[band].get()) {
+ const auto gain=static_cast(slider.getValue());
+ if(lastGain_[band]!=gain&&thumbGroups_[band]!=nullptr) {
+ const float shift=-560.f*juce::jlimit(-12.f,12.f,gain)/12.f;
+ thumbGroups_[band]->setTransform(juce::AffineTransform::translation(0.f, shift));
+ lastGain_[band]=gain;
+ }
+ // 50px columns; original authored vector thumb, zero raster shadow.
+ art->drawWithin(g,{static_cast(x),static_cast(y),
+ static_cast(width),static_cast(height)},
+ juce::RectanglePlacement::stretchToFit,1.f);
+ }else {
+ g.setColour(juce::Colours::red);
+ g.drawFittedText("SVG ERROR",x,y,width,height,
+ juce::Justification::centred,2);
+ }
+ }
+ private:
+ void createBandArtwork(std::size_t band) {
+ if(originalSvg_.isEmpty())return;
+ auto document=juce::XmlDocument::parse(originalSvg_);
+ if(!document)return;
+ auto* fader=document->getChildByAttribute("id","Slider_EQ");
+ if(!fader)return;
+ // Crop only empty source margins for readable track geometry.
+ document->setAttribute("viewBox","60 0 352 2042");
+ auto* labelGroup=fader->getChildByAttribute("id","Text");
+ auto* thumbGroup=fader->getChildByAttribute("id","THUMB");
+ if(!labelGroup||!thumbGroup)return;
+ auto* frequency=labelGroup->getChildByAttribute("id","32");
+ auto* tspan=frequency?frequency->getFirstChildElement():nullptr;
+ if(!tspan)return;
+ tspan->deleteAllTextElements();
+ tspan->addTextElement(juce::String(graphicEq31Labels[band]));
+ // Override the authored Arial class at render time, preserving
+ // the source asset and all original SVG layers byte-for-byte.
+ tspan->setAttribute("style","font-family: Inter; font-size: "+
+ juce::String(juce::String(graphicEq31Labels[band]).length()>3?22:28)+"px");
+ frequency->setAttribute("text-anchor","middle");
+ frequency->setAttribute("style",
+ "transform: matrix(5.4,0,0,4.167,237.76,1850.466); font-family: Inter");
+ // Preserve the original SVG bytes. On this temporary UI clone:
+ // hide redundant 31x "Hz" and the bitmap duplicate shadow.
+ if(auto* hz=labelGroup->getChildByAttribute("id","Hz"))
+ labelGroup->removeChildElement(hz,true);
+ auto* bitmapWrapper=thumbGroup->getFirstChildElement();
+ if(bitmapWrapper&&bitmapWrapper->getChildByAttribute("id","_Image3"))
+ thumbGroup->removeChildElement(bitmapWrapper,true);
+ auto drawable=juce::Drawable::createFromSVG(*document);
+ if(!drawable)return;
+ auto* authoredFader=drawable->findChildWithID("Slider_EQ");
+ auto* authoredThumb=authoredFader?authoredFader->findChildWithID("THUMB"):nullptr;
+ if(!authoredThumb)return;
+ thumbGroups_[band]=authoredThumb;
+ drawables_[band]=std::move(drawable);
+ }
+ juce::String originalSvg_;
+ std::array,GraphicEq31Core::bandCount> drawables_{};
+ std::array thumbGroups_{};
+ std::array lastGain_{};
+ };
+
+ void timerCallback() override {
+ const bool clip=processor_.observedPeak()>=.999f;
+ peakLabel_.setText(clip?"CLIP":"",juce::dontSendNotification);
+ peakLabel_.setColour(juce::Label::textColourId,
+ clip?juce::Colour::fromRGB(226,78,58):
+ juce::Colour::fromRGB(55,158,136));
+ }
+ using Attachment=juce::AudioProcessorValueTreeState::SliderAttachment;
+ static constexpr int bandCellWidth=50;
+ GraphicEq31Processor& processor_;
+ EqSkin skin_;
+ juce::Component bandSurface_;
+ juce::Viewport viewport_;
+ std::array sliders_;
+ std::vector> attachments_;
+ juce::TextButton flat_,smile_;
+ std::array jump_;
+ juce::Label peakLabel_;
+};
+inline juce::AudioProcessorEditor* GraphicEq31Processor::createEditor() {
+ return new GraphicEq31Editor(*this);
+}
+} // namespace armix::builtin_fx
diff --git a/src/NativeBuiltInFx.h b/src/NativeBuiltInFx.h
index b03a5ac4b..fd5429807 100644
--- a/src/NativeBuiltInFx.h
+++ b/src/NativeBuiltInFx.h
@@ -3,6 +3,7 @@
#include "../engine/builtin_fx/ChannelEqProcessor.h"
#include "../engine/builtin_fx/ChannelCompressorProcessor.h"
+#include "../engine/builtin_fx/GraphicEq31Processor.h"
#include "../engine/builtin_fx/ChannelHarmonyProcessor.h"
#include "../engine/builtin_fx/VocalThrowProcessor.h"
#include "../engine/builtin_fx/GuitarRigEditor.h"
@@ -66,6 +67,11 @@ inline constexpr std::array nativeBuiltInFx{
"NATIVE_EQ_UNSUPPORTED_AUDIO_FORMAT","NATIVE_EQ_PREPARE_REJECTED",
"NATIVE_EQ_PREPARE_EXCEPTION","Saved native EQ state rejected; graph unchanged",
prepareNativeBuiltInFx},
+ NativeBuiltInFx{GraphicEq31Processor::catalogIdentity,"Graphic EQ 31","EQ",true,8000.,384000.,
+ "NATIVE_GEQ31_HOST_UNAVAILABLE","NATIVE_GEQ31_DEVICE_CHANGED",
+ "NATIVE_GEQ31_UNSUPPORTED_AUDIO_FORMAT","NATIVE_GEQ31_PREPARE_REJECTED",
+ "NATIVE_GEQ31_PREPARE_EXCEPTION","Saved Graphic EQ 31 state rejected; graph unchanged",
+ prepareNativeBuiltInFx},
NativeBuiltInFx{ChannelCompressorProcessor::catalogIdentity,"Compressor","Dynamics",true,8000.,384000.,
"NATIVE_COMP_HOST_UNAVAILABLE","NATIVE_COMP_DEVICE_CHANGED",
"NATIVE_COMP_UNSUPPORTED_AUDIO_FORMAT","NATIVE_COMP_PREPARE_REJECTED",
diff --git a/tests/graphic_eq31_core_test.cpp b/tests/graphic_eq31_core_test.cpp
new file mode 100644
index 000000000..1874afaaa
--- /dev/null
+++ b/tests/graphic_eq31_core_test.cpp
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+#include "../engine/builtin_fx/GraphicEq31Core.h"
+#include
+#include
+#include
+
+// Keep verification active in Release builds (NDEBUG disables assert).
+// Side-effecting setup must always execute in the Windows CI configuration.
+#define GEQ_CHECK(expr) do { \
+ if (!(expr)) { \
+ std::fprintf(stderr, "Graphic EQ 31 FAILED: %s (%s:%d)\n", \
+ #expr, __FILE__, __LINE__); \
+ std::abort(); \
+ } \
+} while (false)
+#include
+#include
+#include
+#include
+
+using armix::builtin_fx::GraphicEq31Core;
+using armix::builtin_fx::graphicEq31Hz;
+
+static double rms(const std::vector& x,std::size_t from) {
+ double energy=0.;
+ for(std::size_t i=from;i(x[i])*x[i];
+ return std::sqrt(energy/static_cast(x.size()-from));
+}
+static double responseDb(std::size_t band,double gain,double toneHz,int rate) {
+ GraphicEq31Core eq;
+ GEQ_CHECK(eq.prepare(rate));
+ GEQ_CHECK(eq.setGain(band,gain));
+ constexpr std::size_t count=96000;
+ std::vector left(count),right(count);
+ for(std::size_t i=0;i(std::sin(
+ 6.2831853071795864769*toneHz*i/static_cast(rate)));
+ left[i]=right[i]=sample;
+ }
+ const double dry=rms(left,count/2);
+ for(std::size_t i=0;i(97,count-i));
+ const double wet=rms(left,count/2);
+ return 20.*std::log10(wet/dry);
+}
+int main() {
+ static_assert(GraphicEq31Core::bandCount==31);
+ for(std::size_t i=1;igraphicEq31Hz[i-1]);
+ GEQ_CHECK(graphicEq31Hz.front()==20.);
+ GEQ_CHECK(graphicEq31Hz.back()==20000.);
+ GraphicEq31Core eq;
+ GEQ_CHECK(!eq.prepare(std::numeric_limits::quiet_NaN()));
+ GEQ_CHECK(!eq.prepare(7999.));
+ GEQ_CHECK(!eq.prepare(384001.));
+ GEQ_CHECK(eq.prepare(48000.));
+ // Flat fast path must be bit-exact for both channels, including after
+ // moving a previously active band back to 0 dB.
+ {
+ std::array unchangedL{},unchangedR{};
+ for(std::size_t i=0;i<64;++i) {
+ unchangedL[i]=static_cast(i)*0.001f;
+ unchangedR[i]=-unchangedL[i];
+ }
+ const auto referenceL=unchangedL,referenceR=unchangedR;
+ eq.processStereo(unchangedL.data(),unchangedR.data(),64);
+ GEQ_CHECK(unchangedL==referenceL && unchangedR==referenceR);
+ }
+ GEQ_CHECK(!eq.setGain(31,3.));
+ GEQ_CHECK(!eq.setGain(1,13.));
+ GEQ_CHECK(!eq.setGain(1,-13.));
+ GEQ_CHECK(!eq.setGain(1,std::numeric_limits::infinity()));
+ GEQ_CHECK(eq.setGain(17,6.));
+ GEQ_CHECK(std::fabs(eq.gainDb(17)-6.)<1e-8);
+ GEQ_CHECK(responseDb(17,6.,1000.,48000)>5.4);
+ GEQ_CHECK(responseDb(17,-6.,1000.,48000)<-5.4);
+ GEQ_CHECK(std::fabs(responseDb(17,6.,200.,48000))<.6);
+ // Stereo isolation: a silent right channel must remain silent.
+ std::array l{},r{};
+ l[0]=.5f;
+ for(int i=0;i<100;++i) {
+ eq.processStereo(l.data(),r.data(),l.size());
+ for(auto s:r)GEQ_CHECK(s==0.f);
+ for(auto s:l)GEQ_CHECK(std::isfinite(s));
+ l.fill(0.f);
+ }
+ // Low sample rate: out-of-Nyquist bands must be safely transparent.
+ GraphicEq31Core low;
+ GEQ_CHECK(low.setGain(30,12.));
+ GEQ_CHECK(low.prepare(8000.));
+ std::array ll{},rr{};
+ ll[0]=rr[0]=.25f;
+ low.processStereo(ll.data(),rr.data(),ll.size());
+ GEQ_CHECK(std::fabs(ll[0]-.25f)<1e-6f);
+ for(std::size_t i=1;i((iteration%255)+1));
+ for(auto s:l)GEQ_CHECK(std::isfinite(s));
+ for(auto s:r)GEQ_CHECK(std::isfinite(s));
+ }
+ std::puts("Graphic EQ 31 core: frequencies, response, stereo isolation, Nyquist, stress PASS");
+}
diff --git a/tests/graphic_eq31_svg_layers_test.py b/tests/graphic_eq31_svg_layers_test.py
new file mode 100644
index 000000000..b006c2348
--- /dev/null
+++ b/tests/graphic_eq31_svg_layers_test.py
@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: AGPL-3.0-only
+"""Release-gate contract: GEQ31 must use the owner's ORIGINAL grouped SVG.
+
+Not an audio/ASIO test. This deliberately prevents future visual rewrites that
+silently flatten THUMB, paint JUCE substitutes or discard the embedded artwork.
+"""
+from pathlib import Path
+import hashlib
+import unittest
+import xml.etree.ElementTree as ET
+
+ROOT = Path(__file__).resolve().parents[1]
+SVG = ROOT / 'assets/fx/graphic-eq31/slider_eq_grp.svg'
+PROCESSOR = ROOT / 'engine/builtin_fx/GraphicEq31Processor.h'
+KNOB = ROOT / 'assets/fx/graphic-eq31/KNOB-EQ.svg'
+CMAKE = ROOT / 'CMakeLists.txt'
+EXPECTED_SHA256 = 'aeaf02b8904a667724f34774a692da39a5a466bae302611f347fae4d9fd14dba'
+KNOB_SHA256 = '754b3d525be1d4dcbe26fdca1d6bedc5b67e2d2436efec2aa9265ad86c5aad80'
+SVGNS = {'s': 'http://www.w3.org/2000/svg'}
+
+class OwnerOriginalSvgLayersTests(unittest.TestCase):
+ @classmethod
+ def setUpClass(cls):
+ cls.raw = SVG.read_bytes()
+ cls.svg = ET.fromstring(cls.raw)
+ cls.native = PROCESSOR.read_text(encoding='utf-8')
+ cls.cmake = CMAKE.read_text(encoding='utf-8')
+
+ def test_exact_owner_artwork_and_named_groups(self):
+ self.assertEqual(hashlib.sha256(self.raw).hexdigest(), EXPECTED_SHA256)
+ self.assertEqual(self.svg.attrib['viewBox'], '0 0 469 2042')
+ fader = self.svg.find("./s:g[@id='Slider_EQ']", SVGNS)
+ self.assertIsNotNone(fader)
+ self.assertEqual([child.get('id') for child in fader], ['Track', 'Text', 'THUMB'])
+ self.assertGreaterEqual(len(fader.find("./s:g[@id='Track']", SVGNS)), 6)
+ self.assertIsNotNone(fader.find("./s:g[@id='Text']/s:text[@id='32']/s:tspan", SVGNS))
+ self.assertIsNotNone(fader.find("./s:g[@id='Text']/s:g[@id='Hz']", SVGNS))
+ self.assertIsNotNone(fader.find("./s:g[@id='THUMB']//s:use[@id='_Image3']", SVGNS))
+ embedded = self.svg.find("./s:defs/s:image[@id='img1']", SVGNS)
+ self.assertTrue(embedded.get('href', '').startswith('data:image/png;base64,'))
+
+ def test_exact_svg_is_production_embedded_source(self):
+ self.assertIn('assets/fx/graphic-eq31/slider_eq_grp.svg', self.cmake)
+ self.assertNotIn('assets/fx/graphic-eq31/slider_eq_vector.svgz', self.cmake)
+ self.assertIn('BinaryData::slider_eq_grp_svg', self.native)
+ self.assertIn('getChildByAttribute("id", "Text")', self.native)
+ self.assertIn('getChildByAttribute("id", "THUMB")', self.native)
+ self.assertIn('tspan->addTextElement(juce::String(graphicEq31Labels[band]))', self.native)
+ self.assertIn('thumbGroups_[band]->setTransform(juce::AffineTransform::translation(0.f, shift))', self.native)
+ self.assertIn('authoredFader->findChildWithID("THUMB")', self.native)
+ self.assertIn('juce::Drawable::createFromSVG(*document)', self.native)
+ self.assertIn('juce::Viewport viewport_', self.native)
+ self.assertIn('std::array sliders_', self.native)
+ self.assertNotIn('fillRoundedRectangle(cx-thumbWidth', self.native)
+
+ def test_readable_50px_zero_shadow_band_only_policy(self):
+ # Original owner asset remains untouched, but the duplicated raster
+ # shadow is omitted from the UI clone; vector THUMB stays authentic.
+ self.assertIn('document->setAttribute("viewBox","60 0 352 2042")', self.native)
+ self.assertIn('bitmapWrapper->getChildByAttribute("id","_Image3")', self.native)
+ self.assertIn('thumbGroup->removeChildElement(bitmapWrapper,true)', self.native)
+ self.assertIn('labelGroup->removeChildElement(hz,true)', self.native)
+ self.assertIn('static constexpr int bandCellWidth=50', self.native)
+ self.assertIn('setSize(1610,391)', self.native)
+ self.assertIn('font-family: Inter', self.native)
+ self.assertIn('return juce::Font("Inter",size,juce::Font::plain)', self.native)
+ self.assertNotIn('BinaryData::KNOB_EQ_svg', self.native)
+ self.assertNotIn('drawRotarySlider(', self.native)
+ self.assertNotIn('input_.setBounds', self.native)
+ self.assertNotIn('getRawParameterValue("inputDb")', self.native)
+ self.assertNotIn('getRawParameterValue("outputDb")', self.native)
+ self.assertNotIn('inputSmooth_', self.native)
+ self.assertNotIn('outputSmooth_', self.native)
+ self.assertIn('out.writeInt(stateMagic);out.writeInt(3);', self.native)
+ self.assertIn('const auto obsoleteTrim=input.readFloat();', self.native)
+ self.assertNotIn('assets/fx/graphic-eq31/KNOB-EQ.svg', self.cmake)
+
+ def test_thumb_travel_stays_inside_owner_viewbox(self):
+ # Authored thumb bounds from original 469x2042 grouped SVG:
+ # top ~721, bottom ~1139. Positive boost moves original group up.
+ for gain in [-12., -6., 0., 6., 12.]:
+ shift = -560 * gain / 12
+ self.assertGreaterEqual(721 + shift, 0)
+ self.assertLessEqual(1139 + shift, 2042)
+
+if __name__ == '__main__':
+ unittest.main()
\ No newline at end of file
diff --git a/tests/native_fx_registry_extension_test.cpp b/tests/native_fx_registry_extension_test.cpp
index 3e3dbde77..99d676595 100644
--- a/tests/native_fx_registry_extension_test.cpp
+++ b/tests/native_fx_registry_extension_test.cpp
@@ -420,7 +420,83 @@ static void verifyFirstSoundGuitarProcessor() {
static_cast(snapshot.getSize())));
}
+
+static void verifyGraphicEq31Processor() {
+ const auto* descriptor=armix::builtin_fx::findNativeBuiltInFx(
+ armix::builtin_fx::GraphicEq31Processor::catalogIdentity);
+ assert(descriptor && descriptor->showInPicker);
+ assert(juce::String(descriptor->name)=="Graphic EQ 31");
+ auto processor=descriptor->prepare(48000.,128,nullptr,0);
+ assert(processor && processor->getLatencySamples()==0);
+ auto* geq=dynamic_cast(processor.get());
+ assert(geq && geq->isReady());
+ geq->setBandFromUi(17,6.f);
+ juce::MemoryBlock state;
+ processor->getStateInformation(state);
+ assert(state.getSize()==8u+31u*4u); // GEQ1 v3, no hidden gain
+ assert(geq->parameters().getParameter("inputDb")==nullptr);
+ assert(geq->parameters().getParameter("outputDb")==nullptr);
+ // Both historic state schemas must restore without reactivating obsolete
+ // gain. Each legacy trim is fully validated, never applied to PCM.
+ auto makeLegacy=[&](int version) {
+ juce::MemoryBlock legacy;
+ juce::MemoryOutputStream out(legacy,false);
+ out.writeInt(armix::builtin_fx::GraphicEq31Processor::stateMagic);
+ out.writeInt(version);
+ out.write(static_cast(state.getData())+8,state.getSize()-8);
+ out.writeFloat(6.5f); // old inputDb
+ if(version==1)out.writeFloat(9.5f); // old outputDb
+ return legacy;
+ };
+ for(int version:{1,2}) {
+ auto legacy=makeLegacy(version);
+ assert(legacy.getSize()==8u+31u*4u+(version==1?8u:4u));
+ auto migrated=descriptor->prepare(48000.,128,
+ legacy.getData(),static_cast(legacy.getSize()));
+ assert(migrated);
+ juce::MemoryBlock converted;
+ migrated->getStateInformation(converted);
+ assert(converted==state);
+ auto badLegacy=legacy;
+ const float badTrim=std::numeric_limits::quiet_NaN();
+ std::memcpy(static_cast(badLegacy.getData())+8+31*4,
+ &badTrim,sizeof(badTrim));
+ assert(!descriptor->prepare(48000.,128,badLegacy.getData(),
+ static_cast(badLegacy.getSize())));
+ if(version==1) {
+ auto badOutput=legacy;
+ std::memcpy(static_cast(badOutput.getData())+8+32*4,
+ &badTrim,sizeof(badTrim));
+ assert(!descriptor->prepare(48000.,128,badOutput.getData(),
+ static_cast(badOutput.getSize())));
+ }
+ }
+ auto restored=descriptor->prepare(44100.,256,
+ state.getData(),static_cast(state.getSize()));
+ assert(restored && restored->getName()=="Graphic EQ 31");
+ juce::MemoryBlock roundtrip;
+ restored->getStateInformation(roundtrip);
+ assert(roundtrip==state);
+ juce::AudioBuffer pcm(2,256);
+ pcm.clear();pcm.setSample(0,0,.5f);pcm.setSample(1,0,-.5f);
+ juce::MidiBuffer midi;
+ processor->processBlock(pcm,midi);
+ for(int ch=0;ch<2;++ch)
+ for(int n=0;nprepare(48000.,128,malformed.getData(),
+ static_cast(malformed.getSize())));
+ assert(!descriptor->prepare(48000.,128,state.getData(),
+ static_cast(state.getSize()-1)));
+ geq->sealForRealtime();
+ assert(!geq->restoreUnpublishedState(state.getData(),
+ static_cast(state.getSize())));
+}
+
int main() {
+ verifyGraphicEq31Processor();
verifySharedNativeFxControlRequest();
verifyFirstSoundGuitarProcessor();
const auto* found=findNativeBuiltInFxIn(injected,"armix.test.fixture-gain.v1");
diff --git a/web/approved-native-bridge.js b/web/approved-native-bridge.js
index 109d16152..e97352736 100644
--- a/web/approved-native-bridge.js
+++ b/web/approved-native-bridge.js
@@ -1379,6 +1379,8 @@
let nativeBuiltins=Object.freeze([
Object.freeze({id:"armix.builtin.channel-eq.v1",name:"Parametric EQ",
vendor:"ArSonMix",category:"EQ",format:"Native",source:"builtin"}),
+ Object.freeze({id:"armix.builtin.graphic-eq31.v1",name:"Graphic EQ 31",
+ vendor:"ArSonMix",category:"EQ",format:"Native",source:"builtin"}),
Object.freeze({id:"armix.builtin.channel-compressor.v1",name:"Compressor",
vendor:"ArSonMix",category:"Dynamics",format:"Native",source:"builtin"}),
Object.freeze({id:"armix.builtin.arson-harmony.v1",name:"Harmonice",