API cleanups in QMediaPlayer

Rename some methods with better names and adjust the API so
that it also can be used for QML.

Change-Id: Ica19675966680416fbe870808336d8fc82065bc1
Reviewed-by: Lars Knoll <lars.knoll@qt.io>
Reviewed-by: Doris Verria <doris.verria@qt.io>

34 files changed, 388 insertions, 309 deletions

diff --git a/examples/multimediawidgets/player/player.cpp b/examples/multimediawidgets/player/player.cpp
index f0c48cd18..0afa721a1 100644
--- a/examples/multimediawidgets/player/player.cpp
+++ b/examples/multimediawidgets/player/player.cpp
@@ -87,10 +87,10 @@ Player::Player(QWidget *parent)
     connect(m_player, QOverload<>::of(&QMediaPlayer::metaDataChanged), this, &Player::metaDataChanged);
     connect(m_playlist, &QMediaPlaylist::currentIndexChanged, this, &Player::playlistPositionChanged);
     connect(m_player, &QMediaPlayer::mediaStatusChanged, this, &Player::statusChanged);
-    connect(m_player, &QMediaPlayer::bufferStatusChanged, this, &Player::bufferingProgress);
-    connect(m_player, &QMediaPlayer::videoAvailableChanged, this, &Player::videoAvailableChanged);
-    connect(m_player, QOverload<QMediaPlayer::Error>::of(&QMediaPlayer::error), this, &Player::displayErrorMessage);
-    connect(m_player, &QMediaPlayer::stateChanged, this, &Player::stateChanged);
+    connect(m_player, &QMediaPlayer::bufferProgressChanged, this, &Player::bufferingProgress);
+    connect(m_player, &QMediaPlayer::hasVideoChanged, this, &Player::videoAvailableChanged);
+    connect(m_player, &QMediaPlayer::errorChanged, this, &Player::displayErrorMessage);
+    connect(m_player, &QMediaPlayer::playbackStateChanged, this, &Player::stateChanged);
     connect(m_player, &QMediaPlayer::tracksChanged, this, &Player::tracksChanged);
 
     m_playlistView = new QListView(this);
@@ -164,7 +164,7 @@ Player::Player(QWidget *parent)
     connect(openButton, &QPushButton::clicked, this, &Player::open);
 
     PlayerControls *controls = new PlayerControls(this);
-    controls->setState(m_player->state());
+    controls->setState(m_player->playbackState());
     controls->setVolume(m_player->volume());
     controls->setMuted(controls->isMuted());
 
@@ -178,7 +178,7 @@ Player::Player(QWidget *parent)
     connect(controls, &PlayerControls::changeRate, m_player, &QMediaPlayer::setPlaybackRate);
     connect(controls, &PlayerControls::stop, m_videoWidget, QOverload<>::of(&QVideoWidget::update));
 
-    connect(m_player, &QMediaPlayer::stateChanged, controls, &PlayerControls::setState);
+    connect(m_player, &QMediaPlayer::playbackStateChanged, controls, &PlayerControls::setState);
     connect(m_player, &QMediaPlayer::volumeChanged, controls, &PlayerControls::setVolume);
     connect(m_player, &QMediaPlayer::mutedChanged, controls, &PlayerControls::setMuted);
 
@@ -381,7 +381,7 @@ void Player::playlistPositionChanged(int currentItem)
 {
     clearHistogram();
     m_playlistView->setCurrentIndex(m_playlistModel->index(currentItem, 0));
-    m_player->setMedia(m_playlist->currentMedia());
+    m_player->setSource(m_playlist->currentMedia());
 }
 
 void Player::seek(int seconds)
@@ -405,10 +405,10 @@ void Player::statusChanged(QMediaPlayer::MediaStatus status)
         break;
     case QMediaPlayer::BufferingMedia:
     case QMediaPlayer::BufferedMedia:
-        setStatusInfo(tr("Buffering %1%").arg(m_player->bufferStatus()));
+        setStatusInfo(tr("Buffering %1%").arg(m_player->bufferProgress()));
         break;
     case QMediaPlayer::StalledMedia:
-        setStatusInfo(tr("Stalled %1%").arg(m_player->bufferStatus()));
+        setStatusInfo(tr("Stalled %1%").arg(m_player->bufferProgress()));
         break;
     case QMediaPlayer::EndOfMedia:
         QApplication::alert(this);
@@ -420,7 +420,7 @@ void Player::statusChanged(QMediaPlayer::MediaStatus status)
     }
 }
 
-void Player::stateChanged(QMediaPlayer::State state)
+void Player::stateChanged(QMediaPlayer::PlaybackState state)
 {
     if (state == QMediaPlayer::StoppedState)
         clearHistogram();
@@ -512,6 +512,8 @@ void Player::setStatusInfo(const QString &info)
 
 void Player::displayErrorMessage()
 {
+    if (m_player->error() == QMediaPlayer::NoError)
+        return;
     setStatusInfo(m_player->errorString());
 }
 
diff --git a/examples/multimediawidgets/player/player.h b/examples/multimediawidgets/player/player.h
index 9ccecb891..4294e909a 100644
--- a/examples/multimediawidgets/player/player.h
+++ b/examples/multimediawidgets/player/player.h
@@ -100,7 +100,7 @@ private slots:
     void playlistPositionChanged(int);
 
     void statusChanged(QMediaPlayer::MediaStatus status);
-    void stateChanged(QMediaPlayer::State state);
+    void stateChanged(QMediaPlayer::PlaybackState state);
     void bufferingProgress(int progress);
     void videoAvailableChanged(bool available);
 
diff --git a/examples/multimediawidgets/player/playercontrols.cpp b/examples/multimediawidgets/player/playercontrols.cpp
index 3c06c01c6..671c7eaf1 100644
--- a/examples/multimediawidgets/player/playercontrols.cpp
+++ b/examples/multimediawidgets/player/playercontrols.cpp
@@ -111,12 +111,12 @@ PlayerControls::PlayerControls(QWidget *parent)
     setLayout(layout);
 }
 
-QMediaPlayer::State PlayerControls::state() const
+QMediaPlayer::PlaybackState PlayerControls::state() const
 {
     return m_playerState;
 }
 
