mrmidi · rafalzalech · Sep 15, 2026
diff --git a/ASFWDriver/Audio/Core/AudioCoordinator.cpp b/ASFWDriver/Audio/Core/AudioCoordinator.cpp
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 // Copyright (c) 2026 ASFireWire Project
 
 #include "AudioCoordinator.hpp"
@@ -60,7 +61,28 @@ void AudioCoordinator::OnDeviceAdded(std::shared_ptr<Discovery::FWDevice> device
         remoteLostGuids_.erase(guid);
         IOLockUnlock(lock_);
     }
-    if (BackendForGuid(guid) == &dice_) {
+    const auto record = registry_.SnapshotByGuid(guid);
+    if (record.has_value() &&
+        record->vendorId == DeviceProfiles::Audio::kMotuVendorId &&
+        record->modelId == DeviceProfiles::Audio::kMotuUltraliteSwVersion) {
+        Model::ASFWAudioDevice config{};
+        config.guid = record->guid;
+        config.vendorId = record->vendorId;
+        config.modelId = record->modelId;
+        config.deviceName = "MOTU UltraLite";
+        config.channelCount = 14;
+        config.inputChannelCount = 14;
+        config.outputChannelCount = 14;
+        config.sampleRates = {48000};
+        config.currentSampleRate = 48000;
+        config.inputPlugName = "UltraLite Input";
+        config.outputPlugName = "UltraLite Output";
+        config.streamMode = Model::StreamMode::kBlocking;
+        if (auto endpoint = runtime_.EnsureEndpointRuntime(guid)) {
+            endpoint->UpdateConfig(config);
+        }
+        avc_.OnAudioConfigurationReady(guid, config);
+    } else if (BackendForGuid(guid) == &dice_) {
         dice_.OnDeviceRecordUpdated(guid);
     }
 }
@@ -230,6 +252,9 @@ IAudioBackend* AudioCoordinator::BackendForGuid(uint64_t guid) noexcept {
 
     const auto integration = DeviceProtocolFactory::LookupIntegrationMode(record->vendorId, record->modelId);
     if (integration == DeviceIntegrationMode::kHardcodedNub) {
+        if (record->vendorId == DeviceProfiles::Audio::kMotuVendorId) {
+            return &avc_;
+        }
         return &dice_;
     }
 

diff --git a/ASFWDriver/Audio/Core/AudioRuntimeRegistry.cpp b/ASFWDriver/Audio/Core/AudioRuntimeRegistry.cpp
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 // Copyright (c) 2026 ASFireWire Project
 
 #include "AudioRuntimeRegistry.hpp"
@@ -148,9 +149,9 @@ std::shared_ptr<IDeviceProtocol> AudioRuntimeRegistry::EnsureForDevice(
     // mode). No protocol is created, and nothing is logged, for unknown devices.
     auto created = DeviceProtocolFactory::Create(
         record.vendorId, record.modelId, *busOps, *busInfo, routeRegistry,
-        *route,
-        irmClient,
-        cmpClient_, timerScheduler_);
+        *route, irmClient, cmpClient_, timerScheduler_,
+        DeviceProtocolFactory::UnitIdentity{.specId = record.unitSpecId.value_or(0U),
+                                            .swVersion = record.unitSwVersion.value_or(0U)});
     if (!created) {
         return nullptr;
     }

diff --git a/ASFWDriver/Audio/DriverKit/ASFWAudioDevice.cpp b/ASFWDriver/Audio/DriverKit/ASFWAudioDevice.cpp
@@ -1,3 +1,4 @@
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 //
 // ASFWAudioDevice.cpp
 // ASFWDriver
@@ -595,6 +596,15 @@ kern_return_t ASFWAudioDevice::StopIO(IOUserAudioStartStopFlags in_flags) {
                      control->counters.txPackets.load(std::memory_order_relaxed),
                      control->counters.txSilenceSubstitutions.load(std::memory_order_relaxed),
                      control->counters.txUnderruns.load(std::memory_order_relaxed));
+            const auto& payload =
+                ivars.runtime.txStreamEngine.PayloadWriterCounters();
+            ASFW_LOG(DirectAudio,
+                     "ADK DBG STOPPAYLOAD visited=%llu written=%llu nonZeroFrames=%llu nonZeroSlots=%llu maxAbsBits=0x%08x",
+                     payload.framesVisited.load(std::memory_order_relaxed),
+                     payload.framesWritten.load(std::memory_order_relaxed),
+                     payload.framesNonZero.load(std::memory_order_relaxed),
+                     payload.slotsNonZero.load(std::memory_order_relaxed),
+                     payload.maxAbsSampleBits.load(std::memory_order_relaxed));
         }
 
         if (ivars.device.audioNub) {

diff --git a/ASFWDriver/Audio/DriverKit/ASFWAudioDriverDirect.cpp b/ASFWDriver/Audio/DriverKit/ASFWAudioDriverDirect.cpp
@@ -1,3 +1,4 @@
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 //
 // ASFWAudioDriverDirect.cpp
 // ASFWDriver
@@ -299,6 +300,8 @@ bool BindDirectAudioSkeleton(ASFWAudioDriver_IVars& ivars,
             ivars.device.vendorId, ivars.device.modelId, ivars.device.guid)) {
         if (profile->TxWireFormat() == ASFW::Encoding::AudioWireFormat::kRawPcm24In32) {
             wireFormat = ASFW::Audio::Runtime::AudioWireFormat::kRawPcm24In32;
+        } else if (profile->TxWireFormat() == ASFW::Encoding::AudioWireFormat::kMotuV2) {
+            wireFormat = ASFW::Audio::Runtime::AudioWireFormat::kMotuV2;
         }
     }
 

