Added an option to merge artists without MBIDs to those with one, fixes #642

src/libs/services/scanner/CMakeLists.txt

@@ -1,4 +1,5 @@
 add_library(lmsscanner STATIC
+	impl/helpers/ArtistHelpers.cpp
 	impl/scanners/ArtistInfoFileScanner.cpp
 	impl/scanners/AudioFileScanOperation.cpp
 	impl/scanners/AudioFileScanner.cpp
@@ -7,6 +8,7 @@ add_library(lmsscanner STATIC
 	impl/scanners/PlayListFileScanner.cpp
 	impl/scanners/Utils.cpp
 	impl/steps/FileScanQueue.cpp
+	impl/steps/ScanStepArtistReconciliation.cpp
 	impl/steps/ScanStepAssociateArtistImages.cpp
 	impl/steps/ScanStepAssociateExternalLyrics.cpp
 	impl/steps/ScanStepAssociatePlayListTracks.cpp

src/libs/services/scanner/impl/ScannerService.cpp

@@ -35,6 +35,7 @@
 #include "scanners/LyricsFileScanner.hpp"
 #include "scanners/PlayListFileScanner.hpp"
 
+#include "steps/ScanStepArtistReconciliation.hpp"
 #include "steps/ScanStepAssociateArtistImages.hpp"
 #include "steps/ScanStepAssociateExternalLyrics.hpp"
 #include "steps/ScanStepAssociatePlayListTracks.hpp"
@@ -348,7 +349,7 @@ namespace lms::scanner
         } };
 
         _fileScanners.clear();
-        _fileScanners.emplace_back(std::make_unique<ArtistInfoFileScanner>(_db));
+        _fileScanners.emplace_back(std::make_unique<ArtistInfoFileScanner>(_settings, _db));
         _fileScanners.emplace_back(std::make_unique<AudioFileScanner>(_db, _settings));
         _fileScanners.emplace_back(std::make_unique<ImageFileScanner>(_db));
         _fileScanners.emplace_back(std::make_unique<LyricsFileScanner>(_db));
@@ -370,6 +371,7 @@ namespace lms::scanner
         _scanSteps.emplace_back(std::make_unique<ScanStepDiscoverFiles>(params));
         _scanSteps.emplace_back(std::make_unique<ScanStepScanFiles>(params));
         _scanSteps.emplace_back(std::make_unique<ScanStepCheckForRemovedFiles>(params));
+        _scanSteps.emplace_back(std::make_unique<ScanStepArtistReconciliation>(params));
         _scanSteps.emplace_back(std::make_unique<ScanStepAssociatePlayListTracks>(params));
         _scanSteps.emplace_back(std::make_unique<ScanStepUpdateLibraryFields>(params));
         _scanSteps.emplace_back(std::make_unique<ScanStepAssociateArtistImages>(params));
