owen/lms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Now resolve the preferred track artworks during scan steps

Browse Source
This commit is contained in:
emeric
2025-06-21 18:13:20 +02:00
parent a1533c4c8d
commit dd2aa49bb0
16 changed files with 704 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/database/impl/Cluster.cpp
+1
View File
@@ -20,6 +20,7 @@
#include "database/Cluster.hpp"
#include "database/Artist.hpp"
#include "database/Artwork.hpp"
#include "database/Directory.hpp"
#include "database/MediaLibrary.hpp"
#include "database/Release.hpp"
src/libs/database/impl/Migration.cpp
+90 -3
View File
@@ -1231,7 +1231,6 @@ FROM tracklist)");
constraint "fk_artwork_image" foreign key ("image_id") references "image" ("id") on delete cascade deferrable initially deferred))");
// Replaced image by artwork for release
// Create the new table, copy the data, drop the old table, rename the new one
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "release_backup" (
"id" integer primary key autoincrement,
"version" integer not null,
@@ -1267,8 +1266,96 @@ FROM release)");
utils::executeCommand(*session.getDboSession(), "DROP TABLE release");
utils::executeCommand(*session.getDboSession(), "ALTER TABLE release_backup RENAME TO release");
// Replaced image by artwork for track
utils::executeCommand(*session.getDboSession(), R"(CREATE TABLE IF NOT EXISTS "track_backup" (
"id" integer primary key autoincrement,
"version" integer not null,
"scan_version" integer not null,
"track_number" integer,
"disc_number" integer,
"total_track" integer,
"disc_subtitle" text not null,
"name" text not null,
"duration" integer,
"bitrate" integer not null,
"bits_per_sample" integer not null,
"channel_count" integer not null,
"sample_rate" integer not null,
"date" text,
"original_date" text,
"absolute_file_path" text not null,
"relative_file_path" text not null,
"file_stem" text not null,
"file_name" text not null,
"file_size" bigint not null,
"file_last_write" text,
"file_added" text,
"mbid" text not null,
"recording_mbid" text not null,
"copyright" text not null,
"copyright_url" text not null,
"advisory" integer not null,
"track_replay_gain" real,
"release_replay_gain" real,
"artist_display_name" text not null,
"comment" text not null,
"release_id" bigint,
"media_library_id" bigint,
"directory_id" bigint,
"preferred_artwork_id" bigint,
"preferred_media_artwork_id" bigint,
constraint "fk_track_release" foreign key ("release_id") references "release" ("id") on delete cascade deferrable initially deferred,
constraint "fk_track_media_library" foreign key ("media_library_id") references "media_library" ("id") on delete set null deferrable initially deferred,
constraint "fk_track_directory" foreign key ("directory_id") references "directory" ("id") on delete cascade deferrable initially deferred,
constraint "fk_track_preferred_artwork" foreign key ("preferred_artwork_id") references "artwork" ("id") on delete set null deferrable initially deferred,
constraint "fk_track_preferred_media_artwork" foreign key ("preferred_media_artwork_id") references "artwork" ("id") on delete set null deferrable initially deferred
))");
// Migrate data, with the new preferred_artwork_id and preferred_media_artwork_id fields set to null
utils::executeCommand(*session.getDboSession(), R"(INSERT INTO track_backup
SELECT
id,
version,
scan_version,
track_number,
disc_number,
total_track,
disc_subtitle,
name,
duration,
bitrate,
bits_per_sample,
channel_count,
sample_rate,
date,
original_date,
absolute_file_path,
relative_file_path,
file_stem,
file_name,
file_size,
file_last_write,
file_added,
mbid,
recording_mbid,
copyright,
copyright_url,
advisory,
track_replay_gain,
release_replay_gain,
artist_display_name,
comment,
release_id,
media_library_id,
directory_id,
NULL as preferred_artwork_id,
NULL as preferred_media_artwork_id
FROM track)");
utils::executeCommand(*session.getDboSession(), "DROP TABLE track");
utils::executeCommand(*session.getDboSession(), "ALTER TABLE track_backup RENAME TO track");
// Just increment the scan version of the settings to make the next scan rescan everything
utils::executeCommand(*session.getDboSession(), "UPDATE scan_settings SET artist_info_scan_version = artist_info_scan_version + 1");
utils::executeCommand(*session.getDboSession(), "UPDATE scan_settings SET audio_scan_version = audio_scan_version + 1");
}
bool doDbMigration(Session& session)
@@ -1339,7 +1426,7 @@ FROM release)");
{ 89, migrateFromV89 },
{ 90, migrateFromV90 },
{ 91, migrateFromV91 },
{ 92, migrateFromV92 }
{ 92, migrateFromV92 },
};
bool migrationPerformed{};
src/libs/database/impl/PlayQueue.cpp
+1
View File
@@ -21,6 +21,7 @@
#include <Wt/Dbo/SqlTraits.h>
#include "database/Artwork.hpp"
#include "database/Directory.hpp"
#include "database/MediaLibrary.hpp"
#include "database/Release.hpp"
src/libs/database/impl/Release.cpp
+5
View File
@@ -706,6 +706,11 @@ namespace lms::db
return ObjectPtr<Artwork>{ _preferredArtwork };
}
ArtworkId Release::getPreferredArtworkId() const
{
return _preferredArtwork.id();
}
void Release::clearLabels()
{
_labels.clear();
src/libs/database/impl/Track.cpp
+55
View File
@@ -23,6 +23,7 @@
#include "core/ILogger.hpp"
#include "database/Artist.hpp"
#include "database/Artwork.hpp"
#include "database/Cluster.hpp"
#include "database/Directory.hpp"
#include "database/MediaLibrary.hpp"
@@ -324,6 +325,20 @@ namespace lms::db
return utils::execRangeQuery<TrackId>(query, range);
}
void Track::updatePreferredArtwork(Session& session, TrackId trackId, ArtworkId artworkId)
{
session.checkWriteTransaction();
utils::executeCommand(*session.getDboSession(), "UPDATE track SET preferred_artwork_id = ? WHERE id = ?", artworkId, trackId);
}
void Track::updatePreferredMediaArtwork(Session& session, TrackId trackId, ArtworkId artworkId)
{
session.checkWriteTransaction();
utils::executeCommand(*session.getDboSession(), "UPDATE track SET preferred_media_artwork_id = ? WHERE id = ?", artworkId, trackId);
}
std::vector<Cluster::pointer> Track::getClusters() const
{
return utils::fetchQueryResults<Cluster::pointer>(_clusters.find());
@@ -338,6 +353,26 @@ namespace lms::db
return utils::fetchQueryResults(query);
}
ObjectPtr<MediaLibrary> Track::getMediaLibrary() const
{
return _mediaLibrary;
}
ObjectPtr<Directory> Track::getDirectory() const
{
return _directory;
}
ObjectPtr<Artwork> Track::getPreferredArtwork() const
{
return _preferredArtwork;
}
ObjectPtr<Artwork> Track::getPreferredMediaArtwork() const
{
return _preferredMediaArtwork;
}
RangeResults<TrackId> Track::findIds(Session& session, const FindParameters& parameters)
{
session.checkReadTransaction();
@@ -484,6 +519,26 @@ namespace lms::db
_embeddedImageLinks.insert(getDboPtr(image));
}
void Track::setMediaLibrary(ObjectPtr<MediaLibrary> mediaLibrary)
{
_mediaLibrary = getDboPtr(mediaLibrary);
}
void Track::setDirectory(ObjectPtr<Directory> directory)
{
_directory = getDboPtr(directory);
}
void Track::setPreferredArtwork(ObjectPtr<Artwork> artwork)
{
_preferredArtwork = getDboPtr(artwork);
}
void Track::setPreferredMediaArtwork(ObjectPtr<Artwork> artwork)
{
_preferredMediaArtwork = getDboPtr(artwork);
}
std::optional<int> Track::getYear() const
{
return _date.getYear();
src/libs/database/include/database/Track.hpp
+19 -5
View File
@@ -35,6 +35,7 @@
#include "core/PartialDateTime.hpp"
#include "core/UUID.hpp"
#include "database/ArtistId.hpp"
#include "database/ArtworkId.hpp"
#include "database/ClusterId.hpp"
#include "database/DirectoryId.hpp"
#include "database/Filters.hpp"
@@ -50,6 +51,7 @@
namespace lms::db
{
class Artist;
class Artwork;
class Cluster;
class ClusterType;
class Directory;
@@ -215,6 +217,10 @@ namespace lms::db
static RangeResults<TrackId> findIdsTrackMBIDDuplicates(Session& session, std::optional<Range> range = std::nullopt);
static RangeResults<TrackId> findIdsWithRecordingMBIDAndMissingFeatures(Session& session, std::optional<Range> range = std::nullopt);
// Update utility functions
static void updatePreferredArtwork(Session& session, TrackId trackId, ArtworkId artworkId);
static void updatePreferredMediaArtwork(Session& session, TrackId trackId, ArtworkId artworkId);
// Accessors
void setScanVersion(std::size_t version) { _scanVersion = version; }
void setTrackNumber(std::optional<int> num) { _trackNumber = num; }
@@ -252,8 +258,10 @@ namespace lms::db
void addLyrics(const ObjectPtr<TrackLyrics>& lyrics);
void clearEmbeddedImageLinks();
void addEmbeddedImageLink(const ObjectPtr<TrackEmbeddedImageLink>& link);
void setMediaLibrary(ObjectPtr<MediaLibrary> mediaLibrary) { _mediaLibrary = getDboPtr(mediaLibrary); }
void setDirectory(ObjectPtr<Directory> directory) { _directory = getDboPtr(directory); }
void setMediaLibrary(ObjectPtr<MediaLibrary> mediaLibrary);
void setDirectory(ObjectPtr<Directory> directory);
void setPreferredArtwork(ObjectPtr<Artwork> artwork);
void setPreferredMediaArtwork(ObjectPtr<Artwork> artwork);
std::size_t getScanVersion() const { return _scanVersion; }
std::optional<std::size_t> getTrackNumber() const { return _trackNumber; }
@@ -295,8 +303,10 @@ namespace lms::db
ObjectPtr<Release> getRelease() const { return _release; }
std::vector<ObjectPtr<Cluster>> getClusters() const;
std::vector<ClusterId> getClusterIds() const;
ObjectPtr<MediaLibrary> getMediaLibrary() const { return _mediaLibrary; }
ObjectPtr<Directory> getDirectory() const { return _directory; }
ObjectPtr<MediaLibrary> getMediaLibrary() const;
ObjectPtr<Directory> getDirectory() const;
ObjectPtr<Artwork> getPreferredArtwork() const;
ObjectPtr<Artwork> getPreferredMediaArtwork() const;
std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(const std::vector<ClusterTypeId>& clusterTypes, std::size_t size) const;
@@ -331,11 +341,13 @@ namespace lms::db
Wt::Dbo::field(a, _trackReplayGain, "track_replay_gain");
Wt::Dbo::field(a, _releaseReplayGain, "release_replay_gain"); // here in Track since Release does not have concept of "disc" (yet?)
Wt::Dbo::field(a, _artistDisplayName, "artist_display_name");
Wt::Dbo::field(a, _comment, "comment");
Wt::Dbo::field(a, _comment, "comment"); // TODO: move in a dedicated table
Wt::Dbo::belongsTo(a, _release, "release", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::belongsTo(a, _mediaLibrary, "media_library", Wt::Dbo::OnDeleteSetNull); // don't delete track on media library removal, we want to wait for the next scan to have a chance to migrate files
Wt::Dbo::belongsTo(a, _directory, "directory", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::belongsTo(a, _preferredArtwork, "preferred_artwork", Wt::Dbo::OnDeleteSetNull);
Wt::Dbo::belongsTo(a, _preferredMediaArtwork, "preferred_media_artwork", Wt::Dbo::OnDeleteSetNull);
Wt::Dbo::hasMany(a, _trackArtistLinks, Wt::Dbo::ManyToOne, "track");
Wt::Dbo::hasMany(a, _clusters, Wt::Dbo::ManyToMany, "track_cluster", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _trackLyrics, Wt::Dbo::ManyToOne, "track");
@@ -382,6 +394,8 @@ namespace lms::db
Wt::Dbo::ptr<Release> _release;
Wt::Dbo::ptr<MediaLibrary> _mediaLibrary;
Wt::Dbo::ptr<Directory> _directory;
Wt::Dbo::ptr<Artwork> _preferredArtwork;
Wt::Dbo::ptr<Artwork> _preferredMediaArtwork;
Wt::Dbo::collection<Wt::Dbo::ptr<TrackArtistLink>> _trackArtistLinks;
Wt::Dbo::collection<Wt::Dbo::ptr<Cluster>> _clusters;
Wt::Dbo::collection<Wt::Dbo::ptr<TrackLyrics>> _trackLyrics;
src/libs/database/test/Release.cpp
+12
View File
@@ -1220,6 +1220,18 @@ namespace lms::db::tests
ASSERT_TRUE(releaseArtwork);
EXPECT_EQ(releaseArtwork->getId(), artwork.getId());
}
// Check cascade delete
{
auto transaction{ session.createWriteTransaction() };
image.lockAndGet().remove();
}
{
auto transaction{ session.createReadTransaction() };
auto releaseArtwork(release.get()->getPreferredArtwork());
ASSERT_FALSE(releaseArtwork);
}
}
TEST_F(DatabaseFixture, Release_sortDateAdded)
src/libs/services/artwork/impl/ArtworkService.cpp
+12 -95
View File
@@ -39,14 +39,6 @@
namespace lms::artwork
{
namespace
{
bool isImageFound(const ArtworkService::ImageFindResult& res)
{
return !std::holds_alternative<std::monostate>(res);
}
} // namespace
std::unique_ptr<IArtworkService> createArtworkService(db::Db& db, const std::filesystem::path& defaultReleaseCoverSvgPath, const std::filesystem::path& defaultArtistImageSvgPath)
{
return std::make_unique<ArtworkService>(db, defaultReleaseCoverSvgPath, defaultArtistImageSvgPath);
@@ -170,72 +162,15 @@ namespace lms::artwork
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
{
db::TrackEmbeddedImage::FindParameters params;
params.setTrack(trackId);
params.setImageTypes({ db::ImageType::Media });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
if (isImageFound(res))
return res;
// Fallback on another track of the same disc
const db::Track::pointer track{ db::Track::find(session, trackId) };
if (!track)
return res;
const db::ReleaseId releaseId{ track->getReleaseId() };
if (!releaseId.isValid())
return res;
{
db::TrackEmbeddedImage::FindParameters params;
params.setRelease(releaseId);
params.setDiscNumber(track->getDiscNumber());
params.setImageTypes({ db::ImageType::Media });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::TrackNumberThenSizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
if (isImageFound(res))
return res;
// Fallback on front cover for this track
{
db::TrackEmbeddedImage::FindParameters params;
params.setTrack(trackId);
params.setImageTypes({ db::ImageType::FrontCover });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
if (isImageFound(res))
return res;
#if 0
// Fallback on external cover of the release
if (const db::Release::pointer release{ db::Release::find(session, releaseId) })
{
if (const db::ImageId imageId{ release->getImageId() }; imageId.isValid())
res = imageId;
}
#endif
if (isImageFound(res))
return res;
// Fallback on the first front cover found on the release
{
db::TrackEmbeddedImage::FindParameters params;
params.setRelease(releaseId);
params.setImageTypes({ db::ImageType::FrontCover });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::DiscNumberThenTrackNumberThenSizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
const db::Artwork::pointer artwork{ track->getPreferredArtwork() };
if (artwork && artwork->getImageId().isValid())
res = artwork->getImageId();
else if (artwork && artwork->getTrackEmbeddedImageId().isValid())
res = artwork->getTrackEmbeddedImageId();
return res;
}
@@ -246,33 +181,15 @@ namespace lms::artwork
auto transaction{ session.createReadTransaction() };
ImageFindResult res;
{
db::TrackEmbeddedImage::FindParameters params;
params.setTrack(trackId);
params.setImageTypes({ db::ImageType::Media });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
if (isImageFound(res))
const db::Track::pointer track{ db::Track::find(session, trackId) };
if (!track)
return res;
// fallback on another track of the same disc
if (const db::Track::pointer track{ db::Track::find(session, trackId) })
{
const db::ReleaseId releaseId{ track->getReleaseId() };
if (releaseId.isValid())
{
db::TrackEmbeddedImage::FindParameters params;
params.setRelease(releaseId);
params.setDiscNumber(track->getDiscNumber());
params.setImageTypes({ db::ImageType::Media });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::TrackNumberThenSizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
}
const db::Artwork::pointer artwork{ track->getPreferredMediaArtwork() };
if (artwork && artwork->getImageId().isValid())
res = artwork->getImageId();
else if (artwork && artwork->getTrackEmbeddedImageId().isValid())
res = artwork->getTrackEmbeddedImageId();
return res;
}
src/libs/services/scanner/CMakeLists.txt
+2
View File
@@ -8,6 +8,7 @@ add_library(lmsscanner STATIC
impl/scanners/LyricsFileScanner.cpp
impl/scanners/PlayListFileScanner.cpp
impl/scanners/Utils.cpp
impl/steps/ArtworkUtils.cpp
impl/steps/FileScanQueue.cpp
impl/steps/ScanErrorLogger.cpp
impl/steps/ScanStepArtistReconciliation.cpp
@@ -15,6 +16,7 @@ add_library(lmsscanner STATIC
impl/steps/ScanStepAssociateExternalLyrics.cpp
impl/steps/ScanStepAssociatePlayListTracks.cpp
impl/steps/ScanStepAssociateReleaseImages.cpp
impl/steps/ScanStepAssociateTrackImages.cpp
impl/steps/ScanStepBase.cpp
impl/steps/ScanStepCheckForDuplicatedFiles.cpp
impl/steps/ScanStepCheckForRemovedFiles.cpp
src/libs/services/scanner/impl/ScannerService.cpp
+2
View File
@@ -41,6 +41,7 @@
#include "steps/ScanStepAssociateExternalLyrics.hpp"
#include "steps/ScanStepAssociatePlayListTracks.hpp"
#include "steps/ScanStepAssociateReleaseImages.hpp"
#include "steps/ScanStepAssociateTrackImages.hpp"
#include "steps/ScanStepCheckForDuplicatedFiles.hpp"
#include "steps/ScanStepCheckForRemovedFiles.hpp"
#include "steps/ScanStepCompact.hpp"
@@ -463,6 +464,7 @@ namespace lms::scanner
_scanSteps.emplace_back(std::make_unique<ScanStepUpdateLibraryFields>(params));
_scanSteps.emplace_back(std::make_unique<ScanStepAssociateArtistImages>(params));
_scanSteps.emplace_back(std::make_unique<ScanStepAssociateReleaseImages>(params));
_scanSteps.emplace_back(std::make_unique<ScanStepAssociateTrackImages>(params)); // must come after ScanStepAssociateReleaseImages
_scanSteps.emplace_back(std::make_unique<ScanStepAssociateExternalLyrics>(params));
_scanSteps.emplace_back(std::make_unique<ScanStepRemoveOrphanedDbEntries>(params));
_scanSteps.emplace_back(std::make_unique<ScanStepCompact>(params));
src/libs/services/scanner/impl/scanners/Utils.hpp
+3 -6
View File
@@ -30,10 +30,7 @@ namespace lms::db
class Session;
} // namespace lms::db
namespace lms::scanner
namespace lms::scanner::utils
{
namespace utils
{
db::ObjectPtr<db::Directory> getOrCreateDirectory(db::Session& session, const std::filesystem::path& path, const db::ObjectPtr<db::MediaLibrary>& mediaLibrary);
} // namespace utils
} // namespace lms::scanner
db::ObjectPtr<db::Directory> getOrCreateDirectory(db::Session& session, const std::filesystem::path& path, const db::ObjectPtr<db::MediaLibrary>& mediaLibrary);
} // namespace lms::scanner::utils
src/libs/services/scanner/impl/steps/ArtworkUtils.cpp
+104
View File
@@ -0,0 +1,104 @@
/*
* 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 "ArtworkUtils.hpp"
#include "database/Artwork.hpp"
#include "database/Image.hpp"
#include "database/Session.hpp"
#include "database/Track.hpp"
#include "database/TrackEmbeddedImage.hpp"
namespace lms::scanner::utils
{
namespace
{
std::filesystem::path toPath(db::Session& session, const db::TrackEmbeddedImageId trackEmbeddedImageId)
{
session.checkReadTransaction();
std::filesystem::path res;
db::Track::FindParameters params;
params.setEmbeddedImage(trackEmbeddedImageId);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::Track::find(session, params, [&](const db::Track::pointer& track) {
res = track->getAbsoluteFilePath();
});
return res;
}
std::filesystem::path toPath(db::Session& session, db::ImageId imageId)
{
session.checkReadTransaction();
db::Image::pointer image{ db::Image::find(session, imageId) };
return image ? image->getAbsoluteFilePath() : std::filesystem::path{};
}
} // namespace
db::ObjectPtr<db::Artwork> getOrCreateArtworkFromTrackEmbeddedImage(db::Session& session, db::TrackEmbeddedImageId trackEmbeddedImageId)
{
assert(trackEmbeddedImageId.isValid());
session.checkWriteTransaction();
db::ObjectPtr<db::Artwork> artwork{ db::Artwork::find(session, trackEmbeddedImageId) };
if (!artwork)
{
db::TrackEmbeddedImage::pointer trackEmbeddedImage{ db::TrackEmbeddedImage::find(session, trackEmbeddedImageId) };
assert(trackEmbeddedImage);
artwork = session.create<db::Artwork>(trackEmbeddedImage);
}
return artwork;
}
db::ObjectPtr<db::Artwork> getOrCreateArtworkFromImage(db::Session& session, db::ImageId imageId)
{
assert(imageId.isValid());
session.checkWriteTransaction();
db::ObjectPtr<db::Artwork> artwork{ db::Artwork::find(session, imageId) };
if (!artwork)
{
db::Image::pointer image{ db::Image::find(session, imageId) };
assert(image);
artwork = session.create<db::Artwork>(image);
}
return artwork;
}
std::filesystem::path toPath(db::Session& session, db::ArtworkId artworkId)
{
session.checkReadTransaction();
db::Artwork::pointer artwork{ db::Artwork::find(session, artworkId) };
if (!artwork)
return std::filesystem::path{};
if (artwork->getTrackEmbeddedImageId().isValid())
return toPath(session, artwork->getTrackEmbeddedImageId());
if (artwork->getImageId().isValid())
return toPath(session, artwork->getImageId());
return std::filesystem::path{};
}
} // namespace lms::scanner::utils
src/libs/services/scanner/impl/steps/ArtworkUtils.hpp
+41
View File
@@ -0,0 +1,41 @@
/*
* 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/>.
*/
#pragma once
#include <filesystem>
#include "database/ArtworkId.hpp"
#include "database/ImageId.hpp"
#include "database/Object.hpp"
#include "database/TrackEmbeddedImageId.hpp"
namespace lms::db
{
class Artwork;
class Session;
} // namespace lms::db
namespace lms::scanner::utils
{
db::ObjectPtr<db::Artwork> getOrCreateArtworkFromTrackEmbeddedImage(db::Session& session, db::TrackEmbeddedImageId trackEmbeddedImageId);
db::ObjectPtr<db::Artwork> getOrCreateArtworkFromImage(db::Session& session, db::ImageId imageId);
std::filesystem::path toPath(db::Session& session, db::ArtworkId artworkId);
} // namespace lms::scanner::utils
src/libs/services/scanner/impl/steps/ScanStepAssociateReleaseImages.cpp
+19 -67
View File
@@ -38,14 +38,15 @@
#include "database/TrackEmbeddedImage.hpp"
#include "database/TrackEmbeddedImageId.hpp"
#include "ArtworkUtils.hpp"
#include "ScanContext.hpp"
namespace lms::scanner
{
namespace
{
using PreferredArtwork = std::variant<std::monostate, db::TrackEmbeddedImageId, db::ImageId>;
bool isSameArtwork(PreferredArtwork preferredArtwork, const db::Artwork::pointer& artwork)
using Artwork = std::variant<std::monostate, db::TrackEmbeddedImageId, db::ImageId>;
bool isSameArtwork(Artwork preferredArtwork, const db::ObjectPtr<db::Artwork>& artwork)
{
if (std::holds_alternative<std::monostate>(preferredArtwork))
return !artwork;
@@ -59,30 +60,10 @@ namespace lms::scanner
return false;
}
std::filesystem::path toPath(db::Session& session, const db::TrackEmbeddedImageId trackEmbeddedImageId)
{
std::filesystem::path res;
db::Track::FindParameters params;
params.setEmbeddedImage(trackEmbeddedImageId);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::Track::find(session, params, [&](const db::Track::pointer& track) {
res = track->getAbsoluteFilePath();
});
return res;
}
std::filesystem::path toPath(db::Session& session, const db::ImageId imageId)
{
db::Image::pointer image{ db::Image::find(session, imageId) };
return image ? image->getAbsoluteFilePath() : std::filesystem::path{};
}
struct ReleaseImageAssociation
{
db::ReleaseId releaseId;
PreferredArtwork preferredArtwork;
Artwork preferredArtwork;
};
using ReleaseImageAssociationContainer = std::deque<ReleaseImageAssociation>;
@@ -120,7 +101,7 @@ namespace lms::scanner
return image;
}
db::Image::pointer computeBestReleaseImage(SearchReleaseImageContext& searchContext, const db::Release::pointer& release)
db::Image::pointer computePreferredReleaseImage(SearchReleaseImageContext& searchContext, const db::Release::pointer& release)
{
db::Image::pointer image;
@@ -168,11 +149,11 @@ namespace lms::scanner
return image;
}
PreferredArtwork computeBestReleaseArtwork(SearchReleaseImageContext& searchContext, const db::Release::pointer& release)
Artwork computePreferredReleaseArtwork(SearchReleaseImageContext& searchContext, const db::Release::pointer& release)
{
const db::Image::pointer image{ computeBestReleaseImage(searchContext, release) };
const db::Image::pointer image{ computePreferredReleaseImage(searchContext, release) };
if (image)
return PreferredArtwork{ image->getId() };
return Artwork{ image->getId() };
// Fallback on embedded Front image
db::TrackEmbeddedImageId trackEmbeddedImageId;
@@ -187,7 +168,7 @@ namespace lms::scanner
}
if (trackEmbeddedImageId.isValid())
return PreferredArtwork{ trackEmbeddedImageId };
return Artwork{ trackEmbeddedImageId };
// Fallback on embedded media image
{
@@ -201,9 +182,9 @@ namespace lms::scanner
}
if (trackEmbeddedImageId.isValid())
return PreferredArtwork{ trackEmbeddedImageId };
return Artwork{ trackEmbeddedImageId };
return PreferredArtwork{};
return Artwork{};
}
bool fetchNextReleaseArtworksToUpdate(SearchReleaseImageContext& searchContext, ReleaseImageAssociationContainer& releaseImageAssociations)
@@ -216,7 +197,7 @@ namespace lms::scanner
auto transaction{ searchContext.session.createReadTransaction() };
db::Release::find(searchContext.session, searchContext.lastRetrievedReleaseId, readBatchSize, [&](const db::Release::pointer& release) {
const PreferredArtwork preferredArtwork{ computeBestReleaseArtwork(searchContext, release) };
const Artwork preferredArtwork{ computePreferredReleaseArtwork(searchContext, release) };
const db::Artwork::pointer currentPreferredArtwork{ release->getPreferredArtwork() };
if (!isSameArtwork(preferredArtwork, currentPreferredArtwork))
@@ -228,30 +209,6 @@ namespace lms::scanner
return releaseId != searchContext.lastRetrievedReleaseId;
}
db::Artwork::pointer getOrCreateArtworkFromTrackEmbeddedImage(db::Session& session, const db::TrackEmbeddedImageId& trackEmbeddedImageId)
{
db::Artwork::pointer artwork{ db::Artwork::find(session, trackEmbeddedImageId) };
if (!artwork)
{
db::TrackEmbeddedImage::pointer trackEmbeddedImage{ db::TrackEmbeddedImage::find(session, trackEmbeddedImageId) };
assert(trackEmbeddedImage);
artwork = session.create<db::Artwork>(trackEmbeddedImage);
}
return artwork;
}
db::Artwork::pointer getOrCreateArtworkFromImage(db::Session& session, const db::ImageId& imageId)
{
db::Artwork::pointer artwork{ db::Artwork::find(session, imageId) };
if (!artwork)
{
db::Image::pointer image{ db::Image::find(session, imageId) };
assert(image);
artwork = session.create<db::Artwork>(image);
}
return artwork;
}
void updateReleaseArtwork(db::Session& session, const ReleaseImageAssociation& releaseImageAssociation)
{
db::Release::pointer release{ db::Release::find(session, releaseImageAssociation.releaseId) };
@@ -260,21 +217,16 @@ namespace lms::scanner
db::Artwork::pointer artwork;
if (const db::TrackEmbeddedImageId * trackEmbeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&releaseImageAssociation.preferredArtwork) })
{
artwork = getOrCreateArtworkFromTrackEmbeddedImage(session, *trackEmbeddedImageId);
LMS_LOG(DBUPDATER, DEBUG, "Updating preferred artwork in release '" << release->getName() << "' with embedded image in track " << toPath(session, *trackEmbeddedImageId));
}
artwork = utils::getOrCreateArtworkFromTrackEmbeddedImage(session, *trackEmbeddedImageId);
else if (const db::ImageId * imageId{ std::get_if<db::ImageId>(&releaseImageAssociation.preferredArtwork) })
{
artwork = getOrCreateArtworkFromImage(session, *imageId);
LMS_LOG(DBUPDATER, DEBUG, "Updating preferred artwork in release '" << release->getName() << "' with image " << toPath(session, *imageId));
}
else
{
LMS_LOG(DBUPDATER, DEBUG, "Removing preferred artwork from release '" << release->getName() << "'");
}
artwork = utils::getOrCreateArtworkFromImage(session, *imageId);
release.modify()->setPreferredArtwork(artwork);
if (artwork)
LMS_LOG(DBUPDATER, DEBUG, "Updated preferred artwork in release '" << release->getName() << "' with image in " << utils::toPath(session, artwork->getId()));
else
LMS_LOG(DBUPDATER, DEBUG, "Removed preferred artwork from release '" << release->getName() << "'");
}
void updateReleaseImages(db::Session& session, ReleaseImageAssociationContainer& imageAssociations)
src/libs/services/scanner/impl/steps/ScanStepAssociateTrackImages.cpp
+298
View File
@@ -0,0 +1,298 @@
/*
* 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 "ScanStepAssociateTrackImages.hpp"
#include <cassert>
#include <deque>
#include <variant>
#include "core/ILogger.hpp"
#include "database/Artwork.hpp"
#include "database/Db.hpp"
#include "database/Directory.hpp"
#include "database/Image.hpp"
#include "database/Release.hpp"
#include "database/Session.hpp"
#include "database/Track.hpp"
#include "database/TrackEmbeddedImage.hpp"
#include "database/TrackEmbeddedImageId.hpp"
#include "ArtworkUtils.hpp"
#include "ScanContext.hpp"
namespace lms::scanner
{
namespace
{
// May come from an embedded image in a track, or from what has been previously resolved for the release
using Artwork = std::variant<std::monostate, db::TrackEmbeddedImageId, db::ArtworkId>;
bool isSameArtwork(Artwork preferredArtwork, const db::ObjectPtr<db::Artwork>& artwork)
{
if (std::holds_alternative<std::monostate>(preferredArtwork))
return !artwork;
if (const db::TrackEmbeddedImageId* trackEmbeddedImageId = std::get_if<db::TrackEmbeddedImageId>(&preferredArtwork))
return artwork && *trackEmbeddedImageId == artwork->getTrackEmbeddedImageId();
if (const db::ArtworkId* artworkId = std::get_if<db::ArtworkId>(&preferredArtwork))
return artwork && *artworkId == artwork->getId();
return false;
}
bool isValid(const Artwork& res)
{
return !std::holds_alternative<std::monostate>(res);
}
struct TrackImageAssociation
{
db::Track::pointer track;
Artwork preferredArtwork;
Artwork preferredMediaArtwork;
};
using TrackImageAssociationContainer = std::deque<TrackImageAssociation>;
struct SearchTrackImageContext
{
db::Session& session;
db::TrackId lastRetrievedTrackId;
std::size_t processedTrackCount{};
};
Artwork computePreferredTrackArtwork(SearchTrackImageContext& searchContext, const db::Track::pointer& track)
{
// Try to get a media image
Artwork res;
{
db::TrackEmbeddedImage::FindParameters params;
params.setTrack(track->getId());
params.setImageTypes({ db::ImageType::Media });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(searchContext.session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
if (isValid(res))
return res;
// Fallback on another track of the same disc
const db::ReleaseId releaseId{ track->getReleaseId() };
if (!releaseId.isValid())
return Artwork{};
{
db::TrackEmbeddedImage::FindParameters params;
params.setRelease(releaseId);
params.setDiscNumber(track->getDiscNumber());
params.setImageTypes({ db::ImageType::Media });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::TrackNumberThenSizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(searchContext.session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
if (isValid(res))
return res;
// Fallback on front cover for this track
{
db::TrackEmbeddedImage::FindParameters params;
params.setTrack(track->getId());
params.setImageTypes({ db::ImageType::FrontCover });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(searchContext.session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
if (isValid(res))
return res;
// Fallback on the artwork already resolved for the release
if (const db::Release::pointer release{ db::Release::find(searchContext.session, releaseId) })
{
db::ArtworkId artworkId{ release->getPreferredArtworkId() };
if (artworkId.isValid())
res = artworkId;
}
return res;
}
Artwork computePreferredTrackMediaArtwork(SearchTrackImageContext& searchContext, const db::Track::pointer& track)
{
Artwork res;
{
db::TrackEmbeddedImage::FindParameters params;
params.setTrack(track->getId());
params.setImageTypes({ db::ImageType::Media });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(searchContext.session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
if (isValid(res))
return res;
// fallback on another track of the same disc
if (const db::ReleaseId releaseId{ track->getReleaseId() }; releaseId.isValid())
{
db::TrackEmbeddedImage::FindParameters params;
params.setRelease(releaseId);
params.setDiscNumber(track->getDiscNumber());
params.setImageTypes({ db::ImageType::Media });
params.setSortMethod(db::TrackEmbeddedImageSortMethod::TrackNumberThenSizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(searchContext.session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
}
return res;
}
bool fetchNextTrackArtworksToUpdate(SearchTrackImageContext& searchContext, TrackImageAssociationContainer& trackImageAssociations)
{
const db::TrackId trackId{ searchContext.lastRetrievedTrackId };
{
constexpr std::size_t readBatchSize{ 100 };
auto transaction{ searchContext.session.createReadTransaction() };
db::Track::find(searchContext.session, searchContext.lastRetrievedTrackId, readBatchSize, [&](const db::Track::pointer& track) {
const Artwork preferredArtwork{ computePreferredTrackArtwork(searchContext, track) };
const Artwork preferredMediaArtwork{ computePreferredTrackMediaArtwork(searchContext, track) };
const db::Artwork::pointer currentPreferredArtwork{ track->getPreferredArtwork() };
const db::Artwork::pointer currentPreferredMediaArtwork{ track->getPreferredMediaArtwork() };
if (!isSameArtwork(preferredArtwork, currentPreferredArtwork)
|| !isSameArtwork(preferredMediaArtwork, currentPreferredMediaArtwork))
{
trackImageAssociations.push_back(TrackImageAssociation{ track, preferredArtwork, preferredMediaArtwork });
}
searchContext.processedTrackCount++;
});
}
return trackId != searchContext.lastRetrievedTrackId;
}
void updateTrackPreferredArtwork(db::Session& session, db::Track::pointer& track, Artwork preferredArtwork)
{
db::Artwork::pointer artwork;
if (const db::TrackEmbeddedImageId * trackEmbeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&preferredArtwork) })
artwork = utils::getOrCreateArtworkFromTrackEmbeddedImage(session, *trackEmbeddedImageId);
else if (const db::ArtworkId * artworkId{ std::get_if<db::ArtworkId>(&preferredArtwork) })
artwork = db::Artwork::find(session, *artworkId);
// Using track.modify() is quite CPU intensive as the track class has too many fields
db::Track::updatePreferredArtwork(session, track->getId(), artwork->getId());
if (artwork)
LMS_LOG(DBUPDATER, DEBUG, "Updated preferred artwork in track " << track->getAbsoluteFilePath() << " with image in " << utils::toPath(session, artwork->getId()));
else
LMS_LOG(DBUPDATER, DEBUG, "Removed preferred artwork from track " << track->getAbsoluteFilePath());
}
void updateTrackPreferredMediaArtwork(db::Session& session, db::Track::pointer& track, Artwork preferredArtwork)
{
db::Artwork::pointer artwork;
if (const db::TrackEmbeddedImageId * trackEmbeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&preferredArtwork) })
artwork = utils::getOrCreateArtworkFromTrackEmbeddedImage(session, *trackEmbeddedImageId);
else if (const db::ArtworkId * artworkId{ std::get_if<db::ArtworkId>(&preferredArtwork) })
artwork = db::Artwork::find(session, *artworkId);
// Using track.modify() is quite CPU intensive as the track class has too many fields
db::Track::updatePreferredMediaArtwork(session, track->getId(), artwork->getId());
if (artwork)
LMS_LOG(DBUPDATER, DEBUG, "Updated preferred media artwork in track '" << track->getAbsoluteFilePath() << "' with image in " << utils::toPath(session, artwork->getId()));
else
LMS_LOG(DBUPDATER, DEBUG, "Removed preferred media artwork from track '" << track->getAbsoluteFilePath() << "'");
}
void updateTrackPreferredArtworks(db::Session& session, const TrackImageAssociation& trackImageAssociation)
{
db::Track::pointer track{ trackImageAssociation.track };
{
const db::Artwork::pointer currentPreferredArtwork{ track->getPreferredArtwork() };
if (!isSameArtwork(trackImageAssociation.preferredArtwork, currentPreferredArtwork))
updateTrackPreferredArtwork(session, track, trackImageAssociation.preferredArtwork);
}
{
const db::Artwork::pointer currentPreferredMediaArtwork{ track->getPreferredMediaArtwork() };
if (!isSameArtwork(trackImageAssociation.preferredMediaArtwork, currentPreferredMediaArtwork))
updateTrackPreferredMediaArtwork(session, track, trackImageAssociation.preferredMediaArtwork);
}
}
void updateTrackPreferredArtworks(db::Session& session, TrackImageAssociationContainer& imageAssociations)
{
constexpr std::size_t writeBatchSize{ 50 };
while (!imageAssociations.empty())
{
auto transaction{ session.createWriteTransaction() };
for (std::size_t i{}; !imageAssociations.empty() && i < writeBatchSize; ++i)
{
updateTrackPreferredArtworks(session, imageAssociations.front());
imageAssociations.pop_front();
}
}
}
} // namespace
ScanStepAssociateTrackImages::ScanStepAssociateTrackImages(InitParams& initParams)
: ScanStepBase{ initParams }
{
}
bool ScanStepAssociateTrackImages::needProcess(const ScanContext& context) const
{
return context.stats.nbChanges() > 0;
}
void ScanStepAssociateTrackImages::process(ScanContext& context)
{
auto& session{ _db.getTLSSession() };
{
auto transaction{ session.createReadTransaction() };
context.currentStepStats.totalElems = db::Track::getCount(session);
}
SearchTrackImageContext searchContext{
.session = session,
.lastRetrievedTrackId = {},
};
TrackImageAssociationContainer trackImageAssociations;
while (fetchNextTrackArtworksToUpdate(searchContext, trackImageAssociations))
{
if (_abortScan)
return;
updateTrackPreferredArtworks(session, trackImageAssociations);
context.currentStepStats.processedElems = searchContext.processedTrackCount;
_progressCallback(context.currentStepStats);
}
}
} // namespace lms::scanner
src/libs/services/scanner/impl/steps/ScanStepAssociateTrackImages.hpp
+40
View File
@@ -0,0 +1,40 @@
/*
* 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/>.
*/
#pragma once
#include "ScanStepBase.hpp"
namespace lms::scanner
{
class ScanStepAssociateTrackImages : public ScanStepBase
{
public:
ScanStepAssociateTrackImages(InitParams& initParams);
~ScanStepAssociateTrackImages() override = default;
ScanStepAssociateTrackImages(const ScanStepAssociateTrackImages&) = delete;
ScanStepAssociateTrackImages& operator=(const ScanStepAssociateTrackImages&) = delete;
private:
ScanStep getStep() const override { return ScanStep::AssociateReleaseImages; }
core::LiteralString getStepName() const override { return "Associate track images"; }
bool needProcess(const ScanContext& context) const override;
void process(ScanContext& context) override;
};
} // namespace lms::scanner