253 lines
14 KiB
Swift
253 lines
14 KiB
Swift
import Foundation
|
|
|
|
struct TrackMetadata: Sendable {
|
|
var title = ""
|
|
var artist = ""
|
|
var album = ""
|
|
var albumArtist = ""
|
|
var trackNumber = ""
|
|
var discNumber = ""
|
|
var year = ""
|
|
var genre = ""
|
|
var acoustID = ""
|
|
var musicBrainzRecordingID = ""
|
|
var musicBrainzReleaseID = ""
|
|
}
|
|
|
|
enum ID3Metadata {
|
|
private static let standardFrames: [String: WritableKeyPath<TrackMetadata, String>] = [
|
|
"TIT2": \.title, "TPE1": \.artist, "TALB": \.album, "TPE2": \.albumArtist,
|
|
"TRCK": \.trackNumber, "TPOS": \.discNumber, "TDRC": \.year, "TYER": \.year, "TCON": \.genre
|
|
]
|
|
private static let managedFrames = Set(standardFrames.keys)
|
|
private static let managedUserTexts: [String: WritableKeyPath<TrackMetadata, String>] = [
|
|
"Acoustid Id": \.acoustID,
|
|
"MusicBrainz Recording Id": \.musicBrainzRecordingID,
|
|
"MusicBrainz Album Id": \.musicBrainzReleaseID
|
|
]
|
|
private static let v22FrameIDs: [String: String] = [
|
|
"BUF": "RBUF", "CNT": "PCNT", "COM": "COMM", "CRA": "AENC", "ETC": "ETCO", "GEO": "GEOB",
|
|
"IPL": "TIPL", "MCI": "MCDI", "MLL": "MLLT", "PIC": "APIC", "POP": "POPM", "REV": "RVRB",
|
|
"RVA": "RVAD", "SLT": "SYLT", "STC": "SYTC", "TAL": "TALB", "TBP": "TBPM", "TCM": "TCOM",
|
|
"TCO": "TCON", "TCR": "TCOP", "TDA": "TDAT", "TDY": "TDLY", "TEN": "TENC", "TFT": "TFLT",
|
|
"TIM": "TIME", "TKE": "TKEY", "TLA": "TLAN", "TLE": "TLEN", "TMT": "TMED", "TOA": "TOPE",
|
|
"TOF": "TOFN", "TOL": "TOLY", "TOR": "TORY", "TOT": "TOAL", "TP1": "TPE1", "TP2": "TPE2",
|
|
"TP3": "TPE3", "TP4": "TPE4", "TPA": "TPOS", "TPB": "TPUB", "TRC": "TSRC", "TRD": "TRDA",
|
|
"TRK": "TRCK", "TSI": "TSIZ", "TSS": "TSSE", "TT1": "TIT1", "TT2": "TIT2", "TT3": "TIT3",
|
|
"TXT": "TEXT", "TXX": "TXXX", "TYE": "TYER", "UFI": "UFID", "ULT": "USLT", "WAF": "WOAF",
|
|
"WAM": "WOAM", "WAS": "WOAS", "WCM": "WCOM", "WCP": "WCOP", "WPB": "WPUB", "WXX": "WXXX"
|
|
]
|
|
|
|
static func read(_ url: URL) -> TrackMetadata {
|
|
guard let handle = try? FileHandle(forReadingFrom: url) else { return TrackMetadata() }
|
|
defer { try? handle.close() }
|
|
guard let header = try? handle.read(upToCount: 10), header.count == 10,
|
|
String(data: header.prefix(3), encoding: .ascii) == "ID3" else { return TrackMetadata() }
|
|
let tagSize = syncSafe(header[6..<10])
|
|
guard tagSize > 0, let tagBody = try? handle.read(upToCount: tagSize) else { return TrackMetadata() }
|
|
var data = header
|
|
data.append(tagBody)
|
|
let version = header[3]
|
|
let limit = min(data.count, 10 + syncSafe(data[6..<10]))
|
|
var position = 10
|
|
var result = TrackMetadata()
|
|
if version == 2 {
|
|
guard header[5] & 0x40 == 0 else { return result }
|
|
while position + 6 <= limit {
|
|
guard let oldID = String(data: data[position..<position + 3], encoding: .ascii), oldID.utf8.allSatisfy({ $0 >= 0x20 && $0 <= 0x5A }), oldID != "\0\0\0" else { break }
|
|
let size = int24(data[position + 3..<position + 6]); position += 6
|
|
guard size > 0, position + size <= limit else { break }
|
|
let id = v22FrameIDs[oldID] ?? oldID
|
|
let frame = data[position..<position + size]
|
|
if let keyPath = standardFrames[id], let value = decodeText(frame) { result[keyPath: keyPath] = id == "TCON" ? normalizeGenre(value) : value }
|
|
if id == "TXXX", let (description, value) = decodeUserText(frame), let keyPath = managedUserTexts[description] { result[keyPath: keyPath] = value }
|
|
position += size
|
|
}
|
|
} else {
|
|
while position + 10 <= limit {
|
|
guard let id = String(data: data[position..<position + 4], encoding: .ascii), id.utf8.allSatisfy({ $0 >= 0x20 && $0 <= 0x5A }), id != "\0\0\0\0" else { break }
|
|
let size = version == 4 ? syncSafe(data[position + 4..<position + 8]) : int32(data[position + 4..<position + 8]); position += 10
|
|
guard size > 0, position + size <= limit else { break }
|
|
let frame = data[position..<position + size]
|
|
if let keyPath = standardFrames[id], let value = decodeText(frame) { result[keyPath: keyPath] = id == "TCON" ? normalizeGenre(value) : value }
|
|
if id == "TXXX", let (description, value) = decodeUserText(frame), let keyPath = managedUserTexts[description] { result[keyPath: keyPath] = value }
|
|
position += size
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
static func write(_ metadata: TrackMetadata, to url: URL) throws {
|
|
let original = try Data(contentsOf: url)
|
|
var audio = original
|
|
var frames = Data()
|
|
if original.count >= 10, String(data: original.prefix(3), encoding: .ascii) == "ID3" {
|
|
let version = original[3]
|
|
let end = min(original.count, 10 + syncSafe(original[6..<10]))
|
|
audio = original.subdata(in: end..<original.count)
|
|
if version == 2 {
|
|
guard original[5] & 0x40 == 0 else { throw ID3MetadataError.unsupportedCompressedV22 }
|
|
var index = 10
|
|
while index + 6 <= end {
|
|
guard let oldID = String(data: original[index..<index + 3], encoding: .ascii), oldID.utf8.allSatisfy({ $0 >= 0x20 && $0 <= 0x5A }), oldID != "\0\0\0" else { break }
|
|
let size = int24(original[index + 3..<index + 6]); index += 6
|
|
guard size > 0, index + size <= end else { break }
|
|
let oldFrame = original[index..<index + size]
|
|
if let frameID = v22FrameIDs[oldID] {
|
|
let frame = frameID == "APIC" ? convertV22Picture(oldFrame) ?? Data() : Data(oldFrame)
|
|
let shouldReplace = managedFrames.contains(frameID) || (frameID == "TXXX" && decodeUserText(frame).map { managedUserTexts[$0.0] != nil } == true)
|
|
if !shouldReplace, !frame.isEmpty { appendFrame(id: frameID, content: frame, to: &frames) }
|
|
}
|
|
index += size
|
|
}
|
|
} else {
|
|
var index = 10
|
|
while index + 10 <= end {
|
|
guard let frameID = String(data: original[index..<index + 4], encoding: .ascii) else { break }
|
|
let size = version == 4 ? syncSafe(original[index + 4..<index + 8]) : int32(original[index + 4..<index + 8])
|
|
guard size > 0, index + 10 + size <= end else { break }
|
|
let frame = original[index + 10..<index + 10 + size]
|
|
let shouldReplace = managedFrames.contains(frameID) || (frameID == "TXXX" && decodeUserText(frame).map { managedUserTexts[$0.0] != nil } == true)
|
|
if !shouldReplace { appendFrame(id: frameID, content: Data(frame), to: &frames) }
|
|
index += 10 + size
|
|
}
|
|
}
|
|
}
|
|
for (id, keyPath) in standardFrames {
|
|
let value = metadata[keyPath: keyPath]
|
|
guard !value.isEmpty else { continue }
|
|
appendFrame(id: id, content: encodeV23Text(value), to: &frames)
|
|
}
|
|
for (description, keyPath) in managedUserTexts {
|
|
let value = metadata[keyPath: keyPath]
|
|
guard !value.isEmpty else { continue }
|
|
let content = Data([1, 0xFF, 0xFE]) + utf16LE(description) + Data([0, 0, 0xFF, 0xFE]) + utf16LE(value)
|
|
appendFrame(id: "TXXX", content: content, to: &frames)
|
|
}
|
|
var tag = Data("ID3".utf8)
|
|
tag.append(contentsOf: [3, 0, 0]); tag.append(contentsOf: syncSafeBytes(frames.count)); tag.append(frames); tag.append(audio)
|
|
try tag.write(to: url, options: .atomic)
|
|
}
|
|
|
|
static func verify(_ expected: TrackMetadata, at url: URL) throws {
|
|
let actual = read(url)
|
|
guard actual.title == expected.title,
|
|
actual.artist == expected.artist,
|
|
actual.album == expected.album,
|
|
actual.albumArtist == expected.albumArtist,
|
|
actual.trackNumber == expected.trackNumber,
|
|
actual.discNumber == expected.discNumber,
|
|
actual.year == expected.year,
|
|
actual.genre == expected.genre,
|
|
actual.acoustID == expected.acoustID,
|
|
actual.musicBrainzRecordingID == expected.musicBrainzRecordingID,
|
|
actual.musicBrainzReleaseID == expected.musicBrainzReleaseID else {
|
|
throw ID3MetadataError.verificationFailed(url.lastPathComponent)
|
|
}
|
|
}
|
|
|
|
private static func decodeText<S: DataProtocol>(_ data: S) -> String? {
|
|
guard let encoding = data.first else { return nil }
|
|
let value = Data(data.dropFirst())
|
|
let decoded: String?
|
|
switch encoding {
|
|
case 0: decoded = String(data: value, encoding: .isoLatin1)
|
|
case 1: decoded = String(data: value, encoding: .utf16)
|
|
case 2: decoded = String(data: value, encoding: .utf16BigEndian)
|
|
default: decoded = String(data: value, encoding: .utf8)
|
|
}
|
|
return decoded?.trimmingCharacters(in: .controlCharacters)
|
|
}
|
|
|
|
private static func decodeUserText<S: DataProtocol>(_ data: S) -> (String, String)? {
|
|
guard let encoding = data.first else { return nil }
|
|
let value = Data(data.dropFirst())
|
|
let separatorStart: Int
|
|
let separatorLength: Int
|
|
if encoding == 1 || encoding == 2 {
|
|
let start = value.starts(with: [0xFF, 0xFE]) || value.starts(with: [0xFE, 0xFF]) ? 2 : 0
|
|
var cursor = start
|
|
var found: Int?
|
|
while cursor + 1 < value.count {
|
|
if value[cursor] == 0 && value[cursor + 1] == 0 { found = cursor; break }
|
|
cursor += 2
|
|
}
|
|
guard let found else { return nil }
|
|
separatorStart = found; separatorLength = 2
|
|
} else {
|
|
guard let found = value.firstIndex(of: 0) else { return nil }
|
|
separatorStart = found; separatorLength = 1
|
|
}
|
|
let description = decodeEncoded(value[..<separatorStart], encoding: encoding)
|
|
let text = decodeEncoded(value[(separatorStart + separatorLength)...], encoding: encoding)
|
|
return (description, text)
|
|
}
|
|
|
|
private static func decodeEncoded<S: DataProtocol>(_ data: S, encoding: UInt8) -> String {
|
|
let value = Data(data)
|
|
switch encoding {
|
|
case 0: return String(data: value, encoding: .isoLatin1) ?? ""
|
|
case 1: return String(data: value, encoding: .utf16) ?? ""
|
|
case 2: return String(data: value, encoding: .utf16BigEndian) ?? ""
|
|
default: return String(data: value, encoding: .utf8) ?? ""
|
|
}
|
|
}
|
|
|
|
private static func encodeV23Text(_ value: String) -> Data { Data([1, 0xFF, 0xFE]) + utf16LE(value) }
|
|
|
|
private static func normalizeGenre(_ value: String) -> String {
|
|
let genres = [
|
|
"Blues", "Classic Rock", "Country", "Dance", "Disco", "Funk", "Grunge", "Hip-Hop", "Jazz", "Metal",
|
|
"New Age", "Oldies", "Other", "Pop", "R&B", "Rap", "Reggae", "Rock", "Techno", "Industrial",
|
|
"Alternative", "Ska", "Death Metal", "Pranks", "Soundtrack", "Euro-Techno", "Ambient", "Trip-Hop", "Vocal", "Jazz+Funk",
|
|
"Fusion", "Trance", "Classical", "Instrumental", "Acid", "House", "Game", "Sound Clip", "Gospel", "Noise",
|
|
"AlternRock", "Bass", "Soul", "Punk", "Space", "Meditative", "Instrumental Pop", "Instrumental Rock", "Ethnic", "Gothic",
|
|
"Darkwave", "Techno-Industrial", "Electronic", "Pop-Folk", "Eurodance", "Dream", "Southern Rock", "Comedy", "Cult", "Gangsta",
|
|
"Top 40", "Christian Rap", "Pop/Funk", "Jungle", "Native American", "Cabaret", "New Wave", "Psychedelic", "Rave", "Showtunes",
|
|
"Trailer", "Lo-Fi", "Tribal", "Acid Punk", "Acid Jazz", "Polka", "Retro", "Musical", "Rock & Roll", "Hard Rock"
|
|
]
|
|
let trimmed = value.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let pattern = #"^\((\d{1,3})\)\s*"#
|
|
if let range = trimmed.range(of: pattern, options: .regularExpression),
|
|
let numberRange = trimmed.range(of: #"\d{1,3}"#, options: .regularExpression),
|
|
let index = Int(trimmed[numberRange]), genres.indices.contains(index) {
|
|
let suffix = String(trimmed[range.upperBound...]).trimmingCharacters(in: .whitespaces)
|
|
return suffix.isEmpty ? genres[index] : suffix
|
|
}
|
|
if let index = Int(trimmed), genres.indices.contains(index) { return genres[index] }
|
|
return value
|
|
}
|
|
|
|
private static func convertV22Picture<S: DataProtocol>(_ frame: S) -> Data? {
|
|
let bytes = Data(frame)
|
|
guard bytes.count > 5, let format = String(data: bytes[1..<4], encoding: .ascii) else { return nil }
|
|
let normalized = format.uppercased()
|
|
let mime = normalized == "JPG" || normalized == "JPEG" ? "image/jpeg" : "image/\(normalized.lowercased())"
|
|
return Data([bytes[0]]) + Data(mime.utf8) + Data([0]) + bytes[4...]
|
|
}
|
|
private static func utf16LE(_ value: String) -> Data {
|
|
var data = Data(capacity: value.utf16.count * 2)
|
|
for unit in value.utf16 { data.append(UInt8(unit & 0xFF)); data.append(UInt8(unit >> 8)) }
|
|
return data
|
|
}
|
|
|
|
private static func appendFrame(id: String, content: Data, to frames: inout Data) {
|
|
frames.append(Data(id.utf8)); frames.append(contentsOf: [UInt8((content.count >> 24) & 255), UInt8((content.count >> 16) & 255), UInt8((content.count >> 8) & 255), UInt8(content.count & 255), 0, 0]); frames.append(content)
|
|
}
|
|
private static func int32<S: Collection>(_ bytes: S) -> Int where S.Element == UInt8 { bytes.reduce(0) { ($0 << 8) | Int($1) } }
|
|
private static func int24<S: Collection>(_ bytes: S) -> Int where S.Element == UInt8 { bytes.reduce(0) { ($0 << 8) | Int($1) } }
|
|
private static func syncSafe<S: Collection>(_ bytes: S) -> Int where S.Element == UInt8 { bytes.reduce(0) { ($0 << 7) | Int($1 & 0x7f) } }
|
|
private static func syncSafeBytes(_ number: Int) -> [UInt8] { [UInt8((number >> 21) & 0x7f), UInt8((number >> 14) & 0x7f), UInt8((number >> 7) & 0x7f), UInt8(number & 0x7f)] }
|
|
}
|
|
|
|
enum ID3MetadataError: LocalizedError {
|
|
case verificationFailed(String)
|
|
case unsupportedCompressedV22
|
|
var errorDescription: String? {
|
|
switch self {
|
|
case .verificationFailed(let file): "Die geschriebenen Tags in \(file) konnten nicht überprüft werden."
|
|
case .unsupportedCompressedV22: "Diese komprimierten ID3v2.2-Tags können nicht sicher bearbeitet werden. Die Datei wurde nicht geändert."
|
|
}
|
|
}
|
|
}
|