diff --git a/lib/models/ffmpeg_models.dart b/lib/models/ffmpeg_models.dart index b905d7e37..0bc9d5068 100644 --- a/lib/models/ffmpeg_models.dart +++ b/lib/models/ffmpeg_models.dart @@ -114,6 +114,23 @@ class FFmpegResult { }); } +/// Outcome of an FFmpeg session started with `FFmpegExecution.start`. Logs +/// are read on demand because most callers only need the return code. +class FFmpegSessionResult { + /// Null when the session ended without a return code. + final int? returnCode; + final Future Function() _logs; + + FFmpegSessionResult({ + required this.returnCode, + required Future Function() logs, + }) : _logs = logs; + + bool get success => returnCode == 0; + + Future logs() => _logs(); +} + /// Result of an EBU R128 loudness scan, used to compute ReplayGain tags. class ReplayGainResult { /// Track gain in dB, e.g. "-6.50 dB". diff --git a/lib/services/audio_analysis_runner.dart b/lib/services/audio_analysis_runner.dart index 64c65415d..320df62b5 100644 --- a/lib/services/audio_analysis_runner.dart +++ b/lib/services/audio_analysis_runner.dart @@ -2,16 +2,14 @@ import 'dart:async'; import 'dart:io'; import 'dart:ui' as ui; -import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_kit.dart'; -import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_session.dart'; -import 'package:ffmpeg_kit_flutter_new_audio/ffprobe_kit.dart'; -import 'package:ffmpeg_kit_flutter_new_audio/return_code.dart'; import 'package:flutter/foundation.dart'; import 'package:flutter/services.dart'; import 'package:path_provider/path_provider.dart'; import 'package:mornye/services/audio_analysis_ffmpeg.dart'; import 'package:mornye/services/audio_analysis_jobs.dart'; import 'package:mornye/services/audio_analysis_models.dart'; +import 'package:mornye/services/ffmpeg_models.dart'; +import 'package:mornye/services/ffmpeg_support.dart'; import 'package:mornye/services/network_audio_analysis_input.dart'; import 'package:mornye/services/platform_bridge.dart'; @@ -120,22 +118,9 @@ class _LevelMetrics { /// and answers by throwing [AudioAnalysisCancelled]. class AudioAnalysisRunner { final networkInput = NetworkAudioAnalysisInput(); - final _analysisJobs = AudioAnalysisJobs( - start: (arguments) async { - final completed = Completer(); - final session = await FFmpegKit.executeWithArgumentsAsync( - arguments, - completed.complete, - ); - final id = session.getSessionId(); - if (id == null) { - // Never pass null to cancel: FFmpegKit interprets it as cancel-all. - await completed.future; - throw StateError('Analysis session has no ID'); - } - return (id: id, completed: completed.future); - }, - cancel: (id) => FFmpegKit.cancel(id), + final _analysisJobs = AudioAnalysisJobs( + start: FFmpegExecution.start, + cancel: FFmpegExecution.cancel, ); void _checkCancelled(bool Function() isCancelled) { @@ -351,9 +336,8 @@ class AudioAnalysisRunner { ), ); - final returnCode = await session.getReturnCode(); - if (!ReturnCode.isSuccess(returnCode)) { - final logs = await session.getLogsAsString(); + if (!session.success) { + final logs = await session.logs(); throw Exception('FFmpeg spectrogram failed: $logs'); } @@ -434,8 +418,7 @@ class AudioAnalysisRunner { } Future<_MediaInfo> _getMediaInfo(String filePath) async { - final session = await FFprobeKit.getMediaInformation(filePath); - final info = session.getMediaInformation(); + final info = await FFmpegExecution.mediaInformation(filePath); if (info == null) { throw Exception('Failed to get media information'); @@ -615,8 +598,7 @@ class AudioAnalysisRunner { ), ); - final returnCode = await session.getReturnCode(); - if (!ReturnCode.isSuccess(returnCode)) { + if (!session.success) { return null; } @@ -624,9 +606,7 @@ class AudioAnalysisRunner { ? await metadataFile.readAsString() : ''; final metadataSummary = parseAudioAnalysisMetadata(metadata); - final logs = metadataSummary == null - ? await session.getAllLogsAsString() ?? '' - : ''; + final logs = metadataSummary == null ? await session.logs() : ''; final summary = metadataSummary ?? parseAudioAstatsSummary(logs); if (summary == null) return null; final channelStats = metadataSummary?.channelStats.isNotEmpty == true diff --git a/lib/services/automix_analyzer.dart b/lib/services/automix_analyzer.dart index 95ba4f56a..a044cb2b0 100644 --- a/lib/services/automix_analyzer.dart +++ b/lib/services/automix_analyzer.dart @@ -1,13 +1,12 @@ import 'dart:async'; import 'dart:io'; -import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_kit.dart'; -import 'package:ffmpeg_kit_flutter_new_audio/return_code.dart'; import 'package:flutter/foundation.dart'; import 'package:flutter/services.dart'; import 'package:path_provider/path_provider.dart'; import 'package:mornye/services/audio_analysis_jobs.dart'; import 'package:mornye/services/automix_analysis.dart'; +import 'package:mornye/services/ffmpeg_support.dart'; import 'package:mornye/services/platform_bridge.dart'; import 'package:mornye/utils/logger.dart'; @@ -19,21 +18,19 @@ class AutoMixAnalyzer { final _cache = {}; final _jobs = AudioAnalysisJobs( start: (arguments) async { - final done = Completer(); - final session = await FFmpegKit.executeWithArgumentsAsync(arguments, ( - session, - ) async { - final success = ReturnCode.isSuccess(await session.getReturnCode()); - if (!done.isCompleted) done.complete(success); - }); - final id = session.getSessionId(); - if (id == null) throw StateError('AutoMix analysis session has no ID'); + final session = await FFmpegExecution.start(arguments); + final id = session.id; final timeout = Timer(const Duration(seconds: 20), () { - unawaited(FFmpegKit.cancel(id)); + unawaited(FFmpegExecution.cancel(id)); }); - return (id: id, completed: done.future.whenComplete(timeout.cancel)); + return ( + id: id, + completed: session.completed + .then((result) => result.success) + .whenComplete(timeout.cancel), + ); }, - cancel: FFmpegKit.cancel, + cancel: FFmpegExecution.cancel, ); int _generation = 0; final _nativeRequests = {}; diff --git a/lib/services/automix_effect_renderer.dart b/lib/services/automix_effect_renderer.dart index fde4ec02d..d3b9fc929 100644 --- a/lib/services/automix_effect_renderer.dart +++ b/lib/services/automix_effect_renderer.dart @@ -2,11 +2,10 @@ import 'dart:async'; import 'dart:io'; import 'dart:math'; -import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_kit.dart'; -import 'package:ffmpeg_kit_flutter_new_audio/return_code.dart'; import 'package:path_provider/path_provider.dart'; import 'package:mornye/models/automix_options.dart'; import 'package:mornye/services/audio_analysis_jobs.dart'; +import 'package:mornye/services/ffmpeg_support.dart'; /// Keep the beginning dry for the live deck handover, then ease in the FX. String autoMixEffectFilters(AutoMixOptions options, Duration duration) { @@ -57,7 +56,10 @@ class AutoMixEffectRenderer { Future Function()? temporaryDirectory, }) : _jobs = jobs ?? - AudioAnalysisJobs(start: _start, cancel: FFmpegKit.cancel), + AudioAnalysisJobs( + start: _start, + cancel: FFmpegExecution.cancel, + ), _temporaryDirectory = temporaryDirectory ?? getTemporaryDirectory; final AudioAnalysisJobs _jobs; @@ -67,21 +69,18 @@ class AutoMixEffectRenderer { static Future<({int id, Future completed})> _start( List arguments, ) async { - final done = Completer(); - final session = await FFmpegKit.executeWithArgumentsAsync(arguments, ( - session, - ) async { - if (!done.isCompleted) { - done.complete(ReturnCode.isSuccess(await session.getReturnCode())); - } - }); - final id = session.getSessionId(); - if (id == null) throw StateError('Mix effect session has no ID'); + final session = await FFmpegExecution.start(arguments); + final id = session.id; final timeout = Timer( const Duration(seconds: 30), - () => unawaited(FFmpegKit.cancel(id)), + () => unawaited(FFmpegExecution.cancel(id)), + ); + return ( + id: id, + completed: session.completed + .then((result) => result.success) + .whenComplete(timeout.cancel), ); - return (id: id, completed: done.future.whenComplete(timeout.cancel)); } void cancel() { diff --git a/lib/services/backend/rust_ffi_backend.dart b/lib/services/backend/rust_ffi_backend.dart index 84d1f9b9b..f7ea52857 100644 --- a/lib/services/backend/rust_ffi_backend.dart +++ b/lib/services/backend/rust_ffi_backend.dart @@ -6,6 +6,7 @@ import 'package:flutter/services.dart'; import 'package:mornye/services/backend/backend_channel.dart'; import 'package:mornye/services/backend/ffi_backend_transport.dart'; import 'package:mornye/services/backend/native_backend_transport.dart'; +import 'package:mornye/services/ffmpeg_desktop.dart'; import 'package:path_provider/path_provider.dart'; /// Error code of calls made while the desktop library cannot be loaded. @@ -43,23 +44,27 @@ class DesktopBackendConfig { final String? ffmpegPath; final String? ffprobePath; - /// Directories from path_provider. Desktop packaging passes the bundled - /// FFmpeg tool locations through [ffmpegPath] and [ffprobePath]. + /// Directories from path_provider. The FFmpeg tool locations default to + /// those [DesktopFFmpegTools] resolves, so Rust and Dart run one binary. static Future resolve({ String? ffmpegPath, String? ffprobePath, + Future Function()? locateTools, }) async { final directories = await Future.wait([ getApplicationSupportDirectory(), getApplicationDocumentsDirectory(), getTemporaryDirectory(), ]); + final tools = ffmpegPath != null && ffprobePath != null + ? null + : await (locateTools ?? () => DesktopFFmpegTools.shared)(); return DesktopBackendConfig( appSupportDir: directories[0].path, documentsDir: directories[1].path, tempDir: directories[2].path, - ffmpegPath: ffmpegPath, - ffprobePath: ffprobePath, + ffmpegPath: ffmpegPath ?? tools?.ffmpegPath, + ffprobePath: ffprobePath ?? tools?.ffprobePath, ); } diff --git a/lib/services/ffmpeg_desktop.dart b/lib/services/ffmpeg_desktop.dart new file mode 100644 index 000000000..8319c09dc --- /dev/null +++ b/lib/services/ffmpeg_desktop.dart @@ -0,0 +1,272 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; + +import 'package:ffmpeg_kit_flutter_new_audio/media_information.dart'; +import 'package:flutter/foundation.dart'; +import 'package:mornye/models/ffmpeg_models.dart'; +import 'package:mornye/utils/logger.dart'; +import 'package:path/path.dart' as p; + +final _log = AppLogger('FFmpeg'); + +/// Raised when a desktop FFmpeg tool is missing; its message is shown to +/// users as the reason a feature failed. +class FFmpegUnavailableException implements Exception { + const FFmpegUnavailableException(this.tool); + + /// `ffmpeg` or `ffprobe`. + final String tool; + + String get message => + '$tool is not available. Reinstall Mornye, or set ' + '${DesktopFFmpegTools.directoryVariable} to a folder that contains ' + 'ffmpeg and ffprobe.'; + + @override + String toString() => message; +} + +/// Locations of the standalone FFmpeg executables shipped with desktop builds. +/// +/// Lookup order for each tool: +/// 1. the folder named by `MORNYE_FFMPEG_DIR`; +/// 2. the app bundle: `Contents/Resources/ffmpeg/` then `Contents/MacOS/` on +/// macOS, `ffmpeg\` next to the executable on Windows, and `lib/ffmpeg/` +/// next to the executable on Linux (see scripts/fetch_desktop_ffmpeg.sh); +/// 3. `PATH`, a developer fallback. +@immutable +class DesktopFFmpegTools { + const DesktopFFmpegTools({this.ffmpegPath, this.ffprobePath}); + + static const directoryVariable = 'MORNYE_FFMPEG_DIR'; + + final String? ffmpegPath; + final String? ffprobePath; + + static Future? _shared; + + /// The tools of this process, located once. + static Future get shared => _shared ??= locate(); + + @visibleForTesting + static set debugShared(Future? tools) => _shared = tools; + + /// Folders searched for the tools, in order. + static List searchDirectories({ + required String operatingSystem, + required String executablePath, + required Map environment, + }) { + final windows = operatingSystem == 'windows'; + final path = windows ? p.windows : p.posix; + final executableDir = path.dirname(executablePath); + final override = environment[directoryVariable]?.trim() ?? ''; + final searchPath = + environment[windows ? 'Path' : 'PATH'] ?? environment['PATH'] ?? ''; + return [ + if (override.isNotEmpty) override, + ...switch (operatingSystem) { + 'macos' => [ + path.normalize(path.join(executableDir, '..', 'Resources', 'ffmpeg')), + executableDir, + ], + 'windows' => [path.join(executableDir, 'ffmpeg')], + _ => [path.join(executableDir, 'lib', 'ffmpeg')], + }, + ...searchPath + .split(windows ? ';' : ':') + .map((entry) => entry.trim()) + .where((entry) => entry.isNotEmpty), + ]; + } + + /// Resolves both tools; a missing tool stays null. + static Future locate({ + String? operatingSystem, + String? executablePath, + Map? environment, + Future Function(String path)? isFile, + }) async { + final os = operatingSystem ?? Platform.operatingSystem; + final exists = isFile ?? FileSystemEntity.isFile; + final directories = searchDirectories( + operatingSystem: os, + executablePath: executablePath ?? Platform.resolvedExecutable, + environment: environment ?? Platform.environment, + ); + final path = os == 'windows' ? p.windows : p.posix; + final suffix = os == 'windows' ? '.exe' : ''; + + Future find(String tool) async { + for (final directory in directories) { + final candidate = path.join(directory, '$tool$suffix'); + try { + if (await exists(candidate)) return candidate; + } catch (_) { + // Unreadable PATH entries are skipped. + } + } + return null; + } + + final tools = DesktopFFmpegTools( + ffmpegPath: await find('ffmpeg'), + ffprobePath: await find('ffprobe'), + ); + if (tools.ffmpegPath == null || tools.ffprobePath == null) { + _log.w( + 'Desktop FFmpeg tools missing (ffmpeg: ${tools.ffmpegPath}, ' + 'ffprobe: ${tools.ffprobePath})', + ); + } + return tools; + } +} + +/// Starts a tool process; injected by tests. +typedef FFmpegProcessStarter = + Future Function(String executable, List arguments); + +/// Builds the probe model FFprobeKit returns from `ffprobe -print_format +/// json` output. Returns null when ffprobe recognized nothing. +MediaInformation? parseFFprobeJson(String json) { + final Object? decoded; + try { + decoded = jsonDecode(json); + } on FormatException { + return null; + } + if (decoded is! Map || decoded.isEmpty) return null; + return MediaInformation(decoded); +} + +/// Runs the standalone `ffmpeg`/`ffprobe` executables, mirroring the FFmpegKit +/// session semantics the app relies on: an id per session, its return code +/// and log output on completion, and cancellation by id. +class DesktopFFmpegRunner { + DesktopFFmpegRunner({ + Future Function()? tools, + FFmpegProcessStarter? startProcess, + this.killGrace = const Duration(seconds: 2), + }) : _tools = tools ?? (() => DesktopFFmpegTools.shared), + _startProcess = startProcess ?? _defaultStart; + + static DesktopFFmpegRunner? _shared; + + static DesktopFFmpegRunner get shared => _shared ??= DesktopFFmpegRunner(); + + @visibleForTesting + static set debugShared(DesktopFFmpegRunner? runner) => _shared = runner; + + /// How long a cancelled process may run after SIGTERM before it is killed. + final Duration killGrace; + final Future Function() _tools; + final FFmpegProcessStarter _startProcess; + final _processes = {}; + int _nextId = 1; + + static Future _defaultStart( + String executable, + List arguments, + ) => Process.start(executable, arguments); + + static const _decoder = Utf8Decoder(allowMalformed: true); + + Future _tool(String name) async { + final tools = await _tools(); + final path = name == 'ffprobe' ? tools.ffprobePath : tools.ffmpegPath; + if (path == null) throw FFmpegUnavailableException(name); + return path; + } + + /// Starts `ffmpeg` with [arguments]. Throws [FFmpegUnavailableException] + /// when the executable is missing. + Future<({int id, Future completed})> start( + List arguments, + ) async { + final executable = await _tool('ffmpeg'); + // The CLI polls stdin for interactive keys; FFmpegKit never reads it. + final process = await _startProcess(executable, [ + if (!arguments.contains('-nostdin')) '-nostdin', + ...arguments, + ]); + final id = _nextId++; + _processes[id] = process; + unawaited(process.stdin.close().catchError((Object _) {})); + // FFmpegKit reports FFmpeg's log, which the CLI writes to stderr. + final logs = process.stderr.transform(_decoder).join(); + final stdout = process.stdout.drain(); + final completed = () async { + try { + final code = await process.exitCode; + final output = await logs; + await stdout; + return FFmpegSessionResult(returnCode: code, logs: () async => output); + } finally { + _processes.remove(id); + } + }(); + return (id: id, completed: completed); + } + + /// Runs `ffmpeg` to completion; failures, including a missing executable, + /// are reported in the result. + Future run(List arguments) async { + try { + final session = await start(arguments); + final result = await session.completed; + return FFmpegResult( + success: result.success, + returnCode: result.returnCode ?? -1, + output: await result.logs(), + ); + } catch (e) { + _log.e('FFmpeg process error: $e'); + return FFmpegResult(success: false, returnCode: -1, output: '$e'); + } + } + + /// Stops the session with [id]. FFmpeg finalizes on SIGTERM; a process that + /// does not exit within [killGrace] is killed. Unknown ids are ignored. + Future cancel(int id) async { + final process = _processes[id]; + if (process == null) return; + process.kill(); + if (Platform.isWindows) return; + unawaited( + process.exitCode.timeout( + killGrace, + onTimeout: () { + process.kill(ProcessSignal.sigkill); + return -1; + }, + ), + ); + } + + /// Probes [path] with `ffprobe`. Throws [FFmpegUnavailableException] when + /// the executable is missing; returns null when the probe fails. + Future probe(String path) async { + final executable = await _tool('ffprobe'); + final process = await _startProcess(executable, [ + '-v', + 'quiet', + '-print_format', + 'json', + '-show_format', + '-show_streams', + '-show_chapters', + '-i', + path, + ]); + unawaited(process.stdin.close().catchError((Object _) {})); + final stdout = process.stdout.transform(_decoder).join(); + final stderr = process.stderr.drain(); + final code = await process.exitCode; + final json = await stdout; + await stderr; + if (code != 0) return null; + return parseFFprobeJson(json); + } +} diff --git a/lib/services/ffmpeg_probe.dart b/lib/services/ffmpeg_probe.dart index 32d3b60a5..f3bffbdb0 100644 --- a/lib/services/ffmpeg_probe.dart +++ b/lib/services/ffmpeg_probe.dart @@ -1,6 +1,6 @@ import 'dart:io'; -import 'package:ffmpeg_kit_flutter_new_audio/ffprobe_kit.dart'; +import 'package:mornye/services/ffmpeg_support.dart'; import 'package:mornye/utils/logger.dart'; import 'package:mornye/utils/audio_format_utils.dart' as audio; @@ -40,9 +40,7 @@ abstract final class FFmpegProbe { static Future<({int width, int height})?> imageDimensions(String path) async { try { - final info = (await FFprobeKit.getMediaInformation( - path, - )).getMediaInformation(); + final info = await FFmpegExecution.mediaInformation(path); if (info == null) return null; for (final stream in info.getStreams()) { final dimensions = imageDimensionsFromProperties( @@ -89,9 +87,7 @@ abstract final class FFmpegProbe { String path, ) async { try { - final info = (await FFprobeKit.getMediaInformation( - path, - )).getMediaInformation(); + final info = await FFmpegExecution.mediaInformation(path); if (info == null) return const PrimaryAudioProperties(); for (final stream in info.getStreams()) { final props = stream.getAllProperties() ?? const {}; diff --git a/lib/services/ffmpeg_support.dart b/lib/services/ffmpeg_support.dart index 794adec6b..43423600e 100644 --- a/lib/services/ffmpeg_support.dart +++ b/lib/services/ffmpeg_support.dart @@ -1,17 +1,34 @@ +import 'dart:async'; import 'dart:io'; import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_kit.dart'; +import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_kit_config.dart'; +import 'package:ffmpeg_kit_flutter_new_audio/ffprobe_kit.dart'; +import 'package:ffmpeg_kit_flutter_new_audio/media_information.dart'; import 'package:ffmpeg_kit_flutter_new_audio/return_code.dart'; import 'package:path_provider/path_provider.dart'; +import 'package:mornye/services/ffmpeg_desktop.dart'; import 'package:mornye/services/ffmpeg_models.dart'; import 'package:mornye/services/ffmpeg_probe.dart'; +import 'package:mornye/utils/desktop_platform.dart'; import 'package:mornye/utils/logger.dart'; +export 'package:mornye/services/ffmpeg_desktop.dart' + show FFmpegUnavailableException; + final _log = AppLogger('FFmpeg'); /// Shared native execution boundary; feature modules supply their own commands. +/// Mobile runs FFmpegKit in process; desktop runs the bundled `ffmpeg` and +/// `ffprobe` executables through [DesktopFFmpegRunner]. abstract final class FFmpegExecution { static Future command(String command) async { + if (isDesktopPlatform) { + // FFmpegKit's own quoting rules, so commands behave as on mobile. + return DesktopFFmpegRunner.shared.run( + FFmpegKitConfig.parseArguments(command), + ); + } try { final session = await FFmpegKit.execute(command); final code = await session.getReturnCode(); @@ -27,6 +44,7 @@ abstract final class FFmpegExecution { } static Future arguments(List arguments) async { + if (isDesktopPlatform) return DesktopFFmpegRunner.shared.run(arguments); try { final session = await FFmpegKit.executeWithArguments(arguments); final code = await session.getReturnCode(); @@ -41,6 +59,50 @@ abstract final class FFmpegExecution { } } + /// Starts a cancellable session; [cancel] takes its id. Throws when the + /// session cannot start, including [FFmpegUnavailableException] on desktop. + static Future<({int id, Future completed})> start( + List arguments, + ) async { + if (isDesktopPlatform) return DesktopFFmpegRunner.shared.start(arguments); + final completed = Completer(); + final session = await FFmpegKit.executeWithArgumentsAsync(arguments, ( + session, + ) async { + int? code; + try { + code = (await session.getReturnCode())?.getValue(); + } catch (e) { + _log.w('FFmpeg return code unavailable: $e'); + } + if (completed.isCompleted) return; + completed.complete( + FFmpegSessionResult( + returnCode: code, + logs: () async => await session.getAllLogsAsString() ?? '', + ), + ); + }); + final id = session.getSessionId(); + if (id == null) { + // Never pass null to cancel: FFmpegKit interprets it as cancel-all. + await completed.future; + throw StateError('FFmpeg session has no ID'); + } + return (id: id, completed: completed.future); + } + + static Future cancel(int id) => isDesktopPlatform + ? DesktopFFmpegRunner.shared.cancel(id) + : FFmpegKit.cancel(id); + + /// FFprobe media information, or null when the file cannot be probed. + /// Throws [FFmpegUnavailableException] when desktop ffprobe is missing. + static Future mediaInformation(String path) async { + if (isDesktopPlatform) return DesktopFFmpegRunner.shared.probe(path); + return (await FFprobeKit.getMediaInformation(path)).getMediaInformation(); + } + static String preview(String command) { final redacted = command .replaceAll( diff --git a/lib/services/motion_artwork_store.dart b/lib/services/motion_artwork_store.dart index fbc22b128..f6b1023ae 100644 --- a/lib/services/motion_artwork_store.dart +++ b/lib/services/motion_artwork_store.dart @@ -3,10 +3,9 @@ import 'dart:convert'; import 'dart:io'; import 'package:crypto/crypto.dart'; -import 'package:ffmpeg_kit_flutter_new_audio/ffmpeg_kit.dart'; -import 'package:ffmpeg_kit_flutter_new_audio/return_code.dart'; import 'package:path_provider/path_provider.dart'; import 'package:mornye/services/ffmpeg_service.dart'; +import 'package:mornye/services/ffmpeg_support.dart'; import 'package:mornye/services/motion_artwork_download.dart'; import 'package:mornye/services/motion_artwork_proxy.dart'; import 'package:mornye/utils/file_access.dart'; @@ -280,19 +279,14 @@ class MotionArtworkStore { List arguments, { required Duration timeout, }) async { - final completed = Completer(); - final session = await FFmpegKit.executeWithArgumentsAsync(arguments, ( - session, - ) async { - final success = ReturnCode.isSuccess(await session.getReturnCode()); - if (!completed.isCompleted) completed.complete(success); - }); - return completed.future.timeout( + final session = await FFmpegExecution.start(arguments); + final completed = session.completed.then((result) => result.success); + return completed.timeout( timeout, onTimeout: () async { - await FFmpegKit.cancel(session.getSessionId()); + await FFmpegExecution.cancel(session.id); // Wait for this session to release its file before removing partials. - await completed.future.timeout( + await completed.timeout( const Duration(seconds: 5), onTimeout: () => false, ); diff --git a/test/ffmpeg_desktop_test.dart b/test/ffmpeg_desktop_test.dart new file mode 100644 index 000000000..a0fdabf95 --- /dev/null +++ b/test/ffmpeg_desktop_test.dart @@ -0,0 +1,401 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; +import 'dart:typed_data'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:mornye/services/ffmpeg_desktop.dart'; +import 'package:mornye/services/ffmpeg_probe.dart'; +import 'package:mornye/services/ffmpeg_support.dart'; +import 'package:mornye/utils/desktop_platform.dart'; + +class _DiscardingConsumer implements StreamConsumer> { + @override + Future addStream(Stream> stream) => stream.drain(); + + @override + Future close() async {} +} + +class _FakeProcess implements Process { + _FakeProcess({String stdoutText = '', String stderrText = ''}) { + _stdout + ..add(utf8.encode(stdoutText)) + ..close(); + _stderr + ..add(utf8.encode(stderrText)) + ..close(); + } + + final _stdout = StreamController>(); + final _stderr = StreamController>(); + final _exit = Completer(); + final kills = []; + + void finish(int code) { + if (!_exit.isCompleted) _exit.complete(code); + } + + @override + Stream> get stdout => _stdout.stream; + + @override + Stream> get stderr => _stderr.stream; + + @override + IOSink get stdin => IOSink(_DiscardingConsumer()); + + @override + Future get exitCode => _exit.future; + + @override + int get pid => 42; + + @override + bool kill([ProcessSignal signal = ProcessSignal.sigterm]) { + kills.add(signal); + finish(255); + return true; + } +} + +class _Starts { + final calls = <(String, List)>[]; + final processes = <_FakeProcess>[]; + _FakeProcess Function() next = _FakeProcess.new; + + Future call(String executable, List arguments) async { + calls.add((executable, arguments)); + final process = next(); + processes.add(process); + return process; + } +} + +const _tools = DesktopFFmpegTools( + ffmpegPath: '/bundle/ffmpeg', + ffprobePath: '/bundle/ffprobe', +); + +const _probeJson = ''' +{ + "streams": [ + {"index": 0, "codec_name": "mjpeg", "codec_type": "video", + "width": 600, "height": 500}, + {"index": 1, "codec_name": "flac", "codec_type": "audio", + "sample_fmt": "s32", "sample_rate": "96000", "channels": 2, + "bits_per_raw_sample": "24", "duration": "12.500000"} + ], + "chapters": [], + "format": {"filename": "a.flac", "format_name": "flac", + "duration": "12.500000", "bit_rate": "2400000"} +} +'''; + +Future _writeWav(File file) async { + const sampleRate = 8000; + const samples = sampleRate ~/ 4; + final data = ByteData(44 + samples * 2); + void ascii(int offset, String text) { + for (var i = 0; i < text.length; i++) { + data.setUint8(offset + i, text.codeUnitAt(i)); + } + } + + ascii(0, 'RIFF'); + data.setUint32(4, 36 + samples * 2, Endian.little); + ascii(8, 'WAVE'); + ascii(12, 'fmt '); + data.setUint32(16, 16, Endian.little); + data.setUint16(20, 1, Endian.little); + data.setUint16(22, 1, Endian.little); + data.setUint32(24, sampleRate, Endian.little); + data.setUint32(28, sampleRate * 2, Endian.little); + data.setUint16(32, 2, Endian.little); + data.setUint16(34, 16, Endian.little); + ascii(36, 'data'); + data.setUint32(40, samples * 2, Endian.little); + for (var i = 0; i < samples; i++) { + data.setInt16(44 + i * 2, (i % 40 - 20) * 800, Endian.little); + } + await file.writeAsBytes(data.buffer.asUint8List()); +} + +void main() { + group('DesktopFFmpegTools', () { + test('searches the override, the bundle, then PATH', () { + expect( + DesktopFFmpegTools.searchDirectories( + operatingSystem: 'macos', + executablePath: '/Applications/Mornye.app/Contents/MacOS/Mornye', + environment: {'MORNYE_FFMPEG_DIR': '/opt/ff', 'PATH': '/a:/b'}, + ), + [ + '/opt/ff', + '/Applications/Mornye.app/Contents/Resources/ffmpeg', + '/Applications/Mornye.app/Contents/MacOS', + '/a', + '/b', + ], + ); + expect( + DesktopFFmpegTools.searchDirectories( + operatingSystem: 'linux', + executablePath: '/opt/mornye/mornye', + environment: {'PATH': '/usr/bin'}, + ), + ['/opt/mornye/lib/ffmpeg', '/usr/bin'], + ); + expect( + DesktopFFmpegTools.searchDirectories( + operatingSystem: 'windows', + executablePath: r'C:\Program Files\Mornye\mornye.exe', + environment: {'PATH': r'C:\tools;;C:\bin'}, + ), + [r'C:\Program Files\Mornye\ffmpeg', r'C:\tools', r'C:\bin'], + ); + }); + + test('takes each tool from the first folder that has it', () async { + final existing = { + '/usr/local/bin/ffmpeg', + '/opt/mornye/lib/ffmpeg/ffmpeg', + '/opt/mornye/lib/ffmpeg/ffprobe', + }; + final tools = await DesktopFFmpegTools.locate( + operatingSystem: 'linux', + executablePath: '/opt/mornye/mornye', + environment: { + 'MORNYE_FFMPEG_DIR': '/usr/local/bin', + 'PATH': '/usr/bin', + }, + isFile: (path) async => existing.contains(path), + ); + expect(tools.ffmpegPath, '/usr/local/bin/ffmpeg'); + expect(tools.ffprobePath, '/opt/mornye/lib/ffmpeg/ffprobe'); + }); + + test('appends .exe on Windows and leaves missing tools null', () async { + final tools = await DesktopFFmpegTools.locate( + operatingSystem: 'windows', + executablePath: r'C:\Mornye\mornye.exe', + environment: const {}, + isFile: (path) async => path == r'C:\Mornye\ffmpeg\ffmpeg.exe', + ); + expect(tools.ffmpegPath, r'C:\Mornye\ffmpeg\ffmpeg.exe'); + expect(tools.ffprobePath, isNull); + }); + }); + + group('DesktopFFmpegRunner', () { + test('runs ffmpeg with an argument list and returns its log', () async { + final starts = _Starts(); + final runner = DesktopFFmpegRunner( + tools: () async => _tools, + startProcess: starts.call, + ); + final pending = runner.run(['-i', 'in put.flac', 'out.mp3']); + await pumpEventQueue(); + starts.processes.single.finish(0); + starts.next = () => + _FakeProcess(stderrText: 'Conversion failed!')..finish(1); + + final ok = await pending; + expect(starts.calls.single.$1, '/bundle/ffmpeg'); + expect(starts.calls.single.$2, [ + '-nostdin', + '-i', + 'in put.flac', + 'out.mp3', + ]); + expect(ok.success, isTrue); + expect(ok.returnCode, 0); + + final failed = await runner.run(['-nostdin', '-i', 'x']); + expect(starts.calls.last.$2, ['-nostdin', '-i', 'x']); + expect(failed.success, isFalse); + expect(failed.returnCode, 1); + expect(failed.output, 'Conversion failed!'); + }); + + test('cancels only the owned session', () async { + final starts = _Starts(); + final runner = DesktopFFmpegRunner( + tools: () async => _tools, + startProcess: starts.call, + ); + final first = await runner.start(['-i', 'a']); + final second = await runner.start(['-i', 'b']); + expect(first.id, isNot(second.id)); + + await runner.cancel(first.id); + final result = await first.completed; + expect(result.success, isFalse); + expect(starts.processes.first.kills, [ProcessSignal.sigterm]); + expect(starts.processes.last.kills, isEmpty); + + await runner.cancel(first.id); + await runner.cancel(999); + expect(starts.processes.first.kills, hasLength(1)); + starts.processes.last.finish(0); + expect((await second.completed).success, isTrue); + }); + + test('reports a missing executable clearly', () async { + final runner = DesktopFFmpegRunner( + tools: () async => const DesktopFFmpegTools(), + startProcess: (_, _) => throw StateError('must not start'), + ); + await expectLater( + runner.start(['-i', 'a']), + throwsA( + isA().having( + (e) => e.message, + 'message', + contains('MORNYE_FFMPEG_DIR'), + ), + ), + ); + await expectLater( + runner.probe('a.flac'), + throwsA(isA()), + ); + final result = await runner.run(['-i', 'a']); + expect(result.success, isFalse); + expect(result.output, contains('ffmpeg is not available')); + }); + + test('probes with ffprobe JSON into MediaInformation', () async { + final starts = _Starts() + ..next = () => _FakeProcess(stdoutText: _probeJson)..finish(0); + final runner = DesktopFFmpegRunner( + tools: () async => _tools, + startProcess: starts.call, + ); + final info = await runner.probe('/music/a.flac'); + expect(starts.calls.single.$1, '/bundle/ffprobe'); + expect(starts.calls.single.$2, [ + '-v', + 'quiet', + '-print_format', + 'json', + '-show_format', + '-show_streams', + '-show_chapters', + '-i', + '/music/a.flac', + ]); + expect(info!.getDuration(), '12.500000'); + expect(info.getBitrate(), '2400000'); + expect(info.getFormat(), 'flac'); + final streams = info.getStreams(); + expect(streams.map((s) => s.getType()), ['video', 'audio']); + expect( + FFmpegProbe.imageDimensionsFromProperties( + streams.first.getAllProperties()!, + ), + (width: 600, height: 500), + ); + expect(streams.last.getAllProperties()!['bits_per_raw_sample'], '24'); + + starts.next = () => _FakeProcess(stdoutText: '{}')..finish(1); + expect(await runner.probe('/music/missing.flac'), isNull); + }); + + test('parseFFprobeJson rejects empty or invalid output', () { + expect(parseFFprobeJson(''), isNull); + expect(parseFFprobeJson('{}'), isNull); + expect(parseFFprobeJson('[1]'), isNull); + expect(parseFFprobeJson(_probeJson)!.getStreams(), hasLength(2)); + }); + }); + + group('FFmpegExecution on desktop', () { + late _Starts starts; + + setUp(() { + debugDesktopPlatformOverride = true; + starts = _Starts()..next = () => _FakeProcess()..finish(0); + DesktopFFmpegRunner.debugShared = DesktopFFmpegRunner( + tools: () async => _tools, + startProcess: starts.call, + ); + }); + + tearDown(() { + debugDesktopPlatformOverride = null; + DesktopFFmpegRunner.debugShared = null; + }); + + test('splits command strings with FFmpegKit quoting', () async { + final result = await FFmpegExecution.command( + '-v error -i "/music/My Song.flac" -metadata title=\'A B\' out.mp3', + ); + expect(result.success, isTrue); + expect(starts.calls.single.$2, [ + '-nostdin', + '-v', + 'error', + '-i', + '/music/My Song.flac', + '-metadata', + 'title=A B', + 'out.mp3', + ]); + }); + + test('routes sessions and cancellation to the process runner', () async { + starts.next = _FakeProcess.new; + final session = await FFmpegExecution.start(['-i', 'a']); + await FFmpegExecution.cancel(session.id); + expect((await session.completed).success, isFalse); + expect(starts.processes.single.kills, isNotEmpty); + }); + }); + + final hostTools = DesktopFFmpegTools.locate( + environment: {'PATH': Platform.environment['PATH'] ?? ''}, + ); + + test( + 'converts a generated WAV to FLAC and probes it with host binaries', + () async { + final tools = await hostTools; + if (tools.ffmpegPath == null || tools.ffprobePath == null) { + markTestSkipped('ffmpeg and ffprobe are not on PATH'); + return; + } + debugDesktopPlatformOverride = true; + DesktopFFmpegRunner.debugShared = DesktopFFmpegRunner( + tools: () async => tools, + ); + final directory = await Directory.systemTemp.createTemp('mornye-ff-'); + addTearDown(() async { + debugDesktopPlatformOverride = null; + DesktopFFmpegRunner.debugShared = null; + await directory.delete(recursive: true); + }); + final wav = File('${directory.path}/tone in.wav'); + final flac = '${directory.path}/tone out.flac'; + await _writeWav(wav); + + final result = await FFmpegExecution.arguments([ + '-v', + 'error', + '-i', + wav.path, + '-c:a', + 'flac', + flac, + ]); + expect(result.success, isTrue, reason: result.output); + + final properties = await FFmpegProbe.audioProperties(flac); + expect(properties.codec, 'flac'); + expect(properties.sampleRate, 8000); + expect(properties.bitDepth, 16); + expect(await FFmpegProbe.isNativeFlacFile(flac), isTrue); + }, + timeout: const Timeout(Duration(seconds: 60)), + ); +}