Use QAudioOutput in QMediaPlayer

Adjust QMediaPlayer to the new audio output architecture.
One now needs to explicitly add a QAudioOutput to the
media player to get audio playback. While this requires
two more lines of code to set up the media player, it does
make the API consistent between audio and video and also
consistent with what we have in QMediaCaptureSession.

Adjusted auto tests where required and ported all platforms.

Change-Id: I247e915e4862dee6d6bce367b83664b1d1d69726
Reviewed-by: Volker Hilsheimer <volker.hilsheimer@qt.io>

8 files changed, 212 insertions, 110 deletions

diff --git a/tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp b/tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp
index 5200edb40..0a4897c25 100644
--- a/tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp
+++ b/tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp
@@ -34,6 +34,7 @@
 #include <qaudiobuffer.h>
 #include <qvideosink.h>
 #include <qvideoframe.h>
+#include <qaudiooutput.h>
 
 #include "../shared/mediafileselector.h"
 //TESTED_COMPONENT=src/multimedia
@@ -200,6 +201,8 @@ void tst_QMediaPlayerBackend::loadMedia()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::NoMedia);
@@ -233,6 +236,8 @@ void tst_QMediaPlayerBackend::unloadMedia()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     QSignalSpy stateSpy(&player, SIGNAL(playbackStateChanged(QMediaPlayer::PlaybackState)));
     QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
@@ -278,6 +283,8 @@ void tst_QMediaPlayerBackend::loadMediaInLoadingState()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
     player.setSource(localWavFile2);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::LoadingMedia);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
@@ -298,6 +305,8 @@ void tst_QMediaPlayerBackend::playPauseStop()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     QSignalSpy stateSpy(&player, SIGNAL(playbackStateChanged(QMediaPlayer::PlaybackState)));
     QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
@@ -452,6 +461,8 @@ void tst_QMediaPlayerBackend::processEOS()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     QSignalSpy stateSpy(&player, SIGNAL(playbackStateChanged(QMediaPlayer::PlaybackState)));
     QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
@@ -586,6 +597,8 @@ void tst_QMediaPlayerBackend::deleteLaterAtEOS()
         QSKIP("Sound format is not supported");
 
     QPointer<QMediaPlayer> player(new QMediaPlayer);
+    QAudioOutput output;
+    player->setAudioOutput(&output);
     DeleteLaterAtEos deleter(player);
     player->setSource(localWavFile);
 
@@ -606,46 +619,48 @@ void tst_QMediaPlayerBackend::volumeAndMuted()
 {
     //volume and muted properties should be independent
     QMediaPlayer player;
-    QVERIFY(player.volume() > 0);
-    QVERIFY(!player.isMuted());
+    QAudioOutput output;
+    player.setAudioOutput(&output);
+    QCOMPARE(output.volume(), 1.);
+    QVERIFY(!output.isMuted());
 
     player.setSource(localWavFile);
     player.pause();
 
-    QVERIFY(player.volume() > 0);
-    QVERIFY(!player.isMuted());
+    QCOMPARE(output.volume(), 1.);
+    QVERIFY(!output.isMuted());
 
-    QSignalSpy volumeSpy(&player, SIGNAL(volumeChanged(int)));
-    QSignalSpy mutedSpy(&player, SIGNAL(mutedChanged(bool)));
+    QSignalSpy volumeSpy(&output, SIGNAL(volumeChanged(float)));
+    QSignalSpy mutedSpy(&output, SIGNAL(mutedChanged(bool)));
 
     //setting volume to 0 should not trigger muted
-    player.setVolume(0);
-    QTRY_COMPARE(player.volume(), 0);
-    QVERIFY(!player.isMuted());
+    output.setVolume(0);
+    QTRY_COMPARE(output.volume(), 0);
+    QVERIFY(!output.isMuted());
     QCOMPARE(volumeSpy.count(), 1);
-    QCOMPARE(volumeSpy.last()[0].toInt(), player.volume());
+    QCOMPARE(volumeSpy.last()[0].toFloat(), output.volume());
     QCOMPARE(mutedSpy.count(), 0);
 
-    player.setVolume(50);
-    QTRY_COMPARE(player.volume(), 50);
-    QVERIFY(!player.isMuted());
+    output.setVolume(0.5);
+    QTRY_COMPARE(output.volume(), 0.5);
+    QVERIFY(!output.isMuted());
     QCOMPARE(volumeSpy.count(), 2);
-    QCOMPARE(volumeSpy.last()[0].toInt(), player.volume());
+    QCOMPARE(volumeSpy.last()[0].toFloat(), output.volume());
     QCOMPARE(mutedSpy.count(), 0);
 
-    player.setMuted(true);
-    QTRY_VERIFY(player.isMuted());
-    QVERIFY(player.volume() > 0);
+    output.setMuted(true);
+    QTRY_VERIFY(output.isMuted());
+    QVERIFY(output.volume() > 0);
     QCOMPARE(volumeSpy.count(), 2);
     QCOMPARE(mutedSpy.count(), 1);
-    QCOMPARE(mutedSpy.last()[0].toBool(), player.isMuted());
+    QCOMPARE(mutedSpy.last()[0].toBool(), output.isMuted());
 
-    player.setMuted(false);
-    QTRY_VERIFY(!player.isMuted());
-    QVERIFY(player.volume() > 0);
+    output.setMuted(false);
+    QTRY_VERIFY(!output.isMuted());
+    QVERIFY(output.volume() > 0);
     QCOMPARE(volumeSpy.count(), 2);
     QCOMPARE(mutedSpy.count(), 2);
-    QCOMPARE(mutedSpy.last()[0].toBool(), player.isMuted());
+    QCOMPARE(mutedSpy.last()[0].toBool(), output.isMuted());
 
 }
 
