diff --git a/.github/workflows/logical-mixer-fast.yml b/.github/workflows/logical-mixer-fast.yml index d0621622d..0313dc7cf 100644 --- a/.github/workflows/logical-mixer-fast.yml +++ b/.github/workflows/logical-mixer-fast.yml @@ -4,6 +4,10 @@ on: paths: - 'engine/core/DeviceIndependentMixerSession.h' - 'engine/core/DynamicChannelRoster.h' + - 'engine/core/DynamicPreparedMixerBlock.h' + - 'engine/core/DynamicAcceptedSession.h' + - 'engine/core/DynamicNativeSessionPublisher.h' + - 'tests/dynamic_accepted_session_test.cpp' - 'tests/device_independent_mixer_session_test.cpp' - '.github/workflows/logical-mixer-fast.yml' workflow_dispatch: @@ -19,3 +23,9 @@ jobs: tests/device_independent_mixer_session_test.cpp \ -o /tmp/arsonmix-logical-test /tmp/arsonmix-logical-test + - name: Compile and run native PCM gain, PRE/POST and SEND regressions (no JUCE) + run: | + c++ -std=c++20 -O1 -Wall -Wextra -Werror -I. \ + tests/dynamic_accepted_session_test.cpp \ + -o /tmp/arsonmix-dynamic-pcm-test + /tmp/arsonmix-dynamic-pcm-test diff --git a/engine/core/DynamicAcceptedSession.h b/engine/core/DynamicAcceptedSession.h index dd4486f23..55682e73c 100644 --- a/engine/core/DynamicAcceptedSession.h +++ b/engine/core/DynamicAcceptedSession.h @@ -306,6 +306,15 @@ class DynamicAcceptedSession final { return false; return accepted_.rememberLiveMix(id,linear,pan); } + // A real accepted post-source, pre-FX digital gain update. Remembers the + // final value without changing graph topology or touching the audio thread. + bool setLiveInputGain(std::uint64_t epoch,std::uint64_t graphRevision, + ChannelId id,float linear) noexcept { + const auto* row=accepted_.find(id); + if(!row || row->role!=ChannelRole::input || + !publisher_.setInputGain(epoch,graphRevision,id,linear))return false; + return accepted_.rememberLiveInputGain(id,linear); + } // The accepted physical patch is canonical too: subsequent Group/FX // graph recompiles must preserve the most recently ACKed live SOURCE. bool setLivePhysicalSource(std::uint64_t epoch,std::uint64_t graphRevision, @@ -350,6 +359,20 @@ class DynamicAcceptedSession final { source,destination,preFader,linear); } + // Real-time per-EdgeId SEND ON/OFF uses the same prepared PCM graph, + // retains remembered gain, and never tears down/recreates its WIRE. + bool setLiveSendEnabled(std::uint64_t epoch,std::uint64_t graphRevision, + ChannelId source,std::uint64_t edgeId,bool enabled) noexcept { + const auto* row=accepted_.find(source); + if(!row || !edgeId)return false; + for(const auto& edge:row->sends) + if(edge.edgeId==edgeId && !edge.primaryOutput){ + if(!publisher_.setSendEnabled(epoch,graphRevision, + source,edgeId,enabled,edge.gain))return false; + return accepted_.rememberLiveSendEnabled(source,edgeId,enabled); + } + return false; + } bool setLiveWireGain(std::uint64_t epoch,std::uint64_t revision, ChannelId source,std::uint64_t edgeId,float gain) noexcept { const auto* row=accepted_.find(source); diff --git a/engine/core/DynamicChannelRoster.h b/engine/core/DynamicChannelRoster.h index bf76ad572..47a94a9c8 100644 --- a/engine/core/DynamicChannelRoster.h +++ b/engine/core/DynamicChannelRoster.h @@ -30,6 +30,7 @@ struct ChannelSendRef final { float pan=0.f; // send-only balance: PRE mono uses equal-power coefficients bool primaryOutput=false; // OUT selector edge, not a parallel SEND std::uint64_t edgeId=0; // stable native identity; CONTROL-only assignment + bool enabled=true; // independent SEND ON; retain EdgeId/gain/tap when OFF }; struct ChannelStripDefinition final { ChannelId id{}; @@ -37,6 +38,7 @@ struct ChannelStripDefinition final { ProcessingFormat format=ProcessingFormat::mono; std::string name; float faderLinear=1.f, pan=0.f; + float inputGainLinear=1.f; // digital pre-insert gain, not hardware preamp bool mute=false, solo=false; // Catalog identifiers ONLY. No vendor processor object is copied or built. // The existing audio control thread owns independent VST instance creation. @@ -59,7 +61,7 @@ struct ChannelEdit final { enum class Kind : std::uint8_t { add, duplicate, remove, move, rename, setFormat, setFader, setPan, setMute, setSolo, addInsertReference, addSendReference, setPrimaryOutput, - removeInsertReference, moveInsertReference, + removeInsertReference, moveInsertReference, setSendEnabled, setSendTap, setInputGain, // Control-document metadata (rack/slot bypass) changes revision // without changing a fader, audio descriptor or live PCM topology. touchDocumentRevision @@ -76,6 +78,7 @@ struct ChannelEdit final { bool primaryOutput=false; // exclusive OUT edge, independent of parallel SEND bool connectMainOnCreate=false; // WIRE-first native creation; legacy imports unchanged float sendPan=0.f; // independent send PAN, never channel fader PAN + std::uint64_t sendEdgeId=0; // exact parallel send identity for SEND ON/OFF std::string text; }; struct ChannelEditResult final { @@ -119,6 +122,23 @@ class DynamicChannelRoster final { row.faderLinear=gain;row.pan=pan; return true; } + bool rememberLiveInputGain(ChannelId id,float gain) noexcept { + if(!id.value || !std::isfinite(gain) || gain<0.f || gain>16.f)return false; + const auto it=index_.find(id.value); + if(it==index_.end() || channels_[it->second].role!=ChannelRole::input)return false; + channels_[it->second].inputGainLinear=gain; + return true; + } + bool rememberLiveSendEnabled(ChannelId source,std::uint64_t edgeId,bool enabled) noexcept { + if(!source.value || !edgeId)return false; + const auto it=index_.find(source.value); + if(it==index_.end())return false; + for(auto& send:channels_[it->second].sends) + if(send.edgeId==edgeId && !send.primaryOutput){ + send.enabled=enabled;return true; + } + return false; + } bool rememberLiveMuteSolo(ChannelId id,bool mute,bool solo) noexcept { const auto it=index_.find(id.value); if(!id.value||it==index_.end())return false; @@ -230,6 +250,12 @@ class DynamicChannelRoster final { result.fault=ChannelEditFault::invalidValue; else it->faderLinear=op.value; break; + case ChannelEdit::Kind::setInputGain: + if(it->role!=ChannelRole::input || !std::isfinite(op.value)|| + op.value<0.f||op.value>16.f) + result.fault=ChannelEditFault::invalidValue; + else it->inputGainLinear=op.value; + break; case ChannelEdit::Kind::setPan: if(!std::isfinite(op.value)||op.value< -1.f||op.value>1.f) result.fault=ChannelEditFault::invalidValue; @@ -241,6 +267,19 @@ class DynamicChannelRoster final { case ChannelEdit::Kind::setSolo: it->solo=op.enabled; break; + case ChannelEdit::Kind::setSendEnabled: + case ChannelEdit::Kind::setSendTap: { + const auto edge=std::find_if(it->sends.begin(),it->sends.end(), + [&](const auto& send){return send.edgeId==op.sendEdgeId;}); + if(!op.sendEdgeId || edge==it->sends.end()) + result.fault=ChannelEditFault::missingEdge; + else if(edge->primaryOutput) + result.fault=ChannelEditFault::invalidAction; + else if(op.kind==ChannelEdit::Kind::setSendEnabled) + edge->enabled=op.enabled; + else edge->preFader=op.preFader; // post-insert PRE, not PRE_FX + break; + } case ChannelEdit::Kind::touchDocumentRevision: // Exact stable ChannelId is validated above. Bump the // document revision without fabricating a DSP parameter @@ -306,6 +345,7 @@ class DynamicChannelRoster final { primary->gain=1.f; primary->preFader=false; primary->pan=0.f; + primary->enabled=true; } else { if(edges.size()>=budget_.maximumSendsPerChannel) { result.fault=ChannelEditFault::budgetExceeded;break; @@ -439,6 +479,7 @@ class DynamicChannelRoster final { // of doubling a parallel SEND in the accepted PCM. target->primaryOutput=true; target->gain=1.f;target->preFader=false;target->pan=0.f; + target->enabled=true; continue; } } @@ -750,6 +791,9 @@ class DynamicChannelRoster final { if(!ch.id.value || ch.id.value==std::numeric_limits::max() || !ids.insert(ch.id.value).second || !std::isfinite(ch.faderLinear) || ch.faderLinear<0.f || + !std::isfinite(ch.inputGainLinear) || ch.inputGainLinear<0.f || + ch.inputGainLinear>16.f || + (ch.role!=ChannelRole::input && ch.inputGainLinear!=1.f) || ch.faderLinear>4.f || !std::isfinite(ch.pan) || ch.pan< -1.f || ch.pan>1.f)return false; maxId=std::max(maxId,ch.id.value); @@ -762,7 +806,8 @@ class DynamicChannelRoster final { !send.destination.value || send.destination==ch.id || !edges.insert(send.edgeId).second || !std::isfinite(send.gain)||send.gain<0.f||send.gain>4.f || - !std::isfinite(send.pan)||send.pan< -1.f||send.pan>1.f) + !std::isfinite(send.pan)||send.pan< -1.f||send.pan>1.f || + (send.primaryOutput && (!send.enabled || send.preFader))) return false; primary+=send.primaryOutput; maxEdge=std::max(maxEdge,send.edgeId); diff --git a/engine/core/DynamicConsoleRoutingView.h b/engine/core/DynamicConsoleRoutingView.h index 29cf7b460..974600512 100644 --- a/engine/core/DynamicConsoleRoutingView.h +++ b/engine/core/DynamicConsoleRoutingView.h @@ -20,12 +20,14 @@ struct ConsoleSendView final { float gain=1.f,pan=0.f; bool preFader=false; std::uint64_t edgeId=0; + bool enabled=true; }; struct ConsoleEdgeView final { std::uint64_t edgeId=0; ChannelId from{},to{}; float gainLinear=1.f; bool preFader=false,primaryOutput=false; + bool enabled=true; }; struct ConsoleChannelView final { ChannelId id{}; @@ -33,6 +35,7 @@ struct ConsoleChannelView final { ProcessingFormat format=ProcessingFormat::mono; std::string name; ChannelId primaryOutput{}; // zero is genuine OUT NONE, NOT muted parallel sends + float inputGainLinear=1.f; // accepted digital pre-insert stage std::vector parallelSends; std::vector primarySources; std::vector parallelSendSources; @@ -70,7 +73,7 @@ class DynamicConsoleRoutingView final { return false; ConsoleChannelView item; item.id=row.id;item.role=row.role;item.format=row.format; - item.name=row.name; + item.name=row.name;item.inputGainLinear=row.inputGainLinear; if(row.role==ChannelRole::main) { if(next.main.value)return false; next.main=row.id; @@ -90,7 +93,7 @@ class DynamicConsoleRoutingView final { if(it==index.end() || !link.edgeId || !acceptedEdgeIds.insert(link.edgeId).second)return false; next.edges.push_back({link.edgeId,sender.id,link.destination, - link.gain,link.preFader,link.primaryOutput}); + link.gain,link.preFader,link.primaryOutput,link.enabled}); auto& destination=next.channels[it->second]; if(link.primaryOutput) { if(sender.primaryOutput.value || link.preFader || @@ -100,7 +103,7 @@ class DynamicConsoleRoutingView final { destination.primarySources.push_back(sender.id); } else { sender.parallelSends.push_back( - {link.destination,link.gain,link.pan,link.preFader,link.edgeId}); + {link.destination,link.gain,link.pan,link.preFader,link.edgeId,link.enabled}); // One source shown once in the Bus fan-in even if it has // multiple legal taps to that destination. if(std::find(destination.parallelSendSources.begin(), diff --git a/engine/core/DynamicNativeSessionPublisher.h b/engine/core/DynamicNativeSessionPublisher.h index 4970c1046..88668e5f1 100644 --- a/engine/core/DynamicNativeSessionPublisher.h +++ b/engine/core/DynamicNativeSessionPublisher.h @@ -318,6 +318,13 @@ class DynamicNativeSessionPublisher final { return active.graph.setChannelMix(id,gain,pan); }); } + bool setInputGain(std::uint64_t epoch,std::uint64_t revision, + ChannelId id,float linear) noexcept { + return publisher_.updateActiveControl(epoch,revision, + [&](Prepared& active) noexcept { + return active.graph.setInputGain(id,linear); + }); + } bool setChannelMuteSolo(std::uint64_t epoch,std::uint64_t revision, ChannelId id,bool mute,bool solo) noexcept { return publisher_.updateActiveControl(epoch,revision, @@ -353,6 +360,29 @@ class DynamicNativeSessionPublisher final { return true; }); } + bool setSendEnabled(std::uint64_t epoch,std::uint64_t revision, + ChannelId source,std::uint64_t edgeId,bool enabled, + float rememberedGain) noexcept { + if(!source.value || !edgeId || !std::isfinite(rememberedGain) || + rememberedGain<0.f || rememberedGain>4.f)return false; + return publisher_.updateActiveControl(epoch,revision, + [&](Prepared& active) noexcept { + const auto it=std::find_if(active.routing.edges.begin(), + active.routing.edges.end(),[&](const auto& edge){ + return edge.from==source && edge.edgeId==edgeId && + !edge.primaryOutput; + }); + if(it==active.routing.edges.end())return false; + if(active.graph.channelScheduled(source) && + !active.graph.setSendEnabled(source,edgeId,enabled,rememberedGain)) + return false; + it->enabled=enabled; + for(auto& row:active.routing.channels)if(row.id==source) + for(auto& send:row.parallelSends) + if(send.edgeId==edgeId)send.enabled=enabled; + return true; + }); + } bool setWireGain(std::uint64_t epoch,std::uint64_t revision, ChannelId source,std::uint64_t edgeId,float gain) noexcept { const auto* routing=acceptedRouting(epoch,revision); diff --git a/engine/core/DynamicPreparedMixerBlock.h b/engine/core/DynamicPreparedMixerBlock.h index e44575411..d7d674540 100644 --- a/engine/core/DynamicPreparedMixerBlock.h +++ b/engine/core/DynamicPreparedMixerBlock.h @@ -64,7 +64,8 @@ class DynamicPreparedMixerBlock final { struct Edge final { std::size_t destination=0; float panL=0.f,panR=0.f,initialGain=1.f; - bool pre=false,primary=false; + bool pre=false,primary=false,enabled=true; + std::uint64_t edgeId=0; }; struct Lane final { ChannelId id{}; @@ -98,7 +99,8 @@ class DynamicPreparedMixerBlock final { } struct ChannelTarget final { std::atomic state{Word::encode(1.f,1.f,false,false)}; - armix::dsp::RealtimeSlew64 appliedL{},appliedR{},gate{}; // AUDIO only + std::atomic inputGain{1.f}; // pre-insert digital trim target + armix::dsp::RealtimeSlew64 inputApplied{},appliedL{},appliedR{},gate{}; // AUDIO only }; // CONTROL only packs already verified callback-ordinal physical pin pairs. // 0xFFFF means missing right input for mono, never an active physical pin. @@ -121,6 +123,7 @@ class DynamicPreparedMixerBlock final { static_assert(std::atomic::is_always_lock_free, "Realtime SEND must never enter a hidden blocking atomic path"); std::atomic gain{1.f}; + std::atomic enabled{true}; armix::dsp::RealtimeSlew64 applied{}; }; // O1: immutable lane roster + one lock-free control target per lane. @@ -172,6 +175,16 @@ class DynamicPreparedMixerBlock final { std::memory_order_release); return true; } + // Stable-ChannelId digital input gain; one control atomic, 64-sample RT slew. + // Not a physical mic-preamp and never a graph recompile on movement. + bool setInputGain(ChannelId id,float linear) noexcept { + if(!id.value || !std::isfinite(linear) || linear<0.f || linear>16.f)return false; + const auto found=controlIndex_.find(id.value); + if(found==controlIndex_.end() || lanes_[found->second].role!=ChannelRole::input) + return false; + channelTargets_[found->second].inputGain.store(linear,std::memory_order_release); + return true; + } // Canonical physical-pin validation shared by structural preflight and // accepted realtime SOURCE changes. Never normalize an invalid draft // into an apparently successful ACK by replacing it with old pins. @@ -238,13 +251,32 @@ class DynamicPreparedMixerBlock final { for(std::size_t e=lane.first;e4.f)return false; + const auto found=controlIndex_.find(source.value); + if(found==controlIndex_.end())return false; + const auto& lane=lanes_[found->second]; + for(std::size_t e=lane.first;e0.f?1.f-send.pan:1.f); const float gr=monoPre?std::sqrt(.5f*(1.f+send.pan)): (send.pan<0.f?1.f+send.pan:1.f); - outgoing[i].push_back({to,gl,gr,send.gain,send.preFader, - send.primaryOutput}); + outgoing[i].push_back({to,gl,gr,send.enabled?send.gain:0.f, + send.preFader,send.primaryOutput,send.enabled,send.edgeId}); parents[to].push_back(i); ++indegree[to]; } @@ -592,6 +624,8 @@ class DynamicPreparedMixerBlock final { target.state.store(Word::encode(next.lanes_[i].gainL, next.lanes_[i].gainR,rows[i].mute,rows[i].solo), std::memory_order_relaxed); + target.inputGain.store(rows[i].inputGainLinear,std::memory_order_relaxed); + target.inputApplied.reset(rows[i].inputGainLinear); target.appliedL.reset(next.lanes_[i].gainL); target.appliedR.reset(next.lanes_[i].gainR); target.gate.reset(next.initialAudible_[i]?1.f:0.f); @@ -608,6 +642,7 @@ class DynamicPreparedMixerBlock final { for(std::size_t e=0;e{&edit,1}); + } else if(operation=="SET_INPUT_GAIN") { + if(!(number.isDouble() || number.isInt() || number.isInt64())) + return bad("INVALID_INPUT_GAIN"); + const auto db=static_cast(number); + if(!std::isfinite(db) || db< -24. || db>24.) + return bad("INVALID_INPUT_GAIN"); + const auto* target=editor_.roster().find(id); + if(!target || target->role!=Role::input) + return bad("INPUT_GAIN_NOT_APPLICABLE"); + edit.kind=ChannelEdit::Kind::setInputGain; + edit.value=static_cast(std::pow(10.,db/20.)); + result=editor_.edit(expected,std::span{&edit,1}); } else if(operation=="SET_FADER" || operation=="SET_PAN") { if(!(number.isDouble() || number.isInt() || number.isInt64())) return bad("INVALID_CONTROL_VALUE"); @@ -178,6 +190,29 @@ class NativeLogicalMixerWorkspace final { edit.value=static_cast(n); } result=editor_.edit(expected,std::span{&edit,1}); + } else if(operation=="SET_SEND_TAP") { + const auto edgeVar=payload.getProperty("edgeId",{}); + std::uint64_t sendId=0; + if(!armix::session::parseDecimal(edgeVar,sendId) || !sendId) + return bad("INVALID_SEND_TAP_EDGE"); + const auto tap=payload.getProperty("tap","").toString(); + if(tap!="PRE_FADER" && tap!="POST_FADER") + return bad("INVALID_SEND_TAP_STAGE"); + edit.kind=ChannelEdit::Kind::setSendTap; + edit.sendEdgeId=sendId; + edit.preFader=tap=="PRE_FADER"; + result=editor_.edit(expected,std::span{&edit,1}); + } else if(operation=="SET_SEND_ENABLED") { + // Logical/offline operation only: cannot authorize installed PCM. + // The authoritative roster retains EdgeId and stored gain/tap. + const auto edgeVar=payload.getProperty("edgeId",{}); + std::uint64_t sendId=0; + if(!armix::session::parseDecimal(edgeVar,sendId) || !sendId || + !number.isBool())return bad("INVALID_SEND_ENABLED"); + edit.kind=ChannelEdit::Kind::setSendEnabled; + edit.sendEdgeId=sendId; + edit.enabled=static_cast(number); + result=editor_.edit(expected,std::span{&edit,1}); } else if(operation=="SET_MUTE" || operation=="SET_SOLO") { if(!number.isBool())return bad("INVALID_BOOLEAN_CONTROL"); edit.kind=operation=="SET_MUTE"? @@ -341,6 +376,8 @@ class NativeLogicalMixerWorkspace final { for(const char* op:{"CREATE_CHANNEL","DELETE_CHANNEL","CREATE_GROUP", "REMOVE_BUS","RENAME_CHANNEL","SET_FADER","SET_PAN","SET_MUTE", "SET_SOLO","SET_PROCESSING_FORMAT","WIRE_TRANSACTION", + "SET_INPUT_GAIN", + "SET_SEND_ENABLED","SET_SEND_TAP", "ADD_FX_REFERENCE","REMOVE_FX_REFERENCE", "SET_FX_SLOT_BYPASS","SET_FX_RACK_BYPASS"})operations.add(juce::String(op)); set(cap,"supportedOps",juce::var(operations)); @@ -361,6 +398,8 @@ class NativeLogicalMixerWorkspace final { set(controls,"faderDb",row.faderLinear>0.f? std::max(-60.,20.*std::log10(static_cast(row.faderLinear))):-60.); set(controls,"pan",static_cast(row.pan)); + set(controls,"inputGainDb",20.*std::log10( + std::max(1.e-12,static_cast(row.inputGainLinear)))); set(controls,"mute",row.mute);set(controls,"solo",row.solo); set(channel,"controls",controls); auto source=object(); @@ -393,10 +432,13 @@ class NativeLogicalMixerWorkspace final { set(edge,"edgeId",str(send.edgeId)); set(edge,"from",str(row.id.value)); set(edge,"to",str(send.destination.value)); - set(edge,"signalKind","AUDIO");set(edge,"enabled",true); + set(edge,"signalKind","AUDIO");set(edge,"enabled",send.enabled); set(edge,"gainLinear",static_cast(send.gain)); set(edge,"primaryOutput",send.primaryOutput); set(edge,"tap",send.preFader?"SPLIT_PRE":"POST_FADER"); + // Explicit native DSP stage. Legacy SPLIT_PRE field stays + // compatible; it must not be presented as browser PRE_FX. + set(edge,"tapStage",send.preFader?"PRE_FADER":"POST_FADER"); edges.add(edge); sends.add(edge); if(send.primaryOutput)set(channel,"primaryOutId",str(send.destination.value)); diff --git a/src/NativeMixerSessionDocument.h b/src/NativeMixerSessionDocument.h index 4dbdfbb8b..df504123e 100644 --- a/src/NativeMixerSessionDocument.h +++ b/src/NativeMixerSessionDocument.h @@ -530,6 +530,7 @@ class Codec final { set(ch,"format",static_cast(row.format)); set(ch,"name",juce::String::fromUTF8(row.name.c_str())); set(ch,"gain",row.faderLinear); + set(ch,"inputGain",row.inputGainLinear); set(ch,"pan",row.pan);set(ch,"mute",row.mute);set(ch,"solo",row.solo); juce::Array catalogs,sends; for(const auto& c:row.insertCatalogIds) @@ -540,6 +541,7 @@ class Codec final { set(e,"to",decimal(s.destination.value)); set(e,"gain",s.gain);set(e,"pan",s.pan); set(e,"pre",s.preFader);set(e,"primary",s.primaryOutput); + set(e,"enabled",s.enabled); sends.add(e); } set(ch,"catalogs",juce::var(catalogs)); @@ -679,6 +681,12 @@ class Codec final { if(!textField(get(ch,"name"),name,96)|| !real(get(ch,"gain"),n,0.,4.))return false; row.name=name.toStdString();row.faderLinear=static_cast(n); + // Legacy .smix defaults to unity digital trim without a new FX. + const auto trim=get(ch,"inputGain"); + if(!trim.isVoid()) { + if(!real(trim,n,0.,16.))return false; + row.inputGainLinear=static_cast(n); + } if(!real(get(ch,"pan"),n,-1.,1.))return false; row.pan=static_cast(n); if(!strictBool(get(ch,"mute"),row.mute)|| @@ -703,6 +711,11 @@ class Codec final { edge.pan=static_cast(n); if(!strictBool(get(send,"pre"),edge.preFader)|| !strictBool(get(send,"primary"),edge.primaryOutput))return false; + // Backward compatible: historical .smix has no separate SEND ON. + // Missing means ON; an explicitly malformed value fails closed. + const auto enabled=get(send,"enabled"); + if(!enabled.isVoid() && !strictBool(enabled,edge.enabled))return false; + if(edge.primaryOutput && !edge.enabled)return false; row.sends.push_back(edge); } entries.push_back(std::move(row)); diff --git a/tests/device_independent_mixer_session_test.cpp b/tests/device_independent_mixer_session_test.cpp index 780c76216..af1ccdfc8 100644 --- a/tests/device_independent_mixer_session_test.cpp +++ b/tests/device_independent_mixer_session_test.cpp @@ -80,6 +80,41 @@ int main() { valid(track->sends.back().destination==stableMain && !track->sends.back().primaryOutput); + // SEND ON/OFF is a state of the exact parallel EdgeId, NOT removal. + // Primary OUT and a different edge may not be touched accidentally. + const auto sendEdge=track->sends.back().edgeId; + ChannelEdit off;off.kind=ChannelEdit::Kind::setSendEnabled; + off.id=backing;off.sendEdgeId=sendEdge;off.enabled=false; + auto toggled=logical.edit(logical.revision(), + std::span{&off,1}); + valid(toggled.accepted()); + track=logical.roster().find(backing); + valid(track->sends.size()==2 && !track->sends.back().enabled && + track->sends.back().gain==.25f && + track->sends.back().edgeId==sendEdge && + track->sends.front().primaryOutput && track->sends.front().enabled); + const auto revisionAfterOff=logical.revision(); + valid(!logical.edit(revisionAfterOff-1, + std::span{&off,1}).accepted()); + ChannelEdit wrong=off;wrong.sendEdgeId=serialEdge; + valid(!logical.edit(logical.revision(), + std::span{&wrong,1}).accepted()); + wrong.sendEdgeId=99999999; + valid(!logical.edit(logical.revision(), + std::span{&wrong,1}).accepted()); + valid(!logical.roster().find(backing)->sends.back().enabled); + // Restore retains disabled SEND identity and parameters without hardware. + DeviceIndependentMixerSession switched; + valid(switched.restore(logical.roster())); + const auto* swapped=switched.roster().find(backing); + valid(swapped && !swapped->sends.back().enabled && + swapped->sends.back().gain==.25f && swapped->sends.back().edgeId==sendEdge); + ChannelEdit on=off;on.enabled=true; + valid(logical.edit(logical.revision(), + std::span{&on,1}).accepted()); + valid(logical.roster().find(backing)->sends.back().enabled && + logical.roster().find(backing)->sends.back().edgeId==sendEdge); + // 4) SOURCE ONLY removes primary MAIN but leaves the strip and // its explicit parallel SEND. Removing the last send keeps the channel. ChannelEdit sourceOnly; @@ -124,6 +159,9 @@ int main() { ChannelEdit gain;gain.kind=ChannelEdit::Kind::setFader; gain.id=backing;gain.value=.5f; settings.push_back(gain); + ChannelEdit trim;trim.kind=ChannelEdit::Kind::setInputGain; + trim.id=backing;trim.value=2.f; + settings.push_back(trim); ChannelEdit pan;pan.kind=ChannelEdit::Kind::setPan; pan.id=backing;pan.value=-.2f; settings.push_back(pan); @@ -157,7 +195,8 @@ int main() { const auto* row=restored.roster().find(backing); valid(row && row->format==ProcessingFormat::mono && std::abs(row->faderLinear-.5f)<1.e-6f && - std::abs(row->pan+.2f)<1.e-6f && row->mute && row->solo && + std::abs(row->pan+.2f)<1.e-6f && row->inputGainLinear==2.f && + row->mute && row->solo && row->insertCatalogIds.size()==1 && row->insertCatalogIds.front()=="armix.builtin.channel-compressor.v1"); diff --git a/tests/dynamic_accepted_session_test.cpp b/tests/dynamic_accepted_session_test.cpp index de60b7740..48e60f78f 100644 --- a/tests/dynamic_accepted_session_test.cpp +++ b/tests/dynamic_accepted_session_test.cpp @@ -29,6 +29,169 @@ static ChannelEdit send(ChannelId from,ChannelId to,float gain,bool pre=false) { e.id=from;e.target=to;e.value=gain;e.preFader=pre;return e; } +// Real PCM SEND ON/OFF: mute one parallel edge without deleting the cable, +// changing its gain/tap, or affecting the source channel's MAIN contribution. +static void verifyPerEdgeSendEnablePcm() { + constexpr std::uint64_t epoch=9422; + DynamicAcceptedSession session; + DynamicGraphRequest req;req.physicalInputs=1;req.maxFrames=64; + const std::array channels{ + add(0,ChannelRole::input,"VOICE"), + add(1,ChannelRole::fxReturn,"WET",ProcessingFormat::stereo), + add(2,ChannelRole::main,"MAIN",ProcessingFormat::stereo) + }; + auto a=session.edit(0,0,channels,req,epoch,epoch,true); + assert(a.ok()); + const auto voice=a.edit.createdIds[0]; + const auto wet=a.edit.createdIds[1]; + const auto main=a.edit.createdIds[2]; + const std::array links{ + output(voice,main),output(wet,main),send(voice,wet,.5f,true) + }; + req.sources={{voice,0,-1,false}}; + a=session.edit(1,1,links,req,epoch,epoch,true); + assert(a.ok()); + const auto* row=session.acceptedRoster().find(voice); + assert(row && row->sends.size()==2); + const auto edge=std::find_if(row->sends.begin(),row->sends.end(), + [&](const auto& e){return e.destination==wet && !e.primaryOutput;}); + assert(edge!=row->sends.end() && edge->enabled); + const auto edgeId=edge->edgeId; + std::array input{},l{},r{};input.fill(.5f); + const float* pins[]{input.data()}; + const auto fx=+[](ChannelId,float*,float*,int) noexcept {}; + const auto render=[&](int frames=64){ + return session.render(epoch,pins,1,l.data(),r.data(),frames,false,fx); + }; + assert(render()); + const float withSend=l[63]; + assert(withSend>.35f); + ChannelEdit off;off.kind=ChannelEdit::Kind::setSendEnabled; + off.id=voice;off.sendEdgeId=edgeId;off.enabled=false; + const std::array disable{off}; + a=session.edit(2,2,disable,req,epoch,epoch,true); + assert(a.ok() && a.graphRevision==3); + row=session.acceptedRoster().find(voice); + const auto offEdge=std::find_if(row->sends.begin(),row->sends.end(), + [&](const auto& e){return e.edgeId==edgeId;}); + assert(offEdge!=row->sends.end() && !offEdge->enabled && + offEdge->gain==.5f && offEdge->preFader); + assert(!session.setLiveParallelSend(epoch,3,voice,wet,true,1.f)); + assert(render()); + const float withoutSend=l[63]; + assert(withoutSend>.1f && withoutSend enable{on}; + a=session.edit(3,3,enable,req,epoch,epoch,true); + assert(a.ok() && a.graphRevision==4); + row=session.acceptedRoster().find(voice); + const auto onEdge=std::find_if(row->sends.begin(),row->sends.end(), + [&](const auto& e){return e.edgeId==edgeId;}); + assert(onEdge!=row->sends.end() && onEdge->enabled && + onEdge->gain==.5f && onEdge->preFader); + assert(render() && near(l[63],withSend,1e-4f)); + // Toggle the same EdgeId LIVE without a graph revision or WIRE removal. + assert(!session.setLiveSendEnabled(epoch-1,4,voice,edgeId,false)); + assert(!session.setLiveSendEnabled(epoch,3,voice,edgeId,false)); + assert(session.setLiveSendEnabled(epoch,4,voice,edgeId,false)); + assert(session.acceptedGraphRevision()==4); + assert(!session.acceptedRoster().find(voice)->sends.back().enabled); + const auto* accepted=session.acceptedRouting(epoch,4); + assert(accepted); + const auto routingEdge=std::find_if(accepted->edges.begin(),accepted->edges.end(), + [&](const auto& e){return e.edgeId==edgeId;}); + assert(routingEdge!=accepted->edges.end() && !routingEdge->enabled); + assert(!session.setLiveParallelSend(epoch,4,voice,wet,true,1.f)); + assert(render(4)); + const float liveOff=l[3]; + assert(liveOff>withoutSend && liveOffsends.back().enabled); + assert(render(4) && l[3]>withoutSend && l[3].01f && truePre post{retap}; + a=session.edit(4,4,post,req,epoch,epoch,true); + assert(a.ok() && a.graphRevision==5); + row=session.acceptedRoster().find(voice); + const auto moved=std::find_if(row->sends.begin(),row->sends.end(), + [&](const auto& e){return e.edgeId==edgeId;}); + assert(moved!=row->sends.end() && !moved->preFader && + moved->enabled && moved->gain==.5f); + assert(render() && near(l[63],0.f,1e-5f)); + // Reject primary tap edits and keep the accepted revision/audio intact. + const auto primary=std::find_if(row->sends.begin(),row->sends.end(), + [&](const auto& e){return e.primaryOutput;}); + assert(primary!=row->sends.end()); + retap.sendEdgeId=primary->edgeId;retap.preFader=true; + const std::array illegal{retap}; + a=session.edit(5,5,illegal,req,epoch,epoch,true); + assert(!a.ok() && session.acceptedGraphRevision()==5); + assert(render() && near(l[63],0.f,1e-5f)); + session.unpublish();session.pollRetirement(); +} + +// Digital input trim must precede nonlinear FX, with callback-continuous +// sample smoothing and a stable ChannelId during live parameter changes. +static void verifyDigitalInputGainBeforeFxPcm() { + constexpr std::uint64_t epoch=9442; + DynamicAcceptedSession session; + DynamicGraphRequest req;req.physicalInputs=1;req.maxFrames=64; + const std::array setup{ + add(0,ChannelRole::input,"MIC"), + add(1,ChannelRole::main,"MAIN",ProcessingFormat::stereo) + }; + auto a=session.edit(0,0,setup,req,epoch,epoch,true); + assert(a.ok()); + const auto mic=a.edit.createdIds[0]; + const auto main=a.edit.createdIds[1]; + const std::array link{output(mic,main)}; + req.sources={{mic,0,-1,false}}; + a=session.edit(1,1,link,req,epoch,epoch,true); + assert(a.ok()); + std::array input{},l{},r{};input.fill(.25f); + const float* pins[]{input.data()}; + const auto square=[&](ChannelId ch,float* left,float* right,int n) noexcept { + if(ch!=mic)return; + for(int i=0;iinputGainLinear==2.f); + assert(render(4)); + assert(l[3]>original && l[3] change{rename}; + a=session.edit(2,2,change,req,epoch,epoch,true); + assert(a.ok() && session.acceptedRoster().find(mic)->inputGainLinear==2.f); + assert(render(64)); + assert(near(l[63],original*4.f,1e-4f)); + session.unpublish();session.pollRetirement(); +} + static void verifyRealtimeSlewAndNativeChannelIdContinuousControls() { using armix::dsp::RealtimeSlew64; // Sub-64 variable callbacks must not finish a 64-sample gesture in 4 @@ -919,6 +1082,8 @@ int main() { verifyConsoleWirePrimaryOutputPcm(); verifyRealtimeSlewAndNativeChannelIdContinuousControls(); + verifyPerEdgeSendEnablePcm(); + verifyDigitalInputGainBeforeFxPcm(); constexpr std::uint64_t epoch=77; constexpr float center=.7071067811865475f; DynamicAcceptedSession session;