From 61fa325ef05daac7c5105623d2de435ec94ef6a7 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Mon, 28 Mar 2022 23:11:21 +0200
Subject: [PATCH 01/13] Extend music parsing

---
 Emby.Naming/Common/NamingOptions.cs           |  23 +++
 .../Resolvers/Audio/MusicAlbumResolver.cs     |  11 +-
 .../Entities/Audio/MusicAlbum.cs              |   2 +-
 .../MediaBrowser.Providers.csproj             |   1 +
 .../MediaInfo/FFProbeAudioInfo.cs             | 119 ++++++++------
 .../Music/AlbumMetadataService.cs             | 152 ++++++++++++++++--
 .../Music/AudioMetadataService.cs             |  40 +++++
 7 files changed, 287 insertions(+), 61 deletions(-)

diff --git a/Emby.Naming/Common/NamingOptions.cs b/Emby.Naming/Common/NamingOptions.cs
index e016d7e51f..ddeec679d4 100644
--- a/Emby.Naming/Common/NamingOptions.cs
+++ b/Emby.Naming/Common/NamingOptions.cs
@@ -181,6 +181,24 @@ namespace Emby.Naming.Common
                 "volume"
             };
 
+            ArtistSubfolders = new[]
+            {
+                "albums",
+                "broadcasts",
+                "bootlegs",
+                "compilations",
+                "dj-mixes",
+                "eps",
+                "live",
+                "mixtapes",
+                "others",
+                "remixes",
+                "singles",
+                "soundtracks",
+                "spokenwords",
+                "streets"
+            };
+
             AudioFileExtensions = new[]
             {
                 ".669",
@@ -732,6 +750,11 @@ namespace Emby.Naming.Common
         /// </summary>
         public string[] AlbumStackingPrefixes { get; set; }
 
+        /// <summary>
+        /// Gets or sets list of artist subfolders.
+        /// </summary>
+        public string[] ArtistSubfolders { get; set; }
+
         /// <summary>
         /// Gets or sets list of subtitle file extensions.
         /// </summary>
diff --git a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
index da00b9cfa8..5e05ddfb16 100644
--- a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -98,7 +99,15 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
             // Args points to an album if parent is an Artist folder or it directly contains music
             if (args.IsDirectory)
             {
-                // if (args.Parent is MusicArtist) return true;  // saves us from testing children twice
+                foreach (var subfolder in _namingOptions.ArtistSubfolders)
+                {
+                    if (Path.GetDirectoryName(args.Path.AsSpan()).Equals(subfolder, StringComparison.OrdinalIgnoreCase))
+                    {
+                        _logger.LogDebug("Found release folder: {Path}", args.Path);
+                        return false;
+                    }
+                }
+
                 if (ContainsMusic(args.FileSystemChildren, true, args.DirectoryService))
                 {
                     return true;
diff --git a/MediaBrowser.Controller/Entities/Audio/MusicAlbum.cs b/MediaBrowser.Controller/Entities/Audio/MusicAlbum.cs
index bd397bdd13..6555de8554 100644
--- a/MediaBrowser.Controller/Entities/Audio/MusicAlbum.cs
+++ b/MediaBrowser.Controller/Entities/Audio/MusicAlbum.cs
@@ -54,7 +54,7 @@ namespace MediaBrowser.Controller.Entities.Audio
         public string AlbumArtist => AlbumArtists.FirstOrDefault();
 
         [JsonIgnore]
-        public override bool SupportsPeople => false;
+        public override bool SupportsPeople => true;
 
         /// <summary>
         /// Gets the tracks.
diff --git a/MediaBrowser.Providers/MediaBrowser.Providers.csproj b/MediaBrowser.Providers/MediaBrowser.Providers.csproj
index 9864db9ac2..459045dffc 100644
--- a/MediaBrowser.Providers/MediaBrowser.Providers.csproj
+++ b/MediaBrowser.Providers/MediaBrowser.Providers.csproj
@@ -22,6 +22,7 @@
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="OptimizedPriorityQueue" Version="5.1.0" />
     <PackageReference Include="PlaylistsNET" Version="1.2.1" />
+    <PackageReference Include="TagLibSharp" Version="2.2.0" />
     <PackageReference Include="TMDbLib" Version="1.9.2" />
   </ItemGroup>
 
diff --git a/MediaBrowser.Providers/MediaInfo/FFProbeAudioInfo.cs b/MediaBrowser.Providers/MediaInfo/FFProbeAudioInfo.cs
index f22965436f..e801a20efb 100644
--- a/MediaBrowser.Providers/MediaInfo/FFProbeAudioInfo.cs
+++ b/MediaBrowser.Providers/MediaInfo/FFProbeAudioInfo.cs
@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -17,6 +18,7 @@ using MediaBrowser.Model.Dlna;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.MediaInfo;
+using TagLib;
 
 namespace MediaBrowser.Providers.MediaInfo
 {
@@ -93,7 +95,7 @@ namespace MediaBrowser.Providers.MediaInfo
             // var extension = (Path.GetExtension(audio.Path) ?? string.Empty).TrimStart('.');
             // audio.Container = extension;
 
-            FetchDataFromTags(audio, mediaInfo);
+            FetchDataFromTags(audio);
 
             _itemRepo.SaveMediaStreams(audio.Id, mediaInfo.MediaStreams, cancellationToken);
         }
@@ -102,71 +104,90 @@ namespace MediaBrowser.Providers.MediaInfo
         /// Fetches data from the tags dictionary.
         /// </summary>
         /// <param name="audio">The audio.</param>
-        /// <param name="data">The data.</param>
-        private void FetchDataFromTags(Audio audio, Model.MediaInfo.MediaInfo data)
+        private void FetchDataFromTags(Audio audio)
         {
-            // Only set Name if title was found in the dictionary
-            if (!string.IsNullOrEmpty(data.Name))
+            var file = TagLib.File.Create(audio.Path);
+            var tagTypes = file.TagTypesOnDisk;
+            Tag tags = null;
+
+            if (tagTypes.HasFlag(TagTypes.Id3v2))
             {
-                audio.Name = data.Name;
+                tags = file.GetTag(TagTypes.Id3v2);
             }
-
-            if (!string.IsNullOrEmpty(data.ForcedSortName))
+            else if (tagTypes.HasFlag(TagTypes.Ape))
             {
-                audio.ForcedSortName = data.ForcedSortName;
+                tags = file.GetTag(TagTypes.Ape);
             }
-
-            if (audio.SupportsPeople && !audio.LockedFields.Contains(MetadataField.Cast))
+            else if (tagTypes.HasFlag(TagTypes.FlacMetadata))
             {
-                var people = new List<PersonInfo>();
+                tags = file.GetTag(TagTypes.FlacMetadata);
+            }
+            else if (tagTypes.HasFlag(TagTypes.Id3v1))
+            {
+                tags = file.GetTag(TagTypes.Id3v1);
+            }
 
-                foreach (var person in data.People)
+            if (tags != null)
+            {
+                if (audio.SupportsPeople && !audio.LockedFields.Contains(MetadataField.Cast))
                 {
-                    PeopleHelper.AddPerson(people, new PersonInfo
+                    var people = new List<PersonInfo>();
+                    var albumArtists = tags.AlbumArtists;
+                    foreach (var albumArtist in albumArtists)
                     {
-                        Name = person.Name,
-                        Type = person.Type,
-                        Role = person.Role
-                    });
-                }
-
-                _libraryManager.UpdatePeople(audio, people);
-            }
+                        PeopleHelper.AddPerson(people, new PersonInfo
+                        {
+                            Name = albumArtist,
+                            Type = "AlbumArtist"
+                        });
+                    }
 
-            audio.Album = data.Album;
-            audio.Artists = data.Artists;
-            audio.AlbumArtists = data.AlbumArtists;
-            audio.IndexNumber = data.IndexNumber;
-            audio.ParentIndexNumber = data.ParentIndexNumber;
-            audio.ProductionYear = data.ProductionYear;
-            audio.PremiereDate = data.PremiereDate;
+                    var performers = tags.Performers;
+                    foreach (var performer in performers)
+                    {
+                        PeopleHelper.AddPerson(people, new PersonInfo
+                        {
+                            Name = performer,
+                            Type = "Artist"
+                        });
+                    }
 
-            // If we don't have a ProductionYear try and get it from PremiereDate
-            if (audio.PremiereDate.HasValue && !audio.ProductionYear.HasValue)
-            {
-                audio.ProductionYear = audio.PremiereDate.Value.ToLocalTime().Year;
-            }
+                    foreach (var composer in tags.Composers)
+                    {
+                        PeopleHelper.AddPerson(people, new PersonInfo
+                        {
+                            Name = composer,
+                            Type = "Composer"
+                        });
+                    }
+
+                    _libraryManager.UpdatePeople(audio, people);
+                    audio.Artists = performers;
+                    audio.AlbumArtists = albumArtists;
+                }
 
-            if (!audio.LockedFields.Contains(MetadataField.Genres))
-            {
-                audio.Genres = Array.Empty<string>();
+                audio.Name = tags.Title;
+                audio.Album = tags.Album;
+                audio.IndexNumber = Convert.ToInt32(tags.Track);
+                audio.ParentIndexNumber = Convert.ToInt32(tags.Disc);
+                if(tags.Year != 0)
+                {
+                    var year = Convert.ToInt32(tags.Year);
+                    audio.ProductionYear = year;
+                    audio.PremiereDate = new DateTime(year, 01, 01);
+                }
 
-                foreach (var genre in data.Genres)
+                if (!audio.LockedFields.Contains(MetadataField.Genres))
                 {
-                    audio.AddGenre(genre);
+                    audio.Genres = tags.Genres.Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
                 }
-            }
 
-            if (!audio.LockedFields.Contains(MetadataField.Studios))
-            {
-                audio.SetStudios(data.Studios);
+                audio.SetProviderId(MetadataProvider.MusicBrainzArtist, tags.MusicBrainzArtistId);
+                audio.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, tags.MusicBrainzReleaseArtistId);
+                audio.SetProviderId(MetadataProvider.MusicBrainzAlbum, tags.MusicBrainzReleaseId);
+                audio.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, tags.MusicBrainzReleaseGroupId);
+                audio.SetProviderId(MetadataProvider.MusicBrainzTrack, tags.MusicBrainzTrackId);
             }
