Added ffmpeg player retry when source is invalid

Author: standleypg

src/Application/Interfaces/Services/INativePlaceMusicProcessorService.cs

@@ -7,4 +7,5 @@ public interface INativePlaceMusicProcessorService
     Task<Process> CreateStreamAsync(string audioUrl, CancellationToken cancellationToken);
     event Func<Task>? OnExitProcess;
     event Func<Task>? OnProcessStart;
+    event Func<Task>? ErrorDataReceived;
 }

src/Infrastructure/Services/FfmpegProcessService.cs

@@ -11,7 +11,8 @@ public class FfmpegProcessService(ILogger<FfmpegProcessService> logger, IMusicQu
     private bool _disposed;
     public event Func<Task>? OnExitProcess;
     public event Func<Task>? OnProcessStart;
-    
+    public event Func<Task>? ErrorDataReceived;
+
     public async Task<Process> CreateStreamAsync(string audioUrl, CancellationToken cancellationToken)
     {
         DisposeCurrentProcess();
@@ -33,17 +34,23 @@ public async Task<Process> CreateStreamAsync(string audioUrl, CancellationToken
         };
 
         // Set up logging
-        process.ErrorDataReceived += (_, e) =>
+        process.ErrorDataReceived += async (_, e) =>
         {
             if (string.IsNullOrEmpty(e.Data)) return;
 
             var level = e.Data.Contains("error", StringComparison.OrdinalIgnoreCase) ||
-                        e.Data.Contains("warning", StringComparison.OrdinalIgnoreCase) ||
                         e.Data.Contains("failed", StringComparison.OrdinalIgnoreCase)
-                ? LogLevel.Warning
-                : LogLevel.Debug;
+                ? LogLevel.Error
+                : e.Data.Contains("warning", StringComparison.OrdinalIgnoreCase)
+                    ? LogLevel.Warning
+                    : LogLevel.Debug;
 
             logger.Log(level, "FFmpeg: {Message}", e.Data);
+
+            if (level == LogLevel.Error)
+            {
+                await (ErrorDataReceived?.Invoke() ?? Task.CompletedTask);
+            }
         };
 
         process.Exited += async (sender, _) =>
@@ -60,7 +67,7 @@ public async Task<Process> CreateStreamAsync(string audioUrl, CancellationToken
                 logger.LogDebug(ex, "Error reading FFmpeg exit code");
             }
         };
-        
+
         // Handle cancellation
         cancellationToken.Register(() =>
         {

src/Infrastructure/Services/NetCordAudioPlayerService.cs

@@ -21,6 +21,8 @@ public class NetCordAudioPlayerService(
     public event Func<Task>? NotInVoiceChannelCallback;
     private Action<Func<Task>> OnDisconnectAsync { get; set; } = _ => { };
     private StringMenuInteractionContext Context { get; set; } = null!;
+    
+    private int _retryCount = 0;
 
     public async Task Play<T>(T ctx, Action<Func<Task>> onDisconnectAsync)
     {
@@ -80,39 +82,9 @@ async Task HandleVoiceStream()
             }
 
             var selectedValue = currentTrack.Context.SelectedValues[0];
-            string sourceUrl;
+            var sourceUrl = await GetSourceUrl(selectedValue, radioSourceService, youTubeService, currentTrack);
 
-            if (Guid.TryParse(selectedValue, out var radioId))
-            {
-                sourceUrl = (await radioSourceService.GetRadioSourceByIdAsync(radioId)).SourceUrl;
-            }
-            else
-            {
-                sourceUrl = await youTubeService.GetAudioStreamUrlAsync(selectedValue,
-                    playerState.SkipCts?.Token ?? CancellationToken.None);
-                
-                var song = new SongDtoBase
-                {
-                    Url = selectedValue,
-                    Title = await youTubeService.GetVideoTitleAsync(selectedValue,
-                        playerState.SkipCts?.Token ?? CancellationToken.None),
-                    UserId = currentTrack.Context.User.Id
-                };
-                ffmpegProcessService.OnProcessStart += () => HandleOnProcessStartAsync(song);
-            }
-
-            var ffmpeg =
-                await ffmpegProcessService.CreateStreamAsync(sourceUrl,
-                    playerState.SkipCts?.Token ?? CancellationToken.None);
-            
-
-            ffmpegProcessService.OnExitProcess += HandleOnProcessExitAsync;
-
-            await ffmpeg.StandardOutput.BaseStream.CopyToAsync(stream,
-                playerState.SkipCts?.Token ?? CancellationToken.None);
-
-            // Flush 'stream' to make sure all the data has been sent and to indicate to Discord that we have finished sending
-            await stream.FlushAsync(playerState.SkipCts?.Token ?? CancellationToken.None);
+            await StartFfmpegStream(sourceUrl, stream);
         }
 
         async Task StartVoiceClientAsync()
@@ -146,9 +118,54 @@ await client.UpdateVoiceStateAsync(
                 playerState.StopCts?.Token ?? CancellationToken.None);
             await playerState.CurrentVoiceClient.CloseAsync(
                 cancellationToken: playerState.StopCts?.Token ?? CancellationToken.None);
+            
+            _retryCount = 0;
         }
     }
 
+    private async Task StartFfmpegStream(string sourceUrl, OpusEncodeStream stream)
+    {
+        var ffmpeg =
+            await ffmpegProcessService.CreateStreamAsync(sourceUrl,
+                playerState.SkipCts?.Token ?? CancellationToken.None);
+            
+        ffmpegProcessService.ErrorDataReceived += HandleFfmpegErrorAsync;
+        ffmpegProcessService.OnExitProcess += HandleOnProcessExitAsync;
+
+        await ffmpeg.StandardOutput.BaseStream.CopyToAsync(stream,
+            playerState.SkipCts?.Token ?? CancellationToken.None);
+
+        // Flush 'stream' to make sure all the data has been sent and to indicate to Discord that we have finished sending
+        await stream.FlushAsync(playerState.SkipCts?.Token ?? CancellationToken.None);
+    }
+
+    private async Task<string> GetSourceUrl(string selectedValue, IRadioSourceService radioSourceService,
+        IStreamService youTubeService, PlayRequest<StringMenuInteractionContext> currentTrack)
+    {
+        string sourceUrl;
+
+        if (Guid.TryParse(selectedValue, out var radioId))
+        {
+            sourceUrl = (await radioSourceService.GetRadioSourceByIdAsync(radioId)).SourceUrl;
+        }
+        else
+        {
+            sourceUrl = await youTubeService.GetAudioStreamUrlAsync(selectedValue,
+                playerState.SkipCts?.Token ?? CancellationToken.None);
+                
+            var song = new SongDtoBase
+            {
+                Url = selectedValue,
+                Title = await youTubeService.GetVideoTitleAsync(selectedValue,
+                    playerState.SkipCts?.Token ?? CancellationToken.None),
+                UserId = currentTrack.Context.User.Id
+            };
+            ffmpegProcessService.OnProcessStart += () => HandleOnProcessStartAsync(song);
+        }
+
+        return sourceUrl;
+    }
+
     private async Task HandleOnProcessStartAsync(SongDtoBase song)
     {
         using var scope = serviceProvider.CreateScope();
@@ -174,4 +191,18 @@ private async ValueTask HandleOnVoiceClientDisconnectedAsync(DisconnectEventArgs
     {
         await (DisconnectedVoiceClientEvent?.Invoke() ?? Task.CompletedTask);
     }
+    
+    private async Task HandleFfmpegErrorAsync()
+    {
+        // Retry to get new stream URL and play again
+        logger.LogWarning("Ffmpeg error received, retrying to play the stream");
+        _retryCount++;
+        if(_retryCount > 3)
+        {
+            logger.LogError("Ffmpeg error received, maximum retry count reached, stopping playback");
+            await (DisconnectedVoiceClientEvent?.Invoke() ?? Task.CompletedTask);
+            return;
+        }
+        await HandleMusicPlayingAsync();
+    }
 }