@@ -666,40 +681,43 @@ void tst_QMediaPlayerBackend::volumeAcrossFiles()
 {
     QFETCH(int, volume);
     QFETCH(bool, muted);
+    float vol = volume/100.;
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     //volume and muted should not be preserved between player instances
-    QVERIFY(player.volume() > 0);
-    QVERIFY(!player.isMuted());
+    QVERIFY(output.volume() > 0);
+    QVERIFY(!output.isMuted());
 
-    player.setVolume(volume);
-    player.setMuted(muted);
+    output.setVolume(vol);
+    output.setMuted(muted);
 
-    QTRY_COMPARE(player.volume(), volume);
-    QTRY_COMPARE(player.isMuted(), muted);
+    QTRY_COMPARE(output.volume(), vol);
+    QTRY_COMPARE(output.isMuted(), muted);
 
     player.setSource(localWavFile);
-    QCOMPARE(player.volume(), volume);
-    QCOMPARE(player.isMuted(), muted);
+    QCOMPARE(output.volume(), vol);
+    QCOMPARE(output.isMuted(), muted);
 
     player.pause();
 
     //to ensure the backend doesn't change volume/muted
     //async during file loading.
 
-    QTRY_COMPARE(player.volume(), volume);
-    QCOMPARE(player.isMuted(), muted);
+    QTRY_COMPARE(output.volume(), vol);
+    QCOMPARE(output.isMuted(), muted);
 
     player.setSource(QUrl());
-    QTRY_COMPARE(player.volume(), volume);
-    QCOMPARE(player.isMuted(), muted);
+    QTRY_COMPARE(output.volume(), vol);
+    QCOMPARE(output.isMuted(), muted);
 
     player.setSource(localWavFile);
     player.pause();
 
-    QTRY_COMPARE(player.volume(), volume);
-    QCOMPARE(player.isMuted(), muted);
+    QTRY_COMPARE(output.volume(), vol);
+    QCOMPARE(output.isMuted(), muted);
 }
 
 void tst_QMediaPlayerBackend::initialVolume()
@@ -709,21 +727,25 @@ void tst_QMediaPlayerBackend::initialVolume()
 
     {
         QMediaPlayer player;
-        player.setVolume(1);
+        QAudioOutput output;
+        player.setAudioOutput(&output);
+        output.setVolume(1);
         player.setSource(localWavFile);
-        QCOMPARE(player.volume(), 1);
+        QCOMPARE(output.volume(), 1);
         player.play();
         QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::EndOfMedia);
-        QCOMPARE(player.volume(), 1);
+        QCOMPARE(output.volume(), 1);
     }
 
     {
         QMediaPlayer player;
+        QAudioOutput output;
+        player.setAudioOutput(&output);
         player.setSource(localWavFile);
-        QCOMPARE(player.volume(), 100);
+        QCOMPARE(output.volume(), 1);
         player.play();
         QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::EndOfMedia);