-
-            audio.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, data.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist));
-            audio.SetProviderId(MetadataProvider.MusicBrainzArtist, data.GetProviderId(MetadataProvider.MusicBrainzArtist));
-            audio.SetProviderId(MetadataProvider.MusicBrainzAlbum, data.GetProviderId(MetadataProvider.MusicBrainzAlbum));
-            audio.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, data.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup));
-            audio.SetProviderId(MetadataProvider.MusicBrainzTrack, data.GetProviderId(MetadataProvider.MusicBrainzTrack));
         }
     }
 }
diff --git a/MediaBrowser.Providers/Music/AlbumMetadataService.cs b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
index 7743d3b27b..b8426f31c1 100644
--- a/MediaBrowser.Providers/Music/AlbumMetadataService.cs
+++ b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
@@ -61,40 +61,61 @@ namespace MediaBrowser.Providers.Music
 
                 var songs = children.Cast<Audio>().ToArray();
 
-                updateType |= SetAlbumArtistFromSongs(item, songs);
                 updateType |= SetArtistsFromSongs(item, songs);
+                updateType |= SetAlbumArtistFromSongs(item, songs);
+                updateType |= SetAlbumFromSongs(item, songs);
+                updateType |= SetPeople(item);
             }
 
             return updateType;
         }
 
-        private ItemUpdateType SetAlbumArtistFromSongs(MusicAlbum item, IEnumerable<Audio> songs)
+        private ItemUpdateType SetAlbumArtistFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
         {
             var updateType = ItemUpdateType.None;
 
-            var artists = songs
+            var albumArtists = songs
                 .SelectMany(i => i.AlbumArtists)
-                .Distinct(StringComparer.OrdinalIgnoreCase)
-                .OrderBy(i => i)
+                .GroupBy(i => i)
+                .OrderByDescending(g => g.Count())
+                .Select(g => g.Key)
+                .ToArray();
+
+            var musicbrainzAlbumArtistIds = songs
+                .Select(i => i.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist))
+                .GroupBy(i => i)
+                .OrderByDescending(g => g.Count())
+                .Select(g => g.Key)
                 .ToArray();
 
-            if (!item.AlbumArtists.SequenceEqual(artists, StringComparer.OrdinalIgnoreCase))
+            var musicbrainzAlbumArtistId = item.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
+            var firstMusicbrainzAlbumArtistId = musicbrainzAlbumArtistIds[0];
+            if (!string.IsNullOrEmpty(firstMusicbrainzAlbumArtistId) &&
+                (string.IsNullOrEmpty(musicbrainzAlbumArtistId)
+                    || !musicbrainzAlbumArtistId.Equals(firstMusicbrainzAlbumArtistId, StringComparison.OrdinalIgnoreCase)))
+            {
+                item.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, firstMusicbrainzAlbumArtistId);
+                updateType |= ItemUpdateType.MetadataEdit;
+            }
+
+            if (!item.AlbumArtists.SequenceEqual(albumArtists, StringComparer.OrdinalIgnoreCase))
             {
-                item.AlbumArtists = artists;
+                item.AlbumArtists = albumArtists;
                 updateType |= ItemUpdateType.MetadataEdit;
             }
 
             return updateType;
         }
 
-        private ItemUpdateType SetArtistsFromSongs(MusicAlbum item, IEnumerable<Audio> songs)
+        private ItemUpdateType SetArtistsFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
         {
             var updateType = ItemUpdateType.None;
 
             var artists = songs
                 .SelectMany(i => i.Artists)
-                .Distinct(StringComparer.OrdinalIgnoreCase)
-                .OrderBy(i => i)
+                .GroupBy(i => i)
+                .OrderByDescending(g => g.Count())
+                .Select(g => g.Key)
                 .ToArray();
 
             if (!item.Artists.SequenceEqual(artists, StringComparer.OrdinalIgnoreCase))
@@ -106,6 +127,78 @@ namespace MediaBrowser.Providers.Music
             return updateType;
         }
 
+        private ItemUpdateType SetAlbumFromSongs(MusicAlbum item, IReadOnlyList<Audio> songs)
+        {
+            var updateType = ItemUpdateType.None;
+
+            var musicbrainzAlbumIds = songs
+                .Select(i => i.GetProviderId(MetadataProvider.MusicBrainzAlbum))
+                .GroupBy(i => i)
+                .OrderByDescending(g => g.Count())
+                .Select(g => g.Key)
+                .ToArray();
+
+            var musicbrainzAlbumId = item.GetProviderId(MetadataProvider.MusicBrainzAlbum);
+            if (!String.IsNullOrEmpty(musicbrainzAlbumIds[0])
+                && (String.IsNullOrEmpty(musicbrainzAlbumId)
+                    || !musicbrainzAlbumId.Equals(musicbrainzAlbumIds[0], StringComparison.OrdinalIgnoreCase)))
+            {
+                item.SetProviderId(MetadataProvider.MusicBrainzAlbum, musicbrainzAlbumIds[0]!);
+                updateType |= ItemUpdateType.MetadataEdit;
+            }
+
+            var musicbrainzReleaseGroupIds = songs
+                .Select(i => i.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup))
+                .GroupBy(i => i)
+                .OrderByDescending(g => g.Count())
+                .Select(g => g.Key)
+                .ToArray();
+
+            var musicbrainzReleaseGroupId = item.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
+            if (!String.IsNullOrEmpty(musicbrainzReleaseGroupIds[0])
+                && (String.IsNullOrEmpty(musicbrainzReleaseGroupId)
+                    || !musicbrainzReleaseGroupId.Equals(musicbrainzReleaseGroupIds[0], StringComparison.OrdinalIgnoreCase)))
+            {
+                item.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, musicbrainzReleaseGroupIds[0]!);
+                updateType |= ItemUpdateType.MetadataEdit;
+            }
+
+            return updateType;
+        }
+
+        private ItemUpdateType SetPeople(MusicAlbum item)
+        {
+            var updateType = ItemUpdateType.None;
+
+            if (item.AlbumArtists.Any() || item.Artists.Any())
+            {
+                var people = new List<PersonInfo>();
+
+                foreach (var albumArtist in item.AlbumArtists)
+                {
+                    PeopleHelper.AddPerson(people, new PersonInfo
+                    {
+                        Name = albumArtist,
+                        Type = "AlbumArtist"
+                    });
+                }
+
+                foreach (var artist in item.Artists)
+                {
+                    PeopleHelper.AddPerson(people, new PersonInfo
+                    {
+                        Name = artist,
+                        Type = "Artist"
+                    });
+                }
+
+                LibraryManager.UpdatePeople(item, people);
+                updateType |= ItemUpdateType.MetadataEdit;
+            }
+
+            return updateType;
+        }
+
         /// <inheritdoc />
         protected override void MergeData(
             MetadataResult<MusicAlbum> source,
@@ -123,6 +216,45 @@ namespace MediaBrowser.Providers.Music
             {
                 targetItem.Artists = sourceItem.Artists;
             }
+
+            if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist)))
+            {
+                var targetAlbumArtistId = targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
+                var sourceAlbumArtistId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
+
+                if (!string.IsNullOrEmpty(sourceAlbumArtistId)
+                    && (string.IsNullOrEmpty(targetAlbumArtistId)
+                        || !targetAlbumArtistId.Equals(sourceAlbumArtistId, StringComparison.Ordinal)))
+                {
+                    targetItem.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, sourceAlbumArtistId);
+                }
+            }
+
+            if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum)))
+            {
+                var targetAlbumId = targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum);
+                var sourceAlbumId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzAlbum);
+
+                if (!string.IsNullOrEmpty(sourceAlbumId)
+                    && (string.IsNullOrEmpty(targetAlbumId)
+                        || !targetAlbumId.Equals(sourceAlbumId, StringComparison.Ordinal)))
+                {
+                    targetItem.SetProviderId(MetadataProvider.MusicBrainzAlbum, sourceAlbumId);
+                }
+            }
+
+            if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup)))
+            {
+                var targetReleaseGroupId = targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
+                var sourceReleaseGroupId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
+
+                if (!string.IsNullOrEmpty(sourceReleaseGroupId)
+                    && (string.IsNullOrEmpty(targetReleaseGroupId)
+                        || !targetReleaseGroupId.Equals(sourceItem)))
+                {
+                    targetItem.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, sourceReleaseGroupId);
+                }
+            }
         }
     }
 }