@@ -386,7 +388,7 @@ namespace lms::scanner
     {
         ScannerSettings newSettings;
 
-        newSettings.skipDuplicateMBID = core::Service<core::IConfig>::get()->getBool("scanner-skip-duplicate-mbid", false);
+        newSettings.skipDuplicateTrackMBID = core::Service<core::IConfig>::get()->getBool("scanner-skip-duplicate-mbid", false);
         {
             auto transaction{ _db.getTLSSession().createReadTransaction() };
 

src/libs/services/scanner/impl/ScannerService.hpp

@@ -39,6 +39,9 @@ namespace lms::scanner
 {
     class IFileScanner;
 
+    // Main goals to keepthe scanner fast:
+    // - single pass on files: only 1 filesystem exploration must be done (no further reads triggered by parsed values)
+    // - stable: 1 single scan (full or not) is enough: successive scans must have no effect if there is no change in the files
     class ScannerService : public IScannerService
     {
     public:

src/libs/services/scanner/impl/ScannerSettings.hpp

@@ -38,11 +38,12 @@ namespace lms::scanner
         std::size_t scanVersion{};
         Wt::WTime startTime;
         db::ScanSettings::UpdatePeriod updatePeriod{ db::ScanSettings::UpdatePeriod::Never };
-        bool skipDuplicateMBID{};
+        bool skipDuplicateTrackMBID{};
         std::vector<std::string> extraTags;
         std::vector<std::string> artistTagDelimiters;
         std::vector<std::string> defaultTagDelimiters;
         bool skipSingleReleasePlayLists{};
+        bool allowArtistMBIDFallback{ true }; // TODO false?
 
         std::vector<MediaLibraryInfo> mediaLibraries;
 

src/libs/services/scanner/impl/helpers/ArtistHelpers.cpp

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2025 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ArtistHelpers.hpp"
+
+#include "core/ILogger.hpp"
+#include "database/Session.hpp"
+#include "metadata/Types.hpp"
+
+namespace lms::scanner::helpers
+{
+    namespace
+    {
+        db::Artist::pointer createArtist(db::Session& session, const metadata::Artist& artistInfo)
+        {
+            db::Artist::pointer artist{ session.create<db::Artist>(artistInfo.name) };
+
+            if (artistInfo.mbid)
+                artist.modify()->setMBID(artistInfo.mbid);
+
+            artist.modify()->setSortName(artistInfo.sortName ? *artistInfo.sortName : artistInfo.name);
+
+            return artist;
+        }
+
+        std::string optionalMBIDAsString(const std::optional<core::UUID>& uuid)
+        {
+            return uuid ? std::string{ uuid->getAsString() } : "<no MBID>";
+        }
+
+        void updateArtistIfNeeded(db::Artist::pointer artist, const metadata::Artist& artistInfo)
+        {
+            // MBID may be set
+            if (artist->getMBID() != artistInfo.mbid)
+                artist.modify()->setMBID(artistInfo.mbid);
+
+            // Name may have been updated
+            if (artist->getName() != artistInfo.name)
+            {
+                LMS_LOG(DBUPDATER, DEBUG, "Artist [" << optionalMBIDAsString(artist->getMBID()) << "], updated name from '" << artist->getName() << "' to '" << artistInfo.name << "'");
+                artist.modify()->setName(artistInfo.name);
+            }
+
+            // Sortname may have been updated
+            // As the sort name is quite often not filled in, we update it only if already set (for now?)
+            if (artistInfo.sortName && *artistInfo.sortName != artist->getSortName())
+            {
+                LMS_LOG(DBUPDATER, DEBUG, "Artist [" << optionalMBIDAsString(artist->getMBID()) << "], updated sort name from '" << artist->getSortName() << "' to '" << *artistInfo.sortName << "'");
+                artist.modify()->setSortName(*artistInfo.sortName);
+            }
+        }
+
+    } // namespace
+
+    db::Artist::pointer getOrCreateArtistByMBID(db::Session& session, const metadata::Artist& artistInfo, AllowFallbackOnMBIDEntry allowFallbackOnMBIDEntries)
+    {
+        assert(artistInfo.mbid.has_value());
+        db::Artist::pointer artist{ db::Artist::find(session, *artistInfo.mbid) };
+        if (artist)
+        {
+            updateArtistIfNeeded(artist, artistInfo);
+        }
+        else
+        {
+            if (allowFallbackOnMBIDEntries.value())
+            {
+                // an artist with the same name may already exist, let's recycle it
+                for (const db::Artist::pointer& artistWithSameName : db::Artist::find(session, artistInfo.name))
+                {
+                    if (!artistWithSameName->hasMBID())
+                    {
+                        artist = artistWithSameName;
+                        updateArtistIfNeeded(artist, artistInfo);
+                        break;
+                    }
+                }
+            }
+
+            if (!artist)
+                artist = createArtist(session, artistInfo);
+        }
+
+        return artist;
+    }
+
+    db::Artist::pointer getOrCreateArtistByName(db::Session& session, const metadata::Artist& artistInfo, AllowFallbackOnMBIDEntry allowFallbackOnMBIDEntries)
+    {
+        db::Artist::pointer artist;
+
+        // Here we can have only one artist with no MBID, others all have mbids
+        const std::vector<db::Artist::pointer> artistsWithSameName{ db::Artist::find(session, artistInfo.name) };
+        const auto itArtistWithoutMBID{ std::find_if(std::begin(artistsWithSameName), std::end(artistsWithSameName), [](const db::Artist::pointer& artist) { return !artist->hasMBID(); }) };
+        const std::size_t artistCountWithMBID{ artistsWithSameName.size() - (itArtistWithoutMBID != std::end(artistsWithSameName) ? 1 : 0) };
+
+        if (!allowFallbackOnMBIDEntries.value() || artistCountWithMBID > 1)
+        {
+            if (itArtistWithoutMBID != std::end(artistsWithSameName))
+            {
+                artist = *itArtistWithoutMBID;
+                updateArtistIfNeeded(artist, artistInfo);
+            }
+            else
+                artist = createArtist(session, artistInfo);
+        }
+        else
+        {
+            const auto itArtistWithMBID{ std::find_if(std::begin(artistsWithSameName), std::end(artistsWithSameName), [](const db::Artist::pointer& artist) { return artist->hasMBID(); }) };
+
+            if (itArtistWithMBID != std::end(artistsWithSameName))
+            {
+                artist = *itArtistWithMBID;
+                // not updating artist here: consider metadata quality is less good
+            }
+            else if (itArtistWithoutMBID != std::end(artistsWithSameName))
+            {
+                artist = *itArtistWithoutMBID;
+                updateArtistIfNeeded(artist, artistInfo);
+            }
+            else
+                artist = createArtist(session, artistInfo);
+        }
+
+        return artist;
+    }
+
+    db::Artist::pointer getOrCreateArtist(db::Session& session, const metadata::Artist& artistInfo, AllowFallbackOnMBIDEntry allowFallbackOnMBIDEntries)
+    {
+        // First try to get by MBID
+        if (artistInfo.mbid)
+            return getOrCreateArtistByMBID(session, artistInfo, allowFallbackOnMBIDEntries);
+
+        // Fall back on artist name (collisions may occur)
+        return getOrCreateArtistByName(session, artistInfo, allowFallbackOnMBIDEntries);
+    }
+} // namespace lms::scanner::helpers

src/libs/services/scanner/impl/helpers/ArtistHelpers.hpp

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2025 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "core/TaggedType.hpp"
+#include "database/Artist.hpp"
+
+namespace lms::metadata
+{
+    struct Artist;
+}
+
+namespace lms::scanner::helpers
+{
+    using AllowFallbackOnMBIDEntry = core::TaggedBool<struct AllowFallbackOnMBIDEntryTag>;
+
+    db::Artist::pointer getOrCreateArtistByMBID(db::Session& session, const metadata::Artist& artistInfo, AllowFallbackOnMBIDEntry allowFallbackOnMBIDEntries);
+    db::Artist::pointer getOrCreateArtistByName(db::Session& session, const metadata::Artist& artistInfo, AllowFallbackOnMBIDEntry allowFallbackOnMBIDEntries);
+    db::Artist::pointer getOrCreateArtist(db::Session& session, const metadata::Artist& artistInfo, AllowFallbackOnMBIDEntry allowFallbackOnMBIDEntries);
+
+} // namespace lms::scanner::helpers

src/libs/services/scanner/impl/scanners/ArtistInfoFileScanner.cpp

@@ -32,7 +32,10 @@
 
 #include "IFileScanOperation.hpp"
 #include "ScanContext.hpp"
+#include "ScannerSettings.hpp"
 #include "Utils.hpp"
+#include "helpers/ArtistHelpers.hpp"
+#include "metadata/Types.hpp"
 
 namespace lms::scanner
 {
@@ -41,10 +44,13 @@ namespace lms::scanner
         class ArtistInfoFileScanOperation : public IFileScanOperation
         {
         public:
-            ArtistInfoFileScanOperation(const FileToScan& file, db::Db& db)
+            ArtistInfoFileScanOperation(const FileToScan& file, const ScannerSettings& settings, db::Db& db)
                 : _file{ file.file }
                 , _mediaLibrary{ file.mediaLibrary }
-                , _db{ db } {}
+                , _settings{ settings }
+                , _db{ db }
+            {
+            }
             ~ArtistInfoFileScanOperation() override = default;
             ArtistInfoFileScanOperation(const ArtistInfoFileScanOperation&) = delete;
             ArtistInfoFileScanOperation& operator=(const ArtistInfoFileScanOperation&) = delete;
@@ -59,6 +65,7 @@ namespace lms::scanner
 
             const std::filesystem::path _file;
             const MediaLibraryInfo _mediaLibrary;
+            const ScannerSettings& _settings;
             db::Db& _db;
 
             std::optional<metadata::ArtistInfo> _parsedArtistInfo;
@@ -76,12 +83,7 @@ namespace lms::scanner
                 }
 
                 _parsedArtistInfo = metadata::parseArtistInfo(ifs);
-                if (!_parsedArtistInfo->mbid.has_value())
-                {
-                    LMS_LOG(DBUPDATER, DEBUG, "Discarding artist info in file " << _file << ": no mbid set");
-                    _parsedArtistInfo.reset();
-                }
-                else if (_parsedArtistInfo->name.empty())
+                if (_parsedArtistInfo->name.empty())
                 {
                     LMS_LOG(DBUPDATER, DEBUG, "Discarding artist info in file " << _file << ": no name set");
                     _parsedArtistInfo.reset();
@@ -125,6 +127,8 @@ namespace lms::scanner
                 artistInfo.modify()->setAbsoluteFilePath(_file);
             }
 
+            artistInfo.modify()->setName(_parsedArtistInfo->name);
+            artistInfo.modify()->setSortName(_parsedArtistInfo->sortName);
             artistInfo.modify()->setLastWriteTime(fileInfo->lastWriteTime);
             artistInfo.modify()->setType(_parsedArtistInfo->type);
             artistInfo.modify()->setGender(_parsedArtistInfo->gender);
@@ -134,12 +138,8 @@ namespace lms::scanner
             db::MediaLibrary::pointer mediaLibrary{ db::MediaLibrary::find(dbSession, _mediaLibrary.id) }; // may be null if settings are updated in // => next scan will correct this
             artistInfo.modify()->setDirectory(utils::getOrCreateDirectory(dbSession, _file.parent_path(), mediaLibrary));
 
-            db::Artist::pointer artist{ db::Artist::find(dbSession, *_parsedArtistInfo->mbid) };
-            if (!artist)
-                artist = dbSession.create<db::Artist>(_parsedArtistInfo->name, _parsedArtistInfo->mbid);
-
-            artist.modify()->setName(_parsedArtistInfo->name);
-            artist.modify()->setSortName(_parsedArtistInfo->sortName);
+            const metadata::Artist artistMetadata{ _parsedArtistInfo->mbid, _parsedArtistInfo->name, _parsedArtistInfo->sortName.empty() ? std::nullopt : std::make_optional<std::string>(_parsedArtistInfo->sortName) };
+            db::Artist::pointer artist{ helpers::getOrCreateArtist(dbSession, artistMetadata, helpers::AllowFallbackOnMBIDEntry{ _settings.allowArtistMBIDFallback }) };
             artistInfo.modify()->setArtist(artist);
 
             if (added)
@@ -155,8 +155,9 @@ namespace lms::scanner
         }
     } // namespace
 
-    ArtistInfoFileScanner::ArtistInfoFileScanner(db::Db& db)
-        : _db{ db }
+    ArtistInfoFileScanner::ArtistInfoFileScanner(const ScannerSettings& settings, db::Db& db)
+        : _settings{ settings }
+        , _db{ db }
     {
     }
 
@@ -202,6 +203,6 @@ namespace lms::scanner
 
     std::unique_ptr<IFileScanOperation> ArtistInfoFileScanner::createScanOperation(const FileToScan& fileToScan) const
     {
-        return std::make_unique<ArtistInfoFileScanOperation>(fileToScan, _db);
+        return std::make_unique<ArtistInfoFileScanOperation>(fileToScan, _settings, _db);
     }
 } // namespace lms::scanner

src/libs/services/scanner/impl/scanners/ArtistInfoFileScanner.hpp

@@ -31,10 +31,12 @@ namespace lms
 
 namespace lms::scanner
 {
+    struct ScannerSettings;
+
     class ArtistInfoFileScanner : public IFileScanner
     {
     public:
-        ArtistInfoFileScanner(db::Db& db);
+        ArtistInfoFileScanner(const ScannerSettings& _settings, db::Db& db);
         ~ArtistInfoFileScanner() override = default;
         ArtistInfoFileScanner(const ArtistInfoFileScanner&) = delete;
         ArtistInfoFileScanner& operator=(const ArtistInfoFileScanner&) = delete;
@@ -45,6 +47,7 @@ namespace lms::scanner
         bool needsScan(ScanContext& context, const FileToScan& file) const override;
         std::unique_ptr<IFileScanOperation> createScanOperation(const FileToScan& fileToScan) const override;
 
+        const ScannerSettings& _settings;
         db::Db& _db;
     };
 } // namespace lms::scanner

src/libs/services/scanner/impl/scanners/AudioFileScanOperation.cpp

@@ -46,92 +46,30 @@
 #include "ScanContext.hpp"
 #include "ScannerSettings.hpp"
 #include "Utils.hpp"
+#include "helpers/ArtistHelpers.hpp"
 
 namespace lms::scanner
 {
     namespace
     {
-        db::Artist::pointer createArtist(db::Session& session, const metadata::Artist& artistInfo)
+        void createTrackArtistLinks(db::Session& session, const db::Track::pointer& track, db::TrackArtistLinkType linkType, std::string_view role, std::span<const metadata::Artist> artists, helpers::AllowFallbackOnMBIDEntry allowArtistMBIDFallback)
         {
-            db::Artist::pointer artist{ session.create<db::Artist>(artistInfo.name) };
-
-            if (artistInfo.mbid)
-                artist.modify()->setMBID(artistInfo.mbid);
-
-            artist.modify()->setSortName(artistInfo.sortName ? *artistInfo.sortName : artistInfo.name);
-
-            return artist;
-        }
-
-        std::string optionalMBIDAsString(const std::optional<core::UUID>& uuid)
-        {
-            return uuid ? std::string{ uuid->getAsString() } : "<no MBID>";
-        }
-
-        void updateArtistIfNeeded(db::Artist::pointer artist, const metadata::Artist& artistInfo)
-        {
-            // Name may have been updated
-            if (artist->getName() != artistInfo.name)
+            for (const metadata::Artist& artistInfo : artists)
             {
-                LMS_LOG(DBUPDATER, DEBUG, "Artist [" << optionalMBIDAsString(artist->getMBID()) << "], updated name from '" << artist->getName() << "' to '" << artistInfo.name << "'");
-                artist.modify()->setName(artistInfo.name);
-            }
+                db::Artist::pointer artist{ helpers::getOrCreateArtist(session, artistInfo, allowArtistMBIDFallback) };
 
-            // Sortname may have been updated
-            // As the sort name is quite often not filled in, we update it only if already set (for now?)
-            if (artistInfo.sortName && *artistInfo.sortName != artist->getSortName())
-            {
-                LMS_LOG(DBUPDATER, DEBUG, "Artist [" << optionalMBIDAsString(artist->getMBID()) << "], updated sort name from '" << artist->getSortName() << "' to '" << *artistInfo.sortName << "'");
-                artist.modify()->setSortName(*artistInfo.sortName);
+                const bool matchedUsingMbid{ artist->getMBID() == artistInfo.mbid };
+                db::TrackArtistLink::pointer link{ session.create<db::TrackArtistLink>(track, artist, linkType, role, matchedUsingMbid) };
+                link.modify()->setArtistName(artistInfo.name);
+                if (artistInfo.sortName)
+                    link.modify()->setArtistSortName(*artistInfo.sortName);
             }
         }
 
-        std::vector<db::Artist::pointer> getOrCreateArtists(db::Session& session, const std::vector<metadata::Artist>& artistsInfo, bool allowFallbackOnMBIDEntries)
+        void createTrackArtistLinks(db::Session& session, const db::Track::pointer& track, db::TrackArtistLinkType linkType, std::span<const metadata::Artist> artists, helpers::AllowFallbackOnMBIDEntry allowArtistMBIDFallback)
         {
-            std::vector<db::Artist::pointer> artists;
-
-            for (const metadata::Artist& artistInfo : artistsInfo)
-            {
-                db::Artist::pointer artist;
-
-                // First try to get by MBID
-                if (artistInfo.mbid)
-                {
-                    artist = db::Artist::find(session, *artistInfo.mbid);
-                    if (!artist)
-                        artist = createArtist(session, artistInfo);
-                    else
-                        updateArtistIfNeeded(artist, artistInfo);
-
-                    artists.emplace_back(std::move(artist));
-                    continue;
-                }
-
-                // Fall back on artist name (collisions may occur)
-                if (!artistInfo.name.empty())
-                {
-                    for (const db::Artist::pointer& sameNamedArtist : db::Artist::find(session, artistInfo.name))
-                    {
-                        // Do not fallback on artist that is correctly tagged
-                        if (!allowFallbackOnMBIDEntries && sameNamedArtist->getMBID())
-                            continue;
-
-                        artist = sameNamedArtist;
-                        break;
-                    }
-
-                    // No Artist found with the same name and without MBID -> creating
-                    if (!artist)
-                        artist = createArtist(session, artistInfo);
-                    else
-                        updateArtistIfNeeded(artist, artistInfo);
-
-                    artists.emplace_back(std::move(artist));
-                    continue;
-                }
-            }
-
-            return artists;
+            constexpr std::string_view noRole{};
+            createTrackArtistLinks(session, track, linkType, noRole, artists, allowArtistMBIDFallback);
         }
 
         db::ReleaseType::pointer getOrCreateReleaseType(db::Session& session, std::string_view name)
@@ -609,7 +547,7 @@ namespace lms::scanner
             return;
         }
 
-        if (_parsedTrack->mbid && (!track || _settings.skipDuplicateMBID))
+        if (_parsedTrack->mbid && (!track || _settings.skipDuplicateTrackMBID))
         {
             std::vector<db::Track::pointer> duplicateTracks{ db::Track::findByMBID(dbSession, *_parsedTrack->mbid) };
 
@@ -627,7 +565,7 @@ namespace lms::scanner
             }
 
             // Skip duplicate track MBID
-            if (_settings.skipDuplicateMBID)
+            if (_settings.skipDuplicateTrackMBID)
             {
                 for (db::Track::pointer& otherTrack : duplicateTracks)
                 {
@@ -739,41 +677,20 @@ namespace lms::scanner
         track.modify()->setDirectory(directory);
 
         track.modify()->clearArtistLinks();
-        // Do not fallback on artists with the same name but having a MBID for artist and releaseArtists, as it may be corrected by properly tagging files
-        for (const db::Artist::pointer& artist : getOrCreateArtists(dbSession, _parsedTrack->artists, false))
-            track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, artist, db::TrackArtistLinkType::Artist));
 
+        const helpers::AllowFallbackOnMBIDEntry allowFallback{ _settings.allowArtistMBIDFallback };
+        createTrackArtistLinks(dbSession, track, db::TrackArtistLinkType::Artist, _parsedTrack->artists, allowFallback);
         if (_parsedTrack->medium && _parsedTrack->medium->release)
-        {
-            for (const db::Artist::pointer& releaseArtist : getOrCreateArtists(dbSession, _parsedTrack->medium->release->artists, false))
-                track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, releaseArtist, db::TrackArtistLinkType::ReleaseArtist));
-        }
+            createTrackArtistLinks(dbSession, track, db::TrackArtistLinkType::ReleaseArtist, _parsedTrack->medium->release->artists, allowFallback);
 
-        // Allow fallbacks on artists with the same name even if they have MBID, since there is no tag to indicate the MBID of these artists
-        // We could ask MusicBrainz to get all the information, but that would heavily slow down the import process
-        for (const db::Artist::pointer& conductor : getOrCreateArtists(dbSession, _parsedTrack->conductorArtists, true))
-            track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, conductor, db::TrackArtistLinkType::Conductor));
-
-        for (const db::Artist::pointer& composer : getOrCreateArtists(dbSession, _parsedTrack->composerArtists, true))
-            track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, composer, db::TrackArtistLinkType::Composer));
-
-        for (const db::Artist::pointer& lyricist : getOrCreateArtists(dbSession, _parsedTrack->lyricistArtists, true))
-            track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, lyricist, db::TrackArtistLinkType::Lyricist));
-
-        for (const db::Artist::pointer& mixer : getOrCreateArtists(dbSession, _parsedTrack->mixerArtists, true))
-            track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, mixer, db::TrackArtistLinkType::Mixer));
+        createTrackArtistLinks(dbSession, track, db::TrackArtistLinkType::Conductor, _parsedTrack->conductorArtists, allowFallback);
+        createTrackArtistLinks(dbSession, track, db::TrackArtistLinkType::Composer, _parsedTrack->composerArtists, allowFallback);
+        createTrackArtistLinks(dbSession, track, db::TrackArtistLinkType::Lyricist, _parsedTrack->lyricistArtists, allowFallback);
+        createTrackArtistLinks(dbSession, track, db::TrackArtistLinkType::Mixer, _parsedTrack->mixerArtists, allowFallback);
+        createTrackArtistLinks(dbSession, track, db::TrackArtistLinkType::Remixer, _parsedTrack->remixerArtists, allowFallback);
 
         for (const auto& [role, performers] : _parsedTrack->performerArtists)