-void PlayerControls::setState(QMediaPlayer::State state)
+void PlayerControls::setState(QMediaPlayer::PlaybackState state)
 {
     if (state != m_playerState) {
         m_playerState = state;
diff --git a/examples/multimediawidgets/player/playercontrols.h b/examples/multimediawidgets/player/playercontrols.h
index bf1f676c1..3021e4859 100644
--- a/examples/multimediawidgets/player/playercontrols.h
+++ b/examples/multimediawidgets/player/playercontrols.h
@@ -67,13 +67,13 @@ class PlayerControls : public QWidget
 public:
     explicit PlayerControls(QWidget *parent = nullptr);
 
-    QMediaPlayer::State state() const;
+    QMediaPlayer::PlaybackState state() const;
     int volume() const;
     bool isMuted() const;
     qreal playbackRate() const;
 
 public slots:
-    void setState(QMediaPlayer::State state);
+    void setState(QMediaPlayer::PlaybackState state);
     void setVolume(int volume);
     void setMuted(bool muted);
     void setPlaybackRate(float rate);
@@ -95,7 +95,7 @@ private slots:
     void onVolumeSliderValueChanged();
 
 private:
-    QMediaPlayer::State m_playerState = QMediaPlayer::StoppedState;
+    QMediaPlayer::PlaybackState m_playerState = QMediaPlayer::StoppedState;
     bool m_playerMuted = false;
     QAbstractButton *m_playButton = nullptr;
     QAbstractButton *m_stopButton = nullptr;
diff --git a/examples/multimediawidgets/videographicsitem/videoplayer.cpp b/examples/multimediawidgets/videographicsitem/videoplayer.cpp
index d0f5129c9..2f76f2be3 100644
--- a/examples/multimediawidgets/videographicsitem/videoplayer.cpp
+++ b/examples/multimediawidgets/videographicsitem/videoplayer.cpp
@@ -101,7 +101,7 @@ VideoPlayer::VideoPlayer(QWidget *parent)
     layout->addLayout(controlLayout);
 
     m_mediaPlayer->setVideoOutput(m_videoItem);
-    connect(m_mediaPlayer, &QMediaPlayer::stateChanged,
+    connect(m_mediaPlayer, &QMediaPlayer::playbackStateChanged,
             this, &VideoPlayer::mediaStateChanged);
     connect(m_mediaPlayer, &QMediaPlayer::positionChanged, this, &VideoPlayer::positionChanged);
     connect(m_mediaPlayer, &QMediaPlayer::durationChanged, this, &VideoPlayer::durationChanged);
@@ -133,13 +133,13 @@ void VideoPlayer::openFile()
 
 void VideoPlayer::load(const QUrl &url)
 {
-    m_mediaPlayer->setMedia(url);
+    m_mediaPlayer->setSource(url);
     m_playButton->setEnabled(true);
 }
 
 void VideoPlayer::play()
 {
-    switch (m_mediaPlayer->state()) {
+    switch (m_mediaPlayer->playbackState()) {
     case QMediaPlayer::PlayingState:
         m_mediaPlayer->pause();
         break;
@@ -149,7 +149,7 @@ void VideoPlayer::play()
     }
 }
 
-void VideoPlayer::mediaStateChanged(QMediaPlayer::State state)
+void VideoPlayer::mediaStateChanged(QMediaPlayer::PlaybackState state)
 {
     switch(state) {
     case QMediaPlayer::PlayingState:
diff --git a/examples/multimediawidgets/videographicsitem/videoplayer.h b/examples/multimediawidgets/videographicsitem/videoplayer.h
index 87c20c804..9f01e8790 100644
--- a/examples/multimediawidgets/videographicsitem/videoplayer.h
+++ b/examples/multimediawidgets/videographicsitem/videoplayer.h
@@ -78,7 +78,7 @@ public slots:
     void play();
 
 private slots:
-    void mediaStateChanged(QMediaPlayer::State state);
+    void mediaStateChanged(QMediaPlayer::PlaybackState state);
     void positionChanged(qint64 position);
     void durationChanged(qint64 duration);
     void setPosition(int position);
diff --git a/examples/multimediawidgets/videowidget/videoplayer.cpp b/examples/multimediawidgets/videowidget/videoplayer.cpp
index 4ac868730..ded52499c 100644
--- a/examples/multimediawidgets/videowidget/videoplayer.cpp
+++ b/examples/multimediawidgets/videowidget/videoplayer.cpp
@@ -92,11 +92,11 @@ VideoPlayer::VideoPlayer(QWidget *parent)
     setLayout(layout);
 
     m_mediaPlayer->setVideoOutput(videoWidget);
-    connect(m_mediaPlayer, &QMediaPlayer::stateChanged,
+    connect(m_mediaPlayer, &QMediaPlayer::playbackStateChanged,
             this, &VideoPlayer::mediaStateChanged);
     connect(m_mediaPlayer, &QMediaPlayer::positionChanged, this, &VideoPlayer::positionChanged);
     connect(m_mediaPlayer, &QMediaPlayer::durationChanged, this, &VideoPlayer::durationChanged);
-    connect(m_mediaPlayer, QOverload<QMediaPlayer::Error>::of(&QMediaPlayer::error),
+    connect(m_mediaPlayer, &QMediaPlayer::errorChanged,
             this, &VideoPlayer::handleError);
 }
 
@@ -118,13 +118,13 @@ void VideoPlayer::setUrl(const QUrl &url)
 {
     m_errorLabel->setText(QString());
     setWindowFilePath(url.isLocalFile() ? url.toLocalFile() : QString());
-    m_mediaPlayer->setMedia(url);
+    m_mediaPlayer->setSource(url);
     m_playButton->setEnabled(true);
 }
 
 void VideoPlayer::play()
 {
-    switch (m_mediaPlayer->state()) {
+    switch (m_mediaPlayer->playbackState()) {
     case QMediaPlayer::PlayingState:
         m_mediaPlayer->pause();
         break;
@@ -134,7 +134,7 @@ void VideoPlayer::play()
     }
 }
 
-void VideoPlayer::mediaStateChanged(QMediaPlayer::State state)
+void VideoPlayer::mediaStateChanged(QMediaPlayer::PlaybackState state)
 {
     switch(state) {
     case QMediaPlayer::PlayingState:
@@ -163,6 +163,9 @@ void VideoPlayer::setPosition(int position)
 
 void VideoPlayer::handleError()
 {
+    if (m_mediaPlayer->error() == QMediaPlayer::NoError)
+        return;
+
     m_playButton->setEnabled(false);
     const QString errorString = m_mediaPlayer->errorString();
     QString message = "Error: ";
diff --git a/examples/multimediawidgets/videowidget/videoplayer.h b/examples/multimediawidgets/videowidget/videoplayer.h
index 62260d167..723df0b6c 100644
--- a/examples/multimediawidgets/videowidget/videoplayer.h
+++ b/examples/multimediawidgets/videowidget/videoplayer.h
@@ -75,7 +75,7 @@ public slots:
     void play();
 
 private slots:
-    void mediaStateChanged(QMediaPlayer::State state);
+    void mediaStateChanged(QMediaPlayer::PlaybackState state);
     void positionChanged(qint64 position);
     void durationChanged(qint64 duration);
     void setPosition(int position);
diff --git a/src/imports/multimedia/qdeclarativeaudio.cpp b/src/imports/multimedia/qdeclarativeaudio.cpp
index 7fe96666c..ea3a9121e 100644
--- a/src/imports/multimedia/qdeclarativeaudio.cpp
+++ b/src/imports/multimedia/qdeclarativeaudio.cpp
@@ -293,7 +293,7 @@ void QDeclarativeAudio::setSource(const QUrl &url)
             emit errorChanged();
         }
 
-        m_player->setMedia(m_source, nullptr);
+        m_player->setSource(m_source, nullptr);
         m_loaded = true;
     }
     else
@@ -337,7 +337,7 @@ void QDeclarativeAudio::setLoopCount(int loopCount)
     emit loopCountChanged();
 }
 
-void QDeclarativeAudio::setPlaybackState(QMediaPlayer::State playbackState)
+void QDeclarativeAudio::setPlaybackState(QMediaPlayer::PlaybackState playbackState)
 {
     if (m_playbackState == playbackState)
         return;
@@ -346,7 +346,7 @@ void QDeclarativeAudio::setPlaybackState(QMediaPlayer::State playbackState)
         switch (playbackState){
         case (QMediaPlayer::PlayingState):
             if (!m_loaded) {
-                m_player->setMedia(m_source, nullptr);
+                m_player->setSource(m_source, nullptr);
                 m_player->setPosition(m_position);
                 m_loaded = true;
             }
@@ -355,7 +355,7 @@ void QDeclarativeAudio::setPlaybackState(QMediaPlayer::State playbackState)
 
         case (QMediaPlayer::PausedState):
             if (!m_loaded) {
-                m_player->setMedia(m_source, nullptr);
+                m_player->setSource(m_source, nullptr);
                 m_player->setPosition(m_position);
                 m_loaded = true;
             }
@@ -421,7 +421,7 @@ void QDeclarativeAudio::setMuted(bool muted)
 
 qreal QDeclarativeAudio::bufferProgress() const
 {
-    return !m_complete ? 0 : qreal(m_player->bufferStatus()) / 100;
+    return !m_complete ? 0 : qreal(m_player->bufferProgress()) / 100;
 }
 
 bool QDeclarativeAudio::isSeekable() const
@@ -692,7 +692,7 @@ QDeclarativeAudio::PlaybackState QDeclarativeAudio::playbackState() const
 
 bool QDeclarativeAudio::hasAudio() const
 {
-    return !m_complete ? false : m_player->isAudioAvailable();
+    return !m_complete ? false : m_player->hasAudio();
 }
 
 /*!
@@ -703,7 +703,7 @@ bool QDeclarativeAudio::hasAudio() const
 
 bool QDeclarativeAudio::hasVideo() const
 {
-    return !m_complete ? false : m_player->isVideoAvailable();
+    return !m_complete ? false : m_player->hasVideo();
 }
 
 /*!
@@ -781,7 +781,7 @@ void QDeclarativeAudio::classBegin()
             this, SIGNAL(volumeChanged()));
     connect(m_player, SIGNAL(mutedChanged(bool)),
             this, SIGNAL(mutedChanged()));
-    connect(m_player, SIGNAL(bufferStatusChanged(int)),
+    connect(m_player, SIGNAL(bufferProgressChanged(float)),
             this, SIGNAL(bufferProgressChanged()));
     connect(m_player, SIGNAL(seekableChanged(bool)),
             this, SIGNAL(seekableChanged()));
@@ -816,7 +816,7 @@ void QDeclarativeAudio::componentComplete()
         m_player->setAudioRole(QAudio::Role(m_audioRole));
 
     if (!m_source.isEmpty() && (m_autoLoad || m_autoPlay)) {
-        m_player->setMedia(m_source, nullptr);
+        m_player->setSource(m_source, nullptr);
         m_loaded = true;
         if (m_position > 0)
             m_player->setPosition(m_position);
@@ -840,9 +840,9 @@ void QDeclarativeAudio::_q_statusChanged()
         m_player->play();
     }
     const QMediaPlayer::MediaStatus oldStatus = m_status;
-    const QMediaPlayer::State lastPlaybackState = m_playbackState;
+    const QMediaPlayer::PlaybackState lastPlaybackState = m_playbackState;
 
-    const QMediaPlayer::State state = m_player->state();
+    const QMediaPlayer::PlaybackState state = m_player->playbackState();
 
     m_playbackState = state;
 
diff --git a/src/imports/multimedia/qdeclarativeaudio_p.h b/src/imports/multimedia/qdeclarativeaudio_p.h
index 085d7e60a..9d64929e3 100644
--- a/src/imports/multimedia/qdeclarativeaudio_p.h
+++ b/src/imports/multimedia/qdeclarativeaudio_p.h
@@ -69,24 +69,25 @@ class QDeclarativeAudio : public QObject, public QQmlParserStatus
 {
     Q_OBJECT
     Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
-    Q_PROPERTY(int loops READ loopCount WRITE setLoopCount NOTIFY loopCountChanged)
-    Q_PROPERTY(PlaybackState playbackState READ playbackState NOTIFY playbackStateChanged)
-    Q_PROPERTY(bool autoPlay READ autoPlay WRITE setAutoPlay NOTIFY autoPlayChanged)
-    Q_PROPERTY(bool autoLoad READ isAutoLoad WRITE setAutoLoad NOTIFY autoLoadChanged)
-    Q_PROPERTY(Status status READ status NOTIFY statusChanged)
     Q_PROPERTY(int duration READ duration NOTIFY durationChanged)
     Q_PROPERTY(int position READ position NOTIFY positionChanged)
     Q_PROPERTY(qreal volume READ volume WRITE setVolume NOTIFY volumeChanged)
     Q_PROPERTY(bool muted READ isMuted WRITE setMuted NOTIFY mutedChanged)
+    Q_PROPERTY(Status status READ status NOTIFY statusChanged) // MediaStatus in QMediaPlayer
+    Q_PROPERTY(bool autoPlay READ autoPlay WRITE setAutoPlay NOTIFY autoPlayChanged)
+    Q_PROPERTY(PlaybackState playbackState READ playbackState NOTIFY playbackStateChanged)
     Q_PROPERTY(bool hasAudio READ hasAudio NOTIFY hasAudioChanged)
     Q_PROPERTY(bool hasVideo READ hasVideo NOTIFY hasVideoChanged)
-    Q_PROPERTY(qreal bufferProgress READ bufferProgress NOTIFY bufferProgressChanged)
     Q_PROPERTY(bool seekable READ isSeekable NOTIFY seekableChanged)
     Q_PROPERTY(qreal playbackRate READ playbackRate WRITE setPlaybackRate NOTIFY playbackRateChanged)
-    Q_PROPERTY(Error error READ error NOTIFY errorChanged)
     Q_PROPERTY(QString errorString READ errorString NOTIFY errorChanged)
-    Q_PROPERTY(QDeclarativeMediaMetaData *metaData READ metaData CONSTANT)
+    Q_PROPERTY(Error error READ error NOTIFY errorChanged)
     Q_PROPERTY(AudioRole audioRole READ audioRole WRITE setAudioRole NOTIFY audioRoleChanged REVISION 1)
+    Q_PROPERTY(qreal bufferProgress READ bufferProgress NOTIFY bufferProgressChanged)
+
+    Q_PROPERTY(int loops READ loopCount WRITE setLoopCount NOTIFY loopCountChanged) // not needed
+    Q_PROPERTY(bool autoLoad READ isAutoLoad WRITE setAutoLoad NOTIFY autoLoadChanged) // not needed
+    Q_PROPERTY(QDeclarativeMediaMetaData *metaData READ metaData CONSTANT)
     Q_PROPERTY(QVariant videoOutput READ videoOutput WRITE setVideoOutput NOTIFY videoOutputChanged REVISION 15)
     Q_ENUMS(Status)
     Q_ENUMS(Error)
@@ -155,7 +156,7 @@ public:
     Status status() const;
     Error error() const;
     PlaybackState playbackState() const;
-    void setPlaybackState(QMediaPlayer::State playbackState);
+    void setPlaybackState(QMediaPlayer::PlaybackState playbackState);
 
     void classBegin() override;
     void componentComplete() override;
@@ -260,7 +261,7 @@ private:
     qreal m_playbackRate;
     AudioRole m_audioRole;
 
-    QMediaPlayer::State m_playbackState;
+    QMediaPlayer::PlaybackState m_playbackState;
     QMediaPlayer::MediaStatus m_status;
     QMediaPlayer::Error m_error;
     QString m_errorString;
diff --git a/src/multimedia/platform/android/mediaplayer/qandroidmediaplayercontrol.cpp b/src/multimedia/platform/android/mediaplayer/qandroidmediaplayercontrol.cpp
index b1aaaf0ce..044770572 100644
--- a/src/multimedia/platform/android/mediaplayer/qandroidmediaplayercontrol.cpp
+++ b/src/multimedia/platform/android/mediaplayer/qandroidmediaplayercontrol.cpp
@@ -276,9 +276,9 @@ QMediaMetaData QAndroidMediaPlayerControl::metaData() const
     return QAndroidMetaData::extractMetadata(mMediaContent);
 }
 
-int QAndroidMediaPlayerControl::bufferStatus() const
+float QAndroidMediaPlayerControl::bufferProgress() const
 {
-    return mBufferFilled ? 100 : 0;
+    return mBufferFilled ? 1. : 0;
 }
 
 bool QAndroidMediaPlayerControl::isAudioAvailable() const
@@ -810,7 +810,7 @@ void QAndroidMediaPlayerControl::updateBufferStatus()
 
     if (mBufferFilled != bufferFilled) {
         mBufferFilled = bufferFilled;
-        Q_EMIT bufferStatusChanged(bufferStatus());
+        Q_EMIT bufferProgresChanged();
     }
 }
 
diff --git a/src/multimedia/platform/android/mediaplayer/qandroidmediaplayercontrol_p.h b/src/multimedia/platform/android/mediaplayer/qandroidmediaplayercontrol_p.h
index 4f098bd86..c5d835057 100644
--- a/src/multimedia/platform/android/mediaplayer/qandroidmediaplayercontrol_p.h
+++ b/src/multimedia/platform/android/mediaplayer/qandroidmediaplayercontrol_p.h
@@ -75,7 +75,7 @@ public:
     qint64 position() const override;
     int volume() const override;
     bool isMuted() const override;
-    int bufferStatus() const override;
+    float bufferProgress() const override;
     bool isAudioAvailable() const override;
     bool isVideoAvailable() const override;
     bool isSeekable() const override;
diff --git a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer.mm b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer.mm
index b0fa7b555..5f4da2d04 100644
--- a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer.mm
+++ b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer.mm
@@ -493,7 +493,7 @@ AVFMediaPlayer::AVFMediaPlayer(QMediaPlayer *player)
     , m_rate(1.0)
     , m_requestedPosition(-1)
     , m_duration(0)
-    , m_bufferStatus(0)
+    , m_bufferProgress(0)
     , m_videoAvailable(false)
     , m_audioAvailable(false)
     , m_seekable(false)
@@ -650,12 +650,12 @@ qint64 AVFMediaPlayer::duration() const
     return m_duration;
 }
 
-int AVFMediaPlayer::bufferStatus() const
+float AVFMediaPlayer::bufferProgress() const
 {
 #ifdef QT_DEBUG_AVF
     qDebug() << Q_FUNC_INFO;
 #endif
-    return m_bufferStatus;
+    return m_bufferProgress/100.;
 }
 
 int AVFMediaPlayer::volume() const
@@ -1022,14 +1022,14 @@ void AVFMediaPlayer::processLoadStateFailure()
     Q_EMIT stateChanged((m_state = QMediaPlayer::StoppedState));
 }
 
-void AVFMediaPlayer::processBufferStateChange(int bufferStatus)
+void AVFMediaPlayer::processBufferStateChange(int bufferProgress)
 {
-    if (bufferStatus == m_bufferStatus)
+    if (bufferProgress == m_bufferProgress)
         return;
 
     auto status = m_mediaStatus;
     // Buffered -> unbuffered.
-    if (!bufferStatus) {
+    if (!bufferProgress) {
         status = QMediaPlayer::StalledMedia;
     } else if (status == QMediaPlayer::StalledMedia) {
         status = QMediaPlayer::BufferedMedia;
@@ -1041,8 +1041,8 @@ void AVFMediaPlayer::processBufferStateChange(int bufferStatus)
     if (m_mediaStatus != status)
         Q_EMIT mediaStatusChanged(m_mediaStatus = status);
 
-    m_bufferStatus = bufferStatus;
-    Q_EMIT bufferStatusChanged(bufferStatus);
+    m_bufferProgress = bufferProgress;
+    Q_EMIT bufferProgressChanged(bufferProgress/100.);
 }
 
 void AVFMediaPlayer::processDurationChange(qint64 duration)
diff --git a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer_p.h b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer_p.h
index 53d4642f6..eeb372165 100644
--- a/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer_p.h
+++ b/src/multimedia/platform/darwin/mediaplayer/avfmediaplayer_p.h
@@ -91,7 +91,7 @@ public:
     qint64 position() const override;
     qint64 duration() const override;
 
-    int bufferStatus() const override;
+    float bufferProgress() const override;
 
     int volume() const override;
     bool isMuted() const override;
@@ -129,7 +129,7 @@ public Q_SLOTS:
     void processLoadStateChange();
     void processLoadStateFailure();
 
-    void processBufferStateChange(int bufferStatus);
+    void processBufferStateChange(int bufferProgress);
 
     void processDurationChange(qint64 duration);
 
@@ -167,7 +167,7 @@ private:
     qint64 m_requestedPosition;
 
     qint64 m_duration;
-    int m_bufferStatus;
+    int m_bufferProgress;
     bool m_videoAvailable;
     bool m_audioAvailable;
     bool m_seekable;
diff --git a/src/multimedia/platform/gstreamer/common/qgstreamermediaplayer.cpp b/src/multimedia/platform/gstreamer/common/qgstreamermediaplayer.cpp
index 0b914abbf..cbee22a15 100644
--- a/src/multimedia/platform/gstreamer/common/qgstreamermediaplayer.cpp
+++ b/src/multimedia/platform/gstreamer/common/qgstreamermediaplayer.cpp
@@ -117,7 +117,7 @@ qint64 QGstreamerMediaPlayer::duration() const
     return m_duration;
 }
 
-QMediaPlayer::State QGstreamerMediaPlayer::state() const
+QMediaPlayer::PlaybackState QGstreamerMediaPlayer::state() const
 {
     return m_state;
 }
@@ -127,9 +127,9 @@ QMediaPlayer::MediaStatus QGstreamerMediaPlayer::mediaStatus() const
     return m_mediaStatus;
 }
 
-int QGstreamerMediaPlayer::bufferStatus() const
+float QGstreamerMediaPlayer::bufferProgress() const
 {
-    return m_bufferProgress;
+    return m_bufferProgress/100.;
 }
 
 int QGstreamerMediaPlayer::volume() const
@@ -248,7 +248,7 @@ bool QGstreamerMediaPlayer::processBusMessage(const QGstreamerMessage &message)
         int progress = 0;
         gst_message_parse_buffering(gm, &progress);
         m_bufferProgress = progress;
-        emit bufferStatusChanged(progress);
+        emit bufferProgressChanged(m_bufferProgress/100.);
         break;
     }
     case GST_MESSAGE_STATE_CHANGED: {
@@ -284,7 +284,7 @@ bool QGstreamerMediaPlayer::processBusMessage(const QGstreamerMessage &message)
             break;
         case GST_STATE_PAUSED:
         {
-            QMediaPlayer::State prevState = m_state;
+            QMediaPlayer::PlaybackState prevState = m_state;
             m_state = QMediaPlayer::PausedState;
 
             if (prerolling) {
@@ -597,9 +597,9 @@ void QGstreamerMediaPlayer::setMedia(const QUrl &content, QIODevice *stream)
         decoder.connect("element-added", GCallback(QGstreamerMediaPlayer::uridecodebinElementAddedCallback), this);
 
         decoder.set("uri", content.toEncoded().constData());
-        if (m_bufferProgress != -1) {
-            m_bufferProgress = -1;
-            emit bufferStatusChanged(0);
+        if (m_bufferProgress != 0) {
+            m_bufferProgress = 0;
+            emit bufferProgressChanged(0.);
         }
     }
     decoder.onPadAdded<&QGstreamerMediaPlayer::decoderPadAdded>(this);
diff --git a/src/multimedia/platform/gstreamer/common/qgstreamermediaplayer_p.h b/src/multimedia/platform/gstreamer/common/qgstreamermediaplayer_p.h
index fac04ec21..6bdce0cf2 100644
--- a/src/multimedia/platform/gstreamer/common/qgstreamermediaplayer_p.h
+++ b/src/multimedia/platform/gstreamer/common/qgstreamermediaplayer_p.h
@@ -76,13 +76,13 @@ public:
     QGstreamerMediaPlayer(QMediaPlayer *parent = 0);
     ~QGstreamerMediaPlayer();
 
-    QMediaPlayer::State state() const override;
+    QMediaPlayer::PlaybackState state() const override;
     QMediaPlayer::MediaStatus mediaStatus() const override;
 
     qint64 position() const override;
     qint64 duration() const override;
 
-    int bufferStatus() const override;
+    float bufferProgress() const override;
 
     int volume() const override;
     bool isMuted() const override;
@@ -139,7 +139,7 @@ private:
     QMediaMetaData m_metaData;
     QList<QGstPad> m_streams[3];
 
-    QMediaPlayer::State m_state = QMediaPlayer::StoppedState;
+    QMediaPlayer::PlaybackState m_state = QMediaPlayer::StoppedState;
     QMediaPlayer::MediaStatus m_mediaStatus = QMediaPlayer::NoMedia;
 
     int m_bufferProgress = -1;
diff --git a/src/multimedia/platform/qnx/mediaplayer/mmrenderermediaplayercontrol.cpp b/src/multimedia/platform/qnx/mediaplayer/mmrenderermediaplayercontrol.cpp
index 71474d791..c78f515ef 100644
--- a/src/multimedia/platform/qnx/mediaplayer/mmrenderermediaplayercontrol.cpp
+++ b/src/multimedia/platform/qnx/mediaplayer/mmrenderermediaplayercontrol.cpp
@@ -128,12 +128,12 @@ void MmRendererMediaPlayerControl::handleMmSuspend(const QString &reason)
     setMediaStatus(QMediaPlayer::StalledMedia);
 }
 
-void MmRendererMediaPlayerControl::handleMmSuspendRemoval(const QString &bufferStatus)
+void MmRendererMediaPlayerControl::handleMmSuspendRemoval(const QString &bufferProgress)
 {
     if (m_state == QMediaPlayer::StoppedState)
         return;
 
-    if (bufferStatus == QLatin1String("buffering"))
+    if (bufferProgress == QLatin1String("buffering"))
         setMediaStatus(QMediaPlayer::BufferingMedia);
     else
         setMediaStatus(QMediaPlayer::BufferedMedia);
@@ -244,7 +244,7 @@ void MmRendererMediaPlayerControl::attach()
     // mm-renderer has buffer properties "status" and "level"
     // QMediaPlayer's buffer status maps to mm-renderer's buffer level
     m_bufferLevel = 0;
-    emit bufferStatusChanged(m_bufferLevel);
+    emit bufferProgressChanged(m_bufferLevel/100.);
 }
 
 void MmRendererMediaPlayerControl::detach()
@@ -407,11 +407,11 @@ void MmRendererMediaPlayerControl::setMuted(bool muted)
     }
 }
 
-int MmRendererMediaPlayerControl::bufferStatus() const
+float MmRendererMediaPlayerControl::bufferProgress() const
 {
     // mm-renderer has buffer properties "status" and "level"
     // QMediaPlayer's buffer status maps to mm-renderer's buffer level
-    return m_bufferLevel;
+    return m_bufferLevel/100.;
 }
 
 bool MmRendererMediaPlayerControl::isAudioAvailable() const
@@ -591,11 +591,11 @@ void MmRendererMediaPlayerControl::setMmPosition(qint64 newPosition)
     }
 }
 
-void MmRendererMediaPlayerControl::setMmBufferStatus(const QString &bufferStatus)
+void MmRendererMediaPlayerControl::setMmBufferStatus(const QString &bufferProgress)
 {
-    if (bufferStatus == QLatin1String("buffering"))
+    if (bufferProgress == QLatin1String("buffering"))
         setMediaStatus(QMediaPlayer::BufferingMedia);
-    else if (bufferStatus == QLatin1String("playing"))
+    else if (bufferProgress == QLatin1String("playing"))
         setMediaStatus(QMediaPlayer::BufferedMedia);
     // ignore "idle" buffer status
 }
@@ -604,7 +604,7 @@ void MmRendererMediaPlayerControl::setMmBufferLevel(int level, int capacity)
 {
     m_bufferLevel = capacity == 0 ? 0 : level / static_cast<float>(capacity) * 100.0f;
     m_bufferLevel = qBound(0, m_bufferLevel, 100);
-    emit bufferStatusChanged(m_bufferLevel);
+    emit bufferProgressChanged(m_bufferLevel/100.);
 }
 
 void MmRendererMediaPlayerControl::updateMetaData(const strm_dict *dict)
diff --git a/src/multimedia/platform/qnx/mediaplayer/mmrenderermediaplayercontrol_p.h b/src/multimedia/platform/qnx/mediaplayer/mmrenderermediaplayercontrol_p.h
index 5cb958785..62d7373a4 100644
--- a/src/multimedia/platform/qnx/mediaplayer/mmrenderermediaplayercontrol_p.h
+++ b/src/multimedia/platform/qnx/mediaplayer/mmrenderermediaplayercontrol_p.h
@@ -88,7 +88,7 @@ public:
     bool isMuted() const override;
     void setMuted(bool muted) override;
 
-    int bufferStatus() const override;
+    float bufferProgress() const override;
 
     bool isAudioAvailable() const override;
     bool isVideoAvailable() const override;
@@ -126,11 +126,11 @@ protected:
     void emitMmError(const QString &msg);
     void emitPError(const QString &msg);
     void setMmPosition(qint64 newPosition);
-    void setMmBufferStatus(const QString &bufferStatus);
+    void setMmBufferStatus(const QString &bufferProgress);
     void setMmBufferLevel(int level, int capacity);
     void handleMmStopped();
     void handleMmSuspend(const QString &reason);
-    void handleMmSuspendRemoval(const QString &bufferStatus);
+    void handleMmSuspendRemoval(const QString &bufferProgress);
     void handleMmPause();
     void handleMmPlay();
     void updateMetaData(const strm_dict_t *dict);
diff --git a/src/multimedia/platform/qnx/mediaplayer/mmreventmediaplayercontrol.cpp b/src/multimedia/platform/qnx/mediaplayer/mmreventmediaplayercontrol.cpp
index f2e2b999b..218fab7e9 100644
--- a/src/multimedia/platform/qnx/mediaplayer/mmreventmediaplayercontrol.cpp
+++ b/src/multimedia/platform/qnx/mediaplayer/mmreventmediaplayercontrol.cpp
@@ -67,7 +67,7 @@ static std::tuple<int, int, bool> parseBufferLevel(const QByteArray &value)
 MmrEventMediaPlayerControl::MmrEventMediaPlayerControl(QObject *parent)
     : MmRendererMediaPlayerControl(parent)
     , m_eventThread(nullptr)
-    , m_bufferStatus("")
+    , m_bufferProgress("")
     , m_bufferLevel(0)
     , m_bufferCapacity(0)
     , m_position(0)
@@ -103,7 +103,7 @@ void MmrEventMediaPlayerControl::stopMonitoring()
 
 void MmrEventMediaPlayerControl::resetMonitoring()
 {
-    m_bufferStatus = "";
+    m_bufferProgress = "";
     m_bufferLevel = 0;
     m_bufferCapacity = 0;
     m_position = 0;
@@ -139,9 +139,9 @@ void MmrEventMediaPlayerControl::readEvents()
                 const strm_string_t *value;
                 value = strm_dict_find_rstr(event->data, "bufferstatus");
                 if (value) {
-                    m_bufferStatus = QByteArray(strm_string_get(value));
+                    m_bufferProgress = QByteArray(strm_string_get(value));
                     if (!m_suspended)
-                        setMmBufferStatus(m_bufferStatus);
+                        setMmBufferStatus(m_bufferProgress);
                 }
 
                 value = strm_dict_find_rstr(event->data, "bufferlevel");
@@ -169,7 +169,7 @@ void MmrEventMediaPlayerControl::readEvents()
                     }
                 } else if (m_suspended) {
                     m_suspended = false;
-                    handleMmSuspendRemoval(m_bufferStatus);
+                    handleMmSuspendRemoval(m_bufferProgress);
                 }
             }
 
diff --git a/src/multimedia/platform/qnx/mediaplayer/mmreventmediaplayercontrol_p.h b/src/multimedia/platform/qnx/mediaplayer/mmreventmediaplayercontrol_p.h
index f2cb41561..d8e437b1d 100644
--- a/src/multimedia/platform/qnx/mediaplayer/mmreventmediaplayercontrol_p.h
+++ b/src/multimedia/platform/qnx/mediaplayer/mmreventmediaplayercontrol_p.h
@@ -78,7 +78,7 @@ private:
     MmrEventThread *m_eventThread;
 
     // status properties.
-    QByteArray m_bufferStatus;
+    QByteArray m_bufferProgress;
     int m_bufferLevel;
     int m_bufferCapacity;
     qint64 m_position;
diff --git a/src/multimedia/platform/qplatformmediaplayer.cpp b/src/multimedia/platform/qplatformmediaplayer.cpp
index 8b289de04..303cd47dc 100644
--- a/src/multimedia/platform/qplatformmediaplayer.cpp
+++ b/src/multimedia/platform/qplatformmediaplayer.cpp
@@ -55,7 +55,7 @@ QT_BEGIN_NAMESPACE
     \l {play()}{start}, \l {pause()} {pause} and \l {stop()}{stop} playback,
     \l {setPosition()}{seek}, and control the \l {setVolume()}{volume}.
     It also provides feedback on the \l {duration()}{duration} of the media,
-    the current \l {position()}{position}, and \l {bufferStatus()}{buffering}
+    the current \l {position()}{position}, and \l {bufferProgress()}{buffering}
     progress.
 
     The functionality provided by this control is exposed to application
@@ -87,7 +87,7 @@ QPlatformMediaPlayer::~QPlatformMediaPlayer()
     \sa state()
 */
 
-void QPlatformMediaPlayer::stateChanged(QMediaPlayer::State newState)
+void QPlatformMediaPlayer::stateChanged(QMediaPlayer::PlaybackState newState)
 {
     player->d_func()->setState(newState);
 }
@@ -197,18 +197,18 @@ void QPlatformMediaPlayer::error(int error, const QString &errorString)
 */
 
 /*!
-    \fn QPlatformMediaPlayer::bufferStatus() const
+    \fn QPlatformMediaPlayer::bufferProgress() const
 
-    Returns the buffering progress of the current media.  Progress is measured in the percentage
-    of the buffer filled.
+    Returns the buffering progress of the current media.  Progress is measured as a number between
+    0 and 1.
 */
 
 /*!
-    \fn QPlatformMediaPlayer::bufferStatusChanged(int percentFilled)
+    \fn QPlatformMediaPlayer::bufferProgressChanged(float filled)
 
-    Signal the amount of the local buffer filled as a percentage by \a percentFilled.
+    Signal the amount of the local buffer filled as a relative number between 0 and 1.
 
-    \sa bufferStatus()
+    \sa bufferProgress()
 */
 
 /*!
diff --git a/src/multimedia/platform/qplatformmediaplayer_p.h b/src/multimedia/platform/qplatformmediaplayer_p.h
index f972187d8..e5abd6565 100644
--- a/src/multimedia/platform/qplatformmediaplayer_p.h
+++ b/src/multimedia/platform/qplatformmediaplayer_p.h
@@ -66,7 +66,7 @@ class Q_MULTIMEDIA_EXPORT QPlatformMediaPlayer
 {
 public:
     virtual ~QPlatformMediaPlayer();
-    virtual QMediaPlayer::State state() const = 0;
+    virtual QMediaPlayer::PlaybackState state() const = 0;
 
     virtual QMediaPlayer::MediaStatus mediaStatus() const = 0;
 
@@ -81,7 +81,7 @@ public:
     virtual bool isMuted() const = 0;
     virtual void setMuted(bool mute) = 0;
 
-    virtual int bufferStatus() const = 0;
+    virtual float bufferProgress() const = 0;
 
     virtual bool isAudioAvailable() const = 0;
     virtual bool isVideoAvailable() const = 0;
@@ -123,18 +123,18 @@ public:
 
     void durationChanged(qint64 duration) { player->durationChanged(duration); }
     void positionChanged(qint64 position) { player->positionChanged(position); }
-    void audioAvailableChanged(bool audioAvailable) { player->audioAvailableChanged(audioAvailable); }
-    void videoAvailableChanged(bool videoAvailable) { player->videoAvailableChanged(videoAvailable); }
+    void audioAvailableChanged(bool audioAvailable) { player->hasAudioChanged(audioAvailable); }
+    void videoAvailableChanged(bool videoAvailable) { player->hasVideoChanged(videoAvailable); }
     void volumeChanged(int volume) { player->volumeChanged(volume); }
     void mutedChanged(bool mute) { player->mutedChanged(mute); }
     void seekableChanged(bool seekable) { player->seekableChanged(seekable); }
     void playbackRateChanged(qreal rate) { player->playbackRateChanged(rate); }
-    void bufferStatusChanged(int percentFilled) { player->bufferStatusChanged(percentFilled); }
+    void bufferProgressChanged(float progress) { player->bufferProgressChanged(progress); }
     void metaDataChanged() { player->metaDataChanged(); }
     void tracksChanged() { player->tracksChanged(); }
     void activeTracksChanged() { player->activeTracksChanged(); }
 
-    void stateChanged(QMediaPlayer::State newState);
+    void stateChanged(QMediaPlayer::PlaybackState newState);
     void mediaStatusChanged(QMediaPlayer::MediaStatus status);
     void error(int error, const QString &errorString);
 
diff --git a/src/multimedia/platform/windows/player/mfplayercontrol.cpp b/src/multimedia/platform/windows/player/mfplayercontrol.cpp
index f9797c3d7..88fbef38d 100644
--- a/src/multimedia/platform/windows/player/mfplayercontrol.cpp
+++ b/src/multimedia/platform/windows/player/mfplayercontrol.cpp
@@ -274,9 +274,9 @@ void MFPlayerControl::setMuted(bool muted)
     m_session->setMuted(muted);
 }
 
-int MFPlayerControl::bufferStatus() const
+float MFPlayerControl::bufferProgress() const
 {
-    return m_session->bufferStatus();
+    return m_session->bufferProgress() / 100.;
 }
 
 bool MFPlayerControl::isAudioAvailable() const
diff --git a/src/multimedia/platform/windows/player/mfplayercontrol_p.h b/src/multimedia/platform/windows/player/mfplayercontrol_p.h
index d3659cf93..05c5482c5 100644
--- a/src/multimedia/platform/windows/player/mfplayercontrol_p.h
+++ b/src/multimedia/platform/windows/player/mfplayercontrol_p.h
@@ -81,7 +81,7 @@ public:
     bool isMuted() const override;
     void setMuted(bool muted) override;
 
-    int bufferStatus() const override;
+    float bufferProgress() const override;
 
     bool isAudioAvailable() const override;
     bool isVideoAvailable() const override;
diff --git a/src/multimedia/platform/windows/player/mfplayersession.cpp b/src/multimedia/platform/windows/player/mfplayersession.cpp
index 3ce531ddb..7603ac4d2 100644
--- a/src/multimedia/platform/windows/player/mfplayersession.cpp
+++ b/src/multimedia/platform/windows/player/mfplayersession.cpp
@@ -1375,7 +1375,7 @@ void MFPlayerSession::setVolumeInternal(int volume)
     }
 }
 
-int MFPlayerSession::bufferStatus()
+float MFPlayerSession::bufferProgress()
 {
     if (!m_netsourceStatistics)
         return 0;
@@ -1393,10 +1393,10 @@ int MFPlayerSession::bufferStatus()
     }
 
 #ifdef DEBUG_MEDIAFOUNDATION
-    qDebug() << "bufferStatus: progress = " << progress;
+    qDebug() << "bufferProgress: progress = " << progress;
 #endif
 
-    return progress;
+    return progress/100.;
 }
 
 QMediaTimeRange MFPlayerSession::availablePlaybackRanges()
@@ -1630,11 +1630,11 @@ void MFPlayerSession::handleSessionEvent(IMFMediaEvent *sessionEvent)
     switch (meType) {
     case MEBufferingStarted:
         changeStatus(QMediaPlayer::StalledMedia);
-        emit bufferStatusChanged(bufferStatus());
+        emit bufferProgressChanged(bufferProgress());
         break;
     case MEBufferingStopped:
         changeStatus(QMediaPlayer::BufferedMedia);
-        emit bufferStatusChanged(bufferStatus());
+        emit bufferProgressChanged(bufferProgress());
         break;
     case MESessionEnded:
         m_pendingState = NoPending;
diff --git a/src/multimedia/platform/windows/player/mfplayersession_p.h b/src/multimedia/platform/windows/player/mfplayersession_p.h
index 493a2f68f..adc20297b 100644
--- a/src/multimedia/platform/windows/player/mfplayersession_p.h
+++ b/src/multimedia/platform/windows/player/mfplayersession_p.h
@@ -116,7 +116,7 @@ public:
     void setVolume(int volume);
     bool isMuted() const;
     void setMuted(bool muted);
-    int bufferStatus();
+    float bufferProgress();
     QMediaTimeRange availablePlaybackRanges();
 
     void changeStatus(QMediaPlayer::MediaStatus newStatus);
@@ -139,7 +139,7 @@ public:
     void playbackRateChanged(qreal rate) { m_playerControl->playbackRateChanged(rate); }
     void volumeChanged(int volume) { m_playerControl->volumeChanged(volume); }
     void mutedChanged(bool muted) { m_playerControl->mutedChanged(muted); }
-    void bufferStatusChanged(int percentFilled) { m_playerControl->bufferStatusChanged(percentFilled); }
+    void bufferProgressChanged(float percentFilled) { m_playerControl->bufferProgressChanged(percentFilled); }
     void metaDataChanged() { m_playerControl->metaDataChanged(); }
     void positionChanged(qint64 position) { m_playerControl->positionChanged(position); }
 
diff --git a/src/multimedia/playback/qmediaplayer.cpp b/src/multimedia/playback/qmediaplayer.cpp
index abe2b4ab4..1db307425 100644
--- a/src/multimedia/playback/qmediaplayer.cpp
+++ b/src/multimedia/playback/qmediaplayer.cpp
@@ -40,6 +40,7 @@
 #include "qmediaplayer_p.h"
 
 #include <private/qplatformmediaintegration_p.h>
+#include <qvideosink.h>
 
 #include <QtCore/qcoreevent.h>
 #include <QtCore/qmetaobject.h>
@@ -72,13 +73,13 @@ QT_BEGIN_NAMESPACE
     \sa QVideoWidget
 */
 
-void QMediaPlayerPrivate::setState(QMediaPlayer::State ps)
+void QMediaPlayerPrivate::setState(QMediaPlayer::PlaybackState ps)
 {
     Q_Q(QMediaPlayer);
 
     if (ps != state) {
         state = ps;
-        emit q->stateChanged(ps);
+        emit q->playbackStateChanged(ps);
     }
 }
 
@@ -103,7 +104,7 @@ void QMediaPlayerPrivate::setError(int error, const QString &errorString)
 
     this->error = QMediaPlayer::Error(error);
     this->errorString = errorString;
-    emit q->error(this->error);
+    emit q->errorChanged(this->error);
 }
 
 void QMediaPlayerPrivate::setMedia(const QUrl &media, QIODevice *stream)
@@ -175,6 +176,9 @@ void QMediaPlayerPrivate::setMedia(const QUrl &media, QIODevice *stream)
     }
 
     qrcFile.swap(file); // Cleans up any previous file
+
+    if (autoPlay)
+        q->play();
 }
 
 QList<QMediaMetaData> QMediaPlayerPrivate::trackMetaData(QPlatformMediaPlayer::TrackType s) const
@@ -228,7 +232,7 @@ QMediaPlayer::~QMediaPlayer()
     delete d->control;
 }
 
-QUrl QMediaPlayer::media() const
+QUrl QMediaPlayer::source() const
 {
     Q_D(const QMediaPlayer);
 
@@ -243,7 +247,7 @@ QUrl QMediaPlayer::media() const
     \sa setMedia()
 */
 
-const QIODevice *QMediaPlayer::mediaStream() const
+const QIODevice *QMediaPlayer::sourceStream() const
 {
     Q_D(const QMediaPlayer);
 
@@ -255,7 +259,7 @@ const QIODevice *QMediaPlayer::mediaStream() const
     return nullptr;
 }
 
-QMediaPlayer::State QMediaPlayer::state() const
+QMediaPlayer::PlaybackState QMediaPlayer::playbackState() const
 {
     Q_D(const QMediaPlayer);
 
@@ -315,17 +319,17 @@ bool QMediaPlayer::isMuted() const
     return false;
 }
 
-int QMediaPlayer::bufferStatus() const
+float QMediaPlayer::bufferProgress() const
 {
     Q_D(const QMediaPlayer);
 
     if (d->control != nullptr)
-        return d->control->bufferStatus();
+        return d->control->bufferProgress();
 
-    return 0;
+    return 0.;
 }
 
-bool QMediaPlayer::isAudioAvailable() const
+bool QMediaPlayer::hasAudio() const
 {
     Q_D(const QMediaPlayer);
 
@@ -335,7 +339,7 @@ bool QMediaPlayer::isAudioAvailable() const
     return false;
 }
 
-bool QMediaPlayer::isVideoAvailable() const
+bool QMediaPlayer::hasVideo() const
 {
     Q_D(const QMediaPlayer);
 
@@ -455,6 +459,16 @@ void QMediaPlayer::setMuted(bool muted)
     d->control->setMuted(muted);
 }
 
+void QMediaPlayer::setAutoPlay(bool autoPlay)
+{
+    Q_D(QMediaPlayer);
+    if (d->autoPlay == autoPlay)
+        return;
+
+    d->autoPlay = autoPlay;
+    emit autoPlayChanged(autoPlay);
+}
+
 void QMediaPlayer::setPlaybackRate(qreal rate)
 {
     Q_D(QMediaPlayer);
@@ -464,7 +478,7 @@ void QMediaPlayer::setPlaybackRate(qreal rate)
 }
 
 /*!
-    Sets the current \a media source.
+    Sets the current \a source.
 
     If a \a stream is supplied; media data will be read from it instead of resolving the media
     source. In this case the url should be provided to resolve additional information
@@ -481,17 +495,17 @@ void QMediaPlayer::setPlaybackRate(qreal rate)
     when an error occurs during loading.
 */
 
-void QMediaPlayer::setMedia(const QUrl &media, QIODevice *stream)
+void QMediaPlayer::setSource(const QUrl &source, QIODevice *stream)
 {
     Q_D(QMediaPlayer);
     stop();
 
     QUrl oldMedia = d->rootMedia;
-    d->rootMedia = media;
+    d->rootMedia = source;
 
-    if (oldMedia != media) {
-        d->setMedia(media, stream);
-        emit mediaChanged(d->rootMedia);
+    if (oldMedia != source) {
+        d->setMedia(source, stream);
+        emit sourceChanged(d->rootMedia);
     }
 }
 
@@ -583,23 +597,64 @@ void QMediaPlayer::setActiveSubtitleTrack(int index)
     If the media player has already video output attached,
     it will be replaced with a new one.
 */
+void QMediaPlayer::setVideoOutput(const QVariant &output)
+{
+    QVideoSink *s = output.value<QVideoSink *>();
+    if (s) {
+        setVideoOutput(s);
+        return;
+    }
+    QObject *o = output.value<QObject *>();
+    if (o) {
+        setVideoOutput(o);
+        return;
+    }
+}
+
+QVariant QMediaPlayer::videoOutput() const
+{
+    Q_D(const QMediaPlayer);
+    return d->videoOutput;
+}
+
+/*!
+    Attach a video \a output to the media player.
+
+    If the media player has already video output attached,
+    it will be replaced with a new one.
+*/
 void QMediaPlayer::setVideoOutput(QObject *output)
 {
-    auto *mo = output->metaObject();
+    Q_D(QMediaPlayer);
+    if (!d->control)
+        return;
+
     QVideoSink *sink = nullptr;
-    if (output)
-        mo->invokeMethod(output, "videoSink", Q_RETURN_ARG(QVideoSink *, sink));
-    setVideoOutput(sink);
+    if (output) {
+        auto *mo = output->metaObject();
+        if (output)
+            mo->invokeMethod(output, "videoSink", Q_RETURN_ARG(QVideoSink *, sink));
+    }
+    QVariant out = QVariant::fromValue(output);
+    if (d->videoOutput == out)
+        return;
+    d->videoOutput = out;
+    d->control->setVideoSink(sink);
+    emit videoOutputChanged();
 }
 
 void QMediaPlayer::setVideoOutput(QVideoSink *sink)
 {
     Q_D(QMediaPlayer);
-
     if (!d->control)
         return;
 
+    QVariant out = QVariant::fromValue(sink);
+    if (d->videoOutput == out)
+        return;
+    d->videoOutput = out;
     d->control->setVideoSink(sink);
+    emit videoOutputChanged();
 }
 
 /*!
@@ -667,6 +722,12 @@ QList<QAudio::Role> QMediaPlayer::supportedAudioRoles() const
     return d->control->supportedAudioRoles();
 }
 
+bool QMediaPlayer::autoPlay() const
+{
+    Q_D(const QMediaPlayer);
+    return d->autoPlay;
+}
+
 // Enums
 /*!
     \enum QMediaPlayer::State
@@ -859,7 +920,7 @@ QList<QAudio::Role> QMediaPlayer::supportedAudioRoles() const
 */
 
 /*!
-    \property QMediaPlayer::bufferStatus
+    \property QMediaPlayer::bufferProgress
     \brief the percentage of the temporary buffer filled before playback begins or resumes, from
     \c 0 (empty) to \c 100 (full).
 
@@ -968,9 +1029,9 @@ QList<QAudio::Role> QMediaPlayer::supportedAudioRoles() const
 */
 
 /*!
-    \fn void QMediaPlayer::bufferStatusChanged(int percentFilled)
+    \fn void QMediaPlayer::bufferProgressChanged(float filled)
 
-    Signal the amount of the local buffer filled as a percentage by \a percentFilled.
+    Signal the amount of the local buffer filled as a number between 0 and 1.
 */
 
 QT_END_NAMESPACE
diff --git a/src/multimedia/playback/qmediaplayer.h b/src/multimedia/playback/qmediaplayer.h
index 840e521f1..1cd11989e 100644
--- a/src/multimedia/playback/qmediaplayer.h
+++ b/src/multimedia/playback/qmediaplayer.h
@@ -55,27 +55,30 @@ class QMediaPlayerPrivate;
 class Q_MULTIMEDIA_EXPORT QMediaPlayer : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(QUrl media READ media WRITE setMedia NOTIFY mediaChanged)
+    Q_PROPERTY(QUrl source READ source WRITE setSource NOTIFY sourceChanged)
     Q_PROPERTY(qint64 duration READ duration NOTIFY durationChanged)
     Q_PROPERTY(qint64 position READ position WRITE setPosition NOTIFY positionChanged)
     Q_PROPERTY(int volume READ volume WRITE setVolume NOTIFY volumeChanged)
     Q_PROPERTY(bool muted READ isMuted WRITE setMuted NOTIFY mutedChanged)
-    Q_PROPERTY(int bufferStatus READ bufferStatus NOTIFY bufferStatusChanged)
-    Q_PROPERTY(bool audioAvailable READ isAudioAvailable NOTIFY audioAvailableChanged)
-    Q_PROPERTY(bool videoAvailable READ isVideoAvailable NOTIFY videoAvailableChanged)
+    Q_PROPERTY(float bufferProgress READ bufferProgress NOTIFY bufferProgressChanged)
+    Q_PROPERTY(bool hasAudio READ hasAudio NOTIFY hasAudioChanged)
+    Q_PROPERTY(bool hasVideo READ hasVideo NOTIFY hasVideoChanged)
     Q_PROPERTY(bool seekable READ isSeekable NOTIFY seekableChanged)
     Q_PROPERTY(qreal playbackRate READ playbackRate WRITE setPlaybackRate NOTIFY playbackRateChanged)
-    Q_PROPERTY(State state READ state NOTIFY stateChanged)
+    Q_PROPERTY(PlaybackState playbackState READ playbackState NOTIFY playbackStateChanged)
+    Q_PROPERTY(bool autoPlay READ autoPlay WRITE setAutoPlay NOTIFY autoPlayChanged)
     Q_PROPERTY(MediaStatus mediaStatus READ mediaStatus NOTIFY mediaStatusChanged)
     Q_PROPERTY(QAudio::Role audioRole READ audioRole WRITE setAudioRole NOTIFY audioRoleChanged)
     Q_PROPERTY(QMediaMetaData metaData READ metaData NOTIFY metaDataChanged)
-    Q_PROPERTY(QString error READ errorString)
-    Q_ENUMS(State)
+    Q_PROPERTY(Error error READ error NOTIFY errorChanged)
+    Q_PROPERTY(QString errorString READ errorString NOTIFY errorChanged)
+    Q_PROPERTY(QVariant videoOutput READ videoOutput WRITE setVideoOutput NOTIFY videoOutputChanged)
+    Q_ENUMS(PlaybackState)
     Q_ENUMS(MediaStatus)
     Q_ENUMS(Error)
 
 public:
-    enum State
+    enum PlaybackState
     {
         StoppedState,
         PlayingState,
@@ -127,14 +130,17 @@ public:
     void setActiveVideoTrack(int index);
     void setActiveSubtitleTrack(int index);
 
+    void setVideoOutput(const QVariant &output);
+    QVariant videoOutput() const;
+
     void setVideoOutput(QObject *);
     void setVideoOutput(const QList<QVideoSink *> &sinks);
     void setVideoOutput(QVideoSink *sink);
 
-    QUrl media() const;
-    const QIODevice *mediaStream() const;
+    QUrl source() const;
+    const QIODevice *sourceStream() const;
 
-    State state() const;
+    PlaybackState playbackState() const;
     MediaStatus mediaStatus() const;
 
     qint64 duration() const;
@@ -142,10 +148,10 @@ public:
 
     int volume() const;
     bool isMuted() const;
-    bool isAudioAvailable() const;
-    bool isVideoAvailable() const;
+    bool hasAudio() const;
+    bool hasVideo() const;
 
-    int bufferStatus() const;
+    float bufferProgress() const;
 
     bool isSeekable() const;
     qreal playbackRate() const;
@@ -160,6 +166,8 @@ public:
     void setAudioRole(QAudio::Role audioRole);
     QList<QAudio::Role> supportedAudioRoles() const;
 
+    bool autoPlay() const;
+
 public Q_SLOTS:
     void play();
     void pause();
@@ -168,14 +176,15 @@ public Q_SLOTS:
     void setPosition(qint64 position);
     void setVolume(int volume);
     void setMuted(bool muted);
+    void setAutoPlay(bool autoPlay);
 
     void setPlaybackRate(qreal rate);
 
-    void setMedia(const QUrl &media, QIODevice *stream = nullptr);
+    void setSource(const QUrl &media, QIODevice *stream = nullptr);
 
 Q_SIGNALS:
-    void mediaChanged(const QUrl &media);
-    void stateChanged(QMediaPlayer::State newState);
+    void sourceChanged(const QUrl &media);
+    void playbackStateChanged(QMediaPlayer::PlaybackState newState);
     void mediaStatusChanged(QMediaPlayer::MediaStatus status);
 
     void durationChanged(qint64 duration);
@@ -183,10 +192,11 @@ Q_SIGNALS:
 
     void volumeChanged(int volume);
     void mutedChanged(bool muted);
-    void audioAvailableChanged(bool available);
-    void videoAvailableChanged(bool videoAvailable);
+    void autoPlayChanged(bool autoPlay);
+    void hasAudioChanged(bool available);
+    void hasVideoChanged(bool videoAvailable);
 
-    void bufferStatusChanged(int percentFilled);
+    void bufferProgressChanged(float progress);
 
     void seekableChanged(bool seekable);
     void playbackRateChanged(qreal rate);
@@ -194,11 +204,12 @@ Q_SIGNALS:
     void audioRoleChanged(QAudio::Role role);
 
     void metaDataChanged();
+    void videoOutputChanged();
 
     void tracksChanged();
     void activeTracksChanged();
 
-    void error(QMediaPlayer::Error error);
+    void errorChanged(QMediaPlayer::Error error);
 
 private:
     Q_DISABLE_COPY(QMediaPlayer)
@@ -208,7 +219,7 @@ private:
 
 QT_END_NAMESPACE
 
-Q_MEDIA_ENUM_DEBUG(QMediaPlayer, State)
+Q_MEDIA_ENUM_DEBUG(QMediaPlayer, PlaybackState)
 Q_MEDIA_ENUM_DEBUG(QMediaPlayer, MediaStatus)
 Q_MEDIA_ENUM_DEBUG(QMediaPlayer, Error)
 
diff --git a/src/multimedia/playback/qmediaplayer_p.h b/src/multimedia/playback/qmediaplayer_p.h
index f0ff1bbd6..7d5b1839a 100644
--- a/src/multimedia/playback/qmediaplayer_p.h
+++ b/src/multimedia/playback/qmediaplayer_p.h
@@ -76,16 +76,17 @@ public:
     QPlatformMediaPlayer* control = nullptr;
     QString errorString;
 
-    QPointer<QObject> videoOutput;
+    QVariant videoOutput;
     QUrl qrcMedia;
     QScopedPointer<QFile> qrcFile;
     QUrl rootMedia;
 
-    QMediaPlayer::State state = QMediaPlayer::StoppedState;
+    QMediaPlayer::PlaybackState state = QMediaPlayer::StoppedState;
     QMediaPlayer::MediaStatus status = QMediaPlayer::UnknownMediaStatus;
     QMediaPlayer::Error error = QMediaPlayer::NoError;
     int ignoreNextStatusChange = -1;
     bool hasStreamPlaybackFeature = false;
+    bool autoPlay = false;
 
     QAudio::Role audioRole = QAudio::UnknownRole;
 
@@ -93,7 +94,7 @@ public:
 
     QList<QMediaMetaData> trackMetaData(QPlatformMediaPlayer::TrackType s) const;
 
-    void setState(QMediaPlayer::State state);
+    void setState(QMediaPlayer::PlaybackState state);
     void setStatus(QMediaPlayer::MediaStatus status);
     void setError(int error, const QString &errorString);
 };
diff --git a/tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp b/tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp
index 7095a0cc9..ba3342869 100644
--- a/tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp
+++ b/tests/auto/integration/qmediaplayerbackend/tst_qmediaplayerbackend.cpp
@@ -140,7 +140,7 @@ QUrl tst_QMediaPlayerBackend::selectVideoFile(const QStringList& mediaCandidates
         if (!videoFile.exists())
             continue;
         QUrl media = QUrl(QUrl::fromLocalFile(videoFile.absoluteFilePath()));
-        player.setMedia(media);
+        player.setSource(media);
         player.pause();
 
         for (int i = 0; i < 2000 && surface->m_frameList.isEmpty() && errorSpy.isEmpty(); i+=50) {
@@ -204,7 +204,7 @@ void tst_QMediaPlayerBackend::loadMedia()
 
     QMediaPlayer player;
 
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::NoMedia);
 
     QSignalSpy stateSpy(&player, SIGNAL(stateChanged(QMediaPlayer::State)));
@@ -212,13 +212,13 @@ void tst_QMediaPlayerBackend::loadMedia()
     QSignalSpy mediaSpy(&player, SIGNAL(mediaChanged(QUrl)));
     QSignalSpy currentMediaSpy(&player, SIGNAL(currentMediaChanged(QUrl)));
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
 
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
 
     QVERIFY(player.mediaStatus() != QMediaPlayer::NoMedia);
     QVERIFY(player.mediaStatus() != QMediaPlayer::InvalidMedia);
-    QVERIFY(player.media() == localWavFile);
+    QVERIFY(player.source() == localWavFile);
 
     QCOMPARE(stateSpy.count(), 0);
     QVERIFY(statusSpy.count() > 0);
@@ -228,8 +228,8 @@ void tst_QMediaPlayerBackend::loadMedia()
 
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
 
-    QVERIFY(player.isAudioAvailable());
-    QVERIFY(!player.isVideoAvailable());
+    QVERIFY(player.hasAudio());
+    QVERIFY(!player.hasVideo());
 }
 
 void tst_QMediaPlayerBackend::unloadMedia()
@@ -246,7 +246,7 @@ void tst_QMediaPlayerBackend::unloadMedia()
     QSignalSpy positionSpy(&player, SIGNAL(positionChanged(qint64)));
     QSignalSpy durationSpy(&player, SIGNAL(positionChanged(qint64)));
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
 
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
 
@@ -265,13 +265,13 @@ void tst_QMediaPlayerBackend::unloadMedia()
     positionSpy.clear();
     durationSpy.clear();
 
-    player.setMedia(QUrl());
+    player.setSource(QUrl());
 
     QVERIFY(player.position() <= 0);
     QVERIFY(player.duration() <= 0);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::NoMedia);
-    QCOMPARE(player.media(), QUrl());
+    QCOMPARE(player.source(), QUrl());
 
     QVERIFY(!stateSpy.isEmpty());
     QVERIFY(!statusSpy.isEmpty());
@@ -286,11 +286,11 @@ void tst_QMediaPlayerBackend::loadMediaInLoadingState()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
     player.play();
     QCOMPARE(player.mediaStatus(), QMediaPlayer::LoadingMedia);
     // Sets new media while old has not been finished.
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::LoadingMedia);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
 }
@@ -310,7 +310,7 @@ void tst_QMediaPlayerBackend::playPauseStop()
     // Check play() without a media
     player.play();
 
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::NoMedia);
     QCOMPARE(player.error(), QMediaPlayer::NoError);
     QCOMPARE(player.position(), 0);
@@ -322,7 +322,7 @@ void tst_QMediaPlayerBackend::playPauseStop()
     // Check pause() without a media
     player.pause();
 
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::NoMedia);
     QCOMPARE(player.error(), QMediaPlayer::NoError);
     QCOMPARE(player.position(), 0);
@@ -333,18 +333,18 @@ void tst_QMediaPlayerBackend::playPauseStop()
 
     // The rest is with a valid media
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
 
     QCOMPARE(player.position(), qint64(0));
 
     player.play();
 
-    QCOMPARE(player.state(), QMediaPlayer::PlayingState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PlayingState);
 
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::BufferedMedia);
 
     QCOMPARE(stateSpy.count(), 1);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::PlayingState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::PlayingState);
     QTRY_VERIFY(statusSpy.count() > 0 &&
                 statusSpy.last()[0].value<QMediaPlayer::MediaStatus>() == QMediaPlayer::BufferedMedia);
 
@@ -360,11 +360,11 @@ void tst_QMediaPlayerBackend::playPauseStop()
     qint64 positionBeforePause = player.position();
     player.pause();
 
-    QCOMPARE(player.state(), QMediaPlayer::PausedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PausedState);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::BufferedMedia);
 
     QCOMPARE(stateSpy.count(), 1);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::PausedState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::PausedState);
 
     QTest::qWait(2000);
 