diff --git a/MediaBrowser.Providers/Music/AudioMetadataService.cs b/MediaBrowser.Providers/Music/AudioMetadataService.cs
index 4577f77456..64f40ef49f 100644
--- a/MediaBrowser.Providers/Music/AudioMetadataService.cs
+++ b/MediaBrowser.Providers/Music/AudioMetadataService.cs
@@ -1,5 +1,6 @@
 #pragma warning disable CS1591
 
+using System;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Controller.Library;
@@ -40,6 +41,45 @@ namespace MediaBrowser.Providers.Music
             {
                 targetItem.Album = sourceItem.Album;
             }
+
+            var targetAlbumArtistId = targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
+            if (replaceData || string.IsNullOrEmpty(targetAlbumArtistId))
+            {
+                var sourceAlbumArtistId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
+
+                if (!string.IsNullOrEmpty(sourceAlbumArtistId)
+                    && (string.IsNullOrEmpty(targetAlbumArtistId)
+                        || !targetAlbumArtistId.Equals(sourceAlbumArtistId, StringComparison.Ordinal)))
+                {
+                    targetItem.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, sourceAlbumArtistId);
+                }
+            }
+
+            var targetAlbumId = targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum);
+            if (replaceData || string.IsNullOrEmpty(targetAlbumId))
+            {
+                var sourceAlbumId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzAlbum);
+
+                if (!string.IsNullOrEmpty(sourceAlbumId)
+                    && (string.IsNullOrEmpty(targetAlbumId)
+                        || !targetAlbumId.Equals(sourceAlbumId, StringComparison.Ordinal)))
+                {
+                    targetItem.SetProviderId(MetadataProvider.MusicBrainzAlbum, sourceAlbumId);
+                }
+            }
+
+            var targetReleaseGroupId = targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
+            if (replaceData || string.IsNullOrEmpty(targetReleaseGroupId))
+            {
+                var sourceReleaseGroupId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
+
+                if (!string.IsNullOrEmpty(sourceReleaseGroupId)
+                    && (string.IsNullOrEmpty(targetReleaseGroupId)
+                        || !targetReleaseGroupId.Equals(sourceReleaseGroupId, StringComparison.Ordinal)))
+                {
+                    targetItem.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, sourceReleaseGroupId);
+                }
+            }
         }
     }
 }

From e6c6482b9e698d3bcf73a0d06b82d483117b0ad5 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Tue, 29 Mar 2022 17:06:30 +0200
Subject: [PATCH 02/13] Rename providers to be more generic

---
 .../{FFProbeAudioInfo.cs => AudioFileProber.cs}    |  7 +++----
 .../{FFProbeProvider.cs => ProbeProvider.cs}       | 14 +++++++-------
 2 files changed, 10 insertions(+), 11 deletions(-)
 rename MediaBrowser.Providers/MediaInfo/{FFProbeAudioInfo.cs => AudioFileProber.cs} (98%)
 rename MediaBrowser.Providers/MediaInfo/{FFProbeProvider.cs => ProbeProvider.cs} (94%)

