Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 24 additions & 0 deletions CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -1402,6 +1402,14 @@ if(BUILD_TESTING)
add_executable(ARMixIndependentFormatTests tests/independent_stream_format_fence_test.cpp)
target_compile_features(ARMixIndependentFormatTests PRIVATE cxx_std_20)
add_test(NAME IndependentStreamNegotiatedFormatFence COMMAND ARMixIndependentFormatTests)
# IO-0: pure simultaneous-driver/physical-mask fail-closed policies.
# Existing AdaptiveClockBridge and ClockBridgeSizing are reused, not forked.
add_executable(ARMixIo0DualAsioPolicyTests
tests/dual_asio_capture_probe_policy_test.cpp
engine/device/DualAsioCaptureProbePolicy.h)
target_compile_features(ARMixIo0DualAsioPolicyTests PRIVATE cxx_std_20)
add_test(NAME IO0DualVendorCaptureDriverIdentityAndPhysicalMasks
COMMAND ARMixIo0DualAsioPolicyTests)
if(WIN32)
juce_add_console_app(ARMixAsioBackendTests PRODUCT_NAME "ArSonMix ASIO Backend Registration Tests")
target_sources(ARMixAsioBackendTests PRIVATE tests/asio_backend_registration_test.cpp engine/device/AsioPriorityDeviceManager.h)
Expand All @@ -1414,6 +1422,22 @@ if(BUILD_TESTING)
target_link_libraries(ARMixDualJuceTests PRIVATE juce::juce_audio_devices juce::juce_audio_basics juce::juce_recommended_config_flags)
target_compile_features(ARMixDualJuceTests PRIVATE cxx_std_20)
add_test(NAME IndependentJuceDeviceLifecycle COMMAND ARMixDualJuceTests)
# Actual pinned JUCE ASIO instance #A + separate zero-output capture B.
# CTest calls --self-test only: unattended CI NEVER opens hardware.
# Physical --probe is opt-in and does NOT run a second mixer renderer.
juce_add_console_app(ARMixDualAsioCaptureProbe
PRODUCT_NAME "ArSonMix Dual ASIO Capture Compatibility Probe")
target_sources(ARMixDualAsioCaptureProbe PRIVATE
tools/dual_asio_capture_probe.cpp
engine/device/DualAsioCaptureProbePolicy.h)
target_compile_definitions(ARMixDualAsioCaptureProbe PRIVATE JUCE_ASIO=1)
target_link_libraries(ARMixDualAsioCaptureProbe PRIVATE
juce::juce_audio_devices juce::juce_audio_basics
juce::juce_recommended_config_flags advapi32)
target_compile_features(ARMixDualAsioCaptureProbe PRIVATE cxx_std_20)
add_test(NAME IO0DualAsioNativeProbeNeverOpensDriversInCI
COMMAND ARMixDualAsioCaptureProbe --self-test)

juce_add_console_app(ARMixWasapiProbeTests PRODUCT_NAME "ArSonMix WASAPI Probe Tests")
target_sources(ARMixWasapiProbeTests PRIVATE tests/wasapi_capability_probe_test.cpp engine/device/WasapiCapabilityProbe.h)
target_link_libraries(ARMixWasapiProbeTests PRIVATE juce::juce_core ole32 uuid juce::juce_recommended_config_flags)
Expand Down
101 changes: 101 additions & 0 deletions engine/device/DualAsioCaptureProbePolicy.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,101 @@
// SPDX-License-Identifier: AGPL-3.0-only
#pragma once
#include "AsioRegistrationPolicy.h"
#include <cmath>
#include <cstdint>
#include <string_view>

