Merge pull request #9920 from nielsvanvelzen/lyric-parser

6 files changed, 181 insertions, 103 deletions

diff --git a/MediaBrowser.Providers/Lyric/DefaultLyricProvider.cs b/MediaBrowser.Providers/Lyric/DefaultLyricProvider.cs
new file mode 100644
index 0000000000..ab09f278aa
--- /dev/null
+++ b/MediaBrowser.Providers/Lyric/DefaultLyricProvider.cs
@@ -0,0 +1,69 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Resolvers;
+
+namespace MediaBrowser.Providers.Lyric;
+
+/// <inheritdoc />
+public class DefaultLyricProvider : ILyricProvider
+{
+    private static readonly string[] _lyricExtensions = { ".lrc", ".elrc", ".txt" };
+
+    /// <inheritdoc />
+    public string Name => "DefaultLyricProvider";
+
+    /// <inheritdoc />
+    public ResolverPriority Priority => ResolverPriority.First;
+
+    /// <inheritdoc />
+    public bool HasLyrics(BaseItem item)
+    {
+        var path = GetLyricsPath(item);
+        return path is not null;
+    }
+
+    /// <inheritdoc />
+    public async Task<LyricFile?> GetLyrics(BaseItem item)
+    {
+        var path = GetLyricsPath(item);
+        if (path is not null)
+        {
+            var content = await File.ReadAllTextAsync(path).ConfigureAwait(false);
+            if (!string.IsNullOrEmpty(content))
+            {
+                return new LyricFile(path, content);
+            }
+        }
+
+        return null;
+    }
+
+    private string? GetLyricsPath(BaseItem item)
+    {
+        // Ensure the path to the item is not null
+        string? itemDirectoryPath = Path.GetDirectoryName(item.Path);
+        if (itemDirectoryPath is null)
+        {
+            return null;
+        }
+
+        // Ensure the directory path exists
+        if (!Directory.Exists(itemDirectoryPath))
+        {
+            return null;
+        }
+
+        foreach (var lyricFilePath in Directory.GetFiles(itemDirectoryPath, $"{Path.GetFileNameWithoutExtension(item.Path)}.*"))
+        {
+            if (_lyricExtensions.Contains(Path.GetExtension(lyricFilePath.AsSpan()), StringComparison.OrdinalIgnoreCase))
+            {
+                return lyricFilePath;
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/MediaBrowser.Providers/Lyric/ILyricProvider.cs b/MediaBrowser.Providers/Lyric/ILyricProvider.cs
new file mode 100644
index 0000000000..27ceba72bf
--- /dev/null
+++ b/MediaBrowser.Providers/Lyric/ILyricProvider.cs
@@ -0,0 +1,36 @@
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Resolvers;
+
+namespace MediaBrowser.Providers.Lyric;
+
+/// <summary>
+/// Interface ILyricsProvider.
+/// </summary>
+public interface ILyricProvider
+{
+    /// <summary>
+    /// Gets a value indicating the provider name.
+    /// </summary>
+    string Name { get; }
+
+    /// <summary>
+    /// Gets the priority.
+    /// </summary>
+    /// <value>The priority.</value>
+    ResolverPriority Priority { get; }
+
+    /// <summary>
+    /// Checks if an item has lyrics available.
+    /// </summary>
+    /// <param name="item">The media item.</param>
+    /// <returns>Whether lyrics where found or not.</returns>
+    bool HasLyrics(BaseItem item);
+
+    /// <summary>
+    /// Gets the lyrics.
+    /// </summary>
+    /// <param name="item">The media item.</param>
+    /// <returns>A task representing found lyrics.</returns>
+    Task<LyricFile?> GetLyrics(BaseItem item);
+}
diff --git a/MediaBrowser.Providers/Lyric/LrcLyricProvider.cs b/MediaBrowser.Providers/Lyric/LrcLyricParser.cs
index 7b108921b3..7f1ecd7435 100644
--- a/MediaBrowser.Providers/Lyric/LrcLyricProvider.cs
+++ b/MediaBrowser.Providers/Lyric/LrcLyricParser.cs
@@ -3,34 +3,29 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;
+using Jellyfin.Extensions;
 using LrcParser.Model;
 using LrcParser.Parser;
-using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Lyrics;
 using MediaBrowser.Controller.Resolvers;
-using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.Providers.Lyric;
 
 /// <summary>
-/// LRC Lyric Provider.
+/// LRC Lyric Parser.
 /// </summary>
-public class LrcLyricProvider : ILyricProvider
+public class LrcLyricParser : ILyricParser
 {
-    private readonly ILogger<LrcLyricProvider> _logger;
-
     private readonly LyricParser _lrcLyricParser;
 
+    private static readonly string[] _supportedMediaTypes = { ".lrc", ".elrc" };
     private static readonly string[] _acceptedTimeFormats = { "HH:mm:ss", "H:mm:ss", "mm:ss", "m:ss" };
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="LrcLyricProvider"/> class.
+    /// Initializes a new instance of the <see cref="LrcLyricParser"/> class.
     /// </summary>
-    /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
-    public LrcLyricProvider(ILogger<LrcLyricProvider> logger)
+    public LrcLyricParser()
     {
-        _logger = logger;
         _lrcLyricParser = new LrcParser.Parser.Lrc.LrcParser();
     }
 
@@ -41,37 +36,25 @@ public class LrcLyricProvider : ILyricProvider
     /// Gets the priority.
     /// </summary>
     /// <value>The priority.</value>
-    public ResolverPriority Priority => ResolverPriority.First;
+    public ResolverPriority Priority => ResolverPriority.Fourth;
 
     /// <inheritdoc />
-    public IReadOnlyCollection<string> SupportedMediaTypes { get; } = new[] { "lrc", "elrc" };
-
-    /// <summary>
-    /// Opens lyric file for the requested item, and processes it for API return.
-    /// </summary>
-    /// <param name="item">The item to to process.</param>
-    /// <returns>If provider can determine lyrics, returns a <see cref="LyricResponse"/> with or without metadata; otherwise, null.</returns>
-    public async Task<LyricResponse?> GetLyrics(BaseItem item)
+    public LyricResponse? ParseLyrics(LyricFile lyrics)
     {
-        string? lyricFilePath = this.GetLyricFilePath(item.Path);
-
-        if (string.IsNullOrEmpty(lyricFilePath))
+        if (!_supportedMediaTypes.Contains(Path.GetExtension(lyrics.Name.AsSpan()), StringComparison.OrdinalIgnoreCase))
         {
             return null;
         }
 
-        var fileMetaData = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-        string lrcFileContent = await File.ReadAllTextAsync(lyricFilePath).ConfigureAwait(false);
-
         Song lyricData;
 
         try
         {
-            lyricData = _lrcLyricParser.Decode(lrcFileContent);
+            lyricData = _lrcLyricParser.Decode(lyrics.Content);
         }
-        catch (Exception ex)
+        catch (Exception)
         {
-            _logger.LogError(ex, "Error parsing lyric file {LyricFilePath} from {Provider}", lyricFilePath, Name);
+            // Failed to parse, return null so the next parser will be tried
             return null;
         }
 
@@ -84,6 +67,7 @@ public class LrcLyricProvider : ILyricProvider
             .Select(x => x.Text)
             .ToList();
 
+        var fileMetaData = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
         foreach (string metaDataRow in metaDataRows)
         {
             var index = metaDataRow.IndexOf(':', StringComparison.OrdinalIgnoreCase);
@@ -130,17 +114,10 @@ public class LrcLyricProvider : ILyricProvider
             // Map metaData values from LRC file to LyricMetadata properties
             LyricMetadata lyricMetadata = MapMetadataValues(fileMetaData);
 
-            return new LyricResponse
-            {
-                Metadata = lyricMetadata,
-                Lyrics = lyricList
-            };
+            return new LyricResponse { Metadata = lyricMetadata, Lyrics = lyricList };
         }
 
-        return new LyricResponse
-        {
-            Lyrics = lyricList
-        };
+        return new LyricResponse { Lyrics = lyricList };
     }
 
     /// <summary>
diff --git a/MediaBrowser.Providers/Lyric/LyricManager.cs b/MediaBrowser.Providers/Lyric/LyricManager.cs
index f9547e0f05..6da8119275 100644
--- a/MediaBrowser.Providers/Lyric/LyricManager.cs
+++ b/MediaBrowser.Providers/Lyric/LyricManager.cs
@@ -12,14 +12,17 @@ namespace MediaBrowser.Providers.Lyric;
 public class LyricManager : ILyricManager
 {
     private readonly ILyricProvider[] _lyricProviders;
+    private readonly ILyricParser[] _lyricParsers;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="LyricManager"/> class.
     /// </summary>
     /// <param name="lyricProviders">All found lyricProviders.</param>
-    public LyricManager(IEnumerable<ILyricProvider> lyricProviders)
+    /// <param name="lyricParsers">All found lyricParsers.</param>
+    public LyricManager(IEnumerable<ILyricProvider> lyricProviders, IEnumerable<ILyricParser> lyricParsers)
     {
         _lyricProviders = lyricProviders.OrderBy(i => i.Priority).ToArray();
+        _lyricParsers = lyricParsers.OrderBy(i => i.Priority).ToArray();
     }
 
     /// <inheritdoc />
@@ -27,10 +30,19 @@ public class LyricManager : ILyricManager
     {
         foreach (ILyricProvider provider in _lyricProviders)
         {
-            var results = await provider.GetLyrics(item).ConfigureAwait(false);
-            if (results is not null)
+            var lyrics = await provider.GetLyrics(item).ConfigureAwait(false);
+            if (lyrics is null)
             {
-                return results;
+                continue;
+            }
+
+            foreach (ILyricParser parser in _lyricParsers)
+            {
+                var result = parser.ParseLyrics(lyrics);
+                if (result is not null)
+                {
+                    return result;
+                }
             }
         }
 
@@ -47,7 +59,7 @@ public class LyricManager : ILyricManager
                 continue;
             }
 
-            if (provider.GetLyricFilePath(item.Path) is not null)
+            if (provider.HasLyrics(item))
             {
                 return true;
             }
diff --git a/MediaBrowser.Providers/Lyric/TxtLyricParser.cs b/MediaBrowser.Providers/Lyric/TxtLyricParser.cs
new file mode 100644
index 0000000000..706f13dbcd
--- /dev/null
+++ b/MediaBrowser.Providers/Lyric/TxtLyricParser.cs
@@ -0,0 +1,44 @@
+using System;
+using System.IO;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Lyrics;
+using MediaBrowser.Controller.Resolvers;
+
+namespace MediaBrowser.Providers.Lyric;
+
+/// <summary>
+/// TXT Lyric Parser.
+/// </summary>
+public class TxtLyricParser : ILyricParser
+{
+    private static readonly string[] _supportedMediaTypes = { ".lrc", ".elrc", ".txt" };
+    private static readonly string[] _lineBreakCharacters = { "\r\n", "\r", "\n" };
+
+    /// <inheritdoc />
+    public string Name => "TxtLyricProvider";
+
+    /// <summary>
+    /// Gets the priority.
+    /// </summary>
+    /// <value>The priority.</value>
+    public ResolverPriority Priority => ResolverPriority.Fifth;
+
+    /// <inheritdoc />
+    public LyricResponse? ParseLyrics(LyricFile lyrics)
+    {
+        if (!_supportedMediaTypes.Contains(Path.GetExtension(lyrics.Name.AsSpan()), StringComparison.OrdinalIgnoreCase))
+        {
+            return null;
+        }
+
+        string[] lyricTextLines = lyrics.Content.Split(_lineBreakCharacters, StringSplitOptions.None);
+        LyricLine[] lyricList = new LyricLine[lyricTextLines.Length];
+
+        for (int lyricLineIndex = 0; lyricLineIndex < lyricTextLines.Length; lyricLineIndex++)
+        {
+            lyricList[lyricLineIndex] = new LyricLine(lyricTextLines[lyricLineIndex]);
+        }
+
+        return new LyricResponse { Lyrics = lyricList };
+    }
+}
diff --git a/MediaBrowser.Providers/Lyric/TxtLyricProvider.cs b/MediaBrowser.Providers/Lyric/TxtLyricProvider.cs
deleted file mode 100644
index a9099d1927..0000000000
--- a/MediaBrowser.Providers/Lyric/TxtLyricProvider.cs
+++ /dev/null
@@ -1,60 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Threading.Tasks;
-using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Lyrics;
-using MediaBrowser.Controller.Resolvers;
-
-namespace MediaBrowser.Providers.Lyric;
-
-/// <summary>
-/// TXT Lyric Provider.
-/// </summary>
-public class TxtLyricProvider : ILyricProvider
-{
-    /// <inheritdoc />
-    public string Name => "TxtLyricProvider";
-
-    /// <summary>
-    /// Gets the priority.
-    /// </summary>
-    /// <value>The priority.</value>
-    public ResolverPriority Priority => ResolverPriority.Second;
-
-    /// <inheritdoc />
-    public IReadOnlyCollection<string> SupportedMediaTypes { get; } = new[] { "lrc", "elrc", "txt" };
-
-    /// <summary>
-    /// Opens lyric file for the requested item, and processes it for API return.
-    /// </summary>
-    /// <param name="item">The item to to process.</param>
-    /// <returns>If provider can determine lyrics, returns a <see cref="LyricResponse"/>; otherwise, null.</returns>
-    public async Task<LyricResponse?> GetLyrics(BaseItem item)
-    {
-        string? lyricFilePath = this.GetLyricFilePath(item.Path);
-
-        if (string.IsNullOrEmpty(lyricFilePath))
-        {
-            return null;
-        }
-
-        string[] lyricTextLines = await File.ReadAllLinesAsync(lyricFilePath).ConfigureAwait(false);
-
-        if (lyricTextLines.Length == 0)
-        {
-            return null;
-        }
-
-        LyricLine[] lyricList = new LyricLine[lyricTextLines.Length];
-
-        for (int lyricLineIndex = 0; lyricLineIndex < lyricTextLines.Length; lyricLineIndex++)
-        {
-            lyricList[lyricLineIndex] = new LyricLine(lyricTextLines[lyricLineIndex]);
-        }
-
-        return new LyricResponse
-        {
-            Lyrics = lyricList
-        };
-    }
-}