-        QCOMPARE(player.volume(), 100);
+        QCOMPARE(output.volume(), 1);
     }
 }
 
@@ -733,6 +755,8 @@ void tst_QMediaPlayerBackend::seekPauseSeek()
         QSKIP("No supported video file");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     QSignalSpy positionSpy(&player, SIGNAL(positionChanged(qint64)));
 
@@ -805,6 +829,8 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
         QSKIP("No supported video file");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     QSignalSpy stateSpy(&player, SIGNAL(playbackStateChanged(QMediaPlayer::PlaybackState)));
     QSignalSpy positionSpy(&player, SIGNAL(positionChanged(qint64)));
@@ -923,6 +949,8 @@ void tst_QMediaPlayerBackend::subsequentPlayback()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
     player.setSource(localCompressedSoundFile);
     player.setPosition(5000);
     player.play();
@@ -961,6 +989,8 @@ void tst_QMediaPlayerBackend::surfaceTest()
 
     TestVideoSink surface(false);
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
     player.setVideoOutput(&surface);
     player.setSource(localVideoFile);
     player.play();
@@ -994,6 +1024,8 @@ void tst_QMediaPlayerBackend::metadata()
         QSKIP("No supported media file");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     QSignalSpy metadataChangedSpy(&player, SIGNAL(metaDataChanged()));
 
