Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2026-11-12 14:57:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[client/idd] network: discard stale audio after stalls

Browse Source 
Keep PCM and its clock sample in cancellable datagrams so recovery
cannot replay audio buffered before a Wi-Fi stall.

Drop blocked real-time packets with an explicit discontinuity and make
a newer reconnect supersede stale audio authorities.
This commit is contained in:
Geoffrey McRae
2026-10-08 22:51:47 +11:00
parent b1dda92f09
commit 0b0f227c08
11 changed files with 341 additions and 700 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
client/include/interface/audio.h
View File

@@ -116,10 +116,11 @@ typedef struct LG_AudioEventOps
uint8_t channels, const uint16_t volume[]);
void (*playbackMute)(void * opaque, uint32_t generation, bool mute);
/* Sample data is borrowed for the duration of the call. When supplied, the
* source clock position and time identify the first frame in this packet. */
* source clock position and time identify the first frame in this packet.
* Discontinuity remains valid when no source clock is available. */
void (*playbackData)(void * opaque, uint32_t generation,
const void * data, size_t frames,
const LG_AudioClock * sourceClock);
const LG_AudioClock * sourceClock, bool discontinuity);
/* May repeat with the same generation to update an active stream format. */
void (*recordStart)(void * opaque, uint32_t generation,

20
client/src/audio.c
View File

@@ -2294,7 +2294,8 @@ static void playbackResetRateControl(PlaybackSourceData * sourceData,
}
static PlaybackDataResult playbackData(const void * data, size_t frameCount,
const LG_AudioClock * sourceClock, int64_t arrivalTime)
const LG_AudioClock * sourceClock, bool streamDiscontinuity,
int64_t arrivalTime)
{
StreamState state = playbackGetState();
if (state == STREAM_STATE_STOP_PENDING)
@@ -2363,8 +2364,9 @@ static PlaybackDataResult playbackData(const void * data, size_t frameCount,
const bool bufferUnderrun =
STREAM_ACTIVE(playbackGetState()) &&
ringbuffer_getCount(audio.playback.buffer) < 0;
bool discontinuity =
bufferUnderrun || (sourceClock && sourceClock->discontinuity);
bool discontinuity = bufferUnderrun ||
streamDiscontinuity ||
(sourceClock && sourceClock->discontinuity);
const int64_t previousArrivalTime = sourceData->lastArrivalTime;
const int64_t packetTime =
playbackMapMediaTime(sourceData, sourceClock, frames,
@@ -4039,11 +4041,12 @@ static void eventPlaybackMute(void * opaque, uint32_t generation, bool mute)
}
static void eventPlaybackData(void * opaque, uint32_t generation,
const void * data, size_t frames, const LG_AudioClock * sourceClock)
const void * data, size_t frames, const LG_AudioClock * sourceClock,
bool discontinuity)
{
const int64_t arrivalTime = nanotime();
AudioBinding * binding = opaque;
AudioBinding active;
const int64_t arrivalTime = nanotime();
AudioBinding * binding = opaque;
AudioBinding active;
if (!eventBegin(binding, &active))
return;
@@ -4057,7 +4060,8 @@ static void eventPlaybackData(void * opaque, uint32_t generation,
PlaybackDataResult result = PLAYBACK_DATA_DROP;
if (liveGeneration == generation)
{
result = playbackData(data, frames, sourceClock, arrivalTime);
result = playbackData(
data, frames, sourceClock, discontinuity, arrivalTime);
if (result == PLAYBACK_DATA_PROCESSED &&
atomic_load_explicit(&audio.playback.streamGeneration,

20
client/tests/audio_test.c
View File

@@ -593,7 +593,7 @@ static void testPlaybackRetry(void)
atomic_store(&b.setupOK, true);
uint8_t frames[480 * 2 * 2] = { 0 };
usleep(10000);
p.events->playbackData(p.eventOpaque, 11, frames, 480, NULL);
p.events->playbackData(p.eventOpaque, 11, frames, 480, NULL, false);
waitFor(&b.setupN, failed + 1);
for (unsigned int i = 0; i < WAIT_MS; ++i)
@@ -605,7 +605,7 @@ static void testPlaybackRetry(void)
}
CHECK(atomic_load(&audio.playback.streamGeneration) == 11);
for (unsigned int i = 0; i < 8; ++i)
p.events->playbackData(p.eventOpaque, 11, frames, 480, NULL);
p.events->playbackData(p.eventOpaque, 11, frames, 480, NULL, false);
waitFor(&b.playStartN, 1);
LG_AudioFailureFn fail = b.playFail;
@@ -617,7 +617,7 @@ static void testPlaybackRetry(void)
const unsigned int retry = atomic_load(&b.setupN);
usleep(10000);
p.events->playbackData(p.eventOpaque, 11, frames, 480, NULL);
p.events->playbackData(p.eventOpaque, 11, frames, 480, NULL, false);
waitFor(&b.setupN, retry + 1);
p.events->playbackStop(p.eventOpaque, 11);
@@ -679,7 +679,7 @@ static void testPlaybackRecovery(void)
CHECK(ringbuffer_consume(audio.playback.buffer, NULL, 16) == 16);
CHECK(ringbuffer_getCount(audio.playback.buffer) == -16);
uint8_t frames[1200 * 2 * 2] = { 0 };
CHECK(playbackData(frames, 1200, NULL, arrival) ==
CHECK(playbackData(frames, 1200, NULL, false, arrival) ==
PLAYBACK_DATA_PROCESSED);
CHECK(source->sourcePacketDurationSec < 0.010);
@@ -690,12 +690,12 @@ static void testPlaybackRecovery(void)
CHECK(fabs(atomic_load(&audio.playback.backendResampleRatio) -
source->lastClockRatio) < 0.000001);
CHECK(playbackData(frames, 1200, NULL, arrival + 1000) ==
CHECK(playbackData(frames, 1200, NULL, false, arrival + 1000) ==
PLAYBACK_DATA_PROCESSED);
CHECK(source->sourcePacketDurationSec < 0.010);
CHECK(source->sourcePacketRecovering);
CHECK(playbackData(frames, 480, NULL,
CHECK(playbackData(frames, 480, NULL, false,
arrival + INT64_C(10000000)) == PLAYBACK_DATA_PROCESSED);
CHECK(!source->sourcePacketRecovering);
CHECK(fabs(source->sourcePacketDurationSec - 0.010) < 0.000001);
@@ -733,7 +733,7 @@ static void testPlaybackStableUnderrun(void)
uint8_t frames[64 * 2 * 2];
uint8_t output[64 * 2 * 2];
memset(frames, 0x5a, sizeof(frames));
CHECK(playbackData(frames, 64, NULL, arrival) ==
CHECK(playbackData(frames, 64, NULL, false, arrival) ==
PLAYBACK_DATA_PROCESSED);
const int recoveredOccupancy =
@@ -765,7 +765,7 @@ static void testPlaybackStableUnderrun(void)
source->devicePositionOffsetFrames;
const int64_t secondPacketArrival = arrival +
llrint(64.0e9 / format.sampleRate);
CHECK(playbackData(frames, 64, NULL,
CHECK(playbackData(frames, 64, NULL, false,
secondPacketArrival) == PLAYBACK_DATA_PROCESSED);
CHECK(source->devicePositionOffsetFrames == recoveredOffset);
CHECK(ringbuffer_getCount(audio.playback.buffer) ==
@@ -852,7 +852,7 @@ static void testPlaybackResume(void)
CHECK(atomic_load(&b.setupN) == setupN);
uint8_t input[480 * 2 * 2] = { 0 };
p.events->playbackData(p.eventOpaque, 12, input, 480, NULL);
p.events->playbackData(p.eventOpaque, 12, input, 480, NULL, false);
CHECK(atomic_load(&audio.playback.streamGeneration) == 12);
CHECK(playbackGetState() == STREAM_STATE_RUN);
CHECK(atomic_load(&audio.playback.underruns) == 0);
@@ -883,7 +883,7 @@ static void testPlaybackResume(void)
p.events->playbackStart(p.eventOpaque, 13, &format, NULL);
CHECK(atomic_load(&audio.playback.streamGeneration) == 13);
p.events->playbackData(p.eventOpaque, 13, input, 480, NULL);
p.events->playbackData(p.eventOpaque, 13, input, 480, NULL, false);
CHECK(playbackGetState() == STREAM_STATE_RUN);
CHECK(source->deviceClock.time == arrival);
CHECK(source->deviceClock.position == idleFrames);

16
client/tests/lgmp_audio_test.c
View File

@@ -150,21 +150,23 @@ static unsigned audioSampleBytes(LG_AudioSampleFormat format)
}
static void playbackData(void * opaque, uint32_t generation,
const void * data, size_t frames, const LG_AudioClock * clock)
const void * data, size_t frames, const LG_AudioClock * clock,
bool discontinuity)
{
struct Trace * trace = opaque;
(void)discontinuity;
pthread_mutex_lock(&trace->mutex);
trace->playGeneration = generation;
trace->playFrames = frames;
const size_t bytes = frames * trace->playFormat.channelCount *
trace->playGeneration = generation;
trace->playFrames = frames;
const size_t bytes = frames * trace->playFormat.channelCount *
audioSampleBytes(trace->playFormat.sampleFormat);
const size_t copy = bytes < sizeof(trace->playData) ?
const size_t copy = bytes < sizeof(trace->playData) ?
bytes : sizeof(trace->playData);
memset(trace->playData, 0, sizeof(trace->playData));
memcpy(trace->playData, data, copy);
trace->playClockValid = clock != NULL;
trace->playClockValid = clock != NULL;
if (clock)
trace->playClock = *clock;
trace->playClock = *clock;
pthread_mutex_unlock(&trace->mutex);
traceEvent(trace, TRACE_PLAY_DATA, generation);
atomic_fetch_add_explicit(&trace->playDataCount, 1,

16
client/transports/LGMP/audio.c
View File

@@ -1486,13 +1486,15 @@ static void dispatchPlaybackData(LGMPAudio * audio,
return;
}
const uint32_t generation = audio->playback.generation.local;
const LG_AudioEventOps * events =
const uint32_t generation =
audio->playback.generation.local;
const LG_AudioEventOps * events =
audio->attached ? audio->events : NULL;
void * opaque = audio->eventOpaque;
const bool discontinuity = sequenceGap ||
audio->playbackDiscontinuity;
const bool clockValid =
void * opaque = audio->eventOpaque;
const bool discontinuity = sequenceGap ||
audio->playbackDiscontinuity ||
(message->flags & KVMFR_AUDIO_MESSAGE_DISCONTINUITY) != 0;
const bool clockValid =
(message->flags & KVMFR_AUDIO_MESSAGE_CLOCK_VALID) != 0;
if (!events || !events->playbackData)
audio->playbackDiscontinuity = true;
@@ -1506,7 +1508,7 @@ static void dispatchPlaybackData(LGMPAudio * audio,
clockFromMessage(message, discontinuity);
events->playbackData(opaque, generation,
silent ? l_silence : payload, message->frames,
clockValid ? &clock : NULL);
clockValid ? &clock : NULL, discontinuity);
}
LG_UNLOCK(audio->eventLock);
}

250
client/transports/Network/audio.c
View File

@@ -46,7 +46,6 @@
#define NETWORK_AUDIO_CHANNEL_MASK UINT32_C(0x0003FFFF)
#define NETWORK_AUDIO_PLAYBACK_STREAM_ID 1U
#define NETWORK_AUDIO_CAPTURE_STREAM_ID 2U
#define NETWORK_AUDIO_CLOCK_CACHE_SIZE 16U
#define NETWORK_AUDIO_DATAGRAM_PAYLOAD 1136U
#define NETWORK_AUDIO_DATAGRAM_PCM_BYTES \
(NETWORK_AUDIO_DATAGRAM_PAYLOAD - LG_NET_AUDIO_DATA_HEADER_WIRE_SIZE)
@@ -55,8 +54,7 @@
(LG_NET_AUDIO_SUBSCRIBE_LOW_LATENCY | \
LG_NET_AUDIO_SUBSCRIBE_EXCLUSIVE_CAPTURE | \
LG_NET_AUDIO_SUBSCRIBE_CLOCK_FEEDBACK | \
LG_NET_AUDIO_SUBSCRIBE_DATAGRAM_PCM | \
LG_NET_AUDIO_SUBSCRIBE_RELIABLE_PCM)
LG_NET_AUDIO_SUBSCRIBE_DATAGRAM_PCM)
#define NETWORK_AUDIO_DIRECTIONS \
(LG_NET_AUDIO_DIRECTIONS_PLAYBACK | LG_NET_AUDIO_DIRECTIONS_CAPTURE)
@@ -76,12 +74,6 @@ enum NetworkAudioPhase
NETWORK_AUDIO_RELEASING,
};
struct NetworkAudioClockEntry
{
bool valid;
LGNetAudioClockState state;
};
struct NetworkAudioStream
{
uint32_t streamID;
@@ -110,8 +102,6 @@ struct NetworkAudioStream
bool packetKnown;
uint64_t lastPacketID;
bool discontinuity;
unsigned clockInsert;
struct NetworkAudioClockEntry clocks[NETWORK_AUDIO_CLOCK_CACHE_SIZE];
};
struct NetworkAudio
@@ -463,12 +453,6 @@ static void networkAudioEndEvents(NetworkAudio * audio)
LG_UNLOCK(audio->eventLock);
}
static void networkAudioClearClockNL(struct NetworkAudioStream * stream)
{
stream->clockInsert = 0;
memset(stream->clocks, 0, sizeof(stream->clocks));
}
static void networkAudioClearStreamNL(struct NetworkAudioStream * stream)
{
const uint32_t streamID = stream->streamID;
@@ -601,7 +585,7 @@ static LG_TransportStatus networkAudioSendDatagramNL(NetworkAudio * audio,
{
return networkConnectionSendDatagram(audio->connection,
LG_NET_SERVICE_AUDIO, messageType, audio->serviceVersion, 0,
audio->subscriptionEpoch, requestID, payload, payloadLength, 0, false);
audio->subscriptionEpoch, requestID, payload, payloadLength, 0, true);
}
static bool networkAudioSendSubscribeNL(NetworkAudio * audio)
@@ -962,21 +946,12 @@ static void networkAudioDetach(void * opaque)
LG_UNLOCK(audio->eventLock);
}
static bool networkAudioSendClockAndDataNL(NetworkAudio * audio,
const uint8_t * clockPayload, const uint8_t * dataPayload,
uint32_t dataPayloadLength)
static LG_TransportStatus networkAudioSendPCMNL(NetworkAudio * audio,
uint16_t messageType, const void * payload, uint32_t payloadLength)
{
/* CLOCK_STATE and PCM are an ordered pair. Keep both on the same reliable
* stream until a future protocol version provides atomic datagram framing. */
if (!(audio->grantedRoles & LG_NET_AUDIO_ROLE_RELIABLE_PCM))
return false;
return networkAudioSendReliableNL(audio,
LG_NET_AUDIO_MESSAGE_CLOCK_STATE, 0, 0, clockPayload,
LG_NET_AUDIO_CLOCK_STATE_WIRE_SIZE) == LG_TRANSPORT_OK &&
networkAudioSendReliableNL(audio,
LG_NET_AUDIO_MESSAGE_CAPTURE_DATA, 0, 0, dataPayload,
dataPayloadLength) == LG_TRANSPORT_OK;
return (audio->grantedRoles & LG_NET_AUDIO_ROLE_DATAGRAM_PCM) ?
networkAudioSendDatagramNL(audio, messageType, 0,
payload, payloadLength) : LG_TRANSPORT_UNAVAILABLE;
}
static bool networkAudioRecordData(void * opaque, uint32_t generation,
@@ -986,10 +961,9 @@ static bool networkAudioRecordData(void * opaque, uint32_t generation,
if (!generation || !data || !frames)
return false;
uint64_t rateQ32 = 0;
if (sourceClock &&
!networkAudioRateQ32(sourceClock->rate, true, &rateQ32))
return false;
uint64_t rateQ32 = 0;
const bool sourceClockValid = sourceClock && sourceClock->time > 0 &&
networkAudioRateQ32(sourceClock->rate, false, &rateQ32);
LG_LOCK(audio->stateLock);
struct NetworkAudioStream * stream = &audio->capture;
@@ -1044,11 +1018,11 @@ static bool networkAudioRecordData(void * opaque, uint32_t generation,
return false;
}
bool result = true;
bool discontinuity = stream->discontinuity ||
bool result = true;
bool discontinuity = stream->discontinuity ||
(sourceClock && sourceClock->discontinuity);
size_t offset = 0;
const uint8_t * pcm = data;
size_t offset = 0;
const uint8_t * pcm = data;
while (offset < frames)
{
size_t chunkFrames = frames - offset;
@@ -1058,10 +1032,11 @@ static bool networkAudioRecordData(void * opaque, uint32_t generation,
audio->capturePacketID = networkAudioNext64(audio->capturePacketID);
const uint64_t packetID = audio->capturePacketID;
uint64_t position = firstPosition + offset;
int64_t timeNs = sourceClock ? sourceClock->time : 0;
if (sourceClock && offset)
const uint64_t packetID = audio->capturePacketID;
const uint64_t position = firstPosition + offset;
int64_t timeNs = sourceClockValid ? sourceClock->time : 0;
bool clockValid = sourceClockValid;
if (clockValid && offset)
{
const long double elapsed =
(long double)offset * 1000000000.0L /
@@ -1070,29 +1045,13 @@ static bool networkAudioRecordData(void * opaque, uint32_t generation,
if (adjusted >= (long double)INT64_MIN &&
adjusted <= (long double)INT64_MAX)
timeNs = (int64_t)adjusted;
else
{
clockValid = false;
timeNs = 0;
}
}
uint64_t timestampNs = timeNs > 0 ? (uint64_t)timeNs : nanotime();
if (!timestampNs)
timestampNs = 1;
const LGNetAudioClockState clock =
{
.streamID = stream->streamID,
.direction = stream->direction,
.flags = sourceClock ?
LG_NET_AUDIO_CLOCK_VALID |
(sourceClock->stable ? LG_NET_AUDIO_CLOCK_STABLE : 0) : 0,
.formatEpoch = stream->wireFormat.formatEpoch,
.subscriptionEpoch = audio->subscriptionEpoch,
.packetID = packetID,
.framePosition = position,
.timeNs = timeNs,
.rateQ32 = rateQ32,
.targetRateQ32 = 0,
.queuedFrames = 0,
.driftPpm = 0,
};
const LGNetAudioData packet =
LGNetAudioData packet =
{
.streamID = stream->streamID,
.direction = stream->direction,
@@ -1100,31 +1059,50 @@ static bool networkAudioRecordData(void * opaque, uint32_t generation,
LG_NET_AUDIO_DATA_DISCONTINUITY : 0,
.formatEpoch = stream->wireFormat.formatEpoch,
.packetID = packetID,
.timestampNs = timestampNs,
.timestampNs = timeNs > 0 ? (uint64_t)timeNs : 0,
.startFrame = position,
.rateQ32 = clockValid ? rateQ32 : 0,
.frameCount = (uint32_t)chunkFrames,
.dataLength = (uint32_t)chunkBytes,
.data = pcm + offset * frameSize,
};
uint8_t clockPayload[LG_NET_AUDIO_CLOCK_STATE_WIRE_SIZE];
if (clockValid)
{
packet.flags |= LG_NET_AUDIO_DATA_CLOCK_VALID;
if (sourceClock->stable)
packet.flags |= LG_NET_AUDIO_DATA_CLOCK_STABLE;
}
const size_t dataPayloadLength =
LG_NET_AUDIO_DATA_HEADER_WIRE_SIZE + chunkBytes;
if (!lgNetAudioClockStateEncode(clockPayload,
sizeof(clockPayload), &clock) ||
!lgNetAudioDataEncode(payload, dataPayloadLength, &packet) ||
!networkAudioSendClockAndDataNL(audio, clockPayload, payload,
(uint32_t)dataPayloadLength))
if (!lgNetAudioDataEncode(payload, dataPayloadLength, &packet))
{
result = false;
break;
}
discontinuity = false;
const LG_TransportStatus status = networkAudioSendPCMNL(
audio, LG_NET_AUDIO_MESSAGE_CAPTURE_DATA,
payload, (uint32_t)dataPayloadLength);
if (status != LG_TRANSPORT_OK)
{
if (status == LG_TRANSPORT_UNAVAILABLE)
{
discontinuity = true;
offset += chunkFrames;
continue;
}
result = false;
break;
}
discontinuity = false;
offset += chunkFrames;
}
audio->captureFramePosition = firstPosition + offset;
stream->discontinuity = !result;
stream->discontinuity = discontinuity || !result;
free(payload);
LG_UNLOCK(audio->stateLock);
return result;
@@ -1173,16 +1151,12 @@ static bool networkAudioClockFeedback(void * opaque, uint32_t generation,
const bool encoded = lgNetAudioClockStateEncode(
payload, sizeof(payload), &feedback);
bool result = false;
if (encoded &&
(audio->grantedRoles & LG_NET_AUDIO_ROLE_DATAGRAM_PCM))
result = networkAudioSendDatagramNL(audio,
LG_NET_AUDIO_MESSAGE_CLOCK_STATE, 0,
payload, sizeof(payload)) == LG_TRANSPORT_OK;
if (encoded && !result &&
(audio->grantedRoles & LG_NET_AUDIO_ROLE_RELIABLE_PCM))
result = networkAudioSendReliableNL(audio,
LG_NET_AUDIO_MESSAGE_CLOCK_STATE, 0, 0,
payload, sizeof(payload)) == LG_TRANSPORT_OK;
if (encoded)
{
const LG_TransportStatus status = networkAudioSendDatagramNL(audio,
LG_NET_AUDIO_MESSAGE_CLOCK_STATE, 0, payload, sizeof(payload));
result = status == LG_TRANSPORT_OK;
}
LG_UNLOCK(audio->stateLock);
return result;
}
@@ -1322,8 +1296,8 @@ static bool networkAudioHandleGrant(NetworkAudio * audio,
if (!grant.maxPacketFrames ||
(grant.grantedRoles & ~audio->requestedRoles) ||
grant.maxPacketFrames > NETWORK_AUDIO_MAX_PACKET_FRAMES ||
(grant.grantedRoles & LG_NET_AUDIO_ROLE_DATAGRAM_PCM &&
!datagramAvailable) ||
!(grant.grantedRoles & LG_NET_AUDIO_ROLE_DATAGRAM_PCM) ||
!datagramAvailable ||
(grant.grantedRoles & LG_NET_AUDIO_ROLE_CAPTURE &&
!(grant.grantedRoles & LG_NET_AUDIO_ROLE_EXCLUSIVE_CAPTURE)) ||
(grant.grantedRoles & LG_NET_AUDIO_ROLE_CLOCK_FEEDBACK &&
@@ -1430,7 +1404,6 @@ static bool networkAudioHandleStart(NetworkAudio * audio,
stream->packetKnown = false;
stream->lastPacketID = 0;
stream->discontinuity = true;
networkAudioClearClockNL(stream);
networkAudioInvalidateBarrierNL(audio, stream);
const LG_AudioEventOps * events =
audio->attached ? audio->events : NULL;
@@ -1504,7 +1477,6 @@ static bool networkAudioHandleStop(NetworkAudio * audio,
stream->volumeValid = false;
stream->muteValid = false;
stream->discontinuity = true;
networkAudioClearClockNL(stream);
networkAudioInvalidateBarrierNL(audio, stream);
LG_UNLOCK(audio->stateLock);
networkAudioCallEventsNL(audio);
@@ -1774,7 +1746,6 @@ static bool networkAudioHandleStatus(NetworkAudio * audio,
stream->volumeValid = false;
stream->muteValid = false;
stream->discontinuity = true;
networkAudioClearClockNL(stream);
}
stream->stateSequence = state.stateSequence;
networkAudioInvalidateBarrierNL(audio, stream);
@@ -1861,62 +1832,6 @@ static bool networkAudioHandleBarrier(NetworkAudio * audio,
return true;
}
static struct NetworkAudioClockEntry * networkAudioFindClockNL(
struct NetworkAudioStream * stream, uint64_t packetID)
{
for (unsigned i = 0; i < NETWORK_AUDIO_CLOCK_CACHE_SIZE; ++i)
if (stream->clocks[i].valid &&
stream->clocks[i].state.packetID == packetID)
return &stream->clocks[i];
return NULL;
}
static bool networkAudioHandleClock(NetworkAudio * audio,
const LGNetPacketView * packet)
{
LGNetAudioClockState state;
if (lgNetAudioClockStateDecode(&state,
packet->payload, packet->payloadLength) != LG_NET_PARSE_OK)
return false;
LG_LOCK(audio->stateLock);
struct NetworkAudioStream * stream = networkAudioStreamNL(
audio, state.streamID, state.direction);
if (!stream || stream != &audio->playback)
{
LG_UNLOCK(audio->stateLock);
return false;
}
if (!networkAudioSubscriptionCurrentNL(audio, packet) ||
!networkAudioStreamRequiredNL(audio, stream) ||
state.subscriptionEpoch != audio->subscriptionEpoch)
{
LG_UNLOCK(audio->stateLock);
return true;
}
if (!stream->active || !stream->formatValid ||
state.formatEpoch != stream->wireFormat.formatEpoch ||
(stream->packetKnown && state.packetID <= stream->lastPacketID))
{
LG_UNLOCK(audio->stateLock);
return true;
}
struct NetworkAudioClockEntry * entry = networkAudioFindClockNL(
stream, state.packetID);
if (!entry)
{
entry = &stream->clocks[
stream->clockInsert++ % NETWORK_AUDIO_CLOCK_CACHE_SIZE];
if (entry->valid)
stream->discontinuity = true;
}
entry->valid = true;
entry->state = state;
LG_UNLOCK(audio->stateLock);
return true;
}
static bool networkAudioHandlePlaybackData(NetworkAudio * audio,
const LGNetPacketView * packet)
{
@@ -1971,32 +1886,23 @@ static bool networkAudioHandlePlaybackData(NetworkAudio * audio,
return true;
}
struct NetworkAudioClockEntry * entry = networkAudioFindClockNL(
stream, data.packetID);
LG_AudioClock clock;
const LG_AudioClock * clockPtr = NULL;
if (entry && (entry->state.flags & LG_NET_AUDIO_CLOCK_VALID))
const bool discontinuity = stream->discontinuity || sequenceGap ||
(data.flags & LG_NET_AUDIO_DATA_DISCONTINUITY) != 0;
LG_AudioClock clock;
const LG_AudioClock * clockPtr = NULL;
if (data.flags & LG_NET_AUDIO_DATA_CLOCK_VALID)
{
clock = (LG_AudioClock)
{
.position = entry->state.framePosition,
.time = entry->state.timeNs,
.rate = networkAudioRate(entry->state.rateQ32),
.position = data.startFrame,
.time = (int64_t)data.timestampNs,
.rate = networkAudioRate(data.rateQ32),
.stable =
(entry->state.flags & LG_NET_AUDIO_CLOCK_STABLE) != 0,
.discontinuity = stream->discontinuity || sequenceGap ||
(data.flags & LG_NET_AUDIO_DATA_DISCONTINUITY),
(data.flags & LG_NET_AUDIO_DATA_CLOCK_STABLE) != 0,
.discontinuity = discontinuity,
};
clockPtr = &clock;
stream->discontinuity = false;
clockPtr = &clock;
}
else
stream->discontinuity = true;
if (entry)
entry->valid = false;
if (data.flags & LG_NET_AUDIO_DATA_END_OF_STREAM)
stream->discontinuity = true;
const size_t frameSize = (size_t)networkAudioSampleSize(
stream->wireFormat.sampleFormat) * stream->wireFormat.channels;
const size_t bytes = frameSize * data.frameCount;
@@ -2013,11 +1919,13 @@ static bool networkAudioHandlePlaybackData(NetworkAudio * audio,
const LG_AudioEventOps * events =
audio->attached ? audio->events : NULL;
void * opaque = audio->eventOpaque;
stream->discontinuity = !events || !events->playbackData ||
(data.flags & LG_NET_AUDIO_DATA_END_OF_STREAM) != 0;
LG_UNLOCK(audio->stateLock);
networkAudioCallEventsNL(audio);
if (events && events->playbackData)
events->playbackData(opaque, generation, pcm,
data.frameCount, clockPtr);
data.frameCount, clockPtr, discontinuity);
networkAudioEndEvents(audio);
return true;
}
@@ -2078,7 +1986,7 @@ static bool networkAudioHandlePacket(NetworkAudio * audio,
audio, packet, &audio->playback);
case LG_NET_AUDIO_MESSAGE_PLAYBACK_DATA:
return networkAudioHandlePlaybackData(audio, packet);
return datagram && networkAudioHandlePlaybackData(audio, packet);
case LG_NET_AUDIO_MESSAGE_PLAYBACK_VOLUME:
return !datagram && networkAudioHandleVolume(
@@ -2107,9 +2015,6 @@ static bool networkAudioHandlePacket(NetworkAudio * audio,
case LG_NET_AUDIO_MESSAGE_STATE_BARRIER:
return !datagram && networkAudioHandleBarrier(audio, packet);
case LG_NET_AUDIO_MESSAGE_CLOCK_STATE:
return networkAudioHandleClock(audio, packet);
default:
return false;
}
@@ -2149,7 +2054,6 @@ bool networkAudioCreate(NetworkAudio ** result,
LG_NET_AUDIO_ROLE_CAPTURE |
LG_NET_AUDIO_ROLE_CLOCK_FEEDBACK |
LG_NET_AUDIO_ROLE_DATAGRAM_PCM |
LG_NET_AUDIO_ROLE_RELIABLE_PCM |
LG_NET_AUDIO_ROLE_EXCLUSIVE_CAPTURE;
audio->endpointGeneration = 1;
audio->generationSerial = 1;
@@ -2191,6 +2095,8 @@ void networkAudioConnectionState(NetworkAudio * audio, bool connected)
const bool serviceAvailable = connected &&
networkConnectionServiceAvailable(audio->connection,
LG_NET_SERVICE_AUDIO, LG_NET_CAPABILITY_RELIABLE) &&
networkConnectionServiceAvailable(audio->connection,
LG_NET_SERVICE_AUDIO, LG_NET_CAPABILITY_DATAGRAM) &&
networkConnectionServiceVersion(audio->connection,
LG_NET_SERVICE_AUDIO, &serviceVersion) &&
networkAudioVersionSupported(serviceVersion);

2
client/transports/SPICE/audio.c
View File

@@ -845,7 +845,7 @@ void spiceAudio_playbackData(SpiceAudio * audio,
if (target.events->playbackData &&
playbackEventCurrent(audio, &target, generation, true))
target.events->playbackData(target.opaque, generation,
data, frames, &clock);
data, frames, &clock, false);
endEvent(audio);
}

2
client/transports/SPICE/audio_usb.c
View File

@@ -592,7 +592,7 @@ static void usbPlaybackData(
{
const LG_AudioClock clock = makePlaybackClock(state, position);
events->playbackData(
target, generation, data, frames, &clock);
target, generation, data, frames, &clock, false);
}
}
endCallback(&frame, &l_playbackFrames,

701
idd/LGIdd/transport/network/CNetworkAudio.cpp
View File

File diff suppressed because it is too large Load Diff

7
idd/LGIdd/transport/network/CNetworkServer.cpp
View File

@@ -4747,13 +4747,18 @@ retry:
HandshakeState handshake;
uint64_t sessionEpoch;
uint32_t maxPayload;
bool closing;
{
CSRWSharedLock guard(connection.lock);
handshake = connection.handshake;
sessionEpoch = connection.sessionEpoch;
maxPayload = connection.maxPayload;
closing = connection.closing;
}
if (closing)
return true;
if (handshake == HandshakeState::WAITING_HELLO)
return packet.envelope.service == LG_NET_SERVICE_CORE &&
packet.envelope.messageType == LG_NET_CORE_MESSAGE_HELLO &&
@@ -5188,6 +5193,8 @@ retry:
const uint16_t serviceMask = UINT16_C(1) << packet.envelope.service;
{
CSRWExclusiveLock guard(connection.lock);
if (connection.closing)
return true;
const bool serviceReady = packet.envelope.service ==
LG_NET_SERVICE_CORE ||
((connection.selectedServices & serviceMask) &&

2
repos/LGProtocol

Submodule repos/LGProtocol updated: 189c9bc5b6...a4a7519f47