SPB Git

Repository Public

RecordingController.swift 12.7 KB 283 lines swift

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
Files main
Menu

Theme