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 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 32 + + + + + Hz + + + + + + + + + + + + + + + + + + + \ 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",