mirror of
https://github.com/gnif/LookingGlass.git
synced 2026-11-13 07:17:28 +00:00
36e170d93a
Replace the single-owner PCM queues with one shared LGMP SPMC stream. Give each admitted client reliable state and an independent playback cursor, while clients without clock authority resample locally. Extend the audio protocol with per-client epochs and barriers. Keep capture exclusive and bound authority backpressure so slow secondary readers cannot affect the disciplined low-latency path.
3008 lines
94 KiB
C++
3008 lines
94 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 <ntstatus.h>
|
|
|
|
#include "transport/lgmp/CLGMPAudioTransport.h"
|
|
|
|
#include <wudfwdm.h>
|
|
|
|
#include "CDebug.h"
|
|
#include "WCWrite.h"
|
|
#include "transport/lgmp/CLGMPControl.h"
|
|
#include "transport/lgmp/CLGMPHost.h"
|
|
|
|
#include <LGProtocol/KVMFR.h>
|
|
|
|
#include <avrt.h>
|
|
#include <initializer_list>
|
|
#include <limits>
|
|
#include <string.h>
|
|
|
|
#ifndef CREATE_WAITABLE_TIMER_HIGH_RESOLUTION
|
|
#define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION 0x00000002
|
|
#endif
|
|
|
|
namespace
|
|
{
|
|
static_assert(sizeof(KVMFRCursor) == KVMFR_AUDIO_CURSOR_COMPAT_BYTES,
|
|
"KVMFR cursor compatibility layout changed");
|
|
static_assert(AUDIO_MAX_CHANNELS == KVMFR_AUDIO_MAX_CHANNELS,
|
|
"audio channel limits differ");
|
|
static_assert(AUDIO_STREAM_MAX_CHANNELS ==
|
|
KVMFR_AUDIO_STREAM_MAX_CHANNELS,
|
|
"audio stream channel limits differ");
|
|
static_assert(AUDIO_MAX_FRAMES_PER_PACKET ==
|
|
KVMFR_AUDIO_MAX_FRAMES_PER_PACKET,
|
|
"audio packet limits differ");
|
|
static_assert(AUDIO_MAX_PCM_BYTES == KVMFR_AUDIO_PCM_BYTES,
|
|
"audio PCM limits differ");
|
|
static_assert(
|
|
static_cast<uint32_t>(AudioSampleFormat::S16_LE) ==
|
|
KVMFR_AUDIO_SAMPLE_S16_LE &&
|
|
static_cast<uint32_t>(AudioSampleFormat::S24_LE) ==
|
|
KVMFR_AUDIO_SAMPLE_S24_LE &&
|
|
static_cast<uint32_t>(AudioSampleFormat::S32_LE) ==
|
|
KVMFR_AUDIO_SAMPLE_S32_LE &&
|
|
static_cast<uint32_t>(AudioSampleFormat::F32_LE) ==
|
|
KVMFR_AUDIO_SAMPLE_F32_LE,
|
|
"audio sample formats differ");
|
|
static_assert(static_cast<uint32_t>(AUDIO_CAP_PLAYBACK) ==
|
|
static_cast<uint32_t>(KVMFR_AUDIO_CAP_PLAYBACK) &&
|
|
static_cast<uint32_t>(AUDIO_CAP_CAPTURE) ==
|
|
static_cast<uint32_t>(KVMFR_AUDIO_CAP_CAPTURE) &&
|
|
static_cast<uint32_t>(AUDIO_CAP_CLOCK_FEEDBACK) ==
|
|
static_cast<uint32_t>(KVMFR_AUDIO_CAP_CLOCK_FEEDBACK),
|
|
"audio capability bits differ");
|
|
static_assert(sizeof(LGMPStreamDescriptor) ==
|
|
sizeof(KVMFRStreamDescriptor),
|
|
"LGMP and KVMFR stream descriptor sizes differ");
|
|
static_assert(sizeof(LGMPSPMCDescriptor) ==
|
|
sizeof(KVMFRSPMCDescriptor),
|
|
"LGMP and KVMFR SPMC descriptor sizes differ");
|
|
static_assert(LGMP_MAX_CLIENTS ==
|
|
KVMFR_AUDIO_MAX_PLAYBACK_READERS,
|
|
"audio reader and LGMP client limits differ");
|
|
|
|
constexpr uint32_t AUDIO_CAPABILITY_MASK =
|
|
KVMFR_AUDIO_CAP_PLAYBACK | KVMFR_AUDIO_CAP_CAPTURE |
|
|
KVMFR_AUDIO_CAP_CLOCK_FEEDBACK;
|
|
constexpr uint32_t AUDIO_SUBSCRIPTION_MASK =
|
|
KVMFR_AUDIO_SUBSCRIBE_PLAYBACK | KVMFR_AUDIO_SUBSCRIBE_CAPTURE;
|
|
constexpr uint32_t AUDIO_PACKET_FLAG_MASK =
|
|
AUDIO_PACKET_DISCONTINUITY | AUDIO_PACKET_SILENT |
|
|
AUDIO_PACKET_CLOCK_VALID | AUDIO_PACKET_CLOCK_STABLE;
|
|
constexpr uint32_t WIRE_PACKET_FLAG_MASK =
|
|
KVMFR_AUDIO_MESSAGE_DISCONTINUITY |
|
|
KVMFR_AUDIO_MESSAGE_SILENT |
|
|
KVMFR_AUDIO_MESSAGE_CLOCK_VALID |
|
|
KVMFR_AUDIO_MESSAGE_CLOCK_STABLE;
|
|
constexpr size_t AUDIO_SHARED_MEMORY_PREFLIGHT =
|
|
3U * 1024U * 1024U;
|
|
|
|
bool ArmAudioPollTimer(HANDLE timer, uint32_t waitUs)
|
|
{
|
|
LARGE_INTEGER due = {};
|
|
due.QuadPart = -static_cast<LONGLONG>(waitUs) * 10;
|
|
return SetWaitableTimer(timer, &due, 0, nullptr, nullptr, FALSE) != FALSE;
|
|
}
|
|
|
|
uint32_t ChannelCount(uint32_t mask)
|
|
{
|
|
uint32_t count = 0;
|
|
while (mask)
|
|
{
|
|
count += mask & 1U;
|
|
mask >>= 1;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
uint64_t NextSerial(uint64_t serial)
|
|
{
|
|
++serial;
|
|
return serial ? serial : 1;
|
|
}
|
|
|
|
uint32_t NextEpoch(uint32_t epoch)
|
|
{
|
|
++epoch;
|
|
return epoch ? epoch : 1;
|
|
}
|
|
|
|
bool RequestNewer(uint32_t candidate, uint32_t previous)
|
|
{
|
|
return candidate != previous &&
|
|
static_cast<int32_t>(candidate - previous) > 0;
|
|
}
|
|
|
|
bool EmptyControl(const KVMFRAudioMessage& message)
|
|
{
|
|
return !message.streamGeneration && !message.flags &&
|
|
!message.position && !message.timeNs && !message.rateQ32 &&
|
|
!message.frames && !message.length;
|
|
}
|
|
}
|
|
|
|
CLGMPAudio::~CLGMPAudio()
|
|
{
|
|
TransportStop();
|
|
CSRWExclusiveLock lock(m_lock);
|
|
for (ResponseMemory& response : m_responseMemory)
|
|
lgmpHostMemFree(&response.memory);
|
|
FreeStreams();
|
|
m_initialized = false;
|
|
}
|
|
|
|
bool CLGMPAudio::SameFormat(
|
|
const AudioFormat& left, const AudioFormat& right)
|
|
{
|
|
return left.sampleFormat == right.sampleFormat &&
|
|
left.sampleRate == right.sampleRate &&
|
|
left.channelMask == right.channelMask &&
|
|
left.channels == right.channels &&
|
|
left.containerBits == right.containerBits &&
|
|
left.validBits == right.validBits &&
|
|
left.blockAlign == right.blockAlign;
|
|
}
|
|
|
|
bool CLGMPAudio::SamePacket(
|
|
const AudioPacket& left, const AudioPacket& right)
|
|
{
|
|
return left.endpointGeneration == right.endpointGeneration &&
|
|
left.streamGeneration == right.streamGeneration &&
|
|
left.flags == right.flags && left.frames == right.frames &&
|
|
left.position == right.position && left.timeNs == right.timeNs &&
|
|
left.rateQ32 == right.rateQ32 && SameFormat(left.format, right.format);
|
|
}
|
|
|
|
bool CLGMPAudio::ValidFormat(const AudioFormat& format)
|
|
{
|
|
if (!format.sampleRate ||
|
|
format.sampleRate > KVMFR_AUDIO_MAX_SAMPLE_RATE ||
|
|
!format.channels ||
|
|
format.channels > KVMFR_AUDIO_STREAM_MAX_CHANNELS ||
|
|
!format.channelMask ||
|
|
(format.channelMask & ~KVMFR_AUDIO_CHANNEL_POSITION_MASK) ||
|
|
ChannelCount(format.channelMask) != format.channels)
|
|
return false;
|
|
|
|
bool validSampleFormat = false;
|
|
switch (format.sampleFormat)
|
|
{
|
|
case AudioSampleFormat::S16_LE:
|
|
validSampleFormat =
|
|
format.containerBits == 16 && format.validBits == 16;
|
|
break;
|
|
case AudioSampleFormat::S24_LE:
|
|
validSampleFormat =
|
|
format.containerBits == 24 && format.validBits == 24;
|
|
break;
|
|
case AudioSampleFormat::S32_LE:
|
|
case AudioSampleFormat::F32_LE:
|
|
validSampleFormat =
|
|
format.containerBits == 32 && format.validBits == 32;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
const uint16_t bytes = static_cast<uint16_t>(
|
|
format.channels * (format.containerBits / 8U));
|
|
return validSampleFormat && format.blockAlign == bytes;
|
|
}
|
|
|
|
KVMFRAudioFormat CLGMPAudio::WireFormat(
|
|
const AudioFormat& format)
|
|
{
|
|
KVMFRAudioFormat result = {};
|
|
result.version = KVMFR_AUDIO_FORMAT_VERSION;
|
|
result.size = sizeof(result);
|
|
result.sampleFormat = static_cast<uint32_t>(format.sampleFormat);
|
|
result.sampleRate = format.sampleRate;
|
|
result.channelMask = format.channelMask;
|
|
result.channelCount = format.channels;
|
|
result.validBits = format.validBits;
|
|
result.containerBits = format.containerBits;
|
|
result.blockAlign = format.blockAlign;
|
|
return result;
|
|
}
|
|
|
|
KVMFRAudioStreamState CLGMPAudio::WireState(
|
|
AudioStreamState state)
|
|
{
|
|
switch (state)
|
|
{
|
|
case AudioStreamState::ACQUIRED:
|
|
return KVMFR_AUDIO_STREAM_ACQUIRED;
|
|
case AudioStreamState::PAUSED:
|
|
return KVMFR_AUDIO_STREAM_PAUSED;
|
|
case AudioStreamState::RUNNING:
|
|
return KVMFR_AUDIO_STREAM_RUNNING;
|
|
default:
|
|
return KVMFR_AUDIO_STREAM_STOPPED;
|
|
}
|
|
}
|
|
|
|
KVMFRStreamDescriptor CLGMPAudio::WireDescriptor(
|
|
const LGMPStreamDescriptor& descriptor)
|
|
{
|
|
KVMFRStreamDescriptor wire = {};
|
|
wire.magic = descriptor.magic;
|
|
wire.version = descriptor.version;
|
|
wire.size = descriptor.size;
|
|
wire.offset = descriptor.offset;
|
|
wire.regionSize = descriptor.regionSize;
|
|
wire.direction = descriptor.direction;
|
|
wire.policy = descriptor.policy;
|
|
wire.slotCount = descriptor.slotCount;
|
|
wire.slotSize = descriptor.slotSize;
|
|
return wire;
|
|
}
|
|
|
|
KVMFRSPMCDescriptor CLGMPAudio::WireDescriptor(
|
|
const LGMPSPMCDescriptor& descriptor)
|
|
{
|
|
KVMFRSPMCDescriptor wire = {};
|
|
wire.magic = descriptor.magic;
|
|
wire.version = descriptor.version;
|
|
wire.size = descriptor.size;
|
|
wire.offset = descriptor.offset;
|
|
wire.regionSize = descriptor.regionSize;
|
|
wire.slotCount = descriptor.slotCount;
|
|
wire.slotSize = descriptor.slotSize;
|
|
wire.maxReaders = descriptor.maxReaders;
|
|
wire.reserved = descriptor.reserved;
|
|
return wire;
|
|
}
|
|
|
|
bool CLGMPAudio::InitializeStreams()
|
|
{
|
|
const LGMPSPMCConfig playback =
|
|
{
|
|
KVMFR_AUDIO_STREAM_SLOT_COUNT,
|
|
static_cast<uint32_t>(KVMFR_AUDIO_PLAYBACK_SLOT_BYTES),
|
|
KVMFR_AUDIO_MAX_PLAYBACK_READERS,
|
|
};
|
|
LGMP_STATUS status = m_host.CreateSPMC(playback, &m_playbackStream);
|
|
if (status != LGMP_OK)
|
|
{
|
|
DEBUG_ERROR("Failed to create playback audio stream: %s",
|
|
lgmpStatusString(status));
|
|
return false;
|
|
}
|
|
|
|
const LGMPStreamConfig capture =
|
|
{
|
|
LGMP_STREAM_CLIENT_TO_HOST,
|
|
LGMP_STREAM_RELIABLE_FIFO,
|
|
KVMFR_AUDIO_STREAM_SLOT_COUNT,
|
|
static_cast<uint32_t>(KVMFR_AUDIO_CAPTURE_SLOT_BYTES),
|
|
};
|
|
status = m_host.CreateStream(capture, &m_captureStream);
|
|
if (status != LGMP_OK)
|
|
{
|
|
DEBUG_ERROR("Failed to create capture audio stream: %s",
|
|
lgmpStatusString(status));
|
|
FreeStreams();
|
|
return false;
|
|
}
|
|
|
|
const LGMPStreamConfig hostControl =
|
|
{
|
|
LGMP_STREAM_HOST_TO_CLIENT,
|
|
LGMP_STREAM_RELIABLE_FIFO,
|
|
KVMFR_AUDIO_STREAM_SLOT_COUNT,
|
|
static_cast<uint32_t>(KVMFR_AUDIO_HOST_CONTROL_SLOT_BYTES),
|
|
};
|
|
const LGMPStreamConfig clientControl =
|
|
{
|
|
LGMP_STREAM_CLIENT_TO_HOST,
|
|
LGMP_STREAM_RELIABLE_FIFO,
|
|
KVMFR_AUDIO_STREAM_SLOT_COUNT,
|
|
static_cast<uint32_t>(KVMFR_AUDIO_CLIENT_CONTROL_SLOT_BYTES),
|
|
};
|
|
for (Subscriber& subscriber : m_subscribers)
|
|
{
|
|
status = m_host.CreateStream(hostControl, &subscriber.hostControl);
|
|
if (status == LGMP_OK)
|
|
status = m_host.CreateStream(
|
|
clientControl, &subscriber.clientControl);
|
|
if (status != LGMP_OK)
|
|
{
|
|
DEBUG_ERROR("Failed to create audio control stream: %s",
|
|
lgmpStatusString(status));
|
|
FreeStreams();
|
|
return false;
|
|
}
|
|
|
|
LGMPStreamDescriptor descriptor = {};
|
|
lgmpHostStreamGetDescriptor(subscriber.hostControl, &descriptor);
|
|
subscriber.hostControlDescriptor = WireDescriptor(descriptor);
|
|
lgmpHostStreamGetDescriptor(subscriber.clientControl, &descriptor);
|
|
subscriber.clientControlDescriptor = WireDescriptor(descriptor);
|
|
}
|
|
|
|
LGMPSPMCDescriptor playbackDescriptor = {};
|
|
lgmpHostSPMCGetDescriptor(m_playbackStream, &playbackDescriptor);
|
|
m_playbackDescriptor = WireDescriptor(playbackDescriptor);
|
|
LGMPStreamDescriptor captureDescriptor = {};
|
|
lgmpHostStreamGetDescriptor(m_captureStream, &captureDescriptor);
|
|
m_captureDescriptor = WireDescriptor(captureDescriptor);
|
|
return true;
|
|
}
|
|
|
|
void CLGMPAudio::FreeStreams()
|
|
{
|
|
for (Subscriber& subscriber : m_subscribers)
|
|
{
|
|
lgmpHostStreamFree(&subscriber.clientControl);
|
|
lgmpHostStreamFree(&subscriber.hostControl);
|
|
subscriber.clientControlDescriptor = {};
|
|
subscriber.hostControlDescriptor = {};
|
|
}
|
|
lgmpHostStreamFree(&m_captureStream);
|
|
lgmpHostSPMCFree(&m_playbackStream);
|
|
m_captureDescriptor = {};
|
|
m_playbackDescriptor = {};
|
|
}
|
|
|
|
DWORD CALLBACK CLGMPAudio::InboundThreadProc(void * context)
|
|
{
|
|
static_cast<CLGMPAudio *>(context)->InboundThread();
|
|
return 0;
|
|
}
|
|
|
|
bool CLGMPAudio::StartInboundWorker()
|
|
{
|
|
m_inboundStopEvent = CreateEventW(nullptr, TRUE, FALSE, nullptr);
|
|
m_inboundWakeEvent = CreateEventW(nullptr, FALSE, FALSE, nullptr);
|
|
m_inboundPollTimer = CreateWaitableTimerExW(nullptr, nullptr,
|
|
CREATE_WAITABLE_TIMER_HIGH_RESOLUTION, TIMER_ALL_ACCESS);
|
|
if (!m_inboundPollTimer)
|
|
m_inboundPollTimer = CreateWaitableTimerExW(
|
|
nullptr, nullptr, 0, TIMER_ALL_ACCESS);
|
|
|
|
if (!m_inboundStopEvent || !m_inboundWakeEvent ||
|
|
!m_inboundPollTimer)
|
|
{
|
|
DEBUG_ERROR_HR(GetLastError(),
|
|
"Failed to create LGMP audio worker resources");
|
|
if (m_inboundPollTimer)
|
|
CloseHandle(m_inboundPollTimer);
|
|
if (m_inboundWakeEvent)
|
|
CloseHandle(m_inboundWakeEvent);
|
|
if (m_inboundStopEvent)
|
|
CloseHandle(m_inboundStopEvent);
|
|
m_inboundPollTimer = nullptr;
|
|
m_inboundWakeEvent = nullptr;
|
|
m_inboundStopEvent = nullptr;
|
|
return false;
|
|
}
|
|
|
|
m_inboundThread = CreateThread(nullptr, 0, InboundThreadProc,
|
|
this, 0, nullptr);
|
|
if (!m_inboundThread)
|
|
{
|
|
DEBUG_ERROR_HR(GetLastError(),
|
|
"Failed to create LGMP audio worker");
|
|
CloseHandle(m_inboundPollTimer);
|
|
CloseHandle(m_inboundWakeEvent);
|
|
CloseHandle(m_inboundStopEvent);
|
|
m_inboundPollTimer = nullptr;
|
|
m_inboundWakeEvent = nullptr;
|
|
m_inboundStopEvent = nullptr;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CLGMPAudio::StopInboundWorker()
|
|
{
|
|
HANDLE thread = nullptr;
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
m_inboundStopping = true;
|
|
thread = m_inboundThread;
|
|
if (m_inboundStopEvent)
|
|
SetEvent(m_inboundStopEvent);
|
|
}
|
|
if (thread)
|
|
WaitForSingleObject(thread, INFINITE);
|
|
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (m_inboundThread)
|
|
CloseHandle(m_inboundThread);
|
|
if (m_inboundPollTimer)
|
|
CloseHandle(m_inboundPollTimer);
|
|
if (m_inboundWakeEvent)
|
|
CloseHandle(m_inboundWakeEvent);
|
|
if (m_inboundStopEvent)
|
|
CloseHandle(m_inboundStopEvent);
|
|
m_inboundThread = nullptr;
|
|
m_inboundPollTimer = nullptr;
|
|
m_inboundWakeEvent = nullptr;
|
|
m_inboundStopEvent = nullptr;
|
|
}
|
|
|
|
void CLGMPAudio::InboundThread()
|
|
{
|
|
DWORD avTask = 0;
|
|
HANDLE avTaskHandle =
|
|
AvSetMmThreadCharacteristicsW(L"Pro Audio", &avTask);
|
|
if (avTaskHandle &&
|
|
!AvSetMmThreadPriority(avTaskHandle, AVRT_PRIORITY_HIGH))
|
|
DEBUG_WARN("Failed to raise audio ingress MMCSS priority: %lu",
|
|
GetLastError());
|
|
|
|
LGMPStreamPollState streamPoll = {};
|
|
LGMPStreamPollConfig pollConfig = {};
|
|
pollConfig.spinCount = 64U;
|
|
pollConfig.minWaitUs = 25U;
|
|
pollConfig.maxWaitUs = 250U;
|
|
const LGMP_STATUS pollStatus = lgmpStreamPollInit(&streamPoll,
|
|
pollConfig);
|
|
if (pollStatus != LGMP_OK)
|
|
{
|
|
DEBUG_ERROR("Failed to initialize LGMP audio polling: %s",
|
|
lgmpStatusString(pollStatus));
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_inboundStopping)
|
|
Fail("lgmpStreamPollInit(audio)", pollStatus);
|
|
}
|
|
if (avTaskHandle)
|
|
AvRevertMmThreadCharacteristics(avTaskHandle);
|
|
return;
|
|
}
|
|
|
|
const HANDLE idleWaits[] =
|
|
{ m_inboundStopEvent, m_inboundWakeEvent };
|
|
const HANDLE activeWaits[] =
|
|
{ m_inboundStopEvent, m_inboundWakeEvent, m_inboundPollTimer };
|
|
bool workerFailed = false;
|
|
for (;;)
|
|
{
|
|
const DWORD stopped = WaitForSingleObject(m_inboundStopEvent, 0);
|
|
if (stopped == WAIT_OBJECT_0)
|
|
break;
|
|
if (stopped == WAIT_FAILED)
|
|
{
|
|
DEBUG_ERROR_HR(GetLastError(),
|
|
"LGMP audio stop-event poll failed");
|
|
workerFailed = true;
|
|
break;
|
|
}
|
|
|
|
uint64_t before = 0;
|
|
bool active = false;
|
|
{
|
|
CSRWSharedLock lock(m_lock);
|
|
before = m_inboundActivitySerial;
|
|
for (const Subscriber& subscriber : m_subscribers)
|
|
if (subscriber.state != SubscriberState::NONE)
|
|
{
|
|
active = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (active)
|
|
{
|
|
DrainInbound();
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
PumpState();
|
|
CheckPlaybackBackpressure(GetTickCount64());
|
|
}
|
|
NotifyPlaybackReady();
|
|
}
|
|
|
|
{
|
|
CSRWSharedLock lock(m_lock);
|
|
if (before != m_inboundActivitySerial)
|
|
lgmpStreamPollActivity(&streamPoll);
|
|
active = false;
|
|
for (const Subscriber& subscriber : m_subscribers)
|
|
if (subscriber.state != SubscriberState::NONE)
|
|
{
|
|
active = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!active)
|
|
{
|
|
const DWORD wait = WaitForMultipleObjects(
|
|
_countof(idleWaits), idleWaits, FALSE, INFINITE);
|
|
if (wait == WAIT_OBJECT_0)
|
|
break;
|
|
if (wait != WAIT_OBJECT_0 + 1)
|
|
{
|
|
DEBUG_ERROR_HR(GetLastError(),
|
|
"LGMP audio worker wait failed");
|
|
workerFailed = true;
|
|
break;
|
|
}
|
|
lgmpStreamPollActivity(&streamPoll);
|
|
continue;
|
|
}
|
|
|
|
const uint32_t waitUs = lgmpStreamPollIdle(&streamPoll);
|
|
if (!waitUs)
|
|
continue;
|
|
if (!ArmAudioPollTimer(m_inboundPollTimer, waitUs))
|
|
{
|
|
DEBUG_ERROR_HR(GetLastError(),
|
|
"Failed to arm LGMP audio timer");
|
|
workerFailed = true;
|
|
break;
|
|
}
|
|
|
|
const DWORD wait = WaitForMultipleObjects(
|
|
_countof(activeWaits), activeWaits, FALSE, INFINITE);
|
|
if (wait == WAIT_OBJECT_0)
|
|
break;
|
|
if (wait == WAIT_OBJECT_0 + 1)
|
|
{
|
|
lgmpStreamPollActivity(&streamPoll);
|
|
continue;
|
|
}
|
|
if (wait != WAIT_OBJECT_0 + 2)
|
|
{
|
|
DEBUG_ERROR_HR(GetLastError(),
|
|
"LGMP audio worker wait failed");
|
|
workerFailed = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (workerFailed)
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_inboundStopping)
|
|
Fail("audio ingress worker", LGMP_ERR_CLOCK_FAILURE);
|
|
}
|
|
if (avTaskHandle)
|
|
AvRevertMmThreadCharacteristics(avTaskHandle);
|
|
}
|
|
|
|
bool CLGMPAudio::Initialize()
|
|
{
|
|
CSRWExclusiveLock lifecycleLock(m_lifecycleLock);
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (m_initialized)
|
|
return true;
|
|
|
|
if (!m_claimResponderReady)
|
|
{
|
|
LGMP_STATUS status = LGMP_OK;
|
|
for (ResponseMemory& response : m_responseMemory)
|
|
{
|
|
status = m_host.Allocate(sizeof(KVMFRAudioStreamResponse),
|
|
&response.memory);
|
|
if (status != LGMP_OK)
|
|
break;
|
|
memset(lgmpHostMemPtr(response.memory), 0,
|
|
sizeof(KVMFRAudioStreamResponse));
|
|
}
|
|
if (status != LGMP_OK)
|
|
{
|
|
DEBUG_ERROR("Failed to allocate audio response memory: %s",
|
|
lgmpStatusString(status));
|
|
for (ResponseMemory& response : m_responseMemory)
|
|
lgmpHostMemFree(&response.memory);
|
|
return false;
|
|
}
|
|
m_claimResponderReady = true;
|
|
}
|
|
|
|
// LGMP shared allocations are monotonic. Reserve conservatively before
|
|
// the first data-plane allocation; the small response pool above remains
|
|
// available when the optional layout cannot be created.
|
|
if (m_host.Available() < AUDIO_SHARED_MEMORY_PREFLIGHT)
|
|
{
|
|
DEBUG_WARN("LGMP audio requires at least %zu bytes of available "
|
|
"shared memory", AUDIO_SHARED_MEMORY_PREFLIGHT);
|
|
return false;
|
|
}
|
|
if (!InitializeStreams())
|
|
return false;
|
|
|
|
m_state.generation = 1;
|
|
m_initialized = true;
|
|
m_inboundStopping = false;
|
|
if (!StartInboundWorker())
|
|
{
|
|
m_initialized = false;
|
|
FreeStreams();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CLGMPAudio::BindSubscriber(uint32_t index,
|
|
uint32_t clientID, const KVMFRAudioClaim& claim)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS ||
|
|
m_subscribers[index].state != SubscriberState::NONE)
|
|
return false;
|
|
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
LGMP_STATUS status = lgmpHostStreamBind(
|
|
subscriber.hostControl, clientID, &subscriber.hostControlEpoch);
|
|
if (status != LGMP_OK)
|
|
{
|
|
DEBUG_WARN("Failed to bind host audio control for client %u: %s",
|
|
clientID, lgmpStatusString(status));
|
|
return false;
|
|
}
|
|
|
|
status = lgmpHostStreamBind(
|
|
subscriber.clientControl, clientID, &subscriber.clientControlEpoch);
|
|
if (status != LGMP_OK)
|
|
{
|
|
DEBUG_WARN("Failed to bind client audio control for client %u: %s",
|
|
clientID, lgmpStatusString(status));
|
|
(void)lgmpHostStreamUnbind(subscriber.hostControl);
|
|
return false;
|
|
}
|
|
|
|
status = lgmpHostSPMCReaderBind(m_playbackStream, clientID,
|
|
&subscriber.playbackReaderID, &subscriber.playbackReaderEpoch);
|
|
if (status != LGMP_OK)
|
|
{
|
|
DEBUG_WARN("Failed to bind playback reader for client %u: %s",
|
|
clientID, lgmpStatusString(status));
|
|
(void)lgmpHostStreamUnbind(subscriber.clientControl);
|
|
(void)lgmpHostStreamUnbind(subscriber.hostControl);
|
|
return false;
|
|
}
|
|
|
|
subscriber.state = SubscriberState::BOUND;
|
|
subscriber.clientID = clientID;
|
|
subscriber.requestGeneration = claim.requestGeneration;
|
|
subscriber.clientCapabilities = claim.clientCapabilities;
|
|
subscriber.subscriptions = claim.subscriptions;
|
|
subscriber.bindingEpoch =
|
|
m_nextBindingEpoch = NextEpoch(m_nextBindingEpoch);
|
|
subscriber.roleEpoch = m_nextRoleEpoch = NextEpoch(m_nextRoleEpoch);
|
|
subscriber.claimToken = claim.claimToken;
|
|
subscriber.serial =
|
|
m_nextSubscriberSerial = NextSerial(m_nextSubscriberSerial);
|
|
subscriber.stateRevision = 1;
|
|
RenewLease(subscriber);
|
|
RefreshGranted(index, false);
|
|
return true;
|
|
}
|
|
|
|
bool CLGMPAudio::TryUnbindSubscriber(uint32_t index)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS)
|
|
return true;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state == SubscriberState::NONE)
|
|
return true;
|
|
if (m_captureCallbackInFlight && m_captureBinding == index)
|
|
return false;
|
|
|
|
if (m_pendingCapture.valid &&
|
|
m_pendingCapture.subscriber == index)
|
|
ReleasePendingCapture();
|
|
|
|
bool complete = true;
|
|
if (m_captureBinding == index)
|
|
{
|
|
const LGMP_STATUS status = lgmpHostStreamUnbind(m_captureStream);
|
|
if (status == LGMP_ERR_STREAM_BUSY)
|
|
complete = false;
|
|
else if (status == LGMP_OK || status == LGMP_ERR_STREAM_UNBOUND)
|
|
{
|
|
m_captureBinding = INVALID_SLOT;
|
|
if (m_captureOwner == index)
|
|
m_captureOwner = INVALID_SLOT;
|
|
subscriber.captureEpoch = 0;
|
|
subscriber.captureRevoking = false;
|
|
subscriber.captureRevokeDeadline = 0;
|
|
AssignCaptureOwner();
|
|
}
|
|
else
|
|
{
|
|
Fail("lgmpHostStreamUnbind(audio capture)", status);
|
|
complete = false;
|
|
}
|
|
}
|
|
|
|
for (PLGMPHostStream stream :
|
|
{ subscriber.clientControl, subscriber.hostControl })
|
|
{
|
|
const LGMP_STATUS status = lgmpHostStreamUnbind(stream);
|
|
if (status == LGMP_ERR_STREAM_BUSY)
|
|
complete = false;
|
|
else if (status != LGMP_OK && status != LGMP_ERR_STREAM_UNBOUND)
|
|
{
|
|
Fail("lgmpHostStreamUnbind(audio control)", status);
|
|
complete = false;
|
|
}
|
|
}
|
|
|
|
const LGMP_STATUS readerStatus = lgmpHostSPMCReaderUnbind(
|
|
m_playbackStream, subscriber.playbackReaderID);
|
|
if (readerStatus == LGMP_ERR_STREAM_BUSY)
|
|
complete = false;
|
|
else if (readerStatus != LGMP_OK &&
|
|
readerStatus != LGMP_ERR_STREAM_UNBOUND)
|
|
{
|
|
Fail("lgmpHostSPMCReaderUnbind(audio)", readerStatus);
|
|
complete = false;
|
|
}
|
|
return complete;
|
|
}
|
|
|
|
void CLGMPAudio::ForceUnbindSubscriber(uint32_t index)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS)
|
|
return;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state == SubscriberState::NONE)
|
|
return;
|
|
|
|
if (m_pendingCapture.valid &&
|
|
m_pendingCapture.subscriber == index)
|
|
ReleasePendingCapture();
|
|
if (m_captureBinding == index)
|
|
{
|
|
const LGMP_STATUS status =
|
|
lgmpHostStreamForceUnbind(m_captureStream);
|
|
if (status != LGMP_OK && status != LGMP_ERR_STREAM_UNBOUND)
|
|
DEBUG_WARN("Failed to force-unbind audio capture: %s",
|
|
lgmpStatusString(status));
|
|
}
|
|
|
|
for (PLGMPHostStream stream :
|
|
{ subscriber.clientControl, subscriber.hostControl })
|
|
{
|
|
const LGMP_STATUS status = lgmpHostStreamForceUnbind(stream);
|
|
if (status != LGMP_OK && status != LGMP_ERR_STREAM_UNBOUND)
|
|
DEBUG_WARN("Failed to force-unbind audio control: %s",
|
|
lgmpStatusString(status));
|
|
}
|
|
|
|
const LGMP_STATUS status = lgmpHostSPMCReaderForceUnbind(
|
|
m_playbackStream, subscriber.playbackReaderID);
|
|
if (status != LGMP_OK && status != LGMP_ERR_STREAM_UNBOUND)
|
|
DEBUG_WARN("Failed to force-unbind audio reader: %s",
|
|
lgmpStatusString(status));
|
|
}
|
|
|
|
void CLGMPAudio::ResetSubscriber(uint32_t index)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS)
|
|
return;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
const uint32_t clientID = subscriber.clientID;
|
|
const uint32_t requestGeneration = subscriber.requestGeneration;
|
|
const uint64_t claimToken = subscriber.claimToken;
|
|
PLGMPHostStream hostControl = subscriber.hostControl;
|
|
PLGMPHostStream clientControl = subscriber.clientControl;
|
|
const KVMFRStreamDescriptor hostDescriptor =
|
|
subscriber.hostControlDescriptor;
|
|
const KVMFRStreamDescriptor clientDescriptor =
|
|
subscriber.clientControlDescriptor;
|
|
|
|
for (ClaimRecord& record : m_claimRecord)
|
|
if (record.valid && record.clientID == clientID &&
|
|
record.requestGeneration == requestGeneration &&
|
|
record.claimToken == claimToken)
|
|
{
|
|
record.closed = true;
|
|
break;
|
|
}
|
|
|
|
if (m_feedbackAuthority == index)
|
|
m_feedbackAuthority = INVALID_SLOT;
|
|
if (m_captureOwner == index)
|
|
m_captureOwner = INVALID_SLOT;
|
|
if (m_captureBinding == index)
|
|
m_captureBinding = INVALID_SLOT;
|
|
|
|
subscriber = {};
|
|
subscriber.hostControl = hostControl;
|
|
subscriber.clientControl = clientControl;
|
|
subscriber.hostControlDescriptor = hostDescriptor;
|
|
subscriber.clientControlDescriptor = clientDescriptor;
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
}
|
|
|
|
bool CLGMPAudio::ValidateClaim(
|
|
const KVMFRAudioClaim& claim) const
|
|
{
|
|
if (claim.messageType != KVMFR_MESSAGE_AUDIO_CLAIM ||
|
|
claim.version != KVMFR_AUDIO_CONTROL_VERSION ||
|
|
claim.size != sizeof(claim) || !claim.requestGeneration ||
|
|
claim.flags != KVMFR_AUDIO_CLAIM_BIND || !claim.claimToken ||
|
|
!claim.protocolMin || claim.protocolMin > claim.protocolMax ||
|
|
claim.protocolMin > KVMFR_AUDIO_PROTOCOL_MAX ||
|
|
claim.protocolMax < KVMFR_AUDIO_PROTOCOL_MIN ||
|
|
(claim.clientCapabilities & ~AUDIO_CAPABILITY_MASK) ||
|
|
!(claim.clientCapabilities & KVMFR_AUDIO_CAP_PLAYBACK) ||
|
|
((claim.clientCapabilities & KVMFR_AUDIO_CAP_CLOCK_FEEDBACK) &&
|
|
!(claim.clientCapabilities & KVMFR_AUDIO_CAP_PLAYBACK)) ||
|
|
(claim.subscriptions & ~AUDIO_SUBSCRIPTION_MASK) ||
|
|
((claim.subscriptions & KVMFR_AUDIO_SUBSCRIBE_CAPTURE) &&
|
|
!(claim.clientCapabilities & KVMFR_AUDIO_CAP_CAPTURE)))
|
|
return false;
|
|
|
|
for (uint64_t reserved : claim.reserved)
|
|
if (reserved)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CLGMPAudio::ResponsePending(uint32_t clientID,
|
|
const KVMFRAudioStreamResponse& candidate) const
|
|
{
|
|
for (const PendingResponse& pending : m_pendingResponse)
|
|
if (pending.valid && pending.clientID == clientID &&
|
|
pending.response.requestGeneration ==
|
|
candidate.requestGeneration &&
|
|
pending.response.claimToken == candidate.claimToken &&
|
|
pending.response.result == candidate.result)
|
|
return true;
|
|
|
|
for (const ResponseMemory& response : m_responseMemory)
|
|
if (response.valid && response.clientID == clientID &&
|
|
response.requestGeneration == candidate.requestGeneration &&
|
|
response.claimToken == candidate.claimToken &&
|
|
response.result == candidate.result)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool CLGMPAudio::QueueResponse(uint32_t clientID,
|
|
const KVMFRAudioStreamResponse& response)
|
|
{
|
|
if (ResponsePending(clientID, response))
|
|
return true;
|
|
|
|
PendingResponse * available = nullptr;
|
|
PendingResponse * sameClient = nullptr;
|
|
for (PendingResponse& pending : m_pendingResponse)
|
|
{
|
|
if (pending.valid && pending.clientID == clientID)
|
|
{
|
|
if (pending.response.result == KVMFR_AUDIO_RESPONSE_BOUND)
|
|
return false;
|
|
if (!sameClient)
|
|
sameClient = &pending;
|
|
continue;
|
|
}
|
|
if (!pending.valid && !available)
|
|
available = &pending;
|
|
}
|
|
if (sameClient)
|
|
available = sameClient;
|
|
if (!available)
|
|
return false;
|
|
|
|
available->valid = true;
|
|
available->clientID = clientID;
|
|
available->response = response;
|
|
return true;
|
|
}
|
|
|
|
void CLGMPAudio::CleanupResponseMemory()
|
|
{
|
|
for (ResponseMemory& response : m_responseMemory)
|
|
{
|
|
if (!response.valid || m_control.PayloadPending(response.memory))
|
|
continue;
|
|
response.valid = false;
|
|
response.clientID = 0;
|
|
response.requestGeneration = 0;
|
|
response.claimToken = 0;
|
|
response.result = 0;
|
|
}
|
|
}
|
|
|
|
void CLGMPAudio::PumpResponses()
|
|
{
|
|
CleanupResponseMemory();
|
|
for (PendingResponse& pending : m_pendingResponse)
|
|
{
|
|
if (!pending.valid)
|
|
continue;
|
|
|
|
ResponseMemory * available = nullptr;
|
|
for (ResponseMemory& response : m_responseMemory)
|
|
if (response.memory && !response.valid)
|
|
{
|
|
available = &response;
|
|
break;
|
|
}
|
|
if (!available)
|
|
return;
|
|
|
|
memcpy(lgmpHostMemPtr(available->memory), &pending.response,
|
|
sizeof(pending.response));
|
|
WCWrite::Flush();
|
|
unsigned recipients = 0;
|
|
const LGMP_STATUS status = m_control.PostForClient(
|
|
KVMFR_AUDIO_CONTROL_UDATA, available->memory,
|
|
pending.clientID, recipients);
|
|
if (status == LGMP_ERR_QUEUE_FULL)
|
|
return;
|
|
if (status != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostQueuePostForClients(audio)", status);
|
|
return;
|
|
}
|
|
|
|
const bool bound =
|
|
pending.response.result == KVMFR_AUDIO_RESPONSE_BOUND;
|
|
const uint32_t index = bound ?
|
|
FindSubscriber(pending.clientID) : INVALID_SLOT;
|
|
if (recipients)
|
|
{
|
|
available->valid = true;
|
|
available->clientID = pending.clientID;
|
|
available->requestGeneration =
|
|
pending.response.requestGeneration;
|
|
available->claimToken = pending.response.claimToken;
|
|
available->result = pending.response.result;
|
|
if (index != INVALID_SLOT)
|
|
{
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.requestGeneration ==
|
|
pending.response.requestGeneration &&
|
|
subscriber.claimToken == pending.response.claimToken)
|
|
{
|
|
subscriber.responseAdmitted = true;
|
|
RenewLease(subscriber);
|
|
MarkStateDirty(index);
|
|
}
|
|
}
|
|
}
|
|
else if (index != INVALID_SLOT)
|
|
BeginRelease(index, "audio claimant disappeared");
|
|
|
|
pending = {};
|
|
}
|
|
}
|
|
|
|
uint32_t CLGMPAudio::FindSubscriber(uint32_t clientID) const
|
|
{
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
if (m_subscribers[index].state != SubscriberState::NONE &&
|
|
m_subscribers[index].clientID == clientID)
|
|
return index;
|
|
return INVALID_SLOT;
|
|
}
|
|
|
|
uint32_t CLGMPAudio::FindFreeSubscriber() const
|
|
{
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
if (m_subscribers[index].state == SubscriberState::NONE)
|
|
return index;
|
|
return INVALID_SLOT;
|
|
}
|
|
|
|
bool CLGMPAudio::SubscriberPresent(uint32_t clientID,
|
|
const uint32_t clients[LGMP_MAX_CLIENTS], unsigned count) const
|
|
{
|
|
for (unsigned index = 0; index < count; ++index)
|
|
if (clients[index] == clientID)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void CLGMPAudio::RenewLease(Subscriber& subscriber)
|
|
{
|
|
subscriber.deadline =
|
|
GetTickCount64() + KVMFR_AUDIO_OWNER_LEASE_MS;
|
|
}
|
|
|
|
void CLGMPAudio::ReleasePendingCapture()
|
|
{
|
|
if (!m_pendingCapture.valid)
|
|
return;
|
|
const LGMP_STATUS status = lgmpHostStreamReadRelease(
|
|
m_captureStream, &m_pendingCapture.buffer);
|
|
if (status != LGMP_OK && status != LGMP_ERR_STREAM_UNBOUND &&
|
|
status != LGMP_ERR_STREAM_STALE)
|
|
Fail("lgmpHostStreamReadRelease(audio capture)", status);
|
|
m_pendingCapture = {};
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
}
|
|
|
|
void CLGMPAudio::ClearBlockedPlayback(bool notify)
|
|
{
|
|
const bool blocked = m_playbackBlocked;
|
|
m_playbackBlocked = false;
|
|
m_blockedPlayback = {};
|
|
m_blockedPlaybackSize = 0;
|
|
m_authorityBlockedSince = 0;
|
|
if (notify && blocked)
|
|
m_playbackReadyPending = true;
|
|
}
|
|
|
|
bool CLGMPAudio::RememberBlockedPlayback(
|
|
const AudioPacket& packet, size_t size)
|
|
{
|
|
if (m_playbackBlocked)
|
|
return size == m_blockedPlaybackSize &&
|
|
SamePacket(packet, m_blockedPlayback);
|
|
m_playbackBlocked = true;
|
|
m_blockedPlayback = packet;
|
|
m_blockedPlaybackSize = size;
|
|
return true;
|
|
}
|
|
|
|
bool CLGMPAudio::HasBoundSubscribers() const
|
|
{
|
|
for (const Subscriber& subscriber : m_subscribers)
|
|
if (subscriber.state == SubscriberState::BOUND &&
|
|
subscriber.responseAdmitted &&
|
|
subscriber.subscriptionReceived &&
|
|
(((subscriber.subscriptions &
|
|
KVMFR_AUDIO_SUBSCRIBE_PLAYBACK) &&
|
|
(subscriber.clientCapabilities &
|
|
KVMFR_AUDIO_CAP_PLAYBACK)) ||
|
|
((subscriber.subscriptions &
|
|
KVMFR_AUDIO_SUBSCRIBE_CAPTURE) &&
|
|
(subscriber.clientCapabilities &
|
|
KVMFR_AUDIO_CAP_CAPTURE))))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool CLGMPAudio::PlaybackEligible(
|
|
const Subscriber& subscriber) const
|
|
{
|
|
return subscriber.state == SubscriberState::BOUND &&
|
|
(subscriber.clientCapabilities & KVMFR_AUDIO_CAP_PLAYBACK) &&
|
|
(subscriber.subscriptions & KVMFR_AUDIO_SUBSCRIBE_PLAYBACK);
|
|
}
|
|
|
|
bool CLGMPAudio::FeedbackEligible(
|
|
const Subscriber& subscriber) const
|
|
{
|
|
return PlaybackEligible(subscriber) &&
|
|
(subscriber.clientCapabilities & KVMFR_AUDIO_CAP_CLOCK_FEEDBACK);
|
|
}
|
|
|
|
bool CLGMPAudio::CaptureEligible(
|
|
const Subscriber& subscriber) const
|
|
{
|
|
return subscriber.state == SubscriberState::BOUND &&
|
|
(subscriber.clientCapabilities & KVMFR_AUDIO_CAP_CAPTURE) &&
|
|
(subscriber.subscriptions & KVMFR_AUDIO_SUBSCRIBE_CAPTURE);
|
|
}
|
|
|
|
bool CLGMPAudio::HasReadyPlayback() const
|
|
{
|
|
for (const Subscriber& subscriber : m_subscribers)
|
|
if (PlaybackEligible(subscriber) && subscriber.ready &&
|
|
subscriber.announcedPlayback ==
|
|
m_state.playback.generation)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void CLGMPAudio::MarkStateDirty(uint32_t index)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS ||
|
|
m_subscribers[index].state != SubscriberState::BOUND)
|
|
return;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
subscriber.stateRevision = NextSerial(subscriber.stateRevision);
|
|
subscriber.pumpStage = PumpStage::IDLE;
|
|
subscriber.ready = false;
|
|
subscriber.awaitingAck = false;
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
if (!m_inboundStopping && m_inboundWakeEvent)
|
|
SetEvent(m_inboundWakeEvent);
|
|
}
|
|
|
|
void CLGMPAudio::MarkAllStateDirty()
|
|
{
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
MarkStateDirty(index);
|
|
}
|
|
|
|
void CLGMPAudio::RefreshGranted(uint32_t index, bool bumpRole)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS)
|
|
return;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state != SubscriberState::BOUND)
|
|
return;
|
|
|
|
KVMFRAudioCapabilities granted = 0;
|
|
if (m_stateKnown &&
|
|
(m_state.capabilities & KVMFR_AUDIO_CAP_PLAYBACK) &&
|
|
(subscriber.clientCapabilities & KVMFR_AUDIO_CAP_PLAYBACK))
|
|
granted |= KVMFR_AUDIO_CAP_PLAYBACK;
|
|
if (m_captureOwner == index && CaptureEligible(subscriber) &&
|
|
(m_state.capabilities & KVMFR_AUDIO_CAP_CAPTURE))
|
|
granted |= KVMFR_AUDIO_CAP_CAPTURE;
|
|
if (m_feedbackAuthority == index && FeedbackEligible(subscriber) &&
|
|
(m_state.capabilities & KVMFR_AUDIO_CAP_CLOCK_FEEDBACK))
|
|
granted |= KVMFR_AUDIO_CAP_CLOCK_FEEDBACK;
|
|
if (granted == subscriber.grantedCapabilities)
|
|
return;
|
|
|
|
subscriber.grantedCapabilities = granted;
|
|
if (bumpRole && subscriber.subscriptionReceived)
|
|
subscriber.roleEpoch =
|
|
m_nextRoleEpoch = NextEpoch(m_nextRoleEpoch);
|
|
subscriber.response.grantedCapabilities =
|
|
granted | KVMFR_AUDIO_CAP_PLAYBACK;
|
|
subscriber.response.roleEpoch = subscriber.roleEpoch;
|
|
MarkStateDirty(index);
|
|
}
|
|
|
|
void CLGMPAudio::AssignFeedbackAuthority(uint32_t index)
|
|
{
|
|
if (m_feedbackAuthority != INVALID_SLOT ||
|
|
index >= LGMP_MAX_CLIENTS ||
|
|
!FeedbackEligible(m_subscribers[index]))
|
|
return;
|
|
m_feedbackAuthority = index;
|
|
RefreshGranted(index, true);
|
|
DEBUG_INFO("Audio feedback authority assigned to client %u",
|
|
m_subscribers[index].clientID);
|
|
}
|
|
|
|
void CLGMPAudio::RevokeFeedbackAuthority(const char * reason)
|
|
{
|
|
if (m_feedbackAuthority == INVALID_SLOT)
|
|
return;
|
|
const uint32_t index = m_feedbackAuthority;
|
|
m_feedbackAuthority = INVALID_SLOT;
|
|
m_subscribers[index].feedbackRevoked = true;
|
|
DEBUG_INFO("Audio feedback authority client %u revoked: %s",
|
|
m_subscribers[index].clientID, reason);
|
|
RefreshGranted(index, true);
|
|
m_authorityBlockedSince = 0;
|
|
if (m_playbackBlocked)
|
|
ClearBlockedPlayback(true);
|
|
}
|
|
|
|
void CLGMPAudio::PromoteFeedbackAuthority(
|
|
uint64_t playbackGeneration)
|
|
{
|
|
if (!playbackGeneration || m_feedbackAuthority != INVALID_SLOT)
|
|
return;
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
if (FeedbackEligible(m_subscribers[index]) &&
|
|
!m_subscribers[index].feedbackRevoked)
|
|
{
|
|
AssignFeedbackAuthority(index);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CLGMPAudio::AssignCaptureOwner()
|
|
{
|
|
if (m_captureOwner != INVALID_SLOT ||
|
|
m_captureBinding != INVALID_SLOT)
|
|
return;
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
{
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (!CaptureEligible(subscriber))
|
|
continue;
|
|
uint32_t epoch = 0;
|
|
const LGMP_STATUS status = lgmpHostStreamBind(
|
|
m_captureStream, subscriber.clientID, &epoch);
|
|
if (status == LGMP_ERR_STREAM_BUSY)
|
|
return;
|
|
if (status != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostStreamBind(audio capture)", status);
|
|
return;
|
|
}
|
|
m_captureOwner = index;
|
|
m_captureBinding = index;
|
|
subscriber.captureEpoch = epoch;
|
|
subscriber.nextCaptureSequence = 0;
|
|
subscriber.captureSequenceKnown = false;
|
|
subscriber.captureDiscontinuity = true;
|
|
subscriber.captureRevokeDeadline = 0;
|
|
RefreshGranted(index, true);
|
|
DEBUG_INFO("Audio capture assigned to client %u",
|
|
subscriber.clientID);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CLGMPAudio::MaintainCaptureBinding()
|
|
{
|
|
if (m_captureBinding == INVALID_SLOT)
|
|
{
|
|
AssignCaptureOwner();
|
|
return;
|
|
}
|
|
|
|
const uint32_t index = m_captureBinding;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state != SubscriberState::BOUND ||
|
|
!subscriber.captureRevoking || m_captureCallbackInFlight)
|
|
return;
|
|
|
|
const bool acknowledged =
|
|
subscriber.pumpRevision >= subscriber.captureRevokeRevision &&
|
|
!subscriber.awaitingAck && subscriber.ready;
|
|
const uint64_t now = GetTickCount64();
|
|
const bool timedOut = subscriber.captureRevokeDeadline &&
|
|
now >= subscriber.captureRevokeDeadline;
|
|
if (!acknowledged && !timedOut)
|
|
return;
|
|
if (!acknowledged && subscriber.captureRevokeDeadline != 1)
|
|
{
|
|
DEBUG_WARN("Audio capture revoke acknowledgement timed out for "
|
|
"client %u", subscriber.clientID);
|
|
subscriber.captureRevokeDeadline = 1;
|
|
}
|
|
|
|
if (m_pendingCapture.valid &&
|
|
m_pendingCapture.subscriber == index)
|
|
ReleasePendingCapture();
|
|
const LGMP_STATUS status = lgmpHostStreamUnbind(m_captureStream);
|
|
if (status == LGMP_ERR_STREAM_BUSY)
|
|
return;
|
|
if (status != LGMP_OK && status != LGMP_ERR_STREAM_UNBOUND)
|
|
{
|
|
Fail("lgmpHostStreamUnbind(audio capture role)", status);
|
|
return;
|
|
}
|
|
|
|
m_captureBinding = INVALID_SLOT;
|
|
subscriber.captureEpoch = 0;
|
|
subscriber.captureRevoking = false;
|
|
subscriber.captureRevokeDeadline = 0;
|
|
AssignCaptureOwner();
|
|
}
|
|
|
|
void CLGMPAudio::BeginRelease(uint32_t index,
|
|
const char * reason, bool force)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS)
|
|
return;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state == SubscriberState::NONE)
|
|
return;
|
|
subscriber.forceUnbind = subscriber.forceUnbind || force;
|
|
if (subscriber.state == SubscriberState::RELEASING)
|
|
return;
|
|
|
|
DEBUG_INFO("Audio client %u generation %u releasing: %s",
|
|
subscriber.clientID, subscriber.requestGeneration, reason);
|
|
subscriber.state = SubscriberState::RELEASING;
|
|
subscriber.ready = false;
|
|
subscriber.awaitingAck = false;
|
|
subscriber.pumpStage = PumpStage::IDLE;
|
|
if (m_feedbackAuthority == index)
|
|
RevokeFeedbackAuthority(reason);
|
|
if (m_captureOwner == index)
|
|
m_captureOwner = INVALID_SLOT;
|
|
if (m_pendingCapture.valid &&
|
|
m_pendingCapture.subscriber == index &&
|
|
!m_captureCallbackInFlight)
|
|
ReleasePendingCapture();
|
|
|
|
for (PendingResponse& pending : m_pendingResponse)
|
|
if (pending.valid && pending.clientID == subscriber.clientID &&
|
|
pending.response.result == KVMFR_AUDIO_RESPONSE_BOUND)
|
|
pending = {};
|
|
if (!HasReadyPlayback())
|
|
ClearBlockedPlayback(true);
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
if (!m_inboundStopping && m_inboundWakeEvent)
|
|
SetEvent(m_inboundWakeEvent);
|
|
}
|
|
|
|
void CLGMPAudio::MaintainSubscribers(uint64_t now)
|
|
{
|
|
MaintainCaptureBinding();
|
|
uint32_t clients[LGMP_MAX_CLIENTS] = {};
|
|
unsigned count = 0;
|
|
const LGMP_STATUS query = m_control.GetClientIDs(clients, count);
|
|
const bool clientsKnown = query == LGMP_OK;
|
|
if (!clientsKnown)
|
|
DEBUG_WARN("Failed to query audio pointer subscribers: %s",
|
|
lgmpStatusString(query));
|
|
|
|
bool assignCapture = false;
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
{
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state == SubscriberState::NONE)
|
|
continue;
|
|
if (clientsKnown && !SubscriberPresent(
|
|
subscriber.clientID, clients, count))
|
|
subscriber.forceUnbind = true;
|
|
if (subscriber.state == SubscriberState::BOUND)
|
|
{
|
|
if (subscriber.forceUnbind)
|
|
BeginRelease(index,
|
|
"audio pointer subscriber disappeared", true);
|
|
else if (m_pendingCapture.valid &&
|
|
m_pendingCapture.subscriber == index)
|
|
RenewLease(subscriber);
|
|
else if (now >= subscriber.deadline)
|
|
BeginRelease(index, "audio client lease expired");
|
|
}
|
|
|
|
if (subscriber.state != SubscriberState::RELEASING)
|
|
continue;
|
|
if (m_captureCallbackInFlight && m_captureBinding == index)
|
|
continue;
|
|
if (subscriber.forceUnbind)
|
|
{
|
|
ForceUnbindSubscriber(index);
|
|
const bool wasCapture = m_captureOwner == index;
|
|
ResetSubscriber(index);
|
|
assignCapture = assignCapture || wasCapture;
|
|
continue;
|
|
}
|
|
if (TryUnbindSubscriber(index))
|
|
{
|
|
DEBUG_INFO("Audio client %u generation %u released",
|
|
subscriber.clientID, subscriber.requestGeneration);
|
|
const bool wasCapture = m_captureOwner == index;
|
|
ResetSubscriber(index);
|
|
assignCapture = assignCapture || wasCapture;
|
|
}
|
|
}
|
|
if (assignCapture || (m_captureOwner == INVALID_SLOT &&
|
|
m_captureBinding == INVALID_SLOT))
|
|
AssignCaptureOwner();
|
|
}
|
|
|
|
void CLGMPAudio::HandleClaim(uint32_t clientID,
|
|
const KVMFRAudioClaim& claim)
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_claimResponderReady)
|
|
return;
|
|
|
|
KVMFRAudioStreamResponse response = {};
|
|
response.magic = KVMFR_AUDIO_RESPONSE_MAGIC;
|
|
response.version = KVMFR_AUDIO_CONTROL_VERSION;
|
|
response.size = sizeof(response);
|
|
response.requestGeneration = claim.requestGeneration;
|
|
response.boundClientID = clientID;
|
|
response.endpointGeneration = m_state.generation;
|
|
response.claimToken = claim.claimToken;
|
|
|
|
ClaimRecord * claimRecord = nullptr;
|
|
ClaimRecord * claimSlot = nullptr;
|
|
for (ClaimRecord& record : m_claimRecord)
|
|
{
|
|
if (record.valid && record.clientID == clientID)
|
|
claimRecord = &record;
|
|
if (!record.valid && !claimSlot)
|
|
claimSlot = &record;
|
|
}
|
|
if (claimRecord)
|
|
claimSlot = claimRecord;
|
|
|
|
const bool claimValid = ValidateClaim(claim);
|
|
const uint32_t existing = FindSubscriber(clientID);
|
|
if (!claimValid)
|
|
response.result = KVMFR_AUDIO_RESPONSE_INCOMPATIBLE;
|
|
else if (!m_initialized || m_failed)
|
|
response.result = KVMFR_AUDIO_RESPONSE_ERROR;
|
|
else if (existing != INVALID_SLOT)
|
|
{
|
|
Subscriber& subscriber = m_subscribers[existing];
|
|
if (subscriber.state == SubscriberState::BOUND &&
|
|
subscriber.requestGeneration == claim.requestGeneration &&
|
|
subscriber.claimToken == claim.claimToken)
|
|
{
|
|
RenewLease(subscriber);
|
|
response = subscriber.response;
|
|
}
|
|
else
|
|
response.result = KVMFR_AUDIO_RESPONSE_BUSY;
|
|
}
|
|
else if (claimRecord &&
|
|
claimRecord->requestGeneration == claim.requestGeneration &&
|
|
claimRecord->claimToken == claim.claimToken)
|
|
{
|
|
if (claimRecord->response.result == KVMFR_AUDIO_RESPONSE_ERROR)
|
|
response = claimRecord->response;
|
|
else
|
|
response.result = KVMFR_AUDIO_RESPONSE_BUSY;
|
|
}
|
|
else if (claimRecord && !RequestNewer(
|
|
claim.requestGeneration, claimRecord->requestGeneration))
|
|
response.result = KVMFR_AUDIO_RESPONSE_BUSY;
|
|
else if (!claimSlot)
|
|
{
|
|
DEBUG_WARN("Audio claim history is full for client %u", clientID);
|
|
response.result = KVMFR_AUDIO_RESPONSE_ERROR;
|
|
}
|
|
else
|
|
{
|
|
const uint32_t index = FindFreeSubscriber();
|
|
if (index == INVALID_SLOT)
|
|
response.result = KVMFR_AUDIO_RESPONSE_BUSY;
|
|
else if (!BindSubscriber(index, clientID, claim))
|
|
response.result = KVMFR_AUDIO_RESPONSE_ERROR;
|
|
else
|
|
{
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
// Admission grants playback independently from the live subscription.
|
|
// The subscription controls whether this reader consumes PCM.
|
|
if (m_feedbackAuthority == INVALID_SLOT &&
|
|
(claim.subscriptions & KVMFR_AUDIO_SUBSCRIBE_PLAYBACK) &&
|
|
(claim.clientCapabilities &
|
|
KVMFR_AUDIO_CAP_CLOCK_FEEDBACK))
|
|
AssignFeedbackAuthority(index);
|
|
AssignCaptureOwner();
|
|
RefreshGranted(index, false);
|
|
|
|
response.result = KVMFR_AUDIO_RESPONSE_BOUND;
|
|
response.protocolVersion = KVMFR_AUDIO_PROTOCOL_MAX;
|
|
response.grantedCapabilities =
|
|
subscriber.grantedCapabilities | KVMFR_AUDIO_CAP_PLAYBACK;
|
|
response.bindingEpoch = subscriber.bindingEpoch;
|
|
response.roleEpoch = subscriber.roleEpoch;
|
|
response.playbackReaderID = subscriber.playbackReaderID;
|
|
response.playback = m_playbackDescriptor;
|
|
response.hostControl = subscriber.hostControlDescriptor;
|
|
response.clientControl = subscriber.clientControlDescriptor;
|
|
response.capture = m_captureDescriptor;
|
|
subscriber.response = response;
|
|
|
|
claimSlot->valid = true;
|
|
claimSlot->closed = false;
|
|
claimSlot->clientID = clientID;
|
|
claimSlot->requestGeneration = claim.requestGeneration;
|
|
claimSlot->claimToken = claim.claimToken;
|
|
claimSlot->response = response;
|
|
DEBUG_INFO("Audio client %u generation %u admitted in slot %u",
|
|
clientID, claim.requestGeneration, index);
|
|
}
|
|
}
|
|
|
|
if (claimValid && claimSlot &&
|
|
response.result == KVMFR_AUDIO_RESPONSE_ERROR &&
|
|
(!claimRecord || RequestNewer(claim.requestGeneration,
|
|
claimRecord->requestGeneration)))
|
|
{
|
|
claimSlot->valid = true;
|
|
claimSlot->closed = true;
|
|
claimSlot->clientID = clientID;
|
|
claimSlot->requestGeneration = claim.requestGeneration;
|
|
claimSlot->claimToken = claim.claimToken;
|
|
claimSlot->response = response;
|
|
}
|
|
|
|
if (!QueueResponse(clientID, response))
|
|
{
|
|
DEBUG_WARN("Audio response queue is full for client %u", clientID);
|
|
if (response.result == KVMFR_AUDIO_RESPONSE_BOUND)
|
|
{
|
|
const uint32_t index = FindSubscriber(clientID);
|
|
if (index != INVALID_SLOT)
|
|
BeginRelease(index, "audio response queue exhausted");
|
|
}
|
|
}
|
|
PumpResponses();
|
|
}
|
|
|
|
KVMFRAudioStatus CLGMPAudio::WireStatus(uint32_t index) const
|
|
{
|
|
KVMFRAudioStatus status = {};
|
|
if (index >= LGMP_MAX_CLIENTS)
|
|
return status;
|
|
const Subscriber& subscriber = m_subscribers[index];
|
|
|
|
status.version = KVMFR_AUDIO_STATUS_VERSION;
|
|
status.size = sizeof(status);
|
|
status.protocolVersion = KVMFR_AUDIO_PROTOCOL_MAX;
|
|
status.requestGeneration = subscriber.requestGeneration;
|
|
status.capabilities =
|
|
m_state.capabilities & subscriber.clientCapabilities;
|
|
status.grantedCapabilities =
|
|
subscriber.grantedCapabilities & status.capabilities;
|
|
status.bindingEpoch = subscriber.bindingEpoch;
|
|
status.roleEpoch = subscriber.roleEpoch;
|
|
status.boundClientID = subscriber.clientID;
|
|
status.endpointGeneration = m_state.generation;
|
|
status.playbackGeneration = m_state.playback.generation;
|
|
status.captureGeneration = m_state.capture.generation;
|
|
status.playbackState = WireState(m_state.playback.state);
|
|
status.captureState = WireState(m_state.capture.state);
|
|
|
|
if ((status.capabilities & KVMFR_AUDIO_CAP_CLOCK_FEEDBACK) &&
|
|
m_feedbackAuthority != INVALID_SLOT)
|
|
{
|
|
const Subscriber& authority =
|
|
m_subscribers[m_feedbackAuthority];
|
|
if (authority.state == SubscriberState::BOUND)
|
|
{
|
|
status.feedbackAuthorityClientID = authority.clientID;
|
|
status.feedbackAuthorityEpoch = authority.roleEpoch;
|
|
}
|
|
}
|
|
if ((status.capabilities & KVMFR_AUDIO_CAP_CAPTURE) &&
|
|
m_captureOwner != INVALID_SLOT &&
|
|
m_subscribers[m_captureOwner].state == SubscriberState::BOUND)
|
|
status.captureOwnerClientID =
|
|
m_subscribers[m_captureOwner].clientID;
|
|
|
|
if (m_state.playback.formatValid &&
|
|
ValidFormat(m_state.playback.format))
|
|
status.playbackFormat = WireFormat(m_state.playback.format);
|
|
if (m_state.capture.formatValid &&
|
|
ValidFormat(m_state.capture.format))
|
|
status.captureFormat = WireFormat(m_state.capture.format);
|
|
|
|
if (m_state.available)
|
|
status.flags |= KVMFR_AUDIO_STATUS_AVAILABLE;
|
|
if (subscriber.state == SubscriberState::BOUND)
|
|
status.flags |= KVMFR_AUDIO_STATUS_BOUND;
|
|
if (status.capabilities & KVMFR_AUDIO_CAP_PLAYBACK)
|
|
status.flags |= KVMFR_AUDIO_STATUS_PLAYBACK_AVAILABLE;
|
|
if (status.capabilities & KVMFR_AUDIO_CAP_CAPTURE)
|
|
status.flags |= KVMFR_AUDIO_STATUS_CAPTURE_AVAILABLE;
|
|
|
|
const bool playbackPrewarm =
|
|
(m_state.playback.state == AudioStreamState::ACQUIRED ||
|
|
m_state.playback.state == AudioStreamState::PAUSED) &&
|
|
m_playbackRunGeneration != m_state.playback.generation;
|
|
if (m_state.available && m_state.active &&
|
|
PlaybackEligible(subscriber) &&
|
|
(status.grantedCapabilities & KVMFR_AUDIO_CAP_PLAYBACK) &&
|
|
m_state.playback.generation &&
|
|
m_state.playback.formatValid &&
|
|
ValidFormat(m_state.playback.format) &&
|
|
(m_state.playback.state == AudioStreamState::RUNNING ||
|
|
playbackPrewarm))
|
|
status.flags |= KVMFR_AUDIO_STATUS_PLAYBACK_ACTIVE;
|
|
|
|
if (m_state.available && m_state.active &&
|
|
CaptureEligible(subscriber) &&
|
|
(status.grantedCapabilities & KVMFR_AUDIO_CAP_CAPTURE) &&
|
|
m_state.capture.generation &&
|
|
m_state.capture.formatValid &&
|
|
ValidFormat(m_state.capture.format) &&
|
|
m_state.capture.state == AudioStreamState::RUNNING)
|
|
status.flags |= KVMFR_AUDIO_STATUS_CAPTURE_ACTIVE;
|
|
return status;
|
|
}
|
|
|
|
bool CLGMPAudio::WriteControlMessage(uint32_t index,
|
|
KVMFRAudioMessageType type, uint64_t streamGeneration,
|
|
KVMFRAudioMessageFlags flags, uint64_t position, int64_t timeNs,
|
|
uint64_t rateQ32, uint32_t frames, const void * payload,
|
|
uint32_t length)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS)
|
|
return false;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state != SubscriberState::BOUND)
|
|
return false;
|
|
|
|
LGMPStreamBuffer buffer = {};
|
|
LGMP_STATUS status = lgmpHostStreamWriteAcquire(
|
|
subscriber.hostControl, &buffer);
|
|
if (status == LGMP_ERR_STREAM_FULL)
|
|
return false;
|
|
if (status == LGMP_ERR_STREAM_UNBOUND ||
|
|
status == LGMP_ERR_STREAM_STALE)
|
|
{
|
|
BeginRelease(index, "host audio control binding lost");
|
|
return false;
|
|
}
|
|
if (status != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostStreamWriteAcquire(audio control)", status);
|
|
return false;
|
|
}
|
|
|
|
const uint32_t bytes =
|
|
static_cast<uint32_t>(sizeof(KVMFRAudioMessage) + length);
|
|
if (!buffer.data || buffer.capacity < bytes || (length && !payload))
|
|
{
|
|
const LGMP_STATUS cancel = lgmpHostStreamWriteCancel(
|
|
subscriber.hostControl, &buffer);
|
|
if (cancel != LGMP_OK)
|
|
DEBUG_WARN("Failed to cancel audio control reservation: %s",
|
|
lgmpStatusString(cancel));
|
|
Fail("undersized host audio control slot", LGMP_ERR_INVALID_SIZE);
|
|
return false;
|
|
}
|
|
|
|
KVMFRAudioMessage message = {};
|
|
message.version = KVMFR_AUDIO_MESSAGE_VERSION;
|
|
message.size = sizeof(message);
|
|
message.type = type;
|
|
message.streamGeneration = streamGeneration;
|
|
message.flags = flags;
|
|
message.sequence = subscriber.hostSequence;
|
|
message.position = position;
|
|
message.timeNs = timeNs;
|
|
message.rateQ32 = rateQ32;
|
|
message.frames = frames;
|
|
message.length = length;
|
|
WCWrite::Copy(buffer.data, &message, sizeof(message));
|
|
if (length)
|
|
WCWrite::Copy(static_cast<uint8_t *>(buffer.data) +
|
|
sizeof(message), payload, length);
|
|
WCWrite::Flush();
|
|
|
|
status = lgmpHostStreamWriteCommit(
|
|
subscriber.hostControl, &buffer, bytes);
|
|
if (status == LGMP_OK)
|
|
{
|
|
++subscriber.hostSequence;
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
return true;
|
|
}
|
|
if (status == LGMP_ERR_STREAM_UNBOUND ||
|
|
status == LGMP_ERR_STREAM_STALE)
|
|
BeginRelease(index, "host audio control binding lost");
|
|
else
|
|
Fail("lgmpHostStreamWriteCommit(audio control)", status);
|
|
return false;
|
|
}
|
|
|
|
bool CLGMPAudio::PlaybackCurrent(
|
|
const KVMFRAudioStatus& status) const
|
|
{
|
|
return (status.flags & KVMFR_AUDIO_STATUS_PLAYBACK_ACTIVE) != 0;
|
|
}
|
|
|
|
bool CLGMPAudio::CaptureCurrent(
|
|
const KVMFRAudioStatus& status) const
|
|
{
|
|
return (status.flags & KVMFR_AUDIO_STATUS_CAPTURE_ACTIVE) != 0;
|
|
}
|
|
|
|
void CLGMPAudio::BeginStatePump(uint32_t index)
|
|
{
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
subscriber.pendingStatus = WireStatus(index);
|
|
subscriber.pumpRevision = subscriber.stateRevision;
|
|
subscriber.pumpStage = PumpStage::STATUS;
|
|
subscriber.ready = false;
|
|
subscriber.awaitingAck = false;
|
|
}
|
|
|
|
void CLGMPAudio::PumpSubscriberState(uint32_t index)
|
|
{
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state != SubscriberState::BOUND ||
|
|
!subscriber.responseAdmitted ||
|
|
!subscriber.subscriptionReceived || !m_stateKnown || m_failed)
|
|
return;
|
|
if (subscriber.pumpRevision != subscriber.stateRevision)
|
|
BeginStatePump(index);
|
|
else if (subscriber.pumpStage == PumpStage::IDLE)
|
|
return;
|
|
|
|
for (unsigned step = 0; step < 12U; ++step)
|
|
{
|
|
if (subscriber.state != SubscriberState::BOUND ||
|
|
subscriber.pumpRevision != subscriber.stateRevision)
|
|
return;
|
|
const KVMFRAudioStatus& status = subscriber.pendingStatus;
|
|
switch (subscriber.pumpStage)
|
|
{
|
|
case PumpStage::STATUS:
|
|
if (!WriteControlMessage(index, KVMFR_AUDIO_MESSAGE_STATUS,
|
|
0, 0, 0, 0, 0, 0, &status, sizeof(status)))
|
|
return;
|
|
subscriber.pumpStage = PumpStage::PLAYBACK_STOP;
|
|
break;
|
|
|
|
case PumpStage::PLAYBACK_STOP:
|
|
if (subscriber.announcedPlayback &&
|
|
(!PlaybackCurrent(status) ||
|
|
subscriber.announcedPlayback !=
|
|
status.playbackGeneration))
|
|
{
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_PLAYBACK_STOP,
|
|
subscriber.announcedPlayback, 0, 0, 0, 0, 0,
|
|
nullptr, 0))
|
|
return;
|
|
subscriber.announcedPlayback = 0;
|
|
}
|
|
subscriber.pumpStage = PumpStage::CAPTURE_STOP;
|
|
break;
|
|
|
|
case PumpStage::CAPTURE_STOP:
|
|
if (subscriber.announcedCapture &&
|
|
(!CaptureCurrent(status) ||
|
|
subscriber.announcedCapture != status.captureGeneration))
|
|
{
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_CAPTURE_STOP,
|
|
subscriber.announcedCapture, 0, 0, 0, 0, 0,
|
|
nullptr, 0))
|
|
return;
|
|
subscriber.announcedCapture = 0;
|
|
}
|
|
subscriber.pumpStage = PumpStage::PLAYBACK_START;
|
|
break;
|
|
|
|
case PumpStage::PLAYBACK_START:
|
|
if (PlaybackCurrent(status) &&
|
|
subscriber.announcedPlayback != status.playbackGeneration)
|
|
{
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_PLAYBACK_START,
|
|
status.playbackGeneration, 0, 0, 0, 0, 0,
|
|
&status.playbackFormat, sizeof(status.playbackFormat)))
|
|
return;
|
|
subscriber.announcedPlayback = status.playbackGeneration;
|
|
subscriber.pumpStage = PumpStage::PLAYBACK_VOLUME;
|
|
}
|
|
else
|
|
subscriber.pumpStage = PumpStage::CAPTURE_START;
|
|
break;
|
|
|
|
case PumpStage::PLAYBACK_VOLUME:
|
|
{
|
|
KVMFRAudioVolume volume = {};
|
|
volume.version = KVMFR_AUDIO_VOLUME_VERSION;
|
|
volume.size = sizeof(volume);
|
|
volume.channelCount = status.playbackFormat.channelCount;
|
|
for (unsigned channel = 0;
|
|
channel < volume.channelCount; ++channel)
|
|
volume.values[channel] = UINT16_MAX;
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_PLAYBACK_VOLUME,
|
|
status.playbackGeneration, 0, 0, 0, 0, 0,
|
|
&volume, sizeof(volume)))
|
|
return;
|
|
subscriber.pumpStage = PumpStage::PLAYBACK_MUTE;
|
|
break;
|
|
}
|
|
|
|
case PumpStage::PLAYBACK_MUTE:
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_PLAYBACK_MUTE,
|
|
status.playbackGeneration, 0, 0, 0, 0, 0,
|
|
nullptr, 0))
|
|
return;
|
|
subscriber.pumpStage = PumpStage::CAPTURE_START;
|
|
break;
|
|
|
|
case PumpStage::CAPTURE_START:
|
|
if (CaptureCurrent(status) &&
|
|
subscriber.announcedCapture != status.captureGeneration)
|
|
{
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_CAPTURE_START,
|
|
status.captureGeneration, 0, 0, 0, 0, 0,
|
|
&status.captureFormat, sizeof(status.captureFormat)))
|
|
return;
|
|
subscriber.announcedCapture = status.captureGeneration;
|
|
subscriber.pumpStage = PumpStage::CAPTURE_VOLUME;
|
|
}
|
|
else
|
|
subscriber.pumpStage = PumpStage::BARRIER;
|
|
break;
|
|
|
|
case PumpStage::CAPTURE_VOLUME:
|
|
{
|
|
KVMFRAudioVolume volume = {};
|
|
volume.version = KVMFR_AUDIO_VOLUME_VERSION;
|
|
volume.size = sizeof(volume);
|
|
volume.channelCount = status.captureFormat.channelCount;
|
|
for (unsigned channel = 0;
|
|
channel < volume.channelCount; ++channel)
|
|
volume.values[channel] = UINT16_MAX;
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_CAPTURE_VOLUME,
|
|
status.captureGeneration, 0, 0, 0, 0, 0,
|
|
&volume, sizeof(volume)))
|
|
return;
|
|
subscriber.pumpStage = PumpStage::CAPTURE_MUTE;
|
|
break;
|
|
}
|
|
|
|
case PumpStage::CAPTURE_MUTE:
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_CAPTURE_MUTE,
|
|
status.captureGeneration, 0, 0, 0, 0, 0,
|
|
nullptr, 0))
|
|
return;
|
|
subscriber.pumpStage = PumpStage::BARRIER;
|
|
break;
|
|
|
|
case PumpStage::BARRIER:
|
|
{
|
|
KVMFRAudioStateBarrier barrier = {};
|
|
barrier.bindingEpoch = subscriber.bindingEpoch;
|
|
barrier.roleEpoch = subscriber.roleEpoch;
|
|
barrier.stateSerial = NextSerial(subscriber.barrier.stateSerial);
|
|
const uint64_t generation = PlaybackCurrent(status) ?
|
|
status.playbackGeneration : 0;
|
|
if (!WriteControlMessage(index,
|
|
KVMFR_AUDIO_MESSAGE_STATE_BARRIER, generation,
|
|
0, 0, 0, 0, 0, &barrier, sizeof(barrier)))
|
|
return;
|
|
subscriber.barrier = barrier;
|
|
subscriber.barrierGeneration = generation;
|
|
subscriber.awaitingAck = true;
|
|
subscriber.pumpStage = PumpStage::IDLE;
|
|
break;
|
|
}
|
|
|
|
case PumpStage::IDLE:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CLGMPAudio::PumpState()
|
|
{
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
PumpSubscriberState(index);
|
|
}
|
|
|
|
void CLGMPAudio::CheckPlaybackBackpressure(uint64_t now)
|
|
{
|
|
if (!m_playbackBlocked)
|
|
return;
|
|
if (!m_started || m_failed || !m_stateKnown ||
|
|
!m_state.available || !m_state.active ||
|
|
m_blockedPlayback.endpointGeneration != m_state.generation ||
|
|
m_blockedPlayback.streamGeneration !=
|
|
m_state.playback.generation ||
|
|
!m_state.playback.formatValid ||
|
|
m_state.playback.state != AudioStreamState::RUNNING ||
|
|
!SameFormat(m_blockedPlayback.format,
|
|
m_state.playback.format))
|
|
{
|
|
ClearBlockedPlayback(true);
|
|
return;
|
|
}
|
|
|
|
bool eligible = false;
|
|
for (const Subscriber& subscriber : m_subscribers)
|
|
if (subscriber.responseAdmitted &&
|
|
subscriber.subscriptionReceived &&
|
|
PlaybackEligible(subscriber))
|
|
{
|
|
eligible = true;
|
|
break;
|
|
}
|
|
if (!eligible)
|
|
{
|
|
ClearBlockedPlayback(true);
|
|
return;
|
|
}
|
|
if (!HasReadyPlayback())
|
|
return;
|
|
|
|
if (m_feedbackAuthority == INVALID_SLOT)
|
|
{
|
|
ClearBlockedPlayback(true);
|
|
return;
|
|
}
|
|
Subscriber& authority = m_subscribers[m_feedbackAuthority];
|
|
if (!authority.ready || !PlaybackEligible(authority) ||
|
|
!(authority.grantedCapabilities &
|
|
KVMFR_AUDIO_CAP_CLOCK_FEEDBACK))
|
|
{
|
|
ClearBlockedPlayback(true);
|
|
return;
|
|
}
|
|
|
|
LGMPSPMCReaderState reader = {};
|
|
const LGMP_STATUS status = lgmpHostSPMCReaderGetState(
|
|
m_playbackStream, authority.playbackReaderID, &reader);
|
|
if (status == LGMP_ERR_STREAM_BUSY)
|
|
return;
|
|
bool stalled = false;
|
|
if (status == LGMP_OK)
|
|
{
|
|
if (reader.state != LGMP_SPMC_READER_READY ||
|
|
reader.clientID != authority.clientID ||
|
|
reader.epoch != authority.playbackReaderEpoch)
|
|
{
|
|
RevokeFeedbackAuthority("playback reader binding lost");
|
|
return;
|
|
}
|
|
stalled = reader.producerSequence - reader.consumerSequence >=
|
|
KVMFR_AUDIO_STREAM_SLOT_COUNT;
|
|
}
|
|
else
|
|
{
|
|
Fail("lgmpHostSPMCReaderGetState(audio)", status);
|
|
return;
|
|
}
|
|
|
|
if (!stalled)
|
|
{
|
|
ClearBlockedPlayback(true);
|
|
return;
|
|
}
|
|
if (!m_authorityBlockedSince)
|
|
m_authorityBlockedSince = now;
|
|
else if (now - m_authorityBlockedSince >= AUTHORITY_STALL_MS)
|
|
RevokeFeedbackAuthority("playback reader stalled");
|
|
}
|
|
|
|
bool CLGMPAudio::ParseInbound(
|
|
const LGMPStreamBuffer& buffer, KVMFRAudioMessage& message) const
|
|
{
|
|
if (!buffer.data || buffer.size < sizeof(message) ||
|
|
buffer.size > buffer.capacity)
|
|
return false;
|
|
memcpy(&message, buffer.data, sizeof(message));
|
|
if (message.version != KVMFR_AUDIO_MESSAGE_VERSION ||
|
|
message.size != sizeof(message) || message.reserved0 ||
|
|
message.length > KVMFR_AUDIO_PCM_BYTES ||
|
|
message.length >
|
|
(std::numeric_limits<uint32_t>::max)() - sizeof(message))
|
|
return false;
|
|
return buffer.size == sizeof(message) + message.length;
|
|
}
|
|
|
|
bool CLGMPAudio::PendingCaptureCurrent(uint32_t index) const
|
|
{
|
|
if (!m_pendingCapture.valid || index >= LGMP_MAX_CLIENTS ||
|
|
m_pendingCapture.subscriber != index)
|
|
return false;
|
|
const Subscriber& subscriber = m_subscribers[index];
|
|
const AudioPacket& packet = m_pendingCapture.packet;
|
|
return subscriber.state == SubscriberState::BOUND &&
|
|
subscriber.serial == m_pendingCapture.subscriberSerial &&
|
|
m_captureOwner == index && m_captureBinding == index &&
|
|
CaptureEligible(subscriber) &&
|
|
(subscriber.grantedCapabilities & KVMFR_AUDIO_CAP_CAPTURE) &&
|
|
subscriber.announcedCapture == packet.streamGeneration &&
|
|
m_stateKnown && m_state.available && m_state.active &&
|
|
(m_state.capabilities & KVMFR_AUDIO_CAP_CAPTURE) &&
|
|
m_state.capture.formatValid &&
|
|
ValidFormat(m_state.capture.format) &&
|
|
m_state.capture.state == AudioStreamState::RUNNING &&
|
|
packet.endpointGeneration == m_state.generation &&
|
|
packet.streamGeneration == m_state.capture.generation &&
|
|
SameFormat(packet.format, m_state.capture.format);
|
|
}
|
|
|
|
bool CLGMPAudio::PrepareCapture(
|
|
const KVMFRAudioMessage& message, const LGMPStreamBuffer& buffer,
|
|
uint32_t index)
|
|
{
|
|
if (index >= LGMP_MAX_CLIENTS ||
|
|
m_subscribers[index].state != SubscriberState::BOUND ||
|
|
m_captureOwner != index || m_captureBinding != index ||
|
|
!m_stateKnown ||
|
|
!m_state.available || !m_state.active ||
|
|
!(m_state.capabilities & KVMFR_AUDIO_CAP_CAPTURE) ||
|
|
!m_state.capture.formatValid ||
|
|
!ValidFormat(m_state.capture.format) ||
|
|
m_state.capture.state != AudioStreamState::RUNNING ||
|
|
message.streamGeneration != m_state.capture.generation)
|
|
return false;
|
|
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
const bool silent =
|
|
(message.flags & KVMFR_AUDIO_MESSAGE_SILENT) != 0;
|
|
const uint32_t bytes =
|
|
message.frames * m_state.capture.format.blockAlign;
|
|
if (bytes > KVMFR_AUDIO_PCM_BYTES ||
|
|
(silent ? message.length != 0 : message.length != bytes))
|
|
return false;
|
|
|
|
AudioPacket packet = {};
|
|
packet.endpointGeneration = m_state.generation;
|
|
packet.streamGeneration = message.streamGeneration;
|
|
if (message.flags & KVMFR_AUDIO_MESSAGE_DISCONTINUITY)
|
|
packet.flags |= AUDIO_PACKET_DISCONTINUITY;
|
|
if (message.flags & KVMFR_AUDIO_MESSAGE_SILENT)
|
|
packet.flags |= AUDIO_PACKET_SILENT;
|
|
if (message.flags & KVMFR_AUDIO_MESSAGE_CLOCK_VALID)
|
|
packet.flags |= AUDIO_PACKET_CLOCK_VALID;
|
|
if (message.flags & KVMFR_AUDIO_MESSAGE_CLOCK_STABLE)
|
|
packet.flags |= AUDIO_PACKET_CLOCK_STABLE;
|
|
if (subscriber.captureDiscontinuity)
|
|
packet.flags |= AUDIO_PACKET_DISCONTINUITY;
|
|
packet.frames = message.frames;
|
|
packet.position = message.position;
|
|
packet.timeNs = message.timeNs;
|
|
packet.rateQ32 = message.rateQ32;
|
|
packet.format = m_state.capture.format;
|
|
|
|
m_pendingCapture.valid = true;
|
|
m_pendingCapture.subscriber = index;
|
|
m_pendingCapture.subscriberSerial = subscriber.serial;
|
|
m_pendingCapture.buffer = buffer;
|
|
m_pendingCapture.packet = packet;
|
|
m_pendingCapture.data = silent ? nullptr :
|
|
static_cast<const uint8_t *>(buffer.data) +
|
|
sizeof(KVMFRAudioMessage);
|
|
m_pendingCapture.size = message.length;
|
|
m_pendingCapture.readySerial = m_captureReadySerial;
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
return true;
|
|
}
|
|
|
|
void CLGMPAudio::DrainControl(uint32_t index)
|
|
{
|
|
for (unsigned count = 0; count < INBOUND_DRAIN_MAX; ++count)
|
|
{
|
|
CSRWSharedLock callbackLock(m_callbackLock);
|
|
IAudioTarget * target = nullptr;
|
|
AudioClockFeedback feedback = {};
|
|
bool callClock = false;
|
|
uint64_t subscriberSerial = 0;
|
|
uint32_t feedbackRoleEpoch = 0;
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (index >= LGMP_MAX_CLIENTS)
|
|
return;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (subscriber.state == SubscriberState::NONE)
|
|
return;
|
|
|
|
LGMPStreamBuffer buffer = {};
|
|
const LGMP_STATUS peek = lgmpHostStreamReadPeek(
|
|
subscriber.clientControl, &buffer);
|
|
if (peek == LGMP_ERR_STREAM_EMPTY)
|
|
return;
|
|
if (peek == LGMP_ERR_STREAM_UNBOUND ||
|
|
peek == LGMP_ERR_STREAM_STALE)
|
|
{
|
|
if (subscriber.state == SubscriberState::BOUND)
|
|
BeginRelease(index, "client audio control binding lost");
|
|
return;
|
|
}
|
|
if (peek != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostStreamReadPeek(audio control)", peek);
|
|
return;
|
|
}
|
|
|
|
const auto release = [&]() -> bool
|
|
{
|
|
const LGMP_STATUS status = lgmpHostStreamReadRelease(
|
|
subscriber.clientControl, &buffer);
|
|
if (status != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostStreamReadRelease(audio control)", status);
|
|
return false;
|
|
}
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
return true;
|
|
};
|
|
|
|
if (subscriber.state == SubscriberState::RELEASING)
|
|
{
|
|
if (!release())
|
|
return;
|
|
continue;
|
|
}
|
|
|
|
KVMFRAudioMessage message = {};
|
|
if (!ParseInbound(buffer, message))
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "malformed client audio control record");
|
|
return;
|
|
}
|
|
|
|
const bool sequenceValid = subscriber.controlSequenceKnown ?
|
|
message.sequence == subscriber.nextControlSequence :
|
|
message.sequence == 0;
|
|
if (!sequenceValid)
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "client audio control sequence gap");
|
|
return;
|
|
}
|
|
subscriber.nextControlSequence = message.sequence + 1;
|
|
subscriber.controlSequenceKnown = true;
|
|
|
|
const uint8_t * payload =
|
|
static_cast<const uint8_t *>(buffer.data) + sizeof(message);
|
|
switch (message.type)
|
|
{
|
|
case KVMFR_AUDIO_MESSAGE_PLAYBACK_SUBSCRIBE:
|
|
{
|
|
KVMFRAudioSubscription subscription = {};
|
|
if (message.length == sizeof(subscription))
|
|
memcpy(&subscription, payload, sizeof(subscription));
|
|
const bool valid = !message.streamGeneration &&
|
|
!message.flags && !message.position && !message.timeNs &&
|
|
!message.rateQ32 && !message.frames &&
|
|
message.length == sizeof(subscription) &&
|
|
subscription.bindingEpoch == subscriber.bindingEpoch &&
|
|
subscription.roleEpoch &&
|
|
!(subscription.subscriptions &
|
|
~AUDIO_SUBSCRIPTION_MASK) && !subscription.reserved &&
|
|
(!(subscription.subscriptions &
|
|
KVMFR_AUDIO_SUBSCRIBE_CAPTURE) ||
|
|
(subscriber.clientCapabilities &
|
|
KVMFR_AUDIO_CAP_CAPTURE));
|
|
const bool initial = !subscriber.subscriptionReceived;
|
|
if (!valid || (initial &&
|
|
subscription.subscriptions !=
|
|
subscriber.subscriptions))
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "invalid audio subscription");
|
|
return;
|
|
}
|
|
|
|
if (!release())
|
|
return;
|
|
RenewLease(subscriber);
|
|
if (subscription.roleEpoch != subscriber.roleEpoch)
|
|
{
|
|
if (static_cast<int32_t>(subscription.roleEpoch -
|
|
subscriber.roleEpoch) > 0)
|
|
{
|
|
BeginRelease(index,
|
|
"invalid future audio subscription");
|
|
return;
|
|
}
|
|
if (initial)
|
|
{
|
|
subscriber.subscriptionReceived = true;
|
|
MarkStateDirty(index);
|
|
if (m_captureOwner == INVALID_SLOT)
|
|
AssignCaptureOwner();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
const KVMFRAudioSubscriptionFlags previous =
|
|
subscriber.subscriptions;
|
|
subscriber.subscriptions = subscription.subscriptions;
|
|
subscriber.subscriptionReceived = true;
|
|
|
|
if (m_feedbackAuthority == index &&
|
|
!FeedbackEligible(subscriber))
|
|
RevokeFeedbackAuthority("playback subscription removed");
|
|
if (m_captureOwner == index &&
|
|
!CaptureEligible(subscriber))
|
|
{
|
|
m_captureOwner = INVALID_SLOT;
|
|
subscriber.captureRevoking = true;
|
|
subscriber.captureRevokeDeadline =
|
|
GetTickCount64() + CAPTURE_REVOKE_ACK_MS;
|
|
RefreshGranted(index, true);
|
|
}
|
|
if (previous != subscriber.subscriptions ||
|
|
!subscriber.pumpRevision)
|
|
MarkStateDirty(index);
|
|
if (subscriber.captureRevoking)
|
|
subscriber.captureRevokeRevision =
|
|
subscriber.stateRevision;
|
|
if (m_captureOwner == INVALID_SLOT &&
|
|
m_captureBinding == INVALID_SLOT)
|
|
AssignCaptureOwner();
|
|
continue;
|
|
}
|
|
|
|
case KVMFR_AUDIO_MESSAGE_STATE_ACK:
|
|
{
|
|
KVMFRAudioStateBarrier barrier = {};
|
|
if (message.length == sizeof(barrier))
|
|
memcpy(&barrier, payload, sizeof(barrier));
|
|
const bool valid = !message.flags && !message.position &&
|
|
!message.timeNs && !message.rateQ32 && !message.frames &&
|
|
message.length == sizeof(barrier) &&
|
|
barrier.bindingEpoch == subscriber.bindingEpoch &&
|
|
barrier.stateSerial;
|
|
if (!valid)
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "invalid audio state acknowledgement");
|
|
return;
|
|
}
|
|
if (!release())
|
|
return;
|
|
RenewLease(subscriber);
|
|
if (barrier.roleEpoch != subscriber.roleEpoch)
|
|
{
|
|
if (static_cast<int32_t>(barrier.roleEpoch -
|
|
subscriber.roleEpoch) < 0)
|
|
continue;
|
|
BeginRelease(index,
|
|
"invalid future audio state acknowledgement");
|
|
return;
|
|
}
|
|
if (subscriber.awaitingAck &&
|
|
message.streamGeneration ==
|
|
subscriber.barrierGeneration &&
|
|
!memcmp(&barrier, &subscriber.barrier,
|
|
sizeof(barrier)))
|
|
{
|
|
subscriber.awaitingAck = false;
|
|
subscriber.ready = true;
|
|
DEBUG_INFO("Audio client %u generation %u is ready",
|
|
subscriber.clientID,
|
|
subscriber.requestGeneration);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
case KVMFR_AUDIO_MESSAGE_CLOCK_FEEDBACK:
|
|
{
|
|
KVMFRAudioClockFeedback wire = {};
|
|
if (message.length == sizeof(wire))
|
|
memcpy(&wire, payload, sizeof(wire));
|
|
const uint32_t validFlags =
|
|
KVMFR_AUDIO_MESSAGE_CLOCK_VALID |
|
|
KVMFR_AUDIO_MESSAGE_CLOCK_STABLE |
|
|
KVMFR_AUDIO_MESSAGE_DISCONTINUITY;
|
|
const bool valid = !(message.flags & ~validFlags) &&
|
|
(message.flags & KVMFR_AUDIO_MESSAGE_CLOCK_VALID) &&
|
|
(!(message.flags & KVMFR_AUDIO_MESSAGE_CLOCK_STABLE) ||
|
|
(message.flags & KVMFR_AUDIO_MESSAGE_CLOCK_VALID)) &&
|
|
message.streamGeneration && !message.frames &&
|
|
message.length == sizeof(wire) && wire.targetRateQ32 &&
|
|
wire.bindingEpoch == subscriber.bindingEpoch &&
|
|
wire.roleEpoch;
|
|
if (!valid)
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "invalid audio clock feedback");
|
|
return;
|
|
}
|
|
|
|
if (!release())
|
|
return;
|
|
RenewLease(subscriber);
|
|
if (wire.roleEpoch != subscriber.roleEpoch)
|
|
{
|
|
if (static_cast<int32_t>(wire.roleEpoch -
|
|
subscriber.roleEpoch) < 0)
|
|
continue;
|
|
BeginRelease(index,
|
|
"invalid future audio clock feedback");
|
|
return;
|
|
}
|
|
const bool current = m_feedbackAuthority == index &&
|
|
subscriber.ready &&
|
|
(subscriber.grantedCapabilities &
|
|
KVMFR_AUDIO_CAP_CLOCK_FEEDBACK) &&
|
|
m_stateKnown && m_state.available && m_state.active &&
|
|
(m_state.capabilities &
|
|
KVMFR_AUDIO_CAP_CLOCK_FEEDBACK) &&
|
|
message.streamGeneration ==
|
|
m_state.playback.generation;
|
|
if (!current)
|
|
continue;
|
|
|
|
feedback.endpointGeneration = m_state.generation;
|
|
feedback.playbackGeneration = message.streamGeneration;
|
|
feedback.position = message.position;
|
|
feedback.timeNs = message.timeNs;
|
|
feedback.rateQ32 = message.rateQ32;
|
|
feedback.targetRateQ32 = wire.targetRateQ32;
|
|
feedback.flags = AUDIO_CLOCK_VALID;
|
|
if (message.flags & KVMFR_AUDIO_MESSAGE_CLOCK_STABLE)
|
|
feedback.flags |= AUDIO_CLOCK_STABLE;
|
|
if (message.flags & KVMFR_AUDIO_MESSAGE_DISCONTINUITY)
|
|
feedback.flags |= AUDIO_CLOCK_DISCONTINUITY;
|
|
target = m_started ? m_target : nullptr;
|
|
subscriberSerial = subscriber.serial;
|
|
feedbackRoleEpoch = subscriber.roleEpoch;
|
|
callClock = target != nullptr;
|
|
break;
|
|
}
|
|
|
|
case KVMFR_AUDIO_MESSAGE_KEEPALIVE:
|
|
case KVMFR_AUDIO_MESSAGE_RELEASE:
|
|
if (!EmptyControl(message))
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "invalid audio client control");
|
|
return;
|
|
}
|
|
if (!release())
|
|
return;
|
|
if (message.type == KVMFR_AUDIO_MESSAGE_RELEASE)
|
|
{
|
|
BeginRelease(index, "client audio release");
|
|
return;
|
|
}
|
|
RenewLease(subscriber);
|
|
continue;
|
|
|
|
default:
|
|
(void)release();
|
|
BeginRelease(index, "unsupported client audio control");
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!callClock)
|
|
continue;
|
|
const AudioResult result = target->SetClockFeedback(feedback);
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (index >= LGMP_MAX_CLIENTS ||
|
|
m_subscribers[index].state != SubscriberState::BOUND ||
|
|
m_subscribers[index].serial != subscriberSerial)
|
|
return;
|
|
if (result == AudioResult::FAILED ||
|
|
result == AudioResult::REJECTED)
|
|
{
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (m_feedbackAuthority != index || !subscriber.ready ||
|
|
subscriber.roleEpoch != feedbackRoleEpoch ||
|
|
!(subscriber.grantedCapabilities &
|
|
KVMFR_AUDIO_CAP_CLOCK_FEEDBACK) ||
|
|
!m_stateKnown || m_state.playback.generation !=
|
|
feedback.playbackGeneration)
|
|
continue;
|
|
RevokeFeedbackAuthority("audio clock target failed");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CLGMPAudio::DrainCapture()
|
|
{
|
|
for (unsigned count = 0; count < INBOUND_DRAIN_MAX; ++count)
|
|
{
|
|
CSRWSharedLock callbackLock(m_callbackLock);
|
|
IAudioTarget * target = nullptr;
|
|
bool callCapture = false;
|
|
uint32_t index = INVALID_SLOT;
|
|
uint64_t subscriberSerial = 0;
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (m_captureBinding == INVALID_SLOT)
|
|
return;
|
|
index = m_captureBinding;
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
|
|
if (m_pendingCapture.valid)
|
|
{
|
|
if (!PendingCaptureCurrent(index))
|
|
{
|
|
ReleasePendingCapture();
|
|
subscriber.captureDiscontinuity = true;
|
|
continue;
|
|
}
|
|
if (m_pendingCapture.readySerial == m_captureReadySerial)
|
|
return;
|
|
m_pendingCapture.readySerial = m_captureReadySerial;
|
|
target = m_started ? m_target : nullptr;
|
|
subscriberSerial = subscriber.serial;
|
|
callCapture = target != nullptr;
|
|
}
|
|
else
|
|
{
|
|
LGMPStreamBuffer buffer = {};
|
|
const LGMP_STATUS peek = lgmpHostStreamReadPeek(
|
|
m_captureStream, &buffer);
|
|
if (peek == LGMP_ERR_STREAM_EMPTY)
|
|
return;
|
|
if (peek == LGMP_ERR_STREAM_UNBOUND ||
|
|
peek == LGMP_ERR_STREAM_STALE)
|
|
{
|
|
if (subscriber.state == SubscriberState::BOUND)
|
|
BeginRelease(index, "capture audio binding lost");
|
|
return;
|
|
}
|
|
if (peek != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostStreamReadPeek(audio capture)", peek);
|
|
return;
|
|
}
|
|
|
|
const auto release = [&]() -> bool
|
|
{
|
|
const LGMP_STATUS status = lgmpHostStreamReadRelease(
|
|
m_captureStream, &buffer);
|
|
if (status != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostStreamReadRelease(audio capture)", status);
|
|
return false;
|
|
}
|
|
m_inboundActivitySerial =
|
|
NextSerial(m_inboundActivitySerial);
|
|
return true;
|
|
};
|
|
|
|
if (subscriber.state == SubscriberState::RELEASING ||
|
|
subscriber.captureRevoking)
|
|
{
|
|
if (!release())
|
|
return;
|
|
continue;
|
|
}
|
|
|
|
KVMFRAudioMessage message = {};
|
|
if (!ParseInbound(buffer, message))
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "malformed capture audio record");
|
|
return;
|
|
}
|
|
const bool sequenceGap =
|
|
(subscriber.captureSequenceKnown &&
|
|
message.sequence != subscriber.nextCaptureSequence) ||
|
|
(!subscriber.captureSequenceKnown && message.sequence != 0);
|
|
subscriber.nextCaptureSequence = message.sequence + 1;
|
|
subscriber.captureSequenceKnown = true;
|
|
if (sequenceGap)
|
|
subscriber.captureDiscontinuity = true;
|
|
|
|
const bool clockStable =
|
|
(message.flags & KVMFR_AUDIO_MESSAGE_CLOCK_STABLE) != 0;
|
|
const bool clockValid =
|
|
(message.flags & KVMFR_AUDIO_MESSAGE_CLOCK_VALID) != 0;
|
|
const bool structurallyValid =
|
|
message.type == KVMFR_AUDIO_MESSAGE_CAPTURE_DATA &&
|
|
!(message.flags & ~WIRE_PACKET_FLAG_MASK) &&
|
|
(!clockStable || clockValid) &&
|
|
(clockValid || (!message.position && !message.timeNs &&
|
|
!message.rateQ32)) && message.streamGeneration &&
|
|
message.frames &&
|
|
message.frames <= KVMFR_AUDIO_MAX_FRAMES_PER_PACKET;
|
|
if (!structurallyValid)
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "invalid capture audio record");
|
|
return;
|
|
}
|
|
RenewLease(subscriber);
|
|
const bool current = m_captureOwner == index &&
|
|
(subscriber.grantedCapabilities &
|
|
KVMFR_AUDIO_CAP_CAPTURE) &&
|
|
subscriber.announcedCapture == message.streamGeneration &&
|
|
m_stateKnown && m_state.available && m_state.active &&
|
|
(m_state.capabilities & KVMFR_AUDIO_CAP_CAPTURE) &&
|
|
m_state.capture.formatValid &&
|
|
ValidFormat(m_state.capture.format) &&
|
|
m_state.capture.state == AudioStreamState::RUNNING &&
|
|
message.streamGeneration == m_state.capture.generation;
|
|
if (!current)
|
|
{
|
|
if (!release())
|
|
return;
|
|
subscriber.captureDiscontinuity = true;
|
|
continue;
|
|
}
|
|
|
|
const bool silent = (message.flags &
|
|
KVMFR_AUDIO_MESSAGE_SILENT) != 0;
|
|
const uint32_t bytes = message.frames *
|
|
m_state.capture.format.blockAlign;
|
|
if (bytes > KVMFR_AUDIO_PCM_BYTES ||
|
|
(silent ? message.length != 0 :
|
|
message.length != bytes))
|
|
{
|
|
(void)release();
|
|
BeginRelease(index, "invalid capture audio payload");
|
|
return;
|
|
}
|
|
if (!PrepareCapture(message, buffer, index))
|
|
{
|
|
if (!release())
|
|
return;
|
|
subscriber.captureDiscontinuity = true;
|
|
continue;
|
|
}
|
|
target = m_started ? m_target : nullptr;
|
|
subscriberSerial = subscriber.serial;
|
|
callCapture = target != nullptr;
|
|
}
|
|
m_captureCallbackInFlight = callCapture;
|
|
}
|
|
|
|
AudioResult result = AudioResult::UNAVAILABLE;
|
|
if (callCapture)
|
|
result = target->SendCapture(m_pendingCapture.packet,
|
|
m_pendingCapture.data, m_pendingCapture.size);
|
|
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
m_captureCallbackInFlight = false;
|
|
if (index >= LGMP_MAX_CLIENTS ||
|
|
m_subscribers[index].serial != subscriberSerial ||
|
|
!m_pendingCapture.valid)
|
|
{
|
|
if (m_pendingCapture.valid)
|
|
ReleasePendingCapture();
|
|
return;
|
|
}
|
|
Subscriber& subscriber = m_subscribers[index];
|
|
if (!PendingCaptureCurrent(index))
|
|
{
|
|
ReleasePendingCapture();
|
|
subscriber.captureDiscontinuity = true;
|
|
continue;
|
|
}
|
|
if (result == AudioResult::BUSY)
|
|
return;
|
|
|
|
const LGMP_STATUS release = lgmpHostStreamReadRelease(
|
|
m_captureStream, &m_pendingCapture.buffer);
|
|
if (release != LGMP_OK)
|
|
{
|
|
m_pendingCapture = {};
|
|
Fail("lgmpHostStreamReadRelease(audio capture)", release);
|
|
return;
|
|
}
|
|
m_pendingCapture = {};
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
subscriber.captureDiscontinuity =
|
|
result != AudioResult::ACCEPTED;
|
|
if (result == AudioResult::FAILED ||
|
|
result == AudioResult::REJECTED)
|
|
{
|
|
BeginRelease(index, "audio capture target failed");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CLGMPAudio::DrainInbound()
|
|
{
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
DrainControl(index);
|
|
DrainCapture();
|
|
}
|
|
|
|
void CLGMPAudio::ProcessActivation()
|
|
{
|
|
CSRWSharedLock callbackLock(m_callbackLock);
|
|
IAudioTarget * target = nullptr;
|
|
bool activate = false;
|
|
{
|
|
CSRWSharedLock lock(m_lock);
|
|
if (!m_started || !m_target || m_failed || !m_stateKnown)
|
|
return;
|
|
activate = HasBoundSubscribers();
|
|
if (activate == m_activationCommanded)
|
|
return;
|
|
target = m_target;
|
|
}
|
|
|
|
const AudioResult result = target->SetAudioActive(activate);
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_started || m_target != target)
|
|
return;
|
|
if (result == AudioResult::ACCEPTED ||
|
|
(!activate && (result == AudioResult::UNAVAILABLE ||
|
|
result == AudioResult::STALE)))
|
|
m_activationCommanded = activate;
|
|
else if (result == AudioResult::FAILED ||
|
|
result == AudioResult::REJECTED)
|
|
Fail("audio endpoint activation", LGMP_ERR_CORRUPTED);
|
|
}
|
|
|
|
void CLGMPAudio::NotifyPlaybackReady()
|
|
{
|
|
CSRWSharedLock callbackLock(m_callbackLock);
|
|
IAudioTarget * target = nullptr;
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_playbackReadyPending)
|
|
return;
|
|
m_playbackReadyPending = false;
|
|
if (m_started)
|
|
target = m_target;
|
|
}
|
|
if (target)
|
|
target->PlaybackReceiveReady();
|
|
}
|
|
|
|
void CLGMPAudio::NotifyFailure()
|
|
{
|
|
CSRWSharedLock callbackLock(m_callbackLock);
|
|
IAudioTarget * target = nullptr;
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_failed || m_failureNotified)
|
|
return;
|
|
m_failureNotified = true;
|
|
if (m_started)
|
|
target = m_target;
|
|
}
|
|
if (target)
|
|
target->AudioFailed();
|
|
}
|
|
|
|
void CLGMPAudio::Fail(
|
|
const char * operation, LGMP_STATUS status)
|
|
{
|
|
if (!m_failed)
|
|
DEBUG_ERROR("%s Failed (Audio): %s",
|
|
operation, lgmpStatusString(status));
|
|
ClearBlockedPlayback(true);
|
|
m_failed = true;
|
|
}
|
|
|
|
void CLGMPAudio::Process()
|
|
{
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_claimResponderReady)
|
|
return;
|
|
PumpResponses();
|
|
if (!m_initialized)
|
|
return;
|
|
MaintainSubscribers(GetTickCount64());
|
|
PumpResponses();
|
|
PumpState();
|
|
CheckPlaybackBackpressure(GetTickCount64());
|
|
}
|
|
ProcessActivation();
|
|
NotifyPlaybackReady();
|
|
NotifyFailure();
|
|
}
|
|
|
|
bool CLGMPAudio::CanRespondToClaims()
|
|
{
|
|
CSRWSharedLock lock(m_lock);
|
|
return m_claimResponderReady;
|
|
}
|
|
|
|
bool CLGMPAudio::Start(IAudioTarget& target)
|
|
{
|
|
CSRWExclusiveLock lifecycleLock(m_lifecycleLock);
|
|
CSRWExclusiveLock callbackLock(m_callbackLock);
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_initialized || m_failed)
|
|
return false;
|
|
if (m_started)
|
|
return m_target == ⌖
|
|
m_target = ⌖
|
|
m_started = true;
|
|
m_stateKnown = false;
|
|
m_failureNotified = false;
|
|
m_activationCommanded = false;
|
|
return true;
|
|
}
|
|
|
|
void CLGMPAudio::Stop()
|
|
{
|
|
CSRWExclusiveLock lifecycleLock(m_lifecycleLock);
|
|
CSRWExclusiveLock callbackLock(m_callbackLock);
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_started && !m_target)
|
|
return;
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
BeginRelease(index, "audio source stopped");
|
|
ClearBlockedPlayback(false);
|
|
m_started = false;
|
|
m_target = nullptr;
|
|
m_playbackReadyPending = false;
|
|
m_activationCommanded = false;
|
|
}
|
|
|
|
void CLGMPAudio::TransportStop()
|
|
{
|
|
CSRWExclusiveLock lifecycleLock(m_lifecycleLock);
|
|
StopInboundWorker();
|
|
CSRWExclusiveLock callbackLock(m_callbackLock);
|
|
CSRWExclusiveLock lock(m_lock);
|
|
m_started = false;
|
|
m_target = nullptr;
|
|
m_playbackReadyPending = false;
|
|
ClearBlockedPlayback(false);
|
|
ReleasePendingCapture();
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
{
|
|
if (m_subscribers[index].state == SubscriberState::NONE)
|
|
continue;
|
|
ForceUnbindSubscriber(index);
|
|
ResetSubscriber(index);
|
|
}
|
|
m_feedbackAuthority = INVALID_SLOT;
|
|
m_captureOwner = INVALID_SLOT;
|
|
m_captureBinding = INVALID_SLOT;
|
|
m_activationCommanded = false;
|
|
for (PendingResponse& response : m_pendingResponse)
|
|
response = {};
|
|
for (ClaimRecord& record : m_claimRecord)
|
|
record = {};
|
|
}
|
|
|
|
void CLGMPAudio::AudioState(
|
|
const AudioEndpointStatus& state)
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (!m_started)
|
|
return;
|
|
|
|
const uint64_t previousPlayback = m_previousPlaybackGeneration;
|
|
if (state.playback.state == AudioStreamState::RUNNING)
|
|
m_playbackRunGeneration = state.playback.generation;
|
|
|
|
if (m_playbackBlocked)
|
|
{
|
|
const bool playbackCurrent = state.available && state.active &&
|
|
(state.capabilities & AUDIO_CAP_PLAYBACK) &&
|
|
state.playback.formatValid &&
|
|
ValidFormat(state.playback.format) &&
|
|
state.playback.state == AudioStreamState::RUNNING &&
|
|
state.generation == m_blockedPlayback.endpointGeneration &&
|
|
state.playback.generation ==
|
|
m_blockedPlayback.streamGeneration &&
|
|
SameFormat(state.playback.format, m_blockedPlayback.format);
|
|
if (!playbackCurrent)
|
|
ClearBlockedPlayback(true);
|
|
}
|
|
|
|
m_state = state;
|
|
m_stateKnown = true;
|
|
m_previousPlaybackGeneration = state.playback.generation;
|
|
for (uint32_t index = 0; index < LGMP_MAX_CLIENTS; ++index)
|
|
RefreshGranted(index, true);
|
|
MarkAllStateDirty();
|
|
if (state.playback.generation &&
|
|
state.playback.generation != previousPlayback)
|
|
{
|
|
for (Subscriber& subscriber : m_subscribers)
|
|
if (subscriber.state == SubscriberState::BOUND)
|
|
subscriber.feedbackRevoked = false;
|
|
PromoteFeedbackAuthority(state.playback.generation);
|
|
}
|
|
if (m_captureOwner == INVALID_SLOT)
|
|
AssignCaptureOwner();
|
|
if (!m_inboundStopping && m_inboundWakeEvent)
|
|
SetEvent(m_inboundWakeEvent);
|
|
}
|
|
|
|
AudioResult CLGMPAudio::SendPlayback(
|
|
const AudioPacket& packet, const uint8_t * data, size_t size)
|
|
{
|
|
if ((packet.flags & ~AUDIO_PACKET_FLAG_MASK) ||
|
|
((packet.flags & AUDIO_PACKET_CLOCK_STABLE) &&
|
|
!(packet.flags & AUDIO_PACKET_CLOCK_VALID)) ||
|
|
(!(packet.flags & AUDIO_PACKET_CLOCK_VALID) &&
|
|
(packet.position || packet.timeNs || packet.rateQ32)) ||
|
|
!packet.frames ||
|
|
packet.frames > AUDIO_MAX_FRAMES_PER_PACKET ||
|
|
!ValidFormat(packet.format))
|
|
return AudioResult::REJECTED;
|
|
|
|
const size_t pcmBytes = static_cast<size_t>(packet.frames) *
|
|
packet.format.blockAlign;
|
|
const bool silent = (packet.flags & AUDIO_PACKET_SILENT) != 0;
|
|
if (pcmBytes > AUDIO_MAX_PCM_BYTES ||
|
|
(silent ? size != 0 : (size != pcmBytes || !data)))
|
|
return AudioResult::REJECTED;
|
|
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (m_playbackBlocked &&
|
|
(size != m_blockedPlaybackSize ||
|
|
!SamePacket(packet, m_blockedPlayback)))
|
|
{
|
|
DEBUG_WARN("Audio playback retry did not match retained packet");
|
|
ClearBlockedPlayback(false);
|
|
return AudioResult::REJECTED;
|
|
}
|
|
const bool retainedRetry = m_playbackBlocked;
|
|
if (!m_started)
|
|
{
|
|
ClearBlockedPlayback(false);
|
|
return AudioResult::UNAVAILABLE;
|
|
}
|
|
if (m_failed)
|
|
{
|
|
ClearBlockedPlayback(false);
|
|
return AudioResult::FAILED;
|
|
}
|
|
|
|
bool hasPlaybackSubscriber = false;
|
|
for (const Subscriber& subscriber : m_subscribers)
|
|
if (subscriber.responseAdmitted &&
|
|
subscriber.subscriptionReceived &&
|
|
PlaybackEligible(subscriber))
|
|
{
|
|
hasPlaybackSubscriber = true;
|
|
break;
|
|
}
|
|
if (!hasPlaybackSubscriber)
|
|
{
|
|
ClearBlockedPlayback(false);
|
|
return AudioResult::ACCEPTED;
|
|
}
|
|
|
|
if (!m_stateKnown)
|
|
{
|
|
if (!RememberBlockedPlayback(packet, size))
|
|
return AudioResult::REJECTED;
|
|
return AudioResult::BUSY;
|
|
}
|
|
if (!m_state.available || !m_state.active)
|
|
{
|
|
ClearBlockedPlayback(false);
|
|
return AudioResult::UNAVAILABLE;
|
|
}
|
|
if (packet.endpointGeneration != m_state.generation ||
|
|
packet.streamGeneration != m_state.playback.generation)
|
|
{
|
|
ClearBlockedPlayback(false);
|
|
return AudioResult::STALE;
|
|
}
|
|
if (!(m_state.capabilities & AUDIO_CAP_PLAYBACK) ||
|
|
!m_state.playback.formatValid ||
|
|
m_state.playback.state != AudioStreamState::RUNNING ||
|
|
!SameFormat(packet.format, m_state.playback.format))
|
|
{
|
|
ClearBlockedPlayback(false);
|
|
return AudioResult::UNAVAILABLE;
|
|
}
|
|
|
|
PumpState();
|
|
if (m_failed)
|
|
return AudioResult::FAILED;
|
|
if (!HasReadyPlayback())
|
|
{
|
|
if (!RememberBlockedPlayback(packet, size))
|
|
return AudioResult::REJECTED;
|
|
if (!m_inboundStopping && m_inboundWakeEvent)
|
|
SetEvent(m_inboundWakeEvent);
|
|
return AudioResult::BUSY;
|
|
}
|
|
|
|
if (m_feedbackAuthority != INVALID_SLOT)
|
|
{
|
|
Subscriber& authority = m_subscribers[m_feedbackAuthority];
|
|
if (authority.ready && PlaybackEligible(authority) &&
|
|
(authority.grantedCapabilities &
|
|
KVMFR_AUDIO_CAP_CLOCK_FEEDBACK))
|
|
{
|
|
LGMPSPMCReaderState reader = {};
|
|
const LGMP_STATUS query = lgmpHostSPMCReaderGetState(
|
|
m_playbackStream, authority.playbackReaderID, &reader);
|
|
if (query == LGMP_ERR_STREAM_BUSY)
|
|
{
|
|
if (!RememberBlockedPlayback(packet, size))
|
|
return AudioResult::REJECTED;
|
|
if (!m_inboundStopping && m_inboundWakeEvent)
|
|
SetEvent(m_inboundWakeEvent);
|
|
return AudioResult::BUSY;
|
|
}
|
|
bool stalled = false;
|
|
if (query == LGMP_OK)
|
|
{
|
|
if (reader.state != LGMP_SPMC_READER_READY ||
|
|
reader.clientID != authority.clientID ||
|
|
reader.epoch != authority.playbackReaderEpoch)
|
|
RevokeFeedbackAuthority("playback reader binding lost");
|
|
else
|
|
stalled = reader.producerSequence -
|
|
reader.consumerSequence >= KVMFR_AUDIO_STREAM_SLOT_COUNT;
|
|
}
|
|
else
|
|
{
|
|
Fail("lgmpHostSPMCReaderGetState(audio)", query);
|
|
return AudioResult::FAILED;
|
|
}
|
|
|
|
if (stalled && m_feedbackAuthority != INVALID_SLOT)
|
|
{
|
|
const uint64_t now = GetTickCount64();
|
|
if (!m_authorityBlockedSince)
|
|
m_authorityBlockedSince = now;
|
|
if (now - m_authorityBlockedSince >= AUTHORITY_STALL_MS)
|
|
RevokeFeedbackAuthority("playback reader stalled");
|
|
else
|
|
{
|
|
if (!RememberBlockedPlayback(packet, size))
|
|
return AudioResult::REJECTED;
|
|
if (!m_inboundStopping && m_inboundWakeEvent)
|
|
SetEvent(m_inboundWakeEvent);
|
|
return AudioResult::BUSY;
|
|
}
|
|
}
|
|
else
|
|
m_authorityBlockedSince = 0;
|
|
}
|
|
}
|
|
|
|
LGMPSPMCBuffer buffer = {};
|
|
LGMP_STATUS status = lgmpHostSPMCWriteAcquire(
|
|
m_playbackStream, &buffer);
|
|
if (status == LGMP_ERR_STREAM_BUSY)
|
|
{
|
|
if (!RememberBlockedPlayback(packet, size))
|
|
return AudioResult::REJECTED;
|
|
return AudioResult::BUSY;
|
|
}
|
|
if (status != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostSPMCWriteAcquire(audio)", status);
|
|
return AudioResult::FAILED;
|
|
}
|
|
|
|
const size_t required = sizeof(KVMFRAudioMessage) + size;
|
|
if (!buffer.data || buffer.capacity < required)
|
|
{
|
|
const LGMP_STATUS cancel =
|
|
lgmpHostSPMCWriteCancel(m_playbackStream, &buffer);
|
|
if (cancel != LGMP_OK)
|
|
DEBUG_WARN("Failed to cancel audio playback reservation: %s",
|
|
lgmpStatusString(cancel));
|
|
Fail("undersized playback audio slot", LGMP_ERR_INVALID_SIZE);
|
|
return AudioResult::FAILED;
|
|
}
|
|
|
|
KVMFRAudioMessageFlags flags = 0;
|
|
if (packet.flags & AUDIO_PACKET_DISCONTINUITY)
|
|
flags |= KVMFR_AUDIO_MESSAGE_DISCONTINUITY;
|
|
if (packet.flags & AUDIO_PACKET_SILENT)
|
|
flags |= KVMFR_AUDIO_MESSAGE_SILENT;
|
|
if (packet.flags & AUDIO_PACKET_CLOCK_VALID)
|
|
flags |= KVMFR_AUDIO_MESSAGE_CLOCK_VALID;
|
|
if (packet.flags & AUDIO_PACKET_CLOCK_STABLE)
|
|
flags |= KVMFR_AUDIO_MESSAGE_CLOCK_STABLE;
|
|
|
|
KVMFRAudioMessage message = {};
|
|
message.version = KVMFR_AUDIO_MESSAGE_VERSION;
|
|
message.size = sizeof(message);
|
|
message.type = KVMFR_AUDIO_MESSAGE_PLAYBACK_DATA;
|
|
message.streamGeneration = packet.streamGeneration;
|
|
message.flags = flags;
|
|
message.sequence = buffer.sequence;
|
|
message.position = packet.position;
|
|
message.timeNs = packet.timeNs;
|
|
message.rateQ32 = packet.rateQ32;
|
|
message.frames = packet.frames;
|
|
message.length = static_cast<uint32_t>(size);
|
|
WCWrite::Copy(buffer.data, &message, sizeof(message));
|
|
if (size)
|
|
WCWrite::Copy(static_cast<uint8_t *>(buffer.data) +
|
|
sizeof(message), data, size);
|
|
WCWrite::Flush();
|
|
|
|
status = lgmpHostSPMCWriteCommit(m_playbackStream, &buffer,
|
|
static_cast<uint32_t>(required));
|
|
if (status != LGMP_OK)
|
|
{
|
|
Fail("lgmpHostSPMCWriteCommit(audio)", status);
|
|
return AudioResult::FAILED;
|
|
}
|
|
|
|
ClearBlockedPlayback(false);
|
|
if (retainedRetry)
|
|
m_playbackReadyPending = false;
|
|
m_inboundActivitySerial = NextSerial(m_inboundActivitySerial);
|
|
return AudioResult::ACCEPTED;
|
|
}
|
|
|
|
void CLGMPAudio::CaptureReceiveReady()
|
|
{
|
|
CSRWExclusiveLock lock(m_lock);
|
|
if (m_started)
|
|
{
|
|
m_captureReadySerial = NextSerial(m_captureReadySerial);
|
|
if (!m_inboundStopping && m_inboundWakeEvent)
|
|
SetEvent(m_inboundWakeEvent);
|
|
}
|
|
}
|