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/musicbrainz/musicbrainzclient.cpp

525 lines
16 KiB
C++
Raw Permalink Blame History

/*
* Strawberry Music Player
* This file was part of Clementine.
* Copyright 2010, David Sansome <me@davidsansome.com>
* Copyright 2019-2021, 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 "config.h"
#include <algorithm>
#include <QObject>
#include <QSet>
#include <QList>
#include <QVariant>
#include <QString>
#include <QStringList>
#include <QUrl>
#include <QUrlQuery>
#include <QRegularExpression>
#include <QtAlgorithms>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QJsonParseError>
#include <QJsonDocument>
#include <QJsonObject>
#include <QXmlStreamReader>
#include <QTimer>
#include "core/logging.h"
#include "core/shared_ptr.h"
#include "core/networkaccessmanager.h"
#include "core/networktimeouts.h"
#include "utilities/xmlutils.h"
#include "musicbrainzclient.h"
namespace {
constexpr char kTrackUrl[] = "https://musicbrainz.org/ws/2/recording/";
constexpr char kDiscUrl[] = "https://musicbrainz.org/ws/2/discid/";
constexpr char kDateRegex[] = "^[12]\\d{3}";
constexpr int kRequestsDelay = 1200;
constexpr int kDefaultTimeout = 8000;
constexpr int kMaxRequestPerTrack = 3;
} // namespace
MusicBrainzClient::MusicBrainzClient(SharedPtr<NetworkAccessManager> network, QObject *parent)
: QObject(parent),
network_(network),
timeouts_(new NetworkTimeouts(kDefaultTimeout, this)),
timer_flush_requests_(new QTimer(this)) {
timer_flush_requests_->setInterval(kRequestsDelay);
timer_flush_requests_->setSingleShot(true);
QObject::connect(timer_flush_requests_, &QTimer::timeout, this, &MusicBrainzClient::FlushRequests);
}
MusicBrainzClient::~MusicBrainzClient() {
CancelAll();
}
QByteArray MusicBrainzClient::GetReplyData(QNetworkReply *reply, QString &error) {
QByteArray data;
if (reply->error() == QNetworkReply::NoError && reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt() == 200) {
data = reply->readAll();
}
else {
if (reply->error() != QNetworkReply::NoError && reply->error() < 200) {
// This is a network error, there is nothing more to do.
Error(QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error()));
}
else {
// See if there is Json data containing "error" - then use that instead.
data = reply->readAll();
QJsonParseError json_error;
QJsonDocument json_doc = QJsonDocument::fromJson(data, &json_error);
if (json_error.error == QJsonParseError::NoError && json_doc.isObject()) {
QJsonObject json_obj = json_doc.object();
if (!json_obj.isEmpty() && json_obj.contains(QStringLiteral("error"))) {
error = json_obj[QStringLiteral("error")].toString();
}
}
if (error.isEmpty()) {
if (reply->error() != QNetworkReply::NoError) {
error = QStringLiteral("%1 (%2)").arg(reply->errorString()).arg(reply->error());
}
else {
error = QStringLiteral("Received HTTP code %1").arg(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt());
}
Error(error, data);
}
else Error(error);
}
return QByteArray();
}
return data;
}
void MusicBrainzClient::Cancel(int id) {
while (!requests_.isEmpty() && requests_.contains(id)) {
QNetworkReply *reply = requests_.take(id);
QObject::disconnect(reply, nullptr, this, nullptr);
if (reply->isRunning()) reply->abort();
reply->deleteLater();
}
}
void MusicBrainzClient::CancelAll() {
qDeleteAll(requests_.values());
requests_.clear();
}
void MusicBrainzClient::Start(const int id, const QStringList &mbid_list) {
int request_number = 0;
for (const QString &mbid : mbid_list) {
++request_number;
if (request_number > kMaxRequestPerTrack) break;
Request request(id, mbid, request_number);
requests_pending_.insert(id, request);
}
if (!timer_flush_requests_->isActive()) {
timer_flush_requests_->start();
}
}
void MusicBrainzClient::StartDiscIdRequest(const QString &discid) {
const ParamList params = ParamList() << Param(QStringLiteral("inc"), QStringLiteral("artists+recordings"));
QUrlQuery url_query;
url_query.setQueryItems(params);
QUrl url(QString::fromLatin1(kDiscUrl) + discid);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
QNetworkReply *reply = network_->get(req);
QObject::connect(reply, &QNetworkReply::finished, this, [this, discid, reply]() { DiscIdRequestFinished(discid, reply); });
timeouts_->AddReply(reply);
}
void MusicBrainzClient::FlushRequests() {
if (!requests_.isEmpty() || requests_pending_.isEmpty()) return;
Request request = requests_pending_.take(requests_pending_.firstKey());
const ParamList params = ParamList() << Param(QStringLiteral("inc"), QStringLiteral("artists+releases+media"));
QUrlQuery url_query;
url_query.setQueryItems(params);
QUrl url(QString::fromLatin1(kTrackUrl) + request.mbid);
url.setQuery(url_query);
QNetworkRequest req(url);
req.setAttribute(QNetworkRequest::RedirectPolicyAttribute, QNetworkRequest::NoLessSafeRedirectPolicy);
QNetworkReply *reply = network_->get(req);
QObject::connect(reply, &QNetworkReply::finished, this, [this, reply, request]() { RequestFinished(reply, request.id, request.number); });
requests_.insert(request.id, reply);
timeouts_->AddReply(reply);
}
void MusicBrainzClient::RequestFinished(QNetworkReply *reply, const int id, const int request_number) {
QObject::disconnect(reply, nullptr, this, nullptr);
reply->deleteLater();
const qint64 nb_removed = requests_.remove(id, reply);
if (nb_removed != 1) {
qLog(Debug) << "MusicBrainz: Unknown reply received:" << nb_removed << "requests removed, while only one was supposed to be removed";
}
if (!timer_flush_requests_->isActive() && requests_.isEmpty() && !requests_pending_.isEmpty()) {
timer_flush_requests_->start();
}
QString error;
QByteArray data = GetReplyData(reply, error);
if (!data.isEmpty()) {
QXmlStreamReader reader(data);
ResultList res;
while (!reader.atEnd()) {
if (reader.readNext() == QXmlStreamReader::StartElement && reader.name().toString() == QStringLiteral("recording")) {
ResultList tracks = ParseTrack(&reader);
for (const Result &track : tracks) {
if (!track.title_.isEmpty()) {
res << track;
}
}
}
}
pending_results_[id] << PendingResults(request_number, res);
}
// No more pending requests for this id: emit the results we have.
if (!requests_.contains(id) && !requests_pending_.contains(id)) {
// Merge the results we have
ResultList ret;
QList<PendingResults> result_list_list = pending_results_.take(id);
std::sort(result_list_list.begin(), result_list_list.end());
for (const PendingResults &result_list : result_list_list) {
ret << result_list.results_;
}
emit Finished(id, UniqueResults(ret, UniqueResultsSortOption::KeepOriginalOrder), error);
}
}
void MusicBrainzClient::DiscIdRequestFinished(const QString &discid, QNetworkReply *reply) {
QObject::disconnect(reply, nullptr, this, nullptr);
reply->deleteLater();
ResultList ret;
QString artist;
QString album;
int year = 0;
QString error;
QByteArray data = GetReplyData(reply, error);
if (data.isEmpty()) {
emit DiscIdFinished(artist, album, ret, error);
return;
}
// Parse xml result:
// -get title
// -get artist
// -get year
// -get all the tracks' tags
// Note: If there are multiple releases for the discid, the first
// release is chosen.
QXmlStreamReader reader(data);
while (!reader.atEnd()) {
QXmlStreamReader::TokenType type = reader.readNext();
if (type == QXmlStreamReader::StartElement) {
QString name = reader.name().toString();
if (name == QStringLiteral("title")) {
album = reader.readElementText();
}
else if (name == QStringLiteral("date")) {
QRegularExpression regex(QString::fromLatin1(kDateRegex));
QRegularExpressionMatch re_match = regex.match(reader.readElementText());
if (re_match.capturedStart() == 0) {
year = re_match.captured(0).toInt();
}
}
else if (name == QStringLiteral("artist-credit")) {
ParseArtist(&reader, &artist);
}
else if (name == QStringLiteral("medium-list")) {
break;
}
}
}
while (!reader.atEnd()) {
QXmlStreamReader::TokenType token = reader.readNext();
QString name = reader.name().toString();
if (token == QXmlStreamReader::StartElement && name == QStringLiteral("medium")) {
// Get the medium with a matching discid.
if (MediumHasDiscid(discid, &reader)) {
ResultList tracks = ParseMedium(&reader);
for (const Result &track : tracks) {
if (!track.title_.isEmpty()) {
ret << track;
}
}
}
else {
Utilities::ConsumeCurrentElement(&reader);
}
}
else if (token == QXmlStreamReader::EndElement && name == QStringLiteral("medium-list")) {
break;
}
}
// If we parsed a year, copy it to the tracks.
if (year > 0) {
for (ResultList::iterator it = ret.begin(); it != ret.end(); ++it) {
it->year_ = year;
}
}
emit DiscIdFinished(artist, album, UniqueResults(ret, UniqueResultsSortOption::SortResults));
}
bool MusicBrainzClient::MediumHasDiscid(const QString &discid, QXmlStreamReader *reader) {
while (!reader->atEnd()) {
QXmlStreamReader::TokenType type = reader->readNext();
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement && name == QStringLiteral("disc") && reader->attributes().value(QStringLiteral("id")).toString() == discid) {
return true;
}
else if (type == QXmlStreamReader::EndElement && name == QStringLiteral("disc-list")) {
return false;
}
}
qLog(Debug) << "Reached end of xml stream without encountering </disc-list>";
return false;
}
MusicBrainzClient::ResultList MusicBrainzClient::ParseMedium(QXmlStreamReader *reader) {
ResultList ret;
while (!reader->atEnd()) {
QXmlStreamReader::TokenType type = reader->readNext();
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("track")) {
Result result;
result = ParseTrackFromDisc(reader);
ret << result;
}
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("track-list")) {
break;
}
}
return ret;
}
MusicBrainzClient::Result MusicBrainzClient::ParseTrackFromDisc(QXmlStreamReader *reader) {
Result result;
while (!reader->atEnd()) {
QXmlStreamReader::TokenType type = reader->readNext();
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("position")) {
result.track_ = reader->readElementText().toInt();
}
else if (name == QStringLiteral("length")) {
result.duration_msec_ = reader->readElementText().toInt();
}
else if (name == QStringLiteral("title")) {
result.title_ = reader->readElementText();
}
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("track")) {
break;
}
}
return result;
}
MusicBrainzClient::ResultList MusicBrainzClient::ParseTrack(QXmlStreamReader *reader) {
Result result;
QList<Release> releases;
while (!reader->atEnd()) {
QXmlStreamReader::TokenType type = reader->readNext();
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("title")) {
result.title_ = reader->readElementText();
}
else if (name == QStringLiteral("length")) {
result.duration_msec_ = reader->readElementText().toInt();
}
else if (name == QStringLiteral("artist-credit")) {
ParseArtist(reader, &result.artist_);
}
else if (name == QStringLiteral("release")) {
releases << ParseRelease(reader);
}
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("recording")) {
break;
}
}
ResultList ret;
if (releases.isEmpty()) {
ret << result;
}
else {
std::stable_sort(releases.begin(), releases.end());
ret.reserve(releases.count());
for (const Release &release : releases) {
ret << release.CopyAndMergeInto(result);
}
}
return ret;
}
// Parse the artist. Multiple artists are joined together with the joinphrase from musicbrainz.
void MusicBrainzClient::ParseArtist(QXmlStreamReader *reader, QString *artist) {
QString join_phrase;
while (!reader->atEnd()) {
QXmlStreamReader::TokenType type = reader->readNext();
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement && name == QStringLiteral("name-credit")) {
join_phrase = reader->attributes().value(QStringLiteral("joinphrase")).toString();
}
if (type == QXmlStreamReader::StartElement && name == QStringLiteral("name")) {
*artist += reader->readElementText() + join_phrase;
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("artist-credit")) {
return;
}
}
}
MusicBrainzClient::Release MusicBrainzClient::ParseRelease(QXmlStreamReader *reader) {
Release ret;
while (!reader->atEnd()) {
QXmlStreamReader::TokenType type = reader->readNext();
QString name = reader->name().toString();
if (type == QXmlStreamReader::StartElement) {
if (name == QStringLiteral("title")) {
ret.album_ = reader->readElementText();
}
else if (name == QStringLiteral("status")) {
ret.SetStatusFromString(reader->readElementText());
}
else if (name == QStringLiteral("date")) {
QRegularExpression regex(QString::fromLatin1(kDateRegex));
QRegularExpressionMatch re_match = regex.match(reader->readElementText());
if (re_match.capturedStart() == 0) {
ret.year_ = re_match.captured(0).toInt();
}
}
else if (name == QStringLiteral("track-list")) {
ret.track_ = reader->attributes().value(QStringLiteral("offset")).toString().toInt() + 1;
Utilities::ConsumeCurrentElement(reader);
}
}
if (type == QXmlStreamReader::EndElement && name == QStringLiteral("release")) {
break;
}
}
return ret;
}
MusicBrainzClient::ResultList MusicBrainzClient::UniqueResults(const ResultList &results, UniqueResultsSortOption opt) {
ResultList ret;
if (opt == UniqueResultsSortOption::SortResults) {
#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
ret = QSet<Result>(results.begin(), results.end()).values();
#else
ret = QSet<Result>::fromList(results).values();
#endif
std::sort(ret.begin(), ret.end());
}
else { // KeepOriginalOrder
// Qt doesn't provide an ordered set (QSet "stores values in an unspecified order" according to Qt documentation).
// We might use std::set instead, but it's probably faster to use ResultList directly to avoid converting from one structure to another.
for (const Result &res : results) {
if (!ret.contains(res)) {
ret << res;
}
}
}
return ret;
}
void MusicBrainzClient::Error(const QString &error, const QVariant &debug) {
qLog(Error) << "MusicBrainz:" << error;
if (debug.isValid()) qLog(Debug) << debug;
}
Reference in New Issue View Git Blame Copy Permalink