1192 lines
39 KiB
Swift
1192 lines
39 KiB
Swift
import Foundation
|
|
|
|
struct EpisodePlan: Identifiable {
|
|
let id = UUID()
|
|
let source: URL
|
|
let sourceName: String
|
|
let targetFolderName: String
|
|
let tracks: [TrackPlan]
|
|
let warnings: [String]
|
|
}
|
|
|
|
struct TrackPlan: Identifiable {
|
|
let id = UUID()
|
|
let source: URL
|
|
}
|
|
|
|
struct TonUinoExportOptions {
|
|
let overwriteExisting: Bool
|
|
let writeReport: Bool
|
|
}
|
|
|
|
struct TonUinoScanner {
|
|
private let fileManager: FileManager
|
|
|
|
init(fileManager: FileManager) {
|
|
self.fileManager = fileManager
|
|
}
|
|
|
|
func scan(inputURL: URL) throws -> [EpisodePlan] {
|
|
let directoryURLs = try fileManager
|
|
.contentsOfDirectory(
|
|
at: inputURL,
|
|
includingPropertiesForKeys: [.isDirectoryKey, .isHiddenKey],
|
|
options: [.skipsHiddenFiles]
|
|
)
|
|
.filter { url in
|
|
(try? url.resourceValues(forKeys: [.isDirectoryKey]).isDirectory) == true
|
|
}
|
|
.sortedByLocalizedName()
|
|
|
|
let playableDirectories = directoryURLs.compactMap { directoryURL -> (URL, [URL])? in
|
|
let trackURLs = (try? audioFiles(in: directoryURL)) ?? []
|
|
guard !trackURLs.isEmpty else { return nil }
|
|
return (directoryURL, trackURLs)
|
|
}
|
|
|
|
return playableDirectories.enumerated().map { index, item in
|
|
let directoryURL = item.0
|
|
let trackURLs = item.1
|
|
let targetFolderName = String(format: "%02d", index + 1)
|
|
var warnings: [String] = []
|
|
|
|
if index >= 99 {
|
|
warnings.append("TonUINO nutzt üblicherweise maximal 99 Ordner")
|
|
}
|
|
|
|
if trackURLs.count > 255 {
|
|
warnings.append("Mehr als 255 Tracks in einem Ordner")
|
|
}
|
|
|
|
let nonMP3Count = trackURLs.filter { $0.pathExtension.lowercased() != "mp3" }.count
|
|
if nonMP3Count > 0 {
|
|
warnings.append("\(nonMP3Count) Datei(en) sind nicht MP3 und werden nicht exportiert")
|
|
}
|
|
|
|
let tracks = trackURLs.map { trackURL in
|
|
TrackPlan(source: trackURL)
|
|
}
|
|
|
|
return EpisodePlan(
|
|
source: directoryURL,
|
|
sourceName: directoryURL.lastPathComponent,
|
|
targetFolderName: targetFolderName,
|
|
tracks: tracks,
|
|
warnings: warnings
|
|
)
|
|
}
|
|
}
|
|
|
|
private func audioFiles(in directoryURL: URL) throws -> [URL] {
|
|
try fileManager
|
|
.contentsOfDirectory(
|
|
at: directoryURL,
|
|
includingPropertiesForKeys: [.isRegularFileKey, .isHiddenKey],
|
|
options: [.skipsHiddenFiles]
|
|
)
|
|
.filter { url in
|
|
let isFile = (try? url.resourceValues(forKeys: [.isRegularFileKey]).isRegularFile) == true
|
|
return isFile && SupportedAudioExtensions.contains(url.pathExtension)
|
|
}
|
|
.sortedByLocalizedName()
|
|
}
|
|
}
|
|
|
|
struct TonUinoExporter {
|
|
private let fileManager: FileManager
|
|
|
|
init(fileManager: FileManager) {
|
|
self.fileManager = fileManager
|
|
}
|
|
|
|
func export(
|
|
episodes: [EpisodePlan],
|
|
outputURL: URL,
|
|
options: TonUinoExportOptions
|
|
) -> [ExportMessage] {
|
|
var messages: [ExportMessage] = []
|
|
var exportedEpisodes = 0
|
|
var exportedEpisodePlans: [EpisodePlan] = []
|
|
|
|
do {
|
|
try fileManager.createDirectory(at: outputURL, withIntermediateDirectories: true)
|
|
} catch {
|
|
return [.error("Output-Ordner konnte nicht erstellt werden: \(error.localizedDescription)")]
|
|
}
|
|
|
|
for episode in episodes {
|
|
let targetDirectory = outputURL.appending(path: episode.targetFolderName, directoryHint: .isDirectory)
|
|
let destination = targetDirectory.appending(path: "001.mp3")
|
|
let temporaryDestination = targetDirectory.appending(path: ".001.mp3.tmp")
|
|
|
|
do {
|
|
try fileManager.createDirectory(at: targetDirectory, withIntermediateDirectories: true)
|
|
|
|
if fileManager.fileExists(atPath: destination.path(percentEncoded: false)) {
|
|
guard options.overwriteExisting else {
|
|
messages.append(.error("Existiert bereits: \(episode.targetFolderName)/001.mp3"))
|
|
continue
|
|
}
|
|
}
|
|
|
|
if fileManager.fileExists(atPath: temporaryDestination.path(percentEncoded: false)) {
|
|
try fileManager.removeItem(at: temporaryDestination)
|
|
}
|
|
|
|
try MP3Concatenator(fileManager: fileManager).concatenate(
|
|
sources: episode.tracks.map(\.source),
|
|
destination: temporaryDestination
|
|
)
|
|
|
|
if fileManager.fileExists(atPath: destination.path(percentEncoded: false)) {
|
|
try fileManager.removeItem(at: destination)
|
|
}
|
|
try fileManager.moveItem(at: temporaryDestination, to: destination)
|
|
|
|
exportedEpisodes += 1
|
|
exportedEpisodePlans.append(episode)
|
|
messages.append(.info("\(episode.sourceName) -> \(episode.targetFolderName)/001.mp3"))
|
|
} catch {
|
|
if fileManager.fileExists(atPath: temporaryDestination.path(percentEncoded: false)) {
|
|
try? fileManager.removeItem(at: temporaryDestination)
|
|
}
|
|
messages.append(.error("\(episode.sourceName): \(error.localizedDescription)"))
|
|
}
|
|
}
|
|
|
|
if options.writeReport {
|
|
messages.append(contentsOf: ExportReportWriter(fileManager: fileManager).write(
|
|
episodes: exportedEpisodePlans,
|
|
outputURL: outputURL
|
|
))
|
|
}
|
|
|
|
messages.insert(.info("\(exportedEpisodes) Folge(n) exportiert."), at: 0)
|
|
return messages
|
|
}
|
|
}
|
|
|
|
struct ExportReportWriter {
|
|
private let fileManager: FileManager
|
|
|
|
init(fileManager: FileManager) {
|
|
self.fileManager = fileManager
|
|
}
|
|
|
|
func write(episodes: [EpisodePlan], outputURL: URL) -> [ExportMessage] {
|
|
let destination = outputURL.appending(path: "TonUinoNator-Report.txt")
|
|
var lines: [String] = [
|
|
"TonUinoNator Exportbericht",
|
|
"Erstellt: \(DateFormatter.reportDateTime.string(from: Date()))",
|
|
"",
|
|
"Folgen:"
|
|
]
|
|
|
|
for episode in episodes {
|
|
lines.append("\(episode.targetFolderName)/001.mp3 <- \(episode.sourceName)")
|
|
for track in episode.tracks {
|
|
lines.append(" - \(track.source.lastPathComponent)")
|
|
}
|
|
}
|
|
|
|
do {
|
|
try fileManager.createDirectory(at: outputURL, withIntermediateDirectories: true)
|
|
try lines.joined(separator: "\n").write(to: destination, atomically: true, encoding: .utf8)
|
|
return [.info("Exportbericht geschrieben: TonUinoNator-Report.txt")]
|
|
} catch {
|
|
return [.error("Exportbericht konnte nicht geschrieben werden: \(error.localizedDescription)")]
|
|
}
|
|
}
|
|
}
|
|
|
|
enum SupportedAudioExtensions {
|
|
private static let values: Set<String> = ["mp3", "m4a", "aac", "wav", "flac", "ogg"]
|
|
|
|
static func contains(_ pathExtension: String) -> Bool {
|
|
values.contains(pathExtension.lowercased())
|
|
}
|
|
}
|
|
|
|
struct MP3Concatenator {
|
|
enum ConcatenationError: LocalizedError {
|
|
case noSources
|
|
case unsupportedFormat(String)
|
|
case unreadableFile(String)
|
|
|
|
var errorDescription: String? {
|
|
switch self {
|
|
case .noSources:
|
|
"Keine MP3-Dateien zum Zusammenfügen gefunden."
|
|
case .unsupportedFormat(let fileName):
|
|
"\(fileName) ist keine MP3-Datei."
|
|
case .unreadableFile(let fileName):
|
|
"\(fileName) konnte nicht gelesen werden."
|
|
}
|
|
}
|
|
}
|
|
|
|
private let fileManager: FileManager
|
|
|
|
init(fileManager: FileManager) {
|
|
self.fileManager = fileManager
|
|
}
|
|
|
|
func concatenate(sources: [URL], destination: URL) throws {
|
|
guard !sources.isEmpty else {
|
|
throw ConcatenationError.noSources
|
|
}
|
|
|
|
for source in sources where source.pathExtension.lowercased() != "mp3" {
|
|
throw ConcatenationError.unsupportedFormat(source.lastPathComponent)
|
|
}
|
|
|
|
fileManager.createFile(atPath: destination.path(percentEncoded: false), contents: nil)
|
|
guard let output = try? FileHandle(forWritingTo: destination) else {
|
|
throw ConcatenationError.unreadableFile(destination.lastPathComponent)
|
|
}
|
|
|
|
defer {
|
|
try? output.close()
|
|
}
|
|
|
|
for source in sources {
|
|
guard let data = try? Data(contentsOf: source) else {
|
|
throw ConcatenationError.unreadableFile(source.lastPathComponent)
|
|
}
|
|
|
|
let payload = stripMP3Metadata(from: data)
|
|
try output.write(contentsOf: payload)
|
|
}
|
|
}
|
|
|
|
private func stripMP3Metadata(from data: Data) -> Data {
|
|
guard !data.isEmpty else { return data }
|
|
|
|
let start = id3v2EndOffset(in: data)
|
|
let end = id3v1StartOffset(in: data)
|
|
|
|
guard start < end else { return Data() }
|
|
return data.subdata(in: start..<end)
|
|
}
|
|
|
|
private func id3v2EndOffset(in data: Data) -> Int {
|
|
guard data.count >= 10 else { return 0 }
|
|
|
|
let header = [UInt8](data.prefix(10))
|
|
guard header[0] == 0x49, header[1] == 0x44, header[2] == 0x33 else {
|
|
return 0
|
|
}
|
|
|
|
let size = (Int(header[6] & 0x7F) << 21)
|
|
| (Int(header[7] & 0x7F) << 14)
|
|
| (Int(header[8] & 0x7F) << 7)
|
|
| Int(header[9] & 0x7F)
|
|
|
|
let footerSize = (header[5] & 0x10) == 0x10 ? 10 : 0
|
|
return min(data.count, 10 + size + footerSize)
|
|
}
|
|
|
|
private func id3v1StartOffset(in data: Data) -> Int {
|
|
guard data.count >= 128 else { return data.count }
|
|
|
|
let start = data.count - 128
|
|
let tag = data[start..<(start + 3)]
|
|
if tag.elementsEqual([0x54, 0x41, 0x47]) {
|
|
return start
|
|
}
|
|
|
|
return data.count
|
|
}
|
|
}
|
|
|
|
struct SDCardCleaner {
|
|
func clean(url: URL) -> [ExportMessage] {
|
|
guard let dotCleanURL = dotCleanExecutableURL() else {
|
|
return [.error("dot_clean wurde auf diesem Mac nicht gefunden.")]
|
|
}
|
|
|
|
let process = Process()
|
|
process.executableURL = dotCleanURL
|
|
process.arguments = [url.path(percentEncoded: false)]
|
|
|
|
let outputPipe = Pipe()
|
|
let errorPipe = Pipe()
|
|
process.standardOutput = outputPipe
|
|
process.standardError = errorPipe
|
|
|
|
do {
|
|
try process.run()
|
|
process.waitUntilExit()
|
|
} catch {
|
|
return [.error("dot_clean konnte nicht gestartet werden: \(error.localizedDescription)")]
|
|
}
|
|
|
|
let output = outputPipe.readString()
|
|
let errorOutput = errorPipe.readString()
|
|
var messages: [ExportMessage] = []
|
|
|
|
if process.terminationStatus == 0 {
|
|
messages.append(.info("SD-Karte bereinigt: \(url.lastPathComponent)"))
|
|
} else {
|
|
messages.append(.error("dot_clean beendet mit Code \(process.terminationStatus)."))
|
|
}
|
|
|
|
if !output.isEmpty {
|
|
messages.append(.info(output))
|
|
}
|
|
|
|
if !errorOutput.isEmpty {
|
|
messages.append(process.terminationStatus == 0 ? .warning(errorOutput) : .error(errorOutput))
|
|
}
|
|
|
|
return messages
|
|
}
|
|
|
|
private func dotCleanExecutableURL() -> URL? {
|
|
let candidates = [
|
|
"/usr/sbin/dot_clean",
|
|
"/usr/bin/dot_clean"
|
|
]
|
|
|
|
return candidates
|
|
.map(URL.init(fileURLWithPath:))
|
|
.first { FileManager.default.isExecutableFile(atPath: $0.path(percentEncoded: false)) }
|
|
}
|
|
}
|
|
|
|
struct SDCardValidator {
|
|
private let fileManager: FileManager
|
|
|
|
init(fileManager: FileManager) {
|
|
self.fileManager = fileManager
|
|
}
|
|
|
|
func validate(rootURL: URL) -> [ExportMessage] {
|
|
var messages: [ExportMessage] = []
|
|
|
|
do {
|
|
let items = try fileManager.contentsOfDirectory(
|
|
at: rootURL,
|
|
includingPropertiesForKeys: [.isDirectoryKey, .isRegularFileKey, .isHiddenKey],
|
|
options: []
|
|
).sortedByLocalizedName()
|
|
|
|
let visibleItems = items.filter { !$0.lastPathComponent.hasPrefix(".") }
|
|
let metadataItems = items.filter { isMacMetadataFile($0.lastPathComponent) }
|
|
if !metadataItems.isEmpty {
|
|
messages.append(.warning("\(metadataItems.count) macOS-Metadaten-Datei(en) gefunden. dot_clean ausführen."))
|
|
}
|
|
|
|
let numericFolders = visibleItems.filter { url in
|
|
(try? url.resourceValues(forKeys: [.isDirectoryKey]).isDirectory) == true
|
|
&& isNumericTonUinoFolder(url.lastPathComponent)
|
|
}
|
|
|
|
if numericFolders.isEmpty {
|
|
messages.append(.warning("Keine TonUINO-Folgenordner 01 bis 99 gefunden."))
|
|
}
|
|
|
|
for item in visibleItems {
|
|
let values = try item.resourceValues(forKeys: [.isDirectoryKey, .isRegularFileKey])
|
|
let name = item.lastPathComponent
|
|
|
|
if values.isDirectory == true {
|
|
validateRootDirectory(name: name, url: item, messages: &messages)
|
|
} else if values.isRegularFile == true && name != "TonUinoNator-Report.txt" {
|
|
messages.append(.warning("Unerwartete Datei im Hauptordner: \(name)"))
|
|
}
|
|
}
|
|
} catch {
|
|
return [.error("SD-Karte konnte nicht gelesen werden: \(error.localizedDescription)")]
|
|
}
|
|
|
|
if messages.containsErrors {
|
|
messages.insert(.error("Prüfung abgeschlossen: Fehler gefunden."), at: 0)
|
|
} else if messages.containsWarnings {
|
|
messages.insert(.warning("Prüfung abgeschlossen: Warnungen gefunden."), at: 0)
|
|
} else {
|
|
messages.insert(.info("Prüfung abgeschlossen: TonUINO-Struktur sieht gut aus."), at: 0)
|
|
}
|
|
|
|
return messages
|
|
}
|
|
|
|
private func validateRootDirectory(name: String, url: URL, messages: inout [ExportMessage]) {
|
|
if isNumericTonUinoFolder(name) {
|
|
validateEpisodeFolder(url: url, messages: &messages)
|
|
return
|
|
}
|
|
|
|
if name.lowercased() == "mp3" || name.lowercased() == "advert" {
|
|
validateFourDigitFolder(url: url, messages: &messages)
|
|
return
|
|
}
|
|
|
|
messages.append(.warning("Unerwarteter Ordner im Hauptordner: \(name)"))
|
|
}
|
|
|
|
private func validateEpisodeFolder(url: URL, messages: inout [ExportMessage]) {
|
|
do {
|
|
let files = try fileManager.contentsOfDirectory(
|
|
at: url,
|
|
includingPropertiesForKeys: [.isRegularFileKey],
|
|
options: []
|
|
).sortedByLocalizedName()
|
|
|
|
let visibleFiles = files.filter { !$0.lastPathComponent.hasPrefix(".") }
|
|
if visibleFiles.isEmpty {
|
|
messages.append(.warning("\(url.lastPathComponent): leerer Ordner"))
|
|
}
|
|
|
|
for file in files where isMacMetadataFile(file.lastPathComponent) {
|
|
messages.append(.warning("\(url.lastPathComponent): macOS-Metadaten-Datei \(file.lastPathComponent)"))
|
|
}
|
|
|
|
for file in visibleFiles {
|
|
let name = file.lastPathComponent
|
|
let isFile = (try? file.resourceValues(forKeys: [.isRegularFileKey]).isRegularFile) == true
|
|
guard isFile else {
|
|
messages.append(.warning("\(url.lastPathComponent): unerwarteter Unterordner \(name)"))
|
|
continue
|
|
}
|
|
|
|
guard isThreeDigitMP3(name) else {
|
|
messages.append(.error("\(url.lastPathComponent): ungültiger Dateiname \(name), erwartet 001.mp3 bis 255.mp3"))
|
|
continue
|
|
}
|
|
}
|
|
|
|
if visibleFiles.count > 255 {
|
|
messages.append(.error("\(url.lastPathComponent): mehr als 255 Dateien"))
|
|
}
|
|
} catch {
|
|
messages.append(.error("\(url.lastPathComponent): konnte nicht gelesen werden"))
|
|
}
|
|
}
|
|
|
|
private func validateFourDigitFolder(url: URL, messages: inout [ExportMessage]) {
|
|
do {
|
|
let files = try fileManager.contentsOfDirectory(
|
|
at: url,
|
|
includingPropertiesForKeys: [.isRegularFileKey],
|
|
options: []
|
|
).sortedByLocalizedName()
|
|
|
|
for file in files where isMacMetadataFile(file.lastPathComponent) {
|
|
messages.append(.warning("\(url.lastPathComponent): macOS-Metadaten-Datei \(file.lastPathComponent)"))
|
|
}
|
|
|
|
for file in files where !file.lastPathComponent.hasPrefix(".") {
|
|
let name = file.lastPathComponent
|
|
let isFile = (try? file.resourceValues(forKeys: [.isRegularFileKey]).isRegularFile) == true
|
|
guard isFile else {
|
|
messages.append(.warning("\(url.lastPathComponent): unerwarteter Unterordner \(name)"))
|
|
continue
|
|
}
|
|
|
|
if !isFourDigitMP3(name) {
|
|
messages.append(.error("\(url.lastPathComponent): ungültiger Dateiname \(name), erwartet 0001.mp3 bis 9999.mp3"))
|
|
}
|
|
}
|
|
} catch {
|
|
messages.append(.error("\(url.lastPathComponent): konnte nicht gelesen werden"))
|
|
}
|
|
}
|
|
|
|
private func isMacMetadataFile(_ name: String) -> Bool {
|
|
name == ".DS_Store" || name.hasPrefix("._")
|
|
}
|
|
|
|
private func isNumericTonUinoFolder(_ name: String) -> Bool {
|
|
guard name.count == 2, let number = Int(name), number >= 1, number <= 99 else {
|
|
return false
|
|
}
|
|
|
|
return name.allSatisfy(\.isNumber)
|
|
}
|
|
|
|
private func isThreeDigitMP3(_ name: String) -> Bool {
|
|
guard name.lowercased().hasSuffix(".mp3"), name.count >= 7 else { return false }
|
|
let prefix = String(name.prefix(3))
|
|
guard prefix.allSatisfy(\.isNumber), let number = Int(prefix) else {
|
|
return false
|
|
}
|
|
|
|
return number >= 1 && number <= 255
|
|
}
|
|
|
|
private func isFourDigitMP3(_ name: String) -> Bool {
|
|
guard name.lowercased().hasSuffix(".mp3"), name.count >= 8 else { return false }
|
|
let prefix = String(name.prefix(4))
|
|
guard prefix.allSatisfy(\.isNumber), let number = Int(prefix) else {
|
|
return false
|
|
}
|
|
|
|
return number >= 1 && number <= 9999
|
|
}
|
|
}
|
|
|
|
enum ID3TagField: Hashable {
|
|
case title
|
|
case artist
|
|
case album
|
|
case track
|
|
case year
|
|
case genre
|
|
case comment
|
|
case artwork
|
|
|
|
var frameIDs: Set<String> {
|
|
switch self {
|
|
case .title: ["TIT2"]
|
|
case .artist: ["TPE1", "TPE2", "TCOM"]
|
|
case .album: ["TALB"]
|
|
case .track: ["TRCK", "TPOS"]
|
|
case .year: ["TYER", "TDRC", "TDAT", "TIME"]
|
|
case .genre: ["TCON"]
|
|
case .comment: ["COMM"]
|
|
case .artwork: ["APIC", "PIC"]
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ID3TagEditOptions {
|
|
let removeAllTags: Bool
|
|
let fieldsToRemove: Set<ID3TagField>
|
|
let commentToWrite: String?
|
|
|
|
var frameIDsToRemove: Set<String> {
|
|
fieldsToRemove.reduce(into: Set<String>()) { result, field in
|
|
result.formUnion(field.frameIDs)
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ID3TagEditor {
|
|
private let fileManager: FileManager
|
|
|
|
init(fileManager: FileManager) {
|
|
self.fileManager = fileManager
|
|
}
|
|
|
|
func apply(to rootURL: URL, options: ID3TagEditOptions) -> [ExportMessage] {
|
|
do {
|
|
let mp3Files = try MP3FileFinder(fileManager: fileManager).mp3Files(in: rootURL)
|
|
guard !mp3Files.isEmpty else {
|
|
return [.warning("Keine MP3-Dateien gefunden.")]
|
|
}
|
|
|
|
var changed = 0
|
|
var messages: [ExportMessage] = []
|
|
|
|
for file in mp3Files {
|
|
do {
|
|
let didChange = try edit(fileURL: file, options: options)
|
|
if didChange {
|
|
changed += 1
|
|
}
|
|
} catch {
|
|
messages.append(.error("\(file.lastPathComponent): \(error.localizedDescription)"))
|
|
}
|
|
}
|
|
|
|
messages.insert(.info("\(changed) von \(mp3Files.count) MP3-Datei(en) bearbeitet."), at: 0)
|
|
return messages
|
|
} catch {
|
|
return [.error("Ordner konnte nicht gelesen werden: \(error.localizedDescription)")]
|
|
}
|
|
}
|
|
|
|
private func edit(fileURL: URL, options: ID3TagEditOptions) throws -> Bool {
|
|
let original = try Data(contentsOf: fileURL)
|
|
let edited = try ID3TagDataEditor(options: options).edit(data: original)
|
|
|
|
guard edited != original else {
|
|
return false
|
|
}
|
|
|
|
let temporaryURL = fileURL.deletingLastPathComponent()
|
|
.appending(path: ".\(fileURL.lastPathComponent).tmp")
|
|
|
|
if fileManager.fileExists(atPath: temporaryURL.path(percentEncoded: false)) {
|
|
try fileManager.removeItem(at: temporaryURL)
|
|
}
|
|
|
|
try edited.write(to: temporaryURL, options: .atomic)
|
|
try fileManager.removeItem(at: fileURL)
|
|
try fileManager.moveItem(at: temporaryURL, to: fileURL)
|
|
return true
|
|
}
|
|
}
|
|
|
|
struct ID3TagInspector {
|
|
private let fileManager: FileManager
|
|
|
|
init(fileManager: FileManager) {
|
|
self.fileManager = fileManager
|
|
}
|
|
|
|
func inspect(rootURL: URL) -> [ExportMessage] {
|
|
do {
|
|
let mp3Files = try MP3FileFinder(fileManager: fileManager).mp3Files(in: rootURL)
|
|
guard !mp3Files.isEmpty else {
|
|
return [.warning("Keine MP3-Dateien gefunden.")]
|
|
}
|
|
|
|
var messages: [ExportMessage] = [.info("\(mp3Files.count) MP3-Datei(en) gefunden.")]
|
|
|
|
for file in mp3Files {
|
|
do {
|
|
let summary = try inspect(fileURL: file)
|
|
messages.append(.info(summary))
|
|
} catch {
|
|
messages.append(.error("\(file.lastPathComponent): \(error.localizedDescription)"))
|
|
}
|
|
}
|
|
|
|
return messages
|
|
} catch {
|
|
return [.error("Ordner konnte nicht gelesen werden: \(error.localizedDescription)")]
|
|
}
|
|
}
|
|
|
|
private func inspect(fileURL: URL) throws -> String {
|
|
let data = try Data(contentsOf: fileURL)
|
|
let id3v2 = ID3v2Tag(data: data)
|
|
let id3v1 = ID3v1Tag(data: data)
|
|
|
|
var parts: [String] = [fileURL.lastPathComponent]
|
|
|
|
if let id3v2 {
|
|
parts.append("ID3v2.\(id3v2.majorVersion)")
|
|
let values = ID3ReadableTags(frames: id3v2.frames)
|
|
parts.append(contentsOf: values.summaryParts)
|
|
}
|
|
|
|
if let id3v1 {
|
|
parts.append("ID3v1")
|
|
parts.append(contentsOf: id3v1.summaryParts)
|
|
}
|
|
|
|
if parts.count == 1 {
|
|
parts.append("keine ID3-Tags")
|
|
}
|
|
|
|
return parts.joined(separator: " | ")
|
|
}
|
|
}
|
|
|
|
struct ID3TagSearcher {
|
|
private let fileManager: FileManager
|
|
|
|
init(fileManager: FileManager) {
|
|
self.fileManager = fileManager
|
|
}
|
|
|
|
func search(rootURL: URL, query: String) -> [ExportMessage] {
|
|
let normalizedQuery = query.folding(options: [.caseInsensitive, .diacriticInsensitive], locale: .current)
|
|
|
|
do {
|
|
let mp3Files = try MP3FileFinder(fileManager: fileManager).mp3Files(in: rootURL)
|
|
guard !mp3Files.isEmpty else {
|
|
return [.warning("Keine MP3-Dateien gefunden.")]
|
|
}
|
|
|
|
var matches: [ExportMessage] = []
|
|
|
|
for file in mp3Files {
|
|
do {
|
|
let searchableValues = try searchableTags(in: file)
|
|
let matchingValues = searchableValues.filter { value in
|
|
value.text.folding(options: [.caseInsensitive, .diacriticInsensitive], locale: .current)
|
|
.contains(normalizedQuery)
|
|
}
|
|
|
|
if !matchingValues.isEmpty {
|
|
let fields = matchingValues
|
|
.map { "\($0.label): \($0.text)" }
|
|
.joined(separator: " | ")
|
|
matches.append(.info("\(fields) | Datei: \(file.lastPathComponent) | Ordner: \(file.deletingLastPathComponent().path(percentEncoded: false))"))
|
|
}
|
|
} catch {
|
|
matches.append(.error("\(file.lastPathComponent): \(error.localizedDescription)"))
|
|
}
|
|
}
|
|
|
|
if matches.isEmpty {
|
|
return [.warning("Keine Titel, Alben oder Künstler gefunden für: \(query)")]
|
|
}
|
|
|
|
matches.insert(.info("\(matches.count) Treffer für: \(query)"), at: 0)
|
|
return matches
|
|
} catch {
|
|
return [.error("Ordner konnte nicht gelesen werden: \(error.localizedDescription)")]
|
|
}
|
|
}
|
|
|
|
private func searchableTags(in fileURL: URL) throws -> [(label: String, text: String)] {
|
|
let data = try Data(contentsOf: fileURL)
|
|
var values: [(label: String, text: String)] = []
|
|
|
|
if let id3v2 = ID3v2Tag(data: data) {
|
|
let readableTags = ID3ReadableTags(frames: id3v2.frames)
|
|
values.append(contentsOf: readableTags.searchableValues)
|
|
}
|
|
|
|
if let id3v1 = ID3v1Tag(data: data) {
|
|
if !id3v1.title.isEmpty {
|
|
values.append(("Titel", id3v1.title))
|
|
}
|
|
if !id3v1.album.isEmpty {
|
|
values.append(("Album", id3v1.album))
|
|
}
|
|
if !id3v1.artist.isEmpty {
|
|
values.append(("Künstler", id3v1.artist))
|
|
}
|
|
}
|
|
|
|
return values
|
|
}
|
|
}
|
|
|
|
private struct MP3FileFinder {
|
|
let fileManager: FileManager
|
|
|
|
func mp3Files(in rootURL: URL) throws -> [URL] {
|
|
let values = try rootURL.resourceValues(forKeys: [.isDirectoryKey, .isRegularFileKey])
|
|
|
|
if values.isRegularFile == true {
|
|
return rootURL.pathExtension.lowercased() == "mp3" ? [rootURL] : []
|
|
}
|
|
|
|
guard values.isDirectory == true else {
|
|
return []
|
|
}
|
|
|
|
guard let enumerator = fileManager.enumerator(
|
|
at: rootURL,
|
|
includingPropertiesForKeys: [.isRegularFileKey, .isHiddenKey],
|
|
options: [.skipsHiddenFiles]
|
|
) else {
|
|
return []
|
|
}
|
|
|
|
return enumerator.compactMap { item in
|
|
guard let url = item as? URL, url.pathExtension.lowercased() == "mp3" else {
|
|
return nil
|
|
}
|
|
|
|
let isFile = (try? url.resourceValues(forKeys: [.isRegularFileKey]).isRegularFile) == true
|
|
return isFile ? url : nil
|
|
}
|
|
.sortedByLocalizedName()
|
|
}
|
|
}
|
|
|
|
private struct ID3TagDataEditor {
|
|
enum EditError: LocalizedError {
|
|
case unsupportedID3Version(Int)
|
|
|
|
var errorDescription: String? {
|
|
switch self {
|
|
case .unsupportedID3Version(let version):
|
|
"ID3v2.\(version) wird nicht unterstützt."
|
|
}
|
|
}
|
|
}
|
|
|
|
let options: ID3TagEditOptions
|
|
|
|
func edit(data: Data) throws -> Data {
|
|
let id3v2 = ID3v2Tag(data: data)
|
|
let audioStart = id3v2?.endOffset ?? 0
|
|
let audioEnd = id3v1StartOffset(in: data)
|
|
let audioData = data.subdata(in: audioStart..<max(audioStart, audioEnd))
|
|
|
|
if options.removeAllTags {
|
|
let frames = options.commentToWrite.map { [ID3Frame.comment(text: $0, majorVersion: 3)] } ?? []
|
|
return buildData(frames: frames, audioData: audioData, majorVersion: 3)
|
|
}
|
|
|
|
let majorVersion = id3v2?.majorVersion ?? 3
|
|
guard majorVersion == 3 || majorVersion == 4 else {
|
|
throw EditError.unsupportedID3Version(majorVersion)
|
|
}
|
|
|
|
var frames = id3v2?.frames ?? []
|
|
let frameIDsToRemove = options.frameIDsToRemove
|
|
frames.removeAll { frameIDsToRemove.contains($0.id) }
|
|
|
|
if let comment = options.commentToWrite, !comment.isEmpty {
|
|
frames.removeAll { $0.id == "COMM" }
|
|
frames.append(.comment(text: comment, majorVersion: majorVersion))
|
|
}
|
|
|
|
if frames.isEmpty {
|
|
return audioData
|
|
}
|
|
|
|
return buildData(frames: frames, audioData: audioData, majorVersion: majorVersion)
|
|
}
|
|
|
|
private func buildData(frames: [ID3Frame], audioData: Data, majorVersion: Int) -> Data {
|
|
guard !frames.isEmpty else {
|
|
return audioData
|
|
}
|
|
|
|
var frameData = Data()
|
|
for frame in frames {
|
|
frameData.append(frame.encoded(majorVersion: majorVersion))
|
|
}
|
|
|
|
var result = Data()
|
|
result.append(contentsOf: [0x49, 0x44, 0x33])
|
|
result.append(UInt8(majorVersion))
|
|
result.append(0x00)
|
|
result.append(0x00)
|
|
result.append(contentsOf: syncsafeBytes(frameData.count))
|
|
result.append(frameData)
|
|
result.append(audioData)
|
|
return result
|
|
}
|
|
|
|
private func id3v1StartOffset(in data: Data) -> Int {
|
|
guard data.count >= 128 else { return data.count }
|
|
|
|
let start = data.count - 128
|
|
let tag = data[start..<(start + 3)]
|
|
return tag.elementsEqual([0x54, 0x41, 0x47]) ? start : data.count
|
|
}
|
|
}
|
|
|
|
private struct ID3v2Tag {
|
|
let majorVersion: Int
|
|
let endOffset: Int
|
|
let frames: [ID3Frame]
|
|
|
|
init?(data: Data) {
|
|
guard data.count >= 10 else { return nil }
|
|
|
|
let header = [UInt8](data.prefix(10))
|
|
guard header[0] == 0x49, header[1] == 0x44, header[2] == 0x33 else {
|
|
return nil
|
|
}
|
|
|
|
majorVersion = Int(header[3])
|
|
let size = syncsafeInteger(header[6...9])
|
|
let footerSize = (header[5] & 0x10) == 0x10 ? 10 : 0
|
|
endOffset = min(data.count, 10 + size + footerSize)
|
|
|
|
guard majorVersion == 3 || majorVersion == 4, endOffset >= 10 else {
|
|
frames = []
|
|
return
|
|
}
|
|
|
|
frames = ID3Frame.parseFrames(
|
|
data: data.subdata(in: 10..<endOffset),
|
|
majorVersion: majorVersion
|
|
)
|
|
}
|
|
}
|
|
|
|
private struct ID3Frame {
|
|
let id: String
|
|
let payload: Data
|
|
let flags: [UInt8]
|
|
|
|
static func parseFrames(data: Data, majorVersion: Int) -> [ID3Frame] {
|
|
var frames: [ID3Frame] = []
|
|
var offset = 0
|
|
|
|
while offset + 10 <= data.count {
|
|
let header = [UInt8](data[offset..<(offset + 10)])
|
|
if header[0] == 0 {
|
|
break
|
|
}
|
|
|
|
guard let id = String(bytes: header[0..<4], encoding: .ascii),
|
|
id.allSatisfy({ $0.isLetter || $0.isNumber }) else {
|
|
break
|
|
}
|
|
|
|
let size: Int
|
|
if majorVersion == 4 {
|
|
size = syncsafeInteger(header[4...7])
|
|
} else {
|
|
size = bigEndianInteger(header[4...7])
|
|
}
|
|
|
|
guard size >= 0, offset + 10 + size <= data.count else {
|
|
break
|
|
}
|
|
|
|
let payload = data.subdata(in: (offset + 10)..<(offset + 10 + size))
|
|
frames.append(ID3Frame(id: id, payload: payload, flags: Array(header[8...9])))
|
|
offset += 10 + size
|
|
}
|
|
|
|
return frames
|
|
}
|
|
|
|
static func comment(text: String, majorVersion: Int) -> ID3Frame {
|
|
var payload = Data()
|
|
payload.append(0x03)
|
|
payload.append(contentsOf: [0x64, 0x65, 0x75])
|
|
payload.append(0x00)
|
|
payload.append(Data(text.utf8))
|
|
return ID3Frame(id: "COMM", payload: payload, flags: [0x00, 0x00])
|
|
}
|
|
|
|
func encoded(majorVersion: Int) -> Data {
|
|
var data = Data()
|
|
data.append(Data(id.utf8.prefix(4)))
|
|
if majorVersion == 4 {
|
|
data.append(contentsOf: syncsafeBytes(payload.count))
|
|
} else {
|
|
data.append(contentsOf: bigEndianBytes(payload.count))
|
|
}
|
|
data.append(contentsOf: flags.prefix(2))
|
|
if flags.count < 2 {
|
|
data.append(contentsOf: Array(repeating: UInt8(0), count: 2 - flags.count))
|
|
}
|
|
data.append(payload)
|
|
return data
|
|
}
|
|
}
|
|
|
|
private struct ID3ReadableTags {
|
|
let frames: [ID3Frame]
|
|
|
|
var searchableValues: [(label: String, text: String)] {
|
|
var values: [(label: String, text: String)] = []
|
|
appendSearchValue("Titel", ids: ["TIT2"], to: &values)
|
|
appendSearchValue("Album", ids: ["TALB"], to: &values)
|
|
appendSearchValue("Künstler", ids: ["TPE1", "TPE2", "TCOM"], to: &values)
|
|
return values
|
|
}
|
|
|
|
var summaryParts: [String] {
|
|
var parts: [String] = []
|
|
|
|
appendText("Titel", ids: ["TIT2"], to: &parts)
|
|
appendText("Interpret", ids: ["TPE1"], to: &parts)
|
|
appendText("Album", ids: ["TALB"], to: &parts)
|
|
appendText("Track", ids: ["TRCK"], to: &parts)
|
|
appendText("Jahr", ids: ["TDRC", "TYER"], to: &parts)
|
|
appendText("Genre", ids: ["TCON"], to: &parts)
|
|
appendComment(to: &parts)
|
|
appendArtwork(to: &parts)
|
|
|
|
let shownIDs = Set(["TIT2", "TPE1", "TALB", "TRCK", "TDRC", "TYER", "TCON", "COMM", "APIC", "PIC"])
|
|
let otherCount = frames.filter { !shownIDs.contains($0.id) }.count
|
|
if otherCount > 0 {
|
|
parts.append("\(otherCount) weitere Frame(s)")
|
|
}
|
|
|
|
if parts.isEmpty && !frames.isEmpty {
|
|
parts.append("\(frames.count) nicht lesbare Frame(s)")
|
|
}
|
|
|
|
return parts
|
|
}
|
|
|
|
private func appendText(_ label: String, ids: Set<String>, to parts: inout [String]) {
|
|
guard let text = textValue(ids: ids), !text.isEmpty else {
|
|
return
|
|
}
|
|
|
|
parts.append("\(label): \(text)")
|
|
}
|
|
|
|
private func textValue(ids: Set<String>) -> String? {
|
|
frames.first(where: { ids.contains($0.id) })?.textValue
|
|
}
|
|
|
|
private func appendSearchValue(_ label: String, ids: Set<String>, to values: inout [(label: String, text: String)]) {
|
|
guard let text = textValue(ids: ids), !text.isEmpty else {
|
|
return
|
|
}
|
|
|
|
values.append((label, text))
|
|
}
|
|
|
|
private func appendComment(to parts: inout [String]) {
|
|
guard let comment = frames.first(where: { $0.id == "COMM" })?.commentValue, !comment.isEmpty else {
|
|
return
|
|
}
|
|
|
|
parts.append("Kommentar: \(comment)")
|
|
}
|
|
|
|
private func appendArtwork(to parts: inout [String]) {
|
|
let artworkCount = frames.filter { $0.id == "APIC" || $0.id == "PIC" }.count
|
|
guard artworkCount > 0 else {
|
|
return
|
|
}
|
|
|
|
parts.append("\(artworkCount) eingebettete(s) Bild(er)")
|
|
}
|
|
}
|
|
|
|
private struct ID3v1Tag {
|
|
let title: String
|
|
let artist: String
|
|
let album: String
|
|
let year: String
|
|
let comment: String
|
|
let track: UInt8?
|
|
let genre: UInt8
|
|
|
|
init?(data: Data) {
|
|
guard data.count >= 128 else { return nil }
|
|
|
|
let start = data.count - 128
|
|
let tag = data[start..<(start + 3)]
|
|
guard tag.elementsEqual([0x54, 0x41, 0x47]) else {
|
|
return nil
|
|
}
|
|
|
|
title = ID3v1Tag.trimmedString(data[(start + 3)..<(start + 33)])
|
|
artist = ID3v1Tag.trimmedString(data[(start + 33)..<(start + 63)])
|
|
album = ID3v1Tag.trimmedString(data[(start + 63)..<(start + 93)])
|
|
year = ID3v1Tag.trimmedString(data[(start + 93)..<(start + 97)])
|
|
|
|
let commentRange = data[(start + 97)..<(start + 127)]
|
|
let commentBytes = [UInt8](commentRange)
|
|
if commentBytes.count == 30, commentBytes[28] == 0, commentBytes[29] != 0 {
|
|
comment = ID3v1Tag.trimmedString(commentRange.dropLast(2))
|
|
track = commentBytes[29]
|
|
} else {
|
|
comment = ID3v1Tag.trimmedString(commentRange)
|
|
track = nil
|
|
}
|
|
|
|
genre = data[start + 127]
|
|
}
|
|
|
|
var summaryParts: [String] {
|
|
var parts: [String] = []
|
|
if !title.isEmpty { parts.append("Titel: \(title)") }
|
|
if !artist.isEmpty { parts.append("Interpret: \(artist)") }
|
|
if !album.isEmpty { parts.append("Album: \(album)") }
|
|
if !year.isEmpty { parts.append("Jahr: \(year)") }
|
|
if !comment.isEmpty { parts.append("Kommentar: \(comment)") }
|
|
if let track { parts.append("Track: \(track)") }
|
|
return parts
|
|
}
|
|
|
|
private static func trimmedString<S: Sequence>(_ bytes: S) -> String where S.Element == UInt8 {
|
|
let data = Data(bytes)
|
|
return (String(data: data, encoding: .isoLatin1) ?? "")
|
|
.trimmingCharacters(in: CharacterSet(charactersIn: "\0 ").union(.newlines))
|
|
}
|
|
}
|
|
|
|
private extension ID3Frame {
|
|
var textValue: String? {
|
|
guard payload.count >= 1 else { return nil }
|
|
return decodeID3Text(payload.dropFirst())
|
|
}
|
|
|
|
var commentValue: String? {
|
|
guard payload.count >= 4 else { return nil }
|
|
|
|
let body = payload.dropFirst(4)
|
|
let bytes = [UInt8](body)
|
|
let textStart: Int
|
|
if let zeroIndex = bytes.firstIndex(of: 0) {
|
|
textStart = zeroIndex + 1
|
|
} else {
|
|
textStart = 0
|
|
}
|
|
|
|
guard textStart <= bytes.count else { return nil }
|
|
return decodeID3Text(bytes[textStart...])
|
|
}
|
|
|
|
private func decodeID3Text<S: Sequence>(_ bytes: S) -> String? where S.Element == UInt8 {
|
|
guard let encodingByte = payload.first else { return nil }
|
|
let data = Data(bytes)
|
|
|
|
switch encodingByte {
|
|
case 0x00:
|
|
return String(data: data, encoding: .isoLatin1)?.trimmedForID3
|
|
case 0x01:
|
|
return String(data: data, encoding: .utf16)?.trimmedForID3
|
|
case 0x02:
|
|
return String(data: data, encoding: .utf16BigEndian)?.trimmedForID3
|
|
case 0x03:
|
|
return String(data: data, encoding: .utf8)?.trimmedForID3
|
|
default:
|
|
return String(data: data, encoding: .utf8)?.trimmedForID3
|
|
}
|
|
}
|
|
}
|
|
|
|
private extension String {
|
|
var trimmedForID3: String {
|
|
trimmingCharacters(in: CharacterSet(charactersIn: "\0 ").union(.newlines))
|
|
}
|
|
}
|
|
|
|
private func syncsafeInteger<S: Sequence>(_ bytes: S) -> Int where S.Element == UInt8 {
|
|
bytes.reduce(0) { ($0 << 7) | Int($1 & 0x7F) }
|
|
}
|
|
|
|
private func bigEndianInteger<S: Sequence>(_ bytes: S) -> Int where S.Element == UInt8 {
|
|
bytes.reduce(0) { ($0 << 8) | Int($1) }
|
|
}
|
|
|
|
private func syncsafeBytes(_ value: Int) -> [UInt8] {
|
|
[
|
|
UInt8((value >> 21) & 0x7F),
|
|
UInt8((value >> 14) & 0x7F),
|
|
UInt8((value >> 7) & 0x7F),
|
|
UInt8(value & 0x7F)
|
|
]
|
|
}
|
|
|
|
private func bigEndianBytes(_ value: Int) -> [UInt8] {
|
|
[
|
|
UInt8((value >> 24) & 0xFF),
|
|
UInt8((value >> 16) & 0xFF),
|
|
UInt8((value >> 8) & 0xFF),
|
|
UInt8(value & 0xFF)
|
|
]
|
|
}
|
|
|
|
private extension Pipe {
|
|
func readString() -> String {
|
|
let data = fileHandleForReading.readDataToEndOfFile()
|
|
return String(data: data, encoding: .utf8)?
|
|
.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
|
|
}
|
|
}
|
|
|
|
private extension DateFormatter {
|
|
static let reportDateTime: DateFormatter = {
|
|
let formatter = DateFormatter()
|
|
formatter.dateStyle = .medium
|
|
formatter.timeStyle = .medium
|
|
return formatter
|
|
}()
|
|
}
|
|
|
|
private extension Array where Element == ExportMessage {
|
|
var containsErrors: Bool {
|
|
contains { $0.kind == .error }
|
|
}
|
|
|
|
var containsWarnings: Bool {
|
|
contains { $0.kind == .warning }
|
|
}
|
|
}
|
|
|
|
private extension Array where Element == URL {
|
|
func sortedByLocalizedName() -> [URL] {
|
|
sorted {
|
|
$0.lastPathComponent.localizedStandardCompare($1.lastPathComponent) == .orderedAscending
|
|
}
|
|
}
|
|
}
|