From 6be8649b544fded7b5d3ceebef8cf10e44b16666 Mon Sep 17 00:00:00 2001 From: Chrizz Gelbach Date: Mon, 19 Oct 2026 21:42:36 +0200 Subject: [PATCH 1/2] Recover faster from stalled remote streams - Lower the request timeout from 60 s to 15 s so a dead connection is detected while the buffer still plays. - Reopen a stream that has not received data for 2 s when the network path changes (new cell, interface or address), instead of waiting for the timeout. - Retry when the initial range request fails without a response; previously the stream never opened. --- .../Audio Source/RemoteAudioSource.swift | 45 ++++++++++++++++++- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift b/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift index 522a6c2..5e6ea8e 100644 --- a/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift +++ b/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift @@ -13,6 +13,12 @@ enum RemoteAudioSourceError: Error { } public class RemoteAudioSource: AudioStreamSource { + /// Time without any received data after which a request fails and is retried. + /// Short enough to detect a dead connection (e.g. after a cell handover) while the buffer still plays. + static let requestTimeoutInterval: TimeInterval = 15 + /// A stream that has not received data for this long is reopened when the network path changes. + static let stallIntervalForPathChange: TimeInterval = 2 + public weak var delegate: AudioStreamSourceDelegate? public var position: Int { @@ -57,6 +63,10 @@ public class RemoteAudioSource: AudioStreamSource { var waitingForNetwork = false let retrierTimeout: Retrier + private let receiveStateLock = UnfairLock() + /// The time data was last received; `nil` while no stream request is open + private var lastDataReceivedAt: DispatchTime? + init(networking: NetworkingClient, metadataStreamSource: MetadataStreamSource, icycastHeadersProcessor: IcycastHeadersProcessor, @@ -138,6 +148,7 @@ public class RemoteAudioSource: AudioStreamSource { } public func close() { + setLastDataReceived(nil) retrierTimeout.cancel() streamOperationQueue.isSuspended = false streamOperationQueue.cancelAllOperations() @@ -184,10 +195,28 @@ public class RemoteAudioSource: AudioStreamSource { if self.waitingForNetwork { self.seek(at: self.supportsSeek ? self.position : 0) self.waitingForNetwork = false + } else if self.supportsSeek, self.isStreamStalled { + // The path changed (new cell, interface or address) while no data arrived: + // the open connection is most likely dead, so reopen it instead of waiting for the timeout + self.seek(at: self.position) } } } + private var isStreamStalled: Bool { + receiveStateLock.withLock { () -> Bool in + guard let lastDataReceivedAt else { return false } + let elapsed = DispatchTime.now().uptimeNanoseconds - lastDataReceivedAt.uptimeNanoseconds + return Double(elapsed) / Double(NSEC_PER_SEC) >= Self.stallIntervalForPathChange + } + } + + private func setLastDataReceived(_ time: DispatchTime?) { + receiveStateLock.withLock { + lastDataReceivedAt = time + } + } + private func performOpen(seek seekOffset: Int) { if seekOffset == 0 { initialRequest { [weak self] in @@ -210,6 +239,7 @@ public class RemoteAudioSource: AudioStreamSource { private func doPerfomOpen(seek seekOffset: Int) { let urlRequest = buildUrlRequest(with: url, seekIfNeeded: seekOffset) + setLastDataReceived(.now()) streamRequest = networkingClient.stream(request: urlRequest) .responseStream { [weak self] event in guard let self = self else { return } @@ -229,6 +259,11 @@ public class RemoteAudioSource: AudioStreamSource { self?.parseResponseHeader(response: urlResponse) task.cancel() completion() + case let .stream(.failure(error)): + // No response (e.g. a timeout without network): retry, otherwise the stream never opens. + // The cancellation above after a response also ends up here and is ignored. + guard (error as? URLError)?.code != .cancelled else { return } + self?.handleFailedStreamEvent(error: error) default: break } @@ -258,6 +293,12 @@ public class RemoteAudioSource: AudioStreamSource { // MARK: - Network Handle Methods private func handleResponse(event: NetworkDataStream.ResponseEvent) { + switch event { + case .response, .stream(.success): + setLastDataReceived(.now()) + case .stream(.failure), .complete: + setLastDataReceived(nil) + } switch event { case let .response(urlResponse): parseResponseHeader(response: urlResponse) @@ -369,7 +410,7 @@ public class RemoteAudioSource: AudioStreamSource { var urlRequest = URLRequest(url: url) urlRequest.networkServiceType = .avStreaming urlRequest.cachePolicy = .reloadIgnoringLocalCacheData - urlRequest.timeoutInterval = 60 + urlRequest.timeoutInterval = Self.requestTimeoutInterval urlRequest.httpMethod = httpMethod urlRequest.httpBody = httpBody @@ -390,7 +431,7 @@ public class RemoteAudioSource: AudioStreamSource { var urlRequest = URLRequest(url: url) urlRequest.networkServiceType = .avStreaming urlRequest.cachePolicy = .reloadIgnoringLocalCacheData - urlRequest.timeoutInterval = 60 + urlRequest.timeoutInterval = Self.requestTimeoutInterval urlRequest.httpMethod = httpMethod urlRequest.httpBody = httpBody From cad05325fa9c67e054f64d5eb627410a6640e8da Mon Sep 17 00:00:00 2001 From: Chrizz Gelbach Date: Mon, 19 Oct 2026 21:56:08 +0200 Subject: [PATCH 2/2] Resume streams without range support at the read position Without range support a reopened stream starts at byte 0 again, so a retry after a network failure fed the start of the file to the parser in the middle of playback. Now the bytes the player has already read are dropped from the reopened stream. The first 4 KB of the stream are kept to check that the server delivers the same content; if it differs (e.g. a live stream), the new stream plays from its start as before. Streams with ICY metadata or a restructured MP4 keep the old behaviour. A stalled stream is now also reopened on a network path change when the server does not support ranges. --- .../Audio Source/RemoteAudioSource.swift | 83 +++++++++- .../RemoteAudioSourceResumeTests.swift | 156 ++++++++++++++++++ 2 files changed, 232 insertions(+), 7 deletions(-) create mode 100644 AudioStreamingTests/Streaming/Remote Audio Source/RemoteAudioSourceResumeTests.swift diff --git a/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift b/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift index 5e6ea8e..49cb91b 100644 --- a/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift +++ b/AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift @@ -67,6 +67,18 @@ public class RemoteAudioSource: AudioStreamSource { /// The time data was last received; `nil` while no stream request is open private var lastDataReceivedAt: DispatchTime? + /// Length of the stream start kept to check that a reopened stream delivers the same content + static let streamHeadLength = 4096 + /// The first bytes of the stream, to verify a resume without range support + private var streamHead = Data() + /// Progress of dropping the already read bytes after reopening a stream without range support + private var resumeSkip: ResumeSkip? + + private struct ResumeSkip { + let bytesToSkip: Int + var received = 0 + } + init(networking: NetworkingClient, metadataStreamSource: MetadataStreamSource, icycastHeadersProcessor: IcycastHeadersProcessor, @@ -160,12 +172,18 @@ public class RemoteAudioSource: AudioStreamSource { } public func seek(at offset: Int) { + reopen(at: offset, skipping: 0) + } + + /// - Parameter bytesToSkip: Bytes at the start of the stream the player has already read + private func reopen(at offset: Int, skipping bytesToSkip: Int) { close() - relativePosition = 0 + relativePosition = bytesToSkip seekOffset = offset + resumeSkip = bytesToSkip > 0 ? ResumeSkip(bytesToSkip: bytesToSkip) : nil - if !supportsSeek, offset != relativePosition { + if !supportsSeek, offset != 0 { return } @@ -193,12 +211,12 @@ public class RemoteAudioSource: AudioStreamSource { guard let self = self else { return } guard connection.isConnected else { return } if self.waitingForNetwork { - self.seek(at: self.supportsSeek ? self.position : 0) + self.reopenAtCurrentPosition() self.waitingForNetwork = false - } else if self.supportsSeek, self.isStreamStalled { + } else if self.isStreamStalled { // The path changed (new cell, interface or address) while no data arrived: // the open connection is most likely dead, so reopen it instead of waiting for the timeout - self.seek(at: self.position) + self.reopenAtCurrentPosition() } } } @@ -340,11 +358,42 @@ public class RemoteAudioSource: AudioStreamSource { self.relativePosition += audioCount return } - let audioCount = self.processAudio(data: audioData) + guard let unreadData = self.dropAlreadyReadBytes(of: audioData) else { return } + self.recordStreamHead(unreadData) + let audioCount = self.processAudio(data: unreadData) self.relativePosition += audioCount } } + /// While resuming a stream without range support, drops the bytes the player has already read, + /// as long as the reopened stream starts with the same content. + /// - Returns: The data to process, or `nil` if the whole chunk was dropped + private func dropAlreadyReadBytes(of data: Data) -> Data? { + guard var skip = resumeSkip else { return data } + let compareEnd = min(streamHead.count, skip.bytesToSkip) + if skip.received < compareEnd { + let count = min(compareEnd - skip.received, data.count) + let expected = streamHead.subdata(in: skip.received ..< skip.received + count) + if Data(data.prefix(count)) != expected { + // Different content (e.g. a live stream): play the new stream from its start + resumeSkip = nil + relativePosition = 0 + streamHead = Data() + return data + } + } + let dropCount = min(skip.bytesToSkip - skip.received, data.count) + skip.received += dropCount + resumeSkip = skip.received < skip.bytesToSkip ? skip : nil + return dropCount < data.count ? Data(data.dropFirst(dropCount)) : nil + } + + private func recordStreamHead(_ data: Data) { + guard resumeSkip == nil, seekOffset == 0, streamHead.count == relativePosition, + streamHead.count < Self.streamHeadLength else { return } + streamHead.append(data.prefix(Self.streamHeadLength - streamHead.count)) + } + private func handleFailedStreamEvent(error _: Error) { if !netStatusService.isConnected { waitingForNetwork = true @@ -448,10 +497,30 @@ public class RemoteAudioSource: AudioStreamSource { private func retryOnError() { retrierTimeout.retry { [weak self] in guard let self = self else { return } - self.seek(at: self.supportsSeek ? self.position : 0) + self.reopenAtCurrentPosition() + } + } + + /// Reopens the stream after a network failure or stall, continuing where the player stopped reading + private func reopenAtCurrentPosition() { + if supportsSeek { + seek(at: position) + } else if canResumeBySkipping { + // Without range support the stream starts over: drop the bytes already read + reopen(at: 0, skipping: position) + } else { + seek(at: 0) } } + private var canResumeBySkipping: Bool { + position > 0 + && !metadataStreamProcessor.canProcessMetadata + && !shouldTryParsingIcycastHeaders + && !mp4Restructure.dataOptimized + && streamHead.count >= min(position, Self.streamHeadLength) + } + // MARK: - Network Stream Operation Queue /// Schedules the given block on the stream operation queue diff --git a/AudioStreamingTests/Streaming/Remote Audio Source/RemoteAudioSourceResumeTests.swift b/AudioStreamingTests/Streaming/Remote Audio Source/RemoteAudioSourceResumeTests.swift new file mode 100644 index 0000000..2de12fa --- /dev/null +++ b/AudioStreamingTests/Streaming/Remote Audio Source/RemoteAudioSourceResumeTests.swift @@ -0,0 +1,156 @@ +import Network +import XCTest +@testable import AudioStreaming + +/// Resuming a stream from a server without range support after the connection broke +final class RemoteAudioSourceResumeTests: XCTestCase { + private var server: NoRangeHTTPServer! + private var networking: NetworkingClient! + + override func tearDown() { + server?.stop() + server = nil + networking = nil + super.tearDown() + } + + func testResumeDropsAlreadyReadBytesOfSameContent() throws { + let payload = Self.randomData(count: 100_000) + server = try NoRangeHTTPServer { _ in payload } + server.cutFirstStreamAfter = 40000 + + let received = try readStream() + + XCTAssertEqual(server.streamRequestCount, 2) + XCTAssertEqual(received.count, payload.count) + XCTAssertEqual(received, payload) + } + + func testResumePlaysDifferentContentFromItsStart() throws { + let first = Self.randomData(count: 100_000) + let second = Self.randomData(count: 60000) + server = try NoRangeHTTPServer { index in index == 0 ? first : second } + server.cutFirstStreamAfter = 40000 + + let received = try readStream() + + XCTAssertEqual(server.streamRequestCount, 2) + XCTAssertEqual(received, first.prefix(40000) + second) + } + + // MARK: - Helpers + + private func readStream() throws -> Data { + try server.start() + networking = NetworkingClient() + let queue = DispatchQueue(label: "remote.audio.source.test") + let url = URL(string: "http://127.0.0.1:\(server.port)/song.mp3")! + let source = RemoteAudioSource(networking: networking, + metadataStreamSource: MetadataStreamProcessor(parser: MetadataParser().eraseToAnyParser()), + icycastHeadersProcessor: IcycastHeadersProcessor(), + netStatusProvider: ConnectedNetStatusProvider(), + retrier: Retrier(interval: .milliseconds(100), maxInterval: 1, underlyingQueue: nil), + url: url, + httpMethod: nil, + httpBody: nil, + underlyingQueue: queue, + httpHeaders: [:]) + let delegate = CollectingSourceDelegate() + delegate.finished = expectation(description: "end of file") + source.delegate = delegate + queue.async { source.seek(at: 0) } + wait(for: [delegate.finished!], timeout: 10) + source.close() + return delegate.data + } + + private static func randomData(count: Int) -> Data { + Data((0 ..< count).map { _ in UInt8.random(in: 0 ... 255) }) + } +} + +private final class ConnectedNetStatusProvider: NetStatusProvider { + var isConnected: Bool { true } + var connectionType: NetConnectionType { .wifi(connected: true) } + func start(connectionChange _: @escaping (NetConnectionType) -> Void) {} + func stop() {} +} + +private final class CollectingSourceDelegate: AudioStreamSourceDelegate { + private let lock = UnfairLock() + private var _data = Data() + var finished: XCTestExpectation? + + var data: Data { lock.withLock { _data } } + + func dataAvailable(source _: CoreAudioStreamSource, data: Data) { + lock.withLock { _data.append(data) } + } + + func errorOccurred(source _: CoreAudioStreamSource, error: Error) { + XCTFail("unexpected error: \(error)") + } + + func endOfFileOccurred(source _: CoreAudioStreamSource) { + finished?.fulfill() + } + + func metadataReceived(data _: [String: String]) {} +} + +/// Answers every request with 200 OK and the full body, ignoring `Range` headers. +/// The first request without a `Range` header (the audio stream) can be cut off after a number of bytes. +private final class NoRangeHTTPServer { + private let listener: NWListener + private let queue = DispatchQueue(label: "no.range.http.server") + private let bodyForStreamRequest: (Int) -> Data + private(set) var port: UInt16 = 0 + private(set) var streamRequestCount = 0 + var cutFirstStreamAfter: Int? + + init(bodyForStreamRequest: @escaping (Int) -> Data) throws { + self.bodyForStreamRequest = bodyForStreamRequest + let params = NWParameters.tcp + params.allowLocalEndpointReuse = true + listener = try NWListener(using: params, on: .any) + } + + func start() throws { + let ready = DispatchSemaphore(value: 0) + listener.stateUpdateHandler = { state in + if case .ready = state { ready.signal() } + } + listener.newConnectionHandler = { [weak self] connection in + self?.handle(connection) + } + listener.start(queue: queue) + _ = ready.wait(timeout: .now() + 5) + port = listener.port?.rawValue ?? 0 + } + + func stop() { + listener.cancel() + } + + private func handle(_ connection: NWConnection) { + connection.start(queue: queue) + connection.receive(minimumIncompleteLength: 1, maximumLength: 65536) { [weak self] request, _, _, _ in + guard let self, let request else { return } + let isRangeRequest = String(decoding: request, as: UTF8.self).lowercased().contains("\r\nrange:") + var body = self.bodyForStreamRequest(self.streamRequestCount) + if !isRangeRequest { + self.streamRequestCount += 1 + } + let header = "HTTP/1.1 200 OK\r\n" + + "Content-Type: audio/mpeg\r\n" + + "Content-Length: \(body.count)\r\n" + + "Cache-Control: no-cache\r\n" + + "Connection: close\r\n\r\n" + if !isRangeRequest, self.streamRequestCount == 1, let cut = self.cutFirstStreamAfter { + body = body.prefix(cut) + } + connection.send(content: Data(header.utf8) + body, + completion: .contentProcessed { _ in connection.cancel() }) + } + } +}