Check if QNetworkRequest::ContentTypeHeader is filetype everwhere

src/core/utilities.cpp

@@ -64,6 +64,7 @@
 #include <QtEvents>
 #include <QMessageBox>
 #include <QNetworkInterface>
+#include <QImageReader>
 #include <QtDebug>
 #if QT_VERSION >= QT_VERSION_CHECK(5, 10, 0)
 #  include <QRandomGenerator>
@@ -108,6 +109,9 @@
 
 namespace Utilities {
 
+QStringList kSupportedImageMimeTypes;
+QStringList kSupportedImageFormats;
+
 static QString tr(const char *str) {
   return QCoreApplication::translate("", str);
 }
@@ -1024,13 +1028,41 @@ bool IsColorDark(const QColor &color) {
   return ((30 * color.red() + 59 * color.green() + 11 * color.blue()) / 100) <= 130;
 }
 
+QStringList SupportedImageMimeTypes() {
+
+  if (kSupportedImageMimeTypes.isEmpty()) {
+    for (const QByteArray &mimetype : QImageReader::supportedMimeTypes()) {
+      kSupportedImageMimeTypes << mimetype;
+    }
+  }
+
+  return kSupportedImageMimeTypes;
+
+}
+
+QStringList SupportedImageFormats() {
+
+  if (kSupportedImageFormats.isEmpty()) {
+    for (const QByteArray &filetype : QImageReader::supportedImageFormats()) {
+      kSupportedImageFormats << filetype;
+    }
+  }
+
+  return kSupportedImageFormats;
+
+}
+
 QList<QByteArray> ImageFormatsForMimeType(const QByteArray &mimetype) {
 
+#if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
+  return QImageReader::imageFormatsForMimeType(mimetype);
+#else
   if (mimetype == "image/bmp") return QList<QByteArray>() << "BMP";
   else if (mimetype == "image/gif") return QList<QByteArray>() << "GIF";
   else if (mimetype == "image/jpeg") return QList<QByteArray>() << "JPG";
   else if (mimetype == "image/png") return QList<QByteArray>() << "PNG";
   else return QList<QByteArray>();
+#endif
 
 }
 

src/core/utilities.h

@@ -158,6 +158,8 @@ QString ReplaceVariable(const QString &variable, const Song &song, const QString
 
 bool IsColorDark(const QColor &color);
 
+QStringList SupportedImageMimeTypes();
+QStringList SupportedImageFormats();
 QList<QByteArray> ImageFormatsForMimeType(const QByteArray &mimetype);
 
 }  // namespace

src/covermanager/albumcoverfetchersearch.cpp

@@ -40,6 +40,7 @@
 #include <QtDebug>
 
 #include "core/logging.h"
+#include "core/utilities.h"
 #include "core/networktimeouts.h"
 #include "albumcoverfetcher.h"
 #include "albumcoverfetchersearch.h"
@@ -325,7 +326,7 @@ void AlbumCoverFetcherSearch::ProviderCoverFetchFinished(QNetworkReply *reply) {
   }
   else {
     QString mimetype = reply->header(QNetworkRequest::ContentTypeHeader).toString();
-    if (QImageReader::supportedMimeTypes().contains(mimetype.toUtf8())) {
+    if (Utilities::SupportedImageMimeTypes().contains(mimetype, Qt::CaseInsensitive) || Utilities::SupportedImageFormats().contains(mimetype, Qt::CaseInsensitive)) {
       QImage image;
       if (image.loadFromData(reply->readAll())) {
         if (result.image_size != QSize(0,0) && result.image_size != image.size()) {

src/qobuz/qobuzrequest.cpp

@@ -1220,7 +1220,7 @@ void QobuzRequest::AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_ur
 
   if (reply->error() != QNetworkReply::NoError) {
     Error(QString("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
-    album_covers_requests_sent_.remove(cover_url);
+    if (album_covers_requests_sent_.contains(cover_url)) album_covers_requests_sent_.remove(cover_url);
     AlbumCoverFinishCheck();
     return;
   }
@@ -1233,27 +1233,29 @@ void QobuzRequest::AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_ur
   }
 
   QString mimetype = reply->header(QNetworkRequest::ContentTypeHeader).toString();
-  if (!QImageReader::supportedMimeTypes().contains(mimetype.toUtf8())) {
+  if (!Utilities::SupportedImageMimeTypes().contains(mimetype, Qt::CaseInsensitive) && !Utilities::SupportedImageFormats().contains(mimetype, Qt::CaseInsensitive)) {
     Error(QString("Unsupported mimetype for image reader %1 for %2").arg(mimetype).arg(cover_url.toString()));
     if (album_covers_requests_sent_.contains(cover_url)) album_covers_requests_sent_.remove(cover_url);
     AlbumCoverFinishCheck();
     return;
   }
 
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
-  QList<QByteArray> format_list = QImageReader::imageFormatsForMimeType(mimetype.toUtf8());
-#else
-  QList<QByteArray> format_list = Utilities::ImageFormatsForMimeType(mimetype.toUtf8());
-#endif
-
   QByteArray data = reply->readAll();
-  if (format_list.isEmpty() || data.isEmpty()) {
+  if (data.isEmpty()) {
     Error(QString("Received empty image data for %1").arg(cover_url.toString()));
-    album_covers_requests_sent_.remove(cover_url);
+    if (album_covers_requests_sent_.contains(cover_url)) album_covers_requests_sent_.remove(cover_url);
     AlbumCoverFinishCheck();
     return;
   }
-  QByteArray format = format_list.first();
+
+  QList<QByteArray> format_list = Utilities::ImageFormatsForMimeType(mimetype.toUtf8());
+  QByteArray format;
+  if (format_list.isEmpty()) {
+    format = "JPG";
+  }
+  else {
+    format = format_list.first();
+  }
 
   QImage image;
   if (image.loadFromData(data, format)) {
@@ -1263,10 +1265,13 @@ void QobuzRequest::AlbumCoverReceived(QNetworkReply *reply, const QUrl &cover_ur
         song->set_art_automatic(QUrl::fromLocalFile(filename));
       }
     }
-
+    else {
+      Error(QString("Error saving image data to %1").arg(filename));
+      if (album_covers_requests_sent_.contains(cover_url)) album_covers_requests_sent_.remove(cover_url);
+    }
   }
   else {
-    album_covers_requests_sent_.remove(cover_url);
+    if (album_covers_requests_sent_.contains(cover_url)) album_covers_requests_sent_.remove(cover_url);
     Error(QString("Error decoding image data from %1").arg(cover_url.toString()));
   }
 

src/subsonic/subsonicrequest.cpp

@@ -57,9 +57,6 @@ const int SubsonicRequest::kMaxConcurrentAlbumsRequests = 3;
 const int SubsonicRequest::kMaxConcurrentAlbumSongsRequests = 3;
 const int SubsonicRequest::kMaxConcurrentAlbumCoverRequests = 1;
 
-QStringList SubsonicRequest::kSupportedImageMimeTypes;
-QStringList SubsonicRequest::kSupportedImageFormats;
-
 SubsonicRequest::SubsonicRequest(SubsonicService *service, SubsonicUrlHandler *url_handler, Application *app, QObject *parent)
     : SubsonicBaseRequest(service, parent),
       service_(service),
@@ -81,14 +78,6 @@ SubsonicRequest::SubsonicRequest(SubsonicService *service, SubsonicUrlHandler *u
   network_->setRedirectPolicy(QNetworkRequest::NoLessSafeRedirectPolicy);
 #endif
 
-  for (const QByteArray &mimetype : QImageReader::supportedMimeTypes()) {
-    kSupportedImageMimeTypes.append(QString::fromUtf8(mimetype));
-  }
-
-  for (const QByteArray &filetype : QImageReader::supportedImageFormats()) {
-    kSupportedImageFormats.append(filetype);
-  }
-
 }
 
 SubsonicRequest::~SubsonicRequest() {
@@ -799,7 +788,7 @@ void SubsonicRequest::AlbumCoverReceived(QNetworkReply *reply, const QUrl url, c
   }
 
   QString mimetype = reply->header(QNetworkRequest::ContentTypeHeader).toString();
-  if (!kSupportedImageMimeTypes.contains(mimetype, Qt::CaseInsensitive) && !kSupportedImageFormats.contains(mimetype, Qt::CaseInsensitive)) {
+  if (!Utilities::SupportedImageMimeTypes().contains(mimetype, Qt::CaseInsensitive) && !Utilities::SupportedImageFormats().contains(mimetype, Qt::CaseInsensitive)) {
     Error(QString("Unsupported mimetype for image reader %1 for %2").arg(mimetype).arg(url.toString()));
     if (album_covers_requests_sent_.contains(url)) album_covers_requests_sent_.remove(url);
     AlbumCoverFinishCheck();

src/subsonic/subsonicrequest.h

@@ -115,8 +115,6 @@ class SubsonicRequest : public SubsonicBaseRequest {
   static const int kMaxConcurrentArtistAlbumsRequests;
   static const int kMaxConcurrentAlbumSongsRequests;
   static const int kMaxConcurrentAlbumCoverRequests;
-  static QStringList kSupportedImageMimeTypes;
-  static QStringList kSupportedImageFormats;
 
   SubsonicService *service_;
   SubsonicUrlHandler *url_handler_;

src/tidal/tidalrequest.cpp

@@ -1170,27 +1170,29 @@ void TidalRequest::AlbumCoverReceived(QNetworkReply *reply, const QString &album
   }
 
   QString mimetype = reply->header(QNetworkRequest::ContentTypeHeader).toString();
-  if (!QImageReader::supportedMimeTypes().contains(mimetype.toUtf8())) {
+  if (!Utilities::SupportedImageMimeTypes().contains(mimetype, Qt::CaseInsensitive) && !Utilities::SupportedImageFormats().contains(mimetype, Qt::CaseInsensitive)) {
     Error(QString("Unsupported mimetype for image reader %1 for %2").arg(mimetype).arg(url.toString()));
     if (album_covers_requests_sent_.contains(album_id)) album_covers_requests_sent_.remove(album_id);
     AlbumCoverFinishCheck();
     return;
   }
 
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 12, 0))
-  QList<QByteArray> format_list = QImageReader::imageFormatsForMimeType(mimetype.toUtf8());
-#else
-  QList<QByteArray> format_list = Utilities::ImageFormatsForMimeType(mimetype.toUtf8());
-#endif
-
   QByteArray data = reply->readAll();
-  if (format_list.isEmpty() || data.isEmpty()) {
+  if (data.isEmpty()) {
     Error(QString("Received empty image data for %1").arg(url.toString()));
     if (album_covers_requests_sent_.contains(album_id)) album_covers_requests_sent_.remove(album_id);
     AlbumCoverFinishCheck();
     return;
   }
-  QByteArray format = format_list.first();
+
+  QList<QByteArray> format_list = Utilities::ImageFormatsForMimeType(mimetype.toUtf8());
+  QByteArray format;
+  if (format_list.isEmpty()) {
+    format = "JPG";
+  }
+  else {
+    format = format_list.first();
+  }
 
   QImage image;
   if (image.loadFromData(data, format)) {