@@ -376,11 +376,11 @@ void tst_QMediaPlayerBackend::playPauseStop()
 
     player.stop();
 
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
 
     QCOMPARE(stateSpy.count(), 1);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::StoppedState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::StoppedState);
     //it's allowed to emit statusChanged() signal async
     QTRY_COMPARE(statusSpy.count(), 1);
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::LoadedMedia);
@@ -396,10 +396,10 @@ void tst_QMediaPlayerBackend::playPauseStop()
 
     player.play();
 
-    QCOMPARE(player.state(), QMediaPlayer::PlayingState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PlayingState);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::BufferedMedia);
     QCOMPARE(stateSpy.count(), 1);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::PlayingState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::PlayingState);
     QCOMPARE(statusSpy.count(), 1); // Should not go through Loading again when play -> stop -> play
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::BufferedMedia);
 
@@ -408,24 +408,24 @@ void tst_QMediaPlayerBackend::playPauseStop()
     statusSpy.clear();
     positionSpy.clear();
 
-    player.setMedia(localWavFile2);
+    player.setSource(localWavFile2);
 
     QTRY_VERIFY(statusSpy.count() > 0);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::LoadedMedia);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(stateSpy.count(), 0);
 
     player.play();
 
     QTRY_VERIFY(player.position() > 100);
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
 
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::LoadedMedia);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::StoppedState);
     QCOMPARE(player.position(), 0);
     QCOMPARE(positionSpy.last()[0].value<qint64>(), 0);
 
