Make QDeclarativeAudio use QMediaPlayer instead of the controls.

Very minor changes in semantics due to previous differences:
* negative positions are not supported any more (clamped to >= 0)
* setting muted to the same value previously set to the control itself
  won't signal any more.

Change-Id: Iacf4310508d853ae82b63dee28095fce12b6ff28
Reviewed-by: Dmytro Poplavskiy <dmytro.poplavskiy@nokia.com>

src/imports/multimedia/multimedia.pro

@@ -28,7 +28,8 @@ HEADERS += \
         qdeclarativecamerapreviewprovider_p.h \
         qdeclarativetorch_p.h \
         qdeclarativeaudio_p_4.h \
-        qdeclarativemediabase_p_4.h
+        qdeclarativemediabase_p_4.h \
+        qdeclarativemediametadata_p_4.h
 
 SOURCES += \
         multimedia.cpp \

src/imports/multimedia/qdeclarativeaudio.cpp

@@ -56,113 +56,6 @@
 
 QT_BEGIN_NAMESPACE
 
-
-class QDeclarativeMediaBaseObject : public QMediaObject
-{
-public:
-    QDeclarativeMediaBaseObject(QMediaService *service)
-        : QMediaObject(0, service)
-    {
-    }
-};
-
-class QDeclarativeMediaBasePlayerControl : public QMediaPlayerControl
-{
-public:
-    QDeclarativeMediaBasePlayerControl(QObject *parent)
-        : QMediaPlayerControl(parent)
-    {
-    }
-
-    QMediaPlayer::State state() const { return QMediaPlayer::StoppedState; }
-    QMediaPlayer::MediaStatus mediaStatus() const { return QMediaPlayer::NoMedia; }
-
-    qint64 duration() const { return 0; }
-    qint64 position() const { return 0; }
-    void setPosition(qint64) {}
-    int volume() const { return 0; }
-    void setVolume(int) {}
-    bool isMuted() const { return false; }
-    void setMuted(bool) {}
-    int bufferStatus() const { return 0; }
-    bool isAudioAvailable() const { return false; }
-    bool isVideoAvailable() const { return false; }
-    bool isSeekable() const { return false; }
-    QMediaTimeRange availablePlaybackRanges() const { return QMediaTimeRange(); }
-    qreal playbackRate() const { return 1; }
-    void setPlaybackRate(qreal) {}
-    QMediaContent media() const { return QMediaContent(); }
-    const QIODevice *mediaStream() const { return 0; }
-    void setMedia(const QMediaContent &, QIODevice *) {}
-
-    void play() {}
-    void pause() {}
-    void stop() {}
-};
-
-class QDeclarativeMediaBaseAvailabilityControl : public QMediaAvailabilityControl
-{
-public:
-    QDeclarativeMediaBaseAvailabilityControl(bool available)
-        : m_available(available)
-    {
-    }
-
-    QtMultimedia::AvailabilityError availability() const
-    {
-        return m_available ? QtMultimedia::NoError : QtMultimedia::ServiceMissingError;
-    }
-
-private:
-    bool m_available;
-};
-
-class QDeclarativeMediaBaseMetaDataControl : public QMetaDataReaderControl
-{
-public:
-    QDeclarativeMediaBaseMetaDataControl(QObject *parent)
-        : QMetaDataReaderControl(parent)
-    {
-    }
-
-    bool isMetaDataAvailable() const { return false; }
-
-    QVariant metaData(const QString &) const { return QVariant(); }
-    QStringList availableMetaData() const { return QStringList(); }
-};
-
-class QDeclarativeMediaBaseAnimation : public QObject
-{
-public:
-    QDeclarativeMediaBaseAnimation(QDeclarativeAudio *media)
-        : m_media(media)
-    {
-    }
-
-    void start() { if (!m_timer.isActive()) m_timer.start(500, this); }
-    void stop() { m_timer.stop(); }
-
-protected:
-    void timerEvent(QTimerEvent *event)
-    {
-        if (event->timerId() == m_timer.timerId()) {
-            event->accept();
-
-            if (m_media->m_playbackState == QMediaPlayer::PlayingState)
-                emit m_media->positionChanged();
-            if (m_media->m_status == QMediaPlayer::BufferingMedia || QMediaPlayer::StalledMedia)
-                emit m_media->bufferProgressChanged();
-        } else {
-            QObject::timerEvent(event);
-        }
-    }
-
-private:
-    QDeclarativeAudio *m_media;
-    QBasicTimer m_timer;
-};
-
-
 /*!
     \qmlclass MediaPlayer
     \brief The MediaPlayer element allows you to add media playback to a scene.
@@ -261,12 +154,12 @@ private:
     \brief The QDeclarativeAudio class provides an audio item that you can add to a QDeclarativeView.
 */
 
-void QDeclarativeAudio::_q_error(int errorCode, const QString &errorString)
+void QDeclarativeAudio::_q_error(QMediaPlayer::Error errorCode)
 {
-    m_error = QMediaPlayer::Error(errorCode);
+    m_error = errorCode;
-    m_errorString = errorString;
+    m_errorString = m_player->errorString();
 
-    emit error(Error(errorCode), errorString);
+    emit error(Error(errorCode), m_errorString);
     emit errorChanged();
 }
 
@@ -275,7 +168,6 @@ void QDeclarativeAudio::_q_availabilityChanged(QtMultimedia::AvailabilityError)
     emit availabilityChanged(availability());
 }
 
-
 QDeclarativeAudio::QDeclarativeAudio(QObject *parent)
     : QObject(parent)
     , m_autoPlay(false)