diff --git a/MediaBrowser.Providers/MediaInfo/FFProbeAudioInfo.cs b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
similarity index 98%
rename from MediaBrowser.Providers/MediaInfo/FFProbeAudioInfo.cs
rename to MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
index e801a20efb..2591e880f6 100644
--- a/MediaBrowser.Providers/MediaInfo/FFProbeAudioInfo.cs
+++ b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
@@ -4,7 +4,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -22,14 +21,14 @@ using TagLib;
 
 namespace MediaBrowser.Providers.MediaInfo
 {
-    public class FFProbeAudioInfo
+    public class AudioFileProber
     {
         private readonly IMediaEncoder _mediaEncoder;
         private readonly IItemRepository _itemRepo;
         private readonly ILibraryManager _libraryManager;
         private readonly IMediaSourceManager _mediaSourceManager;
 
-        public FFProbeAudioInfo(
+        public AudioFileProber(
             IMediaSourceManager mediaSourceManager,
             IMediaEncoder mediaEncoder,
             IItemRepository itemRepo,
@@ -170,7 +169,7 @@ namespace MediaBrowser.Providers.MediaInfo
                 audio.Album = tags.Album;
                 audio.IndexNumber = Convert.ToInt32(tags.Track);
                 audio.ParentIndexNumber = Convert.ToInt32(tags.Disc);
-                if(tags.Year != 0)
+                if (tags.Year != 0)
                 {
                     var year = Convert.ToInt32(tags.Year);
                     audio.ProductionYear = year;
diff --git a/MediaBrowser.Providers/MediaInfo/FFProbeProvider.cs b/MediaBrowser.Providers/MediaInfo/ProbeProvider.cs
similarity index 94%
rename from MediaBrowser.Providers/MediaInfo/FFProbeProvider.cs
rename to MediaBrowser.Providers/MediaInfo/ProbeProvider.cs
index e58c0e281b..54c12a8f17 100644
--- a/MediaBrowser.Providers/MediaInfo/FFProbeProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/ProbeProvider.cs
@@ -27,7 +27,7 @@ using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.Providers.MediaInfo
 {
-    public class FFProbeProvider : ICustomMetadataProvider<Episode>,
+    public class ProbeProvider : ICustomMetadataProvider<Episode>,
         ICustomMetadataProvider<MusicVideo>,
         ICustomMetadataProvider<Movie>,
         ICustomMetadataProvider<Trailer>,
@@ -39,14 +39,14 @@ namespace MediaBrowser.Providers.MediaInfo
         IPreRefreshProvider,
         IHasItemChangeMonitor
     {
-        private readonly ILogger<FFProbeProvider> _logger;
+        private readonly ILogger<ProbeProvider> _logger;
         private readonly AudioResolver _audioResolver;
         private readonly SubtitleResolver _subtitleResolver;
         private readonly FFProbeVideoInfo _videoProber;
-        private readonly FFProbeAudioInfo _audioProber;
+        private readonly AudioFileProber _audioProber;
         private readonly Task<ItemUpdateType> _cachedTask = Task.FromResult(ItemUpdateType.None);
 
-        public FFProbeProvider(
+        public ProbeProvider(
             IMediaSourceManager mediaSourceManager,
             IMediaEncoder mediaEncoder,
             IItemRepository itemRepo,
@@ -61,7 +61,8 @@ namespace MediaBrowser.Providers.MediaInfo
             ILoggerFactory loggerFactory,
             NamingOptions namingOptions)
         {
-            _logger = loggerFactory.CreateLogger<FFProbeProvider>();
+            _logger = loggerFactory.CreateLogger<ProbeProvider>();
+            _audioProber = new AudioFileProber(mediaSourceManager, mediaEncoder, itemRepo, libraryManager);
             _audioResolver = new AudioResolver(loggerFactory.CreateLogger<AudioResolver>(), localization, mediaEncoder, fileSystem, namingOptions);
             _subtitleResolver = new SubtitleResolver(loggerFactory.CreateLogger<SubtitleResolver>(), localization, mediaEncoder, fileSystem, namingOptions);
             _videoProber = new FFProbeVideoInfo(
@@ -78,10 +79,9 @@ namespace MediaBrowser.Providers.MediaInfo
                 libraryManager,
                 _audioResolver,
                 _subtitleResolver);
-            _audioProber = new FFProbeAudioInfo(mediaSourceManager, mediaEncoder, itemRepo, libraryManager);
         }
 
-        public string Name => "ffprobe";
+        public string Name => "filemetadataprober";
 
         // Run last
         public int Order => 100;

From cfd1db16387b75c340f6e2e7f453a8a97be02eaf Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Tue, 29 Mar 2022 20:31:59 +0200
Subject: [PATCH 03/13] Prevent MusicArtist creation for artist subfolders

---
 .../Library/Resolvers/Audio/MusicArtistResolver.cs    | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
index 210ed0953a..b7c1724c07 100644
--- a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
@@ -61,7 +61,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
 
             var isMusicMediaFolder = string.Equals(collectionType, CollectionType.Music, StringComparison.OrdinalIgnoreCase);
 
-            // If there's a collection type and it's not music, it can't be a series
+            // If there's a collection type and it's not music, it can't be a music artist
             if (!isMusicMediaFolder)
             {
                 return null;
@@ -87,6 +87,15 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
 
             var result = Parallel.ForEach(directories, (fileSystemInfo, state) =>
             {
+                foreach (var subfolder in _namingOptions.ArtistSubfolders)
+                {
+                    if (fileSystemInfo.Name.Equals(subfolder, StringComparison.OrdinalIgnoreCase))
+                    {
+                        // stop once we see a artist subfolder
+                        state.Stop();
+                    }
+                }
+
                 if (albumResolver.IsMusicAlbum(fileSystemInfo.FullName, directoryService))
                 {
                     // stop once we see a music album

From 42fc02cab6a44ff3fd891c9f9afa669711b4215d Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 31 Mar 2022 16:17:37 +0200
Subject: [PATCH 04/13] Add xmldocs

---
 .../Resolvers/Audio/MusicAlbumResolver.cs     | 14 +++---
 .../Resolvers/Audio/MusicArtistResolver.cs    | 19 +++----
 .../Providers/ICustomMetadataProvider.cs      |  6 +--
 .../MediaInfo/AudioFileProber.cs              | 33 ++++++++----
 .../MediaInfo/ProbeProvider.cs                | 50 +++++++++++++++++--
 .../Music/AlbumMetadataService.cs             | 13 ++++-
 .../Music/AudioMetadataService.cs             | 13 ++++-
 7 files changed, 112 insertions(+), 36 deletions(-)

diff --git a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
index 5e05ddfb16..2674d13559 100644
--- a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
@@ -19,7 +19,7 @@ using Microsoft.Extensions.Logging;
 namespace Emby.Server.Implementations.Library.Resolvers.Audio
 {
     /// <summary>
-    /// Class MusicAlbumResolver.
+    /// The music album resolver.
     /// </summary>
     public class MusicAlbumResolver : ItemResolver<MusicAlbum>
     {
@@ -93,12 +93,12 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
         /// Determine if the supplied resolve args should be considered a music album.
         /// </summary>
         /// <param name="args">The args.</param>
-        /// <returns><c>true</c> if [is music album] [the specified args]; otherwise, <c>false</c>.</returns>
+        /// <returns><c>true</c> if [is music album] [the specified args], <c>false</c> otherwise.</returns>
         private bool IsMusicAlbum(ItemResolveArgs args)
         {
-            // Args points to an album if parent is an Artist folder or it directly contains music
             if (args.IsDirectory)
             {
+                // If args is a artist subfolder it's not a music album
                 foreach (var subfolder in _namingOptions.ArtistSubfolders)
                 {
                     if (Path.GetDirectoryName(args.Path.AsSpan()).Equals(subfolder, StringComparison.OrdinalIgnoreCase))
@@ -108,6 +108,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
                     }
                 }
 
+                // If args contains music it's a music album
                 if (ContainsMusic(args.FileSystemChildren, true, args.DirectoryService))
                 {
                     return true;
@@ -120,22 +121,23 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
         /// <summary>
         /// Determine if the supplied list contains what we should consider music.
         /// </summary>
+        /// <returns><c>true</c> if the provided path list contains music, <c>false</c> otherwise.</returns>
         private bool ContainsMusic(
             ICollection<FileSystemMetadata> list,
             bool allowSubfolders,
             IDirectoryService directoryService)
         {
-            // check for audio files before digging down into directories
+            // Check for audio files before digging down into directories
             var foundAudioFile = list.Any(fileSystemInfo => !fileSystemInfo.IsDirectory && AudioFileParser.IsAudioFile(fileSystemInfo.FullName, _namingOptions));
             if (foundAudioFile)
             {
-                // at least one audio file exists
+                // At least one audio file exists
                 return true;
             }
 
             if (!allowSubfolders)
             {
-                // not music since no audio file exists and we're not looking into subfolders
+                // Not music since no audio file exists and we're not looking into subfolders
                 return false;
             }
 
diff --git a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
index b7c1724c07..2538c2b5b4 100644
--- a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicArtistResolver.cs
@@ -13,7 +13,7 @@ using Microsoft.Extensions.Logging;
 namespace Emby.Server.Implementations.Library.Resolvers.Audio
 {
     /// <summary>
-    /// Class MusicArtistResolver.
+    /// The music artist resolver.
     /// </summary>
     public class MusicArtistResolver : ItemResolver<MusicArtist>
     {
@@ -23,8 +23,8 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
         /// <summary>
         /// Initializes a new instance of the <see cref="MusicArtistResolver"/> class.
         /// </summary>
-        /// <param name="logger">The logger for the created <see cref="MusicAlbumResolver"/> instances.</param>
-        /// <param name="namingOptions">The naming options.</param>
+        /// <param name="logger">Instance of the <see cref="MusicAlbumResolver"/> interface.</param>
+        /// <param name="namingOptions">The <see cref="NamingOptions"/>.</param>
         public MusicArtistResolver(
             ILogger<MusicAlbumResolver> logger,
             NamingOptions namingOptions)
@@ -40,10 +40,10 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
         public override ResolverPriority Priority => ResolverPriority.Second;
 
         /// <summary>
-        /// Resolves the specified args.
+        /// Resolves the specified resolver arguments.
         /// </summary>
-        /// <param name="args">The args.</param>
-        /// <returns>MusicArtist.</returns>
+        /// <param name="args">The resolver arguments.</param>
+        /// <returns>A <see cref="MusicArtist"/>.</returns>
         protected override MusicArtist Resolve(ItemResolveArgs args)
         {
             if (!args.IsDirectory)
@@ -82,23 +82,24 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
 
             var albumResolver = new MusicAlbumResolver(_logger, _namingOptions);
 
-            // If we contain an album assume we are an artist folder
             var directories = args.FileSystemChildren.Where(i => i.IsDirectory);
 
             var result = Parallel.ForEach(directories, (fileSystemInfo, state) =>
             {
+                // If we contain a artist subfolder assume we are an artist folder
                 foreach (var subfolder in _namingOptions.ArtistSubfolders)
                 {
                     if (fileSystemInfo.Name.Equals(subfolder, StringComparison.OrdinalIgnoreCase))
                     {
-                        // stop once we see a artist subfolder
+                        // Stop once we see an artist subfolder
                         state.Stop();
                     }
                 }
 
+                // If we contain a music album assume we are an artist folder
                 if (albumResolver.IsMusicAlbum(fileSystemInfo.FullName, directoryService))
                 {
-                    // stop once we see a music album
+                    // Stop once we see a music album
                     state.Stop();
                 }
             });
diff --git a/MediaBrowser.Controller/Providers/ICustomMetadataProvider.cs b/MediaBrowser.Controller/Providers/ICustomMetadataProvider.cs
index 32a9cbef2e..14428df5b3 100644
--- a/MediaBrowser.Controller/Providers/ICustomMetadataProvider.cs
+++ b/MediaBrowser.Controller/Providers/ICustomMetadataProvider.cs
@@ -18,9 +18,9 @@ namespace MediaBrowser.Controller.Providers
         /// Fetches the metadata asynchronously.
         /// </summary>
         /// <param name="item">The item.</param>
-        /// <param name="options">The options.</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
-        /// <returns>Task{ItemUpdateType}.</returns>
+        /// <param name="options">The <see cref="MetadataRefreshOptions"/>.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
+        /// <returns>A <see cref="Task"/> fetching the <see cref="ItemUpdateType"/>.</returns>
         Task<ItemUpdateType> FetchAsync(TItemType item, MetadataRefreshOptions options, CancellationToken cancellationToken);
     }
 }
diff --git a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
index 2591e880f6..2b26b31379 100644
--- a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
+++ b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
@@ -1,7 +1,5 @@
 #nullable disable
 
-#pragma warning disable CS1591
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -21,6 +19,9 @@ using TagLib;
 
 namespace MediaBrowser.Providers.MediaInfo
 {
+    /// <summary>
+    /// Probes audio files for metadata.
+    /// </summary>
     public class AudioFileProber
     {
         private readonly IMediaEncoder _mediaEncoder;
@@ -28,6 +29,13 @@ namespace MediaBrowser.Providers.MediaInfo
         private readonly ILibraryManager _libraryManager;
         private readonly IMediaSourceManager _mediaSourceManager;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AudioFileProber"/> class.
+        /// </summary>
+        /// <param name="mediaSourceManager">Instance of the <see cref="IMediaSourceManager"/> interface.</param>
+        /// <param name="mediaEncoder">Instance of the <see cref="IMediaEncoder"/> interface.</param>
+        /// <param name="itemRepo">Instance of the <see cref="IItemRepository"/> interface.</param>
+        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
         public AudioFileProber(
             IMediaSourceManager mediaSourceManager,
             IMediaEncoder mediaEncoder,
@@ -40,6 +48,14 @@ namespace MediaBrowser.Providers.MediaInfo
             _mediaSourceManager = mediaSourceManager;
         }
 
+        /// <summary>
+        /// Probes the specified item for metadata.
+        /// </summary>
+        /// <param name="item">The item to probe.</param>
+        /// <param name="options">The <see cref="MetadataRefreshOptions"/>.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
+        /// <typeparam name="T">The type of item to resolve.</typeparam>
+        /// <returns>A <see cref="Task"/> probing the item for metadata.</returns>
         public async Task<ItemUpdateType> Probe<T>(
             T item,
             MetadataRefreshOptions options,
@@ -80,9 +96,9 @@ namespace MediaBrowser.Providers.MediaInfo
         /// <summary>
         /// Fetches the specified audio.
         /// </summary>
-        /// <param name="audio">The audio.</param>
-        /// <param name="mediaInfo">The media information.</param>
-        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <param name="audio">The <see cref="Audio"/>.</param>
+        /// <param name="mediaInfo">The <see cref="Model.MediaInfo.MediaInfo"/>.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
         protected void Fetch(Audio audio, Model.MediaInfo.MediaInfo mediaInfo, CancellationToken cancellationToken)
         {
             audio.Container = mediaInfo.Container;
@@ -91,18 +107,15 @@ namespace MediaBrowser.Providers.MediaInfo
             audio.RunTimeTicks = mediaInfo.RunTimeTicks;
             audio.Size = mediaInfo.Size;
 
-            // var extension = (Path.GetExtension(audio.Path) ?? string.Empty).TrimStart('.');
-            // audio.Container = extension;
-
             FetchDataFromTags(audio);
 
             _itemRepo.SaveMediaStreams(audio.Id, mediaInfo.MediaStreams, cancellationToken);
         }
 
         /// <summary>
-        /// Fetches data from the tags dictionary.
+        /// Fetches data from the tags.
         /// </summary>
-        /// <param name="audio">The audio.</param>
+        /// <param name="audio">The <see cref="Audio"/>.</param>
         private void FetchDataFromTags(Audio audio)
         {
             var file = TagLib.File.Create(audio.Path);
diff --git a/MediaBrowser.Providers/MediaInfo/ProbeProvider.cs b/MediaBrowser.Providers/MediaInfo/ProbeProvider.cs
index 54c12a8f17..6591366076 100644
--- a/MediaBrowser.Providers/MediaInfo/ProbeProvider.cs
+++ b/MediaBrowser.Providers/MediaInfo/ProbeProvider.cs
@@ -1,7 +1,5 @@
 #nullable disable
 
-#pragma warning disable CS1591
-
 using System;
 using System.IO;
 using System.Linq;
@@ -27,6 +25,9 @@ using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.Providers.MediaInfo
 {
+    /// <summary>
+    /// The probe provider.
+    /// </summary>
     public class ProbeProvider : ICustomMetadataProvider<Episode>,
         ICustomMetadataProvider<MusicVideo>,
         ICustomMetadataProvider<Movie>,
@@ -46,6 +47,22 @@ namespace MediaBrowser.Providers.MediaInfo
         private readonly AudioFileProber _audioProber;
         private readonly Task<ItemUpdateType> _cachedTask = Task.FromResult(ItemUpdateType.None);
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ProbeProvider"/> class.
+        /// </summary>
+        /// <param name="mediaSourceManager">Instance of the <see cref="IMediaSourceManager"/> interface.</param>
+        /// <param name="mediaEncoder">Instance of the <see cref="IMediaEncoder"/> interface.</param>
+        /// <param name="itemRepo">Instance of the <see cref="IItemRepository"/> interface.</param>
+        /// <param name="blurayExaminer">Instance of the <see cref="IBlurayExaminer"/> interface.</param>
+        /// <param name="localization">Instance of the <see cref="ILocalizationManager"/> interface.</param>
+        /// <param name="encodingManager">Instance of the <see cref="IEncodingManager"/> interface.</param>
+        /// <param name="config">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
+        /// <param name="subtitleManager">Instance of the <see cref="ISubtitleManager"/> interface.</param>
+        /// <param name="chapterManager">Instance of the <see cref="IChapterManager"/> interface.</param>
+        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
+        /// <param name="loggerFactory">Instance of the <see cref="ILoggerFactory"/>.</param>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="namingOptions">The <see cref="NamingOptions"/>.</param>
         public ProbeProvider(
             IMediaSourceManager mediaSourceManager,
             IMediaEncoder mediaEncoder,
@@ -81,11 +98,13 @@ namespace MediaBrowser.Providers.MediaInfo
                 _subtitleResolver);
         }
 
-        public string Name => "filemetadataprober";
+        /// <inheritdoc />
+        public string Name => "Probe Provider";
 
-        // Run last
+        /// <inheritdoc />
         public int Order => 100;
 
+        /// <inheritdoc />
         public bool HasChanged(BaseItem item, IDirectoryService directoryService)
         {
             var video = item as Video;
@@ -127,41 +146,56 @@ namespace MediaBrowser.Providers.MediaInfo
             return false;
         }
 
+        /// <inheritdoc />
         public Task<ItemUpdateType> FetchAsync(Episode item, MetadataRefreshOptions options, CancellationToken cancellationToken)
         {
             return FetchVideoInfo(item, options, cancellationToken);
         }
 
+        /// <inheritdoc />
         public Task<ItemUpdateType> FetchAsync(MusicVideo item, MetadataRefreshOptions options, CancellationToken cancellationToken)
         {
             return FetchVideoInfo(item, options, cancellationToken);
         }
 
+        /// <inheritdoc />
         public Task<ItemUpdateType> FetchAsync(Movie item, MetadataRefreshOptions options, CancellationToken cancellationToken)
         {
             return FetchVideoInfo(item, options, cancellationToken);
         }
 
+        /// <inheritdoc />
         public Task<ItemUpdateType> FetchAsync(Trailer item, MetadataRefreshOptions options, CancellationToken cancellationToken)
         {
             return FetchVideoInfo(item, options, cancellationToken);
         }
 
+        /// <inheritdoc />
         public Task<ItemUpdateType> FetchAsync(Video item, MetadataRefreshOptions options, CancellationToken cancellationToken)
         {
             return FetchVideoInfo(item, options, cancellationToken);
         }
 
+        /// <inheritdoc />
         public Task<ItemUpdateType> FetchAsync(Audio item, MetadataRefreshOptions options, CancellationToken cancellationToken)
         {
             return FetchAudioInfo(item, options, cancellationToken);
         }
 
+        /// <inheritdoc />
         public Task<ItemUpdateType> FetchAsync(AudioBook item, MetadataRefreshOptions options, CancellationToken cancellationToken)
         {
             return FetchAudioInfo(item, options, cancellationToken);
         }
 
+        /// <summary>
+        /// Fetches video information for an item.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="options">The <see cref="MetadataRefreshOptions"/>.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
+        /// <typeparam name="T">The type of item to resolve.</typeparam>
+        /// <returns>A <see cref="Task"/> fetching the <see cref="ItemUpdateType"/> for an item.</returns>
         public Task<ItemUpdateType> FetchVideoInfo<T>(T item, MetadataRefreshOptions options, CancellationToken cancellationToken)
             where T : Video
         {
@@ -208,6 +242,14 @@ namespace MediaBrowser.Providers.MediaInfo
                 .FirstOrDefault(i => !string.IsNullOrWhiteSpace(i) && !i.StartsWith('#'));
         }
 
+        /// <summary>
+        /// Fetches audio information for an item.
+        /// </summary>
+        /// <param name="item">The item.</param>
+        /// <param name="options">The <see cref="MetadataRefreshOptions"/>.</param>
+        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
+        /// <typeparam name="T">The type of item to resolve.</typeparam>
+        /// <returns>A <see cref="Task"/> fetching the <see cref="ItemUpdateType"/> for an item.</returns>
         public Task<ItemUpdateType> FetchAudioInfo<T>(T item, MetadataRefreshOptions options, CancellationToken cancellationToken)
             where T : Audio
         {
diff --git a/MediaBrowser.Providers/Music/AlbumMetadataService.cs b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
index b8426f31c1..1a8e20be32 100644
--- a/MediaBrowser.Providers/Music/AlbumMetadataService.cs
+++ b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
@@ -1,5 +1,3 @@
-#pragma warning disable CS1591
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -15,8 +13,19 @@ using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.Providers.Music
 {
+    /// <summary>
+    /// The album metadata service.
+    /// </summary>
     public class AlbumMetadataService : MetadataService<MusicAlbum, AlbumInfo>
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AlbumMetadataService"/> class.
+        /// </summary>
+        /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/>.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
+        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
         public AlbumMetadataService(
             IServerConfigurationManager serverConfigurationManager,
             ILogger<AlbumMetadataService> logger,
diff --git a/MediaBrowser.Providers/Music/AudioMetadataService.cs b/MediaBrowser.Providers/Music/AudioMetadataService.cs
index 64f40ef49f..7c38d0bcf5 100644
--- a/MediaBrowser.Providers/Music/AudioMetadataService.cs
+++ b/MediaBrowser.Providers/Music/AudioMetadataService.cs
@@ -1,5 +1,3 @@
-#pragma warning disable CS1591
-
 using System;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities.Audio;
@@ -12,8 +10,19 @@ using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.Providers.Music
 {
+    /// <summary>
+    /// The audio metadata service.
+    /// </summary>
     public class AudioMetadataService : MetadataService<Audio, SongInfo>
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AudioMetadataService"/> class.
+        /// </summary>
+        /// <param name="serverConfigurationManager">Instance of the <see cref="IServerConfigurationManager"/>.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
+        /// <param name="providerManager">Instance of the <see cref="IProviderManager"/> interface.</param>
+        /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
+        /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
         public AudioMetadataService(
             IServerConfigurationManager serverConfigurationManager,
             ILogger<AudioMetadataService> logger,

From 12cf98b4e3625a69000a24a27e7117d2d31ad4bc Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sat, 1 Oct 2022 20:18:14 +0200
Subject: [PATCH 05/13] Update taglibsharp, add audible tag parsing

---
 MediaBrowser.Providers/MediaBrowser.Providers.csproj | 2 +-
 MediaBrowser.Providers/MediaInfo/AudioFileProber.cs  | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/MediaBrowser.Providers/MediaBrowser.Providers.csproj b/MediaBrowser.Providers/MediaBrowser.Providers.csproj
index 459045dffc..dd43ba9cb0 100644
--- a/MediaBrowser.Providers/MediaBrowser.Providers.csproj
+++ b/MediaBrowser.Providers/MediaBrowser.Providers.csproj
@@ -22,7 +22,7 @@
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="OptimizedPriorityQueue" Version="5.1.0" />
     <PackageReference Include="PlaylistsNET" Version="1.2.1" />
-    <PackageReference Include="TagLibSharp" Version="2.2.0" />
+    <PackageReference Include="TagLibSharp" Version="2.3.0" />
     <PackageReference Include="TMDbLib" Version="1.9.2" />
   </ItemGroup>
 
diff --git a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
index 2b26b31379..cc41af5822 100644
--- a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
+++ b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
@@ -134,6 +134,10 @@ namespace MediaBrowser.Providers.MediaInfo
             {
                 tags = file.GetTag(TagTypes.FlacMetadata);
             }
+            else if (tagTypes.HasFlag(TagTypes.AudibleMetadata))
+            {
+                tags = file.GetTag(TagTypes.AudibleMetadata);
+            }
             else if (tagTypes.HasFlag(TagTypes.Id3v1))
             {
                 tags = file.GetTag(TagTypes.Id3v1);

From fa9820b1fd50c8df87771980bb0365988b877406 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Mon, 3 Oct 2022 13:05:57 +0200
Subject: [PATCH 06/13] Add apple tag parsing

---
 MediaBrowser.Providers/MediaInfo/AudioFileProber.cs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
index cc41af5822..e0c3bde8e1 100644
--- a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
+++ b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
@@ -134,6 +134,10 @@ namespace MediaBrowser.Providers.MediaInfo
             {
                 tags = file.GetTag(TagTypes.FlacMetadata);
             }
+            else if (tagTypes.HasFlag(TagTypes.Apple))
+            {
+                tags = file.GetTag(TagTypes.Apple);
+            }
             else if (tagTypes.HasFlag(TagTypes.AudibleMetadata))
             {
                 tags = file.GetTag(TagTypes.AudibleMetadata);

From 4649e0e425e5ab37f3a0f62b720d671604f73f4e Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Mon, 3 Oct 2022 13:16:13 +0200
Subject: [PATCH 07/13] Add xiph tag parsing

---
 MediaBrowser.Providers/MediaInfo/AudioFileProber.cs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
index e0c3bde8e1..42d85bb0cf 100644
--- a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
+++ b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
@@ -138,6 +138,10 @@ namespace MediaBrowser.Providers.MediaInfo
             {
                 tags = file.GetTag(TagTypes.Apple);
             }
+            else if (tagTypes.HasFlag(TagTypes.Xiph))
+            {
+                tags = file.GetTag(TagTypes.Xiph);
+            }
             else if (tagTypes.HasFlag(TagTypes.AudibleMetadata))
             {
                 tags = file.GetTag(TagTypes.AudibleMetadata);

From ff18586beb66d574306e6072cf1ce179ef64f62e Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 7 Oct 2022 11:12:16 +0200
Subject: [PATCH 08/13] Apply review suggestions

---
 .../Music/AlbumMetadataService.cs             | 83 +++++++++----------
 1 file changed, 41 insertions(+), 42 deletions(-)

diff --git a/MediaBrowser.Providers/Music/AlbumMetadataService.cs b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
index 1a8e20be32..f5c88a5a5d 100644
--- a/MediaBrowser.Providers/Music/AlbumMetadataService.cs
+++ b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
@@ -98,13 +98,16 @@ namespace MediaBrowser.Providers.Music
                 .ToArray();
 
             var musicbrainzAlbumArtistId = item.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
-            var firstMusicbrainzAlbumArtistId = musicbrainzAlbumArtistIds[0];
-            if (!string.IsNullOrEmpty(firstMusicbrainzAlbumArtistId) &&
-                (string.IsNullOrEmpty(musicbrainzAlbumArtistId)
-                    || !musicbrainzAlbumArtistId.Equals(firstMusicbrainzAlbumArtistId, StringComparison.OrdinalIgnoreCase)))
+            if (musicbrainzAlbumArtistIds.Any())
             {
-                item.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, firstMusicbrainzAlbumArtistId);
-                updateType |= ItemUpdateType.MetadataEdit;
+                var firstMusicbrainzAlbumArtistId = musicbrainzAlbumArtistIds[0];
+                if (!string.IsNullOrEmpty(firstMusicbrainzAlbumArtistId)
+                    && (string.IsNullOrEmpty(musicbrainzAlbumArtistId)
+                        || !musicbrainzAlbumArtistId.Equals(firstMusicbrainzAlbumArtistId, StringComparison.OrdinalIgnoreCase)))
+                {
+                    item.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, firstMusicbrainzAlbumArtistId);
+                    updateType |= ItemUpdateType.MetadataEdit;
+                }
             }
 
             if (!item.AlbumArtists.SequenceEqual(albumArtists, StringComparer.OrdinalIgnoreCase))
@@ -148,12 +151,16 @@ namespace MediaBrowser.Providers.Music
                 .ToArray();
 
             var musicbrainzAlbumId = item.GetProviderId(MetadataProvider.MusicBrainzAlbum);
-            if (!String.IsNullOrEmpty(musicbrainzAlbumIds[0])
-                && (String.IsNullOrEmpty(musicbrainzAlbumId)
-                    || !musicbrainzAlbumId.Equals(musicbrainzAlbumIds[0], StringComparison.OrdinalIgnoreCase)))
+            if (musicbrainzAlbumIds.Any())
             {
-                item.SetProviderId(MetadataProvider.MusicBrainzAlbum, musicbrainzAlbumIds[0]!);
-                updateType |= ItemUpdateType.MetadataEdit;
+                var firstMusicbrainzAlbumId = musicbrainzAlbumIds[0];
+                if (!string.IsNullOrEmpty(firstMusicbrainzAlbumId)
+                    && (string.IsNullOrEmpty(musicbrainzAlbumId)
+                        || !musicbrainzAlbumId.Equals(firstMusicbrainzAlbumId, StringComparison.OrdinalIgnoreCase)))
+                {
+                    item.SetProviderId(MetadataProvider.MusicBrainzAlbum, firstMusicbrainzAlbumId);
+                    updateType |= ItemUpdateType.MetadataEdit;
+                }
             }
 
             var musicbrainzReleaseGroupIds = songs
@@ -164,12 +171,16 @@ namespace MediaBrowser.Providers.Music
                 .ToArray();
 
             var musicbrainzReleaseGroupId = item.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
-            if (!String.IsNullOrEmpty(musicbrainzReleaseGroupIds[0])
-                && (String.IsNullOrEmpty(musicbrainzReleaseGroupId)
-                    || !musicbrainzReleaseGroupId.Equals(musicbrainzReleaseGroupIds[0], StringComparison.OrdinalIgnoreCase)))
+            if (musicbrainzReleaseGroupIds.Any())
             {
-                item.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, musicbrainzReleaseGroupIds[0]!);
-                updateType |= ItemUpdateType.MetadataEdit;
+                var firstMusicbrainzReleaseGroupId = musicbrainzReleaseGroupIds[0];
+                if (!string.IsNullOrEmpty(firstMusicbrainzReleaseGroupId)
+                    && (string.IsNullOrEmpty(musicbrainzReleaseGroupId)
+                        || !musicbrainzReleaseGroupId.Equals(firstMusicbrainzReleaseGroupId, StringComparison.OrdinalIgnoreCase)))
+                {
+                    item.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, firstMusicbrainzReleaseGroupId);
+                    updateType |= ItemUpdateType.MetadataEdit;
+                }
             }
 
             return updateType;
@@ -228,41 +239,29 @@ namespace MediaBrowser.Providers.Music
 
             if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist)))
             {
-                var targetAlbumArtistId = targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
-                var sourceAlbumArtistId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
-
-                if (!string.IsNullOrEmpty(sourceAlbumArtistId)
-                    && (string.IsNullOrEmpty(targetAlbumArtistId)
-                        || !targetAlbumArtistId.Equals(sourceAlbumArtistId, StringComparison.Ordinal)))
-                {
-                    targetItem.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, sourceAlbumArtistId);
-                }
+                setProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbumArtist);
             }
 
             if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum)))
             {
-                var targetAlbumId = targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum);
-                var sourceAlbumId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzAlbum);
-
-                if (!string.IsNullOrEmpty(sourceAlbumId)
-                    && (string.IsNullOrEmpty(targetAlbumId)
-                        || !targetAlbumId.Equals(sourceAlbumId, StringComparison.Ordinal)))
-                {
-                    targetItem.SetProviderId(MetadataProvider.MusicBrainzAlbum, sourceAlbumId);
-                }
+                setProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbum);
             }
 
             if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup)))
             {
-                var targetReleaseGroupId = targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
-                var sourceReleaseGroupId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
+                setProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzReleaseGroup);
+            }
+        }
 
-                if (!string.IsNullOrEmpty(sourceReleaseGroupId)
-                    && (string.IsNullOrEmpty(targetReleaseGroupId)
-                        || !targetReleaseGroupId.Equals(sourceItem)))
-                {
-                    targetItem.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, sourceReleaseGroupId);
-                }
+        private void setProviderId(MusicAlbum sourceItem, MusicAlbum targetItem, MetadataProvider provider)
+        {
+            var source = sourceItem.GetProviderId(provider);
+            var target = targetItem.GetProviderId(provider);
+            if (!string.IsNullOrEmpty(source)
+                && (string.IsNullOrEmpty(target)
+                    || !target.Equals(source, StringComparison.Ordinal)))
+            {
+                targetItem.SetProviderId(provider, source);
             }
         }
     }

From 08c68eb8dc427a6dc9b1b235763189a0af32cd54 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 7 Oct 2022 11:20:40 +0200
Subject: [PATCH 09/13] Apply review suggestions

---
 .../Music/AlbumMetadataService.cs             | 85 ++++++-------------
 1 file changed, 27 insertions(+), 58 deletions(-)

diff --git a/MediaBrowser.Providers/Music/AlbumMetadataService.cs b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
index f5c88a5a5d..dd982a3f98 100644
--- a/MediaBrowser.Providers/Music/AlbumMetadataService.cs
+++ b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
@@ -90,25 +90,7 @@ namespace MediaBrowser.Providers.Music
                 .Select(g => g.Key)
                 .ToArray();
 
-            var musicbrainzAlbumArtistIds = songs
-                .Select(i => i.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist))
-                .GroupBy(i => i)
-                .OrderByDescending(g => g.Count())
-                .Select(g => g.Key)
-                .ToArray();
-
-            var musicbrainzAlbumArtistId = item.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
-            if (musicbrainzAlbumArtistIds.Any())
-            {
-                var firstMusicbrainzAlbumArtistId = musicbrainzAlbumArtistIds[0];
-                if (!string.IsNullOrEmpty(firstMusicbrainzAlbumArtistId)
-                    && (string.IsNullOrEmpty(musicbrainzAlbumArtistId)
-                        || !musicbrainzAlbumArtistId.Equals(firstMusicbrainzAlbumArtistId, StringComparison.OrdinalIgnoreCase)))
-                {
-                    item.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, firstMusicbrainzAlbumArtistId);
-                    updateType |= ItemUpdateType.MetadataEdit;
-                }
-            }
+            updateType |= setProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbumArtist);
 
             if (!item.AlbumArtists.SequenceEqual(albumArtists, StringComparer.OrdinalIgnoreCase))
             {
@@ -143,45 +125,8 @@ namespace MediaBrowser.Providers.Music
         {
             var updateType = ItemUpdateType.None;
 
-            var musicbrainzAlbumIds = songs
-                .Select(i => i.GetProviderId(MetadataProvider.MusicBrainzAlbum))
-                .GroupBy(i => i)
-                .OrderByDescending(g => g.Count())
-                .Select(g => g.Key)
-                .ToArray();
-
-            var musicbrainzAlbumId = item.GetProviderId(MetadataProvider.MusicBrainzAlbum);
-            if (musicbrainzAlbumIds.Any())
-            {
-                var firstMusicbrainzAlbumId = musicbrainzAlbumIds[0];
-                if (!string.IsNullOrEmpty(firstMusicbrainzAlbumId)
-                    && (string.IsNullOrEmpty(musicbrainzAlbumId)
-                        || !musicbrainzAlbumId.Equals(firstMusicbrainzAlbumId, StringComparison.OrdinalIgnoreCase)))
-                {
-                    item.SetProviderId(MetadataProvider.MusicBrainzAlbum, firstMusicbrainzAlbumId);
-                    updateType |= ItemUpdateType.MetadataEdit;
-                }
-            }
-
-            var musicbrainzReleaseGroupIds = songs
-                .Select(i => i.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup))
-                .GroupBy(i => i)
-                .OrderByDescending(g => g.Count())
-                .Select(g => g.Key)
-                .ToArray();
-
-            var musicbrainzReleaseGroupId = item.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
-            if (musicbrainzReleaseGroupIds.Any())
-            {
-                var firstMusicbrainzReleaseGroupId = musicbrainzReleaseGroupIds[0];
-                if (!string.IsNullOrEmpty(firstMusicbrainzReleaseGroupId)
-                    && (string.IsNullOrEmpty(musicbrainzReleaseGroupId)
-                        || !musicbrainzReleaseGroupId.Equals(firstMusicbrainzReleaseGroupId, StringComparison.OrdinalIgnoreCase)))
-                {
-                    item.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, firstMusicbrainzReleaseGroupId);
-                    updateType |= ItemUpdateType.MetadataEdit;
-                }
-            }
+            updateType |= setProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbum);
+            updateType |= setProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzReleaseGroup);
 
             return updateType;
         }
@@ -264,5 +209,29 @@ namespace MediaBrowser.Providers.Music
                 targetItem.SetProviderId(provider, source);
             }
         }
