diff --git a/apps/desktop/lib/src/files/folder_store.dart b/apps/desktop/lib/src/files/folder_store.dart new file mode 100644 index 0000000..ae65868 --- /dev/null +++ b/apps/desktop/lib/src/files/folder_store.dart @@ -0,0 +1,84 @@ +import 'package:flutter/foundation.dart'; +import 'package:hive_ce/hive.dart'; +import 'package:signals/signals_flutter.dart'; + +// Files source state, one Hive box: the folders the user added and the +// local files played last. Same shape as AppSettings: signals start empty, +// take the stored values once [FolderStore.ensureLoaded] finishes, and +// mutators write through. + +const filesBoxName = 'files'; + +const _keyFolders = 'folders'; +const _keyRecent = 'recent'; + +/// Recent files kept, most recent first. +const maxRecentFiles = 30; + +class FolderStore { + static final FolderStore instance = FolderStore(); + + /// Watched folders, in the order they were added. + final folders = signal>(const []); + /// Local files played, most recent first, no duplicates. + final recent = signal>(const []); + + Future? _load; + Box? _box; + + Future ensureLoaded() => _load ??= _loadNow(); + + Future _loadNow() async { + try { + final box = _box = await Hive.openBox(filesBoxName); + final f = box.get(_keyFolders); + if (f is List) folders.value = List.unmodifiable(f.whereType()); + final r = box.get(_keyRecent); + if (r is List) { + recent.value = List.unmodifiable( + r.whereType().toSet().take(maxRecentFiles)); + } + } catch (e, st) { + debugPrint('load files store failed: $e\n$st'); + } + } + + /// False when [dir] is already watched. + bool addFolder(String dir) { + if (folders.value.contains(dir)) return false; + _setFolders([...folders.value, dir]); + return true; + } + + void removeFolder(String dir) => + _setFolders([...folders.value.where((d) => d != dir)]); + + /// Moves [path] to the top of [recent]. + void addRecent(String path) => _setRecent( + [path, ...recent.value.where((p) => p != path)].take(maxRecentFiles)); + + void removeRecent(String path) => + _setRecent(recent.value.where((p) => p != path)); + + void clearRecent() => _setRecent(const []); + + void _setFolders(List list) { + folders.value = List.unmodifiable(list); + _put(_keyFolders, [...list]); + } + + void _setRecent(Iterable list) { + recent.value = List.unmodifiable(list); + _put(_keyRecent, [...recent.value]); + } + + Future _put(String key, Object value) async { + try { + final box = _box ?? + (Hive.isBoxOpen(filesBoxName) ? Hive.box(filesBoxName) : null); + await box?.put(key, value); + } catch (e, st) { + debugPrint('save files store $key failed: $e\n$st'); + } + } +} diff --git a/apps/desktop/lib/src/files/name_parser.dart b/apps/desktop/lib/src/files/name_parser.dart new file mode 100644 index 0000000..2ca3a25 --- /dev/null +++ b/apps/desktop/lib/src/files/name_parser.dart @@ -0,0 +1,196 @@ +// Release file names -> series / season / episode, anitomy-style but small: +// enough to group a downloads folder into shows. Unknown shapes fall back to +// the cleaned name with no episode, never to a wrong number. + +/// What a release file name says. +class ParsedName { + /// Title without group, season marker, episode, year or release tags. + final String series; + final int? season; + final int? episode; + /// Release group: leading `[Group]` or scene-style trailing `-GRP`. + final String? group; + /// Release year, taken out of [series] (movies, `Title (2019)`). + final int? year; + /// Non-episode marker (`NCOP1`, `NCED`, `OVA 2`, `Special`): such files + /// carry no [episode] so they never sort among the real ones. + final String? extra; + + const ParsedName( + this.series, { + this.season, + this.episode, + this.group, + this.year, + this.extra, + }); + + /// `S01E03`, `E25`, the [extra] marker, `S02` for a season pack, else ''. + String get label { + final s = season == null ? '' : 'S${season.toString().padLeft(2, '0')}'; + if (episode != null) return '${s}E${episode.toString().padLeft(2, '0')}'; + return extra ?? s; + } + + /// Grouping key: case, punctuation and spacing do not split a series. + String get seriesKey => normalizeSeries(series); + + @override + String toString() => 'ParsedName($series, s=$season, e=$episode, ' + 'group=$group, year=$year, extra=$extra)'; +} + +/// Lowercase letters and digits of [s], single spaces between words. +String normalizeSeries(String s) => s + .toLowerCase() + .replaceAll(RegExp(r"['’`]"), '') + .replaceAll(RegExp(r'[^\p{L}\p{N}]+', unicode: true), ' ') + .trim(); + +// Release tags: the title ends where the first of these starts. +final _junk = RegExp( + r'\b(?:2160p|1440p|1080[pi]|720p|576p|480p|4K|UHD|[xh]\.?26[45]|HEVC|AVC|' + r'AV1|VP9|WEB(?:-?DL|-?Rip)?|BD(?:Rip|Remux)?|Blu-?Ray|BRRip|DVD(?:Rip)?|' + r'HDTV|HDR(?:10)?|DV|REMUX|AAC(?:\d\.\d)?|FLAC|Opus|DTS(?:-HD)?|E?-?AC-?3|' + r'DDP?\d?|TrueHD|Atmos|10-?bit|8-?bit|Hi10P?|PROPER|REPACK|Dual[ -]Audio|' + r'Multi(?:ple)?[ -]Subs?(?:titles?)?|AMZN|NF|CR|DSNP|HMAX|ATVP|' + r'Batch|Complete)\b', + caseSensitive: false, +); +final _ext = RegExp(r'\.(?=[a-z0-9]*[a-z])[a-z0-9]{2,4}$', caseSensitive: false); +final _leadingGroup = RegExp(r'^\s*\[([^\]]+)\]'); +final _sceneGroup = RegExp(r'-([A-Za-z0-9]+)$'); +final _bracketYear = RegExp(r'[(\[]((?:19|20)\d{2})[)\]]'); +final _brackets = RegExp(r'\[[^\]]*\]|\([^)]*\)|\{[^}]*\}|【[^】]*】'); +// S01E02, S01.E02, S1 E2; a batch `S01E01-E02` / `S01E01E02` keeps the first. +final _sxe = RegExp(r'\bS(\d{1,2})[ .]?E(\d{1,4})(?:v\d)?(?!\d)', + caseSensitive: false); +final _nxn = RegExp(r'\b(\d{1,2})x(\d{2,3})\b'); +// Anime: `Title - 25`, `- 03v2`, `- 01-02` (batch keeps the first). +final _dashNumber = RegExp(r'\s[-–]\s(\d{1,4})(?:v\d)?(?=$|[\s\-~.])'); +final _episodeWord = RegExp( + r'\b(?:Episode|Ep\.?|E)\s?(\d{1,4})(?:v\d)?\b', + caseSensitive: false, +); +// Extras: unambiguous words anywhere, short ones only right after the dash. +final _extraAnywhere = RegExp( + r'(?:^|\s)(NCOP|NCED|OVA|OAD|ONA)\s?(\d{1,2})?(?:v\d)?(?=$|\s)', + caseSensitive: false, +); +final _extraAfterDash = RegExp( + r'\s[-–]\s(OP|ED|SP|Specials?|Extras?|Recap|Preview|PV|Menu)\s?(\d{1,2})?' + r'(?:v\d)?(?=$|\s)', + caseSensitive: false, +); +final _seasonInTitle = RegExp( + r'\s(?:S(\d{1,2})|Season\s?(\d{1,2})|(\d{1,2})(?:st|nd|rd|th)\s+Season)\s*$', + caseSensitive: false, +); +final _trailingYear = RegExp(r'\s((?:19|20)\d{2})$'); + +/// Parses a file name (with or without the extension, no directories). +ParsedName parseReleaseName(String fileName) { + var s = fileName.replaceFirst(_ext, '').trim(); + final original = s; + String? group = _leadingGroup.firstMatch(s)?.group(1)?.trim(); + int? year; + final by = _bracketYear.firstMatch(s); + if (by != null) year = int.parse(by.group(1)!); + s = s.replaceAll(_brackets, ' '); + + // Dots and underscores as separators (scene style), unless the name + // already has spaces and only the odd `Dr. Stone` dot. + final dotted = !s.contains(' ') || RegExp(r'\w\.\w').allMatches(s).length > 2; + if (dotted) { + // `...H264-GRP`, but not `...WEB-DL`. + final tags = _junk.allMatches(s); + if (group == null && tags.isNotEmpty && tags.last.end < s.length) { + final g = _sceneGroup.firstMatch(s); + if (g != null) { + group = g.group(1); + s = s.substring(0, g.start); + } + } + s = s.replaceAll('.', ' '); + } + s = s.replaceAll('_', ' ').replaceAll(RegExp(r'\s+'), ' ').trim(); + + // Release tags end the interesting part. + final junk = _junk.firstMatch(s); + if (junk != null && junk.start > 0) s = s.substring(0, junk.start).trim(); + + int? season, episode; + String? extra; + var cut = s.length; + final extraMatch = + _extraAfterDash.firstMatch(s) ?? _extraAnywhere.firstMatch(s); + final sxe = _sxe.firstMatch(s); + if (extraMatch != null) { + final word = extraMatch.group(1)!; + final upper = word.length <= 4 ? word.toUpperCase() : _title(word); + // `OVA - 02`: the number may follow the dash instead. + final n = extraMatch.group(2) ?? + _dashNumber.firstMatch(s.substring(extraMatch.end))?.group(1); + extra = n == null + ? upper + : (upper.startsWith('NC') || upper.length <= 2) + ? '$upper${int.parse(n)}' + : '$upper ${int.parse(n)}'; + cut = extraMatch.start; + if (sxe != null && sxe.start < cut) { + season = int.parse(sxe.group(1)!); + cut = sxe.start; + } + } else if (sxe != null) { + season = int.parse(sxe.group(1)!); + episode = int.parse(sxe.group(2)!); + cut = sxe.start; + } else { + final nxn = _nxn.firstMatch(s); + if (nxn != null) { + season = int.parse(nxn.group(1)!); + episode = int.parse(nxn.group(2)!); + cut = nxn.start; + } else { + final m = _dashNumber.firstMatch(s) ?? _episodeWord.firstMatch(s); + if (m != null) { + episode = int.parse(m.group(1)!); + cut = m.start; + } + } + } + + var series = s.substring(0, cut); + // Season pack or season marker kept in the title: `Title S2`, + // `Title Season 2`, `Title 2nd Season`, `Title.S01.1080p`. + final sIn = _seasonInTitle.firstMatch(series); + if (sIn != null) { + season ??= int.parse(sIn.group(1) ?? sIn.group(2) ?? sIn.group(3)!); + series = series.substring(0, sIn.start); + } + series = series.replaceAll(RegExp(r'[\s\-–:,~]+$'), '').trim(); + // A trailing year is the release year, unless it is the whole title or + // too far ahead to be one (`Blade Runner 2049`). + final ty = _trailingYear.firstMatch(series); + if (ty != null) { + final y = int.parse(ty.group(1)!); + if (y <= DateTime.now().year + 1) { + year ??= y; + series = series.substring(0, ty.start).trim(); + } + } + series = series.replaceAll(RegExp(r'[\s\-–:,~]+$'), '').trim(); + if (series.isEmpty) { + series = original.replaceAll(RegExp(r'[._]+'), ' ').trim(); + } + return ParsedName( + series, + season: season, + episode: episode, + group: group, + year: year, + extra: extra, + ); +} + +String _title(String w) => w[0].toUpperCase() + w.substring(1).toLowerCase(); diff --git a/apps/desktop/lib/src/files/scanner.dart b/apps/desktop/lib/src/files/scanner.dart new file mode 100644 index 0000000..2e8b01e --- /dev/null +++ b/apps/desktop/lib/src/files/scanner.dart @@ -0,0 +1,257 @@ +import 'dart:io'; +import 'dart:isolate'; + +import 'name_parser.dart'; + +// Folder scan for the Files source: videos with their parsed names, +// sidecar subtitles, everything else counted and hidden. The walk is +// synchronous I/O, so it runs in its own isolate. + +const videoExtensions = { + 'mkv', 'mp4', 'webm', 'avi', 'mov', 'm4v', 'ts', 'm2ts', 'wmv', 'flv', // +}; +const subtitleExtensions = {'ass', 'ssa', 'srt', 'vtt', 'sup'}; + +/// Files looked at per scan; past this the result is [FolderScan.truncated]. +const maxScannedFiles = 20000; + +/// Samples and trailers under this size are hidden next to the real thing. +const _sampleMaxBytes = 300 << 20; + +enum FileKind { video, subtitle, other } + +FileKind kindOf(String path) { + final ext = _extension(_baseName(path)); + if (videoExtensions.contains(ext)) return FileKind.video; + if (subtitleExtensions.contains(ext)) return FileKind.subtitle; + return FileKind.other; +} + +class VideoFile { + final String path; + final int size; + final ParsedName parsed; + final DateTime modified; + const VideoFile(this.path, this.size, this.parsed, this.modified); + + String get name => _baseName(path); +} + +class FolderScan { + final List videos; + /// Non-video files and samples (subtitles and dot-entries not counted). + final int hiddenCount; + /// Up to 6 of the hidden file names, for "and N other files" hints. + final List hiddenExamples; + /// Video path -> subtitle files next to it with the same base name + /// (`Ep 01.mkv` -> `Ep 01.srt`, `Ep 01.en.ass`). + final Map> subtitles; + /// Stopped after [maxScannedFiles] files. + final bool truncated; + + const FolderScan({ + required this.videos, + required this.hiddenCount, + required this.hiddenExamples, + required this.subtitles, + required this.truncated, + }); + + static const empty = FolderScan( + videos: [], + hiddenCount: 0, + hiddenExamples: [], + subtitles: {}, + truncated: false, + ); +} + +/// Scans [dir] recursively off the UI isolate. Symlinks are not followed, +/// hidden (dot) files and folders are skipped, unreadable subfolders are +/// left out; never throws (a missing folder is [FolderScan.empty]). +Future scanFolder(String dir, {int maxFiles = maxScannedFiles}) => + Isolate.run(() => scanFolderSync(dir, maxFiles: maxFiles)) + .catchError((Object _) => FolderScan.empty); + +/// The walk behind [scanFolder]; blocks, so call it from an isolate. +FolderScan scanFolderSync(String dir, {int maxFiles = maxScannedFiles}) { + final videos = []; + final subs = []; + final examples = []; + var hidden = 0, seen = 0; + var truncated = false; + final pending = [Directory(dir)]; + walk: + while (pending.isNotEmpty) { + final List entries; + try { + entries = pending.removeLast().listSync(followLinks: false); + } catch (_) { + continue; + } + entries.sort((a, b) => a.path.compareTo(b.path)); + for (final e in entries) { + final name = _baseName(e.path); + if (name.startsWith('.')) continue; + if (e is Directory) { + pending.add(e); + continue; + } + if (e is! File) continue; // links + if (++seen > maxFiles) { + truncated = true; + break walk; + } + final kind = kindOf(name); + if (kind == FileKind.subtitle) { + subs.add(e.path); + continue; + } + FileStat? stat; + if (kind == FileKind.video) { + try { + stat = e.statSync(); + } catch (_) {} + } + final size = stat?.size ?? 0; + final lower = name.toLowerCase(); + final sample = kind == FileKind.video && + (lower.contains('sample') || lower.contains('trailer')) && + size < _sampleMaxBytes; + if (kind != FileKind.video || sample) { + hidden++; + if (examples.length < 6) examples.add(name); + continue; + } + videos.add(VideoFile(e.path, size, parseReleaseName(name), + stat?.modified ?? DateTime.fromMillisecondsSinceEpoch(0))); + } + } + return FolderScan( + videos: videos, + hiddenCount: hidden, + hiddenExamples: examples, + subtitles: _sidecars(videos, subs), + truncated: truncated, + ); +} + +/// Subtitles in the same folder whose name is the video's base name, +/// optionally followed by `.lang` / `.forced` style suffixes. +Map> _sidecars(List videos, List subs) { + final byStem = >{}; + for (final s in subs) { + final stem = _stripExtension(s); + byStem.putIfAbsent(stem, () => []).add(s); + // `Ep 01.en.ass`, `Ep 01.en.forced.ass`: also index the shorter stems. + var shorter = stem; + for (var i = 0; i < 2; i++) { + final dot = shorter.lastIndexOf('.'); + if (dot <= shorter.lastIndexOf(RegExp(r'[/\\]')) + 1) break; + final suffix = shorter.substring(dot + 1); + // Language / flag tags only (en, eng, pt-BR, forced, sdh): a suffix + // with digits is part of the name (`Show.S01E01.srt` is not `Show`'s). + if (!RegExp(r'^[A-Za-z]{2,8}(-[A-Za-z]{2,4})?$').hasMatch(suffix)) break; + shorter = shorter.substring(0, dot); + byStem.putIfAbsent(shorter, () => []).add(s); + } + } + return { + for (final v in videos) + if (byStem[_stripExtension(v.path)] case final list?) + v.path: (list.toSet().toList()..sort()), + }; +} + +/// One show: its episodes in season/episode order plus its extras +/// (NCOP, OVA...) in name order. +class SeriesGroup { + /// Display title: the most common spelling among the files. + final String title; + final String key; + final List episodes; + final List extras; + const SeriesGroup(this.title, this.key, this.episodes, this.extras); + + /// Distinct seasons, ascending; files without one count as season 1. + List get seasons => + ({for (final e in episodes) e.parsed.season ?? 1}.toList()..sort()); +} + +/// [groupBySeries] result: shows, and videos that are not episodes. +class GroupedVideos { + final List series; + final List loose; + const GroupedVideos(this.series, this.loose); +} + +/// Groups videos with an episode number (or an extra marker) by +/// [ParsedName.seriesKey]; the rest (movies, clips) stay loose, by name. +/// An extra whose series has no episodes in the list is loose too. +GroupedVideos groupBySeries(Iterable videos) { + final episodes = >{}; + final extras = >{}; + final loose = []; + for (final v in videos) { + final p = v.parsed; + final key = p.seriesKey; + if (p.episode != null && key.isNotEmpty) { + episodes.putIfAbsent(key, () => []).add(v); + } else if (p.extra != null && key.isNotEmpty) { + extras.putIfAbsent(key, () => []).add(v); + } else { + loose.add(v); + } + } + for (final e in extras.entries) { + if (!episodes.containsKey(e.key)) loose.addAll(e.value); + } + int byName(VideoFile a, VideoFile b) => + a.name.toLowerCase().compareTo(b.name.toLowerCase()); + final groups = [ + for (final e in episodes.entries) + SeriesGroup( + _commonTitle(e.value), + e.key, + e.value..sort(_byEpisode), + (extras[e.key] ?? [])..sort(byName), + ), + ]..sort((a, b) => a.title.toLowerCase().compareTo(b.title.toLowerCase())); + return GroupedVideos(groups, loose..sort(byName)); +} + +int _byEpisode(VideoFile a, VideoFile b) { + final pa = a.parsed, pb = b.parsed; + final s = (pa.season ?? 1).compareTo(pb.season ?? 1); + if (s != 0) return s; + final e = pa.episode!.compareTo(pb.episode!); + if (e != 0) return e; + // Same episode twice (v2, another group): newest release first. + return b.name.compareTo(a.name); +} + +String _commonTitle(List files) { + final counts = {}; + for (final f in files) { + counts.update(f.parsed.series, (n) => n + 1, ifAbsent: () => 1); + } + return counts.entries + .reduce((a, b) => b.value > a.value ? b : a) + .key; +} + +String _baseName(String path) { + final i = path.lastIndexOf(RegExp(r'[/\\]')); + return i < 0 ? path : path.substring(i + 1); +} + +String _extension(String name) { + final dot = name.lastIndexOf('.'); + return dot <= 0 ? '' : name.substring(dot + 1).toLowerCase(); +} + +String _stripExtension(String path) { + final dot = path.lastIndexOf('.'); + final sep = path.lastIndexOf(RegExp(r'[/\\]')); + return dot > sep + 1 ? path.substring(0, dot) : path; +} diff --git a/apps/desktop/lib/src/files/thumbnails.dart b/apps/desktop/lib/src/files/thumbnails.dart new file mode 100644 index 0000000..baaa29d --- /dev/null +++ b/apps/desktop/lib/src/files/thumbnails.dart @@ -0,0 +1,181 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; + +import 'package:crypto/crypto.dart'; +import 'package:flutter/foundation.dart'; +import 'package:media_kit/media_kit.dart'; +import 'package:path_provider/path_provider.dart'; + +// Poster frames for the Files source, made by mpv itself (no ffmpeg on +// users' machines; Windows ships only libmpv). A hidden player per file +// with `vo=null`: mpv still keeps the last decoded frame, so +// `screenshot-to-file` encodes it with mpv's own JPEG writer. `start=25%` +// makes the first decoded frame the one we want, `vf=scale` keeps it +// small. Results (and failures) are cached on disk by path+size+mtime. + +class Thumbnail { + /// JPEG on disk, at most [thumbnailWidth] wide. + final String imagePath; + final Duration duration; + const Thumbnail(this.imagePath, this.duration); +} + +const thumbnailWidth = 480; + +/// Where thumbnails are cached; swapped in tests. +Future Function() thumbnailCacheRoot = getApplicationCacheDirectory; + +/// Generations running at once: each is a full decoder. +const _maxConcurrent = 2; +const _timeout = Duration(seconds: 20); + +int _running = 0; +final _waiting = >[]; +final _inFlight = >{}; + +/// The cached or freshly made thumbnail of the video at [path], or null +/// when it can't be made (not a video, unreadable, timed out, cancelled). +/// Never throws. [cancelled] is checked while queued and before the +/// expensive steps: a scrolled-away tile returns null without decoding. +Future thumbnailFor(String path, {bool Function()? cancelled}) { + final existing = _inFlight[path]; + if (existing != null) return existing; + final f = _thumbnailFor(path, cancelled ?? () => false).catchError(( + Object e, + StackTrace st, + ) { + debugPrint('thumbnail $path failed: $e\n$st'); + return null; + }); + _inFlight[path] = f; + f.whenComplete(() => _inFlight.remove(path)); + return f; +} + +/// Cache key: the same file at the same size and mtime reuses its frame. +String thumbnailKey(String path, int size, DateTime modified) => sha1 + .convert(utf8.encode('$path|$size|${modified.millisecondsSinceEpoch}')) + .toString(); + +Future _thumbnailFor(String path, bool Function() cancelled) async { + final stat = await File(path).stat(); + if (stat.type != FileSystemEntityType.file) return null; + final dir = Directory( + '${(await thumbnailCacheRoot()).path}${Platform.pathSeparator}thumbnails'); + await dir.create(recursive: true); + final base = + '${dir.path}${Platform.pathSeparator}${thumbnailKey(path, stat.size, stat.modified)}'; + final cached = await _readCache(base); + if (cached != null) return cached.$1; + + if (cancelled()) return null; + await _acquire(); + try { + if (cancelled()) return null; + final made = await _generate(path, '$base.jpg', cancelled) + .timeout(_timeout, onTimeout: () => null); + if (made == null) { + // Remember broken files, not cancellations. + if (!cancelled()) await File('$base.json').writeAsString('{}'); + return null; + } + await File('$base.json') + .writeAsString(jsonEncode({'ms': made.duration.inMilliseconds})); + return made; + } finally { + _release(); + } +} + +/// (thumbnail or null for a remembered failure), or null when not cached. +Future<(Thumbnail?,)?> _readCache(String base) async { + try { + final meta = File('$base.json'); + if (!await meta.exists()) return null; + final ms = (jsonDecode(await meta.readAsString()) as Map)['ms']; + if (ms is! int) return (null,); + final jpg = File('$base.jpg'); + if (!await jpg.exists()) return null; + return (Thumbnail(jpg.path, Duration(milliseconds: ms)),); + } catch (_) { + return null; + } +} + +Future _acquire() async { + if (_running < _maxConcurrent) { + _running++; + return; + } + final c = Completer(); + _waiting.add(c); + await c.future; // the releaser hands its slot over +} + +void _release() { + if (_waiting.isNotEmpty) { + _waiting.removeAt(0).complete(); + } else { + _running--; + } +} + +Future _generate( + String path, + String out, + bool Function() cancelled, +) async { + final player = Player( + configuration: const PlayerConfiguration( + vo: 'null', + muted: true, + osc: false, + libass: false, + title: 'thumbnail', + bufferSize: 4 << 20, + ), + ); + try { + final mpv = player.platform as NativePlayer; + for (final (k, v) in [ + ('ao', 'null'), + ('aid', 'no'), + ('sid', 'no'), + ('vid', 'auto'), // media_kit starts with vid=no + ('hwdec', 'no'), + ('cache', 'no'), + ('hr-seek', 'no'), // nearest keyframe is fine for a poster + ('start', '25%'), + ('vf', 'scale=w=$thumbnailWidth:h=-2'), + ('screenshot-format', 'jpg'), + ('screenshot-jpeg-quality', '85'), + ('screenshot-tag-colorspace', 'no'), + ]) { + await mpv.setProperty(k, v); + } + await player.open(Media(path), play: false); + final target = File(out); + final deadline = DateTime.now().add(_timeout); + while (DateTime.now().isBefore(deadline)) { + if (cancelled()) return null; + // Unreadable or no video (with aid=no, audio-only stops too): mpv + // drops the file and goes idle at once. + if (await mpv.getProperty('idle-active') == 'yes') return null; + // A frame is up once the video has a size and the seek is done. + final w = await mpv.getProperty('video-params/w'); + final seeking = await mpv.getProperty('seeking'); + if (w.isNotEmpty && w != '0' && seeking != 'yes') { + await mpv.command(['screenshot-to-file', out, 'video']); + if (await target.exists() && await target.length() > 0) { + final d = double.tryParse(await mpv.getProperty('duration')) ?? 0; + return Thumbnail(out, Duration(milliseconds: (d * 1000).round())); + } + } + await Future.delayed(const Duration(milliseconds: 50)); + } + return null; + } finally { + await player.dispose(); + } +} diff --git a/apps/desktop/test/files_scanner_test.dart b/apps/desktop/test/files_scanner_test.dart new file mode 100644 index 0000000..af57a1b --- /dev/null +++ b/apps/desktop/test/files_scanner_test.dart @@ -0,0 +1,150 @@ +import 'dart:io'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:watch_together/src/files/name_parser.dart'; +import 'package:watch_together/src/files/scanner.dart'; + +late Directory _root; + +String _p(String rel) => '${_root.path}/$rel'; + +void _file(String rel, {int size = 10}) { + final f = File(_p(rel))..createSync(recursive: true); + if (size > 0) { + final raf = f.openSync(mode: FileMode.write); + raf.truncateSync(size); + raf.closeSync(); + } +} + +VideoFile _v(String name) => + VideoFile('/x/$name', 1, parseReleaseName(name), DateTime(2020)); + +void main() { + setUp(() => _root = Directory.systemTemp.createTempSync('files_scan_')); + tearDown(() => _root.deleteSync(recursive: true)); + + test('classifies, skips hidden and samples, pairs sidecar subtitles', + () async { + _file('Show/[Grp] Show - 01 [1080p].mkv'); + _file('Show/[Grp] Show - 01 [1080p].ass'); + _file('Show/[Grp] Show - 02 [1080p].mkv'); + _file('Show/[Grp] Show - 02 [1080p].en.srt'); + _file('Show/[Grp] Show - 02 [1080p].en.forced.srt'); + _file('Show/unrelated.srt'); + _file('Show/sample-show.mkv'); + _file('Show/info.nfo'); + _file('Show/cover.jpg'); + _file('Movie.2020.1080p.BluRay.mp4'); + _file('Movie.2020.1080p.BluRay.nfo'); + _file('.hidden.mkv'); + _file('.cache/inside.mkv'); + _file('deep/a/b/c/clip.webm'); + _file('Trailer big.mkv', size: 301 << 20); // sparse + Link(_p('link-to-show')).createSync(_p('Show')); + Link(_p('link.mkv')).createSync(_p('Movie.2020.1080p.BluRay.mp4')); + + final scan = await scanFolder(_root.path); + final names = scan.videos.map((v) => v.name).toList()..sort(); + expect(names, [ + 'Movie.2020.1080p.BluRay.mp4', + 'Trailer big.mkv', + '[Grp] Show - 01 [1080p].mkv', + '[Grp] Show - 02 [1080p].mkv', + 'clip.webm', + ]); + expect(scan.hiddenCount, 4); // sample, nfo, jpg, nfo + expect(scan.hiddenExamples, hasLength(4)); + expect(scan.hiddenExamples, contains('sample-show.mkv')); + expect(scan.truncated, isFalse); + expect(scan.subtitles[_p('Show/[Grp] Show - 01 [1080p].mkv')], + [_p('Show/[Grp] Show - 01 [1080p].ass')]); + expect(scan.subtitles[_p('Show/[Grp] Show - 02 [1080p].mkv')], [ + _p('Show/[Grp] Show - 02 [1080p].en.forced.srt'), + _p('Show/[Grp] Show - 02 [1080p].en.srt'), + ]); + expect(scan.subtitles.containsKey(_p('Movie.2020.1080p.BluRay.mp4')), + isFalse); + + final ep = scan.videos.firstWhere((v) => v.name.contains('- 02')); + expect(ep.parsed.episode, 2); + expect(ep.size, 10); + expect(ep.modified.year, DateTime.now().year); + }); + + test('only language/flag suffixes pair a subtitle with a shorter name', + () async { + _file('Show.mkv'); + _file('Show.pt-BR.srt'); + _file('Show.S01E01.srt'); + final scan = await scanFolder(_root.path); + expect(scan.subtitles[_p('Show.mkv')], [_p('Show.pt-BR.srt')]); + }); + + test('stops after the file limit and says so', () async { + for (var i = 0; i < 30; i++) { + _file('f$i.mkv', size: 0); + } + final scan = await scanFolder(_root.path, maxFiles: 12); + expect(scan.truncated, isTrue); + expect(scan.videos, hasLength(12)); + }); + + test('hidden examples stop at 6', () async { + for (var i = 0; i < 9; i++) { + _file('note$i.txt', size: 0); + } + final scan = await scanFolder(_root.path); + expect(scan.hiddenCount, 9); + expect(scan.hiddenExamples, hasLength(6)); + }); + + test('a missing folder is an empty scan', () async { + final scan = await scanFolder(_p('nope')); + expect(scan.videos, isEmpty); + expect(scan.truncated, isFalse); + }); + + test('kindOf', () { + expect(kindOf('/a/b.MKV'), FileKind.video); + expect(kindOf('b.m2ts'), FileKind.video); + expect(kindOf('b.SUP'), FileKind.subtitle); + expect(kindOf('b.nfo'), FileKind.other); + expect(kindOf('mkv'), FileKind.other); + }); + + group('groupBySeries', () { + test('groups across spellings, sorts by season then episode', () { + final g = groupBySeries([ + _v('[A] Re:Zero S2 - 02 [1080p].mkv'), + _v('[A] Re:Zero - 10 [1080p].mkv'), + _v('[B] Re Zero - 02 [720p].mkv'), + _v('[A] Re:Zero S2 - 01 [1080p].mkv'), + _v('[A] Re:Zero - NCOP1 [1080p].mkv'), + _v('Other Show - 03.mkv'), + _v('Other Show - 01.mkv'), + _v('Movie.2020.1080p.mkv'), + _v('vid_2024_final.mp4'), + _v('[A] Lonely - OVA.mkv'), + ]); + expect(g.series.map((s) => s.title), ['Other Show', 'Re:Zero']); + final re = g.series[1]; + expect(re.episodes.map((v) => v.parsed.label), + ['E02', 'E10', 'S02E01', 'S02E02']); + expect(re.seasons, [1, 2]); + expect(re.extras.single.parsed.extra, 'NCOP1'); + expect(g.series[0].episodes.map((v) => v.parsed.episode), [1, 3]); + expect(g.loose.map((v) => v.name), [ + '[A] Lonely - OVA.mkv', + 'Movie.2020.1080p.mkv', + 'vid_2024_final.mp4', + ]); + }); + + test('empty input', () { + final g = groupBySeries(const []); + expect(g.series, isEmpty); + expect(g.loose, isEmpty); + }); + }); +} diff --git a/apps/desktop/test/files_store_test.dart b/apps/desktop/test/files_store_test.dart new file mode 100644 index 0000000..1200206 --- /dev/null +++ b/apps/desktop/test/files_store_test.dart @@ -0,0 +1,48 @@ +import 'dart:io'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:hive_ce/hive.dart'; +import 'package:watch_together/src/files/folder_store.dart'; + +void main() { + test('folders and recent files persist across a reload', () async { + final dir = Directory.systemTemp.createTempSync('files_store_'); + addTearDown(() => dir.deleteSync(recursive: true)); + Hive.init(dir.path); + + final a = FolderStore(); + await a.ensureLoaded(); + expect(a.folders.value, isEmpty); + expect(a.recent.value, isEmpty); + expect(a.addFolder('/media/anime'), isTrue); + expect(a.addFolder('/media/movies'), isTrue); + expect(a.addFolder('/media/anime'), isFalse); + a.removeFolder('/media/movies'); + a.addFolder('/media/films'); + for (var i = 0; i < 35; i++) { + a.addRecent('/v/$i.mkv'); + } + a.addRecent('/v/10.mkv'); // back to the top, not duplicated + a.removeRecent('/v/33.mkv'); + expect(a.recent.value.first, '/v/10.mkv'); + expect(a.recent.value, hasLength(maxRecentFiles - 1)); + expect(a.recent.value.where((p) => p == '/v/10.mkv'), hasLength(1)); + await Future.delayed(const Duration(milliseconds: 100)); + await Hive.close(); + + final b = FolderStore(); + await b.ensureLoaded(); + expect(b.folders.value, ['/media/anime', '/media/films']); + expect(b.recent.value, a.recent.value); + expect(b.recent.value.take(3), ['/v/10.mkv', '/v/34.mkv', '/v/32.mkv']); + b.clearRecent(); + await Future.delayed(const Duration(milliseconds: 100)); + await Hive.close(); + + final c = FolderStore(); + await c.ensureLoaded(); + expect(c.recent.value, isEmpty); + expect(c.folders.value, hasLength(2)); + await Hive.close(); + }); +} diff --git a/apps/desktop/test/files_thumbnails_test.dart b/apps/desktop/test/files_thumbnails_test.dart new file mode 100644 index 0000000..b9f097d --- /dev/null +++ b/apps/desktop/test/files_thumbnails_test.dart @@ -0,0 +1,96 @@ +import 'dart:io'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:image/image.dart' as img; +import 'package:media_kit/media_kit.dart'; +import 'package:watch_together/src/files/thumbnails.dart'; + +// Real libmpv: frames grabbed with vo=null + screenshot-to-file. The test +// media comes from ffmpeg (this machine only; the app never needs it). + +late Directory _tmp; + +/// 8 s, 640x360: red until 1.5 s, green until 4 s, then blue; a keyframe +/// every 0.5 s, so the 25% frame (2 s) is green. +Future _media(String name) async { + final path = '${_tmp.path}/$name'; + final r = await Process.run('ffmpeg', [ + '-y', '-v', 'error', + '-f', 'lavfi', '-i', 'color=c=red:size=640x360:rate=24:duration=1.5', + '-f', 'lavfi', '-i', 'color=c=green:size=640x360:rate=24:duration=2.5', + '-f', 'lavfi', '-i', 'color=c=blue:size=640x360:rate=24:duration=4', + '-filter_complex', '[0][1][2]concat=n=3:v=1:a=0', + '-c:v', 'libx264', '-preset', 'ultrafast', '-g', '12', '-pix_fmt', 'yuv420p', + path, + ]); + if (r.exitCode != 0) fail('ffmpeg failed: ${r.stderr}'); + return path; +} + +void main() { + setUpAll(() { + MediaKit.ensureInitialized(); + _tmp = Directory.systemTemp.createTempSync('files_thumbs_'); + thumbnailCacheRoot = () async => Directory('${_tmp.path}/cache'); + }); + tearDownAll(() => _tmp.deleteSync(recursive: true)); + + test('a JPEG of the 25% frame plus the duration, then from the cache', + timeout: const Timeout(Duration(minutes: 2)), () async { + final path = await _media('a.mkv'); + final sw = Stopwatch()..start(); + final t = await thumbnailFor(path); + final first = sw.elapsedMilliseconds; + expect(t, isNotNull); + expect(t!.duration.inMilliseconds, closeTo(8000, 100)); + final bytes = File(t.imagePath).readAsBytesSync(); + expect(bytes.sublist(0, 2), [0xFF, 0xD8]); // JPEG + final image = img.decodeJpg(bytes)!; + expect(image.width, thumbnailWidth); + expect(image.height, 270); + final px = image.getPixel(image.width ~/ 2, image.height ~/ 2); + expect(px.g, greaterThan(100), reason: 'green frame, got $px'); + expect(px.r, lessThan(60)); + expect(px.b, lessThan(60)); + + sw.reset(); + final again = await thumbnailFor(path); + final cachedMs = sw.elapsedMilliseconds; + expect(again?.imagePath, t.imagePath); + expect(again?.duration, t.duration); + // ignore: avoid_print + print('thumbnail: first $first ms, cached $cachedMs ms'); + expect(cachedMs, lessThan(first)); + }); + + test('several at once (2 at a time), same file deduplicated', + timeout: const Timeout(Duration(minutes: 2)), () async { + final paths = [for (var i = 0; i < 4; i++) await _media('m$i.mp4')]; + final sw = Stopwatch()..start(); + final results = await Future.wait([ + for (final p in paths) thumbnailFor(p), + thumbnailFor(paths.first), + ]); + // ignore: avoid_print + print('4 thumbnails in ${sw.elapsedMilliseconds} ms'); + expect(results.every((t) => t != null), isTrue); + expect(results.first!.imagePath, results.last!.imagePath); + }); + + test('not a video, missing, cancelled: null, never a throw', + timeout: const Timeout(Duration(minutes: 1)), () async { + final text = File('${_tmp.path}/notes.mkv')..writeAsStringSync('hello'); + expect(await thumbnailFor(text.path), isNull); + // The failure is remembered: the second answer comes from the cache. + final sw = Stopwatch()..start(); + expect(await thumbnailFor(text.path), isNull); + expect(sw.elapsedMilliseconds, lessThan(500)); + + expect(await thumbnailFor('${_tmp.path}/missing.mkv'), isNull); + + final path = await _media('c.mkv'); + expect(await thumbnailFor(path, cancelled: () => true), isNull); + // A cancellation is not a remembered failure. + expect(await thumbnailFor(path), isNotNull); + }); +} diff --git a/apps/desktop/test/release_name_test.dart b/apps/desktop/test/release_name_test.dart new file mode 100644 index 0000000..0cab1ab --- /dev/null +++ b/apps/desktop/test/release_name_test.dart @@ -0,0 +1,169 @@ +import 'package:flutter_test/flutter_test.dart'; +import 'package:watch_together/src/files/name_parser.dart'; + +void _expect( + String name, + String series, { + int? season, + int? episode, + String? group, + int? year, + String? extra, + String? label, +}) { + final p = parseReleaseName(name); + final why = '$name -> $p'; + expect(p.series, series, reason: why); + expect(p.season, season, reason: why); + expect(p.episode, episode, reason: why); + expect(p.group, group, reason: why); + expect(p.year, year, reason: why); + expect(p.extra, extra, reason: why); + if (label != null) expect(p.label, label, reason: why); +} + +void main() { + group('anime', () { + test('SubsPlease dash number', () { + _expect('[SubsPlease] Sousou no Frieren - 25 (1080p) [A1B2C3D4].mkv', + 'Sousou no Frieren', + episode: 25, group: 'SubsPlease', label: 'E25'); + }); + test('Erai-raws Nth Season', () { + _expect( + '[Erai-raws] Kusuriya no Hitorigoto 2nd Season - 04 [1080p][Multiple Subtitle].mkv', + 'Kusuriya no Hitorigoto', + season: 2, episode: 4, group: 'Erai-raws', label: 'S02E04'); + }); + test('four-digit episode', () { + _expect('One Piece - 1120 [1080p].mkv', 'One Piece', + episode: 1120, label: 'E1120'); + }); + test('SxxEyy behind a group', () { + _expect('[Judas] Vinland Saga - S01E28.mkv', 'Vinland Saga', + season: 1, episode: 28, group: 'Judas', label: 'S01E28'); + }); + test('S2 in the title and a v2 release', () { + _expect('Mushoku Tensei S2 - 03v2 [1080p].mkv', 'Mushoku Tensei', + season: 2, episode: 3, label: 'S02E03'); + }); + test('Season N in the title', () { + _expect('[Group] Spy x Family Season 2 - 07 [720p].mkv', 'Spy x Family', + season: 2, episode: 7, group: 'Group'); + }); + test('Episode word', () { + _expect('Cowboy Bebop - Episode 12.mkv', 'Cowboy Bebop', episode: 12); + _expect('Cowboy Bebop Ep.05.mkv', 'Cowboy Bebop', episode: 5); + _expect('Cowboy Bebop EP07.mkv', 'Cowboy Bebop', episode: 7); + }); + test('numbers in the title are not episodes', () { + _expect('[SubsPlease] 86 - 05 (1080p).mkv', '86', + episode: 5, group: 'SubsPlease'); + _expect('Mob Psycho 100 - 03 [1080p].mkv', 'Mob Psycho 100', episode: 3); + _expect('Mob Psycho 100 III - 03.mkv', 'Mob Psycho 100 III', episode: 3); + }); + test('batch keeps the first episode', () { + _expect('Show.S01E01-E02.1080p.WEB.mkv', 'Show', season: 1, episode: 1); + _expect('Show S01E05E06.mkv', 'Show', season: 1, episode: 5); + _expect('[Grp] Show - 01-02 [1080p].mkv', 'Show', episode: 1, group: 'Grp'); + _expect('[Grp] Show - 01~12 [1080p].mkv', 'Show', episode: 1, group: 'Grp'); + _expect('Show E01-E02.mkv', 'Show', episode: 1); + }); + test('resolution, codec, CRC and audio never become episodes', () { + _expect('[Grp] Show [1080p][HEVC][ABCD1234].mkv', 'Show', group: 'Grp'); + _expect('Show (1920x1080 x264 AAC 5.1).mkv', 'Show'); + _expect('Show 1080p x265 10bit.mkv', 'Show'); + _expect('Show.720p.HDTV.x264-GRP.mkv', 'Show', group: 'GRP'); + }); + }); + + group('extras', () { + test('NCOP / NCED', () { + _expect('[Grp] Show - NCOP1 [1080p].mkv', 'Show', + group: 'Grp', extra: 'NCOP1', label: 'NCOP1'); + _expect('[Grp] Show - NCED [1080p].mkv', 'Show', + group: 'Grp', extra: 'NCED'); + _expect('[Grp] Show S2 NCOP 2 [BD 1080p].mkv', 'Show', + season: 2, group: 'Grp', extra: 'NCOP2'); + }); + test('OVA, OAD, Special, OP/ED after the dash', () { + _expect('[Grp] Show - OVA [720p].mkv', 'Show', group: 'Grp', extra: 'OVA'); + _expect('[Grp] Show OVA - 02 [720p].mkv', 'Show', + group: 'Grp', extra: 'OVA 2'); + _expect('Show - OAD 3.mkv', 'Show', extra: 'OAD 3'); + _expect('Show - Special 1.mkv', 'Show', extra: 'Special 1'); + _expect('Show - SP2.mkv', 'Show', extra: 'SP2'); + _expect('Show - OP1 [1080p].mkv', 'Show', extra: 'OP1'); + _expect('Show - ED.mkv', 'Show', extra: 'ED'); + }); + test('"Special" inside a title is a title', () { + _expect('Special Operations Unit - 04.mkv', 'Special Operations Unit', + episode: 4); + }); + }); + + group('scene / western', () { + test('dotted SxxEyy with a trailing group', () { + _expect('The.Expanse.S01E07.1080p.WEB.H264-GRP.mkv', 'The Expanse', + season: 1, episode: 7, group: 'GRP', label: 'S01E07'); + }); + test('year before the episode', () { + _expect('Doctor.Who.2005.S02E03.720p.mkv', 'Doctor Who', + season: 2, episode: 3, year: 2005); + _expect('Fargo (2014) - S03E01.mkv', 'Fargo', + season: 3, episode: 1, year: 2014); + }); + test('1x03 style', () { + _expect('Friends 1x03 The One.avi', 'Friends', season: 1, episode: 3); + }); + test('season pack name', () { + _expect('Show.S02.1080p.BluRay.x264-GRP.mkv', 'Show', + season: 2, group: 'GRP', label: 'S02'); + }); + test('lowercase', () { + _expect('show.name.s01e02.mkv', 'show name', season: 1, episode: 2); + }); + }); + + group('movies', () { + test('dotted movie: year taken out of the title', () { + _expect('Movie.Title.2023.1080p.BluRay.x264.mkv', 'Movie Title', + year: 2023, label: ''); + }); + test('year in parentheses', () { + _expect('Movie Title (2019) [1080p].mkv', 'Movie Title', year: 2019); + }); + test('title that is a number, year too far ahead', () { + _expect('Blade.Runner.2049.2017.1080p.BluRay.mkv', 'Blade Runner 2049', + year: 2017); + _expect('Blade Runner 2049.mkv', 'Blade Runner 2049'); + _expect('1917.2019.1080p.WEB-DL.mkv', '1917', year: 2019); + }); + test('WEB-DL at the end is not a group', () { + _expect('Some.Movie.2021.1080p.WEB-DL.mkv', 'Some Movie', year: 2021); + }); + test('hyphen in the title', () { + _expect('Spider-Man.2002.1080p.BluRay.mkv', 'Spider-Man', year: 2002); + }); + }); + + group('unstructured', () { + test('cleaned name, no episode', () { + _expect('vid_2024_final.mp4', 'vid 2024 final'); + _expect('holiday video.mov', 'holiday video'); + _expect('Dr. Stone - 05.mkv', 'Dr. Stone', episode: 5); + }); + test('never empty', () { + expect(parseReleaseName('[Grp].mkv').series, isNotEmpty); + expect(parseReleaseName('1080p.mkv').series, '1080p'); + expect(parseReleaseName('').series, ''); + }); + }); + + test('seriesKey ignores case and punctuation', () { + expect(parseReleaseName('Re:Zero - 01.mkv').seriesKey, + parseReleaseName('re zero - 02.mkv').seriesKey); + expect(parseReleaseName("Frieren: Beyond Journey's End - 01.mkv").seriesKey, + 'frieren beyond journeys end'); + }); +}