@@ -1019,6 +1051,8 @@ void tst_QMediaPlayerBackend::playerStateAtEOS()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     bool endOfMediaReceived = false;
     connect(&player, &QMediaPlayer::mediaStatusChanged, [&](QMediaPlayer::MediaStatus status) {
diff --git a/tests/auto/integration/shared/mediafileselector.h b/tests/auto/integration/shared/mediafileselector.h
index b12cb6525..a9699fc0a 100644
--- a/tests/auto/integration/shared/mediafileselector.h
+++ b/tests/auto/integration/shared/mediafileselector.h
@@ -31,6 +31,7 @@
 
 #include <QUrl>
 #include <QMediaPlayer>
+#include <QAudioOutput>
 #include <qsignalspy.h>
 #include <qfileinfo.h>
 #include <qtest.h>
@@ -42,6 +43,8 @@ namespace MediaFileSelector {
 static QUrl selectMediaFile(const QStringList& mediaCandidates)
 {
     QMediaPlayer player;
+    QAudioOutput output;
+    player.setAudioOutput(&output);
 
     QSignalSpy errorSpy(&player, SIGNAL(errorOccurred(QMediaPlayer::Error, const QString&)));
 
diff --git a/tests/auto/unit/mockbackend/CMakeLists.txt b/tests/auto/unit/mockbackend/CMakeLists.txt
index 8f43aafdd..56f2c11aa 100644
--- a/tests/auto/unit/mockbackend/CMakeLists.txt
+++ b/tests/auto/unit/mockbackend/CMakeLists.txt
@@ -14,6 +14,7 @@ target_link_libraries(QtMultimediaMockBackend INTERFACE
 )
 target_sources(QtMultimediaMockBackend INTERFACE
     qmockaudiodecoder.h
+    qmockaudiooutput.h
     qmockcamera.h
     qmockimagecapture.h qmockimagecapture.cpp
     qmockmediaplayer.h
diff --git a/tests/auto/unit/mockbackend/qmockaudiooutput.h b/tests/auto/unit/mockbackend/qmockaudiooutput.h
new file mode 100644
index 000000000..02245a7a3
--- /dev/null
+++ b/tests/auto/unit/mockbackend/qmockaudiooutput.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2021 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef QMOCKAUDIOOUTPUT_H
+#define QMOCKAUDIOOUTPUT_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <private/qplatformaudiooutput_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QMockAudioOutput : public QPlatformAudioOutput
+{
+public:
+    QMockAudioOutput(QAudioOutput *qq) : QPlatformAudioOutput(qq) {}
+
+    virtual QList<QAudio::Role> supportedAudioRoles() const {
+        if (!hasAudioRole)
+            return {};
+        return QList<QAudio::Role>() << QAudio::MusicRole
+                                     << QAudio::AlarmRole
+                                     << QAudio::NotificationRole;
+    }
+
+    bool hasAudioRole = true;
+};
+
+QT_END_NAMESPACE
+
+
+#endif // QMOCKAUDIOOUTPUT_H
diff --git a/tests/auto/unit/mockbackend/qmockintegration.cpp b/tests/auto/unit/mockbackend/qmockintegration.cpp
index 55a92c3c7..69e5c8e05 100644
--- a/tests/auto/unit/mockbackend/qmockintegration.cpp
+++ b/tests/auto/unit/mockbackend/qmockintegration.cpp
@@ -45,6 +45,7 @@
 #include "qmockmediacapturesession.h"
 #include "qmockvideosink.h"
 #include "qmockimagecapture.h"
+#include "qmockaudiooutput.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -118,6 +119,11 @@ QPlatformVideoSink *QMockIntegration::createVideoSink(QVideoSink *sink)
     return m_lastVideoSink;
 }
 
+QPlatformAudioOutput *QMockIntegration::createAudioOutput(QAudioOutput *q)
+{
+    return new QMockAudioOutput(q);
+}
+
 bool QMockCamera::simpleCamera = false;
 
 QT_END_NAMESPACE
diff --git a/tests/auto/unit/mockbackend/qmockintegration_p.h b/tests/auto/unit/mockbackend/qmockintegration_p.h
index 5f11cb680..1625c021f 100644
--- a/tests/auto/unit/mockbackend/qmockintegration_p.h
+++ b/tests/auto/unit/mockbackend/qmockintegration_p.h
@@ -79,6 +79,8 @@ public:
     QPlatformMediaCaptureSession *createCaptureSession() override;
     QPlatformVideoSink *createVideoSink(QVideoSink *) override;
 
+    QPlatformAudioOutput *createAudioOutput(QAudioOutput *) override;
+
     enum Flag {
         NoPlayerInterface = 0x1,
         NoAudioDecoderInterface = 0x2,
diff --git a/tests/auto/unit/mockbackend/qmockmediaplayer.h b/tests/auto/unit/mockbackend/qmockmediaplayer.h
index 793330f23..81969d256 100644
--- a/tests/auto/unit/mockbackend/qmockmediaplayer.h
+++ b/tests/auto/unit/mockbackend/qmockmediaplayer.h
@@ -45,8 +45,6 @@ public:
         , _error(QMediaPlayer::NoError)
         , _duration(0)
         , _position(0)
-        , _volume(100)
-        , _muted(false)
         , _bufferProgress(0)
         , _audioAvailable(false)
         , _videoAvailable(false)
@@ -77,12 +75,6 @@ public:
 
     void setPosition(qint64 position) { if (position != _position) emit positionChanged(_position = position); }
 
-    int volume() const { return _volume; }
-    void setVolume(int volume) { emit volumeChanged(_volume = volume); }
-
-    bool isMuted() const { return _muted; }
-    void setMuted(bool muted) { if (muted != _muted) emit mutedChanged(_muted = muted); }
-
     float bufferProgress() const { return _bufferProgress; }
     void setBufferStatus(float status)
     {
@@ -121,23 +113,10 @@ public:
     void pause() { if (_isValid && !_media.isEmpty()) setState(QMediaPlayer::PausedState); }
     void stop() { if (_state != QMediaPlayer::StoppedState) setState(QMediaPlayer::StoppedState); }
 
-    void setAudioRole(QAudio::Role role)
-    {
-        if (hasAudioRole)
-            m_audioRole = role;
-    }
-
-    QList<QAudio::Role> supportedAudioRoles() const
-    {
-        if (!hasAudioRole)
-            return {};
-        return QList<QAudio::Role>() << QAudio::MusicRole
-                                     << QAudio::AlarmRole
-                                     << QAudio::NotificationRole;
-    }
-
     void setVideoSink(QVideoSink *) {}
 
+    void setAudioOutput(QPlatformAudioOutput *output) { m_audioOutput = output; }
+
     void emitError(QMediaPlayer::Error err, const QString &errorString)
     {
         emit error(err, errorString);
@@ -174,8 +153,6 @@ public:
         _error = QMediaPlayer::NoError;
         _duration = 0;
         _position = 0;
-        _volume = 0;
-        _muted = false;
         _bufferProgress = 0;
         _videoAvailable = false;
         _isSeekable = false;
@@ -184,19 +161,13 @@ public:
         _stream = 0;
         _isValid = false;
         _errorString = QString();
-        hasAudioRole = true;
     }
 
 
-    bool hasAudioRole = true;
-    QAudio::Role m_audioRole = QAudio::UnknownRole;
-
     QMediaPlayer::PlaybackState _state;
     QMediaPlayer::Error _error;
     qint64 _duration;
     qint64 _position;
-    int _volume;
-    bool _muted;
     float _bufferProgress;
     bool _audioAvailable;
     bool _videoAvailable;
@@ -208,6 +179,7 @@ public:
     bool _isValid;
     QString _errorString;
     bool m_supportsStreamPlayback = false;
+    QPlatformAudioOutput *m_audioOutput = nullptr;
 };
 
 QT_END_NAMESPACE
diff --git a/tests/auto/unit/multimedia/qmediaplayer/tst_qmediaplayer.cpp b/tests/auto/unit/multimedia/qmediaplayer/tst_qmediaplayer.cpp
index 0a069b664..9e3c30466 100644
--- a/tests/auto/unit/multimedia/qmediaplayer/tst_qmediaplayer.cpp
+++ b/tests/auto/unit/multimedia/qmediaplayer/tst_qmediaplayer.cpp
@@ -41,7 +41,9 @@
 
 #include "qmockintegration_p.h"
 #include "qmockmediaplayer.h"
+#include "qmockaudiooutput.h"
 #include "qvideosink.h"
+#include "qaudiooutput.h"
 
 QT_USE_NAMESPACE
 
@@ -123,6 +125,7 @@ private:
 
     QMockIntegration *mockIntegration;
     QMockMediaPlayer *mockPlayer;
+    QAudioOutput *audioOutput = nullptr;
     QMediaPlayer *player;
 };
 
@@ -214,6 +217,9 @@ void tst_QMediaPlayer::init()
     player = new QMediaPlayer;
     mockPlayer = mockIntegration->lastPlayer();
     Q_ASSERT(mockPlayer);
+    audioOutput = new QAudioOutput;
+    player->setAudioOutput(audioOutput);
+    Q_ASSERT(mockPlayer->m_audioOutput != nullptr);
 }
 
 void tst_QMediaPlayer::cleanup()
@@ -326,29 +332,30 @@ void tst_QMediaPlayer::testVolume()
 {
     QFETCH(bool, valid);
     QFETCH(int, volume);
+    float vol = volume/100.;
 
-    mockPlayer->setVolume(volume);
-    QVERIFY(player->volume() == volume);
+    audioOutput->setVolume(vol);
+    QVERIFY(audioOutput->volume() == vol);
 
     if (valid) {
-        { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));
-        player->setVolume(10);
-        QCOMPARE(player->volume(), 10);
+        { QSignalSpy spy(audioOutput, SIGNAL(volumeChanged(float)));
+        audioOutput->setVolume(.1f);
+        QCOMPARE(audioOutput->volume(), .1f);
         QCOMPARE(spy.count(), 1); }
 
-        { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));
-        player->setVolume(-1000);
-        QCOMPARE(player->volume(), 0);
+        { QSignalSpy spy(audioOutput, SIGNAL(volumeChanged(float)));
+        audioOutput->setVolume(-1000.f);
+        QCOMPARE(audioOutput->volume(), 0.f);
         QCOMPARE(spy.count(), 1); }
 
-        { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));
-        player->setVolume(100);
-        QCOMPARE(player->volume(), 100);
+        { QSignalSpy spy(audioOutput, SIGNAL(volumeChanged(float)));
+        audioOutput->setVolume(1.f);
+        QCOMPARE(audioOutput->volume(), 1.f);
         QCOMPARE(spy.count(), 1); }
 
-        { QSignalSpy spy(player, SIGNAL(volumeChanged(int)));
-        player->setVolume(1000);
-        QCOMPARE(player->volume(), 100);
+        { QSignalSpy spy(audioOutput, SIGNAL(volumeChanged(float)));
+        audioOutput->setVolume(1000.f);
+        QCOMPARE(audioOutput->volume(), 1.f);
         QCOMPARE(spy.count(), 0); }
     }
 }
@@ -363,16 +370,17 @@ void tst_QMediaPlayer::testMuted()
     QFETCH(bool, valid);
     QFETCH(bool, muted);
     QFETCH(int, volume);
+    float vol = volume/100.;
 
     if (valid) {
-        mockPlayer->setMuted(muted);
-        mockPlayer->setVolume(volume);
-        QVERIFY(player->isMuted() == muted);
-
-        QSignalSpy spy(player, SIGNAL(mutedChanged(bool)));
-        player->setMuted(!muted);
-        QCOMPARE(player->isMuted(), !muted);
-        QCOMPARE(player->volume(), volume);
+        audioOutput->setMuted(muted);
+        audioOutput->setVolume(vol);
+        QVERIFY(audioOutput->isMuted() == muted);
+
+        QSignalSpy spy(audioOutput, SIGNAL(mutedChanged(bool)));
+        audioOutput->setMuted(!muted);
+        QCOMPARE(audioOutput->isMuted(), !muted);
+        QCOMPARE(audioOutput->volume(), vol);
         QCOMPARE(spy.count(), 1);
     }
 }
