playlist-admin 2.6.76

package/cli/lib/library_index.js

@@ -0,0 +1,370 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { walkDir, stemOf } from './util.js';
+import { readMetadata } from './metadata.js';
+import { toSimplified, isLoaded, loadDict } from './zhcn.js';
+
+// Port of lib/services/library_index.dart
+const artistAliases = {
+  'claire kuo': '郭靜', 'jolin': '蔡依林', 'jolin tsai': '蔡依林',
+  'crowd lu': '盧廣仲', 'pets tseng': '曾沛慈', 'evangeline wong': '王艷薇',
+  'sabrina': '胡恂舞', 'sabrina hu': '胡恂舞', 'eric chou': '周興哲',
+  'shi shi': '孫盛希', 'boon hui lu': '文慧如', 'vicky chen': '陳忻玥',
+  'feng ze': '邱鋒澤', 'ivy': '艾薇', 'genblue': '幻藍小熊',
+  'lbi': '利比', 'erin': '連穎', 'eleanor': '李芷婷',
+  'ann bai': '白安', 'diana wang': '王詩安', 'ethan': '陳威全',
+  'chih siou': '持修', 'show luo': '羅志祥',
+};
+
+const noisePatterns = [
+  '全新單曲', '單曲', '官方完整版', '官方', '完整版',
+  '高清', '動態歌詞版', '歌詞版', '官方版', '全新',
+  'music video', 'official video', 'official music video',
+  'video', 'loop', 'lyrics',
+];
+
+export class LibraryIndex {
+  constructor() {
+    this._filenameIndex = new Map(); // tokenKey(string) -> [paths]
+    this._metadataIndex = new Map();
+    this._fileInfoMap = new Map(); // path -> {size, mtimeMs}
+    this._mp3Count = 0;
+    this._m4aCount = 0;
+    this._podcastMp3Count = 0;
+    this._podcastOtherCount = 0;
+  }
+
+  static _cacheDir() {
+    return path.join(
+      process.env.LOCALAPPDATA || '',
+      'Playlist Administrator', 'data');
+  }
+  static _fingerprintFile() {
+    return path.join(LibraryIndex._cacheDir(), 'index_fingerprint.json');
+  }
+  static _metaIndexFile() {
+    return path.join(LibraryIndex._cacheDir(), 'index_metadata.json');
+  }
+
+  static _buildFingerprint(files) {
+    const fp = new Set();
+    for (const f of files) {
+      try {
+        const st = fs.statSync(f);
+        fp.add(`${f}|${st.mtimeMs}`);
+      } catch {
+        fp.add(`${f}|0`);
+      }
+    }
+    return fp;
+  }
+
+  async build(libraryPath, log, { basePath } = {}) {
+    loadDict();
+    log('掃描音檔…');
+    const allFiles = await this._walkDir(libraryPath);
+    if (basePath && basePath !== libraryPath) {
+      const baseFiles = await this._walkDir(basePath);
+      for (const f of baseFiles) {
+        if (!allFiles.includes(f)) allFiles.push(f);
+      }
+    }
+    const mp3s = [];
+    const m4as = [];
+    for (const f of allFiles) {
+      const low = f.toLowerCase();
+      if (low.endsWith('.mp3')) mp3s.push(f);
+      else if (low.endsWith('.m4a')) m4as.push(f);
+    }
+    this._mp3Count = mp3s.length;
+    this._m4aCount = m4as.length;
+    this._fileInfoMap = new Map();
+    for (const f of allFiles) {
+      try {
+        const st = fs.statSync(f);
+        this._fileInfoMap.set(f, { size: st.size, mtimeMs: st.mtimeMs });
+      } catch {}
+    }
+    this._filenameIndex = this._buildFilenameIndex(mp3s);
+
+    let cachedFingerprint = null;
+    try {
+      const f = LibraryIndex._fingerprintFile();
+      if (fs.existsSync(f)) {
+        cachedFingerprint = new Set(JSON.parse(fs.readFileSync(f, 'utf-8')).fingerprint || []);
+      }
+    } catch {}
+
+    const currentFp = LibraryIndex._buildFingerprint(allFiles);
+    const changedStems = new Set();
+    if (cachedFingerprint) {
+      for (const entry of currentFp) {
+        if (!cachedFingerprint.has(entry)) {
+          const pipeIdx = entry.indexOf('|');
+          if (pipeIdx > 0) changedStems.add(stemOf(entry.substring(0, pipeIdx)).toLowerCase());
+        }
+      }
+      for (const entry of cachedFingerprint) {
+        if (!currentFp.has(entry)) {
+          const pipeIdx = entry.indexOf('|');
+          if (pipeIdx > 0) changedStems.add(stemOf(entry.substring(0, pipeIdx)).toLowerCase());
+        }
+      }
+    }
+
+    this._metadataIndex = new Map();
+
+    if (changedStems.size === 0 && cachedFingerprint) {
+      log(`MP3: ${this._mp3Count}, M4A: ${this._m4aCount} (無變動，載入快取索引)`);
+      const cached = this._loadMetaIndex();
+      if (cached) {
+        for (const [keyJson, paths] of Object.entries(cached)) {
+          try {
+            const tokens = JSON.parse(keyJson);
+            this._metadataIndex.set(tokens.join('\u0000'), paths);
+          } catch {}
+        }
+        log(`  metadata 索引載入完成: ${this._metadataIndex.size} 首`);
+        this._saveFingerprint(currentFp);
+        return;
+      }
+    }
+
+    log(`MP3: ${this._mp3Count}, M4A: ${this._m4aCount}`);
+    log('建立檔名索引…');
+    if (changedStems.size > 0) {
+      log(`metadata 新增/變更: ${changedStems.size} 個檔案`);
+    }
+
+    // Load cached metadata for unchanged files
+    const cached = this._loadMetaIndex();
+    const cachedPaths = new Set();
+    if (cached) {
+      for (const [keyJson, paths] of Object.entries(cached)) {
+        let skip = false;
+        for (const p of paths) {
+          if (changedStems.has(stemOf(p).toLowerCase())) { skip = true; break; }
+        }
+        if (!skip) {
+          this._metadataIndex.set(keyJson, paths);
+          for (const p of paths) cachedPaths.add(p);
+        }
+      }
+    }
+
+    const toIndex = mp3s.filter((f) => {
+      if (changedStems.size === 0) return true;
+      return changedStems.has(stemOf(f).toLowerCase());
+    });
+
+    log(`讀取 metadata 索引 (${toIndex.length}/${mp3s.length} 個檔案)…`);
+    const newEntries = await this._buildMetadataIndex(toIndex, log);
+    for (const [k, v] of newEntries) this._metadataIndex.set(k, v);
+
+    // Remove entries for deleted files
+    const onDisk = new Set(mp3s);
+    for (const [k, paths] of [...this._metadataIndex]) {
+      const kept = paths.filter((p) => onDisk.has(p));
+      if (kept.length === 0) this._metadataIndex.delete(k);
+      else this._metadataIndex.set(k, kept);
+    }
+
+    if (changedStems.size > 0) {
+      log(`索引完成 (新增 ${newEntries.length}，快取 ${this._metadataIndex.size - newEntries.length})`);
+    } else {
+      log('索引完成');
+    }
+
+    const serializable = {};
+    for (const [k, v] of this._metadataIndex) serializable[k] = v;
+    this._saveMetaIndex(serializable);
+    this._saveFingerprint(currentFp);
+  }
+
+  _saveFingerprint(fp) {
+    try {
+      const dir = LibraryIndex._cacheDir();
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(LibraryIndex._fingerprintFile(), JSON.stringify({ fingerprint: [...fp] }));
+    } catch {}
+  }
+
+  _loadMetaIndex() {
+    try {
+      const f = LibraryIndex._metaIndexFile();
+      if (!fs.existsSync(f)) return null;
+      return JSON.parse(fs.readFileSync(f, 'utf-8'));
+    } catch { return null; }
+  }
+
+  _saveMetaIndex(index) {
+    try {
+      const dir = LibraryIndex._cacheDir();
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(LibraryIndex._metaIndexFile(), JSON.stringify(index));
+    } catch {}
+  }
+
+  async _walkDir(dir) {
+    const result = [];
+    if (!fs.existsSync(dir)) return result;
+    const stack = [dir];
+    while (stack.length) {
+      const cur = stack.pop();
+      let entries;
+      try { entries = fs.readdirSync(cur, { withFileTypes: true }); } catch { continue; }
+      for (const e of entries) {
+        const full = path.join(cur, e.name);
+        if (e.isDirectory()) stack.push(full);
+        else if (e.isFile()) {
+          const low = full.toLowerCase();
+          if (!low.endsWith('.mp3') && !low.endsWith('.m4a') && !low.endsWith('.flac')) continue;
+          if (low.includes('podcast_downloads') || low.includes('podcast_rag')) {
+            if (low.endsWith('.mp3')) this._podcastMp3Count++;
+            else this._podcastOtherCount++;
+            continue;
+          }
+          result.push(full);
+        }
+      }
+    }
+    return result;
+  }
+
+  _buildFilenameIndex(files) {
+    const index = new Map();
+    for (const f of files) {
+      const tokens = this._normalize(stemOf(f));
+      if (tokens.length) {
+        const key = tokens.join('\u0000');
+        if (!index.has(key)) index.set(key, []);
+        index.get(key).push(f);
+      }
+    }
+    return index;
+  }
+
+  async _buildMetadataIndex(files, log) {
+    const index = new Map();
+    const batchSize = 20;
+    for (let i = 0; i < files.length; i += batchSize) {
+      const batch = files.slice(i, i + batchSize);
+      const metas = await Promise.all(batch.map((f) => readMetadata(f, this._config)));
+      for (let j = 0; j < batch.length; j++) {
+        const meta = metas[j];
+        if (meta.title) {
+          const tokens = this._normalize(meta.title);
+          if (tokens.length) {
+            const key = tokens.join('\u0000');
+            if (!index.has(key)) index.set(key, []);
+            index.get(key).push(batch[j]);
+          }
+        }
+      }
+      if ((i + batch.length) % 500 === 0 || i + batch.length >= files.length) {
+        log(`  metadata 索引: ${Math.min(i + batch.length, files.length)}/${files.length}`);
+      }
+    }
+    return index;
+  }
+
+  _normalize(text) {
+    let t = (text || '').toLowerCase().trim();
+    if (!t) return [];
+
+    // Remove spaces between CJK chars
+    t = t.replace(/([\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff])\s+(?=[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff])/g, '$1');
+
+    if (isLoaded()) t = toSimplified(t);
+
+    for (const [alias, value] of Object.entries(artistAliases)) {
+      const re = new RegExp(`\\b${alias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
+      t = t.replace(re, isLoaded() ? toSimplified(value) : value.toLowerCase());
+    }
+
+    // Remove "E " prefix artifact
+    t = t.replace(/(^|(?<=[^a-z0-9]))e(?=[a-z\u4e00-\u9fff\u3040-\u30ff])/g, '');
+
+    for (const p of noisePatterns) {
+      t = t.replace(new RegExp(p, 'gi'), ' ');
+    }
+
+    t = t.replace(/\s*(feat|ft|vs)\.?\s*|\s*[&,x]\s*/gi, ' ');
+
+    t = t.replace(/[\(\[【（［][^\)\]】）］]*(?:live|remix|mv|official|lyrics?\s*video|music\s*video)[^\)\]】）］]*[\)\]】）］]/gi, ' ');
+
+    t = t.replace(/([a-z])([\u4e00-\u9fff])/g, '$1 $2');
+    t = t.replace(/([\u4e00-\u9fff])([a-z])/g, '$1 $2');
+
+    const parts = t.split(/[\s\-_()\[\]【】,./:：，。、！？（）「」""''《》〈〉\u3000]+/);
+    return parts.filter((p) => p.length > 0);
+  }
+
+  findMp3ForM4a(m4aPath, { useMtime = true, cachedMeta = null } = {}) {
+    const stem = stemOf(m4aPath);
+    const tokens = this._normalize(stem);
+    const m4aInfo = this._fileInfoMap.get(m4aPath);
+
+    const mtimeOk = (mp3Path) => {
+      if (!useMtime) return true;
+      const mp3Info = this._fileInfoMap.get(mp3Path);
+      return mp3Info && m4aInfo && mp3Info.mtimeMs >= m4aInfo.mtimeMs;
+    };
+
+    // 1. exact filename match
+    const exact = this._findInIndex(tokens, this._filenameIndex);
+    if (exact && mtimeOk(exact)) return exact;
+
+    // 2. fuzzy filename match
+    for (const [key, paths] of this._filenameIndex) {
+      const entryTokens = key.split('\u0000');
+      if (this._isSubset(tokens, entryTokens) || this._isSubset(entryTokens, tokens)) {
+        for (const f of paths) {
+          if (f.toLowerCase().endsWith('.mp3') && this._fileInfoMap.has(f) && mtimeOk(f)) return f;
+        }
+      }
+    }
+
+    // 3. metadata-based matching
+    if (cachedMeta && cachedMeta.title) {
+      const titleTokens = this._normalize(cachedMeta.title);
+      for (const [key, paths] of this._metadataIndex) {
+        const entryTokens = key.split('\u0000');
+        if (this._isSubset(titleTokens, entryTokens) || this._isSubset(entryTokens, titleTokens)) {
+          for (const f of paths) {
+            if (f.toLowerCase().endsWith('.mp3') && this._fileInfoMap.has(f)) return f;
+          }
+        }
+      }
+      if (cachedMeta.artist) {
+        const combined = this._normalize(`${cachedMeta.title} - ${cachedMeta.artist}`);
+        for (const [key, paths] of this._filenameIndex) {
+          const entryTokens = key.split('\u0000');
+          if (this._isSubset(combined, entryTokens) || this._isSubset(entryTokens, combined)) {
+            for (const f of paths) {
+              if (f.toLowerCase().endsWith('.mp3') && this._fileInfoMap.has(f)) return f;
+            }
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  _findInIndex(tokens, index) {
+    const key = tokens.join('\u0000');
+    const paths = index.get(key);
+    if (paths) {
+      for (const f of paths) {
+        if (f.toLowerCase().endsWith('.mp3') && this._fileInfoMap.has(f)) return f;
+      }
+    }
+    return null;
+  }
+
+  _isSubset(small, big) {
+    if (small.length > big.length) return false;
+    return small.every((s) => big.some((b) => b.includes(s)));
+  }
+}

package/cli/lib/lufs.js

@@ -0,0 +1,172 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { run, resolveFfmpeg, isInternalPlaylist, readJson, writeJson, sleep } from './util.js';
+
+// Port of lib/services/lufs_service.dart (measure + normalize playlist MP3s)
+export class LufsService {
+  constructor(config) {
+    this.config = config;
+  }
+
+  _cacheFile(fmt) {
+    return path.join(this.config.basePath, `${fmt}_lufs_cache.json`);
+  }
+
+  _load(fmt) {
+    const data = readJson(this._cacheFile(fmt), {});
+    const out = {};
+    for (const [k, v] of Object.entries(data)) out[k] = typeof v === 'number' ? v : parseFloat(v);
+    return out;
+  }
+
+  _save(fmt, cache) {
+    writeJson(this._cacheFile(fmt), cache);
+  }
+
+  _resolvePlaylistPath(entry, playlistsPath, basePath, libraryPath) {
+    if (!entry) return null;
+    if (!entry.includes('.') && !entry.includes('\\') && !entry.includes('/')) return null;
+    const resolved = path.join(playlistsPath, entry);
+    if (fs.existsSync(resolved)) return resolved;
+    if (fs.existsSync(entry)) return entry;
+    const fname = entry.replace(/[\\/]/g, '\\').split('\\').pop();
+    for (const base of [basePath, libraryPath, playlistsPath]) {
+      const cand = path.join(base, fname);
+      if (fs.existsSync(cand)) return cand;
+    }
+    return null;
+  }
+
+  getPlaylistMp3Files() {
+    const { playlistsPath, basePath, libraryPath } = this.config;
+    if (!fs.existsSync(playlistsPath)) return new Set();
+    const mp3Files = new Set();
+    for (const e of fs.readdirSync(playlistsPath, { withFileTypes: true })) {
+      if (!e.isFile()) continue;
+      const low = e.name.toLowerCase();
+      if (!low.endsWith('.m3u8') && !low.endsWith('.m3u')) continue;
+      if (isInternalPlaylist(e.name)) continue;
+      try {
+        const content = fs.readFileSync(path.join(playlistsPath, e.name), 'utf-8');
+        for (const line of content.split('\n')) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith('#')) continue;
+          if (!trimmed.includes('.mp3') && !trimmed.includes('.m4a') && !trimmed.includes('.flac')) continue;
+          const resolved = this._resolvePlaylistPath(trimmed, playlistsPath, basePath, libraryPath);
+          if (resolved && resolved.toLowerCase().endsWith('.mp3')) {
+            mp3Files.add(resolved);
+          }
+        }
+      } catch {}
+    }
+    return mp3Files;
+  }
+
+  async measureAndNormalizePlaylistMp3s({ onLog, onProgress, concurrency = 8, tolerance = 2.0, isCancelled }) {
+    const { libraryPath, playlistsPath, basePath } = this.config;
+    if (!libraryPath || !playlistsPath) {
+      onLog('Library or Playlists path not configured');
+      return;
+    }
+    onLog('掃描歌單中的 MP3 檔案…');
+    const playlistFiles = this.getPlaylistMp3Files();
+    if (playlistFiles.size === 0) {
+      onLog('歌單中沒有 MP3 檔案');
+      return;
+    }
+    onLog(`歌單內共 ${playlistFiles.size} 個 MP3`);
+
+    const cache = this._load('mp3');
+    const target = -14.0;
+    const needsNormalize = [];
+    let skipCount = 0;
+    for (const p of playlistFiles) {
+      const cached = cache[p];
+      if (cached != null && Math.abs(cached - target) <= tolerance) skipCount++;
+      else needsNormalize.push(p);
+    }
+    if (needsNormalize.length === 0) {
+      onLog(`所有歌單 MP3 已在 ${target}±${tolerance}LUFS 範圍內 (已快取 ${skipCount} 檔)`);
+      return;
+    }
+    onLog(`需 Normalize/測量: ${needsNormalize.length} 檔 (${skipCount} 檔已合格)`);
+    const ffmpeg = resolveFfmpeg(this.config);
+    const total = needsNormalize.length;
+    let done = 0;
+    let lastSave = 0;
+
+    for (let i = 0; i < total; i += concurrency) {
+      if (isCancelled && isCancelled()) break;
+      const batch = needsNormalize.slice(i, i + concurrency);
+      await Promise.all(batch.map((p) => this._normalizeOne(p, ffmpeg, target, cache, onLog, isCancelled)));
+      if (isCancelled && isCancelled()) break;
+      done += batch.length;
+      if (onProgress) onProgress(done, total);
+      if (done - lastSave >= 10) {
+        this._save('mp3', cache);
+        lastSave = done;
+        onLog(`  進度: ${done}/${total}`);
+      }
+    }
+    this._save('mp3', cache);
+    if (isCancelled && isCancelled()) {
+      onLog(`LUFS 已取消（已處理 ${done} 檔）`);
+    } else {
+      onLog(`完成: ${done} 個檔案已統一至 ${target} LUFS`);
+    }
+  }
+
+  async _normalizeOne(absPath, ffmpeg, target, cache, onLog, isCancelled) {
+    if (!fs.existsSync(absPath)) return;
+    const base = absPath.substring(0, absPath.lastIndexOf('.'));
+    const tmp = `${base}_tmp.mp3`;
+    const name = absPath.split('\\').pop();
+    try {
+      const result = await run(ffmpeg, [
+        '-y', '-i', absPath,
+        '-af', `loudnorm=I=${target}:TP=-1:LRA=7`,
+        '-c:a', 'libmp3lame', '-q:a', '2', tmp,
+      ], { timeout: 600000 });
+      if (result.code !== 0 || !fs.existsSync(tmp)) {
+        onLog(`  ❌ ${name} normalize 失敗`);
+        return;
+      }
+      let inputLufs = target;
+      const m = result.stderr.match(/Input Integrated:\s+([-\d.]+)/);
+      if (m) inputLufs = parseFloat(m[1]);
+      fs.renameSync(tmp, absPath);
+      cache[absPath] = target;
+      if (Math.abs(inputLufs - target) > 0.1) {
+        onLog(`  ✅ ${name}  (${inputLufs.toFixed(1)} → ${target})`);
+      }
+    } catch (ex) {
+      onLog(`  ⚠️ ${name}: ${ex.message || ex}`);
+    }
+  }
+
+  cacheConversionLufsFast(m4aPath, lufs) {
+    const m4aCache = this._load('m4a');
+    if (!(m4aPath in m4aCache) && lufs != null) {
+      m4aCache[m4aPath] = lufs;
+      this._save('m4a', m4aCache);
+    }
+  }
+
+  measureOne(path_, onResult, isCancelled) {
+    const ffmpeg = resolveFfmpeg(this.config);
+    return run(ffmpeg, ['-i', path_, '-af', 'loudnorm=print_format=json', '-f', 'null', '-', '-hide_banner', '-y'], { timeout: 300000 })
+      .then((result) => {
+        if (result.code !== 0) { onResult(-14.0); return; }
+        const stderr = result.stderr;
+        const jsonStart = stderr.lastIndexOf('{');
+        if (jsonStart >= 0) {
+          try {
+            const data = JSON.parse(stderr.substring(jsonStart));
+            if (data.input_i != null) { onResult(parseFloat(data.input_i)); return; }
+          } catch {}
+        }
+        onResult(-14.0);
+      })
+      .catch(() => onResult(-14.0));
+  }
+}

package/cli/lib/metadata.js

@@ -0,0 +1,31 @@
+import { run, resolveFfmpeg, resolveFfprobe } from './util.js';
+
+// Port of lib/services/metadata_reader.dart (title/artist/album only;
+// artwork extraction is not needed by the CLI).
+export async function readMetadata(filePath, config) {
+  try {
+    const ffprobe = resolveFfprobe(resolveFfmpeg(config));
+    const r = await run(ffprobe, [
+      '-v', 'quiet', '-print_format', 'json', '-show_format', '-show_streams', filePath,
+    ]);
+    if (r.code !== 0) return { title: null, artist: null, album: null };
+    const json = JSON.parse(r.stdout || '{}');
+    const format = json.format;
+    const tags = format?.tags || {};
+    return {
+      title: first(tags, ['title', 'Title', 'TIT2']),
+      artist: first(tags, ['artist', 'Artist', 'TPE1']),
+      album: first(tags, ['album', 'Album', 'TALB']),
+    };
+  } catch {
+    return { title: null, artist: null, album: null };
+  }
+}
+
+function first(map, keys) {
+  for (const k of keys) {
+    const v = map[k];
+    if (v != null && String(v).length > 0) return String(v);
+  }
+  return null;
+}