diff --git a/ASFWDriver/Audio/DriverKit/ASFWAudioDriverGraph.cpp b/ASFWDriver/Audio/DriverKit/ASFWAudioDriverGraph.cpp
@@ -1,3 +1,4 @@
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 //
 // ASFWAudioDriverGraph.cpp
 // ASFWDriver
@@ -142,12 +143,14 @@ kern_return_t BuildAudioGraph(ASFWAudioDriver& driver,
     // Set once a resolved profile supplies its advertised sample-rate set, so the
     // bring-up single-format policy below is skipped for profiled devices.
     bool profileProvidedSampleRates = false;
+    ASFW::Isoch::Audio::PreferredStereoChannels preferredOutputStereo{};
 
     // Resolve audio profile registry on startup
     if (const auto* profile = ASFW::Isoch::Audio::AudioProfileRegistry::FindProfile(
             parsedConfig.vendorId, parsedConfig.modelId, parsedConfig.guid)) {
         ASFW_LOG(Audio, "ASFWAudioDriver: Resolved profile '%{public}s'", profile->Name());
         strlcpy(parsedConfig.deviceName, profile->Name(), sizeof(parsedConfig.deviceName));
+        preferredOutputStereo = profile->PreferredOutputStereoChannels();
 
         const uint32_t rxChannels = profile->RxChannelCount();
         const uint32_t txChannels = profile->TxChannelCount();
@@ -590,6 +593,32 @@ kern_return_t BuildAudioGraph(ASFWAudioDriver& driver,
         state.outputStreamAdded = true;
     }
 
+    if (preferredOutputStereo.left != 0 || preferredOutputStereo.right != 0) {
+        if (preferredOutputStereo.left == 0 ||
+            preferredOutputStereo.right == 0 ||
+            preferredOutputStereo.left == preferredOutputStereo.right ||
+            preferredOutputStereo.left > ivars.device.outputChannelCount ||
+            preferredOutputStereo.right > ivars.device.outputChannelCount) {
+            ASFW_LOG(Audio,
+                     "ADK FATAL GRAPH invalid preferred stereo pair left=%u right=%u outputChannels=%u",
+                     preferredOutputStereo.left,
+                     preferredOutputStereo.right,
+                     ivars.device.outputChannelCount);
+            return kIOReturnBadArgument;
+        }
+        if (!requireAdkSuccess(
+                "device.SetPreferredChannelsForStereo",
+                ivars.audioDevice->SetPreferredChannelsForStereo(
+                    preferredOutputStereo.left,
+                    preferredOutputStereo.right))) {
+            return error;
+        }
+        ASFW_LOG(Audio,
+                 "ASFWAudioDriver: Preferred stereo output channels left=%u right=%u",
+                 preferredOutputStereo.left,
+                 preferredOutputStereo.right);
+    }
+
     // Install the RT handler only after every exposed stream is fully
     // configured and attached. The direct transport buffers remain duplex even
     // for playback-only CoreAudio devices.

diff --git a/ASFWDriver/Audio/DriverKit/ASFWAudioDriverZts.cpp b/ASFWDriver/Audio/DriverKit/ASFWAudioDriverZts.cpp
@@ -1,3 +1,4 @@
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 //
 // ASFWAudioDriverZts.cpp
 // ASFWDriver
@@ -97,6 +98,9 @@ uint32_t PrepareTransmitSlots(ASFWAudioDriver_IVars& ivars,
     if (directControl == nullptr) {
         return 0;
     }
+    const bool isMotu =
+        ivars.runtime.directAudioGraph.hostToDeviceWireFormat ==
+        ASFW::Audio::Runtime::AudioWireFormat::kMotuV2;
 
     uint64_t nextPacketToPrepare = startPacketIndex;
     uint32_t preparedCount = 0;
@@ -298,6 +302,11 @@ uint32_t PrepareTransmitSlots(ASFWAudioDriver_IVars& ivars,
                 directControl->txReplayEntries.fetch_add(
                     1, std::memory_order_relaxed);
                 timing.replayDataBlocks = replay.dataBlocks;
+                timing.packetCycleTicks = packetAnchorTicks;
+                if (isMotu) {
+                    timing.motuSphCount = replay.motuSphCount;
+                    timing.motuSphOffsets = replay.motuSphOffsets;
+                }
             } else {
                 const int64_t replayDistance =
                     replayDiagnostic.readerCursor >= replayDiagnostic.producerCursor
@@ -378,6 +387,46 @@ uint32_t PrepareTransmitSlots(ASFWAudioDriver_IVars& ivars,
             }
 
             if (replay.dataBlocks != 0) {
+                if (isMotu) {
+                    if ((replay.flags &
+                         ASFW::Audio::Runtime::RxSequenceFlags::
+                             kValidMotuSph) == 0 ||
+                        replay.motuSphCount != replay.dataBlocks) {
+                        failProducer(
+                            ASFW::Audio::Runtime::TxProducerFaultStage::
+                                kReplaySytValidation,
+                            ASFW::Audio::Runtime::TxProducerFaultReason::
+                                kInvalidReplaySyt,
+                            ASFW::Audio::Runtime::FatalStreamReason::
+                                TxReplayInvalidSyt,
+                            nextPacketToPrepare);
+                        break;
+                    }
+                    timing.txClockValid = true;
+                    timing.disposition =
+                        ASFW::Protocols::Audio::AMDTP::
+                            AmdtpPacketDisposition::Data;
+
+                    const int64_t sourceTicks =
+                        ASFW::Timing::encodedTstampToOffsets(
+                            replay.sourceCycleTimer);
+                    const int64_t deltaTicks =
+                        ASFW::Timing::extOffsetDiff(
+                            ASFW::Timing::normalizeOffsetDomain(
+                                packetAnchorTicks),
+                            ASFW::Timing::normalizeOffsetDomain(sourceTicks));
+                    if (deltaTicks >= 0) {
+                        const auto& txConfig =
+                            ivars.runtime.txStreamEngine.StreamConfig();
+                        const uint64_t projectedFrame =
+                            replay.firstAudioFrame +
+                            (static_cast<uint64_t>(deltaTicks) *
+                             txConfig.sampleRate) /
+                                ASFW::Timing::kTicksPerSecond;
+                        (void)ivars.runtime.txStreamEngine
+                            .AlignFrameCursorOnce(projectedFrame);
+                    }
+                } else {
                 if (replay.sytOffset ==
                         ASFW::Audio::Runtime::
                             RxSequenceReplayState::kNoInfo ||
@@ -497,6 +546,7 @@ uint32_t PrepareTransmitSlots(ASFWAudioDriver_IVars& ivars,
                                  txConfig.sampleRate);
                     }
                 }
+                }
             }
         }
 

diff --git a/ASFWDriver/Audio/DriverKit/Config/AudioProfileRegistry.cpp b/ASFWDriver/Audio/DriverKit/Config/AudioProfileRegistry.cpp
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 // Copyright (c) 2026 ASFireWire Project
 //
 // AudioProfileRegistry.cpp
@@ -9,6 +10,7 @@
 #include "AVC/BeBoBProfile.hpp"
 #include "AVC/Phase88Profile.hpp"
 #include "DICE/DiceProfileRegistry.hpp"
+#include "MOTU/MotuUltraLiteProfile.hpp"
 #include "../../../Audio/Protocols/BeBoB/BeBoBPlug0StreamDiscovery.hpp"
 
 #include "../../../DeviceProfiles/Audio/AudioDeviceIds.hpp"
@@ -23,6 +25,12 @@ std::unordered_map<uint64_t, std::unique_ptr<IAudioDeviceProfile>>& AudioProfile
 const IAudioDeviceProfile* AudioProfileRegistry::FindProfile(uint32_t vendorId,
                                                              uint32_t modelId,
                                                              uint64_t guid) noexcept {
+    static MOTU::MotuUltraLiteProfile motuUltraLiteProfile{};
+    if (vendorId == DeviceProfiles::Audio::kMotuVendorId &&
+        modelId == DeviceProfiles::Audio::kMotuUltraliteSwVersion) {
+        return &motuUltraLiteProfile;
+    }
+
     // Curated static profiles win over everything else: a discovery-derived
     // per-GUID profile must never shadow a hand-validated device profile
     // (curated name, warm-up/idle-packet policy, rate set). Shadowing Phase88

diff --git a/ASFWDriver/Audio/DriverKit/Config/AudioStreamProfile.hpp b/ASFWDriver/Audio/DriverKit/Config/AudioStreamProfile.hpp
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 // Copyright (c) 2026 ASFireWire Project
 //
 // AudioStreamProfile.hpp - Protocol-neutral ADK stream geometry contract.
@@ -7,6 +8,7 @@
 
 #include "IAudioDeviceProfile.hpp"
 
+#include <array>
 #include <cstdint>
 
 namespace ASFW::Isoch::Audio {
@@ -28,6 +30,7 @@ struct AudioStreamConfig final {
     uint8_t fdf{0x02};
     uint8_t fmt{0x10};
     uint8_t sourceChannelOffset{0};
+    bool sph{false};
 };
 
 struct AudioStreamTxPolicy final {
@@ -37,6 +40,10 @@ struct AudioStreamTxPolicy final {
     bool initializeNonAudioSlots{true};
     bool preserveFdfInNoDataPackets{false};
     bool emptyPacketsDuringIdle{false};
+    // Optional per-stream map from each wire PCM slot to a zero-based host
+    // channel. Values are relative to sourceChannelOffset.
+    std::array<uint8_t, 32> sourceChannelForWireSlot{};
+    bool sourceChannelMapEnabled{false};
 };
 
 // ADK packet allocation and AMDTP encoding are shared by multiple protocol

diff --git a/ASFWDriver/Audio/DriverKit/Config/IAudioDeviceProfile.hpp b/ASFWDriver/Audio/DriverKit/Config/IAudioDeviceProfile.hpp
@@ -1,4 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
+// Modified in 2026 by Rafal Zalech to add original MOTU UltraLite support.
 // Copyright (c) 2026 ASFireWire Project
 //
 // IAudioDeviceProfile.hpp
@@ -12,6 +13,13 @@
 
 namespace ASFW::Isoch::Audio {
 
+/// One-based Core Audio channel numbers for a device's default stereo route.
+/// A zero value means the profile has no hardware-specific preference.
+struct PreferredStereoChannels {
+    uint32_t left{0};
+    uint32_t right{0};
+};
+
 /// Protocol-agnostic device profile interface for ADK Dext configuration.
 /// Since the driver is compiled with -fno-rtti, all polymorphism is statically
 /// declared as virtual interface methods.
@@ -66,6 +74,12 @@ class IAudioDeviceProfile {
         return {48000u};
     }
 
+    /// Preferred output pair for ordinary stereo clients. Multichannel clients
+    /// still retain direct access to every advertised output channel.
+    [[nodiscard]] virtual PreferredStereoChannels PreferredOutputStereoChannels() const noexcept {
+        return {};
+    }
+
     /// IEC 61883-6 presentation delay removed from received SYT before replay.
     [[nodiscard]] virtual uint32_t RxTransferDelayTicks(double sampleRate) const noexcept {
         (void)sampleRate;