+
+        private ItemUpdateType setProviderIdFromSongs(BaseItem item, IReadOnlyList<Audio> songs, MetadataProvider provider)
+        {
+            var ids = songs
+                .Select(i => i.GetProviderId(provider))
+                .GroupBy(i => i)
+                .OrderByDescending(g => g.Count())
+                .Select(g => g.Key)
+                .ToArray();
+
+            var id = item.GetProviderId(provider);
+            if (ids.Any())
+            {
+                var firstId = ids[0];
+                if (!string.IsNullOrEmpty(firstId)
+                    && (string.IsNullOrEmpty(id)
+                        || !id.Equals(firstId, StringComparison.OrdinalIgnoreCase)))
+                {
+                    item.SetProviderId(provider, firstId);
+                    return ItemUpdateType.MetadataEdit;
+                }
+            }
+            return ItemUpdateType.None;
+        }
     }
 }

From 2ac095d8cd0f0c3cb48ee44738cac1d4f1188357 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 7 Oct 2022 11:24:32 +0200
Subject: [PATCH 10/13] Apply review suggestions

---
 .../Music/AlbumMetadataService.cs             | 84 +++++++++----------
 1 file changed, 42 insertions(+), 42 deletions(-)

diff --git a/MediaBrowser.Providers/Music/AlbumMetadataService.cs b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
index dd982a3f98..ac40f0b3a4 100644
--- a/MediaBrowser.Providers/Music/AlbumMetadataService.cs
+++ b/MediaBrowser.Providers/Music/AlbumMetadataService.cs
@@ -90,7 +90,7 @@ namespace MediaBrowser.Providers.Music
                 .Select(g => g.Key)
                 .ToArray();
 
