Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
124 changes: 117 additions & 7 deletions AudioStreaming/Streaming/Audio Source/RemoteAudioSource.swift
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down Expand Up @@ -57,6 +63,22 @@ 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?

/// 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,
Expand Down Expand Up @@ -138,6 +160,7 @@ public class RemoteAudioSource: AudioStreamSource {
}

public func close() {
setLastDataReceived(nil)
retrierTimeout.cancel()
streamOperationQueue.isSuspended = false
streamOperationQueue.cancelAllOperations()
Expand All @@ -149,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
}

Expand Down Expand Up @@ -182,12 +211,30 @@ 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.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.reopenAtCurrentPosition()
}
}
}

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
Expand All @@ -210,6 +257,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 }
Expand All @@ -229,6 +277,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
}
Expand Down Expand Up @@ -258,6 +311,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)
Expand Down Expand Up @@ -299,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
Expand Down Expand Up @@ -369,7 +459,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

Expand All @@ -390,7 +480,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

Expand All @@ -407,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
Expand Down
Original file line number Diff line number Diff line change
@@ -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() })
}
}
}
Loading