Prefer mp4 over mkv if no re-encoding is done

This also removes -shortest that was used earlier

Author: Marcos Cordeiro

Wasari.App/GenericDownloadService.cs

@@ -11,17 +11,21 @@ namespace Wasari.App;
 
 public class GenericDownloadService : IDownloadService
 {
-    public GenericDownloadService(ILogger<GenericDownloadService> logger, FFmpegService fFmpegService, IOptions<DownloadOptions> options, YoutubeDlpService youtubeDlpService)
+    public GenericDownloadService(ILogger<GenericDownloadService> logger, FFmpegService fFmpegService, IOptions<DownloadOptions> options, YoutubeDlpService youtubeDlpService, IOptions<FFmpegOptions> fFmpegOptions)
     {
         Logger = logger;
         FFmpegService = fFmpegService;
         Options = options;
         YoutubeDlpService = youtubeDlpService;
+        FFmpegOptions = fFmpegOptions;
     }
 
     protected ILogger<GenericDownloadService> Logger { get; }
 
+    
     private IOptions<DownloadOptions> Options { get; }
+    
+    private IOptions<FFmpegOptions> FFmpegOptions { get; }
 
     private FFmpegService FFmpegService { get; }
 
@@ -107,7 +111,7 @@ private async Task<DownloadedEpisode> DownloadEpisode(WasariEpisode episode, Dow
         return new DownloadedEpisode(filepath, sucess ? DownloadedEpisodeStatus.Downloaded : DownloadedEpisodeStatus.Failed, episode);
     }
 
-    private static StringBuilder BuildEpisodeName(IWasariEpisode episode)
+    private StringBuilder BuildEpisodeName(IWasariEpisode episode)
     {
         var episodeNameBuilder = new StringBuilder();
 
@@ -118,7 +122,7 @@ private static StringBuilder BuildEpisodeName(IWasariEpisode episode)
         if (episode.Number.HasValue || episode.SeasonNumber.HasValue)
             episodeNameBuilder.Append(" - ");
         episodeNameBuilder.Append(episode.Title);
-        episodeNameBuilder.Append(".mkv");
+        episodeNameBuilder.Append(FFmpegOptions.Value.UseHevc ? ".mkv" : ".mp4");
         return episodeNameBuilder;
     }
 }

Wasari.Crunchyroll/CrunchyrollDownloadService.cs

@@ -18,9 +18,9 @@ namespace Wasari.Crunchyroll;
 internal class CrunchyrollDownloadService : GenericDownloadService
 {
     public CrunchyrollDownloadService(ILogger<CrunchyrollDownloadService> logger, FFmpegService fFmpegService, IOptions<DownloadOptions> options, YoutubeDlpService youtubeDlpService, CrunchyrollApiService crunchyrollApiService, IOptions<DownloadOptions> downloadOptions,
-        IServiceProvider serviceProvider, IOptions<AuthenticationOptions> authenticationOptions) : base(logger, fFmpegService,
+        IServiceProvider serviceProvider, IOptions<AuthenticationOptions> authenticationOptions, IOptions<FFmpegOptions> fFmpegOptions) : base(logger, fFmpegService,
         options,
-        youtubeDlpService)
+        youtubeDlpService, fFmpegOptions)
     {
         CrunchyrollApiService = crunchyrollApiService;
         DownloadOptions = downloadOptions;

Wasari.FFmpeg/FFmpegService.cs

@@ -154,8 +154,13 @@ private async IAsyncEnumerable<string> BuildArgumentsForEpisode(IWasariEpisode e
         {
             yield return "-c:v copy";
         }
-
-        yield return "-shortest -fflags shortest -max_interleave_delta 100M";
+        
+        var fileExtension = Path.GetExtension(filePath);
+        var isMp4 = fileExtension == ".mp4";
+        
+        if (isMp4)
+            yield return "-c:s mov_text";
+        
         yield return "-y";
         yield return $"\"{filePath}\"";
     }
@@ -166,15 +171,49 @@ private static Command CreateCommand()
             .WithWorkingDirectory(Environment.CurrentDirectory);
     }
 