@@ -437,12 +437,12 @@ void tst_QMediaPlayerBackend::playPauseStop()
 
     QTRY_VERIFY(player.position() > 100);
 
-    player.setMedia(QUrl());
+    player.setSource(QUrl());
 
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::NoMedia);
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::NoMedia);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::StoppedState);
     QCOMPARE(player.position(), 0);
     QCOMPARE(positionSpy.last()[0].value<qint64>(), 0);
     QCOMPARE(player.duration(), 0);
@@ -460,7 +460,7 @@ void tst_QMediaPlayerBackend::processEOS()
     QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
     QSignalSpy positionSpy(&player, SIGNAL(positionChanged(qint64)));
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
 
     player.play();
     player.setPosition(900);
@@ -470,9 +470,9 @@ void tst_QMediaPlayerBackend::processEOS()
 
     QVERIFY(statusSpy.count() > 0);
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::EndOfMedia);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(stateSpy.count(), 2);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::StoppedState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::StoppedState);
 
     //at EOS the position stays at the end of file
     QCOMPARE(player.position(), player.duration());
@@ -490,11 +490,11 @@ void tst_QMediaPlayerBackend::processEOS()
     QTRY_VERIFY(positionSpy.count() > 0);
     QCOMPARE(positionSpy.first()[0].value<qint64>(), 0);
 
