Funkwhale
/
strawberry-audio-player-windows-mac-linux
mirror of https://github.com/strawberrymusicplayer/strawberry
1
0
Fork 0
Code Issues Releases Wiki Activity
strawberry-audio-player-win.../src/covermanager/albumcoverloader.cpp

421 lines
13 KiB
C++
Raw Blame History

/*
* Strawberry Music Player
* Copyright 2019-2023, Jonas Kvinge <jonas@jkvinge.net>
*
* Strawberry 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.
*
* Strawberry 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 Strawberry. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include <memory>
#include <QtGlobal>
#include <QObject>
#include <QThread>
#include <QMutex>
#include <QSet>
#include <QQueue>
#include <QVariant>
#include <QByteArray>
#include <QString>
#include <QUrl>
#include <QFile>
#include <QImage>
#include <QNetworkReply>
#include <QNetworkRequest>
#include "core/networkaccessmanager.h"
#include "core/song.h"
#include "core/tagreaderclient.h"
#include "utilities/mimeutils.h"
#include "utilities/imageutils.h"
#include "albumcoverloader.h"
#include "albumcoverloaderoptions.h"
#include "albumcoverloaderresult.h"
#include "albumcoverimageresult.h"
using std::make_shared;
AlbumCoverLoader::AlbumCoverLoader(QObject *parent)
: QObject(parent),
network_(new NetworkAccessManager(this)),
stop_requested_(false),
load_image_async_id_(1),
original_thread_(nullptr) {
original_thread_ = thread();
}
void AlbumCoverLoader::ExitAsync() {
stop_requested_ = true;
QMetaObject::invokeMethod(this, &AlbumCoverLoader::Exit, Qt::QueuedConnection);
}
void AlbumCoverLoader::Exit() {
Q_ASSERT(QThread::currentThread() == thread());
moveToThread(original_thread_);
emit ExitFinished();
}
void AlbumCoverLoader::CancelTask(const quint64 id) {
QMutexLocker l(&mutex_load_image_async_);
for (QQueue<TaskPtr>::iterator it = tasks_.begin(); it != tasks_.end(); ++it) {
TaskPtr task = *it;
if (task->id == id) {
tasks_.erase(it);
break;
}
}
}
void AlbumCoverLoader::CancelTasks(const QSet<quint64> &ids) {
QMutexLocker l(&mutex_load_image_async_);
for (QQueue<TaskPtr>::iterator it = tasks_.begin(); it != tasks_.end();) {
TaskPtr task = *it;
if (ids.contains(task->id)) {
it = tasks_.erase(it);
}
else {
++it;
}
}
}
quint64 AlbumCoverLoader::LoadImageAsync(const AlbumCoverLoaderOptions &options, const Song &song) {
TaskPtr task = make_shared<Task>();
task->options = options;
task->art_embedded = song.art_embedded();
task->art_automatic = song.art_automatic();
task->art_manual = song.art_manual();
task->art_unset = song.art_unset();
task->song_source = song.source();
task->song_url = song.url();
task->song = song;
return EnqueueTask(task);
}
quint64 AlbumCoverLoader::LoadImageAsync(const AlbumCoverLoaderOptions &options, const bool art_embedded, const QUrl &art_automatic, const QUrl &art_manual, const bool art_unset, const QUrl &song_url, const Song::Source song_source) {
TaskPtr task = make_shared<Task>();
task->options = options;
task->art_embedded = art_embedded;
task->art_automatic = art_automatic;
task->art_manual = art_manual;
task->art_unset = art_unset;
task->song_source = song_source;
task->song_url = song_url;
return EnqueueTask(task);
}
quint64 AlbumCoverLoader::LoadImageAsync(const AlbumCoverLoaderOptions &options, const AlbumCoverImageResult &album_cover) {
TaskPtr task = make_shared<Task>();
task->options = options;
task->album_cover = album_cover;
return EnqueueTask(task);
}
quint64 AlbumCoverLoader::LoadImageAsync(const AlbumCoverLoaderOptions &options, const QImage &image) {
TaskPtr task = make_shared<Task>();
task->options = options;
task->album_cover.image = image;
return EnqueueTask(task);
}
quint64 AlbumCoverLoader::EnqueueTask(TaskPtr task) {
{
QMutexLocker l(&mutex_load_image_async_);
task->id = load_image_async_id_++;
tasks_.enqueue(task);
}
QMetaObject::invokeMethod(this, &AlbumCoverLoader::ProcessTasks, Qt::QueuedConnection);
return task->id;
}
void AlbumCoverLoader::ProcessTasks() {
TaskPtr task;
{
QMutexLocker l(&mutex_load_image_async_);
if (tasks_.isEmpty()) return;
task = tasks_.dequeue();
}
ProcessTask(task);
}
void AlbumCoverLoader::ProcessTask(TaskPtr task) {
// If we have album cover already, only do scale and pad.
if (task->album_cover.is_valid()) {
task->success = true;
}
else {
InitArt(task);
}
while (!task->success && !task->options.types.isEmpty()) {
const AlbumCoverLoaderOptions::Type type = task->options.types.takeFirst();
const LoadImageResult result = LoadImage(task, type);
if (result.status == LoadImageResult::Status::Async) {
// The image is being loaded from a remote URL, we'll carry on later when it's done.
return;
}
if (result.status == LoadImageResult::Status::Success) {
task->success = true;
task->result_type = result.type;
break;
}
}
if (!task->success && !task->options.default_cover.isEmpty()) {
LoadLocalFileImage(task, AlbumCoverLoaderResult::Type::None, task->options.default_cover);
}
FinishTask(task, task->result_type);
}
void AlbumCoverLoader::FinishTask(TaskPtr task, const AlbumCoverLoaderResult::Type result_type) {
QImage image_scaled;
if (!task->album_cover.image_data.isEmpty() && !task->album_cover.image.isNull()) {
task->result_type = result_type;
task->album_cover.mime_type = Utilities::MimeTypeFromData(task->album_cover.image_data);
if (task->scaled_image()) {
image_scaled = ImageUtils::ScaleImage(task->album_cover.image, task->options.desired_scaled_size, task->options.device_pixel_ratio, task->pad_scaled_image());
}
if (!task->raw_image_data() && !task->album_cover.image_data.isNull()) {
task->album_cover.image_data = QByteArray();
}
if (!task->original_image() && !task->album_cover.image.isNull()) {
task->album_cover.image = QImage();
}
}
emit AlbumCoverLoaded(task->id, AlbumCoverLoaderResult(task->success, task->result_type, task->album_cover, image_scaled, task->art_manual_updated, task->art_automatic_updated));
}
void AlbumCoverLoader::InitArt(TaskPtr task) {
// For local files and streams initialize art if found.
if (task->song.is_valid() && (task->song.source() == Song::Source::LocalFile || task->song.is_radio()) && !task->song.art_manual_is_valid() && !task->song.art_automatic_is_valid()) {
task->song.InitArtManual();
if (task->song.art_manual_is_valid()) {
task->art_manual_updated = task->song.art_manual();
task->art_manual = task->song.art_manual();
}
if (task->song.url().isLocalFile()) {
task->song.InitArtAutomatic();
if (task->song.art_automatic_is_valid()) {
task->art_automatic_updated = task->song.art_automatic();
task->art_automatic = task->song.art_automatic();
}
}
}
}
AlbumCoverLoader::LoadImageResult AlbumCoverLoader::LoadImage(TaskPtr task, const AlbumCoverLoaderOptions::Type &type) {
switch (type) {
case AlbumCoverLoaderOptions::Type::Unset:{
if (task->art_unset) {
if (!task->options.default_cover.isEmpty()) {
return LoadLocalFileImage(task, AlbumCoverLoaderResult::Type::Unset, task->options.default_cover);
}
return LoadImageResult(AlbumCoverLoaderResult::Type::Unset, LoadImageResult::Status::Success);
}
break;
}
case AlbumCoverLoaderOptions::Type::Embedded:{
if (task->art_embedded && task->song_url.isValid() && task->song_url.isLocalFile()) {
return LoadEmbeddedImage(task);
}
break;
}
case AlbumCoverLoaderOptions::Type::Automatic:{
if (task->art_automatic.isValid()) {
return LoadUrlImage(task, AlbumCoverLoaderResult::Type::Automatic, task->art_automatic);
}
break;
}
case AlbumCoverLoaderOptions::Type::Manual:{
if (task->art_manual.isValid()) {
return LoadUrlImage(task, AlbumCoverLoaderResult::Type::Manual, task->art_manual);
}
break;
}
}
return LoadImageResult();
}
AlbumCoverLoader::LoadImageResult AlbumCoverLoader::LoadEmbeddedImage(TaskPtr task) {
if (task->art_embedded && task->song_url.isValid() && task->song_url.isLocalFile()) {
task->album_cover.image_data = TagReaderClient::Instance()->LoadEmbeddedArtBlocking(task->song_url.toLocalFile());
if (!task->album_cover.image_data.isEmpty() && task->album_cover.image.loadFromData(task->album_cover.image_data)) {
return LoadImageResult(AlbumCoverLoaderResult::Type::Embedded, LoadImageResult::Status::Success);
}
}
return LoadImageResult(AlbumCoverLoaderResult::Type::Embedded, LoadImageResult::Status::Failure);
}
AlbumCoverLoader::LoadImageResult AlbumCoverLoader::LoadUrlImage(TaskPtr task, const AlbumCoverLoaderResult::Type result_type, const QUrl &cover_url) {
if (cover_url.isValid()) {
if (cover_url.isLocalFile()) {
return LoadLocalUrlImage(task, result_type, cover_url);
}
else if (network_->supportedSchemes().contains(cover_url.scheme())) {
return LoadRemoteUrlImage(task, result_type, cover_url);
}
}
return LoadImageResult(result_type, LoadImageResult::Status::Failure);
}
AlbumCoverLoader::LoadImageResult AlbumCoverLoader::LoadLocalUrlImage(TaskPtr task, const AlbumCoverLoaderResult::Type result_type, const QUrl &cover_url) {
if (cover_url.isEmpty()) {
return LoadImageResult(result_type, LoadImageResult::Status::Failure);
}
if (!cover_url.isValid()) {
return LoadImageResult(result_type, LoadImageResult::Status::Failure);
}
if (!cover_url.isLocalFile()) {
return LoadImageResult(result_type, LoadImageResult::Status::Failure);
}
return LoadLocalFileImage(task, result_type, cover_url.toLocalFile());
}
AlbumCoverLoader::LoadImageResult AlbumCoverLoader::LoadLocalFileImage(TaskPtr task, const AlbumCoverLoaderResult::Type result_type, const QString &cover_file) {
if (!QFileInfo::exists(cover_file)) {
qLog(Error) << "Cover file" << cover_file << "does not exist.";
return LoadImageResult(result_type, LoadImageResult::Status::Failure);
}
QFile file(cover_file);
if (!file.open(QIODevice::ReadOnly)) {
qLog(Error) << "Unable to open cover file" << cover_file << "for reading:" << file.errorString();
return LoadImageResult(result_type, LoadImageResult::Status::Failure);
}
task->album_cover.image_data = file.readAll();
file.close();
if (task->album_cover.image_data.isEmpty()) {
qLog(Error) << "Cover file" << cover_file << "is empty.";
return LoadImageResult(result_type, LoadImageResult::Status::Failure);
}
if (!task->album_cover.image.loadFromData(task->album_cover.image_data)) {
qLog(Error) << "Failed to load image from cover file" << cover_file << ":" << file.errorString();
return LoadImageResult(result_type, LoadImageResult::Status::Failure);
}
return LoadImageResult(result_type, LoadImageResult::Status::Success);
}
AlbumCoverLoader::LoadImageResult AlbumCoverLoader::LoadRemoteUrlImage(TaskPtr task, const AlbumCoverLoaderResult::Type result_type, const QUrl &cover_url) {
qLog(Debug) << "Loading remote cover from URL" << cover_url;
QNetworkRequest request(cover_url);
request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
QNetworkReply *reply = network_->get(request);
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, task, result_type, cover_url]() { LoadRemoteImageFinished(reply, task, result_type, cover_url); });
return LoadImageResult(result_type, LoadImageResult::Status::Async);
}
void AlbumCoverLoader::LoadRemoteImageFinished(QNetworkReply *reply, TaskPtr task, const AlbumCoverLoaderResult::Type result_type, const QUrl &cover_url) {
reply->deleteLater();
QVariant redirect = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
if (redirect.isValid() && redirect.metaType().id() == QMetaType::QUrl) {
#else
if (redirect.isValid() && redirect.type() == QVariant::Url) {
#endif
if (task->redirects++ >= kMaxRedirects) {
ProcessTask(task);
return;
}
const QUrl redirect_url = redirect.toUrl();
qLog(Debug) << "Loading remote cover from redirected URL" << redirect_url;
QNetworkRequest request = reply->request();
request.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
request.setUrl(redirect_url);
QNetworkReply *redirected_reply = network_->get(request);
QObject::connect(redirected_reply, &QNetworkReply::finished, this, [this, reply, task, result_type, redirect_url]() { LoadRemoteImageFinished(reply, task, result_type, redirect_url); });
return;
}
if (reply->error() == QNetworkReply::NoError) {
task->album_cover.image_data = reply->readAll();
if (!task->album_cover.image_data.isEmpty() && task->album_cover.image.loadFromData(task->album_cover.image_data)) {
task->success = true;
FinishTask(task, result_type);
return;
}
else {
qLog(Error) << "Unable to load album cover image from URL" << cover_url;
}
}
else {
qLog(Error) << "Unable to get album cover from URL" << cover_url << reply->error() << reply->errorString();
}
ProcessTask(task);
}
Reference in New Issue View Git Blame Copy Permalink