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

Changed the way album covers are associated, fixes #503

Browse Source
This commit is contained in:
emeric
2024-09-29 16:21:46 +02:00
parent 4e1b422e31
commit 3f6177cedd
31 changed files with 502 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libs/database/impl/Artist.cpp
-1
View File
@@ -379,5 +379,4 @@ namespace lms::db
{
_image = getDboPtr(image);
}
} // namespace lms::db
src/libs/database/impl/Image.cpp
+2 -1
View File
@@ -23,6 +23,7 @@
#include "database/Artist.hpp"
#include "database/Directory.hpp"
#include "database/Release.hpp"
#include "database/Session.hpp"
#include "IdTypeTraits.hpp"
@@ -40,7 +41,7 @@ namespace lms::db
if (params.directory.isValid())
query.where("i.directory_id = ?").bind(params.directory);
if (!params.fileStem.empty())
query.where("i.stem = ?").bind(params.fileStem);
query.where("i.stem = ? COLLATE NOCASE").bind(params.fileStem);
return query;
}
src/libs/database/impl/Migration.cpp
+50 -1
View File
@@ -35,7 +35,7 @@ namespace lms::db
{
namespace
{
static constexpr Version LMS_DATABASE_VERSION{ 67 };
static constexpr Version LMS_DATABASE_VERSION{ 68 };
}
VersionInfo::VersionInfo()
@@ -761,6 +761,54 @@ SELECT
session.getDboSession()->execute("ALTER TABLE user DROP COLUMN cur_playing_track_pos");
}
void migrateFromV67(Session& session)
{
// Add a ref to release in image
session.getDboSession()->execute(R"(CREATE TABLE "image_backup" (
"id" integer primary key autoincrement,
"version" integer not null,
"absolute_file_path" text not null,
"stem" text not null,
"file_last_write" text,
"file_size" integer not null,
"width" integer not null,
"height" integer not null,
"artist_id" bigint,
"release_id" bigint,
"directory_id" bigint,
constraint "fk_image_artist" foreign key ("artist_id") references "artist" ("id") on delete cascade deferrable initially deferred,
constraint "fk_image_release" foreign key ("release_id") references "release" ("id") on delete cascade deferrable initially deferred,
constraint "fk_image_directory" foreign key ("directory_id") references "directory" ("id") on delete cascade deferrable initially deferred
))");
// Migrate data, with the new release_id field set to null
session.getDboSession()->execute(R"(INSERT INTO image_backup
SELECT
id,
version,
absolute_file_path,
stem,
file_last_write,
file_size,
width,
height,
artist_id,
NULL,
directory_id
FROM image
)");
session.getDboSession()->execute("DROP TABLE image");
session.getDboSession()->execute("ALTER TABLE image_backup RENAME TO image");
// Changed some indexes for the image table -> remove all the previoulsy created index, the createIndexesIfNeeded will recreate them all
std::vector<std::string> indexeNames{ utils::fetchQueryResults(session.getDboSession()->query<std::string>(R"(SELECT name FROM sqlite_master WHERE type = 'index' AND name LIKE '%_idx')")) };
for (const auto& indexName : indexeNames)
session.getDboSession()->execute("DROP INDEX " + indexName);
// Just increment the scan version of the settings to make the next scheduled scan rescan everything
session.getDboSession()->execute("UPDATE scan_settings SET scan_version = scan_version + 1");
}
bool doDbMigration(Session& session)
{
static const std::string outdatedMsg{ "Outdated database, please rebuild it (delete the .db file and restart)" };
@@ -804,6 +852,7 @@ SELECT
{ 64, migrateFromV64 },
{ 65, migrateFromV65 },
{ 66, migrateFromV66 },
{ 67, migrateFromV67 },
};
bool migrationPerformed{};
src/libs/database/impl/Release.cpp
+12 -1
View File
@@ -24,6 +24,8 @@
#include "core/ILogger.hpp"
#include "database/Artist.hpp"
#include "database/Cluster.hpp"
#include "database/Directory.hpp"
#include "database/Image.hpp"
#include "database/Session.hpp"
#include "database/Track.hpp"
#include "database/User.hpp"
@@ -540,6 +542,11 @@ namespace lms::db
return utils::fetchQueryResults<Release::pointer>(query);
}
ObjectPtr<Image> Release::getImage() const
{
return ObjectPtr<Image>{ _image.lock() };
}
void Release::clearLabels()
{
_labels.clear();
@@ -560,6 +567,11 @@ namespace lms::db
_releaseTypes.insert(getDboPtr(releaseType));
}
void Release::setImage(ObjectPtr<Image> image)
{
_image = getDboPtr(image);
}
bool Release::hasVariousArtists() const
{
// TODO optimize
@@ -665,5 +677,4 @@ namespace lms::db
return res;
}
} // namespace lms::db
src/libs/database/impl/Session.cpp
+3 -2
View File
@@ -196,10 +196,11 @@ namespace lms::db
_session.execute("CREATE INDEX IF NOT EXISTS directory_media_library_idx ON directory(media_library_id)");
_session.execute("CREATE INDEX IF NOT EXISTS image_artist_idx ON image(artist_id)");
_session.execute("CREATE INDEX IF NOT EXISTS image_directory_idx ON image(directory_id)");
_session.execute("CREATE INDEX IF NOT EXISTS image_directory_stem_idx ON image(directory_id, stem COLLATE NOCASE)");
_session.execute("CREATE INDEX IF NOT EXISTS image_id_idx ON image(id)");
_session.execute("CREATE INDEX IF NOT EXISTS image_path_idx ON image(absolute_file_path)");
_session.execute("CREATE INDEX IF NOT EXISTS image_stem_idx ON image(stem)");
_session.execute("CREATE INDEX IF NOT EXISTS image_release_idx ON image(release_id)");
_session.execute("CREATE INDEX IF NOT EXISTS image_stem_idx ON image(stem COLLATE NOCASE)");
_session.execute("CREATE INDEX IF NOT EXISTS label_name_idx ON label(name)");
src/libs/database/impl/Track.cpp
+3
View File
@@ -157,6 +157,9 @@ namespace lms::db
if (params.directory.isValid())
query.where("t.directory_id = ?").bind(params.directory);
if (params.hasEmbeddedImage.has_value())
query.where("t.has_cover = ?").bind(params.hasEmbeddedImage.value());
switch (params.sortMethod)
{
case TrackSortMethod::None:
src/libs/database/include/database/Image.hpp
+13 -2
View File
@@ -25,7 +25,6 @@
#include <Wt/Dbo/Dbo.h>
#include <Wt/WDateTime.h>
#include "database/ArtistId.hpp"
#include "database/DirectoryId.hpp"
#include "database/ImageId.hpp"
#include "database/Object.hpp"
@@ -35,6 +34,7 @@ namespace lms::db
{
class Artist;
class Directory;
class Release;
class Session;
class Image final : public Object<Image, ImageId>
@@ -87,7 +87,16 @@ namespace lms::db
void setFileSize(std::size_t fileSize) { _fileSize = fileSize; }
void setWidth(std::size_t width) { _width = width; }
void setHeight(std::size_t height) { _height = height; }
void setArtist(const ObjectPtr<Artist>& artist) { _artist = getDboPtr(artist); }
void setArtist(const ObjectPtr<Artist>& artist)
{
_artist = getDboPtr(artist);
_release = nullptr;
}
void setRelease(const ObjectPtr<Release>& release)
{
_release = getDboPtr(release);
_artist = nullptr;
}
void setDirectory(const ObjectPtr<Directory>& directory) { _directory = getDboPtr(directory); }
template<class Action>
@@ -102,6 +111,7 @@ namespace lms::db
Wt::Dbo::field(a, _height, "height");
Wt::Dbo::belongsTo(a, _artist, "artist", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::belongsTo(a, _release, "release", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::belongsTo(a, _directory, "directory", Wt::Dbo::OnDeleteCascade);
}
@@ -118,6 +128,7 @@ namespace lms::db
int _height{};
Wt::Dbo::ptr<Artist> _artist;
Wt::Dbo::ptr<Release> _release;
Wt::Dbo::ptr<Directory> _directory;
};
} // namespace lms::db
src/libs/database/include/database/Release.hpp
+5
View File
@@ -47,6 +47,7 @@ namespace lms::db
class Artist;
class Cluster;
class ClusterType;
class Image;
class Release;
class Session;
class Track;
@@ -245,6 +246,7 @@ namespace lms::db
std::vector<std::string> getLabelNames() const;
std::vector<std::string> getReleaseTypeNames() const;
void visitLabels(const std::function<void(const Label::pointer& label)>& _func) const;
ObjectPtr<Image> getImage() const;
// Setters
void setName(std::string_view name) { _name = name; }
@@ -258,6 +260,7 @@ namespace lms::db
void clearReleaseTypes();
void addLabel(ObjectPtr<Label> releaseType);
void addReleaseType(ObjectPtr<ReleaseType> releaseType);
void setImage(ObjectPtr<Image> image);
// Get the artists of this release
std::vector<ObjectPtr<Artist>> getArtists(TrackArtistLinkType type = TrackArtistLinkType::Artist) const;
@@ -278,6 +281,7 @@ namespace lms::db
Wt::Dbo::field(a, _isCompilation, "is_compilation");
Wt::Dbo::hasMany(a, _tracks, Wt::Dbo::ManyToOne, "release");
Wt::Dbo::hasOne(a, _image, "release");
Wt::Dbo::hasMany(a, _labels, Wt::Dbo::ManyToMany, "release_label", "", Wt::Dbo::OnDeleteCascade);
Wt::Dbo::hasMany(a, _releaseTypes, Wt::Dbo::ManyToMany, "release_release_type", "", Wt::Dbo::OnDeleteCascade);
}
@@ -300,6 +304,7 @@ namespace lms::db
std::string _artistDisplayName;
bool _isCompilation{}; // See https://picard-docs.musicbrainz.org/en/appendices/tag_mapping.html#compilation-itunes-5
Wt::Dbo::weak_ptr<Image> _image;
Wt::Dbo::collection<Wt::Dbo::ptr<Track>> _tracks;
Wt::Dbo::collection<Wt::Dbo::ptr<Label>> _labels;
Wt::Dbo::collection<Wt::Dbo::ptr<ReleaseType>> _releaseTypes;
src/libs/database/include/database/Track.hpp
+6
View File
@@ -83,6 +83,7 @@ namespace lms::db
std::optional<int> discNumber; // matching this disc number
MediaLibraryId mediaLibrary; // If set, tracks in this library
DirectoryId directory; // if set, tracks in this directory
std::optional<bool> hasEmbeddedImage; // if set, tracks that have or not embedded images
FindParameters& setClusters(std::span<const ClusterId> _clusters)
{
@@ -172,6 +173,11 @@ namespace lms::db
directory = _directory;
return *this;
}
FindParameters& setHasEmbeddedImage(std::optional<bool> _hasEmbeddedImage)
{
hasEmbeddedImage = _hasEmbeddedImage;
return *this;
}
};
struct PathResult
src/libs/services/cover/impl/CoverService.cpp
+19 -193
View File
@@ -19,8 +19,6 @@
#include "CoverService.hpp"
#include <set>
#include "av/IAudioFile.hpp"
#include "core/IConfig.hpp"
#include "core/ILogger.hpp"
@@ -41,52 +39,6 @@ namespace lms::cover
{
namespace
{
struct TrackInfo
{
bool hasCover{};
bool isMultiDisc{};
std::filesystem::path trackPath;
std::optional<db::ReleaseId> releaseId;
};
std::optional<TrackInfo> getTrackInfo(db::Session& dbSession, db::TrackId trackId)
{
std::optional<TrackInfo> res;
auto transaction{ dbSession.createReadTransaction() };
const db::Track::pointer track{ db::Track::find(dbSession, trackId) };
if (!track)
return res;
res = TrackInfo{};
res->hasCover = track->hasCover();
res->trackPath = track->getAbsoluteFilePath();
if (const db::Release::pointer & release{ track->getRelease() })
{
res->releaseId = release->getId();
if (release->getTotalDisc() > 1)
res->isMultiDisc = true;
}
return res;
}
std::vector<std::string> constructPreferredFileNames()
{
std::vector<std::string> res;
core::Service<core::IConfig>::get()->visitStrings("cover-preferred-file-names",
[&res](std::string_view fileName) {
res.emplace_back(fileName);
},
{ "cover", "front" });
return res;
}
bool isFileSupported(const std::filesystem::path& file, const std::vector<std::filesystem::path>& extensions)
{
return (std::find(std::cbegin(extensions), std::cend(extensions), file.extension()) != std::cend(extensions));
@@ -104,15 +56,11 @@ namespace lms::cover
const std::filesystem::path& defaultSvgCoverPath)
: _db{ db }
, _cache{ core::Service<core::IConfig>::get()->getULong("cover-max-cache-size", 30) * 1000 * 1000 }
, _maxFileSize{ core::Service<core::IConfig>::get()->getULong("cover-max-file-size", 10) * 1000 * 1000 }
, _preferredFileNames{ constructPreferredFileNames() }
{
setJpegQuality(core::Service<core::IConfig>::get()->getULong("cover-jpeg-quality", 75));
LMS_LOG(COVER, INFO, "Default cover path = '" << defaultSvgCoverPath.string() << "'");
LMS_LOG(COVER, INFO, "Max cache size = " << _cache.getMaxCacheSize());
LMS_LOG(COVER, INFO, "Max file size = " << _maxFileSize);
LMS_LOG(COVER, INFO, "Preferred file names: " << core::stringUtils::joinStrings(_preferredFileNames, ","));
_defaultCover = image::readSvgFile(defaultSvgCoverPath); // may throw
}
@@ -140,7 +88,7 @@ namespace lms::cover
return image;
}
std::unique_ptr<IEncodedImage> CoverService::getFromCoverFile(const std::filesystem::path& p, ImageSize width) const
std::unique_ptr<IEncodedImage> CoverService::getFromImageFile(const std::filesystem::path& p, ImageSize width) const
{
std::unique_ptr<IEncodedImage> image;
@@ -163,66 +111,7 @@ namespace lms::cover
return _defaultCover;
}
std::unique_ptr<IEncodedImage> CoverService::getFromDirectory(const std::filesystem::path& directory, ImageSize width, const std::vector<std::string>& preferredFileNames, bool allowPickRandom) const
{
const std::multimap<std::string, std::filesystem::path> coverPaths{ getCoverPaths(directory) };
auto tryLoadImageFromFilename = [&](std::string_view fileName) {
std::unique_ptr<IEncodedImage> image;
auto range{ coverPaths.equal_range(std::string{ fileName }) };
for (auto it{ range.first }; it != range.second; ++it)
{
image = getFromCoverFile(it->second, width);
if (image)
break;
}
return image;
};
std::unique_ptr<IEncodedImage> image;
for (const std::string_view filename : preferredFileNames)
{
image = tryLoadImageFromFilename(filename);
if (image)
return image;
}
if (allowPickRandom)
{
for (const auto& [filename, coverPath] : coverPaths)
{
image = getFromCoverFile(coverPath, width);
if (image)
return image;
}
}
return image;
}
std::unique_ptr<IEncodedImage> CoverService::getFromSameNamedFile(const std::filesystem::path& filePath, ImageSize width) const
{
std::unique_ptr<IEncodedImage> res;
std::filesystem::path coverPath{ filePath };
for (const std::filesystem::path& extension : _fileExtensions)
{
coverPath.replace_extension(extension);
if (!checkCoverFile(coverPath))
continue;
res = getFromCoverFile(coverPath, width);
if (res)
break;
}
return res;
}
bool CoverService::checkCoverFile(const std::filesystem::path& filePath) const
bool CoverService::checkImageFile(const std::filesystem::path& filePath) const
{
std::error_code ec;
@@ -235,35 +124,9 @@ namespace lms::cover
if (!std::filesystem::is_regular_file(filePath, ec))
return false;
if (std::filesystem::file_size(filePath, ec) > _maxFileSize && !ec)
{
LMS_LOG(COVER, INFO, "Image file '" << filePath.string() << " is too big (" << std::filesystem::file_size(filePath, ec) << "), limit is " << _maxFileSize);
return false;
}
return true;
}
std::multimap<std::string, std::filesystem::path> CoverService::getCoverPaths(const std::filesystem::path& directoryPath) const
{
std::multimap<std::string, std::filesystem::path> res;
std::error_code ec;
std::filesystem::directory_iterator itPath(directoryPath, ec);
const std::filesystem::directory_iterator itEnd;
while (!ec && itPath != itEnd)
{
const std::filesystem::path& path{ *itPath };
if (checkCoverFile(path))
res.emplace(std::filesystem::path{ path }.filename().replace_extension("").string(), path);
itPath.increment(ec);
}
return res;
}
std::unique_ptr<IEncodedImage> CoverService::getFromTrack(const std::filesystem::path& p, ImageSize width) const
{
std::unique_ptr<IEncodedImage> image;
@@ -282,35 +145,19 @@ namespace lms::cover
std::shared_ptr<IEncodedImage> CoverService::getFromTrack(db::TrackId trackId, ImageSize width)
{
return getFromTrack(_db.getTLSSession(), trackId, width, true /* allow release fallback*/);
}
std::shared_ptr<IEncodedImage> CoverService::getFromTrack(db::Session& dbSession, db::TrackId trackId, ImageSize width, bool allowReleaseFallback)
{
using namespace db;
const ImageCache::EntryDesc cacheEntryDesc{ trackId, width };
std::shared_ptr<IEncodedImage> cover{ _cache.getImage(cacheEntryDesc) };
if (cover)
return cover;
if (const std::optional<TrackInfo> trackInfo{ getTrackInfo(dbSession, trackId) })
{
if (trackInfo->hasCover)
cover = getFromTrack(trackInfo->trackPath, width);
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
if (!cover)
cover = getFromSameNamedFile(trackInfo->trackPath, width);
if (!cover && trackInfo->releaseId && allowReleaseFallback)
cover = getFromRelease(*trackInfo->releaseId, width);
if (!cover && trackInfo->isMultiDisc)
{
if (trackInfo->trackPath.parent_path().has_parent_path())
cover = getFromDirectory(trackInfo->trackPath.parent_path().parent_path(), width, _preferredFileNames, true);
}
const db::Track::pointer track{ db::Track::find(session, trackId) };
if (track && track->hasCover())
cover = getFromTrack(track->getAbsoluteFilePath(), width);
}
if (cover)
@@ -324,47 +171,26 @@ namespace lms::cover
using namespace db;
const ImageCache::EntryDesc cacheEntryDesc{ releaseId, width };
std::shared_ptr<IEncodedImage> cover{ _cache.getImage(cacheEntryDesc) };
if (cover)
return cover;
std::shared_ptr<IEncodedImage> image{ _cache.getImage(cacheEntryDesc) };
if (image)
return image;
struct ReleaseInfo
{
TrackId firstTrackId;
std::filesystem::path releaseDirectory;
};
Session& session{ _db.getTLSSession() };
auto getReleaseInfo{ [&] {
std::optional<ReleaseInfo> res;
Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
// get a track in this release, consider the release is in a single directory
const auto tracks{ Track::find(session, Track::FindParameters{}.setRelease(releaseId).setRange(Range{ 0, 1 }).setSortMethod(TrackSortMethod::Release)) };
if (!tracks.results.empty())
const db::Release::pointer release{ db::Release::find(session, releaseId) };
if (release)
{
const Track::pointer& track{ tracks.results.front() };
res = ReleaseInfo{};
res->firstTrackId = track->getId();
res->releaseDirectory = track->getAbsoluteFilePath().parent_path();
if (const db::Image::pointer dbImage{ release->getImage() })
image = getFromImageFile(dbImage->getAbsoluteFilePath(), width);
}
return res;
} };
if (const std::optional<ReleaseInfo> releaseInfo{ getReleaseInfo() })
{
cover = getFromDirectory(releaseInfo->releaseDirectory, width, _preferredFileNames, true);
if (!cover)
cover = getFromTrack(session, releaseInfo->firstTrackId, width, false /* no release fallback */);
}
if (cover)
_cache.addImage(cacheEntryDesc, cover);
if (image)
_cache.addImage(cacheEntryDesc, image);
return cover;
return image;
}
std::shared_ptr<IEncodedImage> CoverService::getFromArtist(db::ArtistId artistId, ImageSize width)
@@ -384,7 +210,7 @@ namespace lms::cover
if (const Artist::pointer artist{ Artist::find(session, artistId) })
{
if (const db::Image::pointer image{ artist->getImage() })
artistImage = getFromCoverFile(image->getAbsoluteFilePath(), width);
artistImage = getFromImageFile(image->getAbsoluteFilePath(), width);
}
}
src/libs/services/cover/impl/CoverService.hpp
+2 -8
View File
@@ -20,7 +20,6 @@
#pragma once
#include <filesystem>
#include <map>
#include <vector>
#include "database/Types.hpp"
@@ -59,14 +58,11 @@ namespace lms::cover
std::shared_ptr<image::IEncodedImage> getFromTrack(db::Session& dbSession, db::TrackId trackId, image::ImageSize width, bool allowReleaseFallback);
std::unique_ptr<image::IEncodedImage> getFromAvMediaFile(const av::IAudioFile& input, image::ImageSize width) const;
std::unique_ptr<image::IEncodedImage> getFromCoverFile(const std::filesystem::path& p, image::ImageSize width) const;
std::unique_ptr<image::IEncodedImage> getFromImageFile(const std::filesystem::path& p, image::ImageSize width) const;
std::unique_ptr<image::IEncodedImage> getFromTrack(const std::filesystem::path& path, image::ImageSize width) const;
std::multimap<std::string, std::filesystem::path> getCoverPaths(const std::filesystem::path& directoryPath) const;
std::unique_ptr<image::IEncodedImage> getFromDirectory(const std::filesystem::path& directory, image::ImageSize width, const std::vector<std::string>& preferredFileNames, bool allowPickRandom) const;
std::unique_ptr<image::IEncodedImage> getFromSameNamedFile(const std::filesystem::path& filePath, image::ImageSize width) const;
bool checkCoverFile(const std::filesystem::path& filePath) const;
bool checkImageFile(const std::filesystem::path& filePath) const;
db::Db& _db;
@@ -74,8 +70,6 @@ namespace lms::cover
std::shared_ptr<image::IEncodedImage> _defaultCover;
static inline const std::vector<std::filesystem::path> _fileExtensions{ ".jpg", ".jpeg", ".png", ".bmp" }; // TODO parametrize
const std::size_t _maxFileSize;
const std::vector<std::string> _preferredFileNames;
unsigned _jpegQuality;
};
src/libs/services/cover/include/services/cover/ICoverService.hpp
+6 -2
View File
@@ -39,10 +39,14 @@ namespace lms::cover
public:
virtual ~ICoverService() = default;
virtual std::shared_ptr<image::IEncodedImage> getFromTrack(db::TrackId trackId, image::ImageSize width) = 0;
virtual std::shared_ptr<image::IEncodedImage> getFromRelease(db::ReleaseId releaseId, image::ImageSize width) = 0;
virtual std::shared_ptr<image::IEncodedImage> getFromArtist(db::ArtistId artistId, image::ImageSize width) = 0;
// no logic to fallback to release here
virtual std::shared_ptr<image::IEncodedImage> getFromTrack(db::TrackId trackId, image::ImageSize width) = 0;
// no logic to fallback to track here
virtual std::shared_ptr<image::IEncodedImage> getFromRelease(db::ReleaseId releaseId, image::ImageSize width) = 0;
virtual std::shared_ptr<image::IEncodedImage> getDefaultSvgCover() = 0;
virtual void flushCache() = 0;
src/libs/services/scanner/CMakeLists.txt
+1
View File
@@ -4,6 +4,7 @@ add_library(lmsscanner SHARED
impl/ScannerService.cpp
impl/ScannerStats.cpp
impl/ScanStepAssociateArtistImages.cpp
impl/ScanStepAssociateReleaseImages.cpp
impl/ScanStepCheckForDuplicatedFiles.cpp
impl/ScanStepCheckForRemovedFiles.cpp
impl/ScanStepCompact.cpp
src/libs/services/scanner/impl/ScanStepAssociateReleaseImages.cpp
+234
View File
@@ -0,0 +1,234 @@
/*
* 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 "ScanStepAssociateReleaseImages.hpp"
#include <array>
#include <cassert>
#include <deque>
#include <set>
#include "core/IConfig.hpp"
#include "core/ILogger.hpp"
#include "core/Path.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 "image/Exception.hpp"
#include "image/Image.hpp"
namespace lms::scanner
{
namespace
{
constexpr std::size_t readBatchSize{ 100 };
constexpr std::size_t writeBatchSize{ 10 };
struct ReleaseImageAssociation
{
db::ReleaseId releaseId;
db::ImageId imageId;
};
using ReleaseImageAssociationContainer = std::deque<ReleaseImageAssociation>;
struct SearchImageContext
{
db::Session& session;
db::ReleaseId lastRetrievedReleaseId;
const std::vector<std::string>& releaseFileNames;
};
db::Image::pointer findImageInDirectory(SearchImageContext& searchContext, const std::filesystem::path& directoryPath)
{
db::Image::pointer image;
const db::Directory::pointer directory{ db::Directory::find(searchContext.session, directoryPath) };
if (directory) // may not exist for releases that are split on different media libraries
{
for (std::string_view fileStem : searchContext.releaseFileNames)
{
db::Image::FindParameters params;
params.setDirectory(directory->getId());
params.setFileStem(fileStem);
db::Image::find(searchContext.session, params, [&](const db::Image::pointer foundImg) {
if (!image)
image = foundImg;
});
if (image)
break;
}
}
return image;
}
db::Image::pointer computeBestReleaseImage(SearchImageContext& searchContext, const db::Release::pointer& release)
{
db::Image::pointer image;
const auto mbid{ release->getMBID() };
if (mbid)
{
// Find anywhere, since it is suppoed to be unique!
db::Image::find(searchContext.session, db::Image::FindParameters{}.setFileStem(mbid->getAsString()), [&](const db::Image::pointer foundImg) {
if (!image)
image = foundImg;
});
}
if (!image)
{
std::set<std::filesystem::path> releasePaths;
db::Directory::FindParameters params;
params.setRelease(release->getId());
db::Directory::find(searchContext.session, params, [&](const db::Directory::pointer& directory) {
releasePaths.insert(directory->getAbsolutePath());
});
// Expect layout like this:
// Artist/Release/CD1/...
// /CD2/...
// /cover.jpg
if (releasePaths.size() > 1)
{
const std::filesystem::path releasePath{ core::pathUtils::getLongestCommonPath(std::cbegin(releasePaths), std::cend(releasePaths)) };
image = findImageInDirectory(searchContext, releasePath);
}
if (!image)
{
for (const std::filesystem::path& releasePath : releasePaths)
{
image = findImageInDirectory(searchContext, releasePath);
if (image)
break;
}
}
}
return image;
}
bool fetchNextReleaseImagesToUpdate(SearchImageContext& searchContext, ReleaseImageAssociationContainer& releaseImageAssociations)
{
const db::ReleaseId releaseId{ searchContext.lastRetrievedReleaseId };
{
auto transaction{ searchContext.session.createReadTransaction() };
db::Release::find(searchContext.session, searchContext.lastRetrievedReleaseId, readBatchSize, [&](const db::Release::pointer& release) {
db::Image::pointer image{ computeBestReleaseImage(searchContext, release) };
if (image != release->getImage())
{
LMS_LOG(DBUPDATER, DEBUG, "Updating release image for release '" << release->getName() << "', using '" << (image ? image->getAbsoluteFilePath().c_str() : "<none>") << "'");
releaseImageAssociations.push_back(ReleaseImageAssociation{ release->getId(), image ? image->getId() : db::ImageId{} });
}
});
}
return releaseId != searchContext.lastRetrievedReleaseId;
}
void updateReleaseImage(db::Session& session, const ReleaseImageAssociation& releaseImageAssociation)
{
db::Release::pointer release{ db::Release::find(session, releaseImageAssociation.releaseId) };
assert(release);
db::Image::pointer image;
if (releaseImageAssociation.imageId.isValid())
image = db::Image::find(session, releaseImageAssociation.imageId);
release.modify()->setImage(image);
}
void updateReleaseImages(db::Session& session, ReleaseImageAssociationContainer& imageAssociations)
{
if (imageAssociations.empty())
return;
auto transaction{ session.createWriteTransaction() };
for (std::size_t i{}; !imageAssociations.empty() && i < writeBatchSize; ++i)
{
updateReleaseImage(session, imageAssociations.front());
imageAssociations.pop_front();
}
}
std::vector<std::string> constructReleaseFileNames()
{
std::vector<std::string> res;
core::Service<core::IConfig>::get()->visitStrings("cover-preferred-file-names",
[&res](std::string_view fileName) {
res.emplace_back(fileName);
},
{ "cover", "front", "folder", "default" });
return res;
}
} // namespace
ScanStepAssociateReleaseImages::ScanStepAssociateReleaseImages(InitParams& initParams)
: ScanStepBase{ initParams }
, _releaseFileNames{ constructReleaseFileNames() }
{
}
void ScanStepAssociateReleaseImages::process(ScanContext& context)
{
if (_abortScan)
return;
if (context.stats.nbChanges() == 0)
return;
auto& session{ _db.getTLSSession() };
{
auto transaction{ session.createReadTransaction() };
context.currentStepStats.totalElems = db::Release::getCount(session);
}
SearchImageContext searchContext{
.session = session,
.lastRetrievedReleaseId = {},
.releaseFileNames = _releaseFileNames,
};
ReleaseImageAssociationContainer releaseImageAssociations;
while (fetchNextReleaseImagesToUpdate(searchContext, releaseImageAssociations))
{
if (_abortScan)
return;
updateReleaseImages(session, releaseImageAssociations);
context.currentStepStats.processedElems += readBatchSize;
_progressCallback(context.currentStepStats);
}
}
} // namespace lms::scanner
src/libs/services/scanner/impl/ScanStepAssociateReleaseImages.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 <string>
#include <vector>
#include "ScanStepBase.hpp"
namespace lms::scanner
{
class ScanStepAssociateReleaseImages : public ScanStepBase
{
public:
ScanStepAssociateReleaseImages(InitParams& initParams);
private:
ScanStep getStep() const override { return ScanStep::AssociateArtistImages; }
core::LiteralString getStepName() const override { return "Associate release images"; }
void process(ScanContext& context) override;
const std::vector<std::string> _releaseFileNames;
};
} // namespace lms::scanner
src/libs/services/scanner/impl/ScannerService.cpp
+2
View File
@@ -32,6 +32,7 @@
#include "image/Image.hpp"
#include "ScanStepAssociateArtistImages.hpp"
#include "ScanStepAssociateReleaseImages.hpp"
#include "ScanStepCheckForDuplicatedFiles.hpp"
#include "ScanStepCheckForRemovedFiles.hpp"
#include "ScanStepCompact.hpp"
@@ -347,6 +348,7 @@ namespace lms::scanner
_scanSteps.push_back(std::make_unique<ScanStepCheckForRemovedFiles>(params));
_scanSteps.push_back(std::make_unique<ScanStepUpdateLibraryFields>(params));
_scanSteps.push_back(std::make_unique<ScanStepAssociateArtistImages>(params));
_scanSteps.push_back(std::make_unique<ScanStepAssociateReleaseImages>(params));
_scanSteps.push_back(std::make_unique<ScanStepRemoveOrphanedDbEntries>(params));
_scanSteps.push_back(std::make_unique<ScanStepCompact>(params));
_scanSteps.push_back(std::make_unique<ScanStepOptimize>(params));
src/libs/services/scanner/include/services/scanner/ScannerStats.hpp
+1
View File
@@ -62,6 +62,7 @@ namespace lms::scanner
enum class ScanStep
{
AssociateArtistImages,
AssociateReleaseImages,
CheckForDuplicatedFiles,
CheckForRemovedFiles,
ComputeClusterStats,
src/libs/subsonic/impl/responses/Album.cpp
+17 -1
View File
@@ -25,7 +25,9 @@
#include "database/Artist.hpp"
#include "database/Cluster.hpp"
#include "database/Directory.hpp"
#include "database/Image.hpp"
#include "database/Release.hpp"
#include "database/Track.hpp"
#include "database/User.hpp"
#include "services/feedback/IFeedbackService.hpp"
#include "services/scrobbling/IScrobblingService.hpp"
@@ -82,7 +84,21 @@ namespace lms::api::subsonic
}
albumNode.setAttribute("created", core::stringUtils::toISO8601String(release->getLastWritten()));
albumNode.setAttribute("coverArt", idToString(release->getId()));
if (release->getImage())
{
albumNode.setAttribute("coverArt", idToString(release->getId()));
}
else
{
db::Track::FindParameters params;
params.setRelease(release->getId());
params.setHasEmbeddedImage(true);
params.setRange(db::Range{ 0, 1 });
db::Track::find(context.dbSession, params, [&](const db::Track::pointer& track) {
albumNode.setAttribute("coverArt", idToString(track->getId()));
});
}
if (const auto year{ release->getYear() })
albumNode.setAttribute("year", *year);
src/libs/subsonic/impl/responses/Artist.cpp
+1 -1
View File
@@ -94,7 +94,7 @@ namespace lms::api::subsonic
artistNode.setAttribute("id", idToString(artist->getId()));
artistNode.setAttribute("name", artist->getName());
if (const db::Image::pointer artistImage{ artist->getImage() })
if (artist->getImage())
artistNode.setAttribute("coverArt", idToString(artist->getId()));
const std::size_t count{ Release::getCount(context.dbSession, Release::FindParameters{}.setArtist(artist->getId())) };
src/libs/subsonic/impl/responses/Playlist.cpp
+10 -3
View File
@@ -31,7 +31,7 @@ namespace lms::api::subsonic
static const std::string_view reportedDummyDate{ "2000-01-01T00:00:00" };
Response::Node createPlaylistNode(const TrackList::pointer& tracklist, Session&)
Response::Node createPlaylistNode(const TrackList::pointer& tracklist, Session& session)
{
Response::Node playlistNode;
@@ -43,8 +43,15 @@ namespace lms::api::subsonic
playlistNode.setAttribute("created", reportedDummyDate);
playlistNode.setAttribute("owner", tracklist->getUser()->getLoginName());
if (const auto entry{ tracklist->getEntry(0) })
playlistNode.setAttribute("coverArt", idToString(entry->getTrack()->getId()));
db::Track::FindParameters params;
params.setTrackList(tracklist->getId());
params.setHasEmbeddedImage(true);
params.setRange(db::Range{ 0, 1 });
params.setSortMethod(TrackSortMethod::TrackList);
db::Track::find(session, params, [&](const db::Track::pointer& track) {
playlistNode.setAttribute("coverArt", idToString(track->getId()));
});
return playlistNode;
}
src/libs/subsonic/impl/responses/Song.cpp
+2 -1
View File
@@ -28,6 +28,7 @@
#include "database/Artist.hpp"
#include "database/Cluster.hpp"
#include "database/Directory.hpp"
#include "database/Image.hpp"
#include "database/Release.hpp"
#include "database/Track.hpp"
#include "database/TrackArtistLink.hpp"
@@ -110,7 +111,7 @@ namespace lms::api::subsonic
if (track->hasCover())
trackResponse.setAttribute("coverArt", idToString(track->getId()));
else if (release)
else if (release && release->getImage())
trackResponse.setAttribute("coverArt", idToString(release->getId()));
const std::vector<Artist::pointer>& artists{ track->getArtists({ TrackArtistLinkType::Artist }) };
src/lms/ui/Utils.cpp
+51 -2
View File
@@ -27,6 +27,7 @@
#include "database/Artist.hpp"
#include "database/Cluster.hpp"
#include "database/Image.hpp"
#include "database/Release.hpp"
#include "database/ScanSettings.hpp"
#include "database/Session.hpp"
@@ -65,7 +66,36 @@ namespace lms::ui::utils
std::unique_ptr<Wt::WImage> createCover(db::ReleaseId releaseId, CoverResource::Size size)
{
auto cover{ std::make_unique<Wt::WImage>() };
cover->setImageLink(LmsApp->getCoverResource()->getReleaseUrl(releaseId, size));
std::string internalUrl;
{
auto transaction{ LmsApp->getDbSession().createReadTransaction() };
const db::Release::pointer release{ db::Release::find(LmsApp->getDbSession(), releaseId) };
if (release)
{
if (release->getImage())
{
internalUrl = LmsApp->getCoverResource()->getReleaseUrl(release->getId(), size);
}
else
{
db::Track::FindParameters params;
params.setRelease(releaseId);
params.setHasEmbeddedImage(true);
params.setRange(db::Range{ 0, 1 });
db::Track::find(LmsApp->getDbSession(), params, [&](const db::Track::pointer& track) {
internalUrl = LmsApp->getCoverResource()->getTrackUrl(track->getId(), size);
});
}
}
}
if (internalUrl.empty())
internalUrl = LmsApp->getCoverResource()->getDefaultUrl(size);
cover->setImageLink(internalUrl);
cover->setStyleClass("Lms-cover img-fluid"); // HACK
cover->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
return cover;
@@ -74,9 +104,28 @@ namespace lms::ui::utils
std::unique_ptr<Wt::WImage> createCover(db::TrackId trackId, CoverResource::Size size)
{
auto cover{ std::make_unique<Wt::WImage>() };
cover->setImageLink(LmsApp->getCoverResource()->getTrackUrl(trackId, size));
std::string internalUrl;
{
auto transaction{ LmsApp->getDbSession().createReadTransaction() };
const db::Track::pointer track{ db::Track::find(LmsApp->getDbSession(), trackId) };
if (track)
{
if (track->hasCover())
internalUrl = LmsApp->getCoverResource()->getTrackUrl(trackId, size);
else if (const db::Release::pointer release{ track->getRelease() }; release && release->getImage())
internalUrl = LmsApp->getCoverResource()->getReleaseUrl(release->getId(), size);
}
}
if (internalUrl.empty())
internalUrl = LmsApp->getCoverResource()->getDefaultUrl(size);
cover->setImageLink(internalUrl);
cover->setStyleClass("Lms-cover img-fluid"); // HACK
cover->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
return cover;
}
src/lms/ui/admin/ScannerController.cpp
+5
View File
@@ -274,6 +274,11 @@ namespace lms::ui
.arg(stepStats.progress()));
break;
case ScanStep::AssociateReleaseImages:
_stepStatus->setText(Wt::WString::tr("Lms.Admin.ScannerController.step-associating-release-images")
.arg(stepStats.progress()));
break;
case ScanStep::CheckForDuplicatedFiles:
_stepStatus->setText(Wt::WString::tr("Lms.Admin.ScannerController.step-checking-for-duplicate-files")
.arg(stepStats.processedElems));
src/lms/ui/resource/CoverResource.cpp
+9 -8
View File
@@ -59,6 +59,11 @@ namespace lms::ui
return url() + "&trackid=" + trackId.toString() + "&size=" + std::to_string(static_cast<std::size_t>(size));
}
std::string CoverResource::getDefaultUrl(Size size) const
{
return url() + "&size=" + std::to_string(static_cast<std::size_t>(size));
}
void CoverResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
{
LMS_SCOPED_TRACE_OVERVIEW("UI", "HandleCoverRequest");
@@ -96,8 +101,6 @@ namespace lms::ui
}
cover = core::Service<cover::ICoverService>::get()->getFromTrack(*trackId, *size);
if (!cover)
cover = core::Service<cover::ICoverService>::get()->getDefaultSvgCover();
}
else if (releaseIdStr)
{
@@ -108,14 +111,12 @@ namespace lms::ui
return;
cover = core::Service<cover::ICoverService>::get()->getFromRelease(*releaseId, *size);
if (!cover)
cover = core::Service<cover::ICoverService>::get()->getDefaultSvgCover();
}
else
{
LOG(DEBUG, "No track or release provided");
return;
}
LOG(DEBUG, "Requested default cover");
if (!cover)
cover = core::Service<cover::ICoverService>::get()->getDefaultSvgCover();
response.setMimeType(std::string{ cover->getMimeType() });
src/lms/ui/resource/CoverResource.hpp
+1
View File
@@ -42,6 +42,7 @@ namespace lms::ui
std::string getReleaseUrl(db::ReleaseId releaseId, Size size) const;
std::string getTrackUrl(db::TrackId trackId, Size size) const;
std::string getDefaultUrl(Size size) const;
private:
void handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response) override;