Changeset 846 for trunk/src/3rdparty/phonon/mmf

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/3rdparty/phonon/mmf/abstractaudioeffect.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/abstractaudioeffect.h (modified) (1 diff)
• src/3rdparty/phonon/mmf/abstractmediaplayer.cpp (modified) (16 diffs)
• src/3rdparty/phonon/mmf/abstractmediaplayer.h (modified) (9 diffs)
• src/3rdparty/phonon/mmf/abstractplayer.h (modified) (2 diffs)
• src/3rdparty/phonon/mmf/abstractvideooutput.cpp (modified) (2 diffs)
• src/3rdparty/phonon/mmf/abstractvideoplayer.cpp (modified) (14 diffs)
• src/3rdparty/phonon/mmf/abstractvideoplayer.h (modified) (2 diffs)
• src/3rdparty/phonon/mmf/audiooutput.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/audioplayer.cpp (modified) (7 diffs)
• src/3rdparty/phonon/mmf/audioplayer.h (modified) (1 diff)
• src/3rdparty/phonon/mmf/bassboost.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/download.cpp (copied) (copied from branches/vendor/nokia/qt/4.7.2/src/3rdparty/phonon/mmf/download.cpp )
• src/3rdparty/phonon/mmf/download.h (copied) (copied from branches/vendor/nokia/qt/4.7.2/src/3rdparty/phonon/mmf/download.h )
• src/3rdparty/phonon/mmf/dummyplayer.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/dummyplayer.h (modified) (1 diff)
• src/3rdparty/phonon/mmf/effectfactory.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/loudness.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/mediaobject.cpp (modified) (12 diffs)
• src/3rdparty/phonon/mmf/mediaobject.h (modified) (6 diffs)
• src/3rdparty/phonon/mmf/videoplayer_dsa.cpp (modified) (3 diffs)
• src/3rdparty/phonon/mmf/videoplayer_surface.cpp (modified) (5 diffs)
• src/3rdparty/phonon/mmf/videoplayer_surface.h (modified) (1 diff)
• src/3rdparty/phonon/mmf/videowidget.cpp (modified) (1 diff)

trunk/src/3rdparty/phonon/mmf/abstractaudioeffect.cpp