-            updateType |= setProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbumArtist);
+            updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbumArtist);
 
             if (!item.AlbumArtists.SequenceEqual(albumArtists, StringComparer.OrdinalIgnoreCase))
             {
@@ -125,12 +125,48 @@ namespace MediaBrowser.Providers.Music
         {
             var updateType = ItemUpdateType.None;
 
-            updateType |= setProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbum);
-            updateType |= setProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzReleaseGroup);
+            updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzAlbum);
+            updateType |= SetProviderIdFromSongs(item, songs, MetadataProvider.MusicBrainzReleaseGroup);
 
             return updateType;
         }
 
+        private ItemUpdateType SetProviderIdFromSongs(BaseItem item, IReadOnlyList<Audio> songs, MetadataProvider provider)
+        {
+            var ids = songs
+                .Select(i => i.GetProviderId(provider))
+                .GroupBy(i => i)
+                .OrderByDescending(g => g.Count())
+                .Select(g => g.Key)
+                .ToArray();
+
+            var id = item.GetProviderId(provider);
+            if (ids.Any())
+            {
+                var firstId = ids[0];
+                if (!string.IsNullOrEmpty(firstId)
+                    && (string.IsNullOrEmpty(id)
+                        || !id.Equals(firstId, StringComparison.OrdinalIgnoreCase)))
+                {
+                    item.SetProviderId(provider, firstId);
+                    return ItemUpdateType.MetadataEdit;
+                }
+            }
+            return ItemUpdateType.None;
+        }
+
+        private void SetProviderId(MusicAlbum sourceItem, MusicAlbum targetItem, MetadataProvider provider)
+        {
+            var source = sourceItem.GetProviderId(provider);
+            var target = targetItem.GetProviderId(provider);
+            if (!string.IsNullOrEmpty(source)
+                && (string.IsNullOrEmpty(target)
+                    || !target.Equals(source, StringComparison.Ordinal)))
+            {
+                targetItem.SetProviderId(provider, source);
+            }
+        }
+
         private ItemUpdateType SetPeople(MusicAlbum item)
         {
             var updateType = ItemUpdateType.None;
@@ -184,54 +220,18 @@ namespace MediaBrowser.Providers.Music
 
             if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist)))
             {
-                setProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbumArtist);
+                SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbumArtist);
             }
 
             if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum)))
             {
-                setProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbum);
+                SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzAlbum);
             }
 
             if (replaceData || string.IsNullOrEmpty(targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup)))
             {
-                setProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzReleaseGroup);
+                SetProviderId(sourceItem, targetItem, MetadataProvider.MusicBrainzReleaseGroup);
             }
         }