@@ -784,36 +792,36 @@ void tst_QMediaPlayer::testQrc()
 
 void tst_QMediaPlayer::testAudioRole()
 {
+    auto *mockAudioOutput = static_cast<QMockAudioOutput *>(mockPlayer->m_audioOutput);
     {
-        mockPlayer->hasAudioRole = false;
+        mockAudioOutput->hasAudioRole = false;
 
-        QCOMPARE(player->audioRole(), QAudio::UnknownRole);
-        QVERIFY(player->supportedAudioRoles().isEmpty());
+        QCOMPARE(audioOutput->audioRole(), QAudio::UnknownRole);
+        QVERIFY(audioOutput->supportedAudioRoles().isEmpty());
 
-        QSignalSpy spy(player, SIGNAL(audioRoleChanged(QAudio::Role)));
-        player->setAudioRole(QAudio::MusicRole);
-        QCOMPARE(player->audioRole(), QAudio::MusicRole);
-        QCOMPARE(spy.count(), 1);
-        player->setAudioRole(QAudio::UnknownRole);
+        QSignalSpy spy(audioOutput, SIGNAL(audioRoleChanged(QAudio::Role)));
+        audioOutput->setAudioRole(QAudio::MusicRole);
+        QCOMPARE(audioOutput->audioRole(), QAudio::UnknownRole);
+        QCOMPARE(spy.count(), 0);
     }
 
     {
         mockPlayer->reset();
-        mockPlayer->hasAudioRole = true;
-        QSignalSpy spy(player, SIGNAL(audioRoleChanged(QAudio::Role)));
+        mockAudioOutput->hasAudioRole = true;
+        QSignalSpy spy(audioOutput, SIGNAL(audioRoleChanged(QAudio::Role)));
 
-        QCOMPARE(player->audioRole(), QAudio::UnknownRole);
-        QVERIFY(!player->supportedAudioRoles().isEmpty());
+        QCOMPARE(audioOutput->audioRole(), QAudio::UnknownRole);
+        QVERIFY(!audioOutput->supportedAudioRoles().isEmpty());
 
-        player->setAudioRole(QAudio::MusicRole);
-        QCOMPARE(player->audioRole(), QAudio::MusicRole);
+        audioOutput->setAudioRole(QAudio::MusicRole);
+        QCOMPARE(audioOutput->audioRole(), QAudio::MusicRole);
         QCOMPARE(spy.count(), 1);
         QCOMPARE(qvariant_cast<QAudio::Role>(spy.last().value(0)), QAudio::MusicRole);
 
         spy.clear();
 
-        player->setProperty("audioRole", QVariant::fromValue(QAudio::AlarmRole));
-        QCOMPARE(qvariant_cast<QAudio::Role>(player->property("audioRole")), QAudio::AlarmRole);
+        audioOutput->setProperty("audioRole", QVariant::fromValue(QAudio::AlarmRole));
+        QCOMPARE(qvariant_cast<QAudio::Role>(audioOutput->property("audioRole")), QAudio::AlarmRole);
         QCOMPARE(spy.count(), 1);
         QCOMPARE(qvariant_cast<QAudio::Role>(spy.last().value(0)), QAudio::AlarmRole);
     }