mirror of
https://github.com/zarzet/SpotiFLAC-Mobile.git
synced 2026-09-29 12:52:13 +02:00
549 lines
16 KiB
Dart
549 lines
16 KiB
Dart
import 'dart:convert';
|
|
|
|
import 'package:xml/xml.dart';
|
|
|
|
class LyricWord {
|
|
final Duration time;
|
|
final Duration? end;
|
|
final String text;
|
|
|
|
const LyricWord({required this.time, this.end, required this.text});
|
|
}
|
|
|
|
class LyricLine {
|
|
final Duration time;
|
|
final Duration? end;
|
|
final String text;
|
|
final List<LyricWord> words;
|
|
final String? romanization;
|
|
final List<LyricWord> romanizationWords;
|
|
final String? translation;
|
|
|
|
const LyricLine({
|
|
required this.time,
|
|
this.end,
|
|
required this.text,
|
|
this.words = const [],
|
|
this.romanization,
|
|
this.romanizationWords = const [],
|
|
this.translation,
|
|
});
|
|
|
|
bool get hasWordTiming => words.isNotEmpty;
|
|
}
|
|
|
|
class ParsedLyrics {
|
|
final bool synced;
|
|
final bool wordSynced;
|
|
final List<LyricLine> lines;
|
|
final String plainText;
|
|
final String? writers;
|
|
final String? provider;
|
|
|
|
const ParsedLyrics({
|
|
required this.synced,
|
|
required this.wordSynced,
|
|
required this.lines,
|
|
required this.plainText,
|
|
this.writers,
|
|
this.provider,
|
|
});
|
|
|
|
bool get isEmpty => lines.isEmpty && plainText.trim().isEmpty;
|
|
|
|
static const ParsedLyrics empty = ParsedLyrics(
|
|
synced: false,
|
|
wordSynced: false,
|
|
lines: [],
|
|
plainText: '',
|
|
);
|
|
}
|
|
|
|
class LyricsParser {
|
|
LyricsParser._();
|
|
|
|
// [mm:ss.xx] or [mm:ss.xxx] or [mm:ss]
|
|
static final RegExp _lineTimeTag = RegExp(
|
|
r'\[(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?\]',
|
|
);
|
|
|
|
// <mm:ss.xx> inline word timestamp (enhanced LRC).
|
|
static final RegExp _wordTimeTag = RegExp(
|
|
r'<(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?>',
|
|
);
|
|
|
|
// ID tags such as [ti:..], [ar:..], [offset:..].
|
|
static final RegExp _idTag = RegExp(
|
|
r'^\[(ti|ar|al|by|offset|length|re|ve|tool|au|la|encoder|instrumental|x-[a-z0-9_-]+):.*\]$',
|
|
caseSensitive: false,
|
|
);
|
|
static final RegExp _supplementTag = RegExp(
|
|
r'^\[x-(romaji-words|romaji|translation):(\d+):([^\]]*)\]$',
|
|
caseSensitive: false,
|
|
);
|
|
|
|
static ParsedLyrics parse(String? raw) {
|
|
final text = (raw ?? '').trim();
|
|
if (text.isEmpty) return ParsedLyrics.empty;
|
|
|
|
if (_looksLikeTtml(text)) {
|
|
final ttml = _parseTtml(text);
|
|
if (ttml != null && ttml.lines.isNotEmpty) {
|
|
return _withCredits(text, ttml);
|
|
}
|
|
}
|
|
|
|
return _withCredits(text, _parseLrcOrPlain(text));
|
|
}
|
|
|
|
static ParsedLyrics _withCredits(String raw, ParsedLyrics lyrics) {
|
|
String? tag(String name) => RegExp(
|
|
'^\\[$name:([^\\]\\r\\n]*)\\]\\s*\$',
|
|
multiLine: true,
|
|
caseSensitive: false,
|
|
).firstMatch(raw)?.group(1)?.trim();
|
|
var writers = tag('au');
|
|
var provider = tag('x-provider');
|
|
final credit = tag('by') ?? '';
|
|
provider ??= RegExp(r'\bvia\s+([^\(]+)', caseSensitive: false)
|
|
.firstMatch(credit)
|
|
?.group(1)
|
|
?.trim()
|
|
.replaceFirst(RegExp(r'\s+API$', caseSensitive: false), '');
|
|
provider ??= RegExp(
|
|
r'\(source:\s*([^\)]+)\)',
|
|
caseSensitive: false,
|
|
).firstMatch(credit)?.group(1)?.trim();
|
|
provider = provider?.replaceFirst(
|
|
RegExp(r'^extension:', caseSensitive: false),
|
|
'',
|
|
);
|
|
if (_looksLikeTtml(raw)) {
|
|
try {
|
|
final doc = XmlDocument.parse(raw);
|
|
final names = doc.descendants
|
|
.whereType<XmlElement>()
|
|
.where((node) => node.name.local == 'songwriter')
|
|
.map((node) => node.innerText.trim())
|
|
.where((name) => name.isNotEmpty)
|
|
.toSet();
|
|
if (names.isNotEmpty) writers = names.join(', ');
|
|
} on XmlParserException {
|
|
// Malformed optional credits must not prevent lyric playback.
|
|
}
|
|
}
|
|
var lines = lyrics.lines;
|
|
if (lines.isNotEmpty) {
|
|
final trailer = RegExp(
|
|
r'^Written\s+by\s*:\s*(.+)$',
|
|
caseSensitive: false,
|
|
).firstMatch(lines.last.text.trim());
|
|
if (trailer != null) {
|
|
writers ??= trailer.group(1)?.trim();
|
|
lines = lines.sublist(0, lines.length - 1);
|
|
}
|
|
}
|
|
return ParsedLyrics(
|
|
synced: lyrics.synced,
|
|
wordSynced: lyrics.wordSynced,
|
|
lines: lines,
|
|
plainText: identical(lines, lyrics.lines)
|
|
? lyrics.plainText
|
|
: lines.map((line) => line.text).join('\n'),
|
|
writers: writers?.isNotEmpty == true ? writers : null,
|
|
provider: provider?.isNotEmpty == true ? provider : null,
|
|
);
|
|
}
|
|
|
|
static bool _looksLikeTtml(String text) {
|
|
final head = text.trimLeft();
|
|
return head.startsWith('<?xml') ||
|
|
head.startsWith('<tt') ||
|
|
head.contains('<tt ') ||
|
|
head.contains('http://www.w3.org/ns/ttml');
|
|
}
|
|
|
|
static Duration? _toDuration(String? min, String? sec, String? frac) {
|
|
if (min == null || sec == null) return null;
|
|
final m = int.tryParse(min) ?? 0;
|
|
final s = int.tryParse(sec) ?? 0;
|
|
var ms = 0;
|
|
if (frac != null && frac.isNotEmpty) {
|
|
// Normalize to milliseconds regardless of 2 or 3 digit fractions.
|
|
final padded = frac.padRight(3, '0').substring(0, 3);
|
|
ms = int.tryParse(padded) ?? 0;
|
|
}
|
|
return Duration(minutes: m, seconds: s, milliseconds: ms);
|
|
}
|
|
|
|
static ParsedLyrics _parseLrcOrPlain(String text) {
|
|
final rawLines = text.split(RegExp(r'\r\n|\r|\n'));
|
|
final parsed = <LyricLine>[];
|
|
final plainBuffer = <String>[];
|
|
final romanization = <int, String>{};
|
|
final romanizationWords = <int, List<LyricWord>>{};
|
|
final translation = <int, String>{};
|
|
var sawTimestamp = false;
|
|
var sawWordTiming = false;
|
|
var offsetMs = 0;
|
|
|
|
for (final rawLine in rawLines) {
|
|
final line = rawLine.trimRight();
|
|
if (line.trim().isEmpty) continue;
|
|
|
|
final supplement = _supplementTag.firstMatch(line.trim());
|
|
if (supplement != null) {
|
|
final time = int.tryParse(supplement.group(2)!);
|
|
try {
|
|
final value = utf8.decode(base64.decode(supplement.group(3)!)).trim();
|
|
if (time != null && value.isNotEmpty) {
|
|
final kind = supplement.group(1)!.toLowerCase();
|
|
if (kind == 'romaji-words') {
|
|
final words = _parseRomanizationWords(value);
|
|
if (words.isNotEmpty) {
|
|
romanizationWords.putIfAbsent(time, () => words);
|
|
}
|
|
} else {
|
|
final target = kind == 'romaji' ? romanization : translation;
|
|
target.putIfAbsent(time, () => value);
|
|
}
|
|
}
|
|
} on FormatException {
|
|
// Optional corrupt metadata must not hide the original lyrics.
|
|
}
|
|
continue;
|
|
}
|
|
|
|
// Capture [offset:] for timing correction, drop other ID tags.
|
|
final idMatch = _idTag.firstMatch(line.trim());
|
|
if (idMatch != null) {
|
|
final key = idMatch.group(1)!.toLowerCase();
|
|
if (key == 'offset') {
|
|
final value = line
|
|
.substring(line.indexOf(':') + 1)
|
|
.replaceAll(']', '')
|
|
.trim();
|
|
offsetMs = int.tryParse(value) ?? 0;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
final timeMatches = _lineTimeTag.allMatches(line).toList();
|
|
if (timeMatches.isEmpty) {
|
|
// No timestamp: treat as plain text line.
|
|
plainBuffer.add(line.trim());
|
|
continue;
|
|
}
|
|
|
|
sawTimestamp = true;
|
|
|
|
// Strip leading line timestamps to obtain the lyric content.
|
|
final lastTag = timeMatches.last;
|
|
final content = line.substring(lastTag.end).trim();
|
|
|
|
// Enhanced LRC word timestamps inside the content.
|
|
final words = _parseWords(content);
|
|
if (words.isNotEmpty) sawWordTiming = true;
|
|
final cleanContent = content.replaceAll(_wordTimeTag, '').trim();
|
|
plainBuffer.add(cleanContent);
|
|
|
|
// A line can have multiple timestamps (repeated chorus).
|
|
for (final tm in timeMatches) {
|
|
final d = _toDuration(tm.group(1), tm.group(2), tm.group(3));
|
|
if (d == null) continue;
|
|
parsed.add(
|
|
LyricLine(
|
|
time: d,
|
|
end: words.lastOrNull?.end,
|
|
text: cleanContent,
|
|
words: words,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
if (!sawTimestamp) {
|
|
// Pure plain text.
|
|
return ParsedLyrics(
|
|
synced: false,
|
|
wordSynced: false,
|
|
lines: const [],
|
|
plainText: plainBuffer.where((l) => l.isNotEmpty).join('\n'),
|
|
);
|
|
}
|
|
|
|
parsed.sort((a, b) => a.time.compareTo(b.time));
|
|
final alignedRomanization = _alignSupplements(parsed, romanization);
|
|
final alignedRomanizationWords = _alignSupplements(
|
|
parsed,
|
|
romanizationWords,
|
|
);
|
|
final alignedTranslation = _alignSupplements(parsed, translation);
|
|
|
|
final adjusted =
|
|
offsetMs == 0 &&
|
|
alignedRomanization.isEmpty &&
|
|
alignedTranslation.isEmpty
|
|
? parsed
|
|
: parsed.map((l) {
|
|
final romanization = alignedRomanization[l.time.inMilliseconds];
|
|
final words =
|
|
alignedRomanizationWords[l.time.inMilliseconds] ??
|
|
const <LyricWord>[];
|
|
// Keep readable text when optional timings are incomplete or
|
|
// belong to a different revision of the transliteration.
|
|
final validWords =
|
|
words.map((word) => word.text).join() == romanization
|
|
? words
|
|
: const <LyricWord>[];
|
|
return LyricLine(
|
|
time: _shift(l.time, offsetMs),
|
|
end: l.end == null ? null : _shift(l.end!, offsetMs),
|
|
text: l.text,
|
|
romanization: romanization,
|
|
romanizationWords: _shiftWords(validWords, offsetMs),
|
|
translation: alignedTranslation[l.time.inMilliseconds],
|
|
words: _shiftWords(l.words, offsetMs),
|
|
);
|
|
}).toList();
|
|
|
|
return ParsedLyrics(
|
|
synced: true,
|
|
wordSynced: sawWordTiming,
|
|
lines: adjusted,
|
|
plainText: plainBuffer.where((l) => l.isNotEmpty).join('\n'),
|
|
);
|
|
}
|
|
|
|
/// Older files may have centisecond line times alongside millisecond
|
|
/// supplement times. Resolve each supplement to one nearest line, keeping
|
|
/// exact matches when multiple metadata entries compete for that line.
|
|
static Map<int, T> _alignSupplements<T>(
|
|
List<LyricLine> lines,
|
|
Map<int, T> supplements,
|
|
) {
|
|
final matched = <int, (int, T)>{};
|
|
for (final entry in supplements.entries) {
|
|
var lo = 0;
|
|
var hi = lines.length;
|
|
while (lo < hi) {
|
|
final mid = (lo + hi) >> 1;
|
|
if (lines[mid].time.inMilliseconds < entry.key) {
|
|
lo = mid + 1;
|
|
} else {
|
|
hi = mid;
|
|
}
|
|
}
|
|
int? nearest;
|
|
var distance = 11;
|
|
for (final index in [lo - 1, lo]) {
|
|
if (index < 0 || index >= lines.length) continue;
|
|
final time = lines[index].time.inMilliseconds;
|
|
final delta = (time - entry.key).abs();
|
|
if (delta < distance) {
|
|
nearest = time;
|
|
distance = delta;
|
|
}
|
|
}
|
|
if (nearest == null) continue;
|
|
final previous = matched[nearest];
|
|
if (previous == null || distance < previous.$1) {
|
|
matched[nearest] = (distance, entry.value);
|
|
}
|
|
}
|
|
return matched.map((time, match) => MapEntry(time, match.$2));
|
|
}
|
|
|
|
static List<LyricWord> _parseRomanizationWords(String raw) {
|
|
final value = jsonDecode(raw);
|
|
if (value is! List) return const [];
|
|
final words = <LyricWord>[];
|
|
for (final item in value) {
|
|
if (item case {
|
|
'text': final String text,
|
|
'startTimeMs': final int start,
|
|
'endTimeMs': final int end,
|
|
}) {
|
|
if (text.trim().isEmpty ||
|
|
start < 0 ||
|
|
end < start ||
|
|
(words.isNotEmpty && words.last.time.inMilliseconds > start)) {
|
|
return const [];
|
|
}
|
|
words.add(
|
|
LyricWord(
|
|
time: Duration(milliseconds: start),
|
|
end: Duration(milliseconds: end),
|
|
text: text,
|
|
),
|
|
);
|
|
} else {
|
|
return const [];
|
|
}
|
|
}
|
|
return words;
|
|
}
|
|
|
|
static List<LyricWord> _shiftWords(List<LyricWord> words, int offsetMs) {
|
|
if (offsetMs == 0 || words.isEmpty) return words;
|
|
return words
|
|
.map(
|
|
(word) => LyricWord(
|
|
time: _shift(word.time, offsetMs),
|
|
end: word.end == null ? null : _shift(word.end!, offsetMs),
|
|
text: word.text,
|
|
),
|
|
)
|
|
.toList(growable: false);
|
|
}
|
|
|
|
static Duration _shift(Duration d, int offsetMs) {
|
|
// LRC offset: positive value shifts lyrics earlier.
|
|
final ms = d.inMilliseconds - offsetMs;
|
|
return Duration(milliseconds: ms < 0 ? 0 : ms);
|
|
}
|
|
|
|
static List<LyricWord> _parseWords(String content) {
|
|
final matches = _wordTimeTag.allMatches(content).toList();
|
|
if (matches.isEmpty) return const [];
|
|
|
|
final words = <LyricWord>[];
|
|
for (var i = 0; i < matches.length; i++) {
|
|
final m = matches[i];
|
|
final d = _toDuration(m.group(1), m.group(2), m.group(3));
|
|
if (d == null) continue;
|
|
final start = m.end;
|
|
final end = i + 1 < matches.length
|
|
? matches[i + 1].start
|
|
: content.length;
|
|
final word = content.substring(start, end);
|
|
if (word.trim().isEmpty) {
|
|
final previous = words.lastOrNull;
|
|
if (previous != null && previous.end == null && d >= previous.time) {
|
|
words[words.length - 1] = LyricWord(
|
|
time: previous.time,
|
|
end: d,
|
|
text: previous.text,
|
|
);
|
|
}
|
|
continue;
|
|
}
|
|
words.add(LyricWord(time: d, text: word));
|
|
}
|
|
return words;
|
|
}
|
|
|
|
static ParsedLyrics? _parseTtml(String text) {
|
|
try {
|
|
final doc = XmlDocument.parse(text);
|
|
final paragraphs = doc.findAllElements('p').toList();
|
|
if (paragraphs.isEmpty) return null;
|
|
|
|
final lines = <LyricLine>[];
|
|
final plain = <String>[];
|
|
var sawWords = false;
|
|
|
|
for (final p in paragraphs) {
|
|
final begin = _parseClock(p.getAttribute('begin'));
|
|
final end = _parseClock(p.getAttribute('end'));
|
|
|
|
// Word/syllable spans carry their own begin attribute.
|
|
final spans = p.findElements('span').toList();
|
|
final words = <LyricWord>[];
|
|
if (spans.isNotEmpty) {
|
|
for (final span in spans) {
|
|
final sBegin = _parseClock(span.getAttribute('begin'));
|
|
final spanText = span.innerText;
|
|
if (sBegin != null && spanText.trim().isNotEmpty) {
|
|
final sEnd = _parseClock(span.getAttribute('end'));
|
|
words.add(
|
|
LyricWord(
|
|
time: sBegin,
|
|
end: sEnd != null && sEnd >= sBegin ? sEnd : null,
|
|
text: '$spanText ',
|
|
),
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if (words.isNotEmpty) sawWords = true;
|
|
|
|
final lineText = p.innerText.replaceAll(RegExp(r'\s+'), ' ').trim();
|
|
if (lineText.isEmpty && words.isEmpty) continue;
|
|
plain.add(lineText);
|
|
|
|
if (begin != null) {
|
|
lines.add(
|
|
LyricLine(time: begin, end: end, text: lineText, words: words),
|
|
);
|
|
}
|
|
}
|
|
|
|
if (lines.isEmpty) {
|
|
return ParsedLyrics(
|
|
synced: false,
|
|
wordSynced: false,
|
|
lines: const [],
|
|
plainText: plain.join('\n'),
|
|
);
|
|
}
|
|
|
|
lines.sort((a, b) => a.time.compareTo(b.time));
|
|
return ParsedLyrics(
|
|
synced: true,
|
|
wordSynced: sawWords,
|
|
lines: lines,
|
|
plainText: plain.where((l) => l.isNotEmpty).join('\n'),
|
|
);
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
// TTML clock value: "mm:ss.fff", "hh:mm:ss.fff" or "12.5s".
|
|
static Duration? _parseClock(String? value) {
|
|
if (value == null || value.isEmpty) return null;
|
|
final v = value.trim();
|
|
|
|
if (v.endsWith('s') && !v.contains(':')) {
|
|
final seconds = double.tryParse(v.substring(0, v.length - 1));
|
|
if (seconds == null) return null;
|
|
return Duration(milliseconds: (seconds * 1000).round());
|
|
}
|
|
|
|
final parts = v.split(':');
|
|
try {
|
|
if (parts.length == 3) {
|
|
final h = int.parse(parts[0]);
|
|
final m = int.parse(parts[1]);
|
|
final s = double.parse(parts[2]);
|
|
return Duration(hours: h, minutes: m, milliseconds: (s * 1000).round());
|
|
} else if (parts.length == 2) {
|
|
final m = int.parse(parts[0]);
|
|
final s = double.parse(parts[1]);
|
|
return Duration(minutes: m, milliseconds: (s * 1000).round());
|
|
}
|
|
} catch (_) {
|
|
return null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
static int activeIndex(List<LyricLine> lines, Duration position) {
|
|
if (lines.isEmpty) return -1;
|
|
var lo = 0;
|
|
var hi = lines.length - 1;
|
|
var result = -1;
|
|
while (lo <= hi) {
|
|
final mid = (lo + hi) >> 1;
|
|
if (lines[mid].time <= position) {
|
|
result = mid;
|
|
lo = mid + 1;
|
|
} else {
|
|
hi = mid - 1;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|