namespace armix::device
{
// IO-0, CONTROL-only: conservative compatibility probe policy, NOT a
// production source binding or a claim that a registered class can open.
// Distinct ASIO driver classes are necessary but NOT sufficient evidence of
// two independently usable physical interfaces.
class DualAsioCaptureProbePolicy final
{
public:
using Identity = AsioRegistrationPolicy::Identity;
enum class Verdict : std::uint8_t
{
ok, missingSelection, unverifiedPrimaryDriver, unverifiedCaptureDriver,
sameDriverClass, wrongPrimaryEndpoint, wrongCaptureEndpoint,
invalidFormat, primaryOutputMissing, captureInputMissing,
captureOutputUnexpected, primaryMaskChanged, captureMaskChanged
};

struct Request
{
std::wstring_view primaryName, captureName;
Identity primary, capture;
std::uint64_t primaryInputMask = 0x3;
std::uint64_t primaryOutputMask = 0x3;
std::uint64_t captureInputMask = 0x1;
};
struct Readback
{
std::wstring_view primaryName, captureName;
double primaryRate = 0., captureRate = 0.;
int primaryPeriod = 0, capturePeriod = 0;
std::uint64_t primaryInputMask = 0, primaryOutputMask = 0;
std::uint64_t captureInputMask = 0, captureOutputMask = 0;
};

static Verdict preflight(const Request& r) noexcept
{
if (r.primaryName.empty() || r.captureName.empty())
return Verdict::missingSelection;
if (!r.primary.valid()) return Verdict::unverifiedPrimaryDriver;
if (!r.capture.valid()) return Verdict::unverifiedCaptureDriver;
if (r.primary.sameDriverClass(r.capture) ||
r.primaryName == r.captureName)
return Verdict::sameDriverClass;
Comment on lines +49 to +51

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

P2 Badge Reject matching CLSIDs even when registry keys differ

When two differently named ASIO registrations point to the same CLSID, this preflight accepts them because Identity::sameDriverClass() requires both the registry key and CLSID to match. A local policy reproduction with different names/keys but identical CLSIDs returns IO0_EXACT_ASIO_READBACK. Such aliases instantiate the same driver class, so they do not satisfy this probe's distinct-class prerequisite and may produce misleading dual-vendor qualification. Compare canonical CLSIDs directly for this rejection, while retaining the stricter registration comparison for before/after identity checks. AGENTS.md requires driver identity verification and separately proven multi-device compatibility.

AGENTS.md reference: AGENTS.md:L37-L37

Useful? React with 👍 / 👎.

if (r.primaryOutputMask == 0 || r.captureInputMask == 0)
return Verdict::invalidFormat;
return Verdict::ok;
}

static Verdict verify(const Request& r, const Readback& a) noexcept
{
const auto ready=preflight(r);
if (ready!=Verdict::ok) return ready;
if (a.primaryName!=r.primaryName) return Verdict::wrongPrimaryEndpoint;
if (a.captureName!=r.captureName) return Verdict::wrongCaptureEndpoint;
if (!std::isfinite(a.primaryRate)||!std::isfinite(a.captureRate)||
a.primaryRate<8000.||a.captureRate<8000.||
a.primaryRate>384000.||a.captureRate>384000.||
a.primaryPeriod<=0||a.capturePeriod<=0)
return Verdict::invalidFormat;
if ((a.primaryOutputMask & 0x3u)!=0x3u)
return Verdict::primaryOutputMissing;
if (a.captureInputMask==0) return Verdict::captureInputMissing;
if (a.captureOutputMask!=0) return Verdict::captureOutputUnexpected;
if (a.primaryInputMask!=r.primaryInputMask||
a.primaryOutputMask!=r.primaryOutputMask)
return Verdict::primaryMaskChanged;
if (a.captureInputMask!=r.captureInputMask)
return Verdict::captureMaskChanged;
return Verdict::ok;
}

static const char* reason(Verdict v) noexcept
{
switch(v)
{
case Verdict::ok: return "IO0_EXACT_ASIO_READBACK";
case Verdict::missingSelection: return "IO0_MISSING_EXPLICIT_DRIVER";
case Verdict::unverifiedPrimaryDriver: return "IO0_PRIMARY_CLASS_NOT_ATTESTED";
case Verdict::unverifiedCaptureDriver: return "IO0_CAPTURE_CLASS_NOT_ATTESTED";
case Verdict::sameDriverClass: return "IO0_REQUIRES_DISTINCT_ASIO_CLASSES";
case Verdict::wrongPrimaryEndpoint: return "IO0_PRIMARY_NAME_SUBSTITUTED";
case Verdict::wrongCaptureEndpoint: return "IO0_CAPTURE_NAME_SUBSTITUTED";
case Verdict::invalidFormat: return "IO0_NEGOTIATED_FORMAT_INVALID";
case Verdict::primaryOutputMissing: return "IO0_PRIMARY_OUTPUT_STEREO_MISSING";
case Verdict::captureInputMissing: return "IO0_CAPTURE_INPUT_MISSING";
case Verdict::captureOutputUnexpected: return "IO0_SECONDARY_CAPTURE_MUST_HAVE_ZERO_OUTPUTS";
case Verdict::primaryMaskChanged: return "IO0_PRIMARY_PIN_MASK_CHANGED";
case Verdict::captureMaskChanged: return "IO0_CAPTURE_PIN_MASK_CHANGED";
}
return "IO0_UNKNOWN_FAILURE";
}
};
} // namespace armix::device
79 changes: 79 additions & 0 deletions tests/dual_asio_capture_probe_policy_test.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,79 @@
// SPDX-License-Identifier: AGPL-3.0-only
#include "../engine/device/DualAsioCaptureProbePolicy.h"
#include "../engine/device/ClockBridgeSizing.h"
#include <cstdlib>
#include <cstdio>
#include <string_view>

