From 4b8e6ec40e9ae378d999cbad29bd11ec1a2018b7 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:39:39 +0700 Subject: [PATCH 01/14] feat(sonku): bounded room-aware musical FDN profiles with original presets locked --- engine/builtin_fx/sonku/SonKuMusicalReverb.h | 42 ++++++++++++++++++-- 1 file changed, 38 insertions(+), 4 deletions(-) diff --git a/engine/builtin_fx/sonku/SonKuMusicalReverb.h b/engine/builtin_fx/sonku/SonKuMusicalReverb.h index f9775aad6..5396f5e2c 100644 --- a/engine/builtin_fx/sonku/SonKuMusicalReverb.h +++ b/engine/builtin_fx/sonku/SonKuMusicalReverb.h @@ -12,7 +12,32 @@ // reflections; no source-following stereo pan is imposed on the reverb tail. // These listening-test presets are OFF in the shipping JUCE editor. namespace armix::sonku { -enum class SonKuReverbPreset : std::uint8_t { StudioGlue=0, AiryChamber=1 }; +enum class SonKuReverbPreset : std::uint8_t { + StudioGlue=0, AiryChamber=1, SpaciousChamber=2, LargeAuditorium=3 +}; +// Control-side room scale policy: explicit, predictable candidates rather +// than making RT60 linearly proportional to room dimensions (which sounds +// unnaturally hollow and rings). No physically calibrated hall claim. +struct SonKuRoomAmbience { + SonKuReverbPreset preset=SonKuReverbPreset::StudioGlue; + float wet=0.f; +}; +inline SonKuRoomAmbience musicalAmbienceForRoom( + float widthMeters,float depthMeters,float distanceMeters) noexcept { + if(!std::isfinite(widthMeters)||!std::isfinite(depthMeters)|| + !std::isfinite(distanceMeters)||widthMeters<5.f|| + depthMeters<5.f||widthMeters>40.f||depthMeters>40.f|| + distanceMeters<1.6f||distanceMeters>10.f|| + 2.f*(distanceMeters+.5f)>std::min(widthMeters,depthMeters)) + return {}; // Safe OFF, not an unbounded wet impulse. + const float span=std::sqrt(widthMeters*depthMeters); + const float distanceScale=std::clamp(1.6f/distanceMeters,.16f,1.f); + // Smaller distant-source input must not suddenly exaggerate late tails. + const float wet=.26f+.12f*std::sqrt(distanceScale); + if(span<10.f)return {SonKuReverbPreset::StudioGlue,wet}; + if(span<20.f)return {SonKuReverbPreset::SpaciousChamber,wet}; + return {SonKuReverbPreset::LargeAuditorium,wet}; +} class SonKuMusicalReverb final { public: @@ -47,7 +72,9 @@ class SonKuMusicalReverb final { } bool setPreset(SonKuReverbPreset value) noexcept { if(value!=SonKuReverbPreset::StudioGlue && - value!=SonKuReverbPreset::AiryChamber)return false; + value!=SonKuReverbPreset::AiryChamber && + value!=SonKuReverbPreset::SpaciousChamber && + value!=SonKuReverbPreset::LargeAuditorium)return false; // Preset updates calculate RT60 coefficients. Never use this setter // on an active realtime callback; native host doesn't expose it yet. if(active())return false; @@ -109,8 +136,15 @@ class SonKuMusicalReverb final { // First late energy arrives ~44 ms: behind earliest image reflections. constexpr std::array lengths{ 2111,2339,2579,2803,3079,3319,3593,3929}; - const float rt60=preset_==SonKuReverbPreset::StudioGlue?.78f:1.28f; - const float cutoff=preset_==SonKuReverbPreset::StudioGlue?5900.f:7000.f; + // Musical tuning, not volume-derived Sabine RT60. Prepared once, + // never recomputed per sample; original two presets remain identical. + float rt60=0.78f,cutoff=5900.f; + switch(preset_) { + case SonKuReverbPreset::StudioGlue: break; + case SonKuReverbPreset::AiryChamber: rt60=1.28f;cutoff=7000.f;break; + case SonKuReverbPreset::SpaciousChamber: rt60=1.65f;cutoff=5400.f;break; + case SonKuReverbPreset::LargeAuditorium: rt60=2.20f;cutoff=4700.f;break; + } constexpr float pi=3.14159265358979323846f; dampCoeff_=1.f-std::exp(-2.f*pi*cutoff/sampleRate_); for(int i=0;i Date: Fri, 13 Nov 2026 14:40:01 +0700 Subject: [PATCH 02/14] test(sonku): room-aware presets invalid fallback, decay and finite impulses --- tests/sonku_musical_reverb_test.cpp | 32 +++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/sonku_musical_reverb_test.cpp b/tests/sonku_musical_reverb_test.cpp index 3a099734a..0bbb619a6 100644 --- a/tests/sonku_musical_reverb_test.cpp +++ b/tests/sonku_musical_reverb_test.cpp @@ -57,6 +57,38 @@ int main(){ airy+=std::abs(output.left)+std::abs(output.right); } assert(airy>.005); + // Prepared, deterministic room-aware presets; explicit old profiles + // remain unchanged and invalid/unsafe dimensions always choose OFF. + const auto bad=armix::sonku::musicalAmbienceForRoom(7.2f,7.2f,5.f); + assert(bad.wet==0.f); + const auto approved=armix::sonku::musicalAmbienceForRoom(7.2f,7.2f,1.6f); + const auto spacious=armix::sonku::musicalAmbienceForRoom(14.4f,14.4f,5.f); + const auto large=armix::sonku::musicalAmbienceForRoom(28.8f,28.8f,8.f); + assert(approved.preset==SonKuReverbPreset::StudioGlue); + assert(spacious.preset==SonKuReverbPreset::SpaciousChamber); + assert(large.preset==SonKuReverbPreset::LargeAuditorium); + assert(approved.wet>spacious.wet && spacious.wet>large.wet); + assert(large.wet>=.26f && approved.wet<=.38f); + SonKuMusicalReverb spaciousFx,largeFx; + assert(spaciousFx.prepare(rate) && largeFx.prepare(rate)); + assert(spaciousFx.setPreset(spacious.preset)); + assert(largeFx.setPreset(large.preset)); + assert(spaciousFx.setAmount(spacious.wet)); + assert(largeFx.setAmount(large.wet)); + double largeLate=0.,spaciousLate=0.; + for(int i=0;i(rate*2.8);++i) { + const float sample=i==0?.5f:0.f; + const auto x=spaciousFx.process(sample,sample); + const auto y=largeFx.process(sample,sample); + assert(std::isfinite(x.left)&&std::isfinite(x.right)); + assert(std::isfinite(y.left)&&std::isfinite(y.right)); + assert(std::abs(x.left)<1.f && std::abs(y.right)<1.f); + if(i>rate*1.8) { + spaciousLate+=std::abs(x.left)+std::abs(x.right); + largeLate+=std::abs(y.left)+std::abs(y.right); + } + } + assert(largeLate>spaciousLate*.4); } return 0; } From 2de1097381443a8abec70a95eba141f1955e0a40 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:40:52 +0700 Subject: [PATCH 03/14] feat(sonku): 2 matched room-aware ambience A/B WAVs alongside dry large-room probes --- tools/sonku_offline_listening.cpp | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/tools/sonku_offline_listening.cpp b/tools/sonku_offline_listening.cpp index 08b579f96..66a9a5ff8 100644 --- a/tools/sonku_offline_listening.cpp +++ b/tools/sonku_offline_listening.cpp @@ -257,6 +257,14 @@ void notes(const std::filesystem::path& directory, <<"tail is not calibrated for large halls (no pretend big-hall RT60).\n" <<"Not simulated: air absorption, floor/ceiling, personalized HRTF,\n" <<"direct path time-of-flight, or higher-order wall reflections.\n" + <<"V5 room-aware MUSICAL AMBIENCE candidates (still offline only):\n" + <<"sonku-v5-spacious-musical-orbit-cw-2x.wav = 14.4m/5m with\n" + <<" prepared Spacious Chamber, RT60 about 1.65s, subtle wet.\n" + <<"sonku-v5-large-musical-orbit-cw-2x.wav = 28.8m/8m with\n" + <<" prepared Large Auditorium, RT60 about 2.2s, subtle wet.\n" + <<"Compare the corresponding V4 room/distance file with FDN OFF;\n" + <<"no existing accepted Square file or public GUI has changed.\n" + <<"These are art-directed ambience, NOT calibrated room physics.\n" <<"Offline candidates only, NO native GUI/session/product release.\n"; std::ofstream key(directory/"BLIND-ANSWER-KEY.txt"); if(!key)throw std::runtime_error("Cannot write blind answer key"); @@ -323,6 +331,21 @@ int main(int argc,char** argv){ orbit(.55f,SonKuRoomShape::Square,true,0.f, SonKuReverbPreset::StudioGlue, SonKuRoomGeometry{28.8f,28.8f,8.f})); + // M4 uses room-scale profile for prepared FDN only. It does not + // change existing v1-v4 WAVs, any live/native GUI parameter or the + // owner-approved Square HRTF/early-reflection footprint. + const SonKuRoomGeometry spacious{14.4f,14.4f,5.f}; + const SonKuRoomGeometry large{28.8f,28.8f,8.f}; + const auto spaciousProfile=armix::sonku::musicalAmbienceForRoom( + spacious.widthMeters,spacious.depthMeters,spacious.distanceMeters); + const auto largeProfile=armix::sonku::musicalAmbienceForRoom( + large.widthMeters,large.depthMeters,large.distanceMeters); + writeWav(dir/"sonku-v5-spacious-musical-orbit-cw-2x.wav", + orbit(.55f,SonKuRoomShape::Square,true,spaciousProfile.wet, + spaciousProfile.preset,spacious)); + writeWav(dir/"sonku-v5-large-musical-orbit-cw-2x.wav", + orbit(.55f,SonKuRoomShape::Square,true,largeProfile.wet, + largeProfile.preset,large)); notes(dir,blind); std::cout<<"SonKu listening package PASS: measured native HRTF, " <<"4 labeled + 8 blind directions + two uninterrupted 360 turns\n"; From 04e665b62ea3d9fc9f5fc4db8c2bb0c2b4bad974 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:41:22 +0700 Subject: [PATCH 04/14] test(sonku): verify room-aware FDN matched-source WAV and seamless orbit --- tests/sonku_offline_demo_contract.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/tests/sonku_offline_demo_contract.py b/tests/sonku_offline_demo_contract.py index 7a9bb4842..abd698e2b 100644 --- a/tests/sonku_offline_demo_contract.py +++ b/tests/sonku_offline_demo_contract.py @@ -39,6 +39,8 @@ def read(name, frames, minimum_peak=250, minimum_energy=100000): spaciousFar=read("sonku-v4-spacious-far-orbit-cw-2x.wav",960000,60,10000) largeNear=read("sonku-v4-large-near-orbit-cw-2x.wav",960000) largeFar=read("sonku-v4-large-far-orbit-cw-2x.wav",960000,40,8000) +spaciousMusical=read("sonku-v5-spacious-musical-orbit-cw-2x.wav",960000,40,8000) +largeMusical=read("sonku-v5-large-musical-orbit-cw-2x.wav",960000,30,7000) # Same source and identical 20s orbital clock: room width only changes # path delay/level; source distance only changes geometric pressure. def pcm_delta(a,b): @@ -47,6 +49,10 @@ def pcm_delta(a,b): assert pcm_delta(largeNear,spaciousNear)>1500,"Large and spacious room are identical" assert pcm_delta(spaciousFar,spaciousNear)>1500,"5m source ignored" assert pcm_delta(largeFar,largeNear)>1500,"8m source ignored" +# In V5 the dry and wet candidates retain identical geometry/source and +# differ only by the prepared late FDN, rather than a louder artificial hall. +assert pcm_delta(spaciousMusical,spaciousFar)>700,"Spacious ambience inaudible in PCM" +assert pcm_delta(largeMusical,largeFar)>700,"Large ambience inaudible in PCM" def energy(a): return sum(abs(int(x)) for x in a[300000:440000]) assert .08400,( From c0ee2604faf2e8c61729ff56a4177e6560ed3333 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:43:14 +0700 Subject: [PATCH 05/14] fix(sonku): callback-safe O(1) room and FDN rearm with age-masked delay rings --- engine/builtin_fx/sonku/SonKuEarlyReflections.h | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/engine/builtin_fx/sonku/SonKuEarlyReflections.h b/engine/builtin_fx/sonku/SonKuEarlyReflections.h index 25c40be4f..5d78ee302 100644 --- a/engine/builtin_fx/sonku/SonKuEarlyReflections.h +++ b/engine/builtin_fx/sonku/SonKuEarlyReflections.h @@ -43,14 +43,20 @@ class SonKuEarlyReflections final { lowpass_.fill(0.f); for(auto& paths:tap_)for(auto& p:paths)p=Tap{}; write_=0;untilGeometry_=0;primed_=false; - amount_=0.f; + activeFrames_=0;amount_=0.f; } // Deliberately experimental and OFF by default. Legacy 8/8 direction // baseline stays bit-identical. A/B is set on an unpublished/offline core // until headphone, CPU and device gates approve native publication. bool setAmount(float value) noexcept { if(!std::isfinite(value)||value<0.f||value>1.f)return false; - if(amountTarget_==0.f&&amount_==0.f&&value>0.f)reset(); + // O(1) activation: never clear the 2x8192 history on an audio + // callback. Mask all reads until they belong to this activation. + if(amountTarget_==0.f&&amount_==0.f&&value>0.f) { + lowpass_.fill(0.f); + for(auto& paths:tap_)for(auto& p:paths)p=Tap{}; + write_=0;untilGeometry_=0;primed_=false;activeFrames_=0; + } amountTarget_=value; return true; } @@ -127,6 +133,7 @@ class SonKuEarlyReflections final { } } write_=(write_+1)&(ringFrames-1); + if(activeFrames_(integer); const int i0=(write_-integer)&(ringFrames-1); const int i1=(i0-1)&(ringFrames-1); - return history_[source][i0]*(1.f-fract)+history_[source][i1]*fract; + const float newer=activeFrames_>=integer ?history_[source][i0]:0.f; + const float older=activeFrames_>integer ?history_[source][i1]:0.f; + return newer*(1.f-fract)+older*fract; } void updateGeometry(double azimuth,float spread) noexcept { constexpr float pi=3.14159265358979323846f; @@ -210,7 +219,7 @@ class SonKuEarlyReflections final { std::array lowpass_{}; float rate_=0.f,delaySlew_=0.f,gainSlew_=0.f,amountSlew_=0.f; float amount_=0.f,amountTarget_=0.f; - int write_=0,untilGeometry_=0; + int write_=0,untilGeometry_=0,activeFrames_=0; SonKuRoomShape shape_=SonKuRoomShape::Rectangular; SonKuRoomGeometry geometry_{}; bool custom_=false,ready_=false,primed_=false; From 39468f6b347104ff0ab4c1d01ffd932024d569a1 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:43:16 +0700 Subject: [PATCH 06/14] fix(sonku): callback-safe O(1) room and FDN rearm with age-masked delay rings --- engine/builtin_fx/sonku/SonKuMusicalReverb.h | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/engine/builtin_fx/sonku/SonKuMusicalReverb.h b/engine/builtin_fx/sonku/SonKuMusicalReverb.h index 5396f5e2c..4cee33c40 100644 --- a/engine/builtin_fx/sonku/SonKuMusicalReverb.h +++ b/engine/builtin_fx/sonku/SonKuMusicalReverb.h @@ -60,13 +60,17 @@ class SonKuMusicalReverb final { void reset() noexcept { for(auto& line:memory_)line.fill(0.f); lowpass_.fill(0.f); - write_=0;amount_=0.f; + write_=0;activeFrames_=0;amount_=0.f; // The target amount is a CONTROL-side setting and survives resetting // host transport/processor so the same program can restart cleanly. } bool setAmount(float amount) noexcept { if(!std::isfinite(amount) || amount<0.f || amount>1.f)return false; - if(amount_==0.f && amountTarget_==0.f && amount>0.f)reset(); + // O(1) safe realtime rearm: no 128KiB ring clear. Delayed + // reads are masked until new post-rearm samples fill their tap. + if(amount_==0.f && amountTarget_==0.f && amount>0.f) { + lowpass_.fill(0.f);write_=0;activeFrames_=0; + } amountTarget_=amount; return true; } @@ -94,7 +98,8 @@ class SonKuMusicalReverb final { std::array y{},mix{}; for(int i=0;i=delay_[i]? + memory_[i][index]:0.f; lowpass_[i]+=dampCoeff_*(sample-lowpass_[i]); y[i]=sample; mix[i]=lowpass_[i]*gain_[i]; @@ -123,6 +128,7 @@ class SonKuMusicalReverb final { (mid*inMid[i]+side*inSide[i]); } write_=(write_+1)&(ringFrames-1); + if(activeFrames_ delay_{}; float sampleRate_=48000.f,dampCoeff_=0.f,slew_=0.f; float amount_=0.f,amountTarget_=0.f; - int write_=0; + int write_=0,activeFrames_=0; SonKuReverbPreset preset_=SonKuReverbPreset::StudioGlue; bool ready_=false; }; From b413774ba4216204efe486856f8af02aba8f6e08 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:43:34 +0700 Subject: [PATCH 07/14] feat(sonku): typed default-OFF Square reflections and ambience PCM amounts --- engine/builtin_fx/sonku/SonKuSpatialCore.h | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/engine/builtin_fx/sonku/SonKuSpatialCore.h b/engine/builtin_fx/sonku/SonKuSpatialCore.h index 6f0073ac0..9fe6ee9d9 100644 --- a/engine/builtin_fx/sonku/SonKuSpatialCore.h +++ b/engine/builtin_fx/sonku/SonKuSpatialCore.h @@ -21,6 +21,8 @@ struct Settings { float outputTrim = 0.75f; // avoid summing two uncorrelated emitters at unity bool moving = true; bool clockwise = true; + float roomAmount = 0.f; // default native ROOM OFF + float ambienceAmount = 0.f; // default native late FDN OFF }; inline bool valid(const Settings& s) noexcept { return std::isfinite(s.startAzimuthDegrees) && @@ -30,7 +32,9 @@ inline bool valid(const Settings& s) noexcept { std::isfinite(s.stereoSpreadDegrees) && s.stereoSpreadDegrees>=0.f && s.stereoSpreadDegrees<=180.f && std::isfinite(s.spatialMix) && s.spatialMix>=0.f && s.spatialMix<=1.f && - std::isfinite(s.outputTrim) && s.outputTrim>=0.f && s.outputTrim<=1.f; + std::isfinite(s.outputTrim) && s.outputTrim>=0.f && s.outputTrim<=1.f && + std::isfinite(s.roomAmount) && s.roomAmount>=0.f && s.roomAmount<=1.f && + std::isfinite(s.ambienceAmount) && s.ambienceAmount>=0.f && s.ambienceAmount<=1.f; } inline double wrapDegrees(double degrees) noexcept { degrees=std::fmod(degrees,360.0); @@ -75,6 +79,13 @@ class SonKuSpatialCore final { if(!s.moving || !settings_.moving || s.startAzimuthDegrees!=settings_.startAzimuthDegrees) degrees_=wrapDegrees(s.startAzimuthDegrees); + // Room geometry is the approved Square for the native SPACE + // controls. Custom offline M3 geometry is not altered by these + // native parameters. Both wet setters are O(1), including rearm. + if(s.roomAmount>0.f && !room_.active() && + !room_.setShape(SonKuRoomShape::Square))return false; + if(!room_.setAmount(s.roomAmount) || + !reverb_.setAmount(s.ambienceAmount))return false; settings_=s; remaining_=0; return true; From 8d00952f6938a8d3bb549fe56bdfe100bfd1453f Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:43:53 +0700 Subject: [PATCH 08/14] fix(sonku): preserve offline room/FDN A/B state when motion settings remain legacy --- engine/builtin_fx/sonku/SonKuSpatialCore.h | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/engine/builtin_fx/sonku/SonKuSpatialCore.h b/engine/builtin_fx/sonku/SonKuSpatialCore.h index 9fe6ee9d9..3024d7223 100644 --- a/engine/builtin_fx/sonku/SonKuSpatialCore.h +++ b/engine/builtin_fx/sonku/SonKuSpatialCore.h @@ -82,9 +82,15 @@ class SonKuSpatialCore final { // Room geometry is the approved Square for the native SPACE // controls. Custom offline M3 geometry is not altered by these // native parameters. Both wet setters are O(1), including rearm. - if(s.roomAmount>0.f && !room_.active() && - !room_.setShape(SonKuRoomShape::Square))return false; - if(!room_.setAmount(s.roomAmount) || + // Do not overwrite already-configured offline acoustic trials + // merely because legacy motion settings are re-sent. Changes are + // strictly native-param deltas; old settings had both amounts OFF. + if(s.roomAmount!=settings_.roomAmount) { + if(s.roomAmount>0.f && !room_.active() && + !room_.setShape(SonKuRoomShape::Square))return false; + if(!room_.setAmount(s.roomAmount))return false; + } + if(s.ambienceAmount!=settings_.ambienceAmount && !reverb_.setAmount(s.ambienceAmount))return false; settings_=s; remaining_=0; From 5594db9167045d76af17480955fdc8cd94b7c3e4 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:44:22 +0700 Subject: [PATCH 09/14] feat(sonku): persist native SPACE v2 with v1 compatibility and bounded tail metadata --- engine/builtin_fx/SonKuSpatialProcessor.h | 25 +++++++++++++++++------ 1 file changed, 19 insertions(+), 6 deletions(-) diff --git a/engine/builtin_fx/SonKuSpatialProcessor.h b/engine/builtin_fx/SonKuSpatialProcessor.h index d0f9ed31b..8c5f0c80d 100644 --- a/engine/builtin_fx/SonKuSpatialProcessor.h +++ b/engine/builtin_fx/SonKuSpatialProcessor.h @@ -23,7 +23,10 @@ class SonKuSpatialProcessor final : public juce::AudioProcessor, bool acceptsMidi() const override {return false;} bool producesMidi() const override {return false;} bool isMidiEffect() const override {return false;} - double getTailLengthSeconds() const override {return 0.;} + double getTailLengthSeconds() const override { + return accepted_.ambienceAmount>0.f?0.78: + accepted_.roomAmount>0.f?0.25:0.; + } int getNumPrograms() override {return 1;} int getCurrentProgram() override {return 0;} void setCurrentProgram(int) override {} @@ -80,7 +83,7 @@ class SonKuSpatialProcessor final : public juce::AudioProcessor, void getStateInformation(juce::MemoryBlock& dest) override { juce::MemoryOutputStream out(dest,false); out.writeInt(0x534F4E4B); // SONK - out.writeInt(1); + out.writeInt(2); // v1 sessions remain readable; v2 adds SPACE out.writeFloat(accepted_.startAzimuthDegrees); out.writeFloat(accepted_.revolutionSeconds); out.writeFloat(accepted_.stereoSpreadDegrees); @@ -88,11 +91,17 @@ class SonKuSpatialProcessor final : public juce::AudioProcessor, out.writeFloat(accepted_.outputTrim); out.writeByte(accepted_.moving?1:0); out.writeByte(accepted_.clockwise?1:0); + out.writeFloat(accepted_.roomAmount); + out.writeFloat(accepted_.ambienceAmount); } bool restoreUnpublishedState(const void* data,int size) { - if(published_||!data||size!=30||!queue_.empty()||!complete_.empty())return false; + if(published_||!data||(size!=30&&size!=38)|| + !queue_.empty()||!complete_.empty())return false; juce::MemoryInputStream in(data,static_cast(size),false); - if(in.readInt()!=0x534F4E4B||in.readInt()!=1)return false; + if(in.readInt()!=0x534F4E4B)return false; + const int version=in.readInt(); + if((version==1&&size!=30)||(version==2&&size!=38)|| + (version!=1&&version!=2))return false; armix::sonku::Settings next{}; next.startAzimuthDegrees=in.readFloat(); next.revolutionSeconds=in.readFloat(); @@ -100,10 +109,14 @@ class SonKuSpatialProcessor final : public juce::AudioProcessor, next.spatialMix=in.readFloat(); next.outputTrim=in.readFloat(); const int moving=in.readByte(),clockwise=in.readByte(); - if(moving>1||clockwise>1||!in.isExhausted())return false; + if(moving>1||clockwise>1)return false; next.moving=moving!=0; next.clockwise=clockwise!=0; - if(!armix::sonku::valid(next))return false; + if(version==2) { + next.roomAmount=in.readFloat(); + next.ambienceAmount=in.readFloat(); + } + if(!in.isExhausted()||!armix::sonku::valid(next))return false; if(ready_&&!core_.setSettings(next))return false; accepted_=next; return true; From 4f485abae0e4d4028353af1460fa656ed777b313 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:44:50 +0700 Subject: [PATCH 10/14] feat(native): carry SonKu SPACE room/ambience through typed dispatcher and accepted snapshot --- src/Main.cpp | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/Main.cpp b/src/Main.cpp index 593a5dc3b..cc2611c46 100644 --- a/src/Main.cpp +++ b/src/Main.cpp @@ -2965,7 +2965,7 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr reply->setProperty("deviceEpoch",epoch); reply->setProperty("graphRevision",revision); reply->setProperty("instanceId",instanceId); - reply->setProperty("schemaVersion",1); + reply->setProperty("schemaVersion",2); reply->setProperty("status",processor?"ACCEPTED":"REJECTED"); if(processor) { const auto s=processor->acceptedSettings(); @@ -2977,6 +2977,8 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr values->setProperty("outputTrim",s.outputTrim); values->setProperty("moving",s.moving); values->setProperty("clockwise",s.clockwise); + values->setProperty("roomAmount",s.roomAmount); + values->setProperty("ambienceAmount",s.ambienceAmount); reply->setProperty("settings",juce::var(values.release())); reply->setProperty("observedAzimuthDegrees", processor->observedAzimuthDegrees()); @@ -4602,6 +4604,8 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr number("stereoSpreadDegrees",settings.stereoSpreadDegrees) && number("spatialMix",settings.spatialMix) && number("outputTrim",settings.outputTrim) && + number("roomAmount",settings.roomAmount) && + number("ambienceAmount",settings.ambienceAmount) && moving.isBool()&&clockwise.isBool(); if(parameters){settings.moving=static_cast(moving); settings.clockwise=static_cast(clockwise);} From 2151dab1e52da7a5a41c34b75f60d422f694807c Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:45:54 +0700 Subject: [PATCH 11/14] feat(gui): compact native SonKu SPACE reflections/ambience controls with accepted ACK/readback --- site/preview-v2/assets/mixer-native-sonku.js | 22 +++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/site/preview-v2/assets/mixer-native-sonku.js b/site/preview-v2/assets/mixer-native-sonku.js index e5f4508a8..ce14db437 100644 --- a/site/preview-v2/assets/mixer-native-sonku.js +++ b/site/preview-v2/assets/mixer-native-sonku.js @@ -4,13 +4,16 @@ "use strict"; const ID="armix.builtin.8d-sonku.v1"; const defaults=()=>({startAzimuthDegrees:0,revolutionSeconds:12, - stereoSpreadDegrees:60,spatialMix:1,outputTrim:.75,moving:true,clockwise:true}); + stereoSpreadDegrees:60,spatialMix:1,outputTrim:.75,moving:true,clockwise:true, + roomAmount:0,ambienceAmount:0}); const valid=s=>s && Number.isFinite(s.startAzimuthDegrees) && Math.abs(s.startAzimuthDegrees)<=360 && Number.isFinite(s.revolutionSeconds)&&s.revolutionSeconds>=.5&&s.revolutionSeconds<=120 && Number.isFinite(s.stereoSpreadDegrees)&&s.stereoSpreadDegrees>=0&&s.stereoSpreadDegrees<=180 && Number.isFinite(s.spatialMix)&&s.spatialMix>=0&&s.spatialMix<=1 && Number.isFinite(s.outputTrim)&&s.outputTrim>=0&&s.outputTrim<=1 && + Number.isFinite(s.roomAmount)&&s.roomAmount>=0&&s.roomAmount<=1 && + Number.isFinite(s.ambienceAmount)&&s.ambienceAmount>=0&&s.ambienceAmount<=1 && typeof s.moving==="boolean"&&typeof s.clockwise==="boolean"; const backend=()=>window.__JUCE__?.backend; const native=()=>typeof backend()?.emitEvent==="function"; @@ -104,6 +107,10 @@ root.innerHTML=[ '', '', '', + '
', + '
SPACESQUARE ROOM · NATIVE PCM
', + '', + '', '
Drag the two monitors on the orbit · knobs: vertical drag, double-click to reset
', '', '
VISUAL PREVIEWNo browser audio
' @@ -142,6 +149,11 @@ function render(){ dial.style.setProperty("--sk-sweep",(p*270).toFixed(2)+"deg"); dial.style.setProperty("--sk-needle",(-135+p*270).toFixed(2)+"deg"); } + for(const [id,value,out] of [["skRoom",s.roomAmount,"skRoomValue"], + ["skAmbience",s.ambienceAmount,"skAmbienceValue"]]){ + $(id).value=String(Math.round(value*100)); + $(out).textContent=value===0?"OFF":Math.round(value*100)+"%"; + } const liveMotion=s.moving&¤t&&!pending?observed: s.startAzimuthDegrees; const phase=native()&&s.moving&¤t&&!pending&&observedAt? @@ -229,6 +241,14 @@ $("skClose").addEventListener("click",()=>{root.hidden=true;current=null; if(clock!==null){clearInterval(clock);clock=null;}}); $("skMotion").addEventListener("click",()=>send({...draft,moving:!draft.moving})); $("skDirection").addEventListener("click",()=>send({...draft,clockwise:!draft.clockwise})); +for(const [id,key] of [["skRoom","roomAmount"],["skAmbience","ambienceAmount"]]) { + const el=$(id); + el.addEventListener("input",()=>{ + const value=Number(el.value)/100; + if(Number.isFinite(value)){draft={...draft,[key]:value};render();} + }); + el.addEventListener("change",()=>send({...draft,[key]:Number(el.value)/100})); +} for(const [id,key,convert] of [ ["skSpeed","revolutionSeconds",v=>v], ["skSpread","stereoSpreadDegrees",v=>v], From 1afe7c7c09f89d386812f29bf5b6ae3fce648097 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:46:09 +0700 Subject: [PATCH 12/14] style(sonku): compact premium SPACE section without extra modal or oversized controls --- site/preview-v2/assets/mixer-fx-rack.css | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/site/preview-v2/assets/mixer-fx-rack.css b/site/preview-v2/assets/mixer-fx-rack.css index 999f30358..7c5fae727 100644 --- a/site/preview-v2/assets/mixer-fx-rack.css +++ b/site/preview-v2/assets/mixer-fx-rack.css @@ -1327,6 +1327,18 @@ .mx-sonku .sk-rotary:focus-within .sk-dial-cap{outline:1px solid #87d5e6;outline-offset:2px} .mx-sonku .sk-rotary output{font-size:11px;font-weight:600;letter-spacing:.2px; font-variant-numeric:tabular-nums;color:#dcf3f7} +.mx-sonku .sk-space{display:grid;gap:5px;padding:8px 9px 7px; + border:1px solid rgba(120,172,189,.28);border-radius:7px; + background:linear-gradient(155deg,rgba(9,27,38,.72),rgba(19,47,60,.50))} +.mx-sonku .sk-space-head{display:flex;align-items:center;justify-content:space-between; + font-size:9px;letter-spacing:1.15px;color:#d0ecf3;font-weight:600} +.mx-sonku .sk-space-head span:last-child{font-size:8px;letter-spacing:.45px; + color:#8baebd;font-weight:400} +.mx-sonku .sk-controls label.sk-space-row{display:grid;grid-template-columns:75px minmax(0,1fr) 36px; + gap:7px;align-items:center;font-size:9px;letter-spacing:0;color:#bcd6df} +.mx-sonku .sk-space-row input{grid-column:auto!important;width:100%!important; + height:14px!important;margin:0!important;accent-color:#73cddd} +.mx-sonku .sk-space-row output{text-align:right;font-size:9px} .mx-sonku .sk-guide{font-size:9px;line-height:1.42;color:#91b2c2; border-top:1px solid rgba(113,157,173,.24);padding-top:9px;letter-spacing:.1px} .mx-sonku .sk-status{background:linear-gradient(#142836,#0c1a27); From 5c3f48e18d0dcfca98a80efa13e9c91dacf7f9da Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Fri, 13 Nov 2026 14:46:34 +0700 Subject: [PATCH 13/14] test(chromium): verify SPACE sliders use typed SonKu ACK and accepted readback --- tests/approved_native_sonku_smoke.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/tests/approved_native_sonku_smoke.py b/tests/approved_native_sonku_smoke.py index c70c0592e..b1de7bff8 100644 --- a/tests/approved_native_sonku_smoke.py +++ b/tests/approved_native_sonku_smoke.py @@ -21,6 +21,8 @@ "outputTrim":0.75, "moving":True, "clockwise":True, + "roomAmount":0.0, + "ambienceAmount":0.0, } def last_action(page,name): @@ -229,6 +231,30 @@ def screen(x,y): "stereoSpreadDegrees":0.0,"startAzimuthDegrees":0.0, "revolutionSeconds":dialAction["settings"]["revolutionSeconds"]}, applied=dialAction["requestId"]) + # Native SPACE uses the SAME typed edit/ACK/accepted DSP readback + # as the existing orbit parameters. It is never a browser-only FX. + for which,percent,field in ( + ("skRoom",45,"roomAmount"),("skAmbience",25,"ambienceAmount")): + page.wait_for_timeout(275) + editor.locator("#"+which).evaluate("""(el,p) => { + el.value=String(p); + el.dispatchEvent(new Event('input',{bubbles:true})); + el.dispatchEvent(new Event('change',{bubbles:true})); + }""",percent) + spaceAction=last_action(page,"nativeSonKuSet") + assert abs(spaceAction["settings"][field]-percent/100)<1e-6,spaceAction + emit(page,"arMixBuiltinSonKuAck",{ + "requestId":spaceAction["requestId"],"status":"APPLIED"}) + acceptedSpace={**SETTINGS,"moving":False,"stereoSpreadDegrees":0.0, + "startAzimuthDegrees":0.0, + "revolutionSeconds":dialAction["settings"]["revolutionSeconds"], + "roomAmount":.45, + "ambienceAmount":.25 if field=="ambienceAmount" else 0.0} + accepted_snapshot(page,state,acceptedSpace, + applied=spaceAction["requestId"]) + assert "ACCEPTED" in editor.locator("#skHint").inner_text() + assert editor.locator("#skRoomValue").inner_text()=="45%" + assert editor.locator("#skAmbienceValue").inner_text()=="25%" bounds=editor.bounding_box() assert bounds and bounds["width"]>260 and bounds["width"] Date: Fri, 13 Nov 2026 14:47:19 +0700 Subject: [PATCH 14/14] test(sonku): native SPACE typed PCM impulse, bypass/reactivation and invalid intents --- tests/sonku_spatial_core_test.cpp | 46 +++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/tests/sonku_spatial_core_test.cpp b/tests/sonku_spatial_core_test.cpp index b48a83257..4c2dbc6f8 100644 --- a/tests/sonku_spatial_core_test.cpp +++ b/tests/sonku_spatial_core_test.cpp @@ -154,6 +154,52 @@ int main() { std::abs(tailR[i]-squareR[i]); } assert(lateDifference>.001); + // Native M4 SPACE contract: the typed settings now traverse the + // real core rather than a browser-only slider. Direct HRTF remains + // identical before the first delayed reflection/reverb sample. + { + auto baseline=std::make_unique(); + auto space=std::make_unique(); + assert(baseline->prepare(rate)&&space->prepare(rate)); + Settings nativeSettings=roomSettings; + nativeSettings.roomAmount=.55f; + nativeSettings.ambienceAmount=.30f; + assert(valid(nativeSettings)); + assert(baseline->setSettings(roomSettings)); + assert(space->setSettings(nativeSettings)); + assert(space->settings().roomAmount==.55f); + assert(space->settings().ambienceAmount==.30f); + std::array baseL{},baseR{},spL{},spR{}; + baseL[0]=baseR[0]=spL[0]=spR[0]=.5f; + baseline->process(baseL.data(),baseR.data(),4096); + space->process(spL.data(),spR.data(),4096); + double spaceDifference=0.; + for(int i=0;i<4096;++i) { + assert(std::isfinite(spL[i])&&std::isfinite(spR[i])); + if(i<180)assert(spL[i]==baseL[i]&&spR[i]==baseR[i]); + if(i>180)spaceDifference+=std::abs(spL[i]-baseL[i])+ + std::abs(spR[i]-baseR[i]); + } + assert(spaceDifference>.001); + Settings off=nativeSettings; + off.roomAmount=off.ambienceAmount=0.f; + assert(space->setSettings(off)); + std::array zerosL{},zerosR{}; + for(int block=0;block<100;++block) { + zerosL.fill(0.f);zerosR.fill(0.f); + space->process(zerosL.data(),zerosR.data(),128); + } + assert(space->setSettings(nativeSettings)); // O(1) reactivation + std::array restartL{},restartR{}; + restartL[0]=restartR[0]=.4f; + space->process(restartL.data(),restartR.data(),128); + for(int i=0;i<128;++i) { + assert(std::isfinite(restartL[i])&&std::isfinite(restartR[i])); + } + Settings invalidSpace=nativeSettings; + invalidSpace.ambienceAmount=1.1f; + assert(!space->setSettings(invalidSpace)); + } // Explicit approved square parameters remain PCM-identical. Radius // attenuation works even with early reflections disabled, so SPACE // and DISTANCE remain independent, not one misleading "big hall" knob.