Repository Public
1// ORIX DJ2// File: App/Sources/Features/Recording/RecordingController.swift3// Description: State of the Recording & Export Studio: the list of raw takes and exported files, the peak overview4// of the selected take (computed off the main thread and cached), trim / fade / gain options, the export5// job and its report.6//7// Author: Simon-Pierre Boucher8// Contact: contact@spboucher.ai9import AVFoundation10import AppKit11import ORIXDJCore12import SwiftUI13import UniformTypeIdentifiers1415struct RecordingTake: Identifiable, Equatable, Sendable {16 var url: URL17 var date: Date18 var duration: Double19 var sampleRate: Double20 var size: Int6421 /// The file was not closed by the recorder (crash, power loss, forced quit): it was read back up to its last write.22 var recovered: Bool23 var id: URL { url }24 var name: String { url.deletingPathExtension().lastPathComponent }25}2627struct ExportedFile: Identifiable, Equatable, Sendable {28 var url: URL29 var date: Date30 var duration: Double31 var size: Int6432 var id: URL { url }33}3435/// Per-column sample peak of a file (both channels), linear 0...1.36struct TakeOverview: Equatable, Sendable {37 var peaks: [Float]38 var duration: Double39 var peak: Float40}4142enum RecordingFiles {43 /// True when a CAF file's audio-data chunk was never finalised: its size is still "unknown" (-1), or it does not44 /// reach the end of the file. That is what an interrupted recording leaves behind.45 static func isUnclosedCAF(_ url: URL) -> Bool {46 guard let handle = try? FileHandle(forReadingFrom: url) else { return false }47 defer { try? handle.close() }48 guard let fileSize = try? handle.seekToEnd(), fileSize > 8 else { return false }49 var offset: UInt64 = 850 while offset + 12 <= fileSize {51 try? handle.seek(toOffset: offset)52 guard let head = try? handle.read(upToCount: 12), head.count == 12 else { return false }53 let type = String(decoding: head.prefix(4), as: UTF8.self)54 let size = head.suffix(8).reduce(Int64(0)) { ($0 << 8) | Int64($1) }55 if type == "data" { return size < 0 || offset + 12 + UInt64(size) != fileSize }56 guard size >= 0 else { return false }57 offset += 12 + UInt64(size)58 }59 return false60 }6162 static func scan(directory: URL, active: URL?) -> (takes: [RecordingTake], exports: [ExportedFile]) {63 let fm = FileManager.default64 var takes: [RecordingTake] = []65 for url in Recorder.recoverableTakes(in: directory) where url.standardizedFileURL != active?.standardizedFileURL {66 let values = try? url.resourceValues(forKeys: [.fileSizeKey, .creationDateKey, .contentModificationDateKey])67 guard let file = try? AVAudioFile(forReading: url), file.length > 0 else { continue }68 let sr = file.fileFormat.sampleRate69 takes.append(RecordingTake(url: url, date: values?.creationDate ?? values?.contentModificationDate ?? .distantPast, duration: Double(file.length) / max(1, sr),70 sampleRate: sr, size: Int64(values?.fileSize ?? 0), recovered: isUnclosedCAF(url)))71 }72 var exports: [ExportedFile] = []73 let extensions = Set(AudioFileFormat.allCases.map(\.fileExtension))74 for url in (try? fm.contentsOfDirectory(at: directory, includingPropertiesForKeys: [.fileSizeKey, .contentModificationDateKey, .isRegularFileKey])) ?? [] {75 guard extensions.contains(url.pathExtension.lowercased()) else { continue }76 let values = try? url.resourceValues(forKeys: [.fileSizeKey, .contentModificationDateKey, .isRegularFileKey])77 guard values?.isRegularFile == true else { continue }78 let duration = (try? AVAudioFile(forReading: url)).map { Double($0.length) / max(1, $0.fileFormat.sampleRate) } ?? 079 exports.append(ExportedFile(url: url, date: values?.contentModificationDate ?? .distantPast, duration: duration, size: Int64(values?.fileSize ?? 0)))80 }81 return (takes.sorted { $0.date > $1.date }, exports.sorted { $0.date > $1.date })82 }8384 /// Reads the file in chunks and keeps one peak per column.85 static func overview(of url: URL, columns: Int = 1400) throws -> TakeOverview {86 let file = try AVAudioFile(forReading: url)87 let total = Int(file.length)88 let format = file.processingFormat89 guard total > 0, let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: 65536) else { return TakeOverview(peaks: [], duration: 0, peak: 0) }90 let n = min(columns, total)91 var peaks = [Float](repeating: 0, count: n)92 var position = 093 var overall: Float = 094 while position < total {95 try file.read(into: buffer, frameCount: AVAudioFrameCount(min(65536, total - position)))96 let frames = Int(buffer.frameLength)97 if frames == 0 { break }98 guard let data = buffer.floatChannelData else { break }99 for c in 0 ..< Int(format.channelCount) {100 let samples = data[c]101 for i in 0 ..< frames {102 let a = abs(samples[i])103 let column = min(n - 1, Int(Int64(position + i) * Int64(n) / Int64(total)))104 if a > peaks[column] { peaks[column] = a }105 }106 }107 position += frames108 }109 for p in peaks where p > overall { overall = p }110 return TakeOverview(peaks: peaks, duration: Double(total) / format.sampleRate, peak: overall)111 }112113 static func freeBytes(at url: URL) -> Int64 {114 var probe = url115 while !FileManager.default.fileExists(atPath: probe.path), probe.pathComponents.count > 1 { probe.deleteLastPathComponent() }116 return (try? probe.resourceValues(forKeys: [.volumeAvailableCapacityForImportantUsageKey]).volumeAvailableCapacityForImportantUsage) ?? 0117 }118}119120@MainActor @Observable121final class RecordingController {122 var takes: [RecordingTake] = []123 var exports: [ExportedFile] = []124 var selection: URL?125 var overview: TakeOverview?126 var overviewLoading = false127 var freeBytes: Int64 = 0128 var deleteRequest: RecordingTake?129130 // Export options for the selected take.131 var trimStart = 0.0132 var trimEnd = 0.0133 var fadeIn = 0.0134 var fadeOut = 0.0135 var gainDB = 0.0136 var normalize = false137 var format = AudioFileFormat.wav24138 var fileName = ""139140 // Export job.141 var exporting = false142 var exportProgress = 0.0143 var report: ExportReport?144 var reportFormat: AudioFileFormat?145 var exportError: String?146147 @ObservationIgnored private var cache: [String: TakeOverview] = [:]148 @ObservationIgnored private var scanGeneration = 0149 @ObservationIgnored var selectNewestAfterScan = false150 @ObservationIgnored var demoStarted = false151152 var selectedTake: RecordingTake? { takes.first { $0.url == selection } }153154 func refresh(model: AppModel) async {155 let directory = model.session.directories.recordings156 let active = model.recording.isRecording ? model.recording.url : nil157 scanGeneration += 1158 let mine = scanGeneration159 let result = await Task.detached(priority: .userInitiated) { (RecordingFiles.scan(directory: directory, active: active), RecordingFiles.freeBytes(at: directory)) }.value160 guard mine == scanGeneration else { return }161 if takes != result.0.takes { takes = result.0.takes }162 if exports != result.0.exports { exports = result.0.exports }163 freeBytes = result.1164 if selectNewestAfterScan, let newest = takes.first { selectNewestAfterScan = false; select(newest, defaultFormat: model.settings.exportFormat) }165 if let s = selection, !takes.contains(where: { $0.url == s }) { selection = nil; overview = nil; report = nil }166 }167168 func select(_ take: RecordingTake, defaultFormat: AudioFileFormat) {169 guard selection != take.url else { return }170 selection = take.url171 trimStart = 0; trimEnd = take.duration; fadeIn = 0; fadeOut = 0; gainDB = 0; normalize = false172 format = defaultFormat173 fileName = take.name174 report = nil; exportError = nil; overview = nil175 }176177 func loadOverview() async {178 guard let take = selectedTake else { overview = nil; return }179 let key = "\(take.url.path)|\(take.size)"180 if let cached = cache[key] { overview = cached; return }181 overviewLoading = true182 let url = take.url183 let result = await Task.detached(priority: .userInitiated) { try? RecordingFiles.overview(of: url) }.value184 overviewLoading = false185 guard selection == url else { return }186 if let result { cache[key] = result }187 overview = result188 }189190 /// Keeps the trim inside the take and at least 50 ms long.191 func setTrim(start: Double? = nil, end: Double? = nil) {192 guard let take = selectedTake else { return }193 if let start { trimStart = min(max(0, start), max(0, trimEnd - 0.05)) }194 if let end { trimEnd = max(min(take.duration, end), min(take.duration, trimStart + 0.05)) }195 }196197 var selectionLength: Double { max(0, trimEnd - trimStart) }198199 var options: ExportOptions {200 var o = ExportOptions()201 o.format = format202 if let take = selectedTake, trimStart > 0.0005 || trimEnd < take.duration - 0.0005 { o.range = trimStart ... max(trimStart, trimEnd) }203 o.fadeIn = min(max(0, fadeIn), selectionLength)204 o.fadeOut = min(max(0, fadeOut), selectionLength)205 o.gainDB = gainDB206 o.normalizePeakDB = normalize ? -1 : nil207 return o208 }209210 func chooseDestinationAndExport(model: AppModel) {211 guard selectedTake != nil, !exporting else { return }212 let panel = NSSavePanel()213 panel.directoryURL = model.session.directories.recordings214 panel.allowedContentTypes = [UTType(filenameExtension: format.fileExtension) ?? .audio]215 panel.nameFieldStringValue = safeFileName + "." + format.fileExtension216 panel.canCreateDirectories = true217 guard panel.runModal() == .OK, let url = panel.url else { return }218 export(to: url, model: model)219 }220221 var safeFileName: String {222 let trimmed = fileName.trimmingCharacters(in: .whitespaces).replacingOccurrences(of: "/", with: "-").replacingOccurrences(of: ":", with: "-")223 return trimmed.isEmpty ? (selectedTake?.name ?? "Recording") : trimmed224 }225226 func export(to destination: URL, model: AppModel) {227 guard let take = selectedTake, !exporting else { return }228 let options = options229 let source = take.url230 exporting = true; exportProgress = 0; report = nil; exportError = nil231 let progress = RecordingProgressBox()232 Task {233 let poll = Task {234 while !Task.isCancelled {235 try? await Task.sleep(nanoseconds: 60_000_000)236 self.exportProgress = progress.value237 }238 }239 let result = await Task.detached(priority: .userInitiated) { () -> Result<ExportReport, Error> in240 do { return .success(try AudioExporter.export(source: source, to: destination, options: options) { progress.value = $0 }) } catch { return .failure(error) }241 }.value242 poll.cancel()243 exporting = false244 switch result {245 case let .success(r):246 report = r; reportFormat = options.format; exportProgress = 1247 model.show(notice: String(localized: "Exported \"\(r.url.lastPathComponent)\""))248 case let .failure(e):249 exportError = (e as? LocalizedError)?.errorDescription ?? e.localizedDescription250 }251 await refresh(model: model)252 }253 }254255 func confirmDelete(model: AppModel) {256 guard let take = deleteRequest else { return }257 deleteRequest = nil258 do { try FileManager.default.trashItem(at: take.url, resultingItemURL: nil) } catch { model.show(notice: error.localizedDescription); return }259 if selection == take.url { selection = nil; overview = nil; report = nil }260 Task { await refresh(model: model) }261 }262263 func reveal(_ url: URL) {264 if FileManager.default.fileExists(atPath: url.path) { NSWorkspace.shared.activateFileViewerSelecting([url]) }265 }266267 func revealFolder(model: AppModel) {268 let folder = model.session.directories.recordings269 try? FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)270 NSWorkspace.shared.open(folder)271 }272}273274/// Export progress written from the export thread and read by the main actor.275final class RecordingProgressBox: @unchecked Sendable {276 private let lock = NSLock()277 private var stored = 0.0278 var value: Double {279 get { lock.withLock { stored } }280 set { lock.withLock { stored = newValue } }281 }282}283