-        {
-            for (const db::Artist::pointer& performer : getOrCreateArtists(dbSession, performers, true))
-                track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, performer, db::TrackArtistLinkType::Performer, role));
-        }
-
-        for (const db::Artist::pointer& producer : getOrCreateArtists(dbSession, _parsedTrack->producerArtists, true))
-            track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, producer, db::TrackArtistLinkType::Producer));
-
-        for (const db::Artist::pointer& remixer : getOrCreateArtists(dbSession, _parsedTrack->remixerArtists, true))
-            track.modify()->addArtistLink(db::TrackArtistLink::create(dbSession, track, remixer, db::TrackArtistLinkType::Remixer));
+            createTrackArtistLinks(dbSession, track, db::TrackArtistLinkType::Performer, role, performers, allowFallback);
 
         track.modify()->setScanVersion(_settings.scanVersion);
         if (_parsedTrack->medium && _parsedTrack->medium->release)

src/libs/services/scanner/impl/steps/ScanStepArtistReconciliation.cpp

@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2024 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "ScanStepArtistReconciliation.hpp"
+
+#include <cassert>
+#include <ostream>
+
+#include "core/ILogger.hpp"
+#include "database/Artist.hpp"
+#include "database/ArtistInfo.hpp"
+#include "database/Db.hpp"
+#include "database/Session.hpp"
+#include "database/Track.hpp"
+#include "database/TrackArtistLink.hpp"
+#include "database/TrackList.hpp"
+#include "metadata/Types.hpp"
+
+#include "ScannerSettings.hpp"
+#include "helpers/ArtistHelpers.hpp"
+
+namespace lms::scanner
+{
+    namespace
+    {
+        std::ostream& operator<<(std::ostream& os, const db::Artist::pointer& artist)
+        {
+            os << artist->getName();
+            if (const auto mbid{ artist->getMBID() })
+                os << " [" << mbid->getAsString() << "]";
+
+            return os;
+        }
+
+        void recomputeArtist(db::Session& session, db::TrackArtistLink::pointer link, bool allowArtistMBIDFallback)
+        {
+            assert(!link->isArtistMBIDMatched());
+
+            metadata::Artist artistInfo{ std::nullopt, link->getArtistName(), link->getArtistSortName().empty() ? std::nullopt : std::make_optional<std::string>(link->getArtistSortName()) };
+
+            db::Artist::pointer newArtist{ helpers::getOrCreateArtistByName(session, artistInfo, helpers::AllowFallbackOnMBIDEntry{ allowArtistMBIDFallback }) };
+            LMS_LOG(DB, INFO, "Reconcile artist link for track " << link->getTrack()->getAbsoluteFilePath() << ", type " << static_cast<int>(link->getType()) << " from " << link->getArtist() << " to " << newArtist);
+
+            assert(newArtist != link->getArtist());
+            link.modify()->setArtist(newArtist);
+        }
+
+        void recomputeArtist(db::Session& session, db::ArtistInfo::pointer artistInfo, bool allowArtistMBIDFallback)
+        {
+            assert(!artistInfo->isMBIDMatched());
+
+            const metadata::Artist artistMetadata{ std::nullopt, artistInfo->getName(), artistInfo->getSortName().empty() ? std::nullopt : std::make_optional<std::string>(artistInfo->getSortName()) };
+            db::Artist::pointer newArtist{ helpers::getOrCreateArtistByName(session, artistMetadata, helpers::AllowFallbackOnMBIDEntry{ allowArtistMBIDFallback }) };
+            LMS_LOG(DB, INFO, "Reconcile artist link for artist info " << artistInfo->getAbsoluteFilePath() << " from " << artistInfo->getArtist() << " to " << newArtist);
+
+            assert(newArtist != artistInfo->getArtist());
+            artistInfo.modify()->setArtist(newArtist);
+        }
+    } // namespace
+
+    void ScanStepArtistReconciliation::process(ScanContext& context)
+    {
+        // Reconcile artist links
+        {
+            // Order is important
+            updateLinksForArtistNameNoLongerMatch(context);
+            updateLinksWithArtistNameAmbiguity(context);
+        }
+
+        // Reconcile artist info
+        {
+            // Order is important
+            updateArtistInfoForArtistNameNoLongerMatch(context);
+            updateArtistInfoWithArtistNameAmbiguity(context);
+        }
+    }
+
+    void ScanStepArtistReconciliation::updateArtistInfoForArtistNameNoLongerMatch(ScanContext& context)
+    {
+        static constexpr std::size_t batchSize{ 50 };
+
+        const bool allowArtistMBIDFallback{ _settings.allowArtistMBIDFallback };
+        db::Session& session{ _db.getTLSSession() };
+
+        std::vector<db::ArtistInfo::pointer> artistInfo;
+        while (true)
+        {
+            artistInfo.clear();
+            {
+                auto transaction{ session.createReadTransaction() };
+                db::ArtistInfo::findArtistNameNoLongerMatch(session, db::Range{ .offset = 0, .size = batchSize }, [&](const db::ArtistInfo::pointer& link) {
+                    artistInfo.push_back(link);
+                });
+            }
+
+            if (artistInfo.empty())
+                break;
+
+            {
+                auto transaction{ session.createWriteTransaction() };
+                for (db::ArtistInfo::pointer& info : artistInfo)
+                {
+                    recomputeArtist(session, info, allowArtistMBIDFallback);
+                    context.currentStepStats.processedElems++;
+                }
+
+                _progressCallback(context.currentStepStats);
+            }
+        }
+    }
+
+    void ScanStepArtistReconciliation::updateArtistInfoWithArtistNameAmbiguity(ScanContext& context)
+    {
+        static constexpr std::size_t batchSize{ 50 };
+
+        const bool allowArtistMBIDFallback{ _settings.allowArtistMBIDFallback };
+        db::Session& session{ _db.getTLSSession() };
+
+        std::vector<db::ArtistInfo::pointer> artistInfo;
+        while (true)
+        {
+            artistInfo.clear();
+            {
+                auto transaction{ session.createReadTransaction() };
+                db::ArtistInfo::findWithArtistNameAmbiguity(session, db::Range{ .offset = 0, .size = batchSize }, allowArtistMBIDFallback, [&](const db::ArtistInfo::pointer& info) {
+                    artistInfo.push_back(info);
+                });
+            }
+
+            if (artistInfo.empty())
+                break;
+
+            {
+                auto transaction{ session.createWriteTransaction() };
+                for (db::ArtistInfo::pointer& info : artistInfo)
+                {
+                    recomputeArtist(session, info, allowArtistMBIDFallback);
+                    context.currentStepStats.processedElems++;
+                }
+
+                _progressCallback(context.currentStepStats);
+            }
+        }
+    }
+    void ScanStepArtistReconciliation::updateLinksForArtistNameNoLongerMatch(ScanContext& context)
+    {
+        static constexpr std::size_t batchSize{ 50 };
+
+        const bool allowArtistMBIDFallback{ _settings.allowArtistMBIDFallback };
+        db::Session& session{ _db.getTLSSession() };
+
+        std::vector<db::TrackArtistLink::pointer> links;
+        while (true)
+        {
+            links.clear();
+            {
+                auto transaction{ session.createReadTransaction() };
+                db::TrackArtistLink::findArtistNameNoLongerMatch(session, db::Range{ .offset = 0, .size = batchSize }, [&](const db::TrackArtistLink::pointer& link) {
+                    links.push_back(link);
+                });
+            }
+
+            if (links.empty())
+                break;
+
+            {
+                auto transaction{ session.createWriteTransaction() };
+                for (db::TrackArtistLink::pointer& link : links)
+                {
+                    recomputeArtist(session, link, allowArtistMBIDFallback);
+                    context.currentStepStats.processedElems++;
+                }
+
+                _progressCallback(context.currentStepStats);
+            }
+        }
+    }
+
+    void ScanStepArtistReconciliation::updateLinksWithArtistNameAmbiguity(ScanContext& context)
+    {
+        static constexpr std::size_t batchSize{ 50 };
+
+        const bool allowArtistMBIDFallback{ _settings.allowArtistMBIDFallback };
+        db::Session& session{ _db.getTLSSession() };
+
+        std::vector<db::TrackArtistLink::pointer> links;
+        while (true)
+        {
+            links.clear();
+            {
+                auto transaction{ session.createReadTransaction() };
+                db::TrackArtistLink::findWithArtistNameAmbiguity(session, db::Range{ .offset = 0, .size = batchSize }, allowArtistMBIDFallback, [&](const db::TrackArtistLink::pointer& link) {
+                    links.push_back(link);
+                });
+            }
+
+            if (links.empty())
+                break;
+
+            {
+                auto transaction{ session.createWriteTransaction() };
+                for (db::TrackArtistLink::pointer& link : links)
+                {
+                    recomputeArtist(session, link, allowArtistMBIDFallback);
+                    context.currentStepStats.processedElems++;
+                }
+
+                _progressCallback(context.currentStepStats);
+            }
+        }
+    }
+} // namespace lms::scanner

