313 lines
14 KiB
C++
313 lines
14 KiB
C++
#include "./musicbrainz.h"
|
|
|
|
#include "../application/settings.h"
|
|
#include "../misc/networkaccessmanager.h"
|
|
#include "../misc/utility.h"
|
|
|
|
#include <QNetworkReply>
|
|
#include <QNetworkRequest>
|
|
#include <QStringBuilder>
|
|
#include <QUrlQuery>
|
|
#include <QXmlStreamReader>
|
|
|
|
#include <algorithm>
|
|
#include <functional>
|
|
#include <map>
|
|
#include <unordered_map>
|
|
#include <vector>
|
|
|
|
using namespace std;
|
|
using namespace std::placeholders;
|
|
using namespace Utility;
|
|
|
|
#if (QT_VERSION < QT_VERSION_CHECK(5, 14, 0))
|
|
namespace std {
|
|
template <> struct hash<QString> {
|
|
std::size_t operator()(const QString &s) const
|
|
{
|
|
return qHash(s);
|
|
}
|
|
};
|
|
} // namespace std
|
|
#endif
|
|
|
|
namespace QtGui {
|
|
|
|
MusicBrainzResultsModel::MusicBrainzResultsModel(SongDescription &&initialSongDescription, QNetworkReply *reply)
|
|
: HttpResultsModel(std::move(initialSongDescription), reply)
|
|
{
|
|
}
|
|
|
|
bool MusicBrainzResultsModel::fetchCover(const QModelIndex &index)
|
|
{
|
|
if (index.parent().isValid() || !index.isValid() || index.row() >= m_results.size()) {
|
|
return true;
|
|
}
|
|
|
|
// skip if cover is already available
|
|
auto &desc = m_results[index.row()];
|
|
if (!desc.cover.isEmpty()) {
|
|
return true;
|
|
}
|
|
|
|
// fail if album ID is unknown
|
|
if (desc.albumId.isEmpty()) {
|
|
m_errorList << tr("Unable to fetch cover: Album ID unknown");
|
|
emit resultsAvailable();
|
|
return true;
|
|
}
|
|
|
|
// skip if the item belongs to an album which cover has already been fetched
|
|
const auto coverData = s_coverData.find(desc.albumId);
|
|
if (coverData != s_coverData.end()) {
|
|
desc.cover = coverData->second;
|
|
return true;
|
|
}
|
|
|
|
// request the cover art
|
|
auto *const reply = queryCoverArtArchive(desc.albumId);
|
|
addReply(reply, bind(&MusicBrainzResultsModel::handleCoverReplyFinished, this, reply, desc.albumId, index.row()));
|
|
setFetchingCover(true);
|
|
return false;
|
|
}
|
|
|
|
QUrl MusicBrainzResultsModel::webUrl(const QModelIndex &index)
|
|
{
|
|
if (index.parent().isValid() || !index.isValid() || index.row() >= m_results.size()) {
|
|
return QUrl();
|
|
}
|
|
return QUrl(QStringLiteral("https://musicbrainz.org/recording/") + m_results.at(index.row()).songId);
|
|
}
|
|
|
|
void MusicBrainzResultsModel::parseInitialResults(const QByteArray &data)
|
|
{
|
|
beginResetModel();
|
|
m_results.clear();
|
|
|
|
// store all song information (called recordings by MusicBrainz)
|
|
auto recordings = std::vector<SongDescription>();
|
|
// store all albums/collections (called releases by MusicBrainz) for a song
|
|
auto releasesByRecording = std::unordered_map<QString, std::vector<SongDescription>>();
|
|
|
|
// parse XML tree
|
|
auto xmlReader = QXmlStreamReader(data);
|
|
// clang-format off
|
|
#include <qtutilities/misc/xmlparsermacros.h>
|
|
children {
|
|
iftag("metadata") {
|
|
children {
|
|
iftag("recording-list") {
|
|
children {
|
|
iftag("recording") {
|
|
auto currentDescription = SongDescription(attribute("id").toString());
|
|
children {
|
|
iftag("title") {
|
|
currentDescription.title = text;
|
|
} eliftag("artist-credit") {
|
|
children {
|
|
iftag("name-credit") {
|
|
children {
|
|
iftag("artist") {
|
|
if (currentDescription.artistId.isEmpty()) {
|
|
currentDescription.artistId = attribute("id").toString();
|
|
}
|
|
children {
|
|
iftag("name") {
|
|
currentDescription.artist = text;
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
} eliftag("release-list") {
|
|
children {
|
|
iftag("release") {
|
|
auto releaseInfo = SongDescription();
|
|
releaseInfo.albumId = attribute("id").toString();
|
|
children {
|
|
iftag("title") {
|
|
releaseInfo.album = text;
|
|
} eliftag("artist-credit") {
|
|
children {
|
|
iftag("name-credit") {
|
|
children {
|
|
iftag("artist") {
|
|
if (currentDescription.artistId.isEmpty()) {
|
|
currentDescription.artistId = attribute("id").toString();
|
|
}
|
|
children {
|
|
iftag("name") {
|
|
currentDescription.artist = text;
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
} eliftag("date") {
|
|
releaseInfo.year = text;
|
|
} eliftag("medium-list") {
|
|
children {
|
|
iftag("medium") {
|
|
children {
|
|
iftag("position") {
|
|
releaseInfo.disk = text.toInt();
|
|
} eliftag("track-list") {
|
|
releaseInfo.totalTracks = attribute("count").toInt();
|
|
children {
|
|
iftag("track") {
|
|
children {
|
|
iftag("number") {
|
|
releaseInfo.track = text.toInt();
|
|
} else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
releasesByRecording[currentDescription.songId].emplace_back(std::move(releaseInfo));
|
|
}
|
|
else_skip
|
|
}
|
|
} eliftag("tag-list") {
|
|
children {
|
|
iftag("tag") {
|
|
children {
|
|
iftag("name") {
|
|
if (!currentDescription.genre.isEmpty()) {
|
|
currentDescription.genre.append(QStringLiteral(", "));
|
|
}
|
|
currentDescription.genre.append(text);
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
recordings.emplace_back(std::move(currentDescription));
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
}
|
|
else_skip
|
|
}
|
|
#include <qtutilities/misc/undefxmlparsermacros.h>
|
|
|
|
// populate results
|
|
// -> create a song for each recording/release combination and group those songs by their releases sorted ascendingly from oldest to latest
|
|
auto recordingsByRelease = std::map<QString, std::vector<SongDescription>>();
|
|
for (const auto &recording : recordings) {
|
|
const auto &releases = releasesByRecording[recording.songId];
|
|
for (const auto &release : releases) {
|
|
// make a copy of the recording/song information and add release/album specific information to it
|
|
SongDescription releaseSpecificRecording = recording;
|
|
if (!release.album.isEmpty()) {
|
|
releaseSpecificRecording.album = release.album;
|
|
releaseSpecificRecording.albumId = release.albumId;
|
|
}
|
|
if (!release.artist.isEmpty()) {
|
|
releaseSpecificRecording.artist = release.artist;
|
|
releaseSpecificRecording.artistId = release.artistId;
|
|
}
|
|
if (release.track) {
|
|
releaseSpecificRecording.track = release.track;
|
|
}
|
|
if (release.totalTracks) {
|
|
releaseSpecificRecording.totalTracks = release.totalTracks;
|
|
}
|
|
if (release.disk) {
|
|
releaseSpecificRecording.disk = release.disk;
|
|
}
|
|
if (!release.year.isEmpty()) {
|
|
releaseSpecificRecording.year = release.year;
|
|
}
|
|
recordingsByRelease[release.year % QChar('-') % release.albumId].emplace_back(std::move(releaseSpecificRecording));
|
|
}
|
|
}
|
|
// -> sort recordings within each release by track number and add recordings to results
|
|
for (auto &releaseAndRecordings : recordingsByRelease) {
|
|
auto &recordingsOfRelease = releaseAndRecordings.second;
|
|
std::sort(recordingsOfRelease.begin(), recordingsOfRelease.end(), [](const auto &recording1, const auto &recording2) {
|
|
if (recording1.disk != recording2.disk) {
|
|
return recording1.disk < recording2.disk;
|
|
}
|
|
return recording1.track < recording2.track;
|
|
});
|
|
for (auto &recording : recordingsOfRelease) {
|
|
m_results << std::move(recording);
|
|
}
|
|
}
|
|
|
|
// check for parsing errors
|
|
switch (xmlReader.error()) {
|
|
case QXmlStreamReader::NoError:
|
|
case QXmlStreamReader::PrematureEndOfDocumentError:
|
|
break;
|
|
default:
|
|
m_errorList << xmlReader.errorString();
|
|
}
|
|
|
|
endResetModel();
|
|
}
|
|
// clang-format on
|
|
|
|
QueryResultsModel *queryMusicBrainz(SongDescription &&songDescription)
|
|
{
|
|
static const auto defaultMusicBrainzUrl(QStringLiteral("https://musicbrainz.org/ws/2/recording/"));
|
|
|
|
auto parts = QStringList();
|
|
parts.reserve(4);
|
|
if (!songDescription.title.isEmpty()) {
|
|
parts << QChar('\"') % songDescription.title % QChar('\"');
|
|
}
|
|
if (!songDescription.artist.isEmpty()) {
|
|
parts << QStringLiteral("artist:\"") % songDescription.artist % QChar('\"');
|
|
}
|
|
if (!songDescription.album.isEmpty()) {
|
|
parts << QStringLiteral("release:\"") % songDescription.album % QChar('\"');
|
|
}
|
|
if (songDescription.track) {
|
|
parts << QStringLiteral("number:") + QString::number(songDescription.track);
|
|
}
|
|
|
|
const auto &musicBrainzUrl = Settings::values().dbQuery.musicBrainzUrl;
|
|
auto url = QUrl(musicBrainzUrl.isEmpty() ? defaultMusicBrainzUrl : (musicBrainzUrl + QStringLiteral("/recording/")));
|
|
auto query = QUrlQuery();
|
|
query.addQueryItem(QStringLiteral("query"), parts.join(QStringLiteral(" AND ")));
|
|
url.setQuery(query);
|
|
auto request = QNetworkRequest(url);
|
|
request.setHeader(QNetworkRequest::UserAgentHeader, QStringLiteral("Mozilla/5.0 (X11; Linux x86_64; rv:54.0) Gecko/20100101 Firefox/54.0"));
|
|
return new MusicBrainzResultsModel(std::move(songDescription), Utility::networkAccessManager().get(request));
|
|
}
|
|
|
|
QNetworkReply *queryCoverArtArchive(const QString &albumId)
|
|
{
|
|
static const auto defaultArchiveUrl(QStringLiteral("https://coverartarchive.org"));
|
|
const auto &coverArtArchiveUrl = Settings::values().dbQuery.coverArtArchiveUrl;
|
|
return networkAccessManager().get(QNetworkRequest(QUrl(
|
|
(coverArtArchiveUrl.isEmpty() ? defaultArchiveUrl : coverArtArchiveUrl) % QStringLiteral("/release/") % albumId % QStringLiteral("/front"))));
|
|
}
|
|
|
|
} // namespace QtGui
|