1 files changed, 67 insertions, 98 deletions

diff --git a/src/imports/multimedia/qdeclarativemediabase.cpp b/src/imports/multimedia/qdeclarativemediabase.cpp
index 593afea36..a1f80f2b4 100644
--- a/src/imports/multimedia/qdeclarativemediabase.cpp
+++ b/src/imports/multimedia/qdeclarativemediabase.cpp
@@ -130,7 +130,7 @@ protected:
         if (event->timerId() == m_timer.timerId()) {
             event->accept();
 
-            if (m_media->m_playing && !m_media->m_paused)
+            if (m_media->m_playbackState == QMediaPlayer::PlayingState)
                 emit m_media->positionChanged();
             if (m_media->m_status == QMediaPlayer::BufferingMedia || QMediaPlayer::StalledMedia)
                 emit m_media->bufferProgressChanged();
@@ -150,63 +150,40 @@ void QDeclarativeMediaBase::_q_statusChanged()
         m_runningCount -= 1;
         m_playerControl->play();
     }
-
     const QMediaPlayer::MediaStatus oldStatus = m_status;
-    const bool wasPlaying = m_playing;
-    const bool wasPaused = m_paused;
+    const QMediaPlayer::State lastPlaybackState = m_playbackState;
 
     const QMediaPlayer::State state = m_playerControl->state();
 
-    m_status = m_playerControl->mediaStatus();
-
-    if (m_complete)
-        m_playing = state != QMediaPlayer::StoppedState;
+    m_playbackState = state;
 
-    if (state == QMediaPlayer::PausedState)
-        m_paused = true;
-    else if (state == QMediaPlayer::PlayingState)
-        m_paused = false;
+    m_status = m_playerControl->mediaStatus();
 
     if (m_status != oldStatus)
         emit statusChanged();
 
