feat(backend): extract audio duration during transcoding and persist to track

backend/Musify.Application/Contracts/IAudioTranscoderService.cs

@@ -2,7 +2,7 @@ namespace Musify.Application.Contracts
 {
     public interface IAudioTranscoderService
     {
-        Task<int> TranscodeToAudioFileAsync(Stream audioStream, string destinationPath, CancellationToken cancellationToken);
+        Task<TimeSpan> TranscodeToAudioFileAsync(Stream audioStream, string destinationPath, CancellationToken cancellationToken);
 
         Task<bool> IsValidAudioFileAsync(string filePath, CancellationToken cancellationToken);
     }

backend/Musify.Infrastructure/MassTransit/Activities/Audio/TranscodeAudioActivity.cs

@@ -38,16 +38,22 @@ namespace Musify.Infrastructure.MassTransit.Activities.Audio
 
             try
             {
+                TimeSpan duration;
                 await using (var fileStream = File.OpenRead(sourceFilePath))
                 {
-                    await audioTranscoder.TranscodeToAudioFileAsync(
+                    duration = await audioTranscoder.TranscodeToAudioFileAsync(
                         fileStream,
                         workingDirectory,
                         executeContext.CancellationToken);
                 }
 
                 File.Delete(sourceFilePath);
-                return executeContext.Completed();
+
+                var log = new TranscodeAudioLog(workingDirectory);
+                return executeContext.CompletedWithVariables(log, new Dictionary<string, object>
+                {
+                    [RoutingSlipVariableNames.Audio.DurationSeconds] = (int)Math.Round(duration.TotalSeconds)
+                } );
             }
             catch (Exception exception)
             {

backend/Musify.Infrastructure/MassTransit/Activities/Audio/UpdateTrackAudioActivity.cs

@@ -47,11 +47,16 @@ namespace Musify.Infrastructure.MassTransit.Activities.Audio
 
             try
             {
+                var durationSeconds = executeContext.GetVariable<int>(executeContext.Arguments.DurationSecondsVariable)
+                    ?? throw new InvalidOperationException($"Missing routing slip variable {executeContext.Arguments.DurationSecondsVariable}");
+
                 var log = new UpdateTrackAudioLog(
                     track.Id,
-                    track.AudioFolderName);
+                    track.AudioFolderName,
+                    track.Duration);
 
                 track.AudioFolderName = Path.GetFileName(audioFolderKey);
+                track.Duration = durationSeconds;
                 track.AudioTranscodeProcessingStatus = ProcessingStatus.Completed;
                 await database.SaveChangesAsync(executeContext.CancellationToken);
 
@@ -92,6 +97,7 @@ namespace Musify.Infrastructure.MassTransit.Activities.Audio
                     throw new InvalidOperationException($"Track with id {compensateContext.Log.TrackId} not found");
 
                 track.AudioFolderName = compensateContext.Log.PreviousAudioFolderName;
+                track.Duration = compensateContext.Log.PreviousDuration;
                 track.AudioTranscodeProcessingStatus = ProcessingStatus.Failed;
                 await database.SaveChangesAsync(compensateContext.CancellationToken);
 

backend/Musify.Infrastructure/MassTransit/Arguments/UpdateTrackAudioArguments.cs

@@ -2,5 +2,6 @@
 {
     public record UpdateTrackAudioArguments(
         Guid TrackId,
-        string AudioFolderKey);
+        string AudioFolderKey,
+        string DurationSecondsVariable);
 }

backend/Musify.Infrastructure/MassTransit/Logs/UpdateTrackAudioLog.cs

@@ -2,5 +2,6 @@
 {
     public record UpdateTrackAudioLog(
         Guid TrackId,
-        string? PreviousAudioFolderName);
+        string? PreviousAudioFolderName,
+        int PreviousDuration);
 }

backend/Musify.Infrastructure/MassTransit/RoutingSlip/Builders/AudioWorkflowRoutingSlipBuilder.cs

@@ -58,7 +58,8 @@ namespace Musify.Infrastructure.MassTransit.RoutingSlip.Builders
                 EndpointHelper.BuildExecuteActivityUri(UpdateTrackAudioActivity.ExecuteEndpointName),
                 new UpdateTrackAudioArguments(
                     message.TrackId,
-                    message.DestinationFolderKey));
+                    message.DestinationFolderKey,
+                    RoutingSlipVariableNames.Audio.DurationSeconds));
 
             routingSlipBuilder.AddVariable(RoutingSlipVariableNames.Workflow.SubjectId, message.TrackId);
             routingSlipBuilder.AddVariable(RoutingSlipVariableNames.Workflow.ProcessKind, RoutingSlipVariableNames.ProcessKinds.TrackAudio);