-    QCOMPARE(player.state(), QMediaPlayer::PlayingState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PlayingState);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::BufferedMedia);
 
     QCOMPARE(stateSpy.count(), 1);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::PlayingState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::PlayingState);
     QVERIFY(statusSpy.count() > 0);
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::BufferedMedia);
 
@@ -503,9 +503,9 @@ void tst_QMediaPlayerBackend::processEOS()
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::EndOfMedia);
     QVERIFY(statusSpy.count() > 0);
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::EndOfMedia);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(stateSpy.count(), 2);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::StoppedState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::StoppedState);
 
     //position stays at the end of file
     QCOMPARE(player.position(), player.duration());
@@ -528,7 +528,7 @@ void tst_QMediaPlayerBackend::processEOS()
     player.setPosition(900);
     //wait up to 5 seconds for EOS
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::EndOfMedia);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.position(), player.duration());
 
     stateSpy.clear();
@@ -542,11 +542,11 @@ void tst_QMediaPlayerBackend::processEOS()
     QTRY_VERIFY(positionSpy.count() > 0);
     QCOMPARE(positionSpy.first()[0].value<qint64>(), 0);
 
-    QCOMPARE(player.state(), QMediaPlayer::PausedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PausedState);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::BufferedMedia);
 
     QCOMPARE(stateSpy.count(), 1);
