87 lines
4.1 KiB
Swift
87 lines
4.1 KiB
Swift
import Foundation
|
|
|
|
struct LyricLine: Hashable {
|
|
let ms: Int64
|
|
let text: String
|
|
}
|
|
|
|
struct Lyrics {
|
|
var lines: [LyricLine] = []
|
|
/// False for plain lyrics, which have no timings (every [ms] is 0).
|
|
var synced = false
|
|
var instrumental = false
|
|
}
|
|
|
|
/// Lyrics from LRCLIB (lrclib.net), synced when it has them. Hits are cached on disk by track,
|
|
/// misses only until the app restarts.
|
|
actor LyricsSource {
|
|
static let shared = LyricsSource()
|
|
|
|
private struct Record: Codable {
|
|
var syncedLyrics: String?
|
|
var plainLyrics: String?
|
|
var instrumental: Bool?
|
|
var duration: Double?
|
|
}
|
|
|
|
private let dir: URL
|
|
private var misses: Set<String> = []
|
|
|
|
private init() {
|
|
dir = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0].appendingPathComponent("lyrics", isDirectory: true)
|
|
try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
|
|
}
|
|
|
|
/// Nil when LRCLIB has nothing for this song or couldn't be reached.
|
|
func lyrics(_ t: Track) async -> Lyrics? {
|
|
let file = dir.appendingPathComponent(t.ratingKey.replacingOccurrences(of: "/", with: "_") + ".json")
|
|
if let data = try? Data(contentsOf: file), let r = try? JSONDecoder().decode(Record.self, from: data) { return Self.parse(r) }
|
|
if misses.contains(t.ratingKey) { return nil }
|
|
let secs = Double(t.durationMs) / 1000
|
|
var rec = await get("get", ["track_name": t.title, "artist_name": t.artist, "album_name": t.album, "duration": String(Int(secs.rounded()))])
|
|
.flatMap { try? JSONDecoder().decode(Record.self, from: $0) }
|
|
if rec == nil, let data = await get("search", ["track_name": t.title, "artist_name": t.artist]),
|
|
let found = try? JSONDecoder().decode([Record].self, from: data) {
|
|
// Closest length first, so a live or extended version doesn't win.
|
|
let close = found.filter { abs(($0.duration ?? 0) - secs) < 8 || secs <= 0 }
|
|
rec = close.first { $0.syncedLyrics?.isEmpty == false } ?? close.first { $0.plainLyrics?.isEmpty == false } ?? close.first
|
|
}
|
|
guard let rec else {
|
|
misses.insert(t.ratingKey)
|
|
return nil
|
|
}
|
|
if let data = try? JSONEncoder().encode(rec) { try? data.write(to: file, options: .atomic) }
|
|
return Self.parse(rec)
|
|
}
|
|
|
|
private func get(_ path: String, _ query: [String: String]) async -> Data? {
|
|
var c = URLComponents(string: "https://lrclib.net/api/\(path)")!
|
|
c.queryItems = query.map { URLQueryItem(name: $0.key, value: $0.value) }
|
|
var req = URLRequest(url: c.url!, timeoutInterval: 10)
|
|
req.setValue("Stemify iOS (https://git.iamchrisama.com/cdnutter/stemify)", forHTTPHeaderField: "User-Agent")
|
|
guard let (data, resp) = try? await URLSession.shared.data(for: req), (resp as? HTTPURLResponse)?.statusCode == 200 else { return nil }
|
|
return data
|
|
}
|
|
|
|
private static let stamp = #/\[(\d+):(\d+(?:\.\d+)?)\]/#
|
|
|
|
/// LRC: each line starts with one or more [mm:ss.xx] stamps.
|
|
private static func parse(_ r: Record) -> Lyrics {
|
|
if let lrc = r.syncedLyrics, !lrc.isEmpty {
|
|
var lines: [LyricLine] = []
|
|
for raw in lrc.split(separator: "\n", omittingEmptySubsequences: false) {
|
|
let stamps = raw.matches(of: stamp)
|
|
guard let last = stamps.last else { continue }
|
|
let text = raw[last.range.upperBound...].trimmingCharacters(in: .whitespaces)
|
|
for m in stamps {
|
|
let ms = (Int64(m.output.1) ?? 0) * 60_000 + Int64((Double(m.output.2) ?? 0) * 1000)
|
|
lines.append(LyricLine(ms: ms, text: text))
|
|
}
|
|
}
|
|
return Lyrics(lines: lines.sorted { $0.ms < $1.ms }, synced: true)
|
|
}
|
|
let plain = (r.plainLyrics ?? "").split(separator: "\n", omittingEmptySubsequences: false).map { LyricLine(ms: 0, text: String($0)) }
|
|
return Lyrics(lines: plain.count > 1 || plain.first?.text.isEmpty == false ? plain : [], instrumental: r.instrumental == true)
|
|
}
|
|
}
|