@@ -288,28 +180,17 @@ QDeclarativeAudio::QDeclarativeAudio(QObject *parent)
     , m_position(0)
     , m_vol(1.0)
     , m_playbackRate(1.0)
-    , m_mediaService(0)
-    , m_playerControl(0)
-    , m_mediaObject(0)
-    , m_mediaProvider(0)
-    , m_metaDataControl(0)
-    , m_animation(0)
-    , m_availabilityControl(0)
     , m_playbackState(QMediaPlayer::StoppedState)
     , m_status(QMediaPlayer::NoMedia)
     , m_error(QMediaPlayer::ServiceMissingError)
+    , m_player(0)
 {
 }
 
 QDeclarativeAudio::~QDeclarativeAudio()
 {
-    delete m_mediaObject;
     m_metaData.reset();
-
+    delete m_player;
-    if (m_mediaProvider)
-        m_mediaProvider->releaseService(m_mediaService);
-
-    delete m_animation;
 }
 
 /*!
@@ -334,11 +215,9 @@ QDeclarativeAudio::~QDeclarativeAudio()
  */
 QDeclarativeAudio::Availability QDeclarativeAudio::availability() const
 {
-    if (!m_playerControl)
+    if (!m_player)
         return Unavailable;
-    if (m_availabilityControl)
+    return Availability(m_player->availabilityError());
-        return Availability(m_availabilityControl->availability());
-    return Available;
 }
 
 QUrl QDeclarativeAudio::source() const
@@ -376,13 +255,14 @@ void QDeclarativeAudio::setSource(const QUrl &url)
             emit errorChanged();
         }
 
-        m_playerControl->setMedia(m_source, 0);
+        m_player->setMedia(m_source, 0);
         m_loaded = true;
     }
     else
         emit sourceChanged();
 
-    if (m_autoPlay) m_playerControl->play();
+    if (m_autoPlay)
+        m_player->play();
 }
 
 bool QDeclarativeAudio::isAutoLoad() const
@@ -428,53 +308,58 @@ void QDeclarativeAudio::setPlaybackState(QMediaPlayer::State playbackState)
         switch (playbackState){
         case (QMediaPlayer::PlayingState):
             if (!m_loaded) {
-                m_playerControl->setMedia(m_source, 0);
+                m_player->setMedia(m_source, 0);
-                m_playerControl->setPosition(m_position);
+                m_player->setPosition(m_position);
                 m_loaded = true;
             }
-            m_playerControl->play();
+            m_player->play();
             break;
 
         case (QMediaPlayer::PausedState):
             if (!m_loaded) {
-                m_playerControl->setMedia(m_source, 0);
+                m_player->setMedia(m_source, 0);
-                m_playerControl->setPosition(m_position);
+                m_player->setPosition(m_position);
                 m_loaded = true;
             }
-            m_playerControl->pause();
+            m_player->pause();
             break;
 
         case (QMediaPlayer::StoppedState):
-            m_playerControl->stop();
+            m_player->stop();
         }
     }
 }
 
 int QDeclarativeAudio::duration() const
 {
-    return !m_complete ? 0 : m_playerControl->duration();
+    return !m_complete ? 0 : m_player->duration();
 }
 
 int QDeclarativeAudio::position() const
 {
-    return !m_complete ? m_position : m_playerControl->position();
+    return !m_complete ? m_position : m_player->position();
 }
 
 void QDeclarativeAudio::setPosition(int position)
 {
+    // QMediaPlayer clamps this to positive numbers
+    if (position < 0)
+        position = 0;
+
     if (this->position() == position)
         return;
 
     m_position = position;
+
     if (m_complete)
-        m_playerControl->setPosition(m_position);
+        m_player->setPosition(m_position);
     else
         emit positionChanged();
 }
 
 qreal QDeclarativeAudio::volume() const
 {
-    return !m_complete ? m_vol : qreal(m_playerControl->volume()) / 100;
+    return !m_complete ? m_vol : qreal(m_player->volume()) / 100;
 }
 
 void QDeclarativeAudio::setVolume(qreal volume)
@@ -490,14 +375,14 @@ void QDeclarativeAudio::setVolume(qreal volume)
     m_vol = volume;
 
     if (m_complete)
-        m_playerControl->setVolume(qRound(volume * 100));
+        m_player->setVolume(qRound(volume * 100));
     else
         emit volumeChanged();
 }
 
 bool QDeclarativeAudio::isMuted() const
 {
-    return !m_complete ? m_muted : m_playerControl->isMuted();
+    return !m_complete ? m_muted : m_player->isMuted();
 }
 
 void QDeclarativeAudio::setMuted(bool muted)
@@ -508,19 +393,19 @@ void QDeclarativeAudio::setMuted(bool muted)
     m_muted = muted;
 
     if (m_complete)
-        m_playerControl->setMuted(muted);
+        m_player->setMuted(muted);
     else
         emit mutedChanged();
 }
 
 qreal QDeclarativeAudio::bufferProgress() const
 {
-    return !m_complete ? 0 : qreal(m_playerControl->bufferStatus()) / 100;
+    return !m_complete ? 0 : qreal(m_player->bufferStatus()) / 100;
 }
 
 bool QDeclarativeAudio::isSeekable() const
 {
-    return !m_complete ? false : m_playerControl->isSeekable();
+    return !m_complete ? false : m_player->isSeekable();
 }
 
 qreal QDeclarativeAudio::playbackRate() const
@@ -536,7 +421,7 @@ void QDeclarativeAudio::setPlaybackRate(qreal rate)
     m_playbackRate = rate;
 
     if (m_complete)