@@ -185 +185 @@
 {
     // Default implementation
+    Q_UNUSED(param)
+    Q_UNUSED(value)
     Q_ASSERT_X(false, Q_FUNC_INFO, "Effect has no parameters");
     return 0;

trunk/src/3rdparty/phonon/mmf/abstractaudioeffect.h

@@ -119 +119 @@
 // in the implementations of the backend effect nodes.
 
+#ifdef Q_CC_NOKIAX86
+#   pragma warn_illtokenpasting off
+#endif
+
 #define PHONON_MMF_DEFINE_EFFECT_FUNCTIONS(Effect)                      \
                                                                         \

trunk/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp

@@ -17 +17 @@
 */
 
+#include <QResource>
 #include <QUrl>
 
@@ -23 +24 @@
 #include "mediaobject.h"
 #include "utils.h"
+#include <cdbcols.h>
+#include <cdblen.h>
+#include <commdb.h>
 
 QT_BEGIN_NAMESPACE
@@ -51 +55 @@
         ,   m_pending(NothingPending)
         ,   m_positionTimer(new QTimer(this))
+        ,   m_position(0)
         ,   m_bufferStatusTimer(new QTimer(this))
         ,   m_mmfMaxVolume(NullMaxVolume)
         ,   m_prefinishMarkSent(false)
         ,   m_aboutToFinishSent(false)
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+        ,   m_download(0)
+        ,   m_downloadStalled(false)
+#endif
 {
     connect(m_positionTimer.data(), SIGNAL(timeout()), this, SLOT(positionTick()));
@@ -183 +192 @@
 
         doSeek(ms);
+        m_position = ms;
         resetMarksIfRewound();
 
@@ -207 +217 @@
 }
 
+qint64 MMF::AbstractMediaPlayer::currentTime() const
+{
+    return m_position;
+}
+
 void MMF::AbstractMediaPlayer::doSetTickInterval(qint32 interval)
 {
@@ -217 +232 @@
 }
 
-void MMF::AbstractMediaPlayer::open(const MediaSource &source, RFile& file)
-{
-    TRACE_CONTEXT(AbstractMediaPlayer::setFileSource, EAudioApi);
+void MMF::AbstractMediaPlayer::open()
+{
+    TRACE_CONTEXT(AbstractMediaPlayer::open, EAudioApi);
+    const MediaSource source = m_parent->source();
     TRACE_ENTRY("state %d source.type %d", privateState(), source.type());
 
@@ -230 +246 @@
     switch (source.type()) {
     case MediaSource::LocalFile: {
-        symbianErr = openFile(file);
+        RFile *const file = m_parent->file();
+        Q_ASSERT(file);
+        symbianErr = openFile(*file);
         if (KErrNone != symbianErr)
             errorMessage = tr("Error opening file");
@@ -238 +256 @@
     case MediaSource::Url: {
         const QUrl url(source.url());
-
         if (url.scheme() == QLatin1String("file")) {
-            symbianErr = openFile(file);
+            RFile *const file = m_parent->file();
+            Q_ASSERT(file);
+            symbianErr = openFile(*file);
             if (KErrNone != symbianErr)
                 errorMessage = tr("Error opening file");
-        } else {
-            symbianErr = openUrl(url.toString());
+        }
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+        else if (url.scheme() == QLatin1String("http")) {
+            Q_ASSERT(!m_download);
+            m_download = new Download(url, this);
+            connect(m_download, SIGNAL(lengthChanged(qint64)),
+                    this, SLOT(downloadLengthChanged(qint64)));
+            connect(m_download, SIGNAL(stateChanged(Download::State)),
+                    this, SLOT(downloadStateChanged(Download::State)));
+            int iap = m_parent->currentIAP();
+            TRACE("HTTP Url: Using IAP %d", iap);
+            m_download->start(iap);
+        }
+#endif
+        else {
+            int iap = m_parent->currentIAP();
+            TRACE("Using IAP %d", iap);
+            symbianErr = openUrl(url.toString(), iap);
             if (KErrNone != symbianErr)
                 errorMessage = tr("Error opening URL");
         }
 
+        break;
+    }
+
+    case MediaSource::Stream: {
+        QResource *const resource = m_parent->resource();
+        if (resource) {
+            m_buffer.Set(resource->data(), resource->size());
+            symbianErr = openDescriptor(m_buffer);
+            if (KErrNone != symbianErr)
+                errorMessage = tr("Error opening resource");
+        } else {
+            errorMessage = tr("Error opening source: resource not opened");
+        }
         break;
     }
@@ -271 +319 @@
 }
 
+void MMF::AbstractMediaPlayer::close()
+{
+    doClose();
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+    delete m_download;
+    m_download = 0;
+#endif
+    m_position = 0;
+}
+
 void MMF::AbstractMediaPlayer::volumeChanged(qreal volume)
 {
@@ -357 +415 @@
     stopBufferStatusTimer();
     emit MMF::AbstractPlayer::bufferStatus(100);
-    changeState(m_stateBeforeBuffering);
+    if (!progressiveDownloadStalled())
+        changeState(m_stateBeforeBuffering);
 }
 
@@ -368 +427 @@
 void MMF::AbstractMediaPlayer::loadingComplete(int error)
 {
-    Q_ASSERT(Phonon::LoadingState == state());
-
-    if (KErrNone == error) {
-        updateMetaData();
-        changeState(StoppedState);
+    TRACE_CONTEXT(AbstractMediaPlayer::loadingComplete, EAudioApi);
+    TRACE_ENTRY("state %d error %d", state(), error);
+    if (progressiveDownloadStalled()) {
+        Q_ASSERT(Phonon::BufferingState == state());
+        if (KErrNone == error) {
+            bufferingComplete();
+            doSeek(m_position);
+            startPlayback();
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+            m_downloadStalled = false;
+#endif
+        }
     } else {
-        setError(tr("Loading clip failed"), error);
+        Q_ASSERT(Phonon::LoadingState == state());
+        if (KErrNone == error) {
+            updateMetaData();
+            changeState(StoppedState);
+        } else {
+            if (isProgressiveDownload() && KErrCorrupt == error) {
+                setProgressiveDownloadStalled();
+            } else {
+                setError(tr("Loading clip failed"), error);
+            }
+        }
     }
 }
@@ -398 +474 @@
     }
     else {
-        setError(tr("Playback complete"), error);
-        emit finished();
+        if (isProgressiveDownload() && KErrCorrupt == error) {
+            setProgressiveDownloadStalled();
+        } else {
+            setError(tr("Playback complete"), error);
+            emit finished();
+        }
     }
 }
@@ -408 +488 @@
 }
 
+bool MMF::AbstractMediaPlayer::isProgressiveDownload() const
+{
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+    return (0 != m_download);
+#else
+    return false;
+#endif
+}
+
+bool MMF::AbstractMediaPlayer::progressiveDownloadStalled() const
+{
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+    return m_downloadStalled;
+#else
+    return false;
+#endif
+}
+
 //-----------------------------------------------------------------------------
 // Slots
@@ -414 +512 @@
 void MMF::AbstractMediaPlayer::positionTick()
 {
-    const qint64 current = currentTime();
-    emitMarksIfReached(current);
-    emit MMF::AbstractPlayer::tick(current);
+    const qint64 pos = getCurrentTime();
+    if (pos > m_position) {
+        m_position = pos;
+        emitMarksIfReached(m_position);
+        emit MMF::AbstractPlayer::tick(m_position);
+    }
 }
 
@@ -441 +542 @@
 void MMF::AbstractMediaPlayer::resetMarksIfRewound()
 {
-    const qint64 current = currentTime();
+    const qint64 current = getCurrentTime();
     const qint64 total = totalTime();
     const qint64 remaining = total - current;
@@ -470 +571 @@
 }
 
+void MMF::AbstractMediaPlayer::setProgressiveDownloadStalled()
+{
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+    TRACE_CONTEXT(AbstractMediaPlayer::setProgressiveDownloadStalled, EAudioApi);
+    TRACE_ENTRY("state %d", state());
+    Q_ASSERT(isProgressiveDownload());
+    m_downloadStalled = true;
+    doClose();
+    bufferingStarted();
+    // Video player loses window handle when closed - need to reapply it here
+    videoOutputChanged();
+    m_download->resume();
+#endif
+}
+
 void MMF::AbstractMediaPlayer::bufferStatusTick()
 {
-    emit MMF::AbstractPlayer::bufferStatus(bufferStatus());
-}
+    // During progressive download, there is no way to detect the buffering status.
+    // Phonon does not support a "buffering; amount unknown" signal, therefore we
+    // return a buffering status of zero.
+    const int status = progressiveDownloadStalled() ? 0 : bufferStatus();
+    emit MMF::AbstractPlayer::bufferStatus(status);
+}
+
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+void MMF::AbstractMediaPlayer::downloadLengthChanged(qint64 length)
+{
+    TRACE_CONTEXT(AbstractMediaPlayer::downloadLengthChanged, EAudioApi);
+    TRACE_ENTRY("length %Ld", length);
+    Q_UNUSED(length)
+    if (m_downloadStalled) {
+        bufferingComplete();
+        int err = m_parent->openFileHandle(m_download->targetFileName());
+        if (KErrNone == err)
+            err = openFile(*m_parent->file());
+        if (KErrNone != err)
+            setError(tr("Error opening file"));
+    }
+}
+
+void MMF::AbstractMediaPlayer::downloadStateChanged(Download::State state)
+{
+    TRACE_CONTEXT(AbstractMediaPlayer::downloadStateChanged, EAudioApi);
+    TRACE_ENTRY("state %d", state);
+    switch (state) {
+    case Download::Idle:
+    case Download::Initializing:
+        break;
+    case Download::Downloading:
+        {
+        int err = m_parent->openFileHandle(m_download->targetFileName());
+        if (KErrNone == err)
+            err = openFile(*m_parent->file());
+        else if (KErrCorrupt == err)
+            // Insufficient data downloaded - enter Buffering state
+            setProgressiveDownloadStalled();
+        if (KErrNone != err)
+            setError(tr("Error opening file"));
+        }
+        break;
+    case Download::Complete:
+        break;
+    case Download::Error:
+        setError(tr("Download error"));
+        break;
+    }
+}
+#endif // PHONON_MMF_PROGRESSIVE_DOWNLOAD
 
 Phonon::State MMF::AbstractMediaPlayer::phononState(PrivateState state) const

trunk/src/3rdparty/phonon/mmf/abstractmediaplayer.h

@@ -24 +24 @@
 #include <e32std.h>
 #include "abstractplayer.h"
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+#   include "download.h"
+#endif
 
 class RFile;
@@ -48 +51 @@
 
 public:
-    virtual void open(const Phonon::MediaSource&, RFile&);
+    virtual void open();
+    virtual void close();
 
     // MediaObjectInterface
@@ -56 +60 @@
     virtual void seek(qint64 milliseconds);
     virtual bool isSeekable() const;
+    virtual qint64 currentTime() const;
     virtual void volumeChanged(qreal volume);
 
@@ -69 +74 @@
     virtual void doSeek(qint64 pos) = 0;
     virtual int setDeviceVolume(int mmfVolume) = 0;
+    virtual int openFile(const QString &fileName) = 0;
     virtual int openFile(RFile& file) = 0;
-    virtual int openUrl(const QString& url) = 0;
+    virtual int openUrl(const QString& url, int iap) = 0;
+    virtual int openDescriptor(const TDesC8 &des) = 0;
     virtual int bufferStatus() const = 0;
-    virtual void close() = 0;
+    virtual void doClose() = 0;
 
     void updateMetaData();
+    virtual qint64 getCurrentTime() const = 0;
     virtual int numberOfMetaDataEntries() const = 0;
     virtual QPair<QString, QString> metaDataEntry(int index) const = 0;
@@ -87 +95 @@
     static qint64 toMilliSeconds(const TTimeIntervalMicroSeconds &);
 
+    bool isProgressiveDownload() const;
+    bool progressiveDownloadStalled() const;
+
 private:
     void startPositionTimer();
@@ -97 +108 @@
     void resetMarksIfRewound();
     void startPlayback();
+    void setProgressiveDownloadStalled();
 
     enum Pending {
@@ -109 +121 @@
     void positionTick();
     void bufferStatusTick();
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+    void downloadLengthChanged(qint64);
+    void downloadStateChanged(Download::State);
+#endif
 
 private:
@@ -116 +132 @@
 
     QScopedPointer<QTimer>      m_positionTimer;
+    qint64                      m_position;
 
     QScopedPointer<QTimer>      m_bufferStatusTimer;
@@ -124 +141 @@
     bool                        m_prefinishMarkSent;
     bool                        m_aboutToFinishSent;
+
+    // Used for playback of resource files
+    TPtrC8                      m_buffer;
+
+#ifdef PHONON_MMF_PROGRESSIVE_DOWNLOAD
+    Download                    *m_download;
+    bool                        m_downloadStalled;
+#endif
 
     QMultiMap<QString, QString> m_metaData;

trunk/src/3rdparty/phonon/mmf/abstractplayer.h

@@ -27 +27 @@
 #include "abstractvideooutput.h"
 
-class RFile;
-
 QT_BEGIN_NAMESPACE
 
@@ -55 +53 @@
     AbstractPlayer(const AbstractPlayer *player);
 
-    virtual void open(const Phonon::MediaSource&, RFile&) = 0;
+    virtual void open() = 0;
+    virtual void close() = 0;
 
     // MediaObjectInterface (implemented)

trunk/src/3rdparty/phonon/mmf/abstractvideooutput.cpp

@@ -61 +61 @@
     ,   m_scaleMode(DefaultScaleMode)
 {
-
+    // Ensure that this widget has a native window handle
+    winId();
 }
 
@@ -161 +162 @@
 #ifndef QT_NO_DEBUG
     TRACE_CONTEXT(AbstractVideoOutput::dump, EVideoInternal);
-
     QScopedPointer<ObjectDump::QVisitor> visitor(new ObjectDump::QVisitor);
     visitor->setPrefix("Phonon::MMF"); // to aid searchability of logs
     ObjectDump::addDefaultAnnotators(*visitor);
-
-    if (QWidget *window = QApplication::activeWindow()) {
-        TRACE("Dumping from root window 0x%08x:", window);
-        ObjectDump::dumpTreeFromLeaf(*window, *visitor);
-    }
-
-    TRACE("Dumping tree from leaf 0x%08x:", this);
     ObjectDump::dumpTreeFromLeaf(*this, *visitor);
-
-    QScopedPointer<ObjectDump::QDumper> dumper(new ObjectDump::QDumper);
-    dumper->setPrefix("Phonon::MMF"); // to aid searchability of logs
-    ObjectDump::addDefaultAnnotators(*dumper);
-    TRACE_0("Dumping AbstractVideoOutput:");
-    dumper->dumpObject(*this);
 #endif
 }

trunk/src/3rdparty/phonon/mmf/abstractvideoplayer.cpp

@@ -17 +17 @@
 */
 
+#include <QDir>
 #include <QUrl>
 #include <QTimer>
@@ -67 +68 @@
     createPlayer();
 
+    m_player->RegisterForVideoLoadingNotification(*this);
+
     TRACE_EXIT_0();
 }