-    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::State>(), QMediaPlayer::PausedState);
+    QCOMPARE(stateSpy.last()[0].value<QMediaPlayer::PlaybackState>(), QMediaPlayer::PausedState);
     QVERIFY(statusSpy.count() > 0);
     QCOMPARE(statusSpy.last()[0].value<QMediaPlayer::MediaStatus>(), QMediaPlayer::BufferedMedia);
 }
@@ -590,7 +590,7 @@ void tst_QMediaPlayerBackend::deleteLaterAtEOS()
 
     QPointer<QMediaPlayer> player(new QMediaPlayer);
     DeleteLaterAtEos deleter(player);
-    player->setMedia(localWavFile);
+    player->setSource(localWavFile);
 
     // Create an event loop for verifying deleteLater behavior instead of using
     // QTRY_VERIFY or QTest::qWait. QTest::qWait makes extra effort to process
@@ -612,7 +612,7 @@ void tst_QMediaPlayerBackend::volumeAndMuted()
     QVERIFY(player.volume() > 0);
     QVERIFY(!player.isMuted());
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
     player.pause();
 
     QVERIFY(player.volume() > 0);
@@ -687,7 +687,7 @@ void tst_QMediaPlayerBackend::volumeAcrossFiles()
     QTRY_COMPARE(player.volume(), volume);
     QTRY_COMPARE(player.isMuted(), muted);
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
     QCOMPARE(player.volume(), volume);
     QCOMPARE(player.isMuted(), muted);
 
@@ -699,11 +699,11 @@ void tst_QMediaPlayerBackend::volumeAcrossFiles()
     QTRY_COMPARE(player.volume(), volume);
     QCOMPARE(player.isMuted(), muted);
 
-    player.setMedia(QUrl());
+    player.setSource(QUrl());
     QTRY_COMPARE(player.volume(), volume);
     QCOMPARE(player.isMuted(), muted);
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
     player.pause();
 
     QTRY_COMPARE(player.volume(), volume);
@@ -718,7 +718,7 @@ void tst_QMediaPlayerBackend::initialVolume()
     {
         QMediaPlayer player;
         player.setVolume(1);
-        player.setMedia(localWavFile);
+        player.setSource(localWavFile);
         QCOMPARE(player.volume(), 1);
         player.play();
         QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::EndOfMedia);
@@ -727,7 +727,7 @@ void tst_QMediaPlayerBackend::initialVolume()
 
     {
         QMediaPlayer player;
-        player.setMedia(localWavFile);
+        player.setSource(localWavFile);
         QCOMPARE(player.volume(), 100);
         player.play();
         QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::EndOfMedia);
@@ -747,20 +747,20 @@ void tst_QMediaPlayerBackend::seekPauseSeek()
     TestVideoSink *surface = new TestVideoSink;
     player.setVideoOutput(surface);
 
-    player.setMedia(localVideoFile);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    player.setSource(localVideoFile);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QVERIFY(surface->m_frameList.isEmpty()); // frame must not appear until we call pause() or play()
 
     positionSpy.clear();
     qint64 position = 7000;
     player.setPosition(position);
     QTRY_VERIFY(!positionSpy.isEmpty() && qAbs(player.position() - position) < (qint64)500);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QTest::qWait(250); // wait a bit to ensure the frame is not rendered
     QVERIFY(surface->m_frameList.isEmpty()); // still no frame, we must call pause() or play() to see a frame
 
     player.pause();
-    QTRY_COMPARE(player.state(), QMediaPlayer::PausedState); // it might take some time for the operation to be completed
+    QTRY_COMPARE(player.playbackState(), QMediaPlayer::PausedState); // it might take some time for the operation to be completed
     QTRY_VERIFY_WITH_TIMEOUT(!surface->m_frameList.isEmpty(), 10000); // we must see a frame at position 7000 here
 
     // Make sure that the frame has a timestamp before testing - not all backends provides this
@@ -789,7 +789,7 @@ void tst_QMediaPlayerBackend::seekPauseSeek()
     position = 12000;
     player.setPosition(position);
     QTRY_VERIFY(!positionSpy.isEmpty() && qAbs(player.position() - position) < (qint64)500);
-    QCOMPARE(player.state(), QMediaPlayer::PausedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PausedState);
     QVERIFY(!surface->m_frameList.isEmpty());
 
     {
@@ -819,9 +819,9 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
     QSignalSpy stateSpy(&player, SIGNAL(stateChanged(QMediaPlayer::State)));
     QSignalSpy positionSpy(&player, SIGNAL(positionChanged(qint64)));
 
-    player.setMedia(localVideoFile);
+    player.setSource(localVideoFile);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.position(), 0);
     QVERIFY(player.isSeekable());
 
@@ -835,7 +835,7 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
     QCOMPARE(positionSpy.count(), 1);
     QVERIFY(qAbs(positionSpy.last()[0].value<qint64>() - position) < qint64(500));
 
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(stateSpy.count(), 0);
 
     QCOMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