-
-        private void setProviderId(MusicAlbum sourceItem, MusicAlbum targetItem, MetadataProvider provider)
-        {
-            var source = sourceItem.GetProviderId(provider);
-            var target = targetItem.GetProviderId(provider);
-            if (!string.IsNullOrEmpty(source)
-                && (string.IsNullOrEmpty(target)
-                    || !target.Equals(source, StringComparison.Ordinal)))
-            {
-                targetItem.SetProviderId(provider, source);
-            }
-        }
-
-        private ItemUpdateType setProviderIdFromSongs(BaseItem item, IReadOnlyList<Audio> songs, MetadataProvider provider)
-        {
-            var ids = songs
-                .Select(i => i.GetProviderId(provider))
-                .GroupBy(i => i)
-                .OrderByDescending(g => g.Count())
-                .Select(g => g.Key)
-                .ToArray();
-
-            var id = item.GetProviderId(provider);
-            if (ids.Any())
-            {
-                var firstId = ids[0];
-                if (!string.IsNullOrEmpty(firstId)
-                    && (string.IsNullOrEmpty(id)
-                        || !id.Equals(firstId, StringComparison.OrdinalIgnoreCase)))
-                {
-                    item.SetProviderId(provider, firstId);
-                    return ItemUpdateType.MetadataEdit;
-                }
-            }
-            return ItemUpdateType.None;
-        }
     }
 }