src/libs/services/scanner/impl/steps/ScanStepArtistReconciliation.hpp

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2025 Emeric Poupon
+ *
+ * This file is part of LMS.
+ *
+ * LMS is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * LMS is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LMS.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "ScanStepBase.hpp"
+
+namespace lms::scanner
+{
+    class ScanStepArtistReconciliation : public ScanStepBase
+    {
+    public:
+        using ScanStepBase::ScanStepBase;
+
+    private:
+        ScanStep getStep() const override { return ScanStep::ReconciliateArtists; }
+        core::LiteralString getStepName() const override { return "Artist reconciliation"; }
+        void process(ScanContext& context) override;
+
+        void updateLinksForArtistNameNoLongerMatch(ScanContext& context);
+        void updateLinksWithArtistNameAmbiguity(ScanContext& context);
+        void updateArtistInfoForArtistNameNoLongerMatch(ScanContext& context);
+        void updateArtistInfoWithArtistNameAmbiguity(ScanContext& context);
+    };
+} // namespace lms::scanner

src/libs/services/scanner/impl/steps/ScanStepBase.hpp

@@ -57,12 +57,11 @@ namespace lms::scanner
             , _fileScanners(std::cbegin(initParams.fileScanners), std::cend(initParams.fileScanners))
         {
         }
-
-    protected:
         ~ScanStepBase() override = default;
         ScanStepBase(const ScanStepBase&) = delete;
         ScanStepBase& operator=(const ScanStepBase&) = delete;
 
+    protected:
         const ScannerSettings& _settings;
         ProgressCallback _progressCallback;
         bool& _abortScan;

src/libs/services/scanner/include/services/scanner/ScannerStats.hpp

@@ -75,6 +75,7 @@ namespace lms::scanner
         DiscoverFiles,
         FetchTrackFeatures,
         Optimize,
+        ReconciliateArtists,
         ReloadSimilarityEngine,
         RemoveOrphanedDbEntries,
         ScanFiles,