-    private string? GetTemporaryFile()
+    private string? GetTemporaryFile(string? baseFilePath = null)
     {
+        if (baseFilePath != null)
+        {
+            var fileName = Path.GetFileNameWithoutExtension(baseFilePath);
+            var fileExtension = Path.GetExtension(baseFilePath);
+            var fileDirectory = Path.GetDirectoryName(baseFilePath);
+            
+            return $"{fileDirectory}{Path.DirectorySeparatorChar}{fileName}_wasari_tmp.{fileExtension}";
+        }
+        
         if (!Options.Value.UseTemporaryEncodingPath)
             return null;
 
         var tempFileName = Path.GetFileNameWithoutExtension(Path.GetTempFileName());
-        return Path.Combine(Path.GetTempPath(), $"{tempFileName}.mkv");
+        return Path.Combine(Path.GetTempPath(), $"{tempFileName}.mp4");
     }
 
+    public TimeSpan? GetVideoDuration(IMediaAnalysis mediaAnalysis)
+    {
+        var videoDuration = mediaAnalysis.VideoStreams.Max(o => o.Duration);
+
+        if (videoDuration == TimeSpan.Zero && (mediaAnalysis.PrimaryVideoStream?.Tags?.TryGetValue("DURATION", out var durationStr) ?? false))
+        {
+            var match = DurationRegex().Match(durationStr);
+            var originalTrail = match.Groups["trail"].Value;
+            var correctedTrail = originalTrail.TrimEnd('0');
+            durationStr = durationStr.Replace(originalTrail, correctedTrail);
+
+            if (TimeSpan.TryParse(durationStr, out var newVideoDuratio))
+            {
+                videoDuration = newVideoDuratio;
+            }
+            else
+            {
+                Logger.LogWarning("Failed to parse duration string: {DurationStr}", durationStr);
+                return null;
+            }
+        }
+
+        return videoDuration == TimeSpan.Zero ? null : videoDuration;
+    }
+    
     public async Task<bool> CheckIfVideoStreamIsValid(string filePath)
     {
         try
@@ -184,25 +223,10 @@ public async Task<bool> CheckIfVideoStreamIsValid(string filePath)
             if (fileAnalysis.ErrorData.Count > 0)
                 return false;
 
-            var videoDuration = fileAnalysis.VideoStreams.Max(o => o.Duration);
-
-            if (videoDuration == TimeSpan.Zero && (fileAnalysis.PrimaryVideoStream?.Tags?.TryGetValue("DURATION", out var durationStr) ?? false))
-            {
-                var match = DurationRegex().Match(durationStr);
-                var originalTrail = match.Groups["trail"].Value;
-                var correctedTrail = originalTrail.TrimEnd('0');
-                durationStr = durationStr.Replace(originalTrail, correctedTrail);
+            var videoDuration = GetVideoDuration(fileAnalysis);
 
-                if (TimeSpan.TryParse(durationStr, out var newVideoDuratio))
-                {
-                    videoDuration = newVideoDuratio;
-                }
-                else
-                {
-                    Logger.LogWarning("Failed to parse duration string: {DurationStr}", durationStr);
-                    return false;
-                }
-            }
+            if(videoDuration == null)
+                return false;
 
             var delta = fileAnalysis.Duration - videoDuration;
             var isValid = videoDuration >= fileAnalysis.Duration || delta < TimeSpan.FromSeconds(10);
@@ -230,7 +254,7 @@ public async Task DownloadEpisode<T>(T episode, string filePath, IProgress<FFmpe
             .WithArguments(arguments, false);
 
         await foreach (var commandEvent in ffmpegCommand.ListenAsync()) ProcessEvent(episode, progress, commandEvent, ffmpegCommand);
-
+        
         if (tempFileName != null)
         {
             var destFileTempName = $"{filePath}.wasari_tmp";