Castopod/kasts
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kasts/src/audiomanager.cpp

726 lines
24 KiB
C++
Raw Normal View History

Adapt license headers of audiomanager
2021-04-11 17:22:13 +02:00
/**
* SPDX-FileCopyrightText: 2017 (c) Matthieu Gallien <matthieu_gallien@yahoo.fr>
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
* SPDX-FileCopyrightText: 2021-2022 Bart De Vries <bart@mogwai.be>
Adapt license headers of audiomanager
2021-04-11 17:22:13 +02:00
*
* SPDX-License-Identifier: LGPL-3.0-or-later
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
*/
#include "audiomanager.h"
#include <QAudio>
Implement the framework for custom audio starting position What's still needed is the backend for saving the current position and making the audio player aware of that position when the entry is changed.
2021-04-11 18:55:09 +02:00
#include <QEventLoop>
Apply clang-format
2021-05-01 21:35:37 +02:00
#include <QTimer>
Implement timeString method to create HH:mm:ss strings from qint64 This method is now used in all places where a HH:mm:ss string is required.
2021-05-02 09:38:48 +02:00
#include <QtMath>
Apply clang-format
2021-05-01 21:35:37 +02:00
#include <algorithm>
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Add error overlay for Invalid Media This implements a TODO mentioned in the sources.
2021-07-04 14:53:42 +02:00
#include <KLocalizedString>
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
#include "audiologging.h"
Restore last playing track on startup
2021-04-11 21:08:25 +02:00
#include "datamanager.h"
Add error overlay for Invalid Media This implements a TODO mentioned in the sources.
2021-07-04 14:53:42 +02:00
#include "feed.h"
Move models to dedicated directory
2021-09-08 11:46:22 +02:00
#include "models/errorlogmodel.h"
Apply clang-format
2021-05-01 21:35:37 +02:00
#include "powermanagementinterface.h"
Restore last playing track on startup
2021-04-11 21:08:25 +02:00
#include "settingsmanager.h"
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
#include <solidextras/networkstatus.h>
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
class AudioManagerPrivate
{
private:
PowerManagementInterface mPowerInterface;
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
SolidExtras::NetworkStatus m_networkStatus;
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
QMediaPlayer m_player;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Apply clang-format
2021-05-01 21:35:37 +02:00
Entry *m_entry = nullptr;
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
bool m_readyToPlay = false;
Change implementation of seekable in AudioManager We cannot simply pass on the value from the underlying QMediaPlayer, since it is not reliable (see hacks concerning restoring startup player position). Instead we keep track of it ourselves and send out the signal in the proper places.
2021-04-13 14:31:52 +02:00
bool m_isSeekable = false;
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
bool m_continuePlayback = false;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
// sort of lock mutex to prevent updating the player position while changing
// sources (which will emit lots of playerPositionChanged signals)
bool m_lockPositionSaving = false;
// m_pendingSeek is used to indicate whether a seek action is still pending
// * -1 corresponds to no seek action pending
// * any positive value indicates that a seek to position=m_pendingSeek is
// still pending
qint64 m_pendingSeek = -1;
Move audio positioning hack into a separate method This allows the hack to be re-used in the play() method. Apparently on some systems the stream becomes unresponsive again after pausing. So probably it's required to ensure that the stream is fully seekable and buffered before restarting playback.
2021-04-22 16:48:13 +02:00
Add sleep timer FEATURE: 443400
2022-06-30 08:21:09 +00:00
QTimer *m_sleepTimer = nullptr;
qint64 m_sleepTime = -1;
qint64 m_remainingSleepTime = -1;
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
bool m_isStreaming = false;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
friend class AudioManager;
};
Apply clang-format
2021-05-01 21:35:37 +02:00
AudioManager::AudioManager(QObject *parent)
: QObject(parent)
, d(std::make_unique<AudioManagerPrivate>())
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
connect(&d->m_player, &QMediaPlayer::mutedChanged, this, &AudioManager::playerMutedChanged);
connect(&d->m_player, &QMediaPlayer::volumeChanged, this, &AudioManager::playerVolumeChanged);
Initial copy and adaptation of MPRIS2 from elisa (WIP) This MPRIS2 implementation compiles without errors, but is not yet instantiated within the application itself. To be continued...
2021-04-11 23:07:21 +02:00
connect(&d->m_player, &QMediaPlayer::mediaChanged, this, &AudioManager::sourceChanged);
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
connect(&d->m_player, &QMediaPlayer::mediaStatusChanged, this, &AudioManager::statusChanged);
connect(&d->m_player, &QMediaPlayer::mediaStatusChanged, this, &AudioManager::mediaStatusChanged);
connect(&d->m_player, &QMediaPlayer::stateChanged, this, &AudioManager::playbackStateChanged);
connect(&d->m_player, &QMediaPlayer::stateChanged, this, &AudioManager::playerStateChanged);
connect(&d->m_player, &QMediaPlayer::playbackRateChanged, this, &AudioManager::playbackRateChanged);
connect(&d->m_player, QOverload<QMediaPlayer::Error>::of(&QMediaPlayer::error), this, &AudioManager::errorChanged);
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
connect(&d->m_player, &QMediaPlayer::durationChanged, this, &AudioManager::playerDurationChanged);
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
connect(&d->m_player, &QMediaPlayer::positionChanged, this, &AudioManager::positionChanged);
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
connect(this, &AudioManager::positionChanged, this, &AudioManager::savePlayPosition);
Make sure that canGoNext is accurate when changing anything in queue
2021-04-16 21:42:27 +02:00
Adjust time left on episodes according to current playback rate This new feature is implemented behind a switch in the settings (default is off). FEATURE: 452135
2022-05-31 22:10:06 +02:00
connect(this, &AudioManager::playbackRateChanged, &DataManager::instance(), &DataManager::playbackRateChanged);
Make sure that canGoNext status is still accurate when queue items have been moved around
2021-04-15 22:51:40 +02:00
connect(&DataManager::instance(), &DataManager::queueEntryMoved, this, &AudioManager::canGoNextChanged);
Make sure that canGoNext is accurate when changing anything in queue
2021-04-16 21:42:27 +02:00
connect(&DataManager::instance(), &DataManager::queueEntryAdded, this, &AudioManager::canGoNextChanged);
connect(&DataManager::instance(), &DataManager::queueEntryRemoved, this, &AudioManager::canGoNextChanged);
Change implementation of seekable in AudioManager We cannot simply pass on the value from the underlying QMediaPlayer, since it is not reliable (see hacks concerning restoring startup player position). Instead we keep track of it ourselves and send out the signal in the proper places.
2021-04-13 14:31:52 +02:00
// we'll send custom seekableChanged signal to work around QMediaPlayer glitches
Restore last playing track on startup
2021-04-11 21:08:25 +02:00
Solve deadlock in startup between ErrorLogModel and AudioManager
2021-07-06 17:01:48 +02:00
connect(this, &AudioManager::logError, &ErrorLogModel::instance(), &ErrorLogModel::monitorErrorMessages);
Restore last playing track on startup
2021-04-11 21:08:25 +02:00
// Check if an entry was playing when the program was shut down and restore it
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
if (DataManager::instance().lastPlayingEntry() != QStringLiteral("none")) {
Save last playing track in database instead of config file
2021-04-17 20:55:01 +02:00
setEntry(DataManager::instance().getEntry(DataManager::instance().lastPlayingEntry()));
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
AudioManager::~AudioManager()
{
d->mPowerInterface.setPreventSleep(false);
}
Apply clang-format
2021-05-01 21:35:37 +02:00
Entry *AudioManager::entry() const
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
return d->m_entry;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
bool AudioManager::muted() const
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
return d->m_player.isMuted();
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
qreal AudioManager::volume() const
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
auto realVolume = static_cast<qreal>(d->m_player.volume() / 100.0);
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
auto userVolume = static_cast<qreal>(QAudio::convertVolume(realVolume, QAudio::LinearVolumeScale, QAudio::LogarithmicVolumeScale));
return userVolume * 100.0;
}
QUrl AudioManager::source() const
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
return d->m_player.media().request().url();
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
QMediaPlayer::Error AudioManager::error() const
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
if (d->m_player.error() != QMediaPlayer::NoError) {
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::error" << d->m_player.errorString();
Fix minor typo
2021-07-27 12:53:21 +03:00
// Some error occurred: probably best to unset the lastPlayingEntry to
Do some additional checks on entry before loading in AudioManager
2021-04-29 11:10:09 +02:00
// avoid a deadlock when starting up again.
DataManager::instance().setLastPlayingEntry(QStringLiteral("none"));
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
return d->m_player.error();
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
qint64 AudioManager::duration() const
{
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
// we fake the duration in case the track has not been properly loaded yet
if (d->m_player.duration() > 0) {
return d->m_player.duration();
} else if (d->m_entry && d->m_entry->enclosure()) {
return d->m_entry->enclosure()->duration() * 1000;
} else {
return 0;
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
qint64 AudioManager::position() const
{
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
// we fake the player position in case there is still a pending seek
if (d->m_pendingSeek != -1) {
return d->m_pendingSeek;
} else {
return d->m_player.position();
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
bool AudioManager::seekable() const
{
Change implementation of seekable in AudioManager We cannot simply pass on the value from the underlying QMediaPlayer, since it is not reliable (see hacks concerning restoring startup player position). Instead we keep track of it ourselves and send out the signal in the proper places.
2021-04-13 14:31:52 +02:00
return d->m_isSeekable;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Initial copy and adaptation of MPRIS2 from elisa (WIP) This MPRIS2 implementation compiles without errors, but is not yet instantiated within the application itself. To be continued...
2021-04-11 23:07:21 +02:00
bool AudioManager::canPlay() const
{
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
return (d->m_readyToPlay);
}
bool AudioManager::canPause() const
{
return (d->m_readyToPlay);
}
Refactor to use skipForward and skipBackward This is done to make the distinction between skipping time and changing track.
2021-04-12 22:44:05 +02:00
bool AudioManager::canSkipForward() const
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
{
return (d->m_readyToPlay);
}
Refactor to use skipForward and skipBackward This is done to make the distinction between skipping time and changing track.
2021-04-12 22:44:05 +02:00
bool AudioManager::canSkipBackward() const
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
{
return (d->m_readyToPlay);
Initial copy and adaptation of MPRIS2 from elisa (WIP) This MPRIS2 implementation compiles without errors, but is not yet instantiated within the application itself. To be continued...
2021-04-11 23:07:21 +02:00
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
QMediaPlayer::State AudioManager::playbackState() const
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
return d->m_player.state();
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Add playbackrate capability to AudioManager
2021-04-11 17:13:44 +02:00
qreal AudioManager::playbackRate() const
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
return d->m_player.playbackRate();
Add playbackrate capability to AudioManager
2021-04-11 17:13:44 +02:00
}
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
qreal AudioManager::minimumPlaybackRate() const
{
return MIN_RATE;
}
qreal AudioManager::maximumPlaybackRate() const
{
return MAX_RATE;
}
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
bool AudioManager::isStreaming() const
{
return d->m_isStreaming;
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
QMediaPlayer::MediaStatus AudioManager::status() const
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
return d->m_player.mediaStatus();
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Apply clang-format
2021-05-01 21:35:37 +02:00
void AudioManager::setEntry(Entry *entry)
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
{
Fix recursive loop when last track finishes playing
2021-07-06 19:21:57 +02:00
// First unset current track, such that any signal that fires doesn't
// operate on the wrong track
Entry *oldEntry = d->m_entry;
d->m_entry = nullptr;
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
// reset any pending seek action, lock position saving and notify interval
d->m_pendingSeek = -1;
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
d->m_lockPositionSaving = true;
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
d->m_player.setNotifyInterval(1000);
Do some additional checks on entry before loading in AudioManager
2021-04-29 11:10:09 +02:00
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
// First check if the previous track needs to be marked as read
// TODO: make grace time a setting in SettingsManager
Fix recursive loop when last track finishes playing
2021-07-06 19:21:57 +02:00
if (oldEntry) {
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "Checking previous track";
Run clang-format
2021-05-28 23:16:35 +02:00
qCDebug(kastsAudio) << "Left time" << (duration() - position());
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "MediaStatus" << d->m_player.mediaStatus();
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
if (((duration() > 0) && (position() > 0) && ((duration() - position()) < SKIP_TRACK_END)) || (d->m_player.mediaStatus() == QMediaPlayer::EndOfMedia)) {
Fix recursive loop when last track finishes playing
2021-07-06 19:21:57 +02:00
qCDebug(kastsAudio) << "Mark as read:" << oldEntry->title();
oldEntry->enclosure()->setPlayPosition(0);
Add podcast subscription and episode play state synchronization This implements the gpodder API from scratch. It turned out that libmygpo-qt has several critical bugs, and there's no response to pull requests upstream. So using that library was not an option. The implementation into kasts consists of the following: - Can sync with gpodder.net or with a nextcloud server that has the nextcloud-gpodder app installed. (This app is mostly API compatible with gpodder.) - Passwords are stored using qtkeychain. If the keychain is unavailable it will fallback to file. - It syncs podcast subscriptions and episode play positions, including marking episodes as played. Episodes that have a non-zero play position will be added to the queue automatically. - It will check for a metered connection before syncing. This is coupled to the allowMeteredFeedUpdates setting. - Full synchronization can be performed either manually (from the settings page) or through automatic triggers: on startup and/or on feed refresh. - There is an additional possibility to trigger quick upload-only syncs to make sure that the local changes are immediately uploaded to the server (if the connection allows). This will trigger when subscriptions are added or removed, when the pause/play button is toggled or an episode is marked as played. - This implements a few safeguards to avoid having multiple feed URLS pointing to the same underlying feed (e.g. http vs https). This solves part of #17 Solves #13
2021-10-29 17:00:52 +02:00
oldEntry->setRead(true);
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
d->m_continuePlayback = SettingsManager::self()->continuePlayingNextEntry();
Mark fully played episodes as read
2021-04-13 22:11:12 +02:00
}
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
}
Do some additional checks on entry before loading in AudioManager
2021-04-29 11:10:09 +02:00
// do some checks on the new entry to see whether it's valid and not corrupted
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
if (entry != nullptr && entry->hasEnclosure() && entry->enclosure()
&& (entry->enclosure()->status() == Enclosure::Downloaded
|| (d->m_networkStatus.connectivity() != SolidExtras::NetworkStatus::No
&& (d->m_networkStatus.metered() != SolidExtras::NetworkStatus::Yes || SettingsManager::self()->allowMeteredStreaming())))) {
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "Going to change source";
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
d->m_entry = entry;
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
Q_EMIT entryChanged(entry);
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
QUrl loadUrl;
if (entry->enclosure()->status() == Enclosure::Downloaded) {
loadUrl = QUrl::fromLocalFile(d->m_entry->enclosure()->path());
if (d->m_isStreaming) {
d->m_isStreaming = false;
Q_EMIT isStreamingChanged();
}
} else {
loadUrl = QUrl(d->m_entry->enclosure()->url());
if (!d->m_isStreaming) {
d->m_isStreaming = true;
Q_EMIT isStreamingChanged();
}
}
Use custom gst-pipeline to avoid pitch changes when audio is sped up
2021-04-21 20:25:01 +02:00
// the gst-pipeline is required to make sure that the pitch is not
// changed when speeding up the audio stream
Only use custom gst-pipeline on linux GStreamer is not used as QMediaPlayer backend on other platforms, so audio will not start with a custom gst-pipeline on Android and Windows. Still needs a solution to get rid of the horrible pitch change on Android and Windows, though.
2021-04-23 10:55:59 +02:00
// TODO: find a solution for Android (GStreamer not available on android by default)
#if !defined Q_OS_ANDROID && !defined Q_OS_WIN
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "use custom pipeline";
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
d->m_player.setMedia(QUrl(QStringLiteral("gst-pipeline: playbin uri=") + loadUrl.toString()
Apply clang-format
2021-05-01 21:35:37 +02:00
+ QStringLiteral(" audio_sink=\"scaletempo ! audioconvert ! audioresample ! autoaudiosink\" video_sink=\"fakevideosink\"")));
Only use custom gst-pipeline on linux GStreamer is not used as QMediaPlayer backend on other platforms, so audio will not start with a custom gst-pipeline on Android and Windows. Still needs a solution to get rid of the horrible pitch change on Android and Windows, though.
2021-04-23 10:55:59 +02:00
#else
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "regular audio backend";
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
d->m_player.setMedia(loadUrl);
Only use custom gst-pipeline on linux GStreamer is not used as QMediaPlayer backend on other platforms, so audio will not start with a custom gst-pipeline on Android and Windows. Still needs a solution to get rid of the horrible pitch change on Android and Windows, though.
2021-04-23 10:55:59 +02:00
#endif
Fix saving last playing item when application is shutdown
2021-04-12 09:40:18 +02:00
// save the current playing track in the settingsfile for restoring on startup
Save last playing track in database instead of config file
2021-04-17 20:55:01 +02:00
DataManager::instance().setLastPlayingEntry(d->m_entry->id());
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "Changed source to" << d->m_entry->title();
Implement the framework for custom audio starting position What's still needed is the backend for saving the current position and making the audio player aware of that position when the entry is changed.
2021-04-11 18:55:09 +02:00
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
// call method which will try to make sure that the stream will skip to
// the previously save position and make sure that the duration and
// position are reported correctly
prepareAudio();
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
} else {
Save last playing track in database instead of config file
2021-04-17 20:55:01 +02:00
DataManager::instance().setLastPlayingEntry(QStringLiteral("none"));
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
d->m_entry = nullptr;
Q_EMIT entryChanged(nullptr);
Fix segfault when removing feeds with currently playing entries
2021-05-22 09:05:33 +00:00
d->m_player.stop();
d->m_player.setMedia(nullptr);
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
d->m_readyToPlay = false;
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
Q_EMIT durationChanged(0);
Q_EMIT positionChanged(0);
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
Q_EMIT canPlayChanged();
Q_EMIT canPauseChanged();
Refactor to use skipForward and skipBackward This is done to make the distinction between skipping time and changing track.
2021-04-12 22:44:05 +02:00
Q_EMIT canSkipForwardChanged();
Q_EMIT canSkipBackwardChanged();
Enable next button in Player This functionality has safeguards built in, including a canGoNext property. This can be extended with streaming playing in the future.
2021-04-13 20:51:00 +02:00
Q_EMIT canGoNextChanged();
Change implementation of seekable in AudioManager We cannot simply pass on the value from the underlying QMediaPlayer, since it is not reliable (see hacks concerning restoring startup player position). Instead we keep track of it ourselves and send out the signal in the proper places.
2021-04-13 14:31:52 +02:00
d->m_isSeekable = false;
Q_EMIT seekableChanged(false);
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
void AudioManager::setMuted(bool muted)
{
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
d->m_player.setMuted(muted);
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
void AudioManager::setVolume(qreal volume)
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::setVolume" << volume;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
auto realVolume = static_cast<qreal>(QAudio::convertVolume(volume / 100.0, QAudio::LogarithmicVolumeScale, QAudio::LinearVolumeScale));
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
d->m_player.setVolume(qRound(realVolume * 100));
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
/*
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
void AudioManager::setSource(const QUrl &source)
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
//qCDebug(kastsAudio) << "AudioManager::setSource" << source;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
d->m_player.setMedia({source});
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
*/
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
void AudioManager::setPosition(qint64 position)
Add playbackrate capability to AudioManager
2021-04-11 17:13:44 +02:00
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::setPosition" << position;
Add playbackrate capability to AudioManager
2021-04-11 17:13:44 +02:00
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
seek(position);
Add playbackrate capability to AudioManager
2021-04-11 17:13:44 +02:00
}
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
void AudioManager::setPlaybackRate(const qreal rate)
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::setPlaybackRate" << rate;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
d->m_player.setPlaybackRate(rate);
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
void AudioManager::play()
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::play";
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
// if we're streaming, check that we're still connected and check for metered
// connection
if (isStreaming()) {
if (d->m_networkStatus.connectivity() != SolidExtras::NetworkStatus::Yes
|| (d->m_networkStatus.metered() != SolidExtras::NetworkStatus::No && !SettingsManager::self()->allowMeteredStreaming())) {
qCDebug(kastsAudio) << "Refusing to play: no Connection or streaming on metered connection not allowed";
Q_EMIT logError(Error::Type::MeteredStreamingNotAllowed,
d->m_entry->feed()->url(),
d->m_entry->id(),
0,
i18n("No connection or streaming on metered connection not allowed"),
QString());
return;
}
}
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
// setting m_continuePlayback will make sure that, if the audio stream is
// still being prepared, that the playback will start once it's ready
d->m_continuePlayback = true;
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
d->m_player.play();
Change implementation of seekable in AudioManager We cannot simply pass on the value from the underlying QMediaPlayer, since it is not reliable (see hacks concerning restoring startup player position). Instead we keep track of it ourselves and send out the signal in the proper places.
2021-04-13 14:31:52 +02:00
d->m_isSeekable = true;
Q_EMIT seekableChanged(d->m_isSeekable);
Set setPreventSleep in play() and pause() Making it toggle based on the playerState did not work properly because the stream is toggling between pause and play several times in the prepareAudioStream method.
2021-04-30 21:45:11 +02:00
d->mPowerInterface.setPreventSleep(true);
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
void AudioManager::pause()
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::pause";
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
// setting m_continuePlayback will make sure that, if the audio stream is
// still being prepared, that the playback will pause once it's ready
d->m_continuePlayback = false;
Change implementation of seekable in AudioManager We cannot simply pass on the value from the underlying QMediaPlayer, since it is not reliable (see hacks concerning restoring startup player position). Instead we keep track of it ourselves and send out the signal in the proper places.
2021-04-13 14:31:52 +02:00
d->m_isSeekable = true;
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
d->m_player.pause();
Set setPreventSleep in play() and pause() Making it toggle based on the playerState did not work properly because the stream is toggling between pause and play several times in the prepareAudioStream method.
2021-04-30 21:45:11 +02:00
d->mPowerInterface.setPreventSleep(false);
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
void AudioManager::playPause()
{
if (playbackState() == QMediaPlayer::State::PausedState)
play();
else if (playbackState() == QMediaPlayer::State::PlayingState)
pause();
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
void AudioManager::stop()
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::stop";
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Remove "source" property from audiomanager Also rename the internal variables of audiomanager to be aligned with the naming conventions used elsewhere.
2021-04-11 18:11:36 +02:00
d->m_player.stop();
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
d->m_continuePlayback = false;
Change implementation of seekable in AudioManager We cannot simply pass on the value from the underlying QMediaPlayer, since it is not reliable (see hacks concerning restoring startup player position). Instead we keep track of it ourselves and send out the signal in the proper places.
2021-04-13 14:31:52 +02:00
d->m_isSeekable = false;
Q_EMIT seekableChanged(d->m_isSeekable);
Set setPreventSleep in play() and pause() Making it toggle based on the playerState did not work properly because the stream is toggling between pause and play several times in the prepareAudioStream method.
2021-04-30 21:45:11 +02:00
d->mPowerInterface.setPreventSleep(false);
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
void AudioManager::seek(qint64 position)
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::seek" << position;
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
// if there is still a pending seek, then we simply update that pending
// value, and then manually send the positionChanged signal to have the UI
// updated
if (d->m_pendingSeek != -1) {
d->m_pendingSeek = position;
Q_EMIT positionChanged(position);
} else {
d->m_player.setPosition(position);
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Refactor to use skipForward and skipBackward This is done to make the distinction between skipping time and changing track.
2021-04-12 22:44:05 +02:00
void AudioManager::skipForward()
Initial copy and adaptation of MPRIS2 from elisa (WIP) This MPRIS2 implementation compiles without errors, but is not yet instantiated within the application itself. To be continued...
2021-04-11 23:07:21 +02:00
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::skipForward";
Use next() and previous() in PlayerControl Also change to std::min and std::max for the implementation of next and previous.
2021-04-12 22:36:17 +02:00
seek(std::min((position() + SKIP_STEP), duration()));
Initial copy and adaptation of MPRIS2 from elisa (WIP) This MPRIS2 implementation compiles without errors, but is not yet instantiated within the application itself. To be continued...
2021-04-11 23:07:21 +02:00
}
Refactor to use skipForward and skipBackward This is done to make the distinction between skipping time and changing track.
2021-04-12 22:44:05 +02:00
void AudioManager::skipBackward()
Initial copy and adaptation of MPRIS2 from elisa (WIP) This MPRIS2 implementation compiles without errors, but is not yet instantiated within the application itself. To be continued...
2021-04-11 23:07:21 +02:00
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::skipBackward";
Use next() and previous() in PlayerControl Also change to std::min and std::max for the implementation of next and previous.
2021-04-12 22:36:17 +02:00
seek(std::max((qint64)0, (position() - SKIP_STEP)));
Initial copy and adaptation of MPRIS2 from elisa (WIP) This MPRIS2 implementation compiles without errors, but is not yet instantiated within the application itself. To be continued...
2021-04-11 23:07:21 +02:00
}
Refactor audiomanager to be closer to MPRIS2 interface
2021-04-12 22:18:04 +02:00
Enable next button in Player This functionality has safeguards built in, including a canGoNext property. This can be extended with streaming playing in the future.
2021-04-13 20:51:00 +02:00
bool AudioManager::canGoNext() const
{
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
if (d->m_entry) {
Update based on review by Tobias Fella
2021-05-01 21:00:12 +02:00
int index = DataManager::instance().queue().indexOf(d->m_entry->id());
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
if (index >= 0) {
// check if there is a next track
Apply clang-format
2021-05-01 21:35:37 +02:00
if (index < DataManager::instance().queue().count() - 1) {
Entry *next_entry = DataManager::instance().getEntry(DataManager::instance().queue()[index + 1]);
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
if (next_entry->enclosure()) {
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "Enclosure status" << next_entry->enclosure()->path() << next_entry->enclosure()->status();
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
if (next_entry->enclosure()->status() == Enclosure::Downloaded) {
return true;
Implement streaming support This implements support for streaming episodes rather than downloading them first. This introduces a new setting: prioritizeStreaming. If it's set to false (default) then a streaming play button is only added to the EntryPage. If it is set to true, then the streaming play button will also appear on the Entry delegates instead of the download button. There is a separate setting to decide if streaming is also allowed on metered connections. FEATURE: 438864
2022-09-22 16:59:30 +02:00
} else {
SolidExtras::NetworkStatus networkStatus;
if (networkStatus.connectivity() == SolidExtras::NetworkStatus::Yes
&& (networkStatus.metered() == SolidExtras::NetworkStatus::No || SettingsManager::self()->allowMeteredStreaming())) {
return true;
}
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
}
Enable next button in Player This functionality has safeguards built in, including a canGoNext property. This can be extended with streaming playing in the future.
2021-04-13 20:51:00 +02:00
}
}
}
}
return false;
}
void AudioManager::next()
{
if (canGoNext()) {
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
qCDebug(kastsAudio) << "Current playbackStatus before next() is:" << playbackState();
d->m_continuePlayback = playbackState() == QMediaPlayer::State::PlayingState;
Update based on review by Tobias Fella
2021-05-01 21:00:12 +02:00
int index = DataManager::instance().queue().indexOf(d->m_entry->id());
Run clang-format
2021-05-28 23:16:35 +02:00
qCDebug(kastsAudio) << "Skipping to" << DataManager::instance().queue()[index + 1];
Apply clang-format
2021-05-01 21:35:37 +02:00
setEntry(DataManager::instance().getEntry(DataManager::instance().queue()[index + 1]));
Enable next button in Player This functionality has safeguards built in, including a canGoNext property. This can be extended with streaming playing in the future.
2021-04-13 20:51:00 +02:00
} else {
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "Next track cannot be played, changing entry to nullptr";
Enable next button in Player This functionality has safeguards built in, including a canGoNext property. This can be extended with streaming playing in the future.
2021-04-13 20:51:00 +02:00
setEntry(nullptr);
}
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
void AudioManager::mediaStatusChanged()
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::mediaStatusChanged" << d->m_player.mediaStatus();
Enable next button in Player This functionality has safeguards built in, including a canGoNext property. This can be extended with streaming playing in the future.
2021-04-13 20:51:00 +02:00
// File has reached the end and has stopped
if (d->m_player.mediaStatus() == QMediaPlayer::EndOfMedia) {
Mark fully played episodes as read
2021-04-13 22:11:12 +02:00
next();
Enable next button in Player This functionality has safeguards built in, including a canGoNext property. This can be extended with streaming playing in the future.
2021-04-13 20:51:00 +02:00
}
Safeguard against QMediaPlayer::InvalidMedia In case of the InvalidMedia status, skip to next track and delete the invalid enclosure.
2021-04-30 11:31:02 +02:00
// if there is a problem with the current track, make sure that it's not
// loaded again when the application is restarted, skip to next track and
// delete the enclosure
if (d->m_player.mediaStatus() == QMediaPlayer::InvalidMedia) {
// save pointer to this bad entry to allow
// us to delete the enclosure after the track has been unloaded
Apply clang-format
2021-05-01 21:35:37 +02:00
Entry *badEntry = d->m_entry;
Safeguard against QMediaPlayer::InvalidMedia In case of the InvalidMedia status, skip to next track and delete the invalid enclosure.
2021-04-30 11:31:02 +02:00
DataManager::instance().setLastPlayingEntry(QStringLiteral("none"));
stop();
next();
Add error overlay for Invalid Media This implements a TODO mentioned in the sources.
2021-07-04 14:53:42 +02:00
if (badEntry && badEntry->enclosure()) {
Safeguard against QMediaPlayer::InvalidMedia In case of the InvalidMedia status, skip to next track and delete the invalid enclosure.
2021-04-30 11:31:02 +02:00
badEntry->enclosure()->deleteFile();
Also add title argument to Error elsewhere
2021-07-14 22:27:52 +02:00
Q_EMIT logError(Error::Type::InvalidMedia, badEntry->feed()->url(), badEntry->id(), QMediaPlayer::InvalidMedia, i18n("Invalid Media"), QString());
Add error overlay for Invalid Media This implements a TODO mentioned in the sources.
2021-07-04 14:53:42 +02:00
}
Safeguard against QMediaPlayer::InvalidMedia In case of the InvalidMedia status, skip to next track and delete the invalid enclosure.
2021-04-30 11:31:02 +02:00
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
void AudioManager::playerStateChanged()
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::playerStateChanged" << d->m_player.state();
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Apply clang-format
2021-05-01 21:35:37 +02:00
switch (d->m_player.state()) {
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
case QMediaPlayer::State::StoppedState:
Q_EMIT stopped();
d->mPowerInterface.setPreventSleep(false);
break;
case QMediaPlayer::State::PlayingState:
Set setPreventSleep in play() and pause() Making it toggle based on the playerState did not work properly because the stream is toggling between pause and play several times in the prepareAudioStream method.
2021-04-30 21:45:11 +02:00
// setPreventSleep is set in play() to avoid it toggling too rapidly
// see d->prepareAudioStream() for details
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Q_EMIT playing();
break;
case QMediaPlayer::State::PausedState:
Set setPreventSleep in play() and pause() Making it toggle based on the playerState did not work properly because the stream is toggling between pause and play several times in the prepareAudioStream method.
2021-04-30 21:45:11 +02:00
// setPreventSleep is set in pause() to avoid it toggling too rapidly
// see d->prepareAudioStream() for details
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Q_EMIT paused();
break;
}
}
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
void AudioManager::playerDurationChanged(qint64 duration)
{
qCDebug(kastsAudio) << "AudioManager::playerDurationChanged" << duration;
// Check if duration mentioned in enclosure corresponds to real duration
if (duration > 0 && (duration / 1000) != d->m_entry->enclosure()->duration()) {
qCDebug(kastsAudio) << "Correcting duration of" << d->m_entry->id() << "to" << duration / 1000 << "(was" << d->m_entry->enclosure()->duration() << ")";
d->m_entry->enclosure()->setDuration(duration / 1000);
}
qint64 correctedDuration = duration;
QTimer::singleShot(0, this, [this, correctedDuration]() {
Q_EMIT durationChanged(correctedDuration);
});
}
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
void AudioManager::playerVolumeChanged()
{
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << "AudioManager::playerVolumeChanged" << d->m_player.volume();
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Contextualize singleShots
2021-05-28 16:54:00 +02:00
QTimer::singleShot(0, this, [this]() {
Apply clang-format
2021-05-01 21:35:37 +02:00
Q_EMIT volumeChanged();
});
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
void AudioManager::playerMutedChanged()
{
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
qCDebug(kastsAudio) << "AudioManager::playerMutedChanged" << muted();
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
Contextualize singleShots
2021-05-28 16:54:00 +02:00
QTimer::singleShot(0, this, [this]() {
Apply clang-format
2021-05-01 21:35:37 +02:00
Q_EMIT mutedChanged(muted());
});
Add audiomanager and powermanagementinterface Both classes are based on classes taken from Elisa. The audiomanager class will be adapted to add functionality like saving and restoring play positions and interfacing with MPRIS2.
2021-04-11 15:26:28 +02:00
}
Finally implement restoring playback positions!
2021-04-11 20:30:12 +02:00
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
void AudioManager::savePlayPosition()
Finally implement restoring playback positions!
2021-04-11 20:30:12 +02:00
{
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
qCDebug(kastsAudio) << "AudioManager::savePlayPosition";
// First check if there is still a pending seek
checkForPendingSeek();
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
if (!d->m_lockPositionSaving) {
if (d->m_entry) {
if (d->m_entry->enclosure()) {
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
d->m_entry->enclosure()->setPlayPosition(position());
Make player robust against having no track loaded at end of queue
2021-04-14 11:32:57 +02:00
}
}
}
Use qCDebug in AudioManager
2021-05-28 22:55:18 +02:00
qCDebug(kastsAudio) << d->m_player.mediaStatus();
Finally implement restoring playback positions!
2021-04-11 20:30:12 +02:00
}
Move audio positioning hack into a separate method This allows the hack to be re-used in the play() method. Apparently on some systems the stream becomes unresponsive again after pausing. So probably it's required to ensure that the stream is fully seekable and buffered before restarting playback.
2021-04-22 16:48:13 +02:00
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
void AudioManager::prepareAudio()
{
d->m_player.pause();
qint64 newDuration = duration();
qint64 startingPosition = d->m_entry->enclosure()->playPosition();
qCDebug(kastsAudio) << "Changing position to" << startingPosition / 1000 << "sec";
if (startingPosition <= newDuration) {
d->m_pendingSeek = startingPosition;
// Change notify interval temporarily. This will help with reducing the
// startup audio glitch to a minimum.
d->m_player.setNotifyInterval(50);
// do not call d->m_player.setPosition() here since it might start
// sending signals with a.o. incorrect duration and position
} else {
d->m_pendingSeek = -1;
}
// Emit positionChanged and durationChanged signals to make sure that
// the GUI can see the faked values (if needed)
qint64 newPosition = position();
Q_EMIT durationChanged(newDuration);
Q_EMIT positionChanged(newPosition);
d->m_readyToPlay = true;
Q_EMIT canPlayChanged();
Q_EMIT canPauseChanged();
Q_EMIT canSkipForwardChanged();
Q_EMIT canSkipBackwardChanged();
Q_EMIT canGoNextChanged();
d->m_isSeekable = true;
Q_EMIT seekableChanged(true);
qCDebug(kastsAudio) << "Duration reported by d->m_player" << d->m_player.duration();
qCDebug(kastsAudio) << "Duration reported by enclosure (in ms)" << d->m_entry->enclosure()->duration() * 1000;
qCDebug(kastsAudio) << "Duration reported by AudioManager" << newDuration;
qCDebug(kastsAudio) << "Position reported by d->m_player" << d->m_player.position();
qCDebug(kastsAudio) << "Saved position stored in enclosure (in ms)" << startingPosition;
qCDebug(kastsAudio) << "Position reported by AudioManager" << newPosition;
if (d->m_continuePlayback) {
// we call play() and not d->m_player.play() because we want to trigger
// things like inhibit suspend
play();
d->m_continuePlayback = false;
Move audio positioning hack into a separate method This allows the hack to be re-used in the play() method. Apparently on some systems the stream becomes unresponsive again after pausing. So probably it's required to ensure that the stream is fully seekable and buffered before restarting playback.
2021-04-22 16:48:13 +02:00
}
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
d->m_lockPositionSaving = false;
}
void AudioManager::checkForPendingSeek()
{
qint64 position = d->m_player.position();
qCDebug(kastsAudio) << "Seek pending?" << d->m_pendingSeek;
qCDebug(kastsAudio) << "Current position" << position;
// Check if we're supposed to skip to a new position
if (d->m_pendingSeek != -1 && d->m_player.mediaStatus() == QMediaPlayer::BufferedMedia && d->m_player.duration() > 0) {
if (abs(d->m_pendingSeek - position) > 2000) {
qCDebug(kastsAudio) << "Position seek still pending to position" << d->m_pendingSeek;
qCDebug(kastsAudio) << "Current reported position and duration" << d->m_player.position() << d->m_player.duration();
// be very careful because this setPosition call will trigger
// a positionChanged signal, which will be nested, so we call it in
// a QTimer::singleShot
qint64 seekPosition = d->m_pendingSeek;
QTimer::singleShot(0, this, [this, seekPosition]() {
d->m_player.setPosition(seekPosition);
});
} else {
qCDebug(kastsAudio) << "Pending position seek has been executed; to position" << d->m_pendingSeek;
d->m_pendingSeek = -1;
d->m_player.setNotifyInterval(1000);
}
Run clang-format
2021-05-28 23:16:35 +02:00
}
Move audio positioning hack into a separate method This allows the hack to be re-used in the play() method. Apparently on some systems the stream becomes unresponsive again after pausing. So probably it's required to ensure that the stream is fully seekable and buffered before restarting playback.
2021-04-22 16:48:13 +02:00
}
Port away from KDeclarative
2021-06-03 16:23:06 +02:00
QString AudioManager::formattedDuration() const
{
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
return m_kformat.formatDuration(duration());
Port away from KDeclarative
2021-06-03 16:23:06 +02:00
}
QString AudioManager::formattedLeftDuration() const
{
Adjust time left on episodes according to current playback rate This new feature is implemented behind a switch in the settings (default is off). FEATURE: 452135
2022-05-31 22:10:06 +02:00
qreal rate = 1.0;
if (SettingsManager::self()->adjustTimeLeft()) {
rate = playbackRate();
rate = (rate > 0.0) ? rate : 1.0;
}
qint64 diff = duration() - position();
return m_kformat.formatDuration(diff / rate);
Port away from KDeclarative
2021-06-03 16:23:06 +02:00
}
QString AudioManager::formattedPosition() const
{
Replace Audio prepare hack by nicer, asynchronous solution The main bits of this implementation are: - Start a new track in paused state. We don't care about the actual media state or player state that QMediaPlayer is reporting. We will deal with that when the audio actually starts playing. - If a player position needs to be restored, we set d->m_pendingSeek to the position that needs to be seeked. We don't actually seek because we have no idea what state the player is in yet. - On the positionChanged signal of QMP, and if the media is buffered, we check if there is pendingSeek value set which is set to a different value than the current player position. If so, we call d->m_player.setPosition(). If we have arrived at the correct position, then we reset d->m_pendingSeek to -1. - In the position(), duration() and seek() methods, we return sensible values, even QMP is not. So, we report the duration from the enclosure, the position from d->m_pendingSeek, and let seek() change the value of d->m_PendingSeek (if it's not -1) to the new seek position. - When there's a pending seek, we set the notifyInterval to shorter interval to reduce the startup audio glitch as much as possible. We then reset it to the default of 1000 msec. This was tested on linux and android.
2021-06-14 16:31:25 +02:00
return m_kformat.formatDuration(position());
Port away from KDeclarative
2021-06-03 16:23:06 +02:00
}
Add sleep timer FEATURE: 443400
2022-06-30 08:21:09 +00:00
qint64 AudioManager::sleepTime() const
{
if (d->m_sleepTimer) {
return d->m_sleepTime;
} else {
return -1;
}
}
qint64 AudioManager::remainingSleepTime() const
{
if (d->m_sleepTimer) {
return d->m_remainingSleepTime;
} else {
return -1;
}
}
void AudioManager::setSleepTimer(qint64 duration)
{
if (duration > 0) {
if (d->m_sleepTimer) {
stopSleepTimer();
}
d->m_sleepTime = duration;
d->m_remainingSleepTime = duration;
d->m_sleepTimer = new QTimer(this);
connect(d->m_sleepTimer, &QTimer::timeout, this, [this]() {
(d->m_remainingSleepTime)--;
if (d->m_remainingSleepTime > 0) {
Q_EMIT remainingSleepTimeChanged(remainingSleepTime());
} else {
pause();
stopSleepTimer();
}
});
d->m_sleepTimer->start(1000);
Q_EMIT sleepTimerChanged(duration);
Q_EMIT remainingSleepTimeChanged(remainingSleepTime());
} else {
stopSleepTimer();
}
}
void AudioManager::stopSleepTimer()
{
if (d->m_sleepTimer) {
d->m_sleepTime = -1;
d->m_remainingSleepTime = -1;
delete d->m_sleepTimer;
d->m_sleepTimer = nullptr;
Q_EMIT sleepTimerChanged(-1);
Q_EMIT remainingSleepTimeChanged(-1);
}
}
QString AudioManager::formattedRemainingSleepTime() const
{
qint64 timeLeft = remainingSleepTime() * 1000;
if (timeLeft < 0) {
timeLeft = 0;
}
return m_kformat.formatDuration(timeLeft);
}
Reference in New Issue Copy Permalink