From a97ec652279fc4288ddf1edbd0e05dcbfb4a77f8 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 7 Oct 2022 11:31:16 +0200
Subject: [PATCH 11/13] Apply review suggestions

---
 .../Music/AudioMetadataService.cs             | 56 ++++++-------------
 1 file changed, 18 insertions(+), 38 deletions(-)

diff --git a/MediaBrowser.Providers/Music/AudioMetadataService.cs b/MediaBrowser.Providers/Music/AudioMetadataService.cs
index 7c38d0bcf5..a5b7cb8959 100644
--- a/MediaBrowser.Providers/Music/AudioMetadataService.cs
+++ b/MediaBrowser.Providers/Music/AudioMetadataService.cs
@@ -33,6 +33,21 @@ namespace MediaBrowser.Providers.Music
         {
         }
 
+        private void SetProviderId(Audio sourceItem, Audio targetItem, bool replaceData, MetadataProvider provider)
+        {
+            var target = targetItem.GetProviderId(provider);
+            if (replaceData || string.IsNullOrEmpty(target))
+            {
+                var source = sourceItem.GetProviderId(provider);
+                if (!string.IsNullOrEmpty(source)
+                    && (string.IsNullOrEmpty(target)
+                        || !target.Equals(source, StringComparison.Ordinal)))
+                {
+                    targetItem.SetProviderId(provider, source);
+                }
+            }
+        }
+
         /// <inheritdoc />
         protected override void MergeData(MetadataResult<Audio> source, MetadataResult<Audio> target, MetadataField[] lockedFields, bool replaceData, bool mergeMetadataSettings)
         {
@@ -51,44 +66,9 @@ namespace MediaBrowser.Providers.Music
                 targetItem.Album = sourceItem.Album;
             }
 
-            var targetAlbumArtistId = targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
-            if (replaceData || string.IsNullOrEmpty(targetAlbumArtistId))
-            {
-                var sourceAlbumArtistId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzAlbumArtist);
-
-                if (!string.IsNullOrEmpty(sourceAlbumArtistId)
-                    && (string.IsNullOrEmpty(targetAlbumArtistId)
-                        || !targetAlbumArtistId.Equals(sourceAlbumArtistId, StringComparison.Ordinal)))
-                {
-                    targetItem.SetProviderId(MetadataProvider.MusicBrainzAlbumArtist, sourceAlbumArtistId);
-                }
-            }
-
-            var targetAlbumId = targetItem.GetProviderId(MetadataProvider.MusicBrainzAlbum);
-            if (replaceData || string.IsNullOrEmpty(targetAlbumId))
-            {
-                var sourceAlbumId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzAlbum);
-
-                if (!string.IsNullOrEmpty(sourceAlbumId)
-                    && (string.IsNullOrEmpty(targetAlbumId)
-                        || !targetAlbumId.Equals(sourceAlbumId, StringComparison.Ordinal)))
-                {
-                    targetItem.SetProviderId(MetadataProvider.MusicBrainzAlbum, sourceAlbumId);
-                }
-            }
-
-            var targetReleaseGroupId = targetItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
-            if (replaceData || string.IsNullOrEmpty(targetReleaseGroupId))
-            {
-                var sourceReleaseGroupId = sourceItem.GetProviderId(MetadataProvider.MusicBrainzReleaseGroup);
-
-                if (!string.IsNullOrEmpty(sourceReleaseGroupId)
-                    && (string.IsNullOrEmpty(targetReleaseGroupId)
-                        || !targetReleaseGroupId.Equals(sourceReleaseGroupId, StringComparison.Ordinal)))
-                {
-                    targetItem.SetProviderId(MetadataProvider.MusicBrainzReleaseGroup, sourceReleaseGroupId);
-                }
-            }
+            SetProviderId(sourceItem, targetItem, replaceData, MetadataProvider.MusicBrainzAlbumArtist);
+            SetProviderId(sourceItem, targetItem, replaceData, MetadataProvider.MusicBrainzAlbum);
+            SetProviderId(sourceItem, targetItem, replaceData, MetadataProvider.MusicBrainzReleaseGroup);
         }
     }
 }

From 6c6f89acc306f2dd9237ce618f024f8630f70696 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 7 Oct 2022 14:14:21 +0200
Subject: [PATCH 12/13] Apply review suggestions

---
 .../Library/Resolvers/Audio/MusicAlbumResolver.cs           | 6 +++---
 MediaBrowser.Providers/MediaInfo/AudioFileProber.cs         | 6 ++----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
index 2674d13559..a922e36855 100644
--- a/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/Audio/MusicAlbumResolver.cs
@@ -83,7 +83,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
         /// </summary>
         /// <param name="path">The path to check.</param>
         /// <param name="directoryService">The directory service.</param>
-        /// <returns><c>true</c> if the provided path points to a music album, <c>false</c> otherwise.</returns>
+        /// <returns><c>true</c> if the provided path points to a music album; otherwise, <c>false</c>.</returns>
         public bool IsMusicAlbum(string path, IDirectoryService directoryService)
         {
             return ContainsMusic(directoryService.GetFileSystemEntries(path), true, directoryService);
@@ -93,7 +93,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
         /// Determine if the supplied resolve args should be considered a music album.
         /// </summary>
         /// <param name="args">The args.</param>
-        /// <returns><c>true</c> if [is music album] [the specified args], <c>false</c> otherwise.</returns>
+        /// <returns><c>true</c> if [is music album] [the specified args]; otherwise, <c>false</c>.</returns>
         private bool IsMusicAlbum(ItemResolveArgs args)
         {
             if (args.IsDirectory)
@@ -121,7 +121,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Audio
         /// <summary>
         /// Determine if the supplied list contains what we should consider music.
         /// </summary>
-        /// <returns><c>true</c> if the provided path list contains music, <c>false</c> otherwise.</returns>
+        /// <returns><c>true</c> if the provided path list contains music; otherwise, <c>false</c>.</returns>
         private bool ContainsMusic(
             ICollection<FileSystemMetadata> list,
             bool allowSubfolders,
diff --git a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
index 42d85bb0cf..7f8ecd5784 100644
--- a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
+++ b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
@@ -1,5 +1,3 @@
-#nullable disable
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -120,7 +118,7 @@ namespace MediaBrowser.Providers.MediaInfo
         {
             var file = TagLib.File.Create(audio.Path);
             var tagTypes = file.TagTypesOnDisk;
-            Tag tags = null;
+            Tag tags = new TagLib.Id3v2.Tag();
 
             if (tagTypes.HasFlag(TagTypes.Id3v2))
             {
@@ -151,7 +149,7 @@ namespace MediaBrowser.Providers.MediaInfo
                 tags = file.GetTag(TagTypes.Id3v1);
             }
 
-            if (tags != null)
+            if (tags.IsEmpty)
             {
                 if (audio.SupportsPeople && !audio.LockedFields.Contains(MetadataField.Cast))
                 {

From 9b2e9640be029482a5d168a0ddb2feac0185d7a2 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 7 Oct 2022 14:40:10 +0200
Subject: [PATCH 13/13] Apply review suggestions

---
 MediaBrowser.Providers/MediaInfo/AudioFileProber.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
index 7f8ecd5784..3699e8f497 100644
--- a/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
+++ b/MediaBrowser.Providers/MediaInfo/AudioFileProber.cs
@@ -118,7 +118,7 @@ namespace MediaBrowser.Providers.MediaInfo
         {
             var file = TagLib.File.Create(audio.Path);
             var tagTypes = file.TagTypesOnDisk;
-            Tag tags = new TagLib.Id3v2.Tag();
+            Tag? tags = null;
 
             if (tagTypes.HasFlag(TagTypes.Id3v2))
             {
@@ -149,7 +149,7 @@ namespace MediaBrowser.Providers.MediaInfo
                 tags = file.GetTag(TagTypes.Id3v1);
             }
 
-            if (tags.IsEmpty)
+            if (tags != null)
             {
                 if (audio.SupportsPeople && !audio.LockedFields.Contains(MetadataField.Cast))
                 {