@@ -844,7 +844,7 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
 
     player.play();
 
-    QCOMPARE(player.state(), QMediaPlayer::PlayingState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PlayingState);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::BufferedMedia);
     QVERIFY(qAbs(player.position() - position) < qint64(500));
 
@@ -858,7 +858,7 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
     // Same tests but after play() --> stop()
 
     player.stop();
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
     QCOMPARE(player.position(), 0);
 
@@ -871,7 +871,7 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
     QCOMPARE(positionSpy.count(), 1);
     QVERIFY(qAbs(positionSpy.last()[0].value<qint64>() - position) < qint64(500));
 
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(stateSpy.count(), 0);
 
     QCOMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
@@ -880,7 +880,7 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
 
     player.play();
 
-    QCOMPARE(player.state(), QMediaPlayer::PlayingState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PlayingState);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::BufferedMedia);
     QVERIFY(qAbs(player.position() - position) < qint64(500));
 
@@ -895,7 +895,7 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
 
     player.setPosition(player.duration() - 500);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::EndOfMedia);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.position(), player.duration());
 
     stateSpy.clear();
@@ -907,7 +907,7 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
     QCOMPARE(positionSpy.count(), 1);
     QVERIFY(qAbs(positionSpy.last()[0].value<qint64>() - position) < qint64(500));
 
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(stateSpy.count(), 0);
 
     QCOMPARE(player.mediaStatus(), QMediaPlayer::LoadedMedia);
@@ -916,7 +916,7 @@ void tst_QMediaPlayerBackend::seekInStoppedState()
 
     player.play();
 
-    QCOMPARE(player.state(), QMediaPlayer::PlayingState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PlayingState);
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::BufferedMedia);
     QVERIFY(qAbs(player.position() - position) < qint64(500));
 
@@ -938,32 +938,32 @@ void tst_QMediaPlayerBackend::subsequentPlayback()
         QSKIP("Sound format is not supported");
 
     QMediaPlayer player;
-    player.setMedia(localCompressedSoundFile);
+    player.setSource(localCompressedSoundFile);
     player.play();
 
     QCOMPARE(player.error(), QMediaPlayer::NoError);
-    QTRY_COMPARE(player.state(), QMediaPlayer::PlayingState);
+    QTRY_COMPARE(player.playbackState(), QMediaPlayer::PlayingState);
     QTRY_COMPARE_WITH_TIMEOUT(player.mediaStatus(), QMediaPlayer::EndOfMedia, 15000);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     // Could differ by up to 1 compressed frame length
     QVERIFY(qAbs(player.position() - player.duration()) < 100);
     QVERIFY(player.position() > 0);
 
     player.play();
-    QTRY_COMPARE(player.state(), QMediaPlayer::PlayingState);
+    QTRY_COMPARE(player.playbackState(), QMediaPlayer::PlayingState);
     QTRY_VERIFY_WITH_TIMEOUT(player.position() > 2000 && player.position() < 5000, 10000);
     player.pause();
-    QCOMPARE(player.state(), QMediaPlayer::PausedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PausedState);
     // make sure position does not "jump" closer to the end of the file
     QVERIFY(player.position() > 2000 && player.position() < 5000);
     // try to seek back to zero
     player.setPosition(0);
     QTRY_COMPARE(player.position(), qint64(0));
     player.play();
-    QCOMPARE(player.state(), QMediaPlayer::PlayingState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PlayingState);
     QTRY_VERIFY_WITH_TIMEOUT(player.position() > 2000 && player.position() < 5000, 10000);
     player.pause();
-    QCOMPARE(player.state(), QMediaPlayer::PausedState);
+    QCOMPARE(player.playbackState(), QMediaPlayer::PausedState);
     QVERIFY(player.position() > 2000 && player.position() < 5000);
 }
 
@@ -1007,7 +1007,7 @@ void tst_QMediaPlayerBackend::surfaceTest()
     TestVideoSink surface(false);
     QMediaPlayer player;
     player.setVideoOutput(&surface);
-    player.setMedia(localVideoFile);
+    player.setSource(localVideoFile);
     player.play();
     QTRY_VERIFY(player.position() >= 1000);
     QVERIFY2(surface.m_totalFrames >= 25, qPrintable(QString("Expected >= 25, got %1").arg(surface.m_totalFrames)));
@@ -1023,7 +1023,7 @@ void tst_QMediaPlayerBackend::multipleSurfaces()
 
     QMediaPlayer player;
     player.setVideoOutput(QList<QVideoSink *>() << &surface1 << &surface2);
-    player.setMedia(localVideoFile);
+    player.setSource(localVideoFile);
     player.play();
     QTRY_VERIFY(player.position() >= 1000);
 //    QVERIFY2(surface1.m_totalFrames >= 25, qPrintable(QString("Expected >= 25, got %1").arg(surface1.m_totalFrames)));
@@ -1040,7 +1040,7 @@ void tst_QMediaPlayerBackend::metadata()
 
     QSignalSpy metadataChangedSpy(&player, SIGNAL(metaDataChanged()));
 
-    player.setMedia(localFileWithMetadata);
+    player.setSource(localFileWithMetadata);
 
     QVERIFY(metadataChangedSpy.count() > 0);
 
@@ -1050,7 +1050,7 @@ void tst_QMediaPlayerBackend::metadata()
 
     metadataChangedSpy.clear();
 
-    player.setMedia(QUrl());
+    player.setSource(QUrl());
 
     QCOMPARE(metadataChangedSpy.count(), 1);
     QVERIFY(player.metaData().isEmpty());
@@ -1066,12 +1066,12 @@ void tst_QMediaPlayerBackend::playerStateAtEOS()
     bool endOfMediaReceived = false;
     connect(&player, &QMediaPlayer::mediaStatusChanged, [&](QMediaPlayer::MediaStatus status) {
         if (status == QMediaPlayer::EndOfMedia) {
-            QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+            QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
             endOfMediaReceived = true;
         }
     });
 
-    player.setMedia(localWavFile);
+    player.setSource(localWavFile);
     player.play();
 
     QTRY_COMPARE(player.mediaStatus(), QMediaPlayer::EndOfMedia);
@@ -1089,7 +1089,7 @@ void tst_QMediaPlayerBackend::playFromBuffer()
     QFile file(localVideoFile.toLocalFile());
     if (!file.open(QIODevice::ReadOnly))
         QSKIP("Could not open file");
-    player.setMedia(localVideoFile, &file);
+    player.setSource(localVideoFile, &file);
     player.play();
     QTRY_VERIFY(player.position() >= 1000);
     QVERIFY2(surface.m_totalFrames >= 25, qPrintable(QString("Expected >= 25, got %1").arg(surface.m_totalFrames)));
diff --git a/tests/auto/integration/shared/mediafileselector.h b/tests/auto/integration/shared/mediafileselector.h
index 5b5c33496..a0b8bc681 100644
--- a/tests/auto/integration/shared/mediafileselector.h
+++ b/tests/auto/integration/shared/mediafileselector.h
@@ -50,7 +50,7 @@ static QUrl selectMediaFile(const QStringList& mediaCandidates)
         if (!mediaFile.exists())
             continue;
         QUrl media = QUrl(QUrl::fromLocalFile(mediaFile.absoluteFilePath()));
-        player.setMedia(media);
+        player.setSource(media);
         player.play();
 
         for (int i = 0; i < 2000 && player.mediaStatus() != QMediaPlayer::BufferedMedia && errorSpy.isEmpty(); i+=50) {
diff --git a/tests/auto/unit/mockbackend/mockmediaplayer.h b/tests/auto/unit/mockbackend/mockmediaplayer.h
index a761545dc..0ef695e40 100644
--- a/tests/auto/unit/mockbackend/mockmediaplayer.h
+++ b/tests/auto/unit/mockbackend/mockmediaplayer.h
@@ -46,7 +46,7 @@ public:
         , _position(0)
         , _volume(100)
         , _muted(false)
-        , _bufferStatus(0)
+        , _bufferProgress(0)
         , _audioAvailable(false)
         , _videoAvailable(false)
         , _isSeekable(true)
@@ -59,14 +59,14 @@ public:
     {
     }
 
-    QMediaPlayer::State state() const { return _state; }
-    void updateState(QMediaPlayer::State state) { emit stateChanged(_state = state); }
+    QMediaPlayer::PlaybackState state() const { return _state; }
+    void updateState(QMediaPlayer::PlaybackState state) { emit stateChanged(_state = state); }
     QMediaPlayer::MediaStatus mediaStatus() const { return _mediaStatus; }
     void updateMediaStatus(QMediaPlayer::MediaStatus status)
     {
         emit mediaStatusChanged(_mediaStatus = status);
     }
-    void updateMediaStatus(QMediaPlayer::MediaStatus status, QMediaPlayer::State state)
+    void updateMediaStatus(QMediaPlayer::MediaStatus status, QMediaPlayer::PlaybackState state)
     {
         _mediaStatus = status;
         _state = state;
@@ -88,8 +88,8 @@ public:
     bool isMuted() const { return _muted; }
     void setMuted(bool muted) { if (muted != _muted) emit mutedChanged(_muted = muted); }
 
-    int bufferStatus() const { return _bufferStatus; }
-    void setBufferStatus(int status) { emit bufferStatusChanged(_bufferStatus = status); }
+    float bufferProgress() const { return _bufferProgress; }
+    void setBufferStatus(float status) { _bufferProgress = status; emit bufferProgressChanged(status); }
 
     bool isAudioAvailable() const { return _audioAvailable; }
     bool isVideoAvailable() const { return _videoAvailable; }
@@ -141,8 +141,8 @@ public:
         emit error(err, errorString);
     }
 
-    void setState(QMediaPlayer::State state) { emit stateChanged(_state = state); }
-    void setState(QMediaPlayer::State state, QMediaPlayer::MediaStatus status) {
+    void setState(QMediaPlayer::PlaybackState state) { emit stateChanged(_state = state); }
+    void setState(QMediaPlayer::PlaybackState state, QMediaPlayer::MediaStatus status) {
         _state = state;
         _mediaStatus = status;
         emit mediaStatusChanged(status);
@@ -164,7 +164,7 @@ public:
         _position = 0;
         _volume = 0;
         _muted = false;
-        _bufferStatus = 0;
+        _bufferProgress = 0;
         _videoAvailable = false;
         _isSeekable = false;
         _playbackRate = 0.0;
@@ -179,14 +179,14 @@ public:
     bool hasAudioRole = true;
     QAudio::Role m_audioRole = QAudio::UnknownRole;
 
-    QMediaPlayer::State _state;
+    QMediaPlayer::PlaybackState _state;
     QMediaPlayer::MediaStatus _mediaStatus;
     QMediaPlayer::Error _error;
     qint64 _duration;
     qint64 _position;
     int _volume;
     bool _muted;
-    int _bufferStatus;
+    float _bufferProgress;
     bool _audioAvailable;
     bool _videoAvailable;
     bool _isSeekable;
diff --git a/tests/auto/unit/multimedia/qmediaplayer/tst_qmediaplayer.cpp b/tests/auto/unit/multimedia/qmediaplayer/tst_qmediaplayer.cpp
index b93c57f79..a187fcd5f 100644
--- a/tests/auto/unit/multimedia/qmediaplayer/tst_qmediaplayer.cpp
+++ b/tests/auto/unit/multimedia/qmediaplayer/tst_qmediaplayer.cpp
@@ -165,7 +165,7 @@ private:
 void tst_QMediaPlayer::setupCommonTestData()
 {
     QTest::addColumn<bool>("valid");
-    QTest::addColumn<QMediaPlayer::State>("state");
+    QTest::addColumn<QMediaPlayer::PlaybackState>("state");
     QTest::addColumn<QMediaPlayer::MediaStatus>("status");
     QTest::addColumn<QUrl>("mediaContent");
     QTest::addColumn<qint64>("duration");
@@ -174,7 +174,7 @@ void tst_QMediaPlayer::setupCommonTestData()
     QTest::addColumn<int>("volume");
     QTest::addColumn<bool>("muted");
     QTest::addColumn<bool>("videoAvailable");
-    QTest::addColumn<int>("bufferStatus");
+    QTest::addColumn<int>("bufferProgress");
     QTest::addColumn<qreal>("playbackRate");
     QTest::addColumn<QMediaPlayer::Error>("error");
     QTest::addColumn<QString>("errorString");
@@ -237,16 +237,16 @@ void tst_QMediaPlayer::testNullService()
 
     const QIODevice *nullDevice = nullptr;
 
-    QCOMPARE(player.media(), QUrl());
-    QCOMPARE(player.mediaStream(), nullDevice);
-    QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+    QCOMPARE(player.source(), QUrl());
+    QCOMPARE(player.sourceStream(), nullDevice);
+    QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
     QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);
     QCOMPARE(player.duration(), qint64(-1));
     QCOMPARE(player.position(), qint64(0));
     QCOMPARE(player.volume(), 0);
     QCOMPARE(player.isMuted(), false);
-    QCOMPARE(player.isVideoAvailable(), false);
-    QCOMPARE(player.bufferStatus(), 0);
+    QCOMPARE(player.hasVideo(), false);
+    QCOMPARE(player.bufferProgress(), 0);
     QCOMPARE(player.isSeekable(), false);
     QCOMPARE(player.playbackRate(), qreal(0));
     QCOMPARE(player.error(), QMediaPlayer::ServiceMissingError);
@@ -259,28 +259,28 @@ void tst_QMediaPlayer::testNullService()
         QFile file;
 
         bool changed = !mediaContent.isEmpty();
-        player.setMedia(mediaContent, &file);
-        QCOMPARE(player.media(), mediaContent);
-        QCOMPARE(player.mediaStream(), nullDevice);
+        player.setSource(mediaContent, &file);
+        QCOMPARE(player.source(), mediaContent);
+        QCOMPARE(player.sourceStream(), nullDevice);
         QCOMPARE(spy.count(), changed ? 1 : 0);
     } {
         QSignalSpy stateSpy(&player, SIGNAL(stateChanged(QMediaPlayer::State)));
         QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
 
         player.play();
-        QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+        QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
         QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);
         QCOMPARE(stateSpy.count(), 0);
         QCOMPARE(statusSpy.count(), 0);
 
         player.pause();
-        QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+        QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
         QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);
         QCOMPARE(stateSpy.count(), 0);
         QCOMPARE(statusSpy.count(), 0);
 
         player.stop();
-        QCOMPARE(player.state(), QMediaPlayer::StoppedState);
+        QCOMPARE(player.playbackState(), QMediaPlayer::StoppedState);
         QCOMPARE(player.mediaStatus(), QMediaPlayer::UnknownMediaStatus);
         QCOMPARE(stateSpy.count(), 0);
         QCOMPARE(statusSpy.count(), 0);
@@ -339,12 +339,12 @@ void tst_QMediaPlayer::testMedia()
     QFETCH(QUrl, mediaContent);
 
     mockPlayer->setMedia(mediaContent);
-    QCOMPARE(player->media(), mediaContent);
+    QCOMPARE(player->source(), mediaContent);
 
     QBuffer stream;
-    player->setMedia(mediaContent, &stream);
-    QCOMPARE(player->media(), mediaContent);
-    QCOMPARE((QBuffer*)player->mediaStream(), &stream);
+    player->setSource(mediaContent, &stream);
+    QCOMPARE(player->source(), mediaContent);
+    QCOMPARE((QBuffer*)player->sourceStream(), &stream);
 }
 
 void tst_QMediaPlayer::testDuration_data()
