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
4 changes: 3 additions & 1 deletion AudioStreaming/Streaming/Audio Source/FileAudioSource.swift
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
126 changes: 126 additions & 0 deletions AudioStreamingTests/Streaming/Audio Source/FileAudioSourceTests.swift
Original file line number Diff line number Diff line change
@@ -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]) {}
}
Original file line number Diff line number Diff line change
@@ -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")
}
}
Binary file not shown.
2 changes: 2 additions & 0 deletions Package.swift
Original file line number Diff line number Diff line change
Expand Up @@ -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")
]
Expand Down