mirror of
https://github.com/gnif/LookingGlass.git
synced 2026-11-12 14:57:20 +00:00
b75b90ff1d
Publish committed WaveRT render frames on a 4 kHz timer while keeping packet completion and notification semantics unchanged. Serialize clock sampling with position updates to prevent concurrent queries from replaying elapsed time.
495 lines
13 KiB
C++
495 lines
13 KiB
C++
/**
|
|
* Looking Glass
|
|
* Copyright © 2017-2026 The Looking Glass Authors
|
|
* https://looking-glass.io
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the Free
|
|
* Software Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc., 59
|
|
* Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "Adapter.h"
|
|
#include "BrokerDevice.h"
|
|
#include "Formats.h"
|
|
#include "MiniportTopology.h"
|
|
#include "MiniportWaveRT.h"
|
|
|
|
namespace
|
|
{
|
|
NTSTATUS InstallTopologySubdevice(
|
|
_In_ PDEVICE_OBJECT deviceObject,
|
|
_In_ PIRP irp,
|
|
_In_ PRESOURCELIST resourceList,
|
|
_In_ CAudioAdapter *adapter,
|
|
_In_ EndpointKind kind,
|
|
_In_ const wchar_t *name,
|
|
_Outptr_ PUNKNOWN *portUnknown)
|
|
{
|
|
*portUnknown = nullptr;
|
|
|
|
PPORT port = nullptr;
|
|
NTSTATUS status = PcNewPort(&port, CLSID_PortTopology);
|
|
if (!NT_SUCCESS(status))
|
|
return status;
|
|
|
|
CMiniportTopology *miniport = new(NonPagedPoolNx, LGAUDIO_POOL_TAG)
|
|
CMiniportTopology(kind);
|
|
if (!miniport)
|
|
{
|
|
port->Release();
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
status = port->Init(deviceObject, irp,
|
|
static_cast<IMiniportTopology *>(miniport), adapter, resourceList);
|
|
if (NT_SUCCESS(status))
|
|
status = PcRegisterSubdevice(deviceObject,
|
|
const_cast<PWSTR>(name), port);
|
|
|
|
miniport->Release();
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
port->Release();
|
|
return status;
|
|
}
|
|
|
|
*portUnknown = port;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS InstallWaveSubdevice(
|
|
_In_ PDEVICE_OBJECT deviceObject,
|
|
_In_ PIRP irp,
|
|
_In_ PRESOURCELIST resourceList,
|
|
_In_ CAudioAdapter *adapter,
|
|
_In_ EndpointKind kind,
|
|
_In_ const wchar_t *name,
|
|
_Outptr_ PUNKNOWN *portUnknown)
|
|
{
|
|
*portUnknown = nullptr;
|
|
|
|
PPORT port = nullptr;
|
|
NTSTATUS status = PcNewPort(&port, CLSID_PortWaveRT);
|
|
if (!NT_SUCCESS(status))
|
|
return status;
|
|
|
|
CMiniportWaveRT *miniport = new(NonPagedPoolNx, LGAUDIO_POOL_TAG)
|
|
CMiniportWaveRT(adapter, kind);
|
|
if (!miniport)
|
|
{
|
|
port->Release();
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
}
|
|
|
|
status = port->Init(deviceObject, irp,
|
|
static_cast<IMiniportWaveRT *>(miniport), adapter, resourceList);
|
|
if (NT_SUCCESS(status))
|
|
status = PcRegisterSubdevice(deviceObject,
|
|
const_cast<PWSTR>(name), port);
|
|
|
|
miniport->Release();
|
|
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
port->Release();
|
|
return status;
|
|
}
|
|
|
|
*portUnknown = port;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
CAudioAdapter::CAudioAdapter() :
|
|
m_refCount(1),
|
|
m_brokerActive(0),
|
|
m_renderDiscontinuity(0),
|
|
m_renderState{},
|
|
m_captureState{}
|
|
{
|
|
KeInitializeSpinLock(&m_transportLock);
|
|
KeInitializeSpinLock(&m_streamStateLock);
|
|
m_renderState.state = KSSTATE_STOP;
|
|
m_captureState.state = KSSTATE_STOP;
|
|
}
|
|
|
|
CAudioAdapter::~CAudioAdapter()
|
|
{
|
|
m_captureRing.Destroy();
|
|
m_renderRing.Destroy();
|
|
}
|
|
|
|
NTSTATUS CAudioAdapter::Initialize()
|
|
{
|
|
NTSTATUS status = m_clock.Initialize();
|
|
if (NT_SUCCESS(status))
|
|
status = m_renderRing.Init();
|
|
if (NT_SUCCESS(status))
|
|
status = m_captureRing.Init();
|
|
return status;
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
NTSTATUS CAudioAdapter::ConfigureStream(
|
|
_In_ EndpointKind kind,
|
|
_In_ const FormatFingerprint &format)
|
|
{
|
|
CAudioRingBuffer &ring = kind == EndpointKind::Render ?
|
|
m_renderRing : m_captureRing;
|
|
KIRQL transportIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &transportIrql);
|
|
const NTSTATUS status = ring.Configure(format);
|
|
if (!NT_SUCCESS(status))
|
|
{
|
|
KeReleaseSpinLock(&m_transportLock, transportIrql);
|
|
return status;
|
|
}
|
|
|
|
KIRQL oldIrql;
|
|
KeAcquireSpinLock(&m_streamStateLock, &oldIrql);
|
|
AudioStreamSnapshot &stream = kind == EndpointKind::Render ?
|
|
m_renderState : m_captureState;
|
|
stream.format = format;
|
|
stream.formatValid = true;
|
|
++stream.generation;
|
|
KeReleaseSpinLock(&m_streamStateLock, oldIrql);
|
|
KeReleaseSpinLock(&m_transportLock, transportIrql);
|
|
|
|
BrokerDeviceNotifyStreamChanged(this, kind);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
void CAudioAdapter::SetStreamState(
|
|
_In_ EndpointKind kind,
|
|
_In_ KSSTATE state)
|
|
{
|
|
bool changed;
|
|
bool reset;
|
|
|
|
KIRQL transportIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &transportIrql);
|
|
KIRQL oldIrql;
|
|
KeAcquireSpinLock(&m_streamStateLock, &oldIrql);
|
|
AudioStreamSnapshot &stream = kind == EndpointKind::Render ?
|
|
m_renderState : m_captureState;
|
|
changed = stream.state != state;
|
|
reset = changed && state == KSSTATE_STOP;
|
|
stream.state = state;
|
|
if (reset)
|
|
++stream.generation;
|
|
KeReleaseSpinLock(&m_streamStateLock, oldIrql);
|
|
|
|
if (reset)
|
|
{
|
|
if (kind == EndpointKind::Render)
|
|
m_renderRing.Reset();
|
|
else
|
|
m_captureRing.Reset();
|
|
}
|
|
KeReleaseSpinLock(&m_transportLock, transportIrql);
|
|
if (changed)
|
|
BrokerDeviceNotifyStreamChanged(this, kind);
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
void CAudioAdapter::GetStreamSnapshot(
|
|
_In_ EndpointKind kind,
|
|
_Out_ AudioStreamSnapshot *snapshot)
|
|
{
|
|
if (!snapshot)
|
|
return;
|
|
|
|
KIRQL oldIrql;
|
|
KeAcquireSpinLock(&m_streamStateLock, &oldIrql);
|
|
*snapshot = kind == EndpointKind::Render ?
|
|
m_renderState : m_captureState;
|
|
KeReleaseSpinLock(&m_streamStateLock, oldIrql);
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
void CAudioAdapter::SetBrokerActive(_In_ bool active)
|
|
{
|
|
KIRQL oldIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &oldIrql);
|
|
const LONG value = active ? 1 : 0;
|
|
if (InterlockedExchange(&m_brokerActive, value) == value)
|
|
{
|
|
KeReleaseSpinLock(&m_transportLock, oldIrql);
|
|
return;
|
|
}
|
|
|
|
m_captureRing.Reset();
|
|
m_renderRing.Reset();
|
|
InterlockedExchange(&m_renderDiscontinuity, active ? 1 : 0);
|
|
KeReleaseSpinLock(&m_transportLock, oldIrql);
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
void CAudioAdapter::ResetCapture()
|
|
{
|
|
KIRQL oldIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &oldIrql);
|
|
if (InterlockedCompareExchange(&m_brokerActive, 0, 0))
|
|
m_captureRing.Reset();
|
|
else
|
|
m_renderRing.Reset();
|
|
KeReleaseSpinLock(&m_transportLock, oldIrql);
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
void CAudioAdapter::WriteRenderFrames(
|
|
_In_reads_bytes_(bytes) const BYTE *data,
|
|
_In_ ULONG bytes)
|
|
{
|
|
ULONG droppedBytes = 0;
|
|
KIRQL oldIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &oldIrql);
|
|
m_renderRing.Push(data, bytes, &droppedBytes);
|
|
if (droppedBytes)
|
|
InterlockedExchange(&m_renderDiscontinuity, 1);
|
|
KeReleaseSpinLock(&m_transportLock, oldIrql);
|
|
BrokerDeviceNotifyRenderAvailable(this, bytes, droppedBytes);
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
void CAudioAdapter::MarkRenderDiscontinuity()
|
|
{
|
|
InterlockedExchange(&m_renderDiscontinuity, 1);
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
void CAudioAdapter::ReadCaptureFrames(
|
|
_In_ const FormatFingerprint &format,
|
|
_Out_writes_bytes_(bytes) BYTE *data,
|
|
_In_ ULONG bytes)
|
|
{
|
|
KIRQL oldIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &oldIrql);
|
|
const bool brokerActive =
|
|
InterlockedCompareExchange(&m_brokerActive, 0, 0) != 0;
|
|
CAudioRingBuffer &ring = brokerActive ?
|
|
m_captureRing : m_renderRing;
|
|
const ULONG copied = ring.Pop(format, data, bytes);
|
|
KeReleaseSpinLock(&m_transportLock, oldIrql);
|
|
if (brokerActive && copied < bytes)
|
|
BrokerDeviceRecordCaptureUnderrun(this, bytes - copied);
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
void CAudioAdapter::DiscardCaptureFrames(
|
|
_In_ const FormatFingerprint &format,
|
|
_In_ ULONGLONG bytes)
|
|
{
|
|
KIRQL oldIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &oldIrql);
|
|
const bool brokerActive =
|
|
InterlockedCompareExchange(&m_brokerActive, 0, 0) != 0;
|
|
CAudioRingBuffer &ring = brokerActive ?
|
|
m_captureRing : m_renderRing;
|
|
const ULONG discarded = ring.Discard(format, bytes);
|
|
KeReleaseSpinLock(&m_transportLock, oldIrql);
|
|
if (brokerActive && bytes > discarded)
|
|
BrokerDeviceRecordCaptureUnderrun(this, bytes - discarded);
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
NTSTATUS CAudioAdapter::ReadRenderFrames(
|
|
_In_ const FormatFingerprint &format,
|
|
_In_ ULONGLONG streamGeneration,
|
|
_Out_writes_bytes_(capacity) BYTE *data,
|
|
_In_ ULONG capacity,
|
|
_Out_ PULONG bytesRead,
|
|
_Out_ bool *discontinuity)
|
|
{
|
|
if (!data || !bytesRead || !discontinuity || !format.blockAlign)
|
|
return STATUS_INVALID_PARAMETER;
|
|
|
|
*bytesRead = 0;
|
|
*discontinuity = false;
|
|
KIRQL transportIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &transportIrql);
|
|
|
|
KIRQL stateIrql;
|
|
KeAcquireSpinLock(&m_streamStateLock, &stateIrql);
|
|
const bool active =
|
|
InterlockedCompareExchange(&m_brokerActive, 0, 0) != 0 &&
|
|
m_renderState.state == KSSTATE_RUN &&
|
|
m_renderState.formatValid &&
|
|
m_renderState.generation == streamGeneration &&
|
|
EqualFormatFingerprint(m_renderState.format, format);
|
|
KeReleaseSpinLock(&m_streamStateLock, stateIrql);
|
|
if (!active)
|
|
{
|
|
KeReleaseSpinLock(&m_transportLock, transportIrql);
|
|
return STATUS_DEVICE_NOT_READY;
|
|
}
|
|
|
|
ULONG bytes = m_renderRing.Available();
|
|
if (bytes > capacity)
|
|
bytes = capacity;
|
|
bytes -= bytes % format.blockAlign;
|
|
if (!bytes)
|
|
{
|
|
KeReleaseSpinLock(&m_transportLock, transportIrql);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
const ULONG copied = m_renderRing.Pop(format, data, bytes);
|
|
if (copied)
|
|
{
|
|
*discontinuity = InterlockedExchange(
|
|
&m_renderDiscontinuity, 0) != 0;
|
|
}
|
|
*bytesRead = copied;
|
|
KeReleaseSpinLock(&m_transportLock, transportIrql);
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
NTSTATUS CAudioAdapter::WriteCaptureFrames(
|
|
_In_ const FormatFingerprint &format,
|
|
_In_ ULONGLONG streamGeneration,
|
|
_In_ bool discontinuity,
|
|
_In_reads_bytes_(bytes) const BYTE *data,
|
|
_In_ ULONG bytes,
|
|
_Out_ PULONG droppedBytes)
|
|
{
|
|
if (!data || !droppedBytes)
|
|
return STATUS_INVALID_PARAMETER;
|
|
|
|
*droppedBytes = 0;
|
|
KIRQL transportIrql;
|
|
KeAcquireSpinLock(&m_transportLock, &transportIrql);
|
|
|
|
KIRQL stateIrql;
|
|
KeAcquireSpinLock(&m_streamStateLock, &stateIrql);
|
|
const bool active =
|
|
InterlockedCompareExchange(&m_brokerActive, 0, 0) != 0 &&
|
|
m_captureState.state == KSSTATE_RUN &&
|
|
m_captureState.formatValid &&
|
|
m_captureState.generation == streamGeneration &&
|
|
EqualFormatFingerprint(m_captureState.format, format);
|
|
KeReleaseSpinLock(&m_streamStateLock, stateIrql);
|
|
if (!active)
|
|
{
|
|
KeReleaseSpinLock(&m_transportLock, transportIrql);
|
|
return STATUS_DEVICE_NOT_READY;
|
|
}
|
|
|
|
if (discontinuity)
|
|
m_captureRing.Reset();
|
|
const ULONG written = m_captureRing.Push(data, bytes, droppedBytes);
|
|
KeReleaseSpinLock(&m_transportLock, transportIrql);
|
|
return written == bytes ? STATUS_SUCCESS : STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
_IRQL_requires_max_(DISPATCH_LEVEL)
|
|
AudioClockSnapshot CAudioAdapter::GetClockSnapshot() const
|
|
{
|
|
return m_clock.GetSnapshot();
|
|
}
|
|
|
|
NTSTATUS CAudioAdapter::QueryInterface(
|
|
_In_ REFIID interfaceId,
|
|
_COM_Outptr_ void **object)
|
|
{
|
|
if (!object)
|
|
return STATUS_INVALID_PARAMETER;
|
|
|
|
*object = nullptr;
|
|
if (!GuidEqual(interfaceId, IID_IUnknown))
|
|
return STATUS_NOINTERFACE;
|
|
|
|
*object = static_cast<IUnknown *>(this);
|
|
AddRef();
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
ULONG CAudioAdapter::AddRef()
|
|
{
|
|
return static_cast<ULONG>(InterlockedIncrement(&m_refCount));
|
|
}
|
|
|
|
ULONG CAudioAdapter::Release()
|
|
{
|
|
const LONG count = InterlockedDecrement(&m_refCount);
|
|
if (!count)
|
|
delete this;
|
|
return static_cast<ULONG>(count);
|
|
}
|
|
|
|
NTSTATUS StartAudioDevice(
|
|
_In_ PDEVICE_OBJECT deviceObject,
|
|
_In_ PIRP irp,
|
|
_In_ PRESOURCELIST resourceList)
|
|
{
|
|
PUNKNOWN topologyRender = nullptr;
|
|
PUNKNOWN waveRender = nullptr;
|
|
PUNKNOWN topologyCapture = nullptr;
|
|
PUNKNOWN waveCapture = nullptr;
|
|
|
|
CAudioAdapter *adapter = new(NonPagedPoolNx, LGAUDIO_POOL_TAG)
|
|
CAudioAdapter();
|
|
if (!adapter)
|
|
return STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
NTSTATUS status = adapter->Initialize();
|
|
if (NT_SUCCESS(status))
|
|
status = InstallTopologySubdevice(deviceObject, irp, resourceList,
|
|
adapter, EndpointKind::Render, kTopologyRenderName, &topologyRender);
|
|
if (NT_SUCCESS(status))
|
|
status = InstallWaveSubdevice(deviceObject, irp, resourceList,
|
|
adapter, EndpointKind::Render, kWaveRenderName, &waveRender);
|
|
if (NT_SUCCESS(status))
|
|
status = InstallTopologySubdevice(deviceObject, irp, resourceList,
|
|
adapter, EndpointKind::Capture, kTopologyCaptureName,
|
|
&topologyCapture);
|
|
if (NT_SUCCESS(status))
|
|
status = InstallWaveSubdevice(deviceObject, irp, resourceList,
|
|
adapter, EndpointKind::Capture, kWaveCaptureName, &waveCapture);
|
|
|
|
if (NT_SUCCESS(status))
|
|
status = PcRegisterPhysicalConnection(deviceObject, waveRender,
|
|
kRenderWaveBridgePin, topologyRender, kRenderTopologyBridgePin);
|
|
if (NT_SUCCESS(status))
|
|
status = PcRegisterPhysicalConnection(deviceObject, topologyCapture,
|
|
kCaptureTopologyBridgePin, waveCapture, kCaptureWaveBridgePin);
|
|
|
|
if (NT_SUCCESS(status))
|
|
{
|
|
const NTSTATUS brokerStatus =
|
|
BrokerDeviceAttachAdapter(deviceObject, adapter);
|
|
if (!NT_SUCCESS(brokerStatus))
|
|
{
|
|
LGAUDIO_TRACE_ERROR("broker adapter unavailable: 0x%08X",
|
|
brokerStatus);
|
|
}
|
|
}
|
|
|
|
SafeRelease(waveCapture);
|
|
SafeRelease(topologyCapture);
|
|
SafeRelease(waveRender);
|
|
SafeRelease(topologyRender);
|
|
adapter->Release();
|
|
|
|
if (!NT_SUCCESS(status))
|
|
LGAUDIO_TRACE_ERROR("device start failed: 0x%08X", status);
|
|
else
|
|
LGAUDIO_TRACE_INFO("render and capture endpoints registered (%s)",
|
|
"Looking Glass Audio");
|
|
|
|
return status;
|
|
}
|