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

Now using new artwork table everywhere in app and subsonic API to refer to artworks

Browse Source
This commit is contained in:
emeric
2025-06-22 16:49:54 +02:00
parent 93b446e124
commit c251c2a924
34 changed files with 475 additions and 478 deletions
Download Patch File Download Diff File Expand all files Collapse all files
approot/artist.xml
+1 -1
View File
@@ -5,7 +5,7 @@
<message id="Lms.Explore.Artist.template">
<div class="row mb-3 gy-3">
<div class="col-lg-3 col-md-4">
${artwork class="Lms-cursor-pointer rounded d-block mx-auto"}
${artwork class="rounded d-block mx-auto"}
</div>
<div class="col">
<h2>${name}</h2>
approot/release.xml
+4 -4
View File
@@ -9,7 +9,7 @@
<message id="Lms.Explore.Release.template">
<div class="row mb-3 gy-3">
<div class="col-lg-3 col-md-4">
${cover class="Lms-cursor-pointer rounded d-block mx-auto"}
${artwork class="rounded d-block mx-auto"}
</div>
<div class="col">
<h2>${name}${<if-has-release-comment>}<span class="ms-1 text-muted">[${comment}]</span>${</if-has-release-comment>}</h2>
@@ -55,9 +55,9 @@
<message id="Lms.Explore.Release.template.entry-disc">
<h4 class="d-flex align-items-center">
${<if-has-image>}
<div class="p-1">${image class="Lms-cursor-pointer"}</div>
${</if-has-image>}
${<if-has-artwork>}
<div class="p-1">${artwork class="Lms-cursor-pointer"}</div>
${</if-has-artwork>}
<div class="p-2 flex-fill">${disc-title}</div>
<div class="p-2 d-flex">
${play-btn class="d-none d-sm-block btn btn-sm btn-outline-secondary border-0"}
src/libs/database/impl/Artwork.cpp
+13
View File
@@ -19,6 +19,8 @@
#include "database/Artwork.hpp"
#include <Wt/Dbo/WtSqlTraits.h>
#include "database/Image.hpp"
#include "database/Session.hpp"
#include "database/TrackEmbeddedImage.hpp"
@@ -74,4 +76,15 @@ namespace lms::db
return utils::fetchQuerySingleResult(session.getDboSession()->query<Wt::Dbo::ptr<Artwork>>("SELECT a FROM artwork a").where("a.image_id = ?").bind(id));
}
Wt::WDateTime Artwork::getLastWrittenTime() const
{
auto query{ session()->query<Wt::WDateTime>("SELECT MAX(COALESCE(image.file_last_write, track.file_last_write)) AS last_written_datetime FROM artwork") };
query.leftJoin("image ON artwork.image_id = image.id");
query.leftJoin("track_embedded_image ON artwork.track_embedded_image_id = track_embedded_image.id");
query.leftJoin("track_embedded_image_link ON track_embedded_image.id = track_embedded_image_link.track_embedded_image_id");
query.leftJoin("track ON track.id = track_embedded_image_link.track_id");
query.where("artwork.id = ?").bind(getId());
return utils::fetchQuerySingleResult(query);
}
} // namespace lms::db
src/libs/database/impl/Track.cpp
+10
View File
@@ -374,11 +374,21 @@ namespace lms::db
return _preferredArtwork;
}
ArtworkId Track::getPreferredArtworkId() const
{
return _preferredArtwork.id();
}
ObjectPtr<Artwork> Track::getPreferredMediaArtwork() const
{
return _preferredMediaArtwork;
}
ArtworkId Track::getPreferredMediaArtworkId() const
{
return _preferredMediaArtwork.id();
}
RangeResults<TrackId> Track::findIds(Session& session, const FindParameters& parameters)
{
session.checkReadTransaction();
src/libs/database/include/database/Artwork.hpp
+2
View File
@@ -20,6 +20,7 @@
#pragma once
#include <Wt/Dbo/Dbo.h>
#include <Wt/WDateTime.h>
#include "database/ArtworkId.hpp"
#include "database/ImageId.hpp"
@@ -46,6 +47,7 @@ namespace lms::db
// getters
TrackEmbeddedImageId getTrackEmbeddedImageId() const { return _trackEmbeddedImage.id(); }
ImageId getImageId() const { return _image.id(); }
Wt::WDateTime getLastWrittenTime() const;
template<class Action>
void persist(Action& a)
src/libs/database/include/database/Track.hpp
+2
View File
@@ -306,7 +306,9 @@ namespace lms::db
ObjectPtr<MediaLibrary> getMediaLibrary() const;
ObjectPtr<Directory> getDirectory() const;
ObjectPtr<Artwork> getPreferredArtwork() const;
ArtworkId getPreferredArtworkId() const;
ObjectPtr<Artwork> getPreferredMediaArtwork() const;
ArtworkId getPreferredMediaArtworkId() const;
std::vector<std::vector<ObjectPtr<Cluster>>> getClusterGroups(const std::vector<ClusterTypeId>& clusterTypes, std::size_t size) const;
src/libs/database/test/Artwork.cpp
+83
View File
@@ -0,0 +1,83 @@
/*
* Copyright (C) 2025of 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 "Common.hpp"
#include "database/Artwork.hpp"
#include "database/Image.hpp"
#include "database/TrackEmbeddedImage.hpp"
#include "database/TrackEmbeddedImageLink.hpp"
namespace lms::db::tests
{
using ScopedArtwork = ScopedEntity<db::Artwork>;
using ScopedImage = ScopedEntity<db::Image>;
using ScopedTrackEmbeddedImage = ScopedEntity<db::TrackEmbeddedImage>;
TEST_F(DatabaseFixture, Artwork_image)
{
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Artwork::getCount(session), 0);
}
ScopedImage image{ session, "/MyImage" };
ScopedArtwork artwork{ session, image.lockAndGet() };
const Wt::WDateTime dateTime{ Wt::WDate{ 2025, 1, 1 } };
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Artwork::getCount(session), 1);
}
{
auto transaction{ session.createWriteTransaction() };
image.get().modify()->setLastWriteTime(dateTime);
}
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(artwork.get()->getLastWrittenTime(), dateTime);
}
}
TEST_F(DatabaseFixture, Artwork_trackEmbeddedImage)
{
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(Artwork::getCount(session), 0);
}
ScopedTrackEmbeddedImage image{ session };
ScopedTrack track{ session };
ScopedArtwork artwork{ session, image.lockAndGet() };
const Wt::WDateTime dateTime{ Wt::WDate{ 2025, 1, 1 } };
{
auto transaction{ session.createWriteTransaction() };
session.create<db::TrackEmbeddedImageLink>(track.get(), image.get());
track.get().modify()->setLastWriteTime(dateTime);
}
{
auto transaction{ session.createReadTransaction() };
EXPECT_EQ(artwork.get()->getLastWrittenTime(), dateTime);
}
}
} // namespace lms::db::tests
src/libs/database/test/CMakeLists.txt
+1
View File
@@ -2,6 +2,7 @@
add_executable(test-database
Artist.cpp
ArtistInfo.cpp
Artwork.cpp
AuthToken.cpp
Cluster.cpp
Common.cpp
src/libs/services/artwork/impl/ArtworkService.cpp
+58 -103
View File
@@ -26,12 +26,13 @@
#include "database/Artwork.hpp"
#include "database/Db.hpp"
#include "database/Image.hpp"
#include "database/ImageId.hpp"
#include "database/Release.hpp"
#include "database/Session.hpp"
#include "database/Track.hpp"
#include "database/TrackEmbeddedImage.hpp"
#include "database/TrackEmbeddedImageLink.hpp"
#include "database/Types.hpp"
#include "database/TrackList.hpp"
#include "image/Exception.hpp"
#include "image/IEncodedImage.hpp"
#include "image/Image.hpp"
@@ -87,12 +88,12 @@ namespace lms::artwork
return image;
}
std::shared_ptr<image::IEncodedImage> ArtworkService::getDefaultReleaseCover()
std::shared_ptr<image::IEncodedImage> ArtworkService::getDefaultReleaseArtwork()
{
return _defaultReleaseCover;
}
std::shared_ptr<image::IEncodedImage> ArtworkService::getDefaultArtistImage()
std::shared_ptr<image::IEncodedImage> ArtworkService::getDefaultArtistArtwork()
{
return _defaultArtistImage;
}
@@ -136,150 +137,104 @@ namespace lms::artwork
return image;
}
ArtworkService::ImageFindResult ArtworkService::findArtistImage(db::ArtistId artistId)
db::ArtworkId ArtworkService::findTrackListImage(db::TrackListId trackListId)
{
db::ArtworkId artworkId;
// Iterate over all tracks and stop when we find an artwork
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
ImageFindResult res;
db::TrackList::pointer trackList{ db::TrackList::find(session, trackListId) };
if (!trackList)
return artworkId;
const db::Artist::pointer artist{ db::Artist::find(session, artistId) };
if (!artist)
return res;
const auto entries{ trackList->getEntries(db::Range{ 0, 10 }) };
for (const auto& entry : entries.results)
{
const auto track{ entry->getTrack() };
if (track->getPreferredMediaArtworkId().isValid())
{
artworkId = track->getPreferredMediaArtworkId();
break; // stop iteration
}
const db::Artwork::pointer artwork{ artist->getPreferredArtwork() };
if (artwork && artwork->getImageId().isValid())
res = artwork->getImageId();
else if (artwork && artwork->getTrackEmbeddedImageId().isValid())
res = artwork->getTrackEmbeddedImageId();
if (track->getPreferredArtworkId().isValid())
{
artworkId = track->getPreferredArtworkId();
break; // stop iteration
}
}
return res;
return artworkId;
}
ArtworkService::ImageFindResult ArtworkService::findTrackImage(db::TrackId trackId)
std::shared_ptr<image::IEncodedImage> ArtworkService::getImage(db::ArtworkId artworkId, std::optional<image::ImageSize> width)
{
ImageFindResult res;
const ImageCache::EntryDesc cacheEntryDesc{ artworkId, width };
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
std::shared_ptr<image::IEncodedImage> image{ _cache.getImage(cacheEntryDesc) };
if (image)
return image;
const db::Track::pointer track{ db::Track::find(session, trackId) };
if (!track)
return res;
db::TrackEmbeddedImageId trackEmbeddedImageId;
db::ImageId imageId;
const db::Artwork::pointer artwork{ track->getPreferredArtwork() };
if (artwork && artwork->getImageId().isValid())
res = artwork->getImageId();
else if (artwork && artwork->getTrackEmbeddedImageId().isValid())
res = artwork->getTrackEmbeddedImageId();
{
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
return res;
}
db::Artwork::pointer artwork{ db::Artwork::find(session, artworkId) };
if (artwork)
{
trackEmbeddedImageId = artwork->getTrackEmbeddedImageId();
imageId = artwork->getImageId();
}
}
ArtworkService::ImageFindResult ArtworkService::findTrackMediaImage(db::TrackId trackId)
{
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
ImageFindResult res;
if (trackEmbeddedImageId.isValid())
image = getTrackEmbeddedImage(trackEmbeddedImageId, width);
else if (imageId.isValid())
image = getImage(imageId, width);
const db::Track::pointer track{ db::Track::find(session, trackId) };
if (!track)
return res;
if (image)
_cache.addImage(cacheEntryDesc, image);
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;
}
ArtworkService::ImageFindResult ArtworkService::findReleaseImage(db::ReleaseId releaseId)
{
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
ImageFindResult res;
const db::Release::pointer release{ db::Release::find(session, releaseId) };
if (!release)
return res;
const db::Artwork::pointer artwork{ release->getPreferredArtwork() };
if (artwork && artwork->getImageId().isValid())
res = artwork->getImageId();
else if (artwork && artwork->getTrackEmbeddedImageId().isValid())
res = artwork->getTrackEmbeddedImageId();
return res;
}
ArtworkService::ImageFindResult ArtworkService::findTrackListImage(db::TrackListId trackListId)
{
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
ImageFindResult res;
db::TrackEmbeddedImage::FindParameters params;
params.setTrackList(trackListId);
params.setSortMethod(db::TrackEmbeddedImageSortMethod::TrackListIndexAscThenSizeDesc);
params.setRange(db::Range{ .offset = 0, .size = 1 });
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) {
res = image->getId();
});
// TODO fallback on release image if not found
return res;
return image;
}
std::shared_ptr<image::IEncodedImage> ArtworkService::getImage(db::ImageId imageId, std::optional<image::ImageSize> width)
{
const ImageCache::EntryDesc cacheEntryDesc{ imageId, width };
std::shared_ptr<image::IEncodedImage> cover{ _cache.getImage(cacheEntryDesc) };
if (cover)
return cover;
std::filesystem::path imageFile;
{
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
const db::Image::pointer image{ db::Image::find(session, imageId) };
if (image)
imageFile = image->getAbsoluteFilePath();
if (!image)
return nullptr;
imageFile = image->getAbsoluteFilePath();
}
cover = getFromImageFile(imageFile, width);
if (cover)
_cache.addImage(cacheEntryDesc, cover);
return cover;
return getFromImageFile(imageFile, width);
}
std::shared_ptr<image::IEncodedImage> ArtworkService::getTrackEmbeddedImage(db::TrackEmbeddedImageId trackEmbeddedImageId, std::optional<image::ImageSize> width)
{
const ImageCache::EntryDesc cacheEntryDesc{ trackEmbeddedImageId, width };
std::shared_ptr<image::IEncodedImage> image{ _cache.getImage(cacheEntryDesc) };
if (image)
return image;
std::shared_ptr<image::IEncodedImage> image;
{
db::Session& session{ _db.getTLSSession() };
auto transaction{ session.createReadTransaction() };
// TODO: could be put outside transaction
db::TrackEmbeddedImageLink::find(session, trackEmbeddedImageId, [&](const db::TrackEmbeddedImageLink::pointer& link) {
if (!image)
image = getTrackImage(link->getTrack()->getAbsoluteFilePath(), link->getIndex(), width);
});
}
if (image)
_cache.addImage(cacheEntryDesc, image);
return image;
}
src/libs/services/artwork/impl/ArtworkService.hpp
+9 -9
View File
@@ -22,6 +22,8 @@
#include <filesystem>
#include <vector>
#include "database/ImageId.hpp"
#include "database/TrackEmbeddedImageId.hpp"
#include "services/artwork/IArtworkService.hpp"
#include "ImageCache.hpp"
@@ -47,21 +49,19 @@ namespace lms::artwork
ArtworkService& operator=(const ArtworkService&) = delete;
private:
ImageFindResult findArtistImage(db::ArtistId artistId) override;
ImageFindResult findTrackImage(db::TrackId trackId) override;
ImageFindResult findTrackMediaImage(db::TrackId trackId) override;
ImageFindResult findReleaseImage(db::ReleaseId releaseId) override;
ImageFindResult findTrackListImage(db::TrackListId trackListId) override;
db::ArtworkId findTrackListImage(db::TrackListId trackListId) override;
std::shared_ptr<image::IEncodedImage> getImage(db::ImageId imageId, std::optional<image::ImageSize> width) override;
std::shared_ptr<image::IEncodedImage> getTrackEmbeddedImage(db::TrackEmbeddedImageId trackEmbeddedImageId, std::optional<image::ImageSize> width) override;
std::shared_ptr<image::IEncodedImage> getImage(db::ArtworkId artworkId, std::optional<image::ImageSize> width) override;
std::shared_ptr<image::IEncodedImage> getDefaultReleaseCover() override;
std::shared_ptr<image::IEncodedImage> getDefaultArtistImage() override;
std::shared_ptr<image::IEncodedImage> getDefaultReleaseArtwork() override;
std::shared_ptr<image::IEncodedImage> getDefaultArtistArtwork() override;
void flushCache() override;
void setJpegQuality(unsigned quality) override;
std::shared_ptr<image::IEncodedImage> getImage(db::ImageId imageId, std::optional<image::ImageSize> width);
std::shared_ptr<image::IEncodedImage> getTrackEmbeddedImage(db::TrackEmbeddedImageId trackEmbeddedImageId, std::optional<image::ImageSize> width);
std::unique_ptr<image::IEncodedImage> getFromImageFile(const std::filesystem::path& p, std::optional<image::ImageSize> width) const;
std::unique_ptr<image::IEncodedImage> getTrackImage(const std::filesystem::path& path, std::size_t index, std::optional<image::ImageSize> width) const;
src/libs/services/artwork/impl/ImageCache.hpp
+5 -8
View File
@@ -25,10 +25,8 @@
#include <optional>
#include <shared_mutex>
#include <unordered_map>
#include <variant>
#include "database/ImageId.hpp"
#include "database/TrackEmbeddedImageId.hpp"
#include "database/ArtworkId.hpp"
#include "image/IEncodedImage.hpp"
namespace lms::artwork
@@ -40,8 +38,7 @@ namespace lms::artwork
struct EntryDesc
{
using VariantType = std::variant<db::TrackEmbeddedImageId, db::ImageId>;
VariantType id;
db::ArtworkId id;
std::optional<std::size_t> size;
bool operator==(const EntryDesc& other) const = default;
@@ -63,13 +60,13 @@ namespace lms::artwork
std::size_t operator()(const EntryDesc& entry) const
{
assert(entry.size); // should not cache unresized images
return std::hash<EntryDesc::VariantType>{}(entry.id) ^ std::hash<std::size_t>{}(*entry.size);
return std::hash<db::ArtworkId>{}(entry.id) ^ std::hash<std::size_t>{}(*entry.size);
}
};
std::unordered_map<EntryDesc, std::shared_ptr<image::IEncodedImage>, EntryHasher> _cache;
std::size_t _cacheSize{};
mutable std::atomic<std::size_t> _cacheMisses{};
mutable std::atomic<std::size_t> _cacheHits{};
mutable std::atomic<std::size_t> _cacheMisses;
mutable std::atomic<std::size_t> _cacheHits;
};
} // namespace lms::artwork
src/libs/services/artwork/include/services/artwork/IArtworkService.hpp
+7 -24
View File
@@ -22,13 +22,8 @@
#include <filesystem>
#include <memory>
#include <optional>
#include <variant>
#include "database/ArtistId.hpp"
#include "database/ImageId.hpp"
#include "database/ReleaseId.hpp"
#include "database/TrackEmbeddedImageId.hpp"
#include "database/TrackId.hpp"
#include "database/ArtworkId.hpp"
#include "database/TrackListId.hpp"
#include "image/IEncodedImage.hpp"
@@ -44,27 +39,15 @@ namespace lms::artwork
public:
virtual ~IArtworkService() = default;
// Helpers to find artworks
using ImageFindResult = std::variant<std::monostate, db::ImageId, db::TrackEmbeddedImageId>;
virtual ImageFindResult findArtistImage(db::ArtistId artistId) = 0;
// Helpers to get preferred artworks
virtual db::ArtworkId findTrackListImage(db::TrackListId trackListId) = 0;
// Will get Disc/Media artwork if available, otherwise, will fallback on release artwork
virtual ImageFindResult findTrackImage(db::TrackId trackId) = 0;
// Will get Disc/Media artwork if available, no fallback
virtual ImageFindResult findTrackMediaImage(db::TrackId trackId) = 0;
// Will get Release if available, otherwise, will fallback on embedded artworks
virtual ImageFindResult findReleaseImage(db::ReleaseId releaseId) = 0;
virtual ImageFindResult findTrackListImage(db::TrackListId trackListId) = 0;
// Image retrieval
virtual std::shared_ptr<image::IEncodedImage> getImage(db::ImageId imageId, std::optional<image::ImageSize> width) = 0;
virtual std::shared_ptr<image::IEncodedImage> getTrackEmbeddedImage(db::TrackEmbeddedImageId trackEmbeddedImageId, std::optional<image::ImageSize> width) = 0;
// Image retrieval, no width means original size
virtual std::shared_ptr<image::IEncodedImage> getImage(db::ArtworkId artworkId, std::optional<image::ImageSize> width) = 0;
// Svg images don't have image "size"
virtual std::shared_ptr<image::IEncodedImage> getDefaultReleaseCover() = 0;
virtual std::shared_ptr<image::IEncodedImage> getDefaultArtistImage() = 0;
virtual std::shared_ptr<image::IEncodedImage> getDefaultReleaseArtwork() = 0;
virtual std::shared_ptr<image::IEncodedImage> getDefaultArtistArtwork() = 0;
virtual void flushCache() = 0;
src/libs/services/scanner/impl/steps/ScanStepAssociateReleaseImages.cpp
+18 -20
View File
@@ -60,14 +60,14 @@ namespace lms::scanner
return false;
}
struct ReleaseImageAssociation
struct ReleaseArtworkAssociation
{
db::ReleaseId releaseId;
db::Release::pointer release;
ReleaseArtwork preferredArtwork;
};
using ReleaseImageAssociationContainer = std::deque<ReleaseImageAssociation>;
using ReleaseArtworkAssociationContainer = std::deque<ReleaseArtworkAssociation>;
struct SearchReleaseImageContext
struct SearchReleaseArtworkContext
{
db::Session& session;
db::ReleaseId lastRetrievedReleaseId;
@@ -75,7 +75,7 @@ namespace lms::scanner
const std::vector<std::string>& releaseImageFileNames;
};
db::Image::pointer findImageInDirectory(SearchReleaseImageContext& searchContext, const std::filesystem::path& directoryPath)
db::Image::pointer findImageInDirectory(SearchReleaseArtworkContext& searchContext, const std::filesystem::path& directoryPath)
{
db::Image::pointer image;
@@ -101,7 +101,7 @@ namespace lms::scanner
return image;
}
db::Image::pointer computePreferredReleaseImage(SearchReleaseImageContext& searchContext, const db::Release::pointer& release)
db::Image::pointer computePreferredReleaseImage(SearchReleaseArtworkContext& searchContext, const db::Release::pointer& release)
{
db::Image::pointer image;
@@ -149,7 +149,7 @@ namespace lms::scanner
return image;
}
ReleaseArtwork computePreferredReleaseArtwork(SearchReleaseImageContext& searchContext, const db::Release::pointer& release)
ReleaseArtwork computePreferredReleaseArtwork(SearchReleaseArtworkContext& searchContext, const db::Release::pointer& release)
{
const db::Image::pointer image{ computePreferredReleaseImage(searchContext, release) };
if (image)
@@ -187,7 +187,7 @@ namespace lms::scanner
return ReleaseArtwork{};
}
bool fetchNextReleaseArtworksToUpdate(SearchReleaseImageContext& searchContext, ReleaseImageAssociationContainer& releaseImageAssociations)
bool fetchNextReleaseArtworksToUpdate(SearchReleaseArtworkContext& searchContext, ReleaseArtworkAssociationContainer& ReleaseArtworkAssociations)
{
const db::ReleaseId releaseId{ searchContext.lastRetrievedReleaseId };
@@ -201,7 +201,7 @@ namespace lms::scanner
const db::Artwork::pointer currentPreferredArtwork{ release->getPreferredArtwork() };
if (!isSameArtwork(preferredArtwork, currentPreferredArtwork))
releaseImageAssociations.push_back(ReleaseImageAssociation{ release->getId(), preferredArtwork });
ReleaseArtworkAssociations.push_back(ReleaseArtworkAssociation{ release, preferredArtwork });
searchContext.processedReleaseCount++;
});
}
@@ -209,16 +209,14 @@ namespace lms::scanner
return releaseId != searchContext.lastRetrievedReleaseId;
}
void updateReleaseArtwork(db::Session& session, const ReleaseImageAssociation& releaseImageAssociation)
void updateReleaseArtwork(db::Session& session, const ReleaseArtworkAssociation& ReleaseArtworkAssociation)
{
db::Release::pointer release{ db::Release::find(session, releaseImageAssociation.releaseId) };
assert(release);
db::Release::pointer release{ ReleaseArtworkAssociation.release };
db::Artwork::pointer artwork;
if (const db::TrackEmbeddedImageId * trackEmbeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&releaseImageAssociation.preferredArtwork) })
if (const db::TrackEmbeddedImageId * trackEmbeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&ReleaseArtworkAssociation.preferredArtwork) })
artwork = utils::getOrCreateArtworkFromTrackEmbeddedImage(session, *trackEmbeddedImageId);
else if (const db::ImageId * imageId{ std::get_if<db::ImageId>(&releaseImageAssociation.preferredArtwork) })
else if (const db::ImageId * imageId{ std::get_if<db::ImageId>(&ReleaseArtworkAssociation.preferredArtwork) })
artwork = utils::getOrCreateArtworkFromImage(session, *imageId);
release.modify()->setPreferredArtwork(artwork);
@@ -229,7 +227,7 @@ namespace lms::scanner
LMS_LOG(DBUPDATER, DEBUG, "Removed preferred artwork from release '" << release->getName() << "'");
}
void updateReleaseImages(db::Session& session, ReleaseImageAssociationContainer& imageAssociations)
void updateReleaseArtworks(db::Session& session, ReleaseArtworkAssociationContainer& imageAssociations)
{
constexpr std::size_t writeBatchSize{ 50 };
@@ -280,19 +278,19 @@ namespace lms::scanner
context.currentStepStats.totalElems = db::Release::getCount(session);
}
SearchReleaseImageContext searchContext{
SearchReleaseArtworkContext searchContext{
.session = session,
.lastRetrievedReleaseId = {},
.releaseImageFileNames = _releaseImageFileNames,
};
ReleaseImageAssociationContainer releaseImageAssociations;
while (fetchNextReleaseArtworksToUpdate(searchContext, releaseImageAssociations))
ReleaseArtworkAssociationContainer ReleaseArtworkAssociations;
while (fetchNextReleaseArtworksToUpdate(searchContext, ReleaseArtworkAssociations))
{
if (_abortScan)
return;
updateReleaseImages(session, releaseImageAssociations);
updateReleaseArtworks(session, ReleaseArtworkAssociations);
context.currentStepStats.processedElems = searchContext.processedReleaseCount;
_progressCallback(context.currentStepStats);
}
src/libs/services/scanner/impl/steps/ScanStepAssociateTrackImages.cpp
+18 -18
View File
@@ -62,22 +62,22 @@ namespace lms::scanner
return !std::holds_alternative<std::monostate>(res);
}
struct TrackImageAssociation
struct TrackArtworksAssociation
{
db::Track::pointer track;
TrackArtwork preferredArtwork;
TrackArtwork preferredMediaArtwork;
};
using TrackImageAssociationContainer = std::deque<TrackImageAssociation>;
using TrackArtworksAssociationContainer = std::deque<TrackArtworksAssociation>;
struct SearchTrackImageContext
struct SearchTrackArtworkContext
{
db::Session& session;
db::TrackId lastRetrievedTrackId;
std::size_t processedTrackCount{};
};
TrackArtwork computePreferredTrackArtwork(SearchTrackImageContext& searchContext, const db::Track::pointer& track)
TrackArtwork computePreferredTrackArtwork(SearchTrackArtworkContext& searchContext, const db::Track::pointer& track)
{
// Try to get a media image
TrackArtwork res;
@@ -135,7 +135,7 @@ namespace lms::scanner
return res;
}
TrackArtwork computePreferredTrackMediaArtwork(SearchTrackImageContext& searchContext, const db::Track::pointer& track)
TrackArtwork computePreferredTrackMediaArtwork(SearchTrackArtworkContext& searchContext, const db::Track::pointer& track)
{
TrackArtwork res;
{
@@ -165,7 +165,7 @@ namespace lms::scanner
return res;
}
bool fetchNextTrackArtworksToUpdate(SearchTrackImageContext& searchContext, TrackImageAssociationContainer& trackImageAssociations)
bool fetchNextTrackArtworksToUpdate(SearchTrackArtworkContext& searchContext, TrackArtworksAssociationContainer& TrackArtworksAssociations)
{
const db::TrackId trackId{ searchContext.lastRetrievedTrackId };
@@ -184,7 +184,7 @@ namespace lms::scanner
if (!isSameArtwork(preferredArtwork, currentPreferredArtwork)
|| !isSameArtwork(preferredMediaArtwork, currentPreferredMediaArtwork))
{
trackImageAssociations.push_back(TrackImageAssociation{ track, preferredArtwork, preferredMediaArtwork });
TrackArtworksAssociations.push_back(TrackArtworksAssociation{ track, preferredArtwork, preferredMediaArtwork });
}
searchContext.processedTrackCount++;
@@ -226,24 +226,24 @@ namespace lms::scanner
LMS_LOG(DBUPDATER, DEBUG, "Removed preferred media artwork from track '" << track->getAbsoluteFilePath() << "'");
}
void updateTrackPreferredArtworks(db::Session& session, const TrackImageAssociation& trackImageAssociation)
void updateTrackPreferredArtworks(db::Session& session, const TrackArtworksAssociation& TrackArtworksAssociation)
{
db::Track::pointer track{ trackImageAssociation.track };
db::Track::pointer track{ TrackArtworksAssociation.track };
{
const db::Artwork::pointer currentPreferredArtwork{ track->getPreferredArtwork() };
if (!isSameArtwork(trackImageAssociation.preferredArtwork, currentPreferredArtwork))
updateTrackPreferredArtwork(session, track, trackImageAssociation.preferredArtwork);
if (!isSameArtwork(TrackArtworksAssociation.preferredArtwork, currentPreferredArtwork))
updateTrackPreferredArtwork(session, track, TrackArtworksAssociation.preferredArtwork);
}
{
const db::Artwork::pointer currentPreferredMediaArtwork{ track->getPreferredMediaArtwork() };
if (!isSameArtwork(trackImageAssociation.preferredMediaArtwork, currentPreferredMediaArtwork))
updateTrackPreferredMediaArtwork(session, track, trackImageAssociation.preferredMediaArtwork);
if (!isSameArtwork(TrackArtworksAssociation.preferredMediaArtwork, currentPreferredMediaArtwork))
updateTrackPreferredMediaArtwork(session, track, TrackArtworksAssociation.preferredMediaArtwork);
}
}
void updateTrackPreferredArtworks(db::Session& session, TrackImageAssociationContainer& imageAssociations)
void updateTrackPreferredArtworks(db::Session& session, TrackArtworksAssociationContainer& imageAssociations)
{
constexpr std::size_t writeBatchSize{ 50 };
@@ -279,18 +279,18 @@ namespace lms::scanner
context.currentStepStats.totalElems = db::Track::getCount(session);
}
SearchTrackImageContext searchContext{
SearchTrackArtworkContext searchContext{
.session = session,
.lastRetrievedTrackId = {},
};
TrackImageAssociationContainer trackImageAssociations;
while (fetchNextTrackArtworksToUpdate(searchContext, trackImageAssociations))
TrackArtworksAssociationContainer TrackArtworksAssociations;
while (fetchNextTrackArtworksToUpdate(searchContext, TrackArtworksAssociations))
{
if (_abortScan)
return;
updateTrackPreferredArtworks(session, trackImageAssociations);
updateTrackPreferredArtworks(session, TrackArtworksAssociations);
context.currentStepStats.processedElems = searchContext.processedTrackCount;
_progressCallback(context.currentStepStats);
}
src/libs/subsonic/impl/CoverArtId.cpp
+19 -44
View File
@@ -22,8 +22,7 @@
#include <cassert>
#include "core/String.hpp"
#include "database/ImageId.hpp"
#include "database/TrackEmbeddedImageId.hpp"
#include "database/ArtworkId.hpp"
namespace lms::api::subsonic
{
@@ -31,14 +30,9 @@ namespace lms::api::subsonic
{
constexpr char timestampSeparatorChar{ '-' };
std::string idToString(db::ImageId id)
std::string idToString(db::ArtworkId id)
{
return "im-" + id.toString();
}
std::string idToString(db::TrackEmbeddedImageId id)
{
return "trim-" + id.toString();
return "art-" + id.toString();
}
} // namespace
@@ -46,19 +40,10 @@ namespace lms::api::subsonic
{
std::string res;
// produce "type-id[-timestamp]"
if (db::TrackEmbeddedImageId * imageId{ std::get_if<db::TrackEmbeddedImageId>(&coverId.id) })
{
res = idToString(*imageId);
assert(!coverId.timestamp.has_value());
}
else if (db::ImageId * imageId{ std::get_if<db::ImageId>(&coverId.id) })
{
res = idToString(*imageId);
res += timestampSeparatorChar;
assert(coverId.timestamp.has_value());
res += std::to_string(*coverId.timestamp);
}
// produce "art-id-timestamp"
res = idToString(coverId.id);
res += timestampSeparatorChar;
res += std::to_string(coverId.timestamp);
assert(!res.empty());
return res;
@@ -74,30 +59,20 @@ namespace lms::core::stringUtils
std::optional<api::subsonic::CoverArtId> res;
std::vector<std::string_view> values{ core::stringUtils::splitString(str, '-') };
if (values.size() <= 1)
// expect "art-id-timestamp"
if (values.size() != 3)
return res;
if (values[0] != "art")
return res;
const auto value{ core::stringUtils::readAs<db::ArtworkId::ValueType>(values[1]) };
const auto timestamp{ core::stringUtils::readAs<std::time_t>(values[2]) };
if (!value || !timestamp)
return std::nullopt;
if (values[0] == "trim")
{
// expect "trim-id"
if (values.size() == 2)
{
if (const auto value{ core::stringUtils::readAs<db::TrackEmbeddedImageId::ValueType>(values[1]) })
res.emplace(db::TrackEmbeddedImageId{ *value });
}
}
else if (values[0] == "im")
{
// expect "im-id-timestamp"
if (values.size() == 3)
{
const auto imageId{ core::stringUtils::readAs<db::ImageId::ValueType>(values[1]) };
const auto timestamp{ core::stringUtils::readAs<std::time_t>(values[2]) };
if (imageId && timestamp)
res.emplace(db::ImageId{ *imageId }, *timestamp);
}
}
res.emplace(api::subsonic::CoverArtId{ *value, *timestamp });
return res;
}
src/libs/subsonic/impl/CoverArtId.hpp
+3 -14
View File
@@ -20,24 +20,16 @@
#pragma once
#include <ctime>
#include <variant>
#include "core/String.hpp"
#include "database/ImageId.hpp"
#include "database/TrackEmbeddedImageId.hpp"
#include "database/ArtworkId.hpp"
namespace lms::api::subsonic
{
struct CoverArtId
{
std::variant<db::ImageId, db::TrackEmbeddedImageId> id;
std::optional<std::time_t> timestamp;
CoverArtId(db::ImageId _id, std::time_t _timestamp)
: id{ _id }
, timestamp{ _timestamp } {}
CoverArtId(db::TrackEmbeddedImageId _id)
: id{ _id } {}
db::ArtworkId id;
std::time_t timestamp;
};
std::string idToString(CoverArtId coverId);
@@ -46,9 +38,6 @@ namespace lms::api::subsonic
// Used to parse parameters
namespace lms::core::stringUtils
{
template<>
std::optional<db::ImageId> readAs(std::string_view str);
template<>
std::optional<api::subsonic::CoverArtId> readAs(std::string_view str);
} // namespace lms::core::stringUtils
src/libs/subsonic/impl/endpoints/MediaRetrieval.cpp
+1 -6
View File
@@ -336,12 +336,7 @@ namespace lms::api::subsonic
if (size)
*size = core::utils::clamp(*size, std::size_t{ 32 }, std::size_t{ 2048 });
std::shared_ptr<image::IEncodedImage> image;
if (const db::TrackEmbeddedImageId * trackEmbeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&coverArtId.id) })
image = core::Service<artwork::IArtworkService>::get()->getTrackEmbeddedImage(*trackEmbeddedImageId, size);
else if (const db::ImageId * imageId{ std::get_if<db::ImageId>(&coverArtId.id) })
image = core::Service<artwork::IArtworkService>::get()->getImage(*imageId, size);
std::shared_ptr<image::IEncodedImage> image{ core::Service<artwork::IArtworkService>::get()->getImage(coverArtId.id, size) };
if (!image)
{
response.setStatus(404);
src/libs/subsonic/impl/responses/Album.cpp
+5 -13
View File
@@ -23,14 +23,13 @@
#include "core/Service.hpp"
#include "core/String.hpp"
#include "database/Artist.hpp"
#include "database/Artwork.hpp"
#include "database/Cluster.hpp"
#include "database/Directory.hpp"
#include "database/Image.hpp"
#include "database/Release.hpp"
#include "database/Track.hpp"
#include "database/Types.hpp"
#include "database/User.hpp"
#include "services/artwork/IArtworkService.hpp"
#include "services/feedback/IFeedbackService.hpp"
#include "services/scrobbling/IScrobblingService.hpp"
@@ -88,19 +87,12 @@ namespace lms::api::subsonic
albumNode.setAttribute("created", core::stringUtils::toISO8601String(release->getAddedTime()));
if (const auto artwork{ release->getPreferredArtwork() })
{
const auto imageResult{ core::Service<artwork::IArtworkService>::get()->findReleaseImage(release->getId()) };
if (const db::ImageId * imageId{ std::get_if<db::ImageId>(&imageResult) })
{
if (const db::Image::pointer image{ db::Image::find(context.dbSession, *imageId) })
{
const CoverArtId coverArtId{ *imageId, image->getLastWriteTime().toTime_t() };
albumNode.setAttribute("coverArt", idToString(coverArtId));
}
}
else if (const db::TrackEmbeddedImageId * embeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&imageResult) })
albumNode.setAttribute("coverArt", idToString(*embeddedImageId));
CoverArtId coverArtId{ artwork->getId(), artwork->getLastWrittenTime().toTime_t() };
albumNode.setAttribute("coverArt", idToString(coverArtId));
}
if (const auto originalYear{ release->getOriginalYear() })
albumNode.setAttribute("year", *originalYear);
else if (const auto year{ release->getYear() })
src/libs/subsonic/impl/responses/Artist.cpp
+4 -13
View File
@@ -23,11 +23,10 @@
#include "core/Service.hpp"
#include "core/String.hpp"
#include "database/Artist.hpp"
#include "database/Image.hpp"
#include "database/Artwork.hpp"
#include "database/Release.hpp"
#include "database/TrackArtistLink.hpp"
#include "database/User.hpp"
#include "services/artwork/IArtworkService.hpp"
#include "services/feedback/IFeedbackService.hpp"
#include "CoverArtId.hpp"
@@ -96,18 +95,10 @@ namespace lms::api::subsonic
artistNode.setAttribute("id", idToString(artist->getId()));
artistNode.setAttribute("name", artist->getName());
if (const auto artwork{ artist->getPreferredArtwork() })
{
const auto imageResult{ core::Service<artwork::IArtworkService>::get()->findArtistImage(artist->getId()) };
if (const db::ImageId * imageId{ std::get_if<db::ImageId>(&imageResult) })
{
if (const db::Image::pointer image{ db::Image::find(context.dbSession, *imageId) })
{
const CoverArtId coverArtId{ *imageId, image->getLastWriteTime().toTime_t() };
artistNode.setAttribute("coverArt", idToString(coverArtId));
}
}
else if (const db::TrackEmbeddedImageId * embeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&imageResult) })
artistNode.setAttribute("coverArt", idToString(*embeddedImageId));
CoverArtId coverArtId{ artwork->getId(), artwork->getLastWrittenTime().toTime_t() };
artistNode.setAttribute("coverArt", idToString(coverArtId));
}
const std::size_t count{ Release::getCount(context.dbSession, Release::FindParameters{}.setArtist(artist->getId())) };
src/libs/subsonic/impl/responses/Playlist.cpp
+5 -10
View File
@@ -21,7 +21,7 @@
#include "core/Service.hpp"
#include "core/String.hpp"
#include "database/Image.hpp"
#include "database/Artwork.hpp"
#include "database/TrackList.hpp"
#include "database/User.hpp"
#include "services/artwork/IArtworkService.hpp"
@@ -46,18 +46,13 @@ namespace lms::api::subsonic
if (const db::User::pointer user{ tracklist->getUser() })
playlistNode.setAttribute("owner", user->getLoginName());
if (const db::ArtworkId artworkId{ core::Service<artwork::IArtworkService>::get()->findTrackListImage(tracklist->getId()) }; artworkId.isValid())
{
const auto imageResult{ core::Service<artwork::IArtworkService>::get()->findTrackListImage(tracklist->getId()) };
if (const db::ImageId * imageId{ std::get_if<db::ImageId>(&imageResult) })
if (const auto artwork{ db::Artwork::find(context.dbSession, artworkId) })
{
if (const db::Image::pointer image{ db::Image::find(context.dbSession, *imageId) })
{
const CoverArtId coverArtId{ *imageId, image->getLastWriteTime().toTime_t() };
playlistNode.setAttribute("coverArt", idToString(coverArtId));
}
CoverArtId coverArtId{ artwork->getId(), artwork->getLastWrittenTime().toTime_t() };
playlistNode.setAttribute("coverArt", idToString(coverArtId));
}
else if (const db::TrackEmbeddedImageId * embeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&imageResult) })
playlistNode.setAttribute("coverArt", idToString(*embeddedImageId));
}
return playlistNode;
src/libs/subsonic/impl/responses/Song.cpp
+8 -14
View File
@@ -21,21 +21,19 @@
#include <string_view>
#include "av/IAudioFile.hpp"
#include "core/ITraceLogger.hpp"
#include "core/MimeTypes.hpp"
#include "core/Service.hpp"
#include "core/String.hpp"
#include "database/Artist.hpp"
#include "database/Artwork.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"
#include "database/Types.hpp"
#include "database/User.hpp"
#include "services/artwork/IArtworkService.hpp"
#include "services/feedback/IFeedbackService.hpp"
#include "services/scrobbling/IScrobblingService.hpp"
@@ -111,18 +109,14 @@ namespace lms::api::subsonic
trackResponse.setAttribute("transcodedContentType", core::getMimeType(std::filesystem::path{ "." + fileSuffix }));
}
auto artwork{ track->getPreferredMediaArtwork() };
if (!artwork)
artwork = track->getPreferredArtwork();
if (artwork)
{
const auto imageResult{ core::Service<artwork::IArtworkService>::get()->findTrackImage(track->getId()) };
if (const db::ImageId * imageId{ std::get_if<db::ImageId>(&imageResult) })
{
if (const db::Image::pointer image{ db::Image::find(context.dbSession, *imageId) })
{
const CoverArtId coverArtId{ *imageId, image->getLastWriteTime().toTime_t() };
trackResponse.setAttribute("coverArt", idToString(coverArtId));
}
}
else if (const db::TrackEmbeddedImageId * embeddedImageId{ std::get_if<db::TrackEmbeddedImageId>(&imageResult) })
trackResponse.setAttribute("coverArt", idToString(*embeddedImageId));
CoverArtId coverArtId{ artwork->getId(), artwork->getLastWrittenTime().toTime_t() };
trackResponse.setAttribute("coverArt", idToString(coverArtId));
}
const std::vector<Artist::pointer>& artists{ track->getArtists({ TrackArtistLinkType::Artist }) };
src/lms/ui/MediaPlayer.cpp
+20 -6
View File
@@ -251,12 +251,26 @@ namespace lms::ui
<< " replayGain: " << replayGain << ","
<< " title: \"" << core::stringUtils::jsEscape(track->getName()) << "\","
<< " artist: \"" << (!artists.empty() ? core::stringUtils::jsEscape(track->getArtistDisplayName()) : "") << "\","
<< " release: \"" << (track->getRelease() ? core::stringUtils::jsEscape(track->getRelease()->getName()) : "") << "\","
<< " artwork: ["
<< " { src: \"" << LmsApp->getArtworkResource()->getTrackImageUrl(trackId, ArtworkResource::Size::Small) << "\", sizes: \"128x128\", type: \"image/jpeg\" },"
<< " { src: \"" << LmsApp->getArtworkResource()->getTrackImageUrl(trackId, ArtworkResource::Size::Large) << "\", sizes: \"512x512\", type: \"image/jpeg\" },"
<< " ]"
<< "};";
<< " release: \"" << (track->getRelease() ? core::stringUtils::jsEscape(track->getRelease()->getName()) : "") << "\",";
db::ArtworkId artworkId{ track->getPreferredMediaArtworkId() };
if (!artworkId.isValid())
artworkId = track->getPreferredArtworkId();
if (artworkId.isValid())
{
oss << " artwork: ["
<< " { src: \"" << LmsApp->getArtworkResource()->getArtworkUrl(artworkId, ArtworkResource::Size::Small) << "\", sizes: \"128x128\", type: \"image/jpeg\" },"
<< " { src: \"" << LmsApp->getArtworkResource()->getArtworkUrl(artworkId, ArtworkResource::Size::Large) << "\", sizes: \"512x512\", type: \"image/jpeg\" },"
<< " ]";
}
else
{
oss << " artwork: ["
<< " { src: \"" << LmsApp->getArtworkResource()->getDefaultTrackArtworkUrl() << "\", type: \"image/svg+xml\" },"
<< " ]";
}
oss << "};";
// Update 'sizes' above to match this:
static_assert(static_cast<std::underlying_type_t<ArtworkResource::Size>>(ArtworkResource::Size::Small) == 128);
static_assert(static_cast<std::underlying_type_t<ArtworkResource::Size>>(ArtworkResource::Size::Large) == 512);
src/lms/ui/PlayQueue.cpp
+12 -2
View File
@@ -490,8 +490,18 @@ namespace lms::ui
entry->bindWidget("artists-md", utils::createArtistAnchorList(artists));
}
auto image{ utils::createTrackImage(track->getId(), ArtworkResource::Size::Small) };
image->addStyleClass("Lms-cover-track rounded");
db::ArtworkId artworkId{ track->getPreferredMediaArtworkId() };
if (!artworkId.isValid())
artworkId = track->getPreferredArtworkId();
std::unique_ptr<Wt::WImage> image;
if (artworkId.isValid())
image = utils::createArtworkImage(artworkId, ArtworkResource::Size::Small);
else
image = utils::createDefaultTrackArtworkImage();
image->addStyleClass("Lms-cover-track rounded"); // HACK
if (const auto release{ track->getRelease() })
{
entry->setCondition("if-has-release", true);
src/lms/ui/Utils.cpp
+27 -29
View File
@@ -40,6 +40,18 @@
namespace lms::ui::utils
{
namespace
{
std::unique_ptr<Wt::WImage> createArtworkImage()
{
auto image{ std::make_unique<Wt::WImage>() };
image->setStyleClass("Lms-cover img-fluid"); // HACK
image->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
return image;
}
} // namespace
std::string durationToString(std::chrono::milliseconds msDuration)
{
const std::chrono::seconds duration{ std::chrono::duration_cast<std::chrono::seconds>(msDuration) };
@@ -76,46 +88,32 @@ namespace lms::ui::utils
LmsApp->getModalManager().show(std::move(rawImage));
}
std::unique_ptr<Wt::WImage> createArtistImage(db::ArtistId artistId, ArtworkResource::Size size)
std::unique_ptr<Wt::WImage> createArtworkImage(db::ArtworkId artworkId, ArtworkResource::Size size)
{
auto image{ std::make_unique<Wt::WImage>() };
image->setImageLink(LmsApp->getArtworkResource()->getArtistImageUrl(artistId, size));
image->setStyleClass("Lms-cover img-fluid"); // HACK
image->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
auto image{ createArtworkImage() };
image->setImageLink(LmsApp->getArtworkResource()->getArtworkUrl(artworkId, size));
return image;
}
std::unique_ptr<Wt::WImage> createReleaseCover(db::ReleaseId releaseId, ArtworkResource::Size size)
std::unique_ptr<Wt::WImage> createDefaultArtistArtworkImage()
{
auto cover{ std::make_unique<Wt::WImage>() };
cover->setImageLink(LmsApp->getArtworkResource()->getReleaseCoverUrl(releaseId, size));
cover->setStyleClass("Lms-cover img-fluid"); // HACK
cover->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
return cover;
auto image{ createArtworkImage() };
image->setImageLink(LmsApp->getArtworkResource()->getDefaultArtistArtworkUrl());
return image;
}
std::unique_ptr<Wt::WImage> createTrackImage(db::TrackId trackId, ArtworkResource::Size size)
std::unique_ptr<Wt::WImage> createDefaultReleaseArtworkImage()
{
auto cover{ std::make_unique<Wt::WImage>() };
cover->setImageLink(LmsApp->getArtworkResource()->getTrackImageUrl(trackId, size));
cover->setStyleClass("Lms-cover img-fluid"); // HACK
cover->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
return cover;
auto image{ createArtworkImage() };
image->setImageLink(LmsApp->getArtworkResource()->getDefaultReleaseArtworkUrl());
return image;
}
std::unique_ptr<Wt::WImage> createTrackMediaImage(db::TrackId trackId, ArtworkResource::Size size)
std::unique_ptr<Wt::WImage> createDefaultTrackArtworkImage()
{
std::string url{ LmsApp->getArtworkResource()->getTrackMediaImageUrl(trackId, size) };
if (url.empty())
return nullptr;
auto cover{ std::make_unique<Wt::WImage>() };
cover->setImageLink(std::move(url));
cover->setStyleClass("Lms-cover img-fluid"); // HACK
cover->setAttributeValue("onload", LmsApp->javaScriptClass() + ".onLoadCover(this)"); // HACK
return cover;
auto image{ createArtworkImage() };
image->setImageLink(LmsApp->getArtworkResource()->getDefaultTrackArtworkUrl());
return image;
}
std::unique_ptr<Wt::WInteractWidget> createFilter(const Wt::WString& name, const Wt::WString& tooltip, std::string_view colorStyleClass, bool canDelete)
src/lms/ui/Utils.hpp
+4 -4
View File
@@ -57,10 +57,10 @@ namespace lms::ui::utils
void showArtworkModal(Wt::WLink image);
std::unique_ptr<Wt::WImage> createReleaseCover(db::ReleaseId releaseId, ArtworkResource::Size size);
std::unique_ptr<Wt::WImage> createTrackImage(db::TrackId trackId, ArtworkResource::Size size);
std::unique_ptr<Wt::WImage> createTrackMediaImage(db::TrackId trackId, ArtworkResource::Size size); // return nullptr if no image
std::unique_ptr<Wt::WImage> createArtistImage(db::ArtistId artistId, ArtworkResource::Size size);
std::unique_ptr<Wt::WImage> createArtworkImage(db::ArtworkId artworkId, ArtworkResource::Size size);
std::unique_ptr<Wt::WImage> createDefaultArtistArtworkImage();
std::unique_ptr<Wt::WImage> createDefaultReleaseArtworkImage();
std::unique_ptr<Wt::WImage> createDefaultTrackArtworkImage();
std::unique_ptr<Wt::WInteractWidget> createFilter(const Wt::WString& name, const Wt::WString& tooltip, std::string_view colorStyleClass, bool canDelete = false);
std::unique_ptr<Wt::WInteractWidget> createFilterCluster(db::ClusterId clusterId, bool canDelete = false);
src/lms/ui/explore/ArtistListHelpers.cpp
+8 -3
View File
@@ -22,18 +22,23 @@
#include "database/Artist.hpp"
#include "LmsApplication.hpp"
#include "Utils.hpp"
namespace lms::ui::ArtistListHelpers
{
std::unique_ptr<Wt::WTemplate> createEntry(const db::ObjectPtr<db::Artist>& artist)
std::unique_ptr<Wt::WTemplate> createEntry(const db::Artist::pointer& artist)
{
auto entry{ std::make_unique<Wt::WTemplate>(Wt::WString::tr("Lms.Explore.Artists.template.entry")) };
entry->bindWidget("name", utils::createArtistAnchor(artist));
Wt::WAnchor* anchor{ entry->bindWidget("image", utils::createArtistAnchor(artist, false)) };
auto image{ utils::createArtistImage(artist->getId(), ArtworkResource::Size::Large) };
std::unique_ptr<Wt::WImage> image;
if (artist->getPreferredArtworkId().isValid())
image = utils::createArtworkImage(artist->getPreferredArtworkId(), ArtworkResource::Size::Large);
else
image = utils::createDefaultArtistArtworkImage();
image->addStyleClass("Lms-cover-release Lms-cover-anchor rounded"); // hack
anchor->setImage(std::move(image));
src/lms/ui/explore/ArtistView.cpp
+19 -6
View File
@@ -24,6 +24,7 @@
#include "core/String.hpp"
#include "database/Artist.hpp"
#include "database/ArtistInfo.hpp"
#include "database/ArtworkId.hpp"
#include "database/Cluster.hpp"
#include "database/Release.hpp"
#include "database/ScanSettings.hpp"
@@ -119,7 +120,7 @@ namespace lms::ui
LmsApp->setTitle(artist->getName());
_artistId = *artistId;
refreshArtwork();
refreshArtwork(artist->getPreferredArtworkId());
refreshArtistInfo();
refreshReleases();
refreshAppearsOnReleases();
@@ -191,12 +192,24 @@ namespace lms::ui
}
}
void Artist::refreshArtwork()
void Artist::refreshArtwork(db::ArtworkId artworkId)
{
auto* image{ bindWidget<Wt::WImage>("artwork", utils::createArtistImage(_artistId, ArtworkResource::Size::Large)) };
image->clicked().connect([this] {
utils::showArtworkModal(Wt::WLink{ LmsApp->getArtworkResource()->getArtistImageUrl(_artistId) });
});
std::unique_ptr<Wt::WImage> artworkImage;
if (artworkId.isValid())
{
artworkImage = utils::createArtworkImage(artworkId, ArtworkResource::Size::Large);
artworkImage->addStyleClass("Lms-cursor-pointer"); // HACK
}
else
artworkImage = utils::createDefaultArtistArtworkImage();
auto* image{ bindWidget<Wt::WImage>("artwork", std::move(artworkImage)) };
if (artworkId.isValid())
{
image->clicked().connect([artworkId] {
utils::showArtworkModal(Wt::WLink{ LmsApp->getArtworkResource()->getArtworkUrl(artworkId) });
});
}
}
void Artist::refreshArtistInfo()
src/lms/ui/explore/ArtistView.hpp
+2 -1
View File
@@ -22,6 +22,7 @@
#include <map>
#include "database/ArtistId.hpp"
#include "database/ArtworkId.hpp"
#include "database/Object.hpp"
#include "database/ReleaseId.hpp"
@@ -47,7 +48,7 @@ namespace lms::ui
private:
void refreshView();
void refreshArtwork();
void refreshArtwork(db::ArtworkId artworkId);
void refreshArtistInfo();
void refreshReleases();
void refreshAppearsOnReleases();
src/lms/ui/explore/ReleaseHelpers.cpp
+7 -1
View File
@@ -51,7 +51,13 @@ namespace lms::ui::releaseListHelpers
{
Wt::WAnchor* anchor{ entry->bindWidget("cover", utils::createReleaseAnchor(release, false)) };
auto image{ utils::createReleaseCover(release->getId(), ArtworkResource::Size::Large) };
std::unique_ptr<Wt::WImage> image;
if (release->getPreferredArtworkId().isValid())
image = utils::createArtworkImage(release->getPreferredArtworkId(), ArtworkResource::Size::Large);
else
image = utils::createDefaultReleaseArtworkImage();
image->addStyleClass("Lms-cover-release Lms-cover-anchor rounded"); // hack
anchor->setImage(std::move(image));
}
src/lms/ui/explore/ReleaseView.cpp
+30 -12
View File
@@ -306,11 +306,7 @@ namespace lms::ui
bindString("duration", utils::durationToString(release->getDuration()), Wt::TextFormat::Plain);
refreshReleaseArtists(release);
auto* image{ bindWidget<Wt::WImage>("cover", utils::createReleaseCover(release->getId(), ArtworkResource::Size::Large)) };
image->clicked().connect([=] {
utils::showArtworkModal(Wt::WLink{ LmsApp->getArtworkResource()->getReleaseCoverUrl(*releaseId) });
});
refreshArtwork(release->getPreferredArtworkId());
Wt::WContainerWidget* clusterContainers{ bindNew<Wt::WContainerWidget>("clusters") };
{
@@ -391,22 +387,24 @@ namespace lms::ui
// Expect to be called in asc order
std::map<std::size_t, Wt::WContainerWidget*> trackContainers;
auto getOrAddDiscContainer = [&, releaseId = _releaseId](std::size_t discNumber, const std::string& discSubtitle, db::TrackId trackId) -> Wt::WContainerWidget* {
auto getOrAddDiscContainer = [&, releaseId = _releaseId](std::size_t discNumber, const std::string& discSubtitle, db::ArtworkId mediaArtworkId) -> Wt::WContainerWidget* {
if (auto it{ trackContainers.find(discNumber) }; it != std::cend(trackContainers))
return it->second;
Template* disc{ rootContainer->addNew<Template>(Wt::WString::tr("Lms.Explore.Release.template.entry-disc")) };
disc->addFunction("id", &Wt::WTemplate::Functions::id);
if (auto image{ utils::createTrackMediaImage(trackId, ArtworkResource::Size::Large) })
if (mediaArtworkId.isValid())
{
disc->setCondition("if-has-image", true);
auto image{ utils::createArtworkImage(mediaArtworkId, ArtworkResource::Size::Small) };
disc->setCondition("if-has-artwork", true);
image->addStyleClass("Lms-cover-track rounded"); // HACK
image->clicked().connect([=] {
utils::showArtworkModal(Wt::WLink{ LmsApp->getArtworkResource()->getTrackMediaImageUrl(trackId) });
utils::showArtworkModal(Wt::WLink{ LmsApp->getArtworkResource()->getArtworkUrl(mediaArtworkId) });
});
disc->bindWidget<Wt::WImage>("image", std::move(image));
disc->bindWidget<Wt::WImage>("artwork", std::move(image));
}
if (discSubtitle.empty())
@@ -469,9 +467,9 @@ namespace lms::ui
Wt::WContainerWidget* container{};
if (useSubtitleContainers && discNumber)
container = getOrAddDiscContainer(*discNumber, track->getDiscSubtitle(), track->getId());
container = getOrAddDiscContainer(*discNumber, track->getDiscSubtitle(), track->getPreferredMediaArtworkId());
else if (hasDiscSubtitle && !discNumber)
container = getOrAddDiscContainer(0, track->getDiscSubtitle(), track->getId());
container = getOrAddDiscContainer(0, track->getDiscSubtitle(), track->getPreferredMediaArtworkId());
else
container = getOrAddNoDiscContainer();
@@ -567,6 +565,26 @@ namespace lms::ui
});
}
void Release::refreshArtwork(db::ArtworkId artworkId)
{
std::unique_ptr<Wt::WImage> artworkImage;
if (artworkId.isValid())
{
artworkImage = utils::createArtworkImage(artworkId, ArtworkResource::Size::Large);
artworkImage->addStyleClass("Lms-cursor-pointer"); // HACK
}
else
artworkImage = utils::createDefaultReleaseArtworkImage();
auto* image{ bindWidget<Wt::WImage>("artwork", std::move(artworkImage)) };
if (artworkId.isValid())
{
image->clicked().connect([artworkId] {
utils::showArtworkModal(Wt::WLink{ LmsApp->getArtworkResource()->getArtworkUrl(artworkId) });
});
}
}
void Release::refreshReleaseArtists(const db::Release::pointer& release)
{
auto container{ utils::createArtistsAnchorsForRelease(release) };
src/lms/ui/explore/ReleaseView.hpp
+2
View File
@@ -19,6 +19,7 @@
#pragma once
#include "database/ArtworkId.hpp"
#include "database/Object.hpp"
#include "database/ReleaseId.hpp"
@@ -41,6 +42,7 @@ namespace lms::ui
private:
void refreshView();
void refreshArtwork(db::ArtworkId artworkId);
void refreshReleaseArtists(const db::ObjectPtr<db::Release>& release);
void refreshCopyright(const db::ObjectPtr<db::Release>& release);
void refreshLinks(const db::ObjectPtr<db::Release>& release);
src/lms/ui/explore/TrackListHelpers.cpp
+9 -2
View File
@@ -228,8 +228,15 @@ namespace lms::ui::TrackListHelpers
entry->bindWidget("artists-md", utils::createArtistDisplayNameWithAnchors(track->getArtistDisplayName(), artists));
}
auto image{ utils::createTrackImage(trackId, ArtworkResource::Size::Small) };
image->addStyleClass("Lms-cover-track rounded");
std::unique_ptr<Wt::WImage> image;
if (track->getPreferredMediaArtworkId().isValid())
image = utils::createArtworkImage(track->getPreferredMediaArtworkId(), ArtworkResource::Size::Small);
else if (track->getPreferredArtworkId().isValid())
image = utils::createArtworkImage(track->getPreferredArtworkId(), ArtworkResource::Size::Small);
else
image = utils::createDefaultTrackArtworkImage();
image->addStyleClass("Lms-cover-track rounded"); // hack
if (track->getRelease())
{
entry->setCondition("if-has-release", true);
src/lms/ui/resource/ArtworkResource.cpp
+52 -95
View File
@@ -47,97 +47,28 @@ namespace lms::ui
beingDeleted();
}
std::string ArtworkResource::getArtistImageUrl(db::ArtistId artistId, std::optional<Size> size) const
std::string ArtworkResource::getArtworkUrl(db::ArtworkId artworkId, std::optional<Size> size) const
{
std::string url;
const auto imageResult{ core::Service<artwork::IArtworkService>::get()->findArtistImage(artistId) };
std::visit([&](const auto& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, std::monostate>)
url = getDefaultArtistImageUrl();
else
url = getImageUrl(arg, size, "artist");
},
imageResult);
return url;
}
std::string ArtworkResource::getReleaseCoverUrl(db::ReleaseId releaseId, std::optional<Size> size) const
{
std::string url;
const auto imageResult{ core::Service<artwork::IArtworkService>::get()->findReleaseImage(releaseId) };
std::visit([&](const auto& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, std::monostate>)
url = getDefaultReleaseCoverUrl();
else
url = getImageUrl(arg, size, "release");
},
imageResult);
return url;
}
std::string ArtworkResource::getTrackImageUrl(db::TrackId trackId, std::optional<Size> size) const
{
std::string url;
const auto imageResult{ core::Service<artwork::IArtworkService>::get()->findTrackImage(trackId) };
std::visit([&](const auto& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<T, std::monostate>)
url = getDefaultReleaseCoverUrl();
else
url = getImageUrl(arg, size, "release");
},
imageResult);
return url;
}
std::string ArtworkResource::getTrackMediaImageUrl(db::TrackId trackId, std::optional<Size> size)
{
std::string url;
const auto imageResult{ core::Service<artwork::IArtworkService>::get()->findTrackMediaImage(trackId) };
std::visit([&](const auto& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (!std::is_same_v<T, std::monostate>)
url = getImageUrl(arg, size, "release");
},
imageResult);
return url;
}
std::string ArtworkResource::getImageUrl(db::ImageId imageId, std::optional<Size> size, std::string_view type) const
{
std::string res{ url() + "&imageid=" + imageId.toString() + "&type=" + std::string{ type } };
std::string res{ url() + "&artworkid=" + artworkId.toString() };
if (size)
res += "&size=" + std::to_string(static_cast<std::size_t>(*size));
return res;
}
std::string ArtworkResource::getImageUrl(db::TrackEmbeddedImageId trackEmbeddedImageId, std::optional<Size> size, std::string_view type) const
std::string ArtworkResource::getDefaultArtistArtworkUrl() const
{
std::string res{ url() + "&trimageid=" + trackEmbeddedImageId.toString() + "&type=" + std::string{ type } };
if (size)
res += "&size=" + std::to_string(static_cast<std::size_t>(*size));
return res;
return url() + "&type=defartist";
}
std::string ArtworkResource::getDefaultArtistImageUrl() const
std::string ArtworkResource::getDefaultReleaseArtworkUrl() const
{
return url() + "&type=artist";
return url() + "&type=defrelease";
}
std::string ArtworkResource::getDefaultReleaseCoverUrl() const
std::string ArtworkResource::getDefaultTrackArtworkUrl() const
{
return url() + "&type=release";
return url() + "&type=defrelease";
}
void ArtworkResource::handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response)
@@ -145,40 +76,64 @@ namespace lms::ui
LMS_SCOPED_TRACE_OVERVIEW("UI", "HandleCoverRequest");
// Retrieve parameters
const std::string* imageIdStr = request.getParameter("imageid");
const std::string* trackEmbeddedImageIdStr = request.getParameter("trimageid");
const std::string* artworkIdStr = request.getParameter("artworkid");
const std::string* sizeStr = request.getParameter("size");
const std::string* typeStr = request.getParameter("type");
std::shared_ptr<image::IEncodedImage> image;
if ((imageIdStr || trackEmbeddedImageIdStr))
if (artworkIdStr && typeStr)
{
ARTWORK_RESOURCE_LOG(DEBUG, "both artwork ID and type provided, only one is allowed");
response.setStatus(400);
return;
}
if (!artworkIdStr && !typeStr)
{
ARTWORK_RESOURCE_LOG(DEBUG, "no artwork ID or type provided");
response.setStatus(400);
return;
}
if (artworkIdStr)
{
const auto size{ sizeStr ? core::stringUtils::readAs<std::size_t>(*sizeStr) : std::nullopt };
if (size && *size > maxSize)
{
ARTWORK_RESOURCE_LOG(DEBUG, "invalid size provided!");
ARTWORK_RESOURCE_LOG(DEBUG, "invalid size provided: " << *sizeStr);
response.setStatus(400);
return;
}
if (imageIdStr)
const auto artworkId{ core::stringUtils::readAs<db::ArtworkId::ValueType>(*artworkIdStr) };
if (!artworkId)
{
if (const auto imageId{ core::stringUtils::readAs<db::ImageId::ValueType>(*imageIdStr) })
image = core::Service<artwork::IArtworkService>::get()->getImage(*imageId, size);
ARTWORK_RESOURCE_LOG(DEBUG, "invalid artwork ID provided: '" << *artworkIdStr << "'");
response.setStatus(400);
return;
}
else if (trackEmbeddedImageIdStr)
{
if (const auto imageId{ core::stringUtils::readAs<db::TrackEmbeddedImageId::ValueType>(*trackEmbeddedImageIdStr) })
image = core::Service<artwork::IArtworkService>::get()->getTrackEmbeddedImage(*imageId, size);
}
}
if (!image && typeStr)
image = core::Service<artwork::IArtworkService>::get()->getImage(*artworkId, size);
if (!image)
ARTWORK_RESOURCE_LOG(DEBUG, "no image found for artwork ID: '" << *artworkIdStr << "'");
}
else
{
if (*typeStr == "release")
image = core::Service<artwork::IArtworkService>::get()->getDefaultReleaseCover();
else if (*typeStr == "artist")
image = core::Service<artwork::IArtworkService>::get()->getDefaultArtistImage();
assert(typeStr);
if (*typeStr == "defartist")
image = core::Service<artwork::IArtworkService>::get()->getDefaultArtistArtwork();
else if (*typeStr == "defrelease")
image = core::Service<artwork::IArtworkService>::get()->getDefaultReleaseArtwork();
else
{
ARTWORK_RESOURCE_LOG(DEBUG, "invalid type provided: '" << *typeStr << "'");
response.setStatus(400);
return;
}
if (!image)
ARTWORK_RESOURCE_LOG(DEBUG, "no default image found for type: '" << *typeStr << "'");
}
if (image)
@@ -187,6 +142,8 @@ namespace lms::ui
response.out().write(reinterpret_cast<const char*>(image->getData().data()), image->getData().size());
}
else
{
response.setStatus(404);
}
}
} // namespace lms::ui
src/lms/ui/resource/ArtworkResource.hpp
+7 -16
View File
@@ -23,11 +23,7 @@
#include <Wt/WResource.h>
#include "database/ArtistId.hpp"
#include "database/ImageId.hpp"
#include "database/ReleaseId.hpp"
#include "database/TrackEmbeddedImageId.hpp"
#include "database/TrackId.hpp"
#include "database/ArtworkId.hpp"
namespace lms::ui
{
@@ -37,7 +33,7 @@ namespace lms::ui
static const std::size_t maxSize{ 512 };
ArtworkResource();
~ArtworkResource();
~ArtworkResource() override;
enum class Size : std::size_t
{
@@ -45,18 +41,13 @@ namespace lms::ui
Large = 512,
};
std::string getArtistImageUrl(db::ArtistId artistId, std::optional<Size> size = std::nullopt) const;
std::string getReleaseCoverUrl(db::ReleaseId releaseId, std::optional<Size> size = std::nullopt) const;
std::string getTrackImageUrl(db::TrackId trackId, std::optional<Size> size = std::nullopt) const;
std::string getTrackMediaImageUrl(db::TrackId trackId, std::optional<Size> size = std::nullopt);
std::string getArtworkUrl(db::ArtworkId artworkId, std::optional<Size> size = std::nullopt) const;
std::string getDefaultArtistArtworkUrl() const;
std::string getDefaultReleaseArtworkUrl() const;
std::string getDefaultTrackArtworkUrl() const;
private:
std::string getImageUrl(db::ImageId imageId, std::optional<Size> size, std::string_view type) const;
std::string getImageUrl(db::TrackEmbeddedImageId trackEmbeddedImageId, std::optional<Size> size, std::string_view type) const;
std::string getDefaultArtistImageUrl() const;
std::string getDefaultReleaseCoverUrl() const;
void handleRequest(const Wt::Http::Request& request, Wt::Http::Response& response) override;
};
} // namespace lms::ui