-    switch (state) {
-    case QMediaPlayer::StoppedState:
-        if (wasPlaying) {
-            emit stopped();
+    if (lastPlaybackState != state) {
 
-            if (!m_playing)
-                emit playingChanged();
-        }
-        break;
-    case QMediaPlayer::PausedState:
-        if (!wasPlaying) {
-            emit started();
-            if (m_playing)
-                emit playingChanged();
-        }
-        if ((!wasPaused || !wasPlaying) && m_paused)
+        if (lastPlaybackState == QMediaPlayer::StoppedState)
+            m_runningCount = m_loopCount - 1;
+
+        switch (state) {
+        case QMediaPlayer::StoppedState:
+            emit stopped();
+            break;
+        case QMediaPlayer::PausedState:
             emit paused();
-        if (!wasPaused && m_paused)
-            emit pausedChanged();
-
-        break;
-
-    case QMediaPlayer::PlayingState:
-        if (wasPaused && wasPlaying)
-            emit resumed();
-        else
-            emit started();
-
-        if (wasPaused && !m_paused)
-            emit pausedChanged();
-        if (!wasPlaying && m_playing)
-            emit playingChanged();
-        break;
+            break;
+        case QMediaPlayer::PlayingState:
+            emit playing();
+            break;
+        }
+
+        emit playbackStateChanged();
     }
 
     // Check
-    if ((m_playing && !m_paused)
+    if ((state == QMediaPlayer::PlayingState)
             || m_status == QMediaPlayer::BufferingMedia
             || m_status == QMediaPlayer::StalledMedia) {
         m_animation->start();
@@ -217,8 +194,7 @@ void QDeclarativeMediaBase::_q_statusChanged()
 }
 
 QDeclarativeMediaBase::QDeclarativeMediaBase()
-    : m_paused(false)
-    , m_playing(false)
+    : m_autoPlay(false)
     , m_autoLoad(true)
     , m_loaded(false)
     , m_muted(false)
@@ -235,6 +211,7 @@ QDeclarativeMediaBase::QDeclarativeMediaBase()
     , m_mediaProvider(0)
     , m_metaDataControl(0)
     , m_animation(0)
+    , m_playbackState(QMediaPlayer::StoppedState)
     , m_status(QMediaPlayer::NoMedia)
     , m_error(QMediaPlayer::ServiceMissingError)
 {
@@ -319,21 +296,18 @@ void QDeclarativeMediaBase::componentComplete()
     if (!qFuzzyCompare(m_playbackRate, qreal(1.0)))
         m_playerControl->setPlaybackRate(m_playbackRate);
 
-    if (!m_source.isEmpty() && (m_autoLoad || m_playing)) // Override autoLoad if playing set
+    if (!m_source.isEmpty() && (m_autoLoad || m_autoPlay)) {
         m_playerControl->setMedia(m_source, 0);
-
-    m_complete = true;
-
-    if (m_playing) {
+        m_loaded = true;
         if (m_position > 0)
             m_playerControl->setPosition(m_position);
+    }
 
-        if (m_source.isEmpty()) {
-            m_playing = false;
+    m_complete = true;
 
-            emit playingChanged();
-        } else if (m_paused) {
-            m_playerControl->pause();
+    if (m_autoPlay) {
+        if (m_source.isEmpty()) {
+            m_playerControl->stop();
         } else {
             m_playerControl->play();
         }
@@ -347,6 +321,21 @@ QUrl QDeclarativeMediaBase::source() const
     return m_source;
 }
 
+bool QDeclarativeMediaBase::autoPlay() const
+{
+    return m_autoPlay;
+}
+
+void QDeclarativeMediaBase::setAutoPlay(bool autoplay)
+{
+    if (m_autoPlay == autoplay)
+        return;
+
+    m_autoPlay = autoplay;
+    emit autoPlayChanged();
+}
+
+
 void QDeclarativeMediaBase::setSource(const QUrl &url)
 {
     if (url == m_source)
@@ -354,7 +343,7 @@ void QDeclarativeMediaBase::setSource(const QUrl &url)
 
     m_source = url;
     m_loaded = false;
-    if (m_complete && (m_autoLoad || url.isEmpty())) {
+    if (m_complete && (m_autoLoad || url.isEmpty() || m_autoPlay)) {
         if (m_error != QMediaPlayer::ServiceMissingError && m_error != QMediaPlayer::NoError) {
             m_error = QMediaPlayer::NoError;
             m_errorString = QString();
@@ -367,6 +356,8 @@ void QDeclarativeMediaBase::setSource(const QUrl &url)
     }
     else
         emit sourceChanged();
+
+    if (m_autoPlay) m_playerControl->play();
 }
 
 bool QDeclarativeMediaBase::isAutoLoad() const
@@ -399,68 +390,46 @@ void QDeclarativeMediaBase::setLoopCount(int loopCount)
         return;
     }
     m_loopCount = loopCount;
+    m_runningCount = loopCount - 1;
     emit loopCountChanged();
 }
 
-bool QDeclarativeMediaBase::isPlaying() const
-{
-    return m_playing;
-}
-
-void QDeclarativeMediaBase::setPlaying(bool playing)
+void QDeclarativeMediaBase::setPlaybackState(QMediaPlayer::State playbackState)
 {
-    if (playing == m_playing)
+    if (m_playbackState == playbackState)
         return;
 
     if (m_complete) {
-        if (playing) {
-            if (!m_autoLoad && !m_loaded) {
+        switch (playbackState){
+        case (QMediaPlayer::PlayingState):
+            if (!m_loaded) {
                 m_playerControl->setMedia(m_source, 0);
                 m_playerControl->setPosition(m_position);
                 m_loaded = true;
             }
+            m_playerControl->play();
+            break;
 
-            m_runningCount = m_loopCount - 1;
+        case (QMediaPlayer::PausedState):
+            if (!m_loaded) {
+                m_playerControl->setMedia(m_source, 0);
+                m_playerControl->setPosition(m_position);
+                m_loaded = true;
+            }
+            m_playerControl->pause();
+            break;
 
-            if (!m_paused)
-                m_playerControl->play();
-            else
-                m_playerControl->pause();
-        } else {
+        case (QMediaPlayer::StoppedState):
             m_playerControl->stop();
         }
-    } else {
-        m_playing = playing;
-        emit playingChanged();
     }
 }
 
-bool QDeclarativeMediaBase::isPaused() const
+QMediaPlayer::State QDeclarativeMediaBase::playbackState() const
 {
-    return m_paused;
+    return m_playbackState;
 }
 
-void QDeclarativeMediaBase::setPaused(bool paused)
-{
-    if (m_paused == paused)
-        return;
-
-    if (m_complete && m_playing) {
-        if (!m_autoLoad && !m_loaded) {
-            m_playerControl->setMedia(m_source, 0);
-            m_playerControl->setPosition(m_position);
-            m_loaded = true;
-        }
-
-        if (!paused)
-            m_playerControl->play();
-        else
-            m_playerControl->pause();
-    } else {
-        m_paused = paused;
-        emit pausedChanged();
-    }
-}
 
 int QDeclarativeMediaBase::duration() const
 {