-        m_playerControl->setPlaybackRate(m_playbackRate);
+        m_player->setPlaybackRate(m_playbackRate);
     else
         emit playbackRateChanged();
 }
@@ -724,7 +609,7 @@ QDeclarativeAudio::PlaybackState QDeclarativeAudio::playbackState() const
 
 bool QDeclarativeAudio::hasAudio() const
 {
-    return !m_complete ? false : m_playerControl->isAudioAvailable();
+    return !m_complete ? false : m_player->isAudioAvailable();
 }
 
 /*!
@@ -735,7 +620,7 @@ bool QDeclarativeAudio::hasAudio() const
 
 bool QDeclarativeAudio::hasVideo() const
 {
-    return !m_complete ? false : m_playerControl->isVideoAvailable();
+    return !m_complete ? false : m_player->isVideoAvailable();
 }
 
 /*!
@@ -782,115 +667,89 @@ QDeclarativeAudio::Error QDeclarativeAudio::error() const
 
 void QDeclarativeAudio::classBegin()
 {
-    if ((m_mediaProvider = QMediaServiceProvider::defaultServiceProvider()) != 0) {
+    m_player = new QMediaPlayer(this);
-        m_mediaService = m_mediaProvider->requestService(Q_MEDIASERVICE_MEDIAPLAYER);
-        if (m_mediaService != 0) {
-            m_playerControl = qobject_cast<QMediaPlayerControl *>(
-                    m_mediaService->requestControl(QMediaPlayerControl_iid));
-            m_metaDataControl = qobject_cast<QMetaDataReaderControl *>(
-                    m_mediaService->requestControl(QMetaDataReaderControl_iid));
-            m_mediaObject = new QDeclarativeMediaBaseObject(m_mediaService);
-            m_availabilityControl = m_mediaService->requestControl<QMediaAvailabilityControl*>();
-        }
-    }
 
-    bool realPlayer = m_playerControl;
+    connect(m_player, SIGNAL(stateChanged(QMediaPlayer::State)),
-
-    if (m_playerControl) {
-        QObject::connect(m_playerControl, SIGNAL(stateChanged(QMediaPlayer::State)),
             this, SLOT(_q_statusChanged()));
-        QObject::connect(m_playerControl, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
+    connect(m_player, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
             this, SLOT(_q_statusChanged()));
-        QObject::connect(m_playerControl, SIGNAL(mediaChanged(QMediaContent)),
+    connect(m_player, SIGNAL(mediaChanged(QMediaContent)),
             this, SIGNAL(sourceChanged()));
-        QObject::connect(m_playerControl, SIGNAL(durationChanged(qint64)),
+    connect(m_player, SIGNAL(durationChanged(qint64)),
             this, SIGNAL(durationChanged()));
-        QObject::connect(m_playerControl, SIGNAL(positionChanged(qint64)),
+    connect(m_player, SIGNAL(positionChanged(qint64)),
             this, SIGNAL(positionChanged()));
-        QObject::connect(m_playerControl, SIGNAL(volumeChanged(int)),
+    connect(m_player, SIGNAL(volumeChanged(int)),
             this, SIGNAL(volumeChanged()));
-        QObject::connect(m_playerControl, SIGNAL(mutedChanged(bool)),
+    connect(m_player, SIGNAL(mutedChanged(bool)),
             this, SIGNAL(mutedChanged()));
-        QObject::connect(m_playerControl, SIGNAL(bufferStatusChanged(int)),
+    connect(m_player, SIGNAL(bufferStatusChanged(int)),
             this, SIGNAL(bufferProgressChanged()));
-        QObject::connect(m_playerControl, SIGNAL(seekableChanged(bool)),
+    connect(m_player, SIGNAL(seekableChanged(bool)),
             this, SIGNAL(seekableChanged()));
-        QObject::connect(m_playerControl, SIGNAL(playbackRateChanged(qreal)),
+    connect(m_player, SIGNAL(playbackRateChanged(qreal)),
             this, SIGNAL(playbackRateChanged()));
-        QObject::connect(m_playerControl, SIGNAL(error(int,QString)),
+    connect(m_player, SIGNAL(error(QMediaPlayer::Error)),
-                this, SLOT(_q_error(int,QString)));
+            this, SLOT(_q_error(QMediaPlayer::Error)));
+    connect(m_player, SIGNAL(audioAvailableChanged(bool)),
+            this, SIGNAL(hasAudioChanged()));
+    connect(m_player, SIGNAL(videoAvailableChanged(bool)),
+            this, SIGNAL(hasVideoChanged()));
 
-        m_animation = new QDeclarativeMediaBaseAnimation(this);
+    m_error = m_player->availabilityError() == QtMultimedia::ServiceMissingError ? QMediaPlayer::ServiceMissingError : QMediaPlayer::NoError;
-        m_error = QMediaPlayer::NoError;
-    } else {
-        m_playerControl = new QDeclarativeMediaBasePlayerControl(this);
-    }
 
-    if (!m_metaDataControl)
+    connect(m_player, SIGNAL(availabilityErrorChanged(QtMultimedia::AvailabilityError)),
-        m_metaDataControl = new QDeclarativeMediaBaseMetaDataControl(this);
-
-    if (!m_availabilityControl)
-        m_availabilityControl = new QDeclarativeMediaBaseAvailabilityControl(realPlayer);
-
-    QObject::connect(m_availabilityControl, SIGNAL(availabilityChanged(QtMultimedia::AvailabilityError)),
                      this, SLOT(_q_availabilityChanged(QtMultimedia::AvailabilityError)));
 
-    m_metaData.reset(new QDeclarativeMediaMetaData(m_metaDataControl));
+    m_metaData.reset(new QDeclarativeMediaMetaData(m_player));
 
-    QObject::connect(m_metaDataControl, SIGNAL(metaDataChanged()),
+    connect(m_player, SIGNAL(metaDataChanged()),
             m_metaData.data(), SIGNAL(metaDataChanged()));
 
-    if (m_mediaService) {
-        connect(m_playerControl, SIGNAL(audioAvailableChanged(bool)),
-                this, SIGNAL(hasAudioChanged()));
-        connect(m_playerControl, SIGNAL(videoAvailableChanged(bool)),
-                this, SIGNAL(hasVideoChanged()));
-    }
-
     emit mediaObjectChanged();
 }
 
 void QDeclarativeAudio::componentComplete()
 {
     if (!qFuzzyCompare(m_vol, qreal(1.0)))
-        m_playerControl->setVolume(m_vol * 100);
+        m_player->setVolume(m_vol * 100);
     if (m_muted)
-        m_playerControl->setMuted(m_muted);
+        m_player->setMuted(m_muted);
     if (!qFuzzyCompare(m_playbackRate, qreal(1.0)))
-        m_playerControl->setPlaybackRate(m_playbackRate);
+        m_player->setPlaybackRate(m_playbackRate);
 
     if (!m_source.isEmpty() && (m_autoLoad || m_autoPlay)) {
-        m_playerControl->setMedia(m_source, 0);
+        m_player->setMedia(m_source, 0);
         m_loaded = true;
         if (m_position > 0)
-            m_playerControl->setPosition(m_position);
+            m_player->setPosition(m_position);
     }
 
     m_complete = true;
 
     if (m_autoPlay) {
         if (m_source.isEmpty()) {
-            m_playerControl->stop();
+            m_player->stop();
         } else {
-            m_playerControl->play();
+            m_player->play();
         }
     }
 }
 
 void QDeclarativeAudio::_q_statusChanged()
 {
-    if (m_playerControl->mediaStatus() == QMediaPlayer::EndOfMedia && m_runningCount != 0) {
+    if (m_player->mediaStatus() == QMediaPlayer::EndOfMedia && m_runningCount != 0) {
         m_runningCount -= 1;
-        m_playerControl->play();
+        m_player->play();
     }
     const QMediaPlayer::MediaStatus oldStatus = m_status;
     const QMediaPlayer::State lastPlaybackState = m_playbackState;
 
-    const QMediaPlayer::State state = m_playerControl->state();
+    const QMediaPlayer::State state = m_player->state();
 
     m_playbackState = state;
 
-    m_status = m_playerControl->mediaStatus();
+    m_status = m_player->mediaStatus();
 
     if (m_status != oldStatus)
         emit statusChanged();
@@ -914,16 +773,6 @@ void QDeclarativeAudio::_q_statusChanged()
 
         emit playbackStateChanged();
     }
-
-    // Check
-    if ((state == QMediaPlayer::PlayingState)
-            || m_status == QMediaPlayer::BufferingMedia
-            || m_status == QMediaPlayer::StalledMedia) {
-        m_animation->start();
-    }
-    else {
-        m_animation->stop();
-    }
 }
 
 /*!

src/imports/multimedia/qdeclarativeaudio_p.h

@@ -158,7 +158,7 @@ public:
     void classBegin();
     void componentComplete();
 
-    QObject *mediaObject() { return m_mediaObject; }
+    QObject *mediaObject() { return m_player; }
 
     Availability availability() const;
 
@@ -236,7 +236,7 @@ Q_SIGNALS:
     void mediaObjectChanged();
 
 private Q_SLOTS:
-    void _q_error(int, const QString &);
+    void _q_error(QMediaPlayer::Error);
     void _q_availabilityChanged(QtMultimedia::AvailabilityError);
     void _q_statusChanged();
 
@@ -253,16 +253,6 @@ private:
     int m_position;
     qreal m_vol;
     qreal m_playbackRate;
-    QMediaService *m_mediaService;
-    QMediaPlayerControl *m_playerControl;
-
-    QMediaObject *m_mediaObject;
-    QMediaServiceProvider *m_mediaProvider;
-    QMetaDataReaderControl *m_metaDataControl;
-    QDeclarativeMediaBaseAnimation *m_animation;
-    QScopedPointer<QDeclarativeMediaMetaData> m_metaData;
-
-    QMediaAvailabilityControl *m_availabilityControl;
 
     QMediaPlayer::State m_playbackState;
     QMediaPlayer::MediaStatus m_status;
@@ -270,6 +260,10 @@ private:
     QString m_errorString;
     QUrl m_source;
 
+    QScopedPointer<QDeclarativeMediaMetaData> m_metaData;
+
+    QMediaPlayer *m_player;
+
     friend class QDeclarativeMediaBaseAnimation;
 };
 

src/imports/multimedia/qdeclarativeaudio_p_4.h

@@ -85,7 +85,7 @@ class QDeclarativeAudio_4 : public QObject, public QDeclarativeMediaBase_4, publ
     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(QDeclarativeMediaMetaData_4 *metaData READ metaData CONSTANT)
     Q_PROPERTY(QObject *mediaObject READ mediaObject NOTIFY mediaObjectChanged SCRIPTABLE false DESIGNABLE false)
     Q_ENUMS(Status)
     Q_ENUMS(Error)

src/imports/multimedia/qdeclarativemediabase_4.cpp

@@ -50,7 +50,7 @@
 #include <private/qmediaserviceprovider_p.h>
 #include <qmetadatareadercontrol.h>
 
-#include "qdeclarativemediametadata_p.h"
+#include "qdeclarativemediametadata_p_4.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -304,7 +304,7 @@ void QDeclarativeMediaBase_4::setObject(QObject *object, const QByteArray &type)
     if (!m_metaDataControl)
         m_metaDataControl = new QDeclarativeMediaBaseMetaDataControl(object);
 
-    m_metaData.reset(new QDeclarativeMediaMetaData(m_metaDataControl));
+    m_metaData.reset(new QDeclarativeMediaMetaData_4(m_metaDataControl));
 
     QObject::connect(m_metaDataControl, SIGNAL(metaDataChanged()),
             m_metaData.data(), SIGNAL(metaDataChanged()));
@@ -558,7 +558,7 @@ QString QDeclarativeMediaBase_4::errorString() const
     return m_errorString;
 }
 
-QDeclarativeMediaMetaData *QDeclarativeMediaBase_4::metaData() const
+QDeclarativeMediaMetaData_4 *QDeclarativeMediaBase_4::metaData() const
 {
     return m_metaData.data();
 }

src/imports/multimedia/qdeclarativemediabase_p_4.h

@@ -66,7 +66,7 @@ class QMediaService;
 class QMediaServiceProvider;
 class QMetaDataReaderControl;
 class QDeclarativeMediaBaseAnimation;
-class QDeclarativeMediaMetaData;
+class QDeclarativeMediaMetaData_4;
 
 class QDeclarativeMediaBase_4
 {
@@ -113,7 +113,7 @@ public:
 
     QString errorString() const;
 
-    QDeclarativeMediaMetaData *metaData() const;
+    QDeclarativeMediaMetaData_4 *metaData() const;
 
     void _q_statusChanged();
 
@@ -171,7 +171,7 @@ protected:
     QMediaServiceProvider *m_mediaProvider;
     QMetaDataReaderControl *m_metaDataControl;
     QDeclarativeMediaBaseAnimation *m_animation;
-    QScopedPointer<QDeclarativeMediaMetaData> m_metaData;
+    QScopedPointer<QDeclarativeMediaMetaData_4> m_metaData;
 
     QMediaPlayer::MediaStatus m_status;
     QMediaPlayer::Error m_error;

src/imports/multimedia/qdeclarativemediametadata_p.h

@@ -53,9 +53,8 @@
 // We mean it.
 //
 
-#include <qmetadatareadercontrol.h>
-
 #include <QtQml/qqml.h>
+#include "qmediaobject.h"
 
 QT_BEGIN_HEADER
 
@@ -111,69 +110,69 @@ class QDeclarativeMediaMetaData : public QObject
     Q_PROPERTY(QVariant leadPerformer READ leadPerformer NOTIFY metaDataChanged)
     Q_PROPERTY(QVariant writer READ writer NOTIFY metaDataChanged)
 public:
-    QDeclarativeMediaMetaData(QMetaDataReaderControl *control, QObject *parent = 0)
+    QDeclarativeMediaMetaData(QMediaObject *player, QObject *parent = 0)
         : QObject(parent)
-        , m_control(control)
+        , m_mediaObject(player)
     {
     }
 
-    QVariant title() const { return m_control->metaData(QtMultimedia::MetaData::Title); }
+    QVariant title() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Title); }
-    QVariant subTitle() const { return m_control->metaData(QtMultimedia::MetaData::SubTitle); }
+    QVariant subTitle() const { return m_mediaObject->metaData(QtMultimedia::MetaData::SubTitle); }
-    QVariant author() const { return m_control->metaData(QtMultimedia::MetaData::Author); }
+    QVariant author() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Author); }
-    QVariant comment() const { return m_control->metaData(QtMultimedia::MetaData::Comment); }
+    QVariant comment() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Comment); }
-    QVariant description() const { return m_control->metaData(QtMultimedia::MetaData::Description); }
+    QVariant description() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Description); }
-    QVariant category() const { return m_control->metaData(QtMultimedia::MetaData::Category); }
+    QVariant category() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Category); }
-    QVariant genre() const { return m_control->metaData(QtMultimedia::MetaData::Genre); }
+    QVariant genre() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Genre); }
-    QVariant year() const { return m_control->metaData(QtMultimedia::MetaData::Year); }
+    QVariant year() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Year); }
-    QVariant date() const { return m_control->metaData(QtMultimedia::MetaData::Date); }
+    QVariant date() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Date); }
-    QVariant userRating() const { return m_control->metaData(QtMultimedia::MetaData::UserRating); }
+    QVariant userRating() const { return m_mediaObject->metaData(QtMultimedia::MetaData::UserRating); }
-    QVariant keywords() const { return m_control->metaData(QtMultimedia::MetaData::Keywords); }
+    QVariant keywords() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Keywords); }
-    QVariant language() const { return m_control->metaData(QtMultimedia::MetaData::Language); }
+    QVariant language() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Language); }
-    QVariant publisher() const { return m_control->metaData(QtMultimedia::MetaData::Publisher); }
+    QVariant publisher() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Publisher); }
-    QVariant copyright() const { return m_control->metaData(QtMultimedia::MetaData::Copyright); }
+    QVariant copyright() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Copyright); }
-    QVariant parentalRating() const { return m_control->metaData(QtMultimedia::MetaData::ParentalRating); }
+    QVariant parentalRating() const { return m_mediaObject->metaData(QtMultimedia::MetaData::ParentalRating); }
     QVariant ratingOrganization() const {
-        return m_control->metaData(QtMultimedia::MetaData::RatingOrganization); }
+        return m_mediaObject->metaData(QtMultimedia::MetaData::RatingOrganization); }
-    QVariant size() const { return m_control->metaData(QtMultimedia::MetaData::Size); }
+    QVariant size() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Size); }
-    QVariant mediaType() const { return m_control->metaData(QtMultimedia::MetaData::MediaType); }
+    QVariant mediaType() const { return m_mediaObject->metaData(QtMultimedia::MetaData::MediaType); }
-    QVariant duration() const { return m_control->metaData(QtMultimedia::MetaData::Duration); }
+    QVariant duration() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Duration); }
-    QVariant audioBitRate() const { return m_control->metaData(QtMultimedia::MetaData::AudioBitRate); }
+    QVariant audioBitRate() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AudioBitRate); }
-    QVariant audioCodec() const { return m_control->metaData(QtMultimedia::MetaData::AudioCodec); }
+    QVariant audioCodec() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AudioCodec); }
-    QVariant averageLevel() const { return m_control->metaData(QtMultimedia::MetaData::AverageLevel); }
+    QVariant averageLevel() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AverageLevel); }
-    QVariant channelCount() const { return m_control->metaData(QtMultimedia::MetaData::ChannelCount); }
+    QVariant channelCount() const { return m_mediaObject->metaData(QtMultimedia::MetaData::ChannelCount); }
-    QVariant peakValue() const { return m_control->metaData(QtMultimedia::MetaData::PeakValue); }
+    QVariant peakValue() const { return m_mediaObject->metaData(QtMultimedia::MetaData::PeakValue); }
-    QVariant sampleRate() const { return m_control->metaData(QtMultimedia::MetaData::SampleRate); }
+    QVariant sampleRate() const { return m_mediaObject->metaData(QtMultimedia::MetaData::SampleRate); }
-    QVariant albumTitle() const { return m_control->metaData(QtMultimedia::MetaData::AlbumTitle); }
+    QVariant albumTitle() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AlbumTitle); }
-    QVariant albumArtist() const { return m_control->metaData(QtMultimedia::MetaData::AlbumArtist); }
+    QVariant albumArtist() const { return m_mediaObject->metaData(QtMultimedia::MetaData::AlbumArtist); }
     QVariant contributingArtist() const {
-        return m_control->metaData(QtMultimedia::MetaData::ContributingArtist); }
+        return m_mediaObject->metaData(QtMultimedia::MetaData::ContributingArtist); }
-    QVariant composer() const { return m_control->metaData(QtMultimedia::MetaData::Composer); }
+    QVariant composer() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Composer); }
-    QVariant conductor() const { return m_control->metaData(QtMultimedia::MetaData::Conductor); }
+    QVariant conductor() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Conductor); }
-    QVariant lyrics() const { return m_control->metaData(QtMultimedia::MetaData::Lyrics); }
+    QVariant lyrics() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Lyrics); }
-    QVariant mood() const { return m_control->metaData(QtMultimedia::MetaData::Mood); }
+    QVariant mood() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Mood); }
-    QVariant trackNumber() const { return m_control->metaData(QtMultimedia::MetaData::TrackNumber); }
+    QVariant trackNumber() const { return m_mediaObject->metaData(QtMultimedia::MetaData::TrackNumber); }
-    QVariant trackCount() const { return m_control->metaData(QtMultimedia::MetaData::TrackCount); }
+    QVariant trackCount() const { return m_mediaObject->metaData(QtMultimedia::MetaData::TrackCount); }
     QVariant coverArtUrlSmall() const {
-        return m_control->metaData(QtMultimedia::MetaData::CoverArtUrlSmall); }
+        return m_mediaObject->metaData(QtMultimedia::MetaData::CoverArtUrlSmall); }
     QVariant coverArtUrlLarge() const {
-        return m_control->metaData(QtMultimedia::MetaData::CoverArtUrlLarge); }
+        return m_mediaObject->metaData(QtMultimedia::MetaData::CoverArtUrlLarge); }
-    QVariant resolution() const { return m_control->metaData(QtMultimedia::MetaData::Resolution); }
+    QVariant resolution() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Resolution); }
     QVariant pixelAspectRatio() const {
-        return m_control->metaData(QtMultimedia::MetaData::PixelAspectRatio); }
+        return m_mediaObject->metaData(QtMultimedia::MetaData::PixelAspectRatio); }
-    QVariant videoFrameRate() const { return m_control->metaData(QtMultimedia::MetaData::VideoFrameRate); }
+    QVariant videoFrameRate() const { return m_mediaObject->metaData(QtMultimedia::MetaData::VideoFrameRate); }
-    QVariant videoBitRate() const { return m_control->metaData(QtMultimedia::MetaData::VideoBitRate); }
+    QVariant videoBitRate() const { return m_mediaObject->metaData(QtMultimedia::MetaData::VideoBitRate); }
-    QVariant videoCodec() const { return m_control->metaData(QtMultimedia::MetaData::VideoCodec); }
+    QVariant videoCodec() const { return m_mediaObject->metaData(QtMultimedia::MetaData::VideoCodec); }
-    QVariant posterUrl() const { return m_control->metaData(QtMultimedia::MetaData::PosterUrl); }
+    QVariant posterUrl() const { return m_mediaObject->metaData(QtMultimedia::MetaData::PosterUrl); }
-    QVariant chapterNumber() const { return m_control->metaData(QtMultimedia::MetaData::ChapterNumber); }
+    QVariant chapterNumber() const { return m_mediaObject->metaData(QtMultimedia::MetaData::ChapterNumber); }
-    QVariant director() const { return m_control->metaData(QtMultimedia::MetaData::Director); }
+    QVariant director() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Director); }
-    QVariant leadPerformer() const { return m_control->metaData(QtMultimedia::MetaData::LeadPerformer); }
+    QVariant leadPerformer() const { return m_mediaObject->metaData(QtMultimedia::MetaData::LeadPerformer); }
-    QVariant writer() const { return m_control->metaData(QtMultimedia::MetaData::Writer); }
+    QVariant writer() const { return m_mediaObject->metaData(QtMultimedia::MetaData::Writer); }
 
 Q_SIGNALS:
     void metaDataChanged();
 
 private:
-    QMetaDataReaderControl *m_control;
+    QMediaObject *m_mediaObject;
 };
 
 QT_END_NAMESPACE

src/imports/multimedia/qdeclarativemediametadata_p_4.h

@@ -0,0 +1,187 @@
+
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements will be met:
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QDECLARATIVEMEDIAMETADATA_P_4_H
+#define QDECLARATIVEMEDIAMETADATA_P_4_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of other Qt classes.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <qmetadatareadercontrol.h>
+
+#include <QtQml/qqml.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QDeclarativeMediaMetaData_4 : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QVariant title READ title NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant subTitle READ subTitle NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant author READ author NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant comment READ comment NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant description READ description NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant category READ category NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant genre READ genre NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant year READ year NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant date READ date NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant userRating READ userRating NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant keywords READ keywords NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant language READ language NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant publisher READ publisher NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant copyright READ copyright NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant parentalRating READ parentalRating NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant ratingOrganization READ ratingOrganization NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant size READ size NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant mediaType READ mediaType NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant duration READ duration NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant audioBitRate READ audioBitRate NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant audioCodec READ audioCodec NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant averageLevel READ averageLevel NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant channelCount READ channelCount NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant peakValue READ peakValue NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant sampleRate READ sampleRate NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant albumTitle READ albumTitle NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant albumArtist READ albumArtist NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant contributingArtist READ contributingArtist NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant composer READ composer NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant conductor READ conductor NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant lyrics READ lyrics NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant mood READ mood NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant trackNumber READ trackNumber NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant trackCount READ trackCount NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant coverArtUrlSmall READ coverArtUrlSmall NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant coverArtUrlLarge READ coverArtUrlLarge NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant resolution READ resolution NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant pixelAspectRatio READ pixelAspectRatio NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant videoFrameRate READ videoFrameRate NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant videoBitRate READ videoBitRate NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant videoCodec READ videoCodec NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant posterUrl READ posterUrl NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant chapterNumber READ chapterNumber NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant director READ director NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant leadPerformer READ leadPerformer NOTIFY metaDataChanged)
+    Q_PROPERTY(QVariant writer READ writer NOTIFY metaDataChanged)
+public:
+    QDeclarativeMediaMetaData_4(QMetaDataReaderControl *control, QObject *parent = 0)
+        : QObject(parent)
+        , m_control(control)
+    {
+    }
+
+    QVariant title() const { return m_control->metaData(QtMultimedia::MetaData::Title); }
+    QVariant subTitle() const { return m_control->metaData(QtMultimedia::MetaData::SubTitle); }
+    QVariant author() const { return m_control->metaData(QtMultimedia::MetaData::Author); }
+    QVariant comment() const { return m_control->metaData(QtMultimedia::MetaData::Comment); }
+    QVariant description() const { return m_control->metaData(QtMultimedia::MetaData::Description); }
+    QVariant category() const { return m_control->metaData(QtMultimedia::MetaData::Category); }
+    QVariant genre() const { return m_control->metaData(QtMultimedia::MetaData::Genre); }
+    QVariant year() const { return m_control->metaData(QtMultimedia::MetaData::Year); }
+    QVariant date() const { return m_control->metaData(QtMultimedia::MetaData::Date); }
+    QVariant userRating() const { return m_control->metaData(QtMultimedia::MetaData::UserRating); }
+    QVariant keywords() const { return m_control->metaData(QtMultimedia::MetaData::Keywords); }
+    QVariant language() const { return m_control->metaData(QtMultimedia::MetaData::Language); }
+    QVariant publisher() const { return m_control->metaData(QtMultimedia::MetaData::Publisher); }
+    QVariant copyright() const { return m_control->metaData(QtMultimedia::MetaData::Copyright); }
+    QVariant parentalRating() const { return m_control->metaData(QtMultimedia::MetaData::ParentalRating); }
+    QVariant ratingOrganization() const {
+        return m_control->metaData(QtMultimedia::MetaData::RatingOrganization); }
+    QVariant size() const { return m_control->metaData(QtMultimedia::MetaData::Size); }
+    QVariant mediaType() const { return m_control->metaData(QtMultimedia::MetaData::MediaType); }
+    QVariant duration() const { return m_control->metaData(QtMultimedia::MetaData::Duration); }
+    QVariant audioBitRate() const { return m_control->metaData(QtMultimedia::MetaData::AudioBitRate); }
+    QVariant audioCodec() const { return m_control->metaData(QtMultimedia::MetaData::AudioCodec); }
+    QVariant averageLevel() const { return m_control->metaData(QtMultimedia::MetaData::AverageLevel); }
+    QVariant channelCount() const { return m_control->metaData(QtMultimedia::MetaData::ChannelCount); }
+    QVariant peakValue() const { return m_control->metaData(QtMultimedia::MetaData::PeakValue); }
+    QVariant sampleRate() const { return m_control->metaData(QtMultimedia::MetaData::SampleRate); }
+    QVariant albumTitle() const { return m_control->metaData(QtMultimedia::MetaData::AlbumTitle); }
+    QVariant albumArtist() const { return m_control->metaData(QtMultimedia::MetaData::AlbumArtist); }
+    QVariant contributingArtist() const {
+        return m_control->metaData(QtMultimedia::MetaData::ContributingArtist); }
+    QVariant composer() const { return m_control->metaData(QtMultimedia::MetaData::Composer); }
+    QVariant conductor() const { return m_control->metaData(QtMultimedia::MetaData::Conductor); }
+    QVariant lyrics() const { return m_control->metaData(QtMultimedia::MetaData::Lyrics); }
+    QVariant mood() const { return m_control->metaData(QtMultimedia::MetaData::Mood); }
+    QVariant trackNumber() const { return m_control->metaData(QtMultimedia::MetaData::TrackNumber); }
+    QVariant trackCount() const { return m_control->metaData(QtMultimedia::MetaData::TrackCount); }
+    QVariant coverArtUrlSmall() const {
+        return m_control->metaData(QtMultimedia::MetaData::CoverArtUrlSmall); }
+    QVariant coverArtUrlLarge() const {
+        return m_control->metaData(QtMultimedia::MetaData::CoverArtUrlLarge); }
+    QVariant resolution() const { return m_control->metaData(QtMultimedia::MetaData::Resolution); }
+    QVariant pixelAspectRatio() const {
+        return m_control->metaData(QtMultimedia::MetaData::PixelAspectRatio); }
+    QVariant videoFrameRate() const { return m_control->metaData(QtMultimedia::MetaData::VideoFrameRate); }
+    QVariant videoBitRate() const { return m_control->metaData(QtMultimedia::MetaData::VideoBitRate); }
+    QVariant videoCodec() const { return m_control->metaData(QtMultimedia::MetaData::VideoCodec); }
+    QVariant posterUrl() const { return m_control->metaData(QtMultimedia::MetaData::PosterUrl); }
+    QVariant chapterNumber() const { return m_control->metaData(QtMultimedia::MetaData::ChapterNumber); }
+    QVariant director() const { return m_control->metaData(QtMultimedia::MetaData::Director); }
+    QVariant leadPerformer() const { return m_control->metaData(QtMultimedia::MetaData::LeadPerformer); }
+    QVariant writer() const { return m_control->metaData(QtMultimedia::MetaData::Writer); }
+
+Q_SIGNALS:
+    void metaDataChanged();
+
+private:
+    QMetaDataReaderControl *m_control;
+};
+
+QT_END_NAMESPACE
+
+QML_DECLARE_TYPE(QT_PREPEND_NAMESPACE(QDeclarativeMediaMetaData_4))
+
+QT_END_HEADER
+
+#endif // QDECLARATIVEMEDIAMETADATA_P_4_H

tests/auto/unit/qdeclarativeaudio/tst_qdeclarativeaudio.cpp

@@ -617,18 +617,18 @@ void tst_QDeclarativeAudio::position()
     QCOMPARE(spy.count(), 1);
 
     audio.setPosition(-5403);
-    QCOMPARE(audio.position(), -5403);
+    QCOMPARE(audio.position(), 0);
-    QCOMPARE(provider.playerControl()->position(), qint64(-5403));
+    QCOMPARE(provider.playerControl()->position(), qint64(0));
     QCOMPARE(spy.count(), 2);
 
     audio.setPosition(-5403);
-    QCOMPARE(audio.position(), -5403);
+    QCOMPARE(audio.position(), 0);
-    QCOMPARE(provider.playerControl()->position(), qint64(-5403));
+    QCOMPARE(provider.playerControl()->position(), qint64(0));
     QCOMPARE(spy.count(), 2);
 
     // Check the signal change signal is emitted if the change originates from the media service.
-    provider.playerControl()->setPosition(0);
+    provider.playerControl()->setPosition(450);
-    QCOMPARE(audio.position(), 0);
+    QCOMPARE(audio.position(), 450);
     QCOMPARE(spy.count(), 3);
 
     connect(&audio, SIGNAL(positionChanged()), &QTestEventLoop::instance(), SLOT(exitLoop()));
@@ -691,7 +691,7 @@ void tst_QDeclarativeAudio::muted()
     audio.setMuted(false);
     QCOMPARE(audio.isMuted(), false);
     QCOMPARE(provider.playerControl()->isMuted(), false);
-    QCOMPARE(spy.count(), 3);
+    QCOMPARE(spy.count(), 2);
 }
 
 void tst_QDeclarativeAudio::bufferProgress()

tests/auto/unit/qdeclarativeaudio_4/qdeclarativeaudio_4.pro

@@ -7,7 +7,7 @@ CONFIG += no_private_qt_headers_warning
 HEADERS += \
         $$QT.multimedia.sources/../imports/multimedia/qdeclarativeaudio_p_4.h \
         $$QT.multimedia.sources/../imports/multimedia/qdeclarativemediabase_p_4.h \
-        $$QT.multimedia.sources/../imports/multimedia/qdeclarativemediametadata_p.h
+        $$QT.multimedia.sources/../imports/multimedia/qdeclarativemediametadata_p_4.h
 
 SOURCES += \
         tst_qdeclarativeaudio_4.cpp \

tests/auto/unit/qdeclarativeaudio_4/tst_qdeclarativeaudio_4.cpp

@@ -44,7 +44,7 @@
 #include <QtTest/QtTest>
 
 #include "qdeclarativeaudio_p_4.h"
-#include "qdeclarativemediametadata_p.h"
+#include "qdeclarativemediametadata_p_4.h"
 
 #include <qmediaplayercontrol.h>
 #include <qmediaservice.h>