@@ -484,7 +484,7 @@ void tst_QMediaPlayer::testVideoAvailable()
     QFETCH(bool, videoAvailable);
 
     mockPlayer->setVideoAvailable(videoAvailable);
-    QVERIFY(player->isVideoAvailable() == videoAvailable);
+    QVERIFY(player->hasVideo() == videoAvailable);
 }
 
 void tst_QMediaPlayer::testBufferStatus_data()
@@ -494,10 +494,10 @@ void tst_QMediaPlayer::testBufferStatus_data()
 
 void tst_QMediaPlayer::testBufferStatus()
 {
-    QFETCH(int, bufferStatus);
+    QFETCH(int, bufferProgress);
 
-    mockPlayer->setBufferStatus(bufferStatus);
-    QVERIFY(player->bufferStatus() == bufferStatus);
+    mockPlayer->setBufferStatus(bufferProgress);
+    QVERIFY(player->bufferProgress() == bufferProgress);
 }
 
 void tst_QMediaPlayer::testSeekable_data()
@@ -588,24 +588,24 @@ void tst_QMediaPlayer::testPlay()
 {
     QFETCH(bool, valid);
     QFETCH(QUrl, mediaContent);
-    QFETCH(QMediaPlayer::State, state);
+    QFETCH(QMediaPlayer::PlaybackState, state);
 
     mockPlayer->setIsValid(valid);
     mockPlayer->setState(state);
-    player->setMedia(mediaContent);
-    QVERIFY(player->state() == state);
-    QVERIFY(player->media() == mediaContent);
+    player->setSource(mediaContent);
+    QVERIFY(player->playbackState() == state);
+    QVERIFY(player->source() == mediaContent);
 
     QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));
 
     player->play();
 
     if (!valid || mediaContent.isEmpty())  {
-        QCOMPARE(player->state(), QMediaPlayer::StoppedState);
+        QCOMPARE(player->playbackState(), QMediaPlayer::StoppedState);
         QCOMPARE(spy.count(), 0);
     }
     else {
-        QCOMPARE(player->state(), QMediaPlayer::PlayingState);
+        QCOMPARE(player->playbackState(), QMediaPlayer::PlayingState);
         QCOMPARE(spy.count(), state == QMediaPlayer::PlayingState ? 0 : 1);
     }
 }
@@ -619,24 +619,24 @@ void tst_QMediaPlayer::testPause()
 {
     QFETCH(bool, valid);
     QFETCH(QUrl, mediaContent);
-    QFETCH(QMediaPlayer::State, state);
+    QFETCH(QMediaPlayer::PlaybackState, state);
 
     mockPlayer->setIsValid(valid);
     mockPlayer->setState(state);
     mockPlayer->setMedia(mediaContent);
-    QVERIFY(player->state() == state);
-    QVERIFY(player->media() == mediaContent);
+    QVERIFY(player->playbackState() == state);
+    QVERIFY(player->source() == mediaContent);
 
     QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));
 
     player->pause();
 
     if (!valid || mediaContent.isEmpty()) {
-        QCOMPARE(player->state(), QMediaPlayer::StoppedState);
+        QCOMPARE(player->playbackState(), QMediaPlayer::StoppedState);
         QCOMPARE(spy.count(), 0);
     }
     else {
-        QCOMPARE(player->state(), QMediaPlayer::PausedState);
+        QCOMPARE(player->playbackState(), QMediaPlayer::PausedState);
         QCOMPARE(spy.count(), state == QMediaPlayer::PausedState ? 0 : 1);
     }
 }
@@ -649,23 +649,23 @@ void tst_QMediaPlayer::testStop_data()
 void tst_QMediaPlayer::testStop()
 {
     QFETCH(QUrl, mediaContent);
-    QFETCH(QMediaPlayer::State, state);
+    QFETCH(QMediaPlayer::PlaybackState, state);
 
     mockPlayer->setState(state);
     mockPlayer->setMedia(mediaContent);
-    QVERIFY(player->state() == state);
-    QVERIFY(player->media() == mediaContent);
+    QVERIFY(player->playbackState() == state);
+    QVERIFY(player->source() == mediaContent);
 
     QSignalSpy spy(player, SIGNAL(stateChanged(QMediaPlayer::State)));
 
     player->stop();
 
     if (mediaContent.isEmpty() || state == QMediaPlayer::StoppedState) {
-        QCOMPARE(player->state(), QMediaPlayer::StoppedState);
+        QCOMPARE(player->playbackState(), QMediaPlayer::StoppedState);
         QCOMPARE(spy.count(), 0);
     }
     else {
-        QCOMPARE(player->state(), QMediaPlayer::StoppedState);
+        QCOMPARE(player->playbackState(), QMediaPlayer::StoppedState);
         QCOMPARE(spy.count(), 1);
     }
 }
@@ -677,18 +677,18 @@ void tst_QMediaPlayer::testMediaStatus_data()
 
 void tst_QMediaPlayer::testMediaStatus()
 {
-    QFETCH(int, bufferStatus);
+    QFETCH(int, bufferProgress);
     int bufferSignals = 0;
 
     mockPlayer->setMediaStatus(QMediaPlayer::NoMedia);
-    mockPlayer->setBufferStatus(bufferStatus);
+    mockPlayer->setBufferStatus(bufferProgress);
 
     AutoConnection connection(
-            player, SIGNAL(bufferStatusChanged(int)),
+            player, SIGNAL(bufferProgressChanged(float)),
             &QTestEventLoop::instance(), SLOT(exitLoop()));
 
     QSignalSpy statusSpy(player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
-    QSignalSpy bufferSpy(player, SIGNAL(bufferStatusChanged(int)));
+    QSignalSpy bufferSpy(player, SIGNAL(bufferProgressChanged(float)));
 
     QCOMPARE(player->mediaStatus(), QMediaPlayer::NoMedia);
 
@@ -706,7 +706,7 @@ void tst_QMediaPlayer::testMediaStatus()
     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),
              QMediaPlayer::LoadedMedia);
 
-    // Verify the bufferStatusChanged() signal isn't being emitted.
+    // Verify the bufferProgressChanged() signal isn't being emitted.
     QTestEventLoop::instance().enterLoop(1);
     QCOMPARE(bufferSpy.count(), 0);
 
@@ -717,10 +717,10 @@ void tst_QMediaPlayer::testMediaStatus()
     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),
              QMediaPlayer::StalledMedia);
 
-    // Verify the bufferStatusChanged() signal is being emitted.
+    // Verify the bufferProgressChanged() signal is being emitted.
     QTestEventLoop::instance().enterLoop(1);
     QVERIFY(bufferSpy.count() > bufferSignals);
-    QCOMPARE(bufferSpy.last().value(0).toInt(), bufferStatus);
+    QCOMPARE(bufferSpy.last().value(0).toInt(), bufferProgress);
     bufferSignals = bufferSpy.count();
 
     mockPlayer->setMediaStatus(QMediaPlayer::BufferingMedia);
@@ -730,10 +730,10 @@ void tst_QMediaPlayer::testMediaStatus()
     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),
              QMediaPlayer::BufferingMedia);
 
-    // Verify the bufferStatusChanged() signal is being emitted.
+    // Verify the bufferProgressChanged() signal is being emitted.
     QTestEventLoop::instance().enterLoop(1);
     QVERIFY(bufferSpy.count() > bufferSignals);
-    QCOMPARE(bufferSpy.last().value(0).toInt(), bufferStatus);
+    QCOMPARE(bufferSpy.last().value(0).toInt(), bufferProgress);
     bufferSignals = bufferSpy.count();
 
     mockPlayer->setMediaStatus(QMediaPlayer::BufferedMedia);
@@ -743,7 +743,7 @@ void tst_QMediaPlayer::testMediaStatus()
     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)),
              QMediaPlayer::BufferedMedia);
 
-    // Verify the bufferStatusChanged() signal isn't being emitted.
+    // Verify the bufferProgressChanged() signal isn't being emitted.
     QTestEventLoop::instance().enterLoop(1);
     QCOMPARE(bufferSpy.count(), bufferSignals);
 
@@ -866,13 +866,13 @@ void tst_QMediaPlayer::testQrc()
     QSignalSpy statusSpy(&player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
     QSignalSpy errorSpy(&player, SIGNAL(error(QMediaPlayer::Error)));
 
-    player.setMedia(mediaContent);
+    player.setSource(mediaContent);
 
     QTRY_COMPARE(player.mediaStatus(), status);
     QCOMPARE(statusSpy.count(), 1);
     QCOMPARE(qvariant_cast<QMediaPlayer::MediaStatus>(statusSpy.last().value(0)), status);
 
-    QCOMPARE(player.media(), mediaContent);
+    QCOMPARE(player.source(), mediaContent);
     QCOMPARE(mediaSpy.count(), 1);
     QCOMPARE(qvariant_cast<QUrl>(mediaSpy.last().value(0)), mediaContent);
 
diff --git a/tests/auto/unit/qml/qdeclarativevideo/tst_qdeclarativevideo.cpp b/tests/auto/unit/qml/qdeclarativevideo/tst_qdeclarativevideo.cpp
index f2c5a92b7..7ea4179eb 100644
--- a/tests/auto/unit/qml/qdeclarativevideo/tst_qdeclarativevideo.cpp
+++ b/tests/auto/unit/qml/qdeclarativevideo/tst_qdeclarativevideo.cpp
@@ -80,7 +80,7 @@ public:
         , m_position(0)
         , m_playbackRate(1.0)
         , m_volume(50)
-        , m_bufferStatus(0)
+        , m_bufferProgress(0)
         , m_muted(false)
         , m_audioAvailable(false)
         , m_videoAvailable(false)
@@ -115,8 +115,8 @@ public:
     bool isMuted() const { return m_muted; }
     void setMuted(bool muted) { emit mutedChanged(m_muted = muted); }
 
-    int bufferStatus() const { return m_bufferStatus; }
-    void setBufferStatus(int status) { emit bufferStatusChanged(m_bufferStatus = status); }
+    float bufferProgress() const { return m_bufferProgress/100.; }
+    void setBufferStatus(int status) { emit bufferProgressChanged(m_bufferProgress = status); }
 
     bool isAudioAvailable() const { return m_audioAvailable; }
     void setAudioAvailable(bool available) {
@@ -160,7 +160,7 @@ private:
     qint64 m_position;
     qreal m_playbackRate;
     int m_volume;
-    int m_bufferStatus;
+    int m_bufferProgress;
     bool m_muted;
     bool m_audioAvailable;
     bool m_videoAvailable;