2018-02-27 18:06:05 +01:00
|
|
|
/*
|
|
|
|
* Strawberry Music Player
|
|
|
|
* This file was part of Clementine.
|
|
|
|
* Copyright 2010, David Sansome <me@davidsansome.com>
|
2018-09-08 12:38:02 +02:00
|
|
|
* Copyright 2018, Jonas Kvinge <jonas@jkvinge.net>
|
2018-02-27 18:06:05 +01:00
|
|
|
*
|
|
|
|
* 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/>.
|
2018-08-09 18:39:44 +02:00
|
|
|
*
|
2018-02-27 18:06:05 +01:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include "config.h"
|
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
#include "player.h"
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
#include <memory>
|
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
#include <QtGlobal>
|
|
|
|
#include <QObject>
|
2018-02-27 18:06:05 +01:00
|
|
|
#include <QSortFilterProxyModel>
|
2018-05-01 00:41:33 +02:00
|
|
|
#include <QList>
|
|
|
|
#include <QMap>
|
|
|
|
#include <QVariant>
|
|
|
|
#include <QString>
|
|
|
|
#include <QUrl>
|
|
|
|
#include <QDateTime>
|
|
|
|
#include <QSettings>
|
2018-02-27 18:06:05 +01:00
|
|
|
#include <QtDebug>
|
|
|
|
|
|
|
|
#include "core/logging.h"
|
2018-05-01 00:41:33 +02:00
|
|
|
|
|
|
|
#include "song.h"
|
|
|
|
#include "timeconstants.h"
|
|
|
|
#include "urlhandler.h"
|
|
|
|
#include "application.h"
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
#include "engine/enginebase.h"
|
2018-05-01 00:41:33 +02:00
|
|
|
#include "engine/enginetype.h"
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
#ifdef HAVE_GSTREAMER
|
|
|
|
# include "engine/gstengine.h"
|
2019-04-20 15:25:31 +02:00
|
|
|
# include "engine/gststartup.h"
|
2018-02-27 18:06:05 +01:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_XINE
|
|
|
|
# include "engine/xineengine.h"
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_PHONON
|
|
|
|
# include "engine/phononengine.h"
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_VLC
|
|
|
|
# include "engine/vlcengine.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "collection/collectionbackend.h"
|
|
|
|
#include "playlist/playlist.h"
|
|
|
|
#include "playlist/playlistitem.h"
|
|
|
|
#include "playlist/playlistmanager.h"
|
2018-05-01 00:41:33 +02:00
|
|
|
#include "playlist/playlistsequence.h"
|
2018-02-27 18:06:05 +01:00
|
|
|
#include "equalizer/equalizer.h"
|
2018-05-01 00:41:33 +02:00
|
|
|
#include "analyzer/analyzercontainer.h"
|
2018-02-27 18:06:05 +01:00
|
|
|
#include "settings/backendsettingspage.h"
|
|
|
|
#include "settings/behavioursettingspage.h"
|
|
|
|
#include "settings/playlistsettingspage.h"
|
2018-10-23 23:25:02 +02:00
|
|
|
#include "internet/internetservices.h"
|
2018-10-14 00:08:33 +02:00
|
|
|
#include "internet/internetservice.h"
|
2018-12-23 18:54:27 +01:00
|
|
|
#include "scrobbler/audioscrobbler.h"
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
using std::shared_ptr;
|
2019-04-20 15:25:31 +02:00
|
|
|
using std::unique_ptr;
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2019-03-09 16:48:45 +01:00
|
|
|
const char *Player::kSettingsGroup = "Player";
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
Player::Player(Application *app, QObject *parent)
|
|
|
|
: PlayerInterface(parent),
|
|
|
|
app_(app),
|
2019-04-20 15:25:31 +02:00
|
|
|
engine_(nullptr),
|
|
|
|
#ifdef HAVE_GSTREAMER
|
|
|
|
gst_startup_(new GstStartup(this)),
|
|
|
|
#endif
|
2019-04-08 18:46:11 +02:00
|
|
|
analyzer_(nullptr),
|
|
|
|
equalizer_(nullptr),
|
2018-02-27 18:06:05 +01:00
|
|
|
stream_change_type_(Engine::First),
|
|
|
|
last_state_(Engine::Empty),
|
|
|
|
nb_errors_received_(0),
|
2019-03-09 16:48:45 +01:00
|
|
|
volume_before_mute_(100),
|
2018-02-27 18:06:05 +01:00
|
|
|
last_pressed_previous_(QDateTime::currentDateTime()),
|
2018-10-30 23:21:51 +01:00
|
|
|
continue_on_error_(false),
|
|
|
|
greyout_(true),
|
2018-02-27 18:06:05 +01:00
|
|
|
menu_previousmode_(PreviousBehaviour_DontRestart),
|
2019-03-09 16:48:45 +01:00
|
|
|
seek_step_sec_(10),
|
|
|
|
volume_control_(true)
|
|
|
|
{
|
|
|
|
|
|
|
|
settings_.beginGroup(kSettingsGroup);
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
QSettings s;
|
|
|
|
s.beginGroup(BackendSettingsPage::kSettingsGroup);
|
2018-06-28 01:15:32 +02:00
|
|
|
Engine::EngineType enginetype = Engine::EngineTypeFromName(s.value("engine", EngineName(Engine::GStreamer)).toString().toLower());
|
2018-02-27 18:06:05 +01:00
|
|
|
s.endGroup();
|
|
|
|
CreateEngine(enginetype);
|
|
|
|
|
2018-07-01 01:29:52 +02:00
|
|
|
}
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-07-01 01:29:52 +02:00
|
|
|
Player::~Player() {
|
|
|
|
settings_.endGroup();
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
2018-10-17 22:55:36 +02:00
|
|
|
Engine::EngineType Player::CreateEngine(Engine::EngineType enginetype) {
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-10-14 00:08:33 +02:00
|
|
|
Engine::EngineType use_enginetype(Engine::None);
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-07-01 01:29:52 +02:00
|
|
|
for (int i = 0 ; use_enginetype == Engine::None ; i++) {
|
2018-02-27 18:06:05 +01:00
|
|
|
switch(enginetype) {
|
|
|
|
case Engine::None:
|
|
|
|
#ifdef HAVE_GSTREAMER
|
2019-04-20 15:25:31 +02:00
|
|
|
case Engine::GStreamer:{
|
2018-07-01 01:29:52 +02:00
|
|
|
use_enginetype=Engine::GStreamer;
|
2019-04-20 15:25:31 +02:00
|
|
|
unique_ptr<GstEngine> gst_engine(new GstEngine(app_->task_manager()));
|
|
|
|
gst_engine->SetStartup(gst_startup_);
|
|
|
|
engine_.reset(gst_engine.release());
|
2018-02-27 18:06:05 +01:00
|
|
|
break;
|
2019-04-20 15:25:31 +02:00
|
|
|
}
|
2018-02-27 18:06:05 +01:00
|
|
|
#endif
|
2018-03-10 23:51:05 +01:00
|
|
|
#ifdef HAVE_XINE
|
|
|
|
case Engine::Xine:
|
2018-07-01 01:29:52 +02:00
|
|
|
use_enginetype=Engine::Xine;
|
|
|
|
engine_.reset(new XineEngine(app_->task_manager()));
|
2018-03-10 23:51:05 +01:00
|
|
|
break;
|
|
|
|
#endif
|
2018-02-27 18:06:05 +01:00
|
|
|
#ifdef HAVE_VLC
|
|
|
|
case Engine::VLC:
|
2018-07-01 01:29:52 +02:00
|
|
|
use_enginetype=Engine::VLC;
|
|
|
|
engine_.reset(new VLCEngine(app_->task_manager()));
|
2018-02-27 18:06:05 +01:00
|
|
|
break;
|
2018-06-28 01:15:32 +02:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_PHONON
|
|
|
|
case Engine::Phonon:
|
2018-07-01 01:29:52 +02:00
|
|
|
use_enginetype=Engine::Phonon;
|
|
|
|
engine_.reset(new PhononEngine(app_->task_manager()));
|
2018-06-28 01:15:32 +02:00
|
|
|
break;
|
2018-02-27 18:06:05 +01:00
|
|
|
#endif
|
|
|
|
default:
|
2018-07-01 01:29:52 +02:00
|
|
|
if (i > 0) { qFatal("No engine available!"); }
|
|
|
|
enginetype = Engine::None;
|
|
|
|
break;
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-01 01:29:52 +02:00
|
|
|
if (use_enginetype != enginetype) { // Engine was set to something else. Reset output and device.
|
|
|
|
QSettings s;
|
|
|
|
s.beginGroup(BackendSettingsPage::kSettingsGroup);
|
|
|
|
s.setValue("engine", EngineName(use_enginetype));
|
|
|
|
s.setValue("output", engine_->DefaultOutput());
|
2018-10-14 00:08:33 +02:00
|
|
|
s.setValue("device", QVariant());
|
2018-07-01 01:29:52 +02:00
|
|
|
s.endGroup();
|
|
|
|
}
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-07-01 01:29:52 +02:00
|
|
|
if (!engine_) {
|
2018-02-27 18:06:05 +01:00
|
|
|
qFatal("Failed to create engine!");
|
|
|
|
}
|
|
|
|
|
2019-04-20 15:25:31 +02:00
|
|
|
emit EngineChanged(use_enginetype);
|
|
|
|
|
2018-10-17 22:55:36 +02:00
|
|
|
return use_enginetype;
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::Init() {
|
2018-10-02 00:38:52 +02:00
|
|
|
|
2019-03-09 16:48:45 +01:00
|
|
|
QSettings s;
|
|
|
|
|
|
|
|
if (!engine_.get()) {
|
|
|
|
s.beginGroup(BackendSettingsPage::kSettingsGroup);
|
|
|
|
Engine::EngineType enginetype = Engine::EngineTypeFromName(s.value("engine", EngineName(Engine::GStreamer)).toString().toLower());
|
|
|
|
s.endGroup();
|
|
|
|
CreateEngine(enginetype);
|
|
|
|
}
|
|
|
|
|
2018-07-01 01:29:52 +02:00
|
|
|
if (!engine_->Init()) { qFatal("Error initialising audio engine"); }
|
|
|
|
|
|
|
|
analyzer_->SetEngine(engine_.get());
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
connect(engine_.get(), SIGNAL(Error(QString)), SIGNAL(Error(QString)));
|
2018-10-30 23:21:51 +01:00
|
|
|
connect(engine_.get(), SIGNAL(FatalError()), SLOT(FatalError()));
|
2018-02-27 18:06:05 +01:00
|
|
|
connect(engine_.get(), SIGNAL(ValidSongRequested(QUrl)), SLOT(ValidSongRequested(QUrl)));
|
|
|
|
connect(engine_.get(), SIGNAL(InvalidSongRequested(QUrl)), SLOT(InvalidSongRequested(QUrl)));
|
|
|
|
connect(engine_.get(), SIGNAL(StateChanged(Engine::State)), SLOT(EngineStateChanged(Engine::State)));
|
|
|
|
connect(engine_.get(), SIGNAL(TrackAboutToEnd()), SLOT(TrackAboutToEnd()));
|
|
|
|
connect(engine_.get(), SIGNAL(TrackEnded()), SLOT(TrackEnded()));
|
|
|
|
connect(engine_.get(), SIGNAL(MetaData(Engine::SimpleMetaBundle)), SLOT(EngineMetadataReceived(Engine::SimpleMetaBundle)));
|
|
|
|
|
|
|
|
// Equalizer
|
2019-11-08 23:07:21 +01:00
|
|
|
connect(equalizer_, SIGNAL(StereoBalancerEnabledChanged(bool)), app_->player()->engine(), SLOT(SetStereoBalancerEnabled(bool)));
|
|
|
|
connect(equalizer_, SIGNAL(StereoBalanceChanged(float)), app_->player()->engine(), SLOT(SetStereoBalance(float)));
|
|
|
|
connect(equalizer_, SIGNAL(EqualizerEnabledChanged(bool)), app_->player()->engine(), SLOT(SetEqualizerEnabled(bool)));
|
|
|
|
connect(equalizer_, SIGNAL(EqualizerParametersChanged(int, QList<int>)), app_->player()->engine(), SLOT(SetEqualizerParameters(int, QList<int>)));
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2019-11-08 23:07:21 +01:00
|
|
|
engine_->SetStereoBalancerEnabled(equalizer_->is_stereo_balancer_enabled());
|
|
|
|
engine_->SetStereoBalance(equalizer_->stereo_balance());
|
2019-10-27 23:48:54 +01:00
|
|
|
engine_->SetEqualizerEnabled(equalizer_->is_equalizer_enabled());
|
2018-02-27 18:06:05 +01:00
|
|
|
engine_->SetEqualizerParameters(equalizer_->preamp_value(), equalizer_->gain_values());
|
|
|
|
|
2019-03-09 16:48:45 +01:00
|
|
|
s.beginGroup(BackendSettingsPage::kSettingsGroup);
|
|
|
|
volume_control_ = s.value("volume_control", true).toBool();
|
|
|
|
s.endGroup();
|
|
|
|
|
|
|
|
if (volume_control_) {
|
|
|
|
int volume = settings_.value("volume", 100).toInt();
|
|
|
|
SetVolume(volume);
|
|
|
|
}
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
ReloadSettings();
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::ReloadSettings() {
|
|
|
|
|
|
|
|
QSettings s;
|
|
|
|
|
|
|
|
s.beginGroup(PlaylistSettingsPage::kSettingsGroup);
|
2018-10-30 23:21:51 +01:00
|
|
|
continue_on_error_ = s.value("continue_on_error", false).toBool();
|
|
|
|
greyout_ = s.value("greyout_songs_play", true).toBool();
|
2018-02-27 18:06:05 +01:00
|
|
|
menu_previousmode_ = PreviousBehaviour(s.value("menu_previousmode", PreviousBehaviour_DontRestart).toInt());
|
|
|
|
s.endGroup();
|
|
|
|
|
|
|
|
s.beginGroup(BehaviourSettingsPage::kSettingsGroup);
|
|
|
|
seek_step_sec_ = s.value("seek_step_sec", 10).toInt();
|
|
|
|
s.endGroup();
|
|
|
|
|
2019-03-09 16:48:45 +01:00
|
|
|
s.beginGroup(BackendSettingsPage::kSettingsGroup);
|
|
|
|
bool volume_control = s.value("volume_control", true).toBool();
|
|
|
|
if (!volume_control && GetVolume() != 100) SetVolume(100);
|
|
|
|
s.endGroup();
|
|
|
|
|
2018-07-01 01:29:52 +02:00
|
|
|
engine_->ReloadSettings();
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::HandleLoadResult(const UrlHandler::LoadResult &result) {
|
|
|
|
|
2019-06-15 19:32:26 +02:00
|
|
|
if (loading_async_.contains(result.original_url_)) {
|
|
|
|
loading_async_.removeAll(result.original_url_);
|
|
|
|
}
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
// Might've been an async load, so check we're still on the same item
|
2019-06-15 19:32:26 +02:00
|
|
|
PlaylistItemPtr item = app_->playlist_manager()->active()->current_item();
|
2018-02-27 18:06:05 +01:00
|
|
|
if (!item) {
|
|
|
|
return;
|
|
|
|
}
|
2019-06-15 19:32:26 +02:00
|
|
|
const bool has_next_row = app_->playlist_manager()->active()->next_row() != -1;
|
|
|
|
PlaylistItemPtr next_item;
|
|
|
|
if (has_next_row) {
|
|
|
|
next_item = app_->playlist_manager()->active()->item_at(app_->playlist_manager()->active()->next_row());
|
|
|
|
}
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2019-06-15 19:32:26 +02:00
|
|
|
bool is_current(false);
|
|
|
|
bool is_next(false);
|
|
|
|
|
|
|
|
if (result.original_url_ == item->Url()) {
|
|
|
|
is_current = true;
|
|
|
|
}
|
|
|
|
else if (has_next_row && next_item->Url() == result.original_url_) {
|
|
|
|
is_next = true;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return;
|
|
|
|
}
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
switch (result.type_) {
|
2019-01-13 00:06:08 +01:00
|
|
|
case UrlHandler::LoadResult::Error:
|
2019-06-15 19:32:26 +02:00
|
|
|
if (is_current) {
|
|
|
|
EngineStateChanged(Engine::Error);
|
|
|
|
FatalError();
|
|
|
|
}
|
2019-01-13 00:06:08 +01:00
|
|
|
emit Error(result.error_);
|
|
|
|
break;
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2019-06-15 19:32:26 +02:00
|
|
|
case UrlHandler::LoadResult::NoMoreTracks:
|
|
|
|
qLog(Debug) << "URL handler for" << result.original_url_ << "said no more tracks" << is_current;
|
|
|
|
if (is_current) NextItem(stream_change_type_);
|
2018-02-27 18:06:05 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case UrlHandler::LoadResult::TrackAvailable: {
|
|
|
|
|
2019-09-07 23:34:13 +02:00
|
|
|
qLog(Debug) << "URL handler for" << result.original_url_ << "returned" << result.stream_url_;
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2019-06-15 19:32:26 +02:00
|
|
|
Song song;
|
|
|
|
if (is_current) song = item->Metadata();
|
|
|
|
else if (is_next) song = next_item->Metadata();
|
|
|
|
|
2018-09-20 22:13:30 +02:00
|
|
|
bool update(false);
|
|
|
|
|
2019-09-07 23:34:13 +02:00
|
|
|
// Set the stream url in the temporary metadata.
|
2019-06-15 19:32:26 +02:00
|
|
|
if (
|
2019-09-07 23:34:13 +02:00
|
|
|
(result.stream_url_.isValid())
|
2019-06-15 19:32:26 +02:00
|
|
|
&&
|
2019-09-07 23:34:13 +02:00
|
|
|
(result.stream_url_ != song.url())
|
2019-06-15 19:32:26 +02:00
|
|
|
)
|
|
|
|
{
|
2019-09-07 23:34:13 +02:00
|
|
|
song.set_stream_url(result.stream_url_);
|
2019-06-15 19:32:26 +02:00
|
|
|
update = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there was no filetype in the song's metadata, use the one provided by URL handler, if there is one.
|
2018-09-20 22:13:30 +02:00
|
|
|
if (
|
2019-06-15 19:32:26 +02:00
|
|
|
(song.filetype() == Song::FileType_Unknown && result.filetype_ != Song::FileType_Unknown)
|
2018-09-20 22:13:30 +02:00
|
|
|
||
|
2019-06-15 19:32:26 +02:00
|
|
|
(song.filetype() == Song::FileType_Stream && result.filetype_ != Song::FileType_Stream)
|
2018-09-20 22:13:30 +02:00
|
|
|
)
|
|
|
|
{
|
|
|
|
song.set_filetype(result.filetype_);
|
|
|
|
update = true;
|
|
|
|
}
|
2019-06-15 19:32:26 +02:00
|
|
|
|
2019-06-22 08:39:30 +02:00
|
|
|
// If there was no samplerate info in song's metadata, use the one provided by URL handler, if there is one.
|
|
|
|
if (song.samplerate() <= 0 && result.samplerate_ > 0) {
|
|
|
|
song.set_samplerate(result.samplerate_);
|
|
|
|
update = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If there was no bit depth info in song's metadata, use the one provided by URL handler, if there is one.
|
|
|
|
if (song.bitdepth() <= 0 && result.bit_depth_ > 0) {
|
|
|
|
song.set_bitdepth(result.bit_depth_);
|
|
|
|
update = true;
|
|
|
|
}
|
|
|
|
|
2019-06-15 19:32:26 +02:00
|
|
|
// If there was no length info in song's metadata, use the one provided by URL handler, if there is one.
|
|
|
|
if (song.length_nanosec() <= 0 && result.length_nanosec_ != -1) {
|
2018-02-27 18:06:05 +01:00
|
|
|
song.set_length_nanosec(result.length_nanosec_);
|
2018-09-20 22:13:30 +02:00
|
|
|
update = true;
|
|
|
|
}
|
2019-06-15 19:32:26 +02:00
|
|
|
|
2018-09-20 22:13:30 +02:00
|
|
|
if (update) {
|
2019-06-15 19:32:26 +02:00
|
|
|
if (is_current) {
|
|
|
|
item->SetTemporaryMetadata(song);
|
|
|
|
app_->playlist_manager()->active()->InformOfCurrentSongChange();
|
|
|
|
}
|
|
|
|
else if (is_next) {
|
|
|
|
next_item->SetTemporaryMetadata(song);
|
|
|
|
app_->playlist_manager()->active()->ItemChanged(next_item);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_current) {
|
2019-09-07 23:34:13 +02:00
|
|
|
qLog(Debug) << "Playing song" << item->Metadata().title() << result.stream_url_;
|
2019-09-22 22:47:07 +02:00
|
|
|
engine_->Play(result.stream_url_, result.original_url_, stream_change_type_, song.has_cue(), song.beginning_nanosec(), song.end_nanosec());
|
2019-06-15 19:32:26 +02:00
|
|
|
current_item_ = item;
|
|
|
|
}
|
|
|
|
else if (is_next) {
|
2019-09-07 23:34:13 +02:00
|
|
|
qLog(Debug) << "Preloading next song" << next_item->Metadata().title() << result.stream_url_;
|
2019-09-22 22:47:07 +02:00
|
|
|
engine_->StartPreloading(result.stream_url_, next_item->Url(), song.has_cue(), song.beginning_nanosec(), song.end_nanosec());
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case UrlHandler::LoadResult::WillLoadAsynchronously:
|
|
|
|
qLog(Debug) << "URL handler for" << result.original_url_ << "is loading asynchronously";
|
|
|
|
|
|
|
|
// We'll get called again later with either NoMoreTracks or TrackAvailable
|
2019-06-15 19:32:26 +02:00
|
|
|
loading_async_ << result.original_url_;
|
2018-02-27 18:06:05 +01:00
|
|
|
break;
|
|
|
|
}
|
2018-09-22 23:30:19 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::Next() { NextInternal(Engine::Manual); }
|
|
|
|
|
|
|
|
void Player::NextInternal(Engine::TrackChangeFlags change) {
|
|
|
|
|
|
|
|
if (HandleStopAfter()) return;
|
|
|
|
|
|
|
|
NextItem(change);
|
2018-10-02 00:21:50 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::NextItem(Engine::TrackChangeFlags change) {
|
|
|
|
|
|
|
|
Playlist *active_playlist = app_->playlist_manager()->active();
|
|
|
|
|
|
|
|
// If we received too many errors in auto change, with repeat enabled, we stop
|
|
|
|
if (change == Engine::Auto) {
|
|
|
|
const PlaylistSequence::RepeatMode repeat_mode = active_playlist->sequence()->repeat_mode();
|
|
|
|
if (repeat_mode != PlaylistSequence::Repeat_Off) {
|
|
|
|
if ((repeat_mode == PlaylistSequence::Repeat_Track && nb_errors_received_ >= 3) || (nb_errors_received_ >= app_->playlist_manager()->active()->proxy()->rowCount())) {
|
2018-05-01 00:41:33 +02:00
|
|
|
// We received too many "Error" state changes: probably looping over a playlist which contains only unavailable elements: stop now.
|
2018-02-27 18:06:05 +01:00
|
|
|
nb_errors_received_ = 0;
|
|
|
|
Stop();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Manual track changes override "Repeat track"
|
|
|
|
const bool ignore_repeat_track = change & Engine::Manual;
|
|
|
|
|
|
|
|
int i = active_playlist->next_row(ignore_repeat_track);
|
|
|
|
if (i == -1) {
|
|
|
|
app_->playlist_manager()->active()->set_current_row(i);
|
|
|
|
emit PlaylistFinished();
|
|
|
|
Stop();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
PlayAt(i, change, false);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Player::HandleStopAfter() {
|
|
|
|
|
|
|
|
if (app_->playlist_manager()->active()->stop_after_current()) {
|
2018-05-01 00:41:33 +02:00
|
|
|
// Find what the next track would've been, and mark that one as current so it plays next time the user presses Play.
|
2018-02-27 18:06:05 +01:00
|
|
|
const int next_row = app_->playlist_manager()->active()->next_row();
|
|
|
|
if (next_row != -1) {
|
|
|
|
app_->playlist_manager()->active()->set_current_row(next_row, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
app_->playlist_manager()->active()->StopAfter(-1);
|
|
|
|
|
|
|
|
Stop(true);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2018-10-19 19:15:33 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::TrackEnded() {
|
|
|
|
|
|
|
|
if (HandleStopAfter()) return;
|
|
|
|
|
|
|
|
if (current_item_ && current_item_->IsLocalCollectionItem() && current_item_->Metadata().id() != -1) {
|
2019-04-19 14:02:28 +02:00
|
|
|
app_->playlist_manager()->collection_backend()->IncrementPlayCountAsync(current_item_->Metadata().id());
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
NextInternal(Engine::Auto);
|
2018-10-19 19:15:33 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::PlayPause() {
|
2018-10-02 00:38:52 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
switch (engine_->state()) {
|
|
|
|
case Engine::Paused:
|
|
|
|
engine_->Unpause();
|
2019-06-29 19:54:27 +02:00
|
|
|
emit Resumed();
|
2018-02-27 18:06:05 +01:00
|
|
|
break;
|
|
|
|
|
|
|
|
case Engine::Playing: {
|
|
|
|
if (current_item_->options() & PlaylistItem::PauseDisabled) {
|
|
|
|
Stop();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
engine_->Pause();
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Engine::Empty:
|
|
|
|
case Engine::Error:
|
|
|
|
case Engine::Idle: {
|
|
|
|
app_->playlist_manager()->SetActivePlaylist(app_->playlist_manager()->current_id());
|
|
|
|
if (app_->playlist_manager()->active()->rowCount() == 0) break;
|
|
|
|
int i = app_->playlist_manager()->active()->current_row();
|
|
|
|
if (i == -1) i = app_->playlist_manager()->active()->last_played_row();
|
|
|
|
if (i == -1) i = 0;
|
|
|
|
PlayAt(i, Engine::First, true);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::RestartOrPrevious() {
|
|
|
|
|
|
|
|
if (engine_->position_nanosec() < 8 * kNsecPerSec) return Previous();
|
|
|
|
|
|
|
|
SeekTo(0);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::Stop(bool stop_after) {
|
2019-06-15 19:32:26 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
engine_->Stop(stop_after);
|
|
|
|
app_->playlist_manager()->active()->set_current_row(-1);
|
|
|
|
current_item_.reset();
|
2019-06-15 19:32:26 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::StopAfterCurrent() {
|
2019-06-15 19:32:26 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
app_->playlist_manager()->active()->StopAfter(app_->playlist_manager()->active()->current_row());
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Player::PreviousWouldRestartTrack() const {
|
2019-06-15 19:32:26 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
// Check if it has been over two seconds since previous button was pressed
|
|
|
|
return menu_previousmode_ == PreviousBehaviour_Restart && last_pressed_previous_.isValid() && last_pressed_previous_.secsTo(QDateTime::currentDateTime()) >= 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::Previous() { PreviousItem(Engine::Manual); }
|
|
|
|
|
|
|
|
void Player::PreviousItem(Engine::TrackChangeFlags change) {
|
|
|
|
|
|
|
|
const bool ignore_repeat_track = change & Engine::Manual;
|
|
|
|
|
|
|
|
if (menu_previousmode_ == PreviousBehaviour_Restart) {
|
|
|
|
// Check if it has been over two seconds since previous button was pressed
|
|
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
|
|
if (last_pressed_previous_.isValid() && last_pressed_previous_.secsTo(now) >= 2) {
|
|
|
|
last_pressed_previous_ = now;
|
|
|
|
PlayAt(app_->playlist_manager()->active()->current_row(), change, false);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
last_pressed_previous_ = now;
|
|
|
|
}
|
|
|
|
|
|
|
|
int i = app_->playlist_manager()->active()->previous_row(ignore_repeat_track);
|
|
|
|
app_->playlist_manager()->active()->set_current_row(i);
|
|
|
|
if (i == -1) {
|
|
|
|
Stop();
|
|
|
|
PlayAt(i, change, true);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
PlayAt(i, change, false);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::EngineStateChanged(Engine::State state) {
|
|
|
|
|
|
|
|
if (Engine::Error == state) {
|
|
|
|
nb_errors_received_++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
nb_errors_received_ = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
case Engine::Paused:
|
|
|
|
emit Paused();
|
|
|
|
break;
|
|
|
|
case Engine::Playing:
|
|
|
|
emit Playing();
|
|
|
|
break;
|
|
|
|
case Engine::Error:
|
2018-08-29 21:42:24 +02:00
|
|
|
emit Error();
|
2019-09-16 21:20:12 +02:00
|
|
|
// fallthrough
|
2018-02-27 18:06:05 +01:00
|
|
|
case Engine::Empty:
|
|
|
|
case Engine::Idle:
|
|
|
|
emit Stopped();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
last_state_ = state;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::SetVolume(int value) {
|
|
|
|
|
|
|
|
int old_volume = engine_->volume();
|
|
|
|
|
|
|
|
int volume = qBound(0, value, 100);
|
|
|
|
settings_.setValue("volume", volume);
|
|
|
|
engine_->SetVolume(volume);
|
|
|
|
|
|
|
|
if (volume != old_volume) {
|
|
|
|
emit VolumeChanged(volume);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int Player::GetVolume() const { return engine_->volume(); }
|
|
|
|
|
|
|
|
void Player::PlayAt(int index, Engine::TrackChangeFlags change, bool reshuffle) {
|
|
|
|
|
2018-10-22 23:04:34 +02:00
|
|
|
if (current_item_ && change == Engine::Manual && engine_->position_nanosec() != engine_->length_nanosec()) {
|
2018-02-27 18:06:05 +01:00
|
|
|
emit TrackSkipped(current_item_);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (current_item_ && app_->playlist_manager()->active()->has_item_at(index) && current_item_->Metadata().IsOnSameAlbum(app_->playlist_manager()->active()->item_at(index)->Metadata())) {
|
|
|
|
change |= Engine::SameAlbum;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (reshuffle) app_->playlist_manager()->active()->ReshuffleIndices();
|
|
|
|
app_->playlist_manager()->active()->set_current_row(index);
|
|
|
|
if (app_->playlist_manager()->active()->current_row() == -1) {
|
|
|
|
// Maybe index didn't exist in the playlist.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
current_item_ = app_->playlist_manager()->active()->current_item();
|
2019-09-22 22:47:07 +02:00
|
|
|
const QUrl url = current_item_->StreamUrl();
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2019-03-09 17:43:20 +01:00
|
|
|
if (url_handlers_.contains(url.scheme())) {
|
2018-02-27 18:06:05 +01:00
|
|
|
// It's already loading
|
2019-06-15 19:32:26 +02:00
|
|
|
if (loading_async_.contains(url)) return;
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
stream_change_type_ = change;
|
|
|
|
HandleLoadResult(url_handlers_[url.scheme()]->StartLoading(url));
|
|
|
|
}
|
|
|
|
else {
|
2019-06-15 19:32:26 +02:00
|
|
|
qLog(Debug) << "Playing song" << current_item_->Metadata().title() << url;
|
2019-08-17 00:52:29 +02:00
|
|
|
if (current_item_->HasTemporaryMetadata()) {
|
2019-06-15 19:32:26 +02:00
|
|
|
app_->playlist_manager()->active()->InformOfCurrentSongChange();
|
2019-08-17 00:52:29 +02:00
|
|
|
}
|
2019-09-22 22:47:07 +02:00
|
|
|
engine_->Play(url, current_item_->Url(), change, current_item_->Metadata().has_cue(), current_item_->effective_beginning_nanosec(), current_item_->effective_end_nanosec());
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::CurrentMetadataChanged(const Song &metadata) {
|
2018-12-23 18:54:27 +01:00
|
|
|
|
2019-06-15 19:32:26 +02:00
|
|
|
// Those things might have changed (especially when a previously invalid song was reloaded) so we push the latest version into Engine
|
2018-02-27 18:06:05 +01:00
|
|
|
engine_->RefreshMarkers(metadata.beginning_nanosec(), metadata.end_nanosec());
|
|
|
|
|
2018-12-23 18:54:27 +01:00
|
|
|
// Send now playing to scrobble services
|
|
|
|
if (app_->scrobbler()->IsEnabled() && engine_->state() == Engine::Playing) {
|
|
|
|
Playlist *playlist = app_->playlist_manager()->active();
|
|
|
|
current_item_ = playlist->current_item();
|
|
|
|
if (playlist && current_item_ && !playlist->nowplaying() && current_item_->Metadata() == metadata && current_item_->Metadata().length_nanosec() > 0) {
|
|
|
|
app_->scrobbler()->UpdateNowPlaying(metadata);
|
|
|
|
playlist->set_nowplaying(true);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::SeekTo(int seconds) {
|
2018-10-02 00:38:52 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
const qint64 length_nanosec = engine_->length_nanosec();
|
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
// If the length is 0 then either there is no song playing, or the song isn't seekable.
|
2018-02-27 18:06:05 +01:00
|
|
|
if (length_nanosec <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const qint64 nanosec = qBound(0ll, qint64(seconds) * kNsecPerSec, length_nanosec);
|
|
|
|
engine_->Seek(nanosec);
|
|
|
|
|
2018-12-23 18:54:27 +01:00
|
|
|
qLog(Debug) << "Track seeked to" << nanosec << "ns - updating scrobble point";
|
|
|
|
app_->playlist_manager()->active()->UpdateScrobblePoint(nanosec);
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
emit Seeked(nanosec / 1000);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::SeekForward() {
|
|
|
|
SeekTo(engine()->position_nanosec() / kNsecPerSec + seek_step_sec_);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::SeekBackward() {
|
|
|
|
SeekTo(engine()->position_nanosec() / kNsecPerSec - seek_step_sec_);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::EngineMetadataReceived(const Engine::SimpleMetaBundle &bundle) {
|
2018-09-21 00:34:02 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
PlaylistItemPtr item = app_->playlist_manager()->active()->current_item();
|
|
|
|
if (!item) return;
|
|
|
|
|
2019-09-23 01:03:03 +02:00
|
|
|
if (bundle.url == item->Url()) {
|
|
|
|
Song song = item->Metadata();
|
|
|
|
bool minor = song.MergeFromSimpleMetaBundle(bundle);
|
|
|
|
app_->playlist_manager()->active()->SetStreamMetadata(item->Url(), song, minor);
|
|
|
|
return;
|
|
|
|
}
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2019-09-23 01:03:03 +02:00
|
|
|
if (app_->playlist_manager()->active()->next_row() != -1) {
|
|
|
|
PlaylistItemPtr next_item = app_->playlist_manager()->active()->item_at(app_->playlist_manager()->active()->next_row());
|
|
|
|
if (bundle.url == next_item->Url()) {
|
|
|
|
Song song = next_item->Metadata();
|
|
|
|
song.MergeFromSimpleMetaBundle(bundle);
|
|
|
|
next_item->SetTemporaryMetadata(song);
|
|
|
|
app_->playlist_manager()->active()->ItemChanged(next_item);
|
|
|
|
}
|
|
|
|
}
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
PlaylistItemPtr Player::GetItemAt(int pos) const {
|
|
|
|
|
|
|
|
if (pos < 0 || pos >= app_->playlist_manager()->active()->rowCount())
|
|
|
|
return PlaylistItemPtr();
|
|
|
|
return app_->playlist_manager()->active()->item_at(pos);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::Mute() {
|
|
|
|
|
2019-03-09 16:48:45 +01:00
|
|
|
if (!volume_control_) return;
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
const int current_volume = engine_->volume();
|
|
|
|
|
|
|
|
if (current_volume == 0) {
|
|
|
|
SetVolume(volume_before_mute_);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
volume_before_mute_ = current_volume;
|
|
|
|
SetVolume(0);
|
|
|
|
}
|
2019-03-09 16:48:45 +01:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::Pause() { engine_->Pause(); }
|
|
|
|
|
|
|
|
void Player::Play() {
|
2019-06-15 19:32:26 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
switch (GetState()) {
|
|
|
|
case Engine::Playing:
|
|
|
|
SeekTo(0);
|
|
|
|
break;
|
|
|
|
case Engine::Paused:
|
|
|
|
engine_->Unpause();
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
PlayPause();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::ShowOSD() {
|
|
|
|
if (current_item_) emit ForceShowOSD(current_item_->Metadata(), false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::TogglePrettyOSD() {
|
|
|
|
if (current_item_) emit ForceShowOSD(current_item_->Metadata(), true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::TrackAboutToEnd() {
|
|
|
|
|
|
|
|
const bool has_next_row = app_->playlist_manager()->active()->next_row() != -1;
|
|
|
|
PlaylistItemPtr next_item;
|
|
|
|
|
|
|
|
if (has_next_row) {
|
|
|
|
next_item = app_->playlist_manager()->active()->item_at(app_->playlist_manager()->active()->next_row());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (engine_->is_autocrossfade_enabled()) {
|
2018-05-01 00:41:33 +02:00
|
|
|
// Crossfade is on, so just start playing the next track. The current one will fade out, and the new one will fade in
|
2018-02-27 18:06:05 +01:00
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
// But, if there's no next track and we don't want to fade out, then do nothing and just let the track finish to completion.
|
2018-02-27 18:06:05 +01:00
|
|
|
if (!engine_->is_fadeout_enabled() && !has_next_row) return;
|
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
// If the next track is on the same album (or same cue file),
|
|
|
|
// and the user doesn't want to crossfade between tracks on the same album, then don't do this automatic crossfading.
|
2018-02-27 18:06:05 +01:00
|
|
|
if (engine_->crossfade_same_album() || !has_next_row || !next_item || !current_item_->Metadata().IsOnSameAlbum(next_item->Metadata())) {
|
|
|
|
TrackEnded();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-01 00:41:33 +02:00
|
|
|
// Crossfade is off, so start preloading the next track so we don't get a gap between songs.
|
2018-02-27 18:06:05 +01:00
|
|
|
if (!has_next_row || !next_item) return;
|
|
|
|
|
2019-09-22 22:47:07 +02:00
|
|
|
QUrl url = next_item->StreamUrl();
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
// Get the actual track URL rather than the stream URL.
|
2019-03-09 17:43:20 +01:00
|
|
|
if (url_handlers_.contains(url.scheme())) {
|
2019-06-15 19:32:26 +02:00
|
|
|
if (loading_async_.contains(url)) return;
|
|
|
|
UrlHandler::LoadResult result = url_handlers_[url.scheme()]->StartLoading(url);
|
2018-02-27 18:06:05 +01:00
|
|
|
switch (result.type_) {
|
2019-01-13 00:06:08 +01:00
|
|
|
case UrlHandler::LoadResult::Error:
|
|
|
|
emit Error(result.error_);
|
|
|
|
return;
|
2018-02-27 18:06:05 +01:00
|
|
|
case UrlHandler::LoadResult::NoMoreTracks:
|
|
|
|
return;
|
|
|
|
case UrlHandler::LoadResult::WillLoadAsynchronously:
|
2019-06-15 19:32:26 +02:00
|
|
|
loading_async_ << url;
|
2018-02-27 18:06:05 +01:00
|
|
|
return;
|
|
|
|
case UrlHandler::LoadResult::TrackAvailable:
|
2019-09-07 23:34:13 +02:00
|
|
|
url = result.stream_url_;
|
2018-02-27 18:06:05 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2019-06-15 19:32:26 +02:00
|
|
|
|
2019-09-22 22:47:07 +02:00
|
|
|
engine_->StartPreloading(url, next_item->Url(), next_item->Metadata().has_cue(), next_item->effective_beginning_nanosec(), next_item->effective_end_nanosec());
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::IntroPointReached() { NextInternal(Engine::Intro); }
|
|
|
|
|
2018-10-30 23:21:51 +01:00
|
|
|
void Player::FatalError() {
|
|
|
|
nb_errors_received_ = 0;
|
|
|
|
Stop();
|
|
|
|
}
|
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
void Player::ValidSongRequested(const QUrl &url) {
|
|
|
|
emit SongChangeRequestProcessed(url, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::InvalidSongRequested(const QUrl &url) {
|
|
|
|
|
2018-10-30 23:21:51 +01:00
|
|
|
if (greyout_) emit SongChangeRequestProcessed(url, false);
|
2018-10-02 00:21:50 +02:00
|
|
|
|
2018-10-30 23:21:51 +01:00
|
|
|
if (!continue_on_error_) {
|
|
|
|
FatalError();
|
|
|
|
return;
|
2018-10-02 00:21:50 +02:00
|
|
|
}
|
2018-10-30 23:21:51 +01:00
|
|
|
|
|
|
|
NextItem(Engine::Auto);
|
2018-02-27 18:06:05 +01:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::RegisterUrlHandler(UrlHandler *handler) {
|
2018-09-22 23:13:56 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
const QString scheme = handler->scheme();
|
|
|
|
|
|
|
|
if (url_handlers_.contains(scheme)) {
|
|
|
|
qLog(Warning) << "Tried to register a URL handler for" << scheme << "but one was already registered";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qLog(Info) << "Registered URL handler for" << scheme;
|
|
|
|
url_handlers_.insert(scheme, handler);
|
|
|
|
connect(handler, SIGNAL(destroyed(QObject*)), SLOT(UrlHandlerDestroyed(QObject*)));
|
|
|
|
connect(handler, SIGNAL(AsyncLoadComplete(UrlHandler::LoadResult)), SLOT(HandleLoadResult(UrlHandler::LoadResult)));
|
2018-10-02 00:38:52 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void Player::UnregisterUrlHandler(UrlHandler *handler) {
|
2018-09-22 23:13:56 +02:00
|
|
|
|
2018-02-27 18:06:05 +01:00
|
|
|
const QString scheme = url_handlers_.key(handler);
|
|
|
|
if (scheme.isEmpty()) {
|
|
|
|
qLog(Warning) << "Tried to unregister a URL handler for" << handler->scheme() << "that wasn't registered";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qLog(Info) << "Unregistered URL handler for" << scheme;
|
|
|
|
url_handlers_.remove(scheme);
|
|
|
|
disconnect(handler, SIGNAL(destroyed(QObject*)), this, SLOT(UrlHandlerDestroyed(QObject*)));
|
|
|
|
disconnect(handler, SIGNAL(AsyncLoadComplete(UrlHandler::LoadResult)), this, SLOT(HandleLoadResult(UrlHandler::LoadResult)));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
const UrlHandler *Player::HandlerForUrl(const QUrl &url) const {
|
|
|
|
|
|
|
|
QMap<QString, UrlHandler*>::const_iterator it = url_handlers_.constFind(url.scheme());
|
|
|
|
if (it == url_handlers_.constEnd()) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
return *it;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void Player::UrlHandlerDestroyed(QObject *object) {
|
|
|
|
|
|
|
|
UrlHandler *handler = static_cast<UrlHandler*>(object);
|
|
|
|
const QString scheme = url_handlers_.key(handler);
|
|
|
|
if (!scheme.isEmpty()) {
|
|
|
|
url_handlers_.remove(scheme);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2018-10-14 00:08:33 +02:00
|
|
|
|
|
|
|
void Player::HandleAuthentication() {
|
|
|
|
emit Authenticated();
|
|
|
|
}
|