backend/Musify.Infrastructure/MassTransit/RoutingSlip/RoutingSlipVariableNames.cs

@@ -21,6 +21,7 @@ namespace Musify.Infrastructure.MassTransit
         {
             internal const string SourceFilePath = "Audio.SourceFilePath";
             internal const string TranscodedDirectory = "Audio.TranscodedDirectory";
+            internal const string DurationSeconds = "Audio.DurationSeconds";
         }
 
         internal static class Picture

backend/Musify.Infrastructure/Services/AudioTranscoderService.cs

@@ -2,16 +2,21 @@ using Microsoft.Extensions.Logging;
 using Musify.Application.Contracts;
 using Musify.Infrastructure.Configuration;
 using System.Diagnostics;
+using System.Globalization;
+using System.Text.RegularExpressions;
 
 namespace Musify.Infrastructure.Services
 {
-    public class AudioTranscoderService(ILogger<AudioTranscoderService> logger,
+    public partial class AudioTranscoderService(ILogger<AudioTranscoderService> logger,
         AudioTranscoderConfiguration audioTranscoderConfiguration)
         : IAudioTranscoderService
     {
         record FfmpegExecutionResult(int ExitCode, string StandardOutput, string StandardError);
 
-        public async Task<int> TranscodeToAudioFileAsync(Stream audioStream, string destinationPath, CancellationToken cancellationToken)
+        [GeneratedRegex(@"Duration:\s*(\d+):(\d{2}):(\d{2}(?:\.\d+)?)", RegexOptions.IgnoreCase)]
+        private static partial Regex DurationRegex();
+
+        public async Task<TimeSpan> TranscodeToAudioFileAsync(Stream audioStream, string destinationPath, CancellationToken cancellationToken)
         {
             try
             {
@@ -30,13 +35,13 @@ namespace Musify.Infrastructure.Services
                 {
                     logger.LogError("Audio transcoding failed with exit code {ExitCode}. Output: {StandardOutput}, Error: {StandardError}",
                         executionResult.ExitCode, executionResult.StandardOutput, executionResult.StandardError);
-                }
-                else
-                {
-                    logger.LogInformation("Audio transcoding completed for {DestinationPath}", destinationPath);
+                    throw new InvalidOperationException($"ffmpeg transcoding failed with exit code {executionResult.ExitCode}.");
                 }
 
-                return executionResult.ExitCode;
+                logger.LogInformation("Audio transcoding completed for {DestinationPath}", destinationPath);
+
+                var outputPath = Path.Combine(destinationPath, audioTranscoderConfiguration.Ffmpeg.OutputFileName);
+                return await GetAudioDurationAsync(outputPath, cancellationToken);
             }
             catch (TimeoutException timeoutException)
             {
@@ -50,6 +55,25 @@ namespace Musify.Infrastructure.Services
             }
         }
 
+        async Task<TimeSpan> GetAudioDurationAsync(string filePath, CancellationToken cancellationToken)
+        {
+            var executionResult = await ExecuteFfmpegAsync(
+                BuildProbeDurationArguments(filePath),
+                Path.GetDirectoryName(filePath) ?? Environment.CurrentDirectory,
+                "ProbeAudioDuration",
+                cancellationToken);
+
+            var match = DurationRegex().Match(executionResult.StandardError);
+            if (!match.Success)
+                throw new InvalidOperationException($"Could not determine audio duration for {filePath}.");
+
+            var hours = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
+            var minutes = int.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture);
+            var seconds = double.Parse(match.Groups[3].Value, CultureInfo.InvariantCulture);
+
+            return new TimeSpan(hours, minutes, 0) + TimeSpan.FromSeconds(seconds);
+        }
+
         public async Task<bool> IsValidAudioFileAsync(string filePath, CancellationToken cancellationToken)
         {
             if (!File.Exists(filePath))
@@ -216,5 +240,8 @@ namespace Musify.Infrastructure.Services
 
         static string BuildValidateAudioArguments(string filePath)
             => $"-v error -i \"{filePath}\" -map 0:a:0 -f null -";
+
+        static string BuildProbeDurationArguments(string filePath)
+            => $"-hide_banner -i \"{filePath}\" -f null -";
     }
 }