diff --git a/AudioStreaming/Streaming/Audio Source/FileAudioSource.swift b/AudioStreaming/Streaming/Audio Source/FileAudioSource.swift index 4a356b3..25a111a 100644 --- a/AudioStreaming/Streaming/Audio Source/FileAudioSource.swift +++ b/AudioStreaming/Streaming/Audio Source/FileAudioSource.swift @@ -128,8 +128,10 @@ final class FileAudioSource: NSObject, CoreAudioStreamSource { break case .optimized: mp4IsAlreadyOptimized = true + // The probe buffer holds every byte read so far, not just this chunk + let probedData = mp4ProbeBuffer mp4ProbeBuffer = Data() - delegate?.dataAvailable(source: self, data: data) + delegate?.dataAvailable(source: self, data: probedData) case let .needsRestructure(moovOffset): mp4ProbeBuffer = Data() try performMp4Restructure(inputStream: inputStream, moovOffset: moovOffset) diff --git a/AudioStreamingTests/Streaming/Audio Source/FileAudioSourceTests.swift b/AudioStreamingTests/Streaming/Audio Source/FileAudioSourceTests.swift new file mode 100644 index 0000000..cd93a17 --- /dev/null +++ b/AudioStreamingTests/Streaming/Audio Source/FileAudioSourceTests.swift @@ -0,0 +1,126 @@ +// +// FileAudioSourceTests.swift +// AudioStreamingTests +// + +import XCTest +@testable import AudioStreaming + +class FileAudioSourceTests: XCTestCase { + /// The default read size of `FileAudioSource` + private let readSize = 64 * 1024 + + func test_Optimized_Mp4_Decided_After_Several_Reads_Forwards_All_Bytes() throws { + // a free atom larger than one read pushes the moov atom beyond the first read + let ftyp = mp4Atom("ftyp", payload: ftypPayload) + let free = mp4Atom("free", payload: pattern(count: 96 * 1024, modulo: 251)) + let moov = mp4Atom("moov", payload: pattern(count: 248, modulo: 253)) + let mdat = mp4Atom("mdat", payload: pattern(count: 32 * 1024, modulo: 241)) + let file = ftyp + free + moov + mdat + XCTAssertGreaterThan(ftyp.count + free.count, readSize, "moov must start beyond the first read") + + let result = try readAll(file: file) + + XCTAssertNil(result.error) + XCTAssertEqual(result.data.count, file.count, "byte count") + XCTAssertEqual(result.data, file) + } + + func test_Optimized_Mp4_Decided_On_First_Read_Forwards_All_Bytes() throws { + let ftyp = mp4Atom("ftyp", payload: ftypPayload) + let free = mp4Atom("free", payload: pattern(count: 100, modulo: 251)) + let moov = mp4Atom("moov", payload: pattern(count: 248, modulo: 253)) + let mdat = mp4Atom("mdat", payload: pattern(count: 32 * 1024, modulo: 241)) + let file = ftyp + free + moov + mdat + XCTAssertLessThan(file.count, readSize, "the whole file must fit in the first read") + + let result = try readAll(file: file) + + XCTAssertNil(result.error) + XCTAssertEqual(result.data.count, file.count, "byte count") + XCTAssertEqual(result.data, file) + } + + func test_Non_Optimized_Mp4_Restructure_Path_Is_Unchanged() throws { + let ftyp = mp4Atom("ftyp", payload: ftypPayload) + let mdat = mp4Atom("mdat", payload: pattern(count: 4 * 1024, modulo: 241)) + // no stco or co64 inside, so restructuring leaves the moov atom as it is + let moov = mp4Atom("moov", payload: mp4Atom("udta", payload: Data(count: 8))) + // a trailing atom keeps the synchronous moov read from ending exactly at EOF + let free = mp4Atom("free", payload: Data(count: 8)) + let file = ftyp + mdat + moov + free + + let result = try readAll(file: file) + + // ftyp and moov first, then everything from the mdat atom onwards + let expected = ftyp + moov + file.subdata(in: ftyp.count ..< file.count) + XCTAssertNil(result.error) + XCTAssertEqual(result.data.count, expected.count, "byte count") + XCTAssertEqual(result.data, expected) + } + + // MARK: - Helpers + + private var ftypPayload: Data { + Data("M4A ".utf8) + Data([0x00, 0x00, 0x02, 0x00]) + Data("M4A isom".utf8) + } + + private func mp4Atom(_ type: String, payload: Data) -> Data { + var atom = Data() + withUnsafeBytes(of: UInt32(8 + payload.count).bigEndian) { atom.append(contentsOf: $0) } + atom.append(Data(type.utf8)) + atom.append(payload) + return atom + } + + private func pattern(count: Int, modulo: Int) -> Data { + Data((0 ..< count).map { UInt8($0 % modulo) }) + } + + /// Plays the given bytes as a local `.m4a` file through `FileAudioSource` and records what reaches the delegate + private func readAll(file: Data) throws -> (data: Data, error: Error?) { + let url = FileManager.default.temporaryDirectory + .appendingPathComponent("FileAudioSourceTests-\(UUID().uuidString).m4a") + try file.write(to: url) + defer { try? FileManager.default.removeItem(at: url) } + + let queue = DispatchQueue(label: "file-audio-source-tests") + let source = FileAudioSource(url: url, underlyingQueue: queue) + let recorder = RecordingSourceDelegate(finished: expectation(description: "source finished")) + source.delegate = recorder + queue.async { source.seek(at: 0) } + + wait(for: [recorder.finished], timeout: 10) + return queue.sync { + source.close() + return (recorder.data, recorder.error) + } + } +} + +private final class RecordingSourceDelegate: AudioStreamSourceDelegate { + let finished: XCTestExpectation + var data = Data() + var error: Error? + + init(finished: XCTestExpectation) { + // an error can be followed by the end of the file + finished.assertForOverFulfill = false + self.finished = finished + } + + func dataAvailable(source _: CoreAudioStreamSource, data: Data) { + self.data.append(data) + } + + func errorOccurred(source _: CoreAudioStreamSource, error: Error) { + self.error = error + finished.fulfill() + } + + func endOfFileOccurred(source _: CoreAudioStreamSource) { + finished.fulfill() + } + + func metadataReceived(data _: [String: String]) {} +} diff --git a/AudioStreamingTests/Streaming/Audio Source/Mp4ProbeForwardPlaybackTests.swift b/AudioStreamingTests/Streaming/Audio Source/Mp4ProbeForwardPlaybackTests.swift new file mode 100644 index 0000000..9865ff9 --- /dev/null +++ b/AudioStreamingTests/Streaming/Audio Source/Mp4ProbeForwardPlaybackTests.swift @@ -0,0 +1,105 @@ +// +// Mp4ProbeForwardPlaybackTests.swift +// AudioStreamingTests +// + +import XCTest +@testable import AudioStreaming + +final class Mp4ProbeForwardPlaybackTests: XCTestCase { + /// The default read size of `FileAudioSource` + private let readSize = 64 * 1024 + + func test_Local_Mp4_Optimized_After_Several_Reads_Plays_To_End() throws { + // A 2 s, 440 Hz, 44.1 kHz mono AAC-LC tone (ffmpeg, 64 kbit/s, -movflags +faststart), with a + // 72 KiB top-level free atom inserted before moov and the stco chunk offsets shifted to match + let fixtureURL = try XCTUnwrap(Bundle.module.url(forResource: "faststart-free-before-moov", withExtension: "m4a")) + let data = try Data(contentsOf: fixtureURL) + // the fixture is only recognised as optimized once more than the first read is buffered + XCTAssertEqual(try Mp4Restructure().checkIsOptimized(data: Data(data.prefix(readSize))), .undetermined) + XCTAssertEqual(try Mp4Restructure().checkIsOptimized(data: data), .optimized) + + let recorder = Mp4PlaybackRecorder() + let finished = expectation(description: "audioPlayerDidFinishPlaying") + recorder.onFinish = { finished.fulfill() } + + let player = AudioPlayer() + player.delegate = recorder + // AudioPlayer.init creates its output unit asynchronously + RunLoop.main.run(until: Date().addingTimeInterval(1)) + + var progressSamples: [Double] = [] + let sampler = Timer.scheduledTimer(withTimeInterval: 0.1, repeats: true) { _ in + progressSamples.append(player.progress) + } + player.play(url: fixtureURL) + // a short wait, so that a stalled player fails on the assertions below instead of a timeout + let waitResult = XCTWaiter().wait(for: [finished], timeout: 8) + sampler.invalidate() + recorder.onFinish = nil + player.stop() + + let positiveProgress = progressSamples.filter { $0 > 0 } + let observed = "waiter=\(waitResult.rawValue) events=\(recorder.events) maxProgress=\(progressSamples.max() ?? 0)" + + XCTAssertEqual(waitResult, .completed, "playback did not finish; \(observed)") + XCTAssertTrue(recorder.started, "playback did not start; \(observed)") + XCTAssertTrue(recorder.errors.isEmpty, "unexpected errors: \(recorder.errors)") + XCTAssertGreaterThan(positiveProgress.last ?? 0, positiveProgress.first ?? 0, "progress did not grow; \(observed)") + XCTAssertEqual(recorder.finishReason, .eof, "unexpected stop reason; \(observed)") + XCTAssertGreaterThan(recorder.finishProgress ?? 0, 1.8, "did not play the whole 2 s; \(observed)") + } +} + +private final class Mp4PlaybackRecorder: AudioPlayerDelegate { + private let start = Date() + private(set) var events: [String] = [] + private(set) var started = false + private(set) var errors: [String] = [] + private(set) var finishProgress: Double? + private(set) var finishReason: AudioPlayerStopReason? + var onFinish: (() -> Void)? + + private func log(_ text: String) { + events.append(String(format: "+%.2fs ", Date().timeIntervalSince(start)) + text) + } + + func audioPlayerDidStartPlaying(player _: AudioPlayer, with _: AudioEntryId) { + started = true + log("didStartPlaying") + } + + func audioPlayerDidFinishBuffering(player _: AudioPlayer, with _: AudioEntryId) { + log("didFinishBuffering") + } + + func audioPlayerStateChanged(player _: AudioPlayer, with newState: AudioPlayerState, previous: AudioPlayerState) { + log("stateChanged \(previous) -> \(newState)") + } + + func audioPlayerDidFinishPlaying(player _: AudioPlayer, + entryId _: AudioEntryId, + stopReason: AudioPlayerStopReason, + progress: Double, + duration: Double) + { + log(String(format: "didFinishPlaying \(stopReason) progress=%.3f duration=%.3f", progress, duration)) + guard finishProgress == nil else { return } + finishProgress = progress + finishReason = stopReason + onFinish?() + } + + func audioPlayerUnexpectedError(player _: AudioPlayer, error: AudioPlayerError) { + errors.append("\(error)") + log("unexpectedError \(error)") + } + + func audioPlayerDidCancel(player _: AudioPlayer, queuedItems _: [AudioEntryId]) { + log("didCancel") + } + + func audioPlayerDidReadMetadata(player _: AudioPlayer, metadata _: [String: String]) { + log("didReadMetadata") + } +} diff --git a/AudioStreamingTests/Streaming/Audio Source/faststart-free-before-moov.m4a b/AudioStreamingTests/Streaming/Audio Source/faststart-free-before-moov.m4a new file mode 100644 index 0000000..9e3cdf0 Binary files /dev/null and b/AudioStreamingTests/Streaming/Audio Source/faststart-free-before-moov.m4a differ diff --git a/Package.swift b/Package.swift index 5249157..0aa7b63 100644 --- a/Package.swift +++ b/Package.swift @@ -59,6 +59,8 @@ let package = Package( path: "AudioStreamingTests", exclude: ["Info.plist", "Streaming/output"], resources: [ + // MP4 fixture for the FileAudioSource playback test + .copy("Streaming/Audio Source/faststart-free-before-moov.m4a"), // Test resources for metadata stream processor tests .copy("Streaming/Metadata Stream Processor/raw-audio-streams") ]