Implemented buffer status notifications in Phonon MMF backend

When clips are buffering (either at the start of playback, or
during playback, when buffer levels drop due to e.g. CPU, file system
or network load), the backend receives notification from the MMF.

While buffering is ongoing, the backend periodically queries the
filling status and emits a signal.

Task-number: QTBUG-4660
Reviewed-by: Frans Englich

9 files changed, 162 insertions, 62 deletions

diff --git a/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp b/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
index 260d8e6..6e7f458 100644
--- a/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
+++ b/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
@@ -36,6 +36,7 @@ using namespace Phonon::MMF;
 //-----------------------------------------------------------------------------
 
 const int       NullMaxVolume = -1;
+const int       BufferStatusTimerInterval = 100; // ms
 
 
 //-----------------------------------------------------------------------------
@@ -44,19 +45,23 @@ const int       NullMaxVolume = -1;
 
 MMF::AbstractMediaPlayer::AbstractMediaPlayer() :
             m_playPending(false)
-        ,   m_tickTimer(new QTimer(this))
+        ,   m_positionTimer(new QTimer(this))
+        ,   m_bufferStatusTimer(new QTimer(this))
         ,   m_mmfMaxVolume(NullMaxVolume)
 {
-    connect(m_tickTimer.data(), SIGNAL(timeout()), this, SLOT(tick()));
+    connect(m_positionTimer.data(), SIGNAL(timeout()), this, SLOT(positionTick()));
+    connect(m_bufferStatusTimer.data(), SIGNAL(timeout()), this, SLOT(bufferStatusTick()));
 }
 
 MMF::AbstractMediaPlayer::AbstractMediaPlayer(const AbstractPlayer& player) :
         AbstractPlayer(player)
         ,   m_playPending(false)
-        ,   m_tickTimer(new QTimer(this))
+        ,   m_positionTimer(new QTimer(this))
+        ,   m_bufferStatusTimer(new QTimer(this))
         ,   m_mmfMaxVolume(NullMaxVolume)
 {
-    connect(m_tickTimer.data(), SIGNAL(timeout()), this, SLOT(tick()));
+    connect(m_positionTimer.data(), SIGNAL(timeout()), this, SLOT(positionTick()));
+    connect(m_bufferStatusTimer.data(), SIGNAL(timeout()), this, SLOT(bufferStatusTick()));
 }
 
 //-----------------------------------------------------------------------------
@@ -80,7 +85,7 @@ void MMF::AbstractMediaPlayer::play()
     case StoppedState:
     case PausedState:
         doPlay();
-        startTickTimer();
+        startPositionTimer();
         changeState(PlayingState);
         break;
 
@@ -104,7 +109,7 @@ void MMF::AbstractMediaPlayer::pause()
     TRACE_ENTRY("state %d", privateState());
 
     m_playPending = false;
-    stopTickTimer();
+    stopTimers();
 
     switch (privateState()) {
     case GroundState:
@@ -136,7 +141,7 @@ void MMF::AbstractMediaPlayer::stop()
     TRACE_ENTRY("state %d", privateState());
 
     m_playPending = false;
-    stopTickTimer();
+    stopTimers();
 
     switch (privateState()) {
     case GroundState:
@@ -174,14 +179,13 @@ void MMF::AbstractMediaPlayer::seek(qint64 ms)
     case PlayingState:
     case LoadingState:
     {
-        const bool tickTimerWasRunning = m_tickTimer->isActive();
-        stopTickTimer();
+        const bool positionTimerWasRunning = m_positionTimer->isActive();
+        stopPositionTimer();
 
         doSeek(ms);
 
-        if (tickTimerWasRunning) {
-            startTickTimer();
-        }
+        if (positionTimerWasRunning)
+            startPositionTimer();
         break;
     }
     case BufferingState:
@@ -204,7 +208,7 @@ void MMF::AbstractMediaPlayer::doSetTickInterval(qint32 interval)
     TRACE_CONTEXT(AbstractMediaPlayer::doSetTickInterval, EAudioApi);
     TRACE_ENTRY("state %d m_interval %d interval %d", privateState(), tickInterval(), interval);
 
-    m_tickTimer->setInterval(interval);
+    m_positionTimer->setInterval(interval);
 
     TRACE_EXIT_0();
 }
@@ -307,6 +311,35 @@ void MMF::AbstractMediaPlayer::volumeChanged(qreal volume)
     TRACE_EXIT_0();
 }
 
