404 lines
14 KiB
C++
404 lines
14 KiB
C++
/*
|
|
* Copyright (C) 2013 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 "ArtworkService.hpp"
|
|
|
|
#include "core/IConfig.hpp"
|
|
#include "core/ILogger.hpp"
|
|
#include "core/Utils.hpp"
|
|
#include "database/Artist.hpp"
|
|
#include "database/Db.hpp"
|
|
#include "database/Image.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 "image/Exception.hpp"
|
|
#include "image/IEncodedImage.hpp"
|
|
#include "image/Image.hpp"
|
|
#include "metadata/IAudioFileParser.hpp"
|
|
|
|
namespace lms::artwork
|
|
{
|
|
namespace
|
|
{
|
|
bool isImageFound(const ArtworkService::ImageFindResult& res)
|
|
{
|
|
return !std::holds_alternative<std::monostate>(res);
|
|
}
|
|
} // namespace
|
|
|
|
std::unique_ptr<IArtworkService> createArtworkService(db::Db& db, const std::filesystem::path& defaultReleaseCoverSvgPath, const std::filesystem::path& defaultArtistImageSvgPath)
|
|
{
|
|
return std::make_unique<ArtworkService>(db, defaultReleaseCoverSvgPath, defaultArtistImageSvgPath);
|
|
}
|
|
|
|
ArtworkService::ArtworkService(db::Db& db,
|
|
const std::filesystem::path& defaultReleaseCoverSvgPath,
|
|
const std::filesystem::path& defaultArtistImageSvgPath)
|
|
: _db{ db }
|
|
, _audioFileParser{ metadata::createAudioFileParser(metadata::AudioFileParserParameters{}) }
|
|
, _cache{ core::Service<core::IConfig>::get()->getULong("cover-max-cache-size", 30) * 1000 * 1000 }
|
|
{
|
|
setJpegQuality(core::Service<core::IConfig>::get()->getULong("cover-jpeg-quality", 75));
|
|
|
|
LMS_LOG(COVER, INFO, "Default release cover path = " << defaultReleaseCoverSvgPath);
|
|
LMS_LOG(COVER, INFO, "Max cache size = " << _cache.getMaxCacheSize());
|
|
|
|
_defaultReleaseCover = image::readImage(defaultReleaseCoverSvgPath); // may throw
|
|
_defaultArtistImage = image::readImage(defaultArtistImageSvgPath); // may throw
|
|
}
|
|
|
|
ArtworkService::~ArtworkService() = default;
|
|
|
|
std::unique_ptr<image::IEncodedImage> ArtworkService::getFromImageFile(const std::filesystem::path& p, std::optional<image::ImageSize> width) const
|
|
{
|
|
std::unique_ptr<image::IEncodedImage> image;
|
|
|
|
try
|
|
{
|
|
if (!width)
|
|
{
|
|
image = image::readImage(p);
|
|
}
|
|
else
|
|
{
|
|
auto rawImage{ image::decodeImage(p) };
|
|
rawImage->resize(*width);
|
|
image = image::encodeToJPEG(*rawImage, _jpegQuality);
|
|
}
|
|
}
|
|
catch (const image::Exception& e)
|
|
{
|
|
LMS_LOG(COVER, ERROR, "Cannot read cover in file " << p << ": " << e.what());
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
std::shared_ptr<image::IEncodedImage> ArtworkService::getDefaultReleaseCover()
|
|
{
|
|
return _defaultReleaseCover;
|
|
}
|
|
|
|
std::shared_ptr<image::IEncodedImage> ArtworkService::getDefaultArtistImage()
|
|
{
|
|
return _defaultArtistImage;
|
|
}
|
|
|
|
std::unique_ptr<image::IEncodedImage> ArtworkService::getTrackImage(const std::filesystem::path& p, std::size_t index, std::optional<image::ImageSize> width) const
|
|
{
|
|
std::unique_ptr<image::IEncodedImage> image;
|
|
|
|
try
|
|
{
|
|
std::size_t currentIndex{};
|
|
|
|
_audioFileParser->parseImages(p, [&](const metadata::Image& parsedImage) {
|
|
if (currentIndex++ != index)
|
|
return;
|
|
|
|
try
|
|
{
|
|
if (!width)
|
|
{
|
|
image = image::readImage(parsedImage.data, parsedImage.mimeType);
|
|
}
|
|
else
|
|
{
|
|
auto rawImage{ image::decodeImage(parsedImage.data) };
|
|
rawImage->resize(*width);
|
|
image = image::encodeToJPEG(*rawImage, _jpegQuality);
|
|
}
|
|
}
|
|
catch (const image::Exception& e)
|
|
{
|
|
LMS_LOG(COVER, ERROR, "Cannot decode image from track " << p << ": " << e.what());
|
|
}
|
|
});
|
|
}
|
|
catch (const metadata::Exception& e)
|
|
{
|
|
LMS_LOG(COVER, ERROR, "Cannot parse images from track " << p << ": " << e.what());
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
ArtworkService::ImageFindResult ArtworkService::findArtistImage(db::ArtistId artistId)
|
|
{
|
|
db::Session& session{ _db.getTLSSession() };
|
|
auto transaction{ session.createReadTransaction() };
|
|
|
|
ImageFindResult res;
|
|
|
|
if (const db::Artist::pointer artist{ db::Artist::find(session, artistId) })
|
|
{
|
|
if (const db::ImageId imageId{ artist->getImageId() }; imageId.isValid())
|
|
res = imageId;
|
|
|
|
// TODO fallback on embedded Band/LeadArtist/Artist?
|
|
// TODO fallback on first release?
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
ArtworkService::ImageFindResult ArtworkService::findTrackImage(db::TrackId trackId)
|
|
{
|
|
ImageFindResult res;
|
|
|
|
db::Session& session{ _db.getTLSSession() };
|
|
auto transaction{ session.createReadTransaction() };
|
|
|
|
{
|
|
db::TrackEmbeddedImage::FindParameters params;
|
|
params.setTrack(trackId);
|
|
params.setImageTypes({ db::ImageType::Media });
|
|
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
|
|
params.setRange(db::Range{ .offset = 0, .size = 1 });
|
|
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
|
|
}
|
|
|
|
if (isImageFound(res))
|
|
return res;
|
|
|
|
// Fallback on another track of the same disc
|
|
const db::Track::pointer track{ db::Track::find(session, trackId) };
|
|
if (!track)
|
|
return res;
|
|
|
|
const db::ReleaseId releaseId{ track->getReleaseId() };
|
|
if (!releaseId.isValid())
|
|
return res;
|
|
|
|
{
|
|
db::TrackEmbeddedImage::FindParameters params;
|
|
params.setRelease(releaseId);
|
|
params.setDiscNumber(track->getDiscNumber());
|
|
params.setImageTypes({ db::ImageType::Media });
|
|
params.setSortMethod(db::TrackEmbeddedImageSortMethod::TrackNumberThenSizeDesc);
|
|
params.setRange(db::Range{ .offset = 0, .size = 1 });
|
|
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
|
|
}
|
|
|
|
if (isImageFound(res))
|
|
return res;
|
|
|
|
// Fallback on front cover
|
|
{
|
|
db::TrackEmbeddedImage::FindParameters params;
|
|
params.setTrack(trackId);
|
|
params.setImageTypes({ db::ImageType::FrontCover });
|
|
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
|
|
params.setRange(db::Range{ .offset = 0, .size = 1 });
|
|
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
|
|
}
|
|
|
|
if (isImageFound(res))
|
|
return res;
|
|
|
|
// Fallback on whatever front cover found on the release
|
|
{
|
|
db::TrackEmbeddedImage::FindParameters params;
|
|
params.setRelease(releaseId);
|
|
params.setImageTypes({ db::ImageType::FrontCover });
|
|
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
|
|
params.setRange(db::Range{ .offset = 0, .size = 1 });
|
|
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
|
|
}
|
|
|
|
if (isImageFound(res))
|
|
return res;
|
|
|
|
// Fallback on external cover of the release
|
|
if (const db::Release::pointer release{ db::Release::find(session, releaseId) })
|
|
{
|
|
if (const db::ImageId imageId{ release->getImageId() }; imageId.isValid())
|
|
res = imageId;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
ArtworkService::ImageFindResult ArtworkService::findTrackMediaImage(db::TrackId trackId)
|
|
{
|
|
db::Session& session{ _db.getTLSSession() };
|
|
auto transaction{ session.createReadTransaction() };
|
|
ImageFindResult res;
|
|
|
|
{
|
|
db::TrackEmbeddedImage::FindParameters params;
|
|
params.setTrack(trackId);
|
|
params.setImageTypes({ db::ImageType::Media });
|
|
params.setSortMethod(db::TrackEmbeddedImageSortMethod::SizeDesc);
|
|
params.setRange(db::Range{ .offset = 0, .size = 1 });
|
|
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
|
|
}
|
|
|
|
if (isImageFound(res))
|
|
return res;
|
|
|
|
// fallback on another track of the same disc
|
|
if (const db::Track::pointer track{ db::Track::find(session, trackId) })
|
|
{
|
|
const db::ReleaseId releaseId{ track->getReleaseId() };
|
|
if (releaseId.isValid())
|
|
{
|
|
db::TrackEmbeddedImage::FindParameters params;
|
|
params.setRelease(releaseId);
|
|
params.setDiscNumber(track->getDiscNumber());
|
|
params.setImageTypes({ db::ImageType::Media });
|
|
params.setSortMethod(db::TrackEmbeddedImageSortMethod::TrackNumberThenSizeDesc);
|
|
params.setRange(db::Range{ .offset = 0, .size = 1 });
|
|
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
if (const db::ImageId imageId{ release->getImageId() }; imageId.isValid())
|
|
res = imageId;
|
|
|
|
if (isImageFound(res))
|
|
return res;
|
|
|
|
// Fallback on embedded Front image
|
|
{
|
|
db::TrackEmbeddedImage::FindParameters params;
|
|
params.setRelease(releaseId);
|
|
params.setImageTypes({ db::ImageType::FrontCover });
|
|
params.setSortMethod(db::TrackEmbeddedImageSortMethod::DiscNumberThenTrackNumberThenSizeDesc);
|
|
params.setRange(db::Range{ .offset = 0, .size = 1 });
|
|
|
|
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
|
|
}
|
|
|
|
if (isImageFound(res))
|
|
return res;
|
|
|
|
// Fallback on embedded media image
|
|
{
|
|
db::TrackEmbeddedImage::FindParameters params;
|
|
params.setRelease(releaseId);
|
|
params.setImageTypes({ db::ImageType::Media });
|
|
params.setSortMethod(db::TrackEmbeddedImageSortMethod::DiscNumberThenTrackNumberThenSizeDesc);
|
|
params.setRange(db::Range{ .offset = 0, .size = 1 });
|
|
|
|
db::TrackEmbeddedImage::find(session, params, [&](const db::TrackEmbeddedImage::pointer& image) { res = image->getId(); });
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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();
|
|
}
|
|
|
|
cover = getFromImageFile(imageFile, width);
|
|
if (cover)
|
|
_cache.addImage(cacheEntryDesc, cover);
|
|
|
|
return cover;
|
|
}
|
|
|
|
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;
|
|
|
|
{
|
|
db::Session& session{ _db.getTLSSession() };
|
|
auto transaction{ session.createReadTransaction() };
|
|
|
|
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;
|
|
}
|
|
|
|
void ArtworkService::flushCache()
|
|
{
|
|
_cache.flush();
|
|
}
|
|
|
|
void ArtworkService::setJpegQuality(unsigned quality)
|
|
{
|
|
_jpegQuality = core::utils::clamp<unsigned>(quality, 1, 100);
|
|
|
|
LMS_LOG(COVER, INFO, "JPEG export quality = " << _jpegQuality);
|
|
}
|
|
} // namespace lms::artwork
|