using Policy=armix::device::DualAsioCaptureProbePolicy;
using V=Policy::Verdict;
static void check(bool ok)
{
// Always active in Release/MSVC CTest; never use NDEBUG-stripped assert.
if (!ok) {std::fputs("IO0_POLICY_FAIL\\n",stderr); std::abort();}
}

int main()
{
const Policy::Identity a{L"ASIO Vendor A",L"{11111111-1111-1111-1111-111111111111}"};
const Policy::Identity b{L"ASIO Vendor B",L"{22222222-2222-2222-2222-222222222222}"};
Policy::Request wanted{L"Vendor A ASIO",L"Vendor B ASIO",a,b,3,3,1};
Policy::Readback actual{L"Vendor A ASIO",L"Vendor B ASIO",
48000.,44100.,256,128,3,3,1,0};
check(Policy::preflight(wanted)==V::ok);
check(Policy::verify(wanted,actual)==V::ok);
check(Policy::preflight({L"Vendor A ASIO",L"Vendor A ASIO",a,a})==
V::sameDriverClass);
check(Policy::preflight({L"Vendor A ASIO",L"Vendor B ASIO",a,a})==
V::sameDriverClass);
check(Policy::preflight({L"",L"Vendor B ASIO",a,b})==
V::missingSelection);
check(Policy::preflight({L"Vendor A ASIO",L"Vendor B ASIO",{},b})==
V::unverifiedPrimaryDriver);
check(Policy::preflight({L"Vendor A ASIO",L"Vendor B ASIO",a,{}})==
V::unverifiedCaptureDriver);
auto changed=actual;
changed.captureName=L"USB Audio with same channel names";
check(Policy::verify(wanted,changed)==V::wrongCaptureEndpoint);
changed=actual;
changed.primaryName=L"Unexpected output";
check(Policy::verify(wanted,changed)==V::wrongPrimaryEndpoint);
changed=actual;
changed.primaryOutputMask=1;
check(Policy::verify(wanted,changed)==V::primaryOutputMissing);
changed=actual;
changed.primaryInputMask=1;
check(Policy::verify(wanted,changed)==V::primaryMaskChanged);
changed=actual;
changed.captureInputMask=0;
check(Policy::verify(wanted,changed)==V::captureInputMissing);
changed=actual;
changed.captureOutputMask=3;
check(Policy::verify(wanted,changed)==V::captureOutputUnexpected);
changed=actual;
changed.captureInputMask=2;
check(Policy::verify(wanted,changed)==V::captureMaskChanged);
changed=actual;
changed.captureRate=0;
check(Policy::verify(wanted,changed)==V::invalidFormat);
changed=actual;
changed.primaryPeriod=0;
check(Policy::verify(wanted,changed)==V::invalidFormat);

// Reuse production ASRC sizing. Different clocks always need a bounded
// prepared source bridge in IO-1; IO-0 does not insert one into primary.
for (const double source : {44100.,48000.,96000.})
for (const double primary : {44100.,48000.,96000.})
{
const auto sizing=armix::device::ClockBridgeSizing::choose(
source,primary,128,256,48,32768,24.);
check(sizing.valid);
check(sizing.targetMs>=24.);
check(sizing.minFrames>0);
}
const auto impossible=armix::device::ClockBridgeSizing::choose(
48000.,48000.,32768,32768,48,32768,24.);
check(!impossible.valid);
std::puts("IO0_POLICY_PASS: identity, zero-output capture, exact masks, 9 clock profiles");
return 0;
}
Loading
Loading