+//-----------------------------------------------------------------------------
+// Private functions
+//-----------------------------------------------------------------------------
+
+void MMF::AbstractMediaPlayer::startPositionTimer()
+{
+    m_positionTimer->start(tickInterval());
+}
+
+void MMF::AbstractMediaPlayer::stopPositionTimer()
+{
+    m_positionTimer->stop();
+}
+
+void MMF::AbstractMediaPlayer::startBufferStatusTimer()
+{
+    m_bufferStatusTimer->start(BufferStatusTimerInterval);
+}
+
+void MMF::AbstractMediaPlayer::stopBufferStatusTimer()
+{
+    m_bufferStatusTimer->stop();
+}
+
+void MMF::AbstractMediaPlayer::stopTimers()
+{
+    stopPositionTimer();
+    stopBufferStatusTimer();
+}
 
 void MMF::AbstractMediaPlayer::doVolumeChanged()
 {
@@ -342,14 +375,19 @@ void MMF::AbstractMediaPlayer::doVolumeChanged()
 // Protected functions
 //-----------------------------------------------------------------------------
 
-void MMF::AbstractMediaPlayer::startTickTimer()
+void MMF::AbstractMediaPlayer::bufferingStarted()
 {
-    m_tickTimer->start(tickInterval());
+    m_stateBeforeBuffering = privateState();
+    changeState(BufferingState);
+    bufferStatusTick();
+    startBufferStatusTimer();
 }
 
-void MMF::AbstractMediaPlayer::stopTickTimer()
+void MMF::AbstractMediaPlayer::bufferingComplete()
 {
-    m_tickTimer->stop();
+    stopBufferStatusTimer();
+    emit MMF::AbstractPlayer::bufferStatus(100);
+    changeState(m_stateBeforeBuffering);
 }
 
 void MMF::AbstractMediaPlayer::maxVolumeChanged(int mmfMaxVolume)
@@ -367,12 +405,16 @@ qint64 MMF::AbstractMediaPlayer::toMilliSeconds(const TTimeIntervalMicroSeconds
 // Slots
 //-----------------------------------------------------------------------------
 
-void MMF::AbstractMediaPlayer::tick()
+void MMF::AbstractMediaPlayer::positionTick()
 {
-    // For the MWC compiler, we need to qualify the base class.
     emit MMF::AbstractPlayer::tick(currentTime());
 }
 
+void MMF::AbstractMediaPlayer::bufferStatusTick()
+{
+    emit MMF::AbstractPlayer::bufferStatus(bufferStatus());
+}
+
 void MMF::AbstractMediaPlayer::changeState(PrivateState newState)
 {
     TRACE_CONTEXT(AbstractMediaPlayer::changeState, EAudioInternal);
diff --git a/src/3rdparty/phonon/mmf/abstractmediaplayer.h b/src/3rdparty/phonon/mmf/abstractmediaplayer.h
index 0432b07..7c11ec7 100644
--- a/src/3rdparty/phonon/mmf/abstractmediaplayer.h
+++ b/src/3rdparty/phonon/mmf/abstractmediaplayer.h
@@ -69,6 +69,7 @@ protected:
     virtual int setDeviceVolume(int mmfVolume) = 0;
     virtual int openFile(RFile& file) = 0;
     virtual int openUrl(const QString& url) = 0;
+    virtual int bufferStatus() const = 0;
     virtual void close() = 0;
     virtual void changeState(PrivateState newState);
 
@@ -77,21 +78,22 @@ protected:
     virtual QPair<QString, QString> metaDataEntry(int index) const = 0;
 
 protected:
-    bool tickTimerRunning() const;
-    void startTickTimer();
-    void stopTickTimer();
+    void bufferingStarted();
+    void bufferingComplete();
     void maxVolumeChanged(int maxVolume);
-
     static qint64 toMilliSeconds(const TTimeIntervalMicroSeconds &);
 
 private:
+    void startPositionTimer();
+    void stopPositionTimer();
+    void startBufferStatusTimer();
+    void stopBufferStatusTimer();
+    void stopTimers();
     void doVolumeChanged();
 
 private Q_SLOTS:
-    /**
-     * Receives signal from m_tickTimer
-     */
-    void tick();
+    void positionTick();
+    void bufferStatusTick();
 
 private:
     /**
@@ -101,7 +103,10 @@ private:
      */
     bool                        m_playPending;
 
-    QScopedPointer<QTimer>      m_tickTimer;
+    QScopedPointer<QTimer>      m_positionTimer;
+
+    QScopedPointer<QTimer>      m_bufferStatusTimer;
+    PrivateState                m_stateBeforeBuffering;
 
     int                         m_mmfMaxVolume;
 
diff --git a/src/3rdparty/phonon/mmf/abstractplayer.h b/src/3rdparty/phonon/mmf/abstractplayer.h
index cd15baf..5aaae3c 100644
--- a/src/3rdparty/phonon/mmf/abstractplayer.h
+++ b/src/3rdparty/phonon/mmf/abstractplayer.h
@@ -110,6 +110,7 @@ Q_SIGNALS:
     void totalTimeChanged(qint64 length);
     void finished();
     void tick(qint64 time);
+    void bufferStatus(int percentFilled);
     void stateChanged(Phonon::State oldState,
                       Phonon::State newState);
     void metaDataChanged(const QMultiMap<QString, QString>& metaData);
diff --git a/src/3rdparty/phonon/mmf/audioplayer.cpp b/src/3rdparty/phonon/mmf/audioplayer.cpp
index 2d618b8..0967a27 100644
--- a/src/3rdparty/phonon/mmf/audioplayer.cpp
+++ b/src/3rdparty/phonon/mmf/audioplayer.cpp
@@ -53,6 +53,7 @@ void MMF::AudioPlayer::construct()
     CPlayerType *player = 0;
     QT_TRAP_THROWING(player = CPlayerType::NewL(*this, 0, EMdaPriorityPreferenceNone));
     m_player.reset(player);
+    m_player->RegisterForAudioLoadingNotification(*this);
 
     TRACE_EXIT_0();
 }
@@ -135,6 +136,13 @@ int MMF::AudioPlayer::openUrl(const QString& /*url*/)
     return 0;
 }
 
+int MMF::AudioPlayer::bufferStatus() const
+{
+    int result = 0;
+    TRAP_IGNORE(m_player->GetAudioLoadingProgressL(result));
+    return result;
+}
+
 void MMF::AudioPlayer::close()
 {
     m_player->Close();
@@ -211,8 +219,6 @@ void MMF::AudioPlayer::MapcPlayComplete(TInt aError)
     TRACE_CONTEXT(AudioPlayer::MapcPlayComplete, EAudioInternal);
     TRACE_ENTRY("state %d error %d", state(), aError);
 
-    stopTickTimer();
-
     if (KErrNone == aError) {
         changeState(StoppedState);
         // TODO: move on to m_nextSource
@@ -260,6 +266,21 @@ void MMF::AudioPlayer::MaloLoadingComplete()
 
 
 //-----------------------------------------------------------------------------
+// MAudioLoadingObserver callbacks
+//-----------------------------------------------------------------------------
+
+void MMF::AudioPlayer::MaloLoadingStarted()
+{
+    bufferingStarted();
+}
+
+void MMF::AudioPlayer::MaloLoadingComplete()
+{
+    bufferingComplete();
+}
+
+
+//-----------------------------------------------------------------------------
 // Private functions
 //-----------------------------------------------------------------------------
 
diff --git a/src/3rdparty/phonon/mmf/audioplayer.h b/src/3rdparty/phonon/mmf/audioplayer.h
index 4674afc..5c7cfc1 100644
--- a/src/3rdparty/phonon/mmf/audioplayer.h
+++ b/src/3rdparty/phonon/mmf/audioplayer.h
@@ -45,9 +45,7 @@ namespace MMF
  */
 class AudioPlayer   :   public AbstractMediaPlayer
                     ,   public MPlayerObserverType    // typedef
-#ifdef QT_PHONON_MMF_AUDIO_DRM
                     ,   public MAudioLoadingObserver
-#endif
 {
     Q_OBJECT
 
@@ -64,6 +62,7 @@ public:
     virtual int setDeviceVolume(int mmfVolume);
     virtual int openFile(RFile& file);
     virtual int openUrl(const QString& url);
+    virtual int bufferStatus() const;
     virtual void close();
 
     // MediaObjectInterface
@@ -71,15 +70,24 @@ public:
     virtual qint64 currentTime() const;
     virtual qint64 totalTime() const;
 
+    // AbstractMediaPlayer
+    virtual int numberOfMetaDataEntries() const;
+    virtual QPair<QString, QString> metaDataEntry(int index) const;
+
+    /**
+     * This class owns the pointer.
+     */
+    CPlayerType *player() const;
+
+private:
+    void construct();
+
+private:
 #ifdef QT_PHONON_MMF_AUDIO_DRM
     // MDrmAudioPlayerCallback
     virtual void MdapcInitComplete(TInt aError,
                                    const TTimeIntervalMicroSeconds &aDuration);
     virtual void MdapcPlayComplete(TInt aError);
-
-    // MAudioLoadingObserver
-    virtual void MaloLoadingStarted();
-    virtual void MaloLoadingComplete();
 #else
     // MMdaAudioPlayerCallback
     virtual void MapcInitComplete(TInt aError,
@@ -87,17 +95,9 @@ public:
     virtual void MapcPlayComplete(TInt aError);
 #endif
 
-    /**
-     * This class owns the pointer.
-     */
-    CPlayerType *player() const;
-
-private:
-    void construct();
-
-    // AbstractMediaPlayer
-    virtual int numberOfMetaDataEntries() const;
-    virtual QPair<QString, QString> metaDataEntry(int index) const;
+    // MAudioLoadingObserver
+    virtual void MaloLoadingStarted();
+    virtual void MaloLoadingComplete();
 
 private:
     /**
diff --git a/src/3rdparty/phonon/mmf/mediaobject.cpp b/src/3rdparty/phonon/mmf/mediaobject.cpp
index ca3e837..bf1f268 100644
--- a/src/3rdparty/phonon/mmf/mediaobject.cpp
+++ b/src/3rdparty/phonon/mmf/mediaobject.cpp
@@ -321,6 +321,7 @@ void MMF::MediaObject::createPlayer(const MediaSource &source)
     connect(m_player.data(), SIGNAL(stateChanged(Phonon::State,Phonon::State)), SIGNAL(stateChanged(Phonon::State,Phonon::State)));
     connect(m_player.data(), SIGNAL(finished()), SIGNAL(finished()));
     connect(m_player.data(), SIGNAL(tick(qint64)), SIGNAL(tick(qint64)));
+    connect(m_player.data(), SIGNAL(bufferStatus(int)), SIGNAL(bufferStatus(int)));
     connect(m_player.data(), SIGNAL(metaDataChanged(QMultiMap<QString,QString>)), SIGNAL(metaDataChanged(QMultiMap<QString,QString>)));
 
     // We need to call setError() after doing the connects, otherwise the
diff --git a/src/3rdparty/phonon/mmf/mediaobject.h b/src/3rdparty/phonon/mmf/mediaobject.h
index d6f4c7b..07baad0 100644
--- a/src/3rdparty/phonon/mmf/mediaobject.h
+++ b/src/3rdparty/phonon/mmf/mediaobject.h
@@ -92,7 +92,6 @@ Q_SIGNALS:
     void totalTimeChanged(qint64 length);
     void hasVideoChanged(bool hasVideo);
     void seekableChanged(bool seekable);
-    // TODO: emit bufferStatus from MediaObject
     void bufferStatus(int);
     // TODO: emit aboutToFinish from MediaObject
     void aboutToFinish();
diff --git a/src/3rdparty/phonon/mmf/mmf_videoplayer.cpp b/src/3rdparty/phonon/mmf/mmf_videoplayer.cpp
index 62bbdef..4a70d58 100644
--- a/src/3rdparty/phonon/mmf/mmf_videoplayer.cpp
+++ b/src/3rdparty/phonon/mmf/mmf_videoplayer.cpp
@@ -93,6 +93,8 @@ void MMF::VideoPlayer::construct()
     // CVideoPlayerUtility::NewL starts DSA
     m_dsaActive = true;
 
+    m_player->RegisterForVideoLoadingNotification(*this);
+
     TRACE_EXIT_0();
 }
 
@@ -178,6 +180,13 @@ int MMF::VideoPlayer::openUrl(const QString& url)
     return err;
 }
 
+int MMF::VideoPlayer::bufferStatus() const
+{
+    int result = 0;
+    TRAP_IGNORE(m_player->GetVideoLoadingProgressL(result));
+    return result;
+}
+
 void MMF::VideoPlayer::close()
 {
     m_player->Close();
@@ -292,7 +301,8 @@ void MMF::VideoPlayer::MvpuoPlayComplete(TInt aError)
     TRACE_CONTEXT(VideoPlayer::MvpuoPlayComplete, EVideoApi)
     TRACE_ENTRY("state %d error %d", state(), aError);
 
-    Q_UNUSED(aError);   // suppress warnings in release builds
+    // TODO: handle aError
+    Q_UNUSED(aError);
     changeState(StoppedState);
 
     TRACE_EXIT_0();
@@ -310,6 +320,21 @@ void MMF::VideoPlayer::MvpuoEvent(const TMMFEvent &aEvent)
 
 
 //-----------------------------------------------------------------------------
+// MVideoLoadingObserver callbacks
+//-----------------------------------------------------------------------------
+
+void MMF::VideoPlayer::MvloLoadingStarted()
+{
+    bufferingStarted();
+}
+
+void MMF::VideoPlayer::MvloLoadingComplete()
+{
+    bufferingComplete();
+}
+
+
+//-----------------------------------------------------------------------------
 // Video window updates
 //-----------------------------------------------------------------------------
 
diff --git a/src/3rdparty/phonon/mmf/mmf_videoplayer.h b/src/3rdparty/phonon/mmf/mmf_videoplayer.h
index 7c42991..3ece19c 100644
--- a/src/3rdparty/phonon/mmf/mmf_videoplayer.h
+++ b/src/3rdparty/phonon/mmf/mmf_videoplayer.h
@@ -39,6 +39,7 @@ namespace MMF
  */
 class VideoPlayer : public AbstractMediaPlayer
                   , public MVideoPlayerUtilityObserver
+                  , public MVideoLoadingObserver
 {
     Q_OBJECT
 
@@ -55,6 +56,7 @@ public:
     virtual int setDeviceVolume(int mmfVolume);
     virtual int openFile(RFile& file);
     virtual int openUrl(const QString& url);
+    virtual int bufferStatus() const;
     virtual void close();
 
     // MediaObjectInterface
@@ -62,12 +64,12 @@ public:
     virtual qint64 currentTime() const;
     virtual qint64 totalTime() const;
 
-    // MVideoPlayerUtilityObserver
-    virtual void MvpuoOpenComplete(TInt aError);
-    virtual void MvpuoPrepareComplete(TInt aError);
-    virtual void MvpuoFrameReady(CFbsBitmap &aFrame, TInt aError);
-    virtual void MvpuoPlayComplete(TInt aError);
-    virtual void MvpuoEvent(const TMMFEvent &aEvent);
+    // AbstractPlayer
+    virtual void videoOutputChanged();
+
+    // AbstractMediaPlayer
+    virtual int numberOfMetaDataEntries() const;
+    virtual QPair<QString, QString> metaDataEntry(int index) const;
 
 public Q_SLOTS:
     void videoWindowChanged();
@@ -81,12 +83,8 @@ private:
 
     void doPrepareCompleteL(TInt aError);
 
-    // AbstractPlayer
-    virtual void videoOutputChanged();
-
     void getVideoWindow();
     void initVideoOutput();
-
     void updateVideoRect();
 
     void applyPendingChanges();
@@ -95,9 +93,17 @@ private:
     void startDirectScreenAccess();
     bool stopDirectScreenAccess();
 
-    // AbstractMediaPlayer
-    virtual int numberOfMetaDataEntries() const;
-    virtual QPair<QString, QString> metaDataEntry(int index) const;
+private:
+    // MVideoPlayerUtilityObserver
+    virtual void MvpuoOpenComplete(TInt aError);
+    virtual void MvpuoPrepareComplete(TInt aError);
+    virtual void MvpuoFrameReady(CFbsBitmap &aFrame, TInt aError);
+    virtual void MvpuoPlayComplete(TInt aError);
+    virtual void MvpuoEvent(const TMMFEvent &aEvent);
+
+    // MVideoLoadingObserver
+    virtual void MvloLoadingStarted();
+    virtual void MvloLoadingComplete();
 
 private:
     QScopedPointer<CVideoPlayerUtility> m_player;