@@ -131 +134 @@
 }
 
+int MMF::AbstractVideoPlayer::openFile(const QString &fileName)
+{
+    const QHBufC nativeFileName(QDir::toNativeSeparators(fileName));
+    TRAPD(err, m_player->OpenFileL(*nativeFileName));
+    return err;
+}
+
 int MMF::AbstractVideoPlayer::openFile(RFile &file)
 {
@@ -137 +147 @@
 }
 
-int MMF::AbstractVideoPlayer::openUrl(const QString &url)
-{
-    TRAPD(err, m_player->OpenUrlL(qt_QString2TPtrC(url)));
+int MMF::AbstractVideoPlayer::openUrl(const QString &url, int iap)
+{
+    TRAPD(err, m_player->OpenUrlL(qt_QString2TPtrC(url), iap));
+    return err;
+}
+
+int MMF::AbstractVideoPlayer::openDescriptor(const TDesC8 &des)
+{
+    TRAPD(err, m_player->OpenDesL(des));
     return err;
 }
@@ -150 +166 @@
 }
 
-void MMF::AbstractVideoPlayer::close()
+void MMF::AbstractVideoPlayer::doClose()
 {
     m_player->Close();
@@ -160 +176 @@
 }
 
-qint64 MMF::AbstractVideoPlayer::currentTime() const
-{
-    TRACE_CONTEXT(AbstractVideoPlayer::currentTime, EVideoApi);
+qint64 MMF::AbstractVideoPlayer::getCurrentTime() const
+{
+    TRACE_CONTEXT(AbstractVideoPlayer::getCurrentTime, EVideoApi);
 
     TTimeIntervalMicroSeconds us;
@@ -212 +228 @@
     TRACE_ENTRY("state %d aspectRatio %d", state());
 
-    updateScaleFactors(m_videoOutput->videoWindowSize());
+    if (m_videoOutput)
+        updateScaleFactors(m_videoOutput->videoWindowSize());
 
     TRACE_EXIT_0();
@@ -222 +239 @@
     TRACE_ENTRY("state %d", state());
 
-    updateScaleFactors(m_videoOutput->videoWindowSize());
+    if (m_videoOutput)
+        updateScaleFactors(m_videoOutput->videoWindowSize());
 
     TRACE_EXIT_0();
@@ -237 +255 @@
     TRACE_ENTRY("state %d error %d", state(), aError);
 
-    __ASSERT_ALWAYS(LoadingState == state(), Utils::panic(InvalidStatePanic));
+    __ASSERT_ALWAYS(LoadingState == state() ||
+                    progressiveDownloadStalled() && BufferingState == state(),
+                    Utils::panic(InvalidStatePanic));
 
     if (KErrNone == aError)
@@ -252 +272 @@
     TRACE_ENTRY("state %d error %d", state(), aError);
 
-    __ASSERT_ALWAYS(LoadingState == state(), Utils::panic(InvalidStatePanic));
+    __ASSERT_ALWAYS(LoadingState == state() ||
+                    progressiveDownloadStalled() && BufferingState == state(),
+                    Utils::panic(InvalidStatePanic));
 
     TRAPD(err, getVideoClipParametersL(aError));
@@ -358 +380 @@
 void MMF::AbstractVideoPlayer::initVideoOutput()
 {
+    Q_ASSERT(m_videoOutput);
+
     bool connected = connect(
         m_videoOutput, SIGNAL(videoWindowChanged()),
@@ -379 +403 @@
     Q_UNUSED(connected);
 
-    // Do these after all connections are complete, to ensure
-    // that any signals generated get to their destinations.
-    m_videoOutput->winId();
     m_videoOutput->setVideoSize(m_videoFrameSize);
 }
@@ -401 +422 @@
 void MMF::AbstractVideoPlayer::updateScaleFactors(const QSize &windowSize, bool apply)
 {
+    Q_ASSERT(m_videoOutput);
+
     if (m_videoFrameSize.isValid()) {
         QRect videoRect;
@@ -460 +483 @@
 void MMF::AbstractVideoPlayer::parametersChanged(VideoParameters parameters)
 {
-    if (state() == LoadingState)
+    if (state() == LoadingState || progressiveDownloadStalled() && BufferingState == state())
         m_pendingChanges |= parameters;
     else

trunk/src/3rdparty/phonon/mmf/abstractvideoplayer.h

@@ -65 +65 @@
     virtual void doSeek(qint64 milliseconds);
     virtual int setDeviceVolume(int mmfVolume);
+    virtual int openFile(const QString &fileName);
     virtual int openFile(RFile &file);
-    virtual int openUrl(const QString &url);
+    virtual int openUrl(const QString &url, int iap);
+    virtual int openDescriptor(const TDesC8 &des);
     virtual int bufferStatus() const;
-    virtual void close();
+    virtual void doClose();
 
     // MediaObjectInterface
     virtual bool hasVideo() const;
-    virtual qint64 currentTime() const;
     virtual qint64 totalTime() const;
 
@@ -79 +80 @@
 
     // AbstractMediaPlayer
+    virtual qint64 getCurrentTime() const;
     virtual int numberOfMetaDataEntries() const;
     virtual QPair<QString, QString> metaDataEntry(int index) const;

trunk/src/3rdparty/phonon/mmf/audiooutput.cpp

@@ -79 +79 @@
     Q_ASSERT_X(index == AudioOutputDeviceID, Q_FUNC_INFO,
                "We only support one output device, with id 0");
+#ifdef QT_NO_DEBUG
+    Q_UNUSED(index)
+#endif
     return true;
 }

trunk/src/3rdparty/phonon/mmf/audioplayer.cpp

@@ -17 +17 @@
 */
 
+#include <QDir>
 #include <QUrl>
 
@@ -110 +111 @@
 }
 
+int MMF::AudioPlayer::openFile(const QString &fileName)
+{
+    const QHBufC nativeFileName(QDir::toNativeSeparators(fileName));
+    TRAPD(err, m_player->OpenFileL(*nativeFileName));
+    return err;
+}
+
 int MMF::AudioPlayer::openFile(RFile& file)
 {
@@ -127 +135 @@
 }
 
-int MMF::AudioPlayer::openUrl(const QString& /*url*/)
+int MMF::AudioPlayer::openUrl(const QString& /*url*/, int /*iap*/)
 {
     // Streaming playback is generally not supported by the implementation
@@ -138 +146 @@
 }
 
+int MMF::AudioPlayer::openDescriptor(const TDesC8 &des)
+{
+    TRAPD(err, m_player->OpenDesL(des));
+    return err;
+}
+
 int MMF::AudioPlayer::bufferStatus() const
 {
@@ -145 +159 @@
 }
 
-void MMF::AudioPlayer::close()
+void MMF::AudioPlayer::doClose()
 {
     m_player->Close();
@@ -155 +169 @@
 }
 
-qint64 MMF::AudioPlayer::currentTime() const
-{
-    TRACE_CONTEXT(AudioPlayer::currentTime, EAudioApi);
+qint64 MMF::AudioPlayer::getCurrentTime() const
+{
+    TRACE_CONTEXT(AudioPlayer::getCurrentTime, EAudioApi);
 
     TTimeIntervalMicroSeconds us;
@@ -198 +212 @@
     TRACE_ENTRY("state %d error %d", state(), aError);
 
-    __ASSERT_ALWAYS(LoadingState == state(), Utils::panic(InvalidStatePanic));
+    __ASSERT_ALWAYS(LoadingState == state() ||
+                    progressiveDownloadStalled() && BufferingState == state(),
+                    Utils::panic(InvalidStatePanic));
 
     if (KErrNone == aError) {

trunk/src/3rdparty/phonon/mmf/audioplayer.h

@@ -66 +66 @@
     virtual void doSeek(qint64 milliseconds);
     virtual int setDeviceVolume(int mmfVolume);
+    virtual int openFile(const QString &fileName);
     virtual int openFile(RFile& file);
-    virtual int openUrl(const QString& url);
+    virtual int openUrl(const QString& url, int iap);
+    virtual int openDescriptor(const TDesC8 &des);
     virtual int bufferStatus() const;
-    virtual void close();
+    virtual void doClose();
 
     // MediaObjectInterface
     virtual bool hasVideo() const;
-    virtual qint64 currentTime() const;
     virtual qint64 totalTime() const;
 
     // AbstractMediaPlayer
+    virtual qint64 getCurrentTime() const;
     virtual int numberOfMetaDataEntries() const;
     virtual QPair<QString, QString> metaDataEntry(int index) const;

trunk/src/3rdparty/phonon/mmf/bassboost.cpp

@@ -50 +50 @@
     QList<EffectParameter> &parameters)
 {
+    Q_UNUSED(parameters)
     QScopedPointer<CBassBoost> effect;
     TRAPD(err, effect.reset(CBassBoost::NewL(*stream)));

trunk/src/3rdparty/phonon/mmf/dummyplayer.cpp

@@ -93 +93 @@
 }
 
-void MMF::DummyPlayer::open(const Phonon::MediaSource &, RFile &)
+void MMF::DummyPlayer::open()
 {
 
 }
 
+void MMF::DummyPlayer::close()
+{
+
+}
 
 //-----------------------------------------------------------------------------

trunk/src/3rdparty/phonon/mmf/dummyplayer.h

@@ -58 +58 @@
 
     // AbstractPlayer
-    virtual void open(const Phonon::MediaSource&, RFile&);
+    virtual void open();
+    virtual void close();
     virtual void doSetTickInterval(qint32 interval);
 };

trunk/src/3rdparty/phonon/mmf/effectfactory.cpp

@@ -184 +184 @@
     data.m_parameters.append(param);
 
-    if (data.m_supported = BackendNode::getParameters
-            (stream.data(), data.m_parameters)) {
+    data.m_supported = BackendNode::getParameters(stream.data(),
+                                                  data.m_parameters);
+    if (data.m_supported) {
         const QString description = QCoreApplication::translate
             ("Phonon::MMF::EffectFactory", BackendNode::description());

trunk/src/3rdparty/phonon/mmf/loudness.cpp

@@ -50 +50 @@
     QList<EffectParameter> &parameters)
 {
+    Q_UNUSED(parameters)
     QScopedPointer<CLoudness> effect;
     TRAPD(err, effect.reset(CLoudness::NewL(*stream)));

trunk/src/3rdparty/phonon/mmf/mediaobject.cpp

@@ -35 +35 @@
 
 #include <QDir>
+#include <QResource>
 #include <QUrl>
+#include <cdbcols.h>
+#include <cdblen.h>
+#include <commdb.h>
+#include <mmf/common/mmfcontrollerframeworkbase.h>
 
 QT_BEGIN_NAMESPACE
@@ -53 +58 @@
                                                , m_recognizerOpened(false)
                                                , m_nextSourceSet(false)
+                                               , m_file(0)
+                                               , m_resource(0)
 {
     m_player.reset(new DummyPlayer());
@@ -59 +66 @@
     TRACE_ENTRY_0();
 
-    Q_UNUSED(parent);
+    const int err = m_fileServer.Connect();
+    QT_TRAP_THROWING(User::LeaveIfError(err));
+
+    parent->installEventFilter(this);
+    m_iap = KUseDefaultIap;
 
     TRACE_EXIT_0();
@@ -69 +80 @@
     TRACE_ENTRY_0();
 
-    m_file.Close();
+    parent()->removeEventFilter(this);
+    delete m_resource;
+
+    if (m_file)
+        m_file->Close();
+    delete m_file;
+
     m_fileServer.Close();
     m_recognizer.Close();
@@ -89 +106 @@
         if (KErrNone != err) {
             TRACE("RApaLsSession::Connect error %d", err);
-            return false;
-        }
-
-        err = m_fileServer.Connect();
-        if (KErrNone != err) {
-            TRACE("RFs::Connect error %d", err);
             return false;
         }
@@ -120 +131 @@
 
     if (openRecognizer()) {
-
-        const QHBufC fileNameSymbian(QDir::toNativeSeparators(fileName));
-
-        m_file.Close();
-        TInt err = m_file.Open(m_fileServer, *fileNameSymbian, EFileRead | EFileShareReadersOnly);
-
+        TInt err = openFileHandle(fileName);
+        const QHBufC nativeFileName(QDir::toNativeSeparators(fileName));
         if (KErrNone == err) {
             TDataRecognitionResult recognizerResult;
-            err = m_recognizer.RecognizeData(m_file, recognizerResult);
+            err = m_recognizer.RecognizeData(*m_file, recognizerResult);
             if (KErrNone == err) {
                 const TPtrC mimeType = recognizerResult.iDataType.Des();
                 result = Utils::mimeTypeToMediaType(mimeType);
             } else {
-                TRACE("RApaLsSession::RecognizeData filename %S error %d", fileNameSymbian.data(), err);
+                TRACE("RApaLsSession::RecognizeData filename %S error %d", nativeFileName.data(), err);
             }
         } else {
-            TRACE("RFile::Open filename %S error %d", fileNameSymbian.data(), err);
+            TRACE("RFile::Open filename %S error %d", nativeFileName.data(), err);
         }
     }
@@ -143 +150 @@
 }
 
+int MMF::MediaObject::openFileHandle(const QString &fileName)
+{
+    TRACE_CONTEXT(MediaObject::openFileHandle, EAudioInternal);
+    const QHBufC nativeFileName(QDir::toNativeSeparators(fileName));
+    TRACE_ENTRY("filename %S", nativeFileName.data());
+    if (m_file)
+        m_file->Close();
+    delete m_file;
+    m_file = 0;
+    m_file = new RFile;
+    TInt err = m_file->Open(m_fileServer, *nativeFileName, EFileRead | EFileShareReadersOrWriters);
+    return err;
+}
+
+MMF::MediaType MMF::MediaObject::bufferMediaType(const uchar *data, qint64 size)
+{
+    TRACE_CONTEXT(MediaObject::bufferMediaType, EAudioInternal);
+    MediaType result = MediaTypeUnknown;
+    if (openRecognizer()) {
+        TDataRecognitionResult recognizerResult;
+        const TPtrC8 des(data, size);
+        const TInt err = m_recognizer.RecognizeData(KNullDesC, des, recognizerResult);
+        if (KErrNone == err) {
+            const TPtrC mimeType = recognizerResult.iDataType.Des();
+            result = Utils::mimeTypeToMediaType(mimeType);
+        } else {
+            TRACE("RApaLsSession::RecognizeData error %d", err);
+        }
+    }
+    return result;
+}
 
 //-----------------------------------------------------------------------------
@@ -229 +267 @@
 void MMF::MediaObject::switchToSource(const MediaSource &source)
 {
+    if (m_file)
+        m_file->Close();
+    delete m_file;
+    m_file = 0;
+
+    delete m_resource;
+    m_resource = 0;
+
     createPlayer(source);
     m_source = source;
-    m_player->open(m_source, m_file);
+    m_player->open();
     emit currentSourceChanged(m_source);
 }
@@ -273 +319 @@
     case MediaSource::Invalid:
     case MediaSource::Disc:
+        errorMessage = tr("Error opening source: type not supported");
+        break;
+
     case MediaSource::Stream:
-        errorMessage = tr("Error opening source: type not supported");
+        {
+            const QString fileName = source.url().toLocalFile();
+            if (fileName.startsWith(QLatin1String(":/")) || fileName.startsWith(QLatin1String("qrc://"))) {
+                Q_ASSERT(!m_resource);
+                m_resource = new QResource(fileName);
+                if (m_resource->isValid()) {
+                    if (m_resource->isCompressed())
+                        errorMessage = tr("Error opening source: resource is compressed");
+                    else
+                        mediaType = bufferMediaType(m_resource->data(), m_resource->size());
+                } else {
+                    errorMessage = tr("Error opening source: resource not valid");
+                }
+            } else {
+                errorMessage = tr("Error opening source: type not supported");
+            }
+        }
         break;
 
@@ -281 +346 @@
         break;
     }
+
+    if (oldPlayer)
+        oldPlayer->close();
 
     AbstractPlayer* newPlayer = 0;
@@ -372 +440 @@
 }
 
+RFile* MMF::MediaObject::file() const
+{
+    return m_file;
+}
+
+QResource* MMF::MediaObject::resource() const
+{
+    return m_resource;
+}
+
 //-----------------------------------------------------------------------------
 // MediaNode
@@ -422 +500 @@
 
 //-----------------------------------------------------------------------------
+// IAP support
+//-----------------------------------------------------------------------------
+
+int MMF::MediaObject::currentIAP() const
+{
+    return m_iap;
+}
+
+bool MMF::MediaObject::eventFilter(QObject *watched, QEvent *event)
+{
+    if (event->type() == QEvent::DynamicPropertyChange ) {
+        QDynamicPropertyChangeEvent* dynamicEvent = static_cast<QDynamicPropertyChangeEvent*>(event);
+        if (dynamicEvent->propertyName() == "InternetAccessPointName") {
+            QVariant value = watched->property("InternetAccessPointName");
+            if (value.isValid()) {
+                QString iapName = value.toString();
+                TRAPD(err, setIAPIdFromNameL(iapName));
+                if (err)
+                    m_player->setError(tr("Failed to set requested IAP"), err);
+            }
+        }
+    }
+    return false;
+}
+
+void MMF::MediaObject::setIAPIdFromNameL(const QString& iapString)
+{
+    TRACE_CONTEXT(MediaObject::getIapIdFromName, EVideoInternal);
+    TBuf<KCommsDbSvrMaxColumnNameLength> iapDes = qt_QString2TPtrC(iapString);
+    CCommsDatabase *commsDb = CCommsDatabase::NewL(EDatabaseTypeIAP);
+    CleanupStack::PushL(commsDb);
+    commsDb->ShowHiddenRecords();
+    CCommsDbTableView *view = commsDb->OpenTableLC(TPtrC(IAP));
+    for (TInt l = view->GotoFirstRecord(); l != KErrNotFound; l = view->GotoNextRecord()) {
+        TBuf<KCommsDbSvrMaxColumnNameLength> iapName;
+        view->ReadTextL(TPtrC(COMMDB_NAME), iapName);
+        TRACE("found IAP %S", &iapName);
+        if (iapName.CompareF(iapDes) == 0) {
+            TUint32 uiap;
+            view->ReadUintL(TPtrC(COMMDB_ID), uiap);
+            TRACE("matched IAP %S, setting m_iap %d", &iapName, uiap);
+            m_iap = uiap;
+            break;
+        }
+    }
+    CleanupStack::PopAndDestroy(2); // commsDb, view
+}
+
+//-----------------------------------------------------------------------------
 // Other private functions
 //-----------------------------------------------------------------------------

trunk/src/3rdparty/phonon/mmf/mediaobject.h

@@ -24 +24 @@
 #include <QScopedPointer>
 #include <QTimer>
+#include <QString>
 
 // For recognizer
@@ -33 +34 @@
 
 QT_BEGIN_NAMESPACE
+
+class QResource;
 
 namespace Phonon
@@ -88 +91 @@
     void setVideoOutput(AbstractVideoOutput* videoOutput);
 
+    int openFileHandle(const QString &fileName);
+    RFile* file() const;
+    QResource* resource() const;
+    int currentIAP() const;
+
 public Q_SLOTS:
     void volumeChanged(qreal volume);
@@ -108 +116 @@
     void tick(qint64 time);
 
+protected:
+    bool eventFilter(QObject *watched, QEvent *event);
+
 private Q_SLOTS:
     void handlePrefinishMarkReached(qint32);
@@ -115 +126 @@
     void createPlayer(const MediaSource &source);
     bool openRecognizer();
+    void setIAPIdFromNameL(const QString& iapString);
 
     // Audio / video media type recognition
     MediaType fileMediaType(const QString& fileName);
+    MediaType bufferMediaType(const uchar *data, qint64 size);
     // TODO: urlMediaType function
 
@@ -133 +146 @@
     bool                                m_nextSourceSet;
 
-    // Storing the file handle here to work around KErrInUse error
-    // from MMF player utility OpenFileL functions
-    RFile                               m_file;
+    RFile*                              m_file;
+    QResource*                          m_resource;
 
     QScopedPointer<AbstractPlayer>      m_player;
+    int                                 m_iap;
 
 };

trunk/src/3rdparty/phonon/mmf/videoplayer_dsa.cpp

@@ -62 +62 @@
 void MMF::DsaVideoPlayer::videoWindowScreenRectChanged()
 {
+    Q_ASSERT(m_videoOutput);
+
     QRect windowRect = static_cast<DsaVideoOutput *>(m_videoOutput)->videoWindowScreenRect();
 
@@ -125 +127 @@
     // CVideoPlayerUtility::NewL starts DSA
     m_dsaActive = true;
-
-    m_player->RegisterForVideoLoadingNotification(*this);
 }
 
 void MMF::DsaVideoPlayer::initVideoOutput()
 {
+    Q_ASSERT(m_videoOutput);
+
     bool connected = connect(
         m_videoOutput, SIGNAL(videoWindowScreenRectChanged()),
@@ -157 +159 @@
 void MMF::DsaVideoPlayer::prepareCompleted()
 {
-    videoWindowScreenRectChanged();
+    if (m_videoOutput)
+        videoWindowScreenRectChanged();
 }
 

trunk/src/3rdparty/phonon/mmf/videoplayer_surface.cpp

@@ -60 +60 @@
 void MMF::SurfaceVideoPlayer::videoWindowSizeChanged()
 {
-    updateScaleFactors(m_videoOutput->videoWindowSize());
+    if (m_videoOutput)
+        updateScaleFactors(m_videoOutput->videoWindowSize());
 }
 
@@ -81 +82 @@
 void MMF::SurfaceVideoPlayer::initVideoOutput()
 {
+    Q_ASSERT(m_videoOutput);
+
     bool connected = connect(
         m_videoOutput, SIGNAL(videoWindowSizeChanged()),
@@ -105 +108 @@
 void MMF::SurfaceVideoPlayer::handleParametersChanged(VideoParameters parameters)
 {
+    TRACE_CONTEXT(SurfaceVideoPlayer::handleParametersChanged, EVideoApi);
+    TRACE_ENTRY("parameters 0x%x", parameters.operator int());
+
     TRect rect;
     if (m_videoOutput) {
@@ -116 +122 @@
         int err = KErrNone;
         if (parameters & WindowHandle) {
-            if (m_displayWindow)
-                player->RemoveDisplayWindow(*m_displayWindow);
-
-            RWindow *window = static_cast<RWindow *>(m_window);
-            if (window) {
-                window->SetBackgroundColor(TRgb(0, 0, 0, 255));
-                TRAP(err, player->AddDisplayWindowL(m_wsSession, m_screenDevice, *window, rect, rect));
-                if (KErrNone != err) {
-                    setError(tr("Video display error"), err);
-                    window = 0;
-                }
-            }
-            m_displayWindow = window;
+            removeDisplayWindow();
+            addDisplayWindow(rect);
         }
 
         if (KErrNone == err) {
             if (parameters & ScaleFactors) {
+                if (!m_displayWindow)
+                    addDisplayWindow(rect);
                 Q_ASSERT(m_displayWindow);
                 TRAP(err, player->SetVideoExtentL(*m_displayWindow, rect));
@@ -144 +141 @@
         }
     }
+
+    TRACE_EXIT_0();
+}
+
+void MMF::SurfaceVideoPlayer::addDisplayWindow(const TRect &rect)
+{
+    TRACE_CONTEXT(SurfaceVideoPlayer::addDisplayWindow, EVideoApi);
+    TRACE_ENTRY("rect %d %d - %d %d", rect.iTl.iX, rect.iTl.iY, rect.iBr.iX, rect.iBr.iY);
+
+    Q_ASSERT(!m_displayWindow);
+    RWindow *window = static_cast<RWindow *>(m_window);
+
+    TRACE("window 0x%08x", window);
+
+    if (window) {
+        window->SetBackgroundColor(TRgb(0, 0, 0, 255));
+        CVideoPlayerUtility2 *player = static_cast<CVideoPlayerUtility2 *>(m_player.data());
+        Q_ASSERT(player);
+        TRAPD(err, player->AddDisplayWindowL(m_wsSession, m_screenDevice, *window, rect, rect));
+        if (KErrNone == err)
+            m_displayWindow = window;
+        else
+            setError(tr("Video display error"), err);
+        TRACE("err %d", err);
+    }
+
+    TRACE_EXIT_0();
+}
+
+void MMF::SurfaceVideoPlayer::removeDisplayWindow()
+{
+    TRACE_CONTEXT(SurfaceVideoPlayer::removeDisplayWindow, EVideoApi);
+    TRACE("player 0x%08x window 0x%08x", m_player.data(), m_displayWindow);
+
+    CVideoPlayerUtility2 *player = static_cast<CVideoPlayerUtility2 *>(m_player.data());
+    if (player && m_displayWindow) {
+        player->RemoveDisplayWindow(*m_displayWindow);
+        m_displayWindow = 0;
+    }
 }
 

trunk/src/3rdparty/phonon/mmf/videoplayer_surface.h

@@ -63 +63 @@
     void handleParametersChanged(VideoParameters parameters);
 
+    void addDisplayWindow(const TRect &rect);
+    void removeDisplayWindow();
+
 private:
     // Window handle which has been passed to the MMF via

trunk/src/3rdparty/phonon/mmf/videowidget.cpp

@@ -65 +65 @@
     TRACE_CONTEXT(VideoWidget::VideoWidget, EVideoApi);
     TRACE_ENTRY_0();
+
+    parent->setProperty("_q_DummyWindowSurface", true);
 
     TRACE_EXIT_0();