summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/3rdparty/phonon/mmf/abstractmediaplayer.cpp492
-rw-r--r--src/3rdparty/phonon/mmf/abstractmediaplayer.h148
-rw-r--r--src/3rdparty/phonon/mmf/abstractplayer.h4
-rw-r--r--src/3rdparty/phonon/mmf/audioplayer.cpp452
-rw-r--r--src/3rdparty/phonon/mmf/audioplayer.h95
-rw-r--r--src/3rdparty/phonon/mmf/utils.h1
-rw-r--r--src/3rdparty/phonon/mmf/videoplayer.cpp521
-rw-r--r--src/3rdparty/phonon/mmf/videoplayer.h96
-rw-r--r--src/plugins/phonon/mmf/mmf.pro28
9 files changed, 745 insertions, 1092 deletions
diff --git a/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp b/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
new file mode 100644
index 0000000..a3affef
--- /dev/null
+++ b/src/3rdparty/phonon/mmf/abstractmediaplayer.cpp
@@ -0,0 +1,492 @@
+/* This file is part of the KDE project.
+
+Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+
+This library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 2.1 or 3 of the License.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "abstractmediaplayer.h"
+#include "audiooutput.h"
+#include "utils.h"
+
+using namespace Phonon;
+using namespace Phonon::MMF;
+
+//-----------------------------------------------------------------------------
+// Constants
+//-----------------------------------------------------------------------------
+
+const qint32 DefaultTickInterval = 20;
+const int NullMaxVolume = -1;
+
+
+//-----------------------------------------------------------------------------
+// Constructor / destructor
+//-----------------------------------------------------------------------------
+
+MMF::AbstractMediaPlayer::AbstractMediaPlayer() :
+ m_state(GroundState)
+ , m_error(NoError)
+ , m_tickInterval(DefaultTickInterval)
+ , m_tickTimer(new QTimer(this))
+ , m_volume(0.0)
+ , m_mmfMaxVolume(NullMaxVolume)
+ , m_audioOutput(NULL)
+{
+ connect(m_tickTimer.data(), SIGNAL(timeout()), this, SLOT(tick()));
+}
+
+MMF::AbstractMediaPlayer::~AbstractMediaPlayer()
+{
+
+}
+
+
+//-----------------------------------------------------------------------------
+// Public functions (AbstractPlayer interface)
+//-----------------------------------------------------------------------------
+
+void MMF::AbstractMediaPlayer::play()
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::play, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ switch(m_state)
+ {
+ case GroundState:
+ case LoadingState:
+ // Is this the correct error? Really we want 'NotReadyError'
+ m_error = NormalError;
+ changeState(ErrorState);
+ break;
+
+ case StoppedState:
+ case PausedState:
+ doPlay();
+ startTickTimer();
+ changeState(PlayingState);
+ break;
+
+ case PlayingState:
+ case BufferingState:
+ case ErrorState:
+ // Do nothing
+ break;
+
+ // Protection against adding new states and forgetting to update this switch
+ default:
+ TRACE_PANIC(InvalidStatePanic);
+ }
+
+ TRACE_EXIT("state %d", m_state);
+}
+
+void MMF::AbstractMediaPlayer::pause()
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::pause, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ switch(m_state)
+ {
+ case GroundState:
+ case LoadingState:
+ case StoppedState:
+ case PausedState:
+ case ErrorState:
+ // Do nothing
+ break;
+
+ case PlayingState:
+ case BufferingState:
+ doPause();
+ stopTickTimer();
+ changeState(PausedState);
+ break;
+
+ // Protection against adding new states and forgetting to update this switch
+ default:
+ TRACE_PANIC(InvalidStatePanic);
+ }
+
+ TRACE_EXIT("state %d", m_state);
+}
+
+void MMF::AbstractMediaPlayer::stop()
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::stop, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ switch(m_state)
+ {
+ case GroundState:
+ case LoadingState:
+ case StoppedState:
+ case ErrorState:
+ // Do nothing
+ break;
+
+ case PlayingState:
+ case BufferingState:
+ case PausedState:
+ doStop();
+ stopTickTimer();
+ changeState(StoppedState);
+ break;
+
+ // Protection against adding new states and forgetting to update this switch
+ default:
+ TRACE_PANIC(InvalidStatePanic);
+ }
+
+ TRACE_EXIT("state %d", m_state);
+}
+
+bool MMF::AbstractMediaPlayer::isSeekable() const
+{
+ return true;
+}
+
+qint32 MMF::AbstractMediaPlayer::tickInterval() const
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::tickInterval, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ TRACE_RETURN("%d", m_tickInterval);
+}
+
+void MMF::AbstractMediaPlayer::setTickInterval(qint32 interval)
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::setTickInterval, EAudioApi);
+ TRACE_ENTRY("state %d m_interval %d interval %d", m_state, m_tickInterval, interval);
+
+ m_tickInterval = interval;
+ m_tickTimer->setInterval(interval);
+
+ TRACE_EXIT_0();
+}
+
+Phonon::ErrorType MMF::AbstractMediaPlayer::errorType() const
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::errorType, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ const Phonon::ErrorType result = (ErrorState == m_state)
+ ? m_error : NoError;
+
+ TRACE_RETURN("%d", result);
+}
+
+QString MMF::AbstractMediaPlayer::errorString() const
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::errorString, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ TRACE_EXIT_0();
+ // TODO: put in proper error strings
+ QString result;
+ return result;
+}
+
+Phonon::State MMF::AbstractMediaPlayer::state() const
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::state, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ const Phonon::State result = phononState(m_state);
+
+ TRACE_RETURN("%d", result);
+}
+
+qint32 MMF::AbstractMediaPlayer::prefinishMark() const
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::prefinishMark, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ // TODO: implement prefinish mark
+ const qint32 result = 0;
+ TRACE_RETURN("%d", result);
+}
+
+void MMF::AbstractMediaPlayer::setPrefinishMark(qint32 mark)
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::setPrefinishMark, EAudioApi);
+ TRACE_ENTRY("state %d mark %d", m_state, mark);
+ Q_UNUSED(mark); // to silence warnings in release builds
+
+ // TODO: implement prefinish mark
+
+ TRACE_EXIT_0();
+}
+
+qint32 MMF::AbstractMediaPlayer::transitionTime() const
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::transitionTime, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ // TODO: implement transition time
+ const qint32 result = 0;
+ TRACE_RETURN("%d", result);
+}
+
+void MMF::AbstractMediaPlayer::setTransitionTime(qint32 time)
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::setTransitionTime, EAudioApi);
+ TRACE_ENTRY("state %d time %d", m_state, time);
+ Q_UNUSED(time); // to silence warnings in release builds
+
+ // TODO: implement transition time
+
+ TRACE_EXIT_0();
+}
+
+MediaSource MMF::AbstractMediaPlayer::source() const
+{
+ return m_source;
+}
+
+void MMF::AbstractMediaPlayer::setNextSource(const MediaSource &source)
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::setNextSource, EAudioApi);
+ TRACE_ENTRY("state %d", m_state);
+
+ // TODO: handle 'next source'
+
+ m_nextSource = source;
+ Q_UNUSED(source);
+
+ TRACE_EXIT_0();
+}
+
+void MMF::AbstractMediaPlayer::setFileSource(const MediaSource &source, RFile& file)
+{
+ TRACE_CONTEXT(AudioPlayer::setSource, EAudioApi);
+ TRACE_ENTRY("state %d source.type %d", m_state, source.type());
+
+ close();
+ changeState(GroundState);
+
+ // TODO: is it correct to assign even if the media type is not supported in
+ // the switch statement below?
+ m_source = source;
+
+ TInt symbianErr = KErrNone;
+
+ switch(m_source.type())
+ {
+ case MediaSource::LocalFile:
+ {
+ // TODO: work out whose responsibility it is to ensure that paths
+ // are Symbian-style, i.e. have backslashes for path delimiters.
+ // Until then, use this utility function...
+ //const QHBufC filename = Utils::symbianFilename(m_source.fileName());
+ //TRAP(symbianErr, m_player->OpenFileL(*filename));
+
+ // Open using shared filehandle
+ // This is a temporary hack to work around KErrInUse from MMF
+ // client utility OpenFileL calls
+ //TRAP(symbianErr, m_player->OpenFileL(file));
+
+ symbianErr = openFile(file);
+ break;
+ }
+
+ case MediaSource::Url:
+ {
+ // TODO: support opening URLs
+ symbianErr = KErrNotSupported;
+ break;
+ }
+
+ case MediaSource::Invalid:
+ case MediaSource::Disc:
+ case MediaSource::Stream:
+ symbianErr = KErrNotSupported;
+ break;
+
+ case MediaSource::Empty:
+ TRACE_EXIT_0();
+ return;
+
+ // Protection against adding new media types and forgetting to update this switch
+ default:
+ TRACE_PANIC(InvalidMediaTypePanic);
+ }
+
+ if(KErrNone == symbianErr)
+ {
+ changeState(LoadingState);
+ }
+ else
+ {
+ // TODO: do something with the value of symbianErr?
+ m_error = NormalError;
+ changeState(ErrorState);
+ }
+
+ TRACE_EXIT_0();
+}
+
+
+//-----------------------------------------------------------------------------
+// Volume
+//-----------------------------------------------------------------------------
+
+qreal MMF::AbstractMediaPlayer::volume() const
+{
+ return m_volume;
+}
+
+bool MMF::AbstractMediaPlayer::setVolume(qreal volume)
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::setVolume, EAudioInternal);
+ TRACE_ENTRY("state %d", m_state);
+
+ bool volumeChanged = false;
+
+ switch(m_state)
+ {
+ case GroundState:
+ case LoadingState:
+ case ErrorState:
+ // Do nothing
+ break;
+
+ case StoppedState:
+ case PausedState:
+ case PlayingState:
+ case BufferingState:
+ {
+ if(volume != m_volume)
+ {
+ const int err = doSetVolume(volume * m_mmfMaxVolume);
+
+ if(KErrNone == err)
+ {
+ m_volume = volume;
+ volumeChanged = true;
+
+ if(m_audioOutput)
+ {
+ // Trigger AudioOutput signal
+ m_audioOutput->triggerVolumeChanged(m_volume);
+ }
+ }
+ else
+ {
+ m_error = NormalError;
+ changeState(ErrorState);
+ }
+ }
+ break;
+ }
+
+ // Protection against adding new states and forgetting to update this
+ // switch
+ default:
+ TRACE_PANIC(InvalidStatePanic);
+ }
+
+ TRACE_RETURN("%d", volumeChanged);
+}
+
+
+//-----------------------------------------------------------------------------
+// Proxies
+//-----------------------------------------------------------------------------
+
+void MMF::AbstractMediaPlayer::setAudioOutput(AudioOutput* audioOutput)
+{
+ m_audioOutput = audioOutput;
+}
+
+
+//-----------------------------------------------------------------------------
+// Protected functions
+//-----------------------------------------------------------------------------
+
+void MMF::AbstractMediaPlayer::startTickTimer()
+{
+ m_tickTimer->start(m_tickInterval);
+}
+
+void MMF::AbstractMediaPlayer::stopTickTimer()
+{
+ m_tickTimer->stop();
+}
+
+void MMF::AbstractMediaPlayer::initVolume(int initialVolume, int mmfMaxVolume)
+{
+ m_volume = static_cast<qreal>(initialVolume) / mmfMaxVolume;
+ m_mmfMaxVolume = mmfMaxVolume;
+}
+
+Phonon::State MMF::AbstractMediaPlayer::phononState() const
+{
+ return phononState(m_state);
+}
+
+Phonon::State MMF::AbstractMediaPlayer::phononState(PrivateState state)
+{
+ const Phonon::State phononState =
+ GroundState == state
+ ? Phonon::StoppedState
+ : static_cast<Phonon::State>(state);
+
+ return phononState;
+}
+
+void MMF::AbstractMediaPlayer::changeState(PrivateState newState)
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::changeState, EAudioInternal);
+ TRACE_ENTRY("state %d newState %d", m_state, newState);
+
+ // TODO: add some invariants to check that the transition is valid
+
+ const Phonon::State currentPhononState = phononState(m_state);
+ const Phonon::State newPhononState = phononState(newState);
+ if(currentPhononState != newPhononState)
+ {
+ TRACE("emit stateChanged(%d, %d)", newPhononState, currentPhononState);
+ emit stateChanged(newPhononState, currentPhononState);
+ }
+
+ m_state = newState;
+
+ TRACE_EXIT_0();
+}
+
+qint64 MMF::AbstractMediaPlayer::toMilliSeconds(const TTimeIntervalMicroSeconds &in)
+{
+ return in.Int64() / 1000;
+}
+
+
+//-----------------------------------------------------------------------------
+// Slots
+//-----------------------------------------------------------------------------
+
+void MMF::AbstractMediaPlayer::tick()
+{
+ TRACE_CONTEXT(AbstractMediaPlayer::tick, EAudioInternal);
+ TRACE_ENTRY("state %d", m_state);
+
+ emit tick(currentTime());
+
+ TRACE_EXIT_0();
+}
+
+
+
+
+
diff --git a/src/3rdparty/phonon/mmf/abstractmediaplayer.h b/src/3rdparty/phonon/mmf/abstractmediaplayer.h
new file mode 100644
index 0000000..6f7ae1d
--- /dev/null
+++ b/src/3rdparty/phonon/mmf/abstractmediaplayer.h
@@ -0,0 +1,148 @@
+/* This file is part of the KDE project.
+
+Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+
+This library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 2.1 or 3 of the License.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this library. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef PHONON_MMF_ABSTRACTMEDIAPLAYER_H
+#define PHONON_MMF_ABSTRACTMEDIAPLAYER_H
+
+#include <QTimer>
+#include <QScopedPointer>
+#include <e32std.h>
+#include "abstractplayer.h"
+
+class RFile;
+
+namespace Phonon
+{
+ namespace MMF
+ {
+ class AudioOutput;
+
+ class AbstractMediaPlayer : public AbstractPlayer
+ {
+ Q_OBJECT
+
+ protected:
+ AbstractMediaPlayer();
+ ~AbstractMediaPlayer();
+
+ public:
+ // AbstractPlayer
+ virtual void play();
+ virtual void pause();
+ virtual void stop();
+ virtual bool isSeekable() const;
+ virtual qint32 tickInterval() const;
+ virtual void setTickInterval(qint32 interval);
+ virtual Phonon::ErrorType errorType() const;
+ virtual QString errorString() const;
+ virtual Phonon::State state() const;
+ virtual qint32 prefinishMark() const;
+ virtual void setPrefinishMark(qint32);
+ virtual qint32 transitionTime() const;
+ virtual void setTransitionTime(qint32);
+ virtual MediaSource source() const;
+ virtual void setNextSource(const MediaSource &source);
+
+ // This is a temporary hack to work around KErrInUse from MMF
+ // client utility OpenFileL calls
+ //virtual void setSource(const Phonon::MediaSource &) = 0;
+ virtual void setFileSource
+ (const Phonon::MediaSource&, RFile&);
+
+ qreal volume() const;
+ bool setVolume(qreal volume);
+
+ void setAudioOutput(AudioOutput* audioOutput);
+
+ protected:
+ virtual void doPlay() = 0;
+ virtual void doPause() = 0;
+ virtual void doStop() = 0;
+ virtual int doSetVolume(int mmfVolume) = 0;
+ virtual int openFile(RFile& file) = 0;
+ virtual void close() = 0;
+
+ protected:
+ void startTickTimer();
+ void stopTickTimer();
+ void initVolume(int initialVolume, int maxVolume);
+
+ /**
+ * Defined private state enumeration in order to add GroundState
+ */
+ enum PrivateState
+ {
+ LoadingState = Phonon::LoadingState,
+ StoppedState = Phonon::StoppedState,
+ PlayingState = Phonon::PlayingState,
+ BufferingState = Phonon::BufferingState,
+ PausedState = Phonon::PausedState,
+ ErrorState = Phonon::ErrorState,
+ GroundState
+ };
+
+ /**
+ * Converts PrivateState into the corresponding Phonon::State
+ */
+ Phonon::State phononState() const;
+
+ /**
+ * Converts PrivateState into the corresponding Phonon::State
+ */
+ static Phonon::State phononState(PrivateState state);
+
+ /**
+ * Changes state and emits stateChanged()
+ */
+ void changeState(PrivateState newState);
+
+ static qint64 toMilliSeconds(const TTimeIntervalMicroSeconds &);
+
+ Q_SIGNALS:
+ void tick(qint64 time);
+ void stateChanged(Phonon::State oldState,
+ Phonon::State newState);
+
+ private Q_SLOTS:
+ /**
+ * Receives signal from m_tickTimer
+ */
+ void tick();
+
+ protected: // Temporary
+ PrivateState m_state;
+ Phonon::ErrorType m_error;
+
+ private:
+ qint32 m_tickInterval;
+ QScopedPointer<QTimer> m_tickTimer;
+ qreal m_volume;
+ int m_mmfMaxVolume;
+
+ // Not owned
+ AudioOutput* m_audioOutput;
+
+ MediaSource m_source;
+ MediaSource m_nextSource;
+
+ };
+ }
+}
+
+#endif
+
diff --git a/src/3rdparty/phonon/mmf/abstractplayer.h b/src/3rdparty/phonon/mmf/abstractplayer.h
index 418b896..97527ff 100644
--- a/src/3rdparty/phonon/mmf/abstractplayer.h
+++ b/src/3rdparty/phonon/mmf/abstractplayer.h
@@ -33,6 +33,10 @@ namespace Phonon
class AbstractPlayer : public QObject
{
+ // Required although this class has no signals or slots
+ // Without this, qobject_cast will fail
+ Q_OBJECT
+
public:
virtual void play() = 0;
virtual void pause() = 0;
diff --git a/src/3rdparty/phonon/mmf/audioplayer.cpp b/src/3rdparty/phonon/mmf/audioplayer.cpp
index ce6a5f3..45105ee 100644
--- a/src/3rdparty/phonon/mmf/audioplayer.cpp
+++ b/src/3rdparty/phonon/mmf/audioplayer.cpp
@@ -17,36 +17,18 @@ along with this library. If not, see <http://www.gnu.org/licenses/>.
*/
#include <QUrl>
-#include <QTimer>
-#include <private/qcore_symbian_p.h>
#include "audioplayer.h"
-#include "audiooutput.h"
#include "utils.h"
using namespace Phonon;
using namespace Phonon::MMF;
//-----------------------------------------------------------------------------
-// Constants
-//-----------------------------------------------------------------------------
-
-const qint32 DefaultTickInterval = 20;
-const int NullMaxVolume = -1;
-
-
-//-----------------------------------------------------------------------------
// Constructor / destructor
//-----------------------------------------------------------------------------
-MMF::AudioPlayer::AudioPlayer() : m_player(NULL)
- , m_audioOutput(NULL)
- , m_error(NoError)
- , m_state(GroundState)
- , m_tickInterval(DefaultTickInterval)
- , m_tickTimer(NULL)
- , m_volume(0.0)
- , m_maxVolume(NullMaxVolume)
+MMF::AudioPlayer::AudioPlayer() : m_player(NULL)
{
TRACE_CONTEXT(AudioPlayer::AudioPlayer, EAudioApi);
TRACE_ENTRY_0();
@@ -56,9 +38,6 @@ MMF::AudioPlayer::AudioPlayer() : m_player(NULL)
// TODO: should leaves be trapped in the constructor?
m_player = CPlayerType::NewL(*this, 0, EMdaPriorityPreferenceNone);
- m_tickTimer = new QTimer(this);
- connect(m_tickTimer, SIGNAL(timeout()), this, SLOT(tick()));
-
TRACE_EXIT_0();
}
@@ -67,136 +46,64 @@ MMF::AudioPlayer::~AudioPlayer()
TRACE_CONTEXT(AudioPlayer::~AudioPlayer, EAudioApi);
TRACE_ENTRY_0();
- delete m_tickTimer;
delete m_player;
TRACE_EXIT_0();
}
//-----------------------------------------------------------------------------
-// AudioPlayerInterface
+// Public API
//-----------------------------------------------------------------------------
-void MMF::AudioPlayer::play()
+void MMF::AudioPlayer::doPlay()
{
- TRACE_CONTEXT(AudioPlayer::play, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- switch(m_state)
- {
- case GroundState:
- case LoadingState:
- // Is this the correct error? Really we want 'NotReadyError'
- m_error = NormalError;
- changeState(ErrorState);
- break;
-
- case StoppedState:
- case PausedState:
- m_player->Play();
- m_tickTimer->start(m_tickInterval);
- changeState(PlayingState);
- break;
-
- case PlayingState:
- case BufferingState:
- case ErrorState:
- // Do nothing
- break;
-
- // Protection against adding new states and forgetting to update this switch
- default:
- TRACE_PANIC(InvalidStatePanic);
- }
-
- TRACE_EXIT("state %d", m_state);
+ m_player->Play();
}
-void MMF::AudioPlayer::pause()
+void MMF::AudioPlayer::doPause()
{
- TRACE_CONTEXT(AudioPlayer::pause, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- switch(m_state)
- {
- case GroundState:
- case LoadingState:
- case StoppedState:
- case PausedState:
- case ErrorState:
- // Do nothing
- break;
-
- case PlayingState:
- case BufferingState:
- m_player->Pause();
- m_tickTimer->stop();
- changeState(PausedState);
- break;
-
- // Protection against adding new states and forgetting to update this switch
- default:
- TRACE_PANIC(InvalidStatePanic);
- }
-
- TRACE_EXIT("state %d", m_state);
+ m_player->Pause();
}
-void MMF::AudioPlayer::stop()
+void MMF::AudioPlayer::doStop()
{
- TRACE_CONTEXT(AudioPlayer::stop, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- switch(m_state)
- {
- case GroundState:
- case LoadingState:
- case StoppedState:
- case ErrorState:
- // Do nothing
- break;
-
- case PlayingState:
- case BufferingState:
- case PausedState:
- m_player->Stop();
- m_tickTimer->stop();
- changeState(StoppedState);
- break;
-
- // Protection against adding new states and forgetting to update this switch
- default:
- TRACE_PANIC(InvalidStatePanic);
- }
-
- TRACE_EXIT("state %d", m_state);
+ m_player->Stop();
}
-void MMF::AudioPlayer::seek(qint64 ms)
+int MMF::AudioPlayer::doSetVolume(int mmfVolume)
{
- TRACE_CONTEXT(AudioPlayer::seek, EAudioApi);
- TRACE_ENTRY("state %d pos %Ld", m_state, ms);
-
- m_player->SetPosition(TTimeIntervalMicroSeconds(ms));
-
- TRACE_EXIT_0();
+ return m_player->SetVolume(mmfVolume);
}
-qint32 MMF::AudioPlayer::tickInterval() const
+int MMF::AudioPlayer::openFile(RFile& file)
{
- TRACE_CONTEXT(AudioPlayer::tickInterval, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
+ TRAPD(err, m_player->OpenFileL(file));
+
+#ifdef QT_PHONON_MMF_AUDIO_DRM
+ if(KErrNone == err)
+ {
+ // There appears to be a bug in the CDrmPlayerUtility implementation (at least
+ // in S60 5.x) whereby the player does not check whether the loading observer
+ // pointer is null before dereferencing it. Therefore we must register for
+ // loading notification, even though we do nothing in the callback functions.
+ m_player->RegisterForAudioLoadingNotification(*this);
+ }
+#endif
+
+ return err;
+}
- TRACE_RETURN("%d", m_tickInterval);
+void MMF::AudioPlayer::close()
+{
+ m_player->Close();
}
-void MMF::AudioPlayer::setTickInterval(qint32 interval)
+void MMF::AudioPlayer::seek(qint64 ms)
{
- TRACE_CONTEXT(AudioPlayer::setTickInterval, EAudioApi);
- TRACE_ENTRY("state %d m_interval %d interval %d", m_state, m_tickInterval, interval);
+ TRACE_CONTEXT(AudioPlayer::seek, EAudioApi);
+ TRACE_ENTRY("state %d pos %Ld", m_state, ms);
- m_tickInterval = interval;
- m_tickTimer->setInterval(interval);
+ m_player->SetPosition(TTimeIntervalMicroSeconds(ms));
TRACE_EXIT_0();
}
@@ -205,32 +112,9 @@ bool MMF::AudioPlayer::hasVideo() const
{
TRACE_CONTEXT(AudioPlayer::hasVideo, EAudioApi);
TRACE_ENTRY("state %d", m_state);
-
- // TODO: re-factor this class so that audio playback and video playback are
- // delegated to separate classes, which internally hoat a
- // CMdaAudioPlayerUtility / CVideoPlayerUtility instance as appropriate.
-
TRACE_RETURN("%d", false);
}
-bool MMF::AudioPlayer::isSeekable() const
-{
- TRACE_CONTEXT(AudioPlayer::isSeekable, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- TRACE_RETURN("%d", true);
-}
-
-Phonon::State MMF::AudioPlayer::state() const
-{
- TRACE_CONTEXT(AudioPlayer::state, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- const Phonon::State result = phononState(m_state);
-
- TRACE_RETURN("%d", result);
-}
-
qint64 MMF::AudioPlayer::currentTime() const
{
TRACE_CONTEXT(AudioPlayer::currentTime, EAudioApi);
@@ -248,28 +132,6 @@ qint64 MMF::AudioPlayer::currentTime() const
TRACE_RETURN("%Ld", result);
}
-QString MMF::AudioPlayer::errorString() const
-{
- TRACE_CONTEXT(AudioPlayer::errorString, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- TRACE_EXIT_0();
- // TODO: put in proper error strings
- QString result;
- return result;
-}
-
-Phonon::ErrorType MMF::AudioPlayer::errorType() const
-{
- TRACE_CONTEXT(AudioPlayer::errorType, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- const Phonon::ErrorType result = (ErrorState == m_state)
- ? m_error : NoError;
-
- TRACE_RETURN("%d", result);
-}
-
qint64 MMF::AudioPlayer::totalTime() const
{
TRACE_CONTEXT(AudioPlayer::totalTime, EAudioApi);
@@ -280,144 +142,6 @@ qint64 MMF::AudioPlayer::totalTime() const
TRACE_RETURN("%Ld", result);
}
-MediaSource MMF::AudioPlayer::source() const
-{
- TRACE_CONTEXT(AudioPlayer::source, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- TRACE_EXIT_0();
- return m_mediaSource;
-}
-
-void MMF::AudioPlayer::setFileSource(const MediaSource &source, RFile& file)
-{
- TRACE_CONTEXT(AudioPlayer::setSource, EAudioApi);
- TRACE_ENTRY("state %d source.type %d", m_state, source.type());
-
- m_player->Close();
- changeState(GroundState);
-
- // TODO: is it correct to assign even if the media type is not supported in
- // the switch statement below?
- m_mediaSource = source;
-
- TInt symbianErr = KErrNone;
-
- switch(m_mediaSource.type())
- {
- case MediaSource::LocalFile:
- {
- // TODO: work out whose responsibility it is to ensure that paths
- // are Symbian-style, i.e. have backslashes for path delimiters.
- // Until then, use this utility function...
- const QHBufC filename = Utils::symbianFilename(m_mediaSource.fileName());
- //TRAP(symbianErr, m_player->OpenFileL(*filename));
-
- // Open using shared filehandle
- // This is a temporary hack to work around KErrInUse from MMF
- // client utility OpenFileL calls
- TRAP(symbianErr, m_player->OpenFileL(file));
- break;
- }
-
- case MediaSource::Url:
- {
- const QHBufC filename(m_mediaSource.url().toString());
- TRAP(symbianErr, m_player->OpenUrlL(*filename));
- break;
- }
-
- case MediaSource::Invalid:
- case MediaSource::Disc:
- case MediaSource::Stream:
- symbianErr = KErrNotSupported;
- break;
-
- case MediaSource::Empty:
- TRACE_EXIT_0();
- return;
-
- // Protection against adding new media types and forgetting to update this switch
- default:
- TRACE_PANIC(InvalidMediaTypePanic);
- }
-
- if(KErrNone == symbianErr)
- {
-#ifdef QT_PHONON_MMF_AUDIO_DRM
- // There appears to be a bug in the CDrmPlayerUtility implementation (at least
- // in S60 5.x) whereby the player does not check whether the loading observer
- // pointer is null before dereferencing it. Therefore we must register for
- // loading notification, even though we do nothing in the callback functions.
- m_player->RegisterForAudioLoadingNotification(*this);
-#endif
- changeState(LoadingState);
- }
- else
- {
- // TODO: do something with the value of symbianErr?
- m_error = NormalError;
- changeState(ErrorState);
- }
-
- TRACE_EXIT_0();
-}
-
-void MMF::AudioPlayer::setNextSource(const MediaSource &source)
-{
- TRACE_CONTEXT(AudioPlayer::setNextSource, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- // TODO: handle 'next source'
-
- m_nextSource = source;
- Q_UNUSED(source);
-
- TRACE_EXIT_0();
-}
-
-qint32 MMF::AudioPlayer::prefinishMark() const
-{
- TRACE_CONTEXT(AudioPlayer::prefinishMark, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- // TODO: implement prefinish mark
- const qint32 result = 0;
- TRACE_RETURN("%d", result);
-}
-
-void MMF::AudioPlayer::setPrefinishMark(qint32 mark)
-{
- TRACE_CONTEXT(AudioPlayer::setPrefinishMark, EAudioApi);
- TRACE_ENTRY("state %d mark %d", m_state, mark);
- Q_UNUSED(mark); // to silence warnings in release builds
-
- // TODO: implement prefinish mark
-
- TRACE_EXIT_0();
-}
-
-qint32 MMF::AudioPlayer::transitionTime() const
-{
- TRACE_CONTEXT(AudioPlayer::transitionTime, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- // TODO: implement transition time
- const qint32 result = 0;
- TRACE_RETURN("%d", result);
-}
-
-void MMF::AudioPlayer::setTransitionTime(qint32 time)
-{
- TRACE_CONTEXT(AudioPlayer::setTransitionTime, EAudioApi);
- TRACE_ENTRY("state %d time %d", m_state, time);
- Q_UNUSED(time); // to silence warnings in release builds
-
- // TODO: implement transition time
-
- TRACE_EXIT_0();
-}
-
//-----------------------------------------------------------------------------
// Symbian multimedia client observer callbacks
@@ -442,14 +166,7 @@ void MMF::AudioPlayer::MapcInitComplete(TInt aError,
aError = m_player->GetVolume(volume);
if(KErrNone == aError)
{
- m_maxVolume = m_player->MaxVolume();
- m_volume = static_cast<qreal>(volume) / m_maxVolume;
-
- if(m_audioOutput)
- {
- // Trigger AudioOutput signal
- m_audioOutput->triggerVolumeChanged(m_volume);
- }
+ initVolume(volume, m_player->MaxVolume());
emit totalTimeChanged();
changeState(StoppedState);
@@ -474,7 +191,7 @@ void MMF::AudioPlayer::MapcPlayComplete(TInt aError)
TRACE_CONTEXT(AudioPlayer::MapcPlayComplete, EAudioInternal);
TRACE_ENTRY("state %d error %d", m_state, aError);
- m_tickTimer->stop();
+ stopTickTimer();
if(KErrNone == aError)
{
@@ -521,115 +238,16 @@ void MMF::AudioPlayer::MaloLoadingComplete()
#endif // QT_PHONON_MMF_AUDIO_DRM
-//-----------------------------------------------------------------------------
-// Volume
-//-----------------------------------------------------------------------------
-
-qreal MMF::AudioPlayer::volume() const
-{
- return m_volume;
-}
-
-bool MMF::AudioPlayer::setVolume(qreal volume)
-{
- TRACE_CONTEXT(AudioPlayer::setVolume, EAudioInternal);
- TRACE_ENTRY("state %d", m_state);
-
- bool volumeChanged = false;
-
- switch(m_state)
- {
- case GroundState:
- case LoadingState:
- case ErrorState:
- // Do nothing
- break;
-
- case StoppedState:
- case PausedState:
- case PlayingState:
- case BufferingState:
- {
- if(volume != m_volume)
- {
- const int err = m_player->SetVolume(volume * m_maxVolume);
- if(KErrNone == err)
- {
- m_volume = volume;
- volumeChanged = true;
- }
- else
- {
- m_error = NormalError;
- changeState(ErrorState);
- }
- }
- break;
- }
-
- // Protection against adding new states and forgetting to update this
- // switch
- default:
- TRACE_PANIC(InvalidStatePanic);
- }
-
- TRACE_RETURN("%d", volumeChanged);
-}
-
-void MMF::AudioPlayer::setAudioOutput(AudioOutput* audioOutput)
-{
- m_audioOutput = audioOutput;
-}
-
-
-//-----------------------------------------------------------------------------
-// Private functions
-//-----------------------------------------------------------------------------
-
-qint64 MMF::AudioPlayer::toMilliSeconds(const TTimeIntervalMicroSeconds &in)
-{
- return in.Int64() / 1000;
-}
-Phonon::State MMF::AudioPlayer::phononState(PrivateState state)
-{
- const Phonon::State phononState =
- GroundState == state
- ? Phonon::StoppedState
- : static_cast<Phonon::State>(state);
- return phononState;
-}
-void MMF::AudioPlayer::changeState(PrivateState newState)
-{
- TRACE_CONTEXT(AudioPlayer::changeState, EAudioInternal);
- TRACE_ENTRY("state %d newState %d", m_state, newState);
- // TODO: add some invariants to check that the transition is valid
- const Phonon::State currentPhononState = phononState(m_state);
- const Phonon::State newPhononState = phononState(newState);
- if(currentPhononState != newPhononState)
- {
- TRACE("emit stateChanged(%d, %d)", newPhononState, currentPhononState);
- emit stateChanged(newPhononState, currentPhononState);
- }
- m_state = newState;
- TRACE_EXIT_0();
-}
-void MMF::AudioPlayer::tick()
-{
- TRACE_CONTEXT(AudioPlayer::tick, EAudioInternal);
- TRACE_ENTRY("state %d", m_state);
- emit tick(currentTime());
- TRACE_EXIT_0();
-}
diff --git a/src/3rdparty/phonon/mmf/audioplayer.h b/src/3rdparty/phonon/mmf/audioplayer.h
index f573c94..f58ee0d 100644
--- a/src/3rdparty/phonon/mmf/audioplayer.h
+++ b/src/3rdparty/phonon/mmf/audioplayer.h
@@ -19,7 +19,7 @@ along with this library. If not, see <http://www.gnu.org/licenses/>.
#ifndef PHONON_MMF_AUDIOPLAYER_H
#define PHONON_MMF_AUDIOPLAYER_H
-#include "abstractplayer.h"
+#include "abstractmediaplayer.h"
class CDrmPlayerUtility;
class TTimeIntervalMicroSeconds;
@@ -47,7 +47,7 @@ namespace Phonon
* <a href="http://wiki.forum.nokia.com/index.php/How_to_play_a_video_file_using_CVideoPlayerUtility">How to
* play a video file using CVideoPlayerUtility</a>
*/
- class AudioPlayer : public AbstractPlayer
+ class AudioPlayer : public AbstractMediaPlayer
, public MPlayerObserverType // typedef
#ifdef QT_PHONON_MMF_AUDIO_DRM
, public MAudioLoadingObserver
@@ -59,33 +59,18 @@ namespace Phonon
AudioPlayer();
virtual ~AudioPlayer();
- // AbstractPlayer
- virtual void play();
- virtual void pause();
- virtual void stop();
+ // AbstractMediaPlayer
+ virtual void doPlay();
+ virtual void doPause();
+ virtual void doStop();
+ virtual int doSetVolume(int mmfVolume);
+ virtual int openFile(RFile& file);
+ virtual void close();
+
virtual void seek(qint64 milliseconds);
- virtual qint32 tickInterval() const;
- virtual void setTickInterval(qint32 interval);
virtual bool hasVideo() const;
- virtual bool isSeekable() const;
virtual qint64 currentTime() const;
- virtual Phonon::State state() const;
- virtual QString errorString() const;
- virtual Phonon::ErrorType errorType() const;
virtual qint64 totalTime() const;
- virtual MediaSource source() const;
-
- // This is a temporary hack to work around KErrInUse from MMF
- // client utility OpenFileL calls
- //virtual void setSource(const Phonon::MediaSource &) = 0;
- virtual void setFileSource
- (const Phonon::MediaSource&, RFile&);
-
- virtual void setNextSource(const MediaSource &source);
- virtual qint32 prefinishMark() const;
- virtual void setPrefinishMark(qint32);
- virtual qint32 transitionTime() const;
- virtual void setTransitionTime(qint32);
#ifdef QT_PHONON_MMF_AUDIO_DRM
// MDrmAudioPlayerCallback
@@ -103,75 +88,17 @@ namespace Phonon
virtual void MapcPlayComplete(TInt aError);
#endif
- qreal volume() const;
- bool setVolume(qreal volume);
-
- void setAudioOutput(AudioOutput* audioOutput);
-
Q_SIGNALS:
void totalTimeChanged();
- void stateChanged(Phonon::State oldState,
- Phonon::State newState);
- void finished();
- void tick(qint64 time);
-
- private Q_SLOTS:
- /**
- * Receives signal from m_tickTimer
- */
- void tick();
+ void finished();
private:
- static qint64 toMilliSeconds(const TTimeIntervalMicroSeconds &);
-
- /**
- * Defined private state enumeration in order to add GroundState
- */
- enum PrivateState
- {
- LoadingState = Phonon::LoadingState,
- StoppedState = Phonon::StoppedState,
- PlayingState = Phonon::PlayingState,
- BufferingState = Phonon::BufferingState,
- PausedState = Phonon::PausedState,
- ErrorState = Phonon::ErrorState,
- GroundState
- };
-
- /**
- * Converts PrivateState into the corresponding Phonon::State
- */
- static Phonon::State phononState(PrivateState state);
-
- /**
- * Changes state and emits stateChanged()
- */
- void changeState(PrivateState newState);
-
/**
* Using CPlayerType typedef in order to be able to easily switch between
* CMdaAudioPlayerUtility and CDrmPlayerUtility
*/
CPlayerType* m_player;
- AudioOutput* m_audioOutput;
-
- ErrorType m_error;
-
- /**
- * Do not set this directly - call changeState() instead.
- */
- PrivateState m_state;
-
- qint32 m_tickInterval;
-
- QTimer* m_tickTimer;
-
- MediaSource m_mediaSource;
- MediaSource m_nextSource;
-
- qreal m_volume;
- int m_maxVolume;
};
}
}
diff --git a/src/3rdparty/phonon/mmf/utils.h b/src/3rdparty/phonon/mmf/utils.h
index 72d5472..51470cd 100644
--- a/src/3rdparty/phonon/mmf/utils.h
+++ b/src/3rdparty/phonon/mmf/utils.h
@@ -20,6 +20,7 @@ along with this library. If not, see <http://www.gnu.org/licenses/>.
#define PHONON_MMF_UTILS_H
#include <private/qcore_symbian_p.h>
+#include <e32debug.h> // for RDebug
namespace Phonon
{
diff --git a/src/3rdparty/phonon/mmf/videoplayer.cpp b/src/3rdparty/phonon/mmf/videoplayer.cpp
index a1cfc3c..3ffa3e7 100644
--- a/src/3rdparty/phonon/mmf/videoplayer.cpp
+++ b/src/3rdparty/phonon/mmf/videoplayer.cpp
@@ -18,560 +18,99 @@ along with this library. If not, see <http://www.gnu.org/licenses/>.
#include <QUrl>
#include <QTimer>
-#include <private/qcore_symbian_p.h>
#include "videoplayer.h"
-#include "audiooutput.h"
#include "utils.h"
using namespace Phonon;
using namespace Phonon::MMF;
//-----------------------------------------------------------------------------
-// Constants
-//-----------------------------------------------------------------------------
-
-const qint32 DefaultTickInterval = 20;
-const int NullMaxVolume = -1;
-
-
-//-----------------------------------------------------------------------------
// Constructor / destructor
//-----------------------------------------------------------------------------
-MMF::VideoPlayer::VideoPlayer() : m_audioOutput(NULL)
- , m_error(NoError)
- , m_state(GroundState)
- , m_tickInterval(DefaultTickInterval)
- , m_tickTimer(NULL)
- , m_volume(0.0)
- , m_maxVolume(NullMaxVolume)
+MMF::VideoPlayer::VideoPlayer()
{
-#if 0
TRACE_CONTEXT(VideoPlayer::VideoPlayer, EAudioApi);
TRACE_ENTRY_0();
- Q_UNUSED(parent);
-
- // TODO: should leaves be trapped in the constructor?
- m_player = CPlayerType::NewL(*this, 0, EMdaPriorityPreferenceNone);
-
- m_tickTimer = new QTimer(this);
- connect(m_tickTimer, SIGNAL(timeout()), this, SLOT(tick()));
+ // TODO
TRACE_EXIT_0();
-#endif
}
MMF::VideoPlayer::~VideoPlayer()
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::~VideoPlayer, EAudioApi);
- TRACE_ENTRY_0();
-
- delete m_tickTimer;
- delete m_player;
-
- TRACE_EXIT_0();
-#endif
+ // TODO
}
//-----------------------------------------------------------------------------
-// VideoPlayerInterface
+// Public API
//-----------------------------------------------------------------------------
-void MMF::VideoPlayer::play()
+void MMF::VideoPlayer::doPlay()
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::play, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- switch(m_state)
- {
- case GroundState:
- case LoadingState:
- // Is this the correct error? Really we want 'NotReadyError'
- m_error = NormalError;
- changeState(ErrorState);
- break;
-
- case StoppedState:
- case PausedState:
- m_player->Play();
- m_tickTimer->start(m_tickInterval);
- changeState(PlayingState);
- break;
-
- case PlayingState:
- case BufferingState:
- case ErrorState:
- // Do nothing
- break;
-
- // Protection against adding new states and forgetting to update this switch
- default:
- TRACE_PANIC(InvalidStatePanic);
- }
-
- TRACE_EXIT("state %d", m_state);
-#endif
+ // TODO
}
-void MMF::VideoPlayer::pause()
+void MMF::VideoPlayer::doPause()
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::pause, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- switch(m_state)
- {
- case GroundState:
- case LoadingState:
- case StoppedState:
- case PausedState:
- case ErrorState:
- // Do nothing
- break;
-
- case PlayingState:
- case BufferingState:
- m_player->Pause();
- m_tickTimer->stop();
- changeState(PausedState);
- break;
-
- // Protection against adding new states and forgetting to update this switch
- default:
- TRACE_PANIC(InvalidStatePanic);
- }
-
- TRACE_EXIT("state %d", m_state);
-#endif
+ // TODO
}
-void MMF::VideoPlayer::stop()
+void MMF::VideoPlayer::doStop()
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::stop, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- switch(m_state)
- {
- case GroundState:
- case LoadingState:
- case StoppedState:
- case ErrorState:
- // Do nothing
- break;
-
- case PlayingState:
- case BufferingState:
- case PausedState:
- m_player->Stop();
- m_tickTimer->stop();
- changeState(StoppedState);
- break;
-
- // Protection against adding new states and forgetting to update this switch
- default:
- TRACE_PANIC(InvalidStatePanic);
- }
-
- TRACE_EXIT("state %d", m_state);
-#endif
+ // TODO
}
-void MMF::VideoPlayer::seek(qint64 ms)
+int MMF::VideoPlayer::doSetVolume(int mmfVolume)
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::seek, EAudioApi);
- TRACE_ENTRY("state %d pos %Ld", m_state, ms);
-
- m_player->SetPosition(TTimeIntervalMicroSeconds(ms));
-
- TRACE_EXIT_0();
-#endif
-}
-
-qint32 MMF::VideoPlayer::tickInterval() const
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::tickInterval, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- TRACE_RETURN("%d", m_tickInterval);
-#endif
+ // TODO
+ Q_UNUSED(mmfVolume);
+ return KErrNotSupported;
}
-void MMF::VideoPlayer::setTickInterval(qint32 interval)
+int MMF::VideoPlayer::openFile(RFile& file)
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::setTickInterval, EAudioApi);
- TRACE_ENTRY("state %d m_interval %d interval %d", m_state, m_tickInterval, interval);
-
- m_tickInterval = interval;
- m_tickTimer->setInterval(interval);
-
- TRACE_EXIT_0();
-#endif
+ // TODO
+ Q_UNUSED(file);
+ return KErrNotSupported;
}
-bool MMF::VideoPlayer::hasVideo() const
+void MMF::VideoPlayer::close()
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::hasVideo, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- // TODO: re-factor this class so that audio playback and video playback are
- // delegated to separate classes, which internally hoat a
- // CMdaVideoPlayerUtility / CVideoPlayerUtility instance as appropriate.
- TRACE_RETURN("%d", false);
-#endif
}
-bool MMF::VideoPlayer::isSeekable() const
+void MMF::VideoPlayer::seek(qint64 ms)
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::isSeekable, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- TRACE_RETURN("%d", true);
-#endif
+ // TODO
+ Q_UNUSED(ms);
}
-Phonon::State MMF::VideoPlayer::state() const
+bool MMF::VideoPlayer::hasVideo() const
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::state, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- const Phonon::State result = phononState(m_state);
-
- TRACE_RETURN("%d", result);
-#endif
+ return true;
}
qint64 MMF::VideoPlayer::currentTime() const
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::currentTime, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- TTimeIntervalMicroSeconds us;
- const TInt err = m_player->GetPosition(us);
-
- qint64 result = -1;
-
- if(KErrNone == err) {
- result = toMilliSeconds(us);
- }
-
- TRACE_RETURN("%Ld", result);
-#endif
-}
-
-QString MMF::VideoPlayer::errorString() const
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::errorString, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- TRACE_EXIT_0();
- // TODO: put in proper error strings
- QString result;
- return result;
-#endif
-}
-
-Phonon::ErrorType MMF::VideoPlayer::errorType() const
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::errorType, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- const Phonon::ErrorType result = (ErrorState == m_state)
- ? m_error : NoError;
-
- TRACE_RETURN("%d", result);
-#endif
+ // TODO
+ return 0;
}
qint64 MMF::VideoPlayer::totalTime() const
{
-#if 0
- TRACE_CONTEXT(VideoPlayer::totalTime, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- const qint64 result = toMilliSeconds(m_player->Duration());
-
- TRACE_RETURN("%Ld", result);
-#endif
-}
-
-MediaSource MMF::VideoPlayer::source() const
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::source, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- TRACE_EXIT_0();
- return m_mediaSource;
-#endif
-}
-
-void MMF::VideoPlayer::setFileSource(const MediaSource &source, RFile&)
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::setSource, EAudioApi);
- TRACE_ENTRY("state %d source.type %d", m_state, source.type());
-
- m_player->Close();
- changeState(GroundState);
-
- // TODO: is it correct to assign even if the media type is not supported in
- // the switch statement below?
- m_mediaSource = source;
-
- TInt symbianErr = KErrNone;
-
- switch(m_mediaSource.type())
- {
- case MediaSource::LocalFile:
- {
- // TODO: work out whose responsibility it is to ensure that paths
- // are Symbian-style, i.e. have backslashes for path delimiters.
- // Until then, use this utility function...
- const QHBufC filename = Utils::symbianFilename(m_mediaSource.fileName());
- TRAP(symbianErr, m_player->OpenFileL(*filename));
- break;
- }
-
- case MediaSource::Url:
- {
- const QHBufC filename(m_mediaSource.url().toString());
- TRAP(symbianErr, m_player->OpenUrlL(*filename));
- break;
- }
-
- case MediaSource::Invalid:
- case MediaSource::Disc:
- case MediaSource::Stream:
- symbianErr = KErrNotSupported;
- break;
-
- case MediaSource::Empty:
- TRACE_EXIT_0();
- return;
-
- // Protection against adding new media types and forgetting to update this switch
- default:
- TRACE_PANIC(InvalidMediaTypePanic);
- }
-
- if(KErrNone == symbianErr)
- {
-#ifdef QT_PHONON_MMF_AUDIO_DRM
- // There appears to be a bug in the CDrmPlayerUtility implementation (at least
- // in S60 5.x) whereby the player does not check whether the loading observer
- // pointer is null before dereferencing it. Therefore we must register for
- // loading notification, even though we do nothing in the callback functions.
- m_player->RegisterForAudioLoadingNotification(*this);
-#endif
- changeState(LoadingState);
- }
- else
- {
- // TODO: do something with the value of symbianErr?
- m_error = NormalError;
- changeState(ErrorState);
- }
-
- TRACE_EXIT_0();
-#endif
-}
-
-void MMF::VideoPlayer::setNextSource(const MediaSource &source)
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::setNextSource, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- // TODO: handle 'next source'
-
- m_nextSource = source;
- Q_UNUSED(source);
-
- TRACE_EXIT_0();
-#endif
-}
-
-qint32 MMF::VideoPlayer::prefinishMark() const
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::prefinishMark, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- // TODO: implement prefinish mark
- const qint32 result = 0;
- TRACE_RETURN("%d", result);
-#endif
-}
-
-void MMF::VideoPlayer::setPrefinishMark(qint32 mark)
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::setPrefinishMark, EAudioApi);
- TRACE_ENTRY("state %d mark %d", m_state, mark);
- Q_UNUSED(mark); // to silence warnings in release builds
-
- // TODO: implement prefinish mark
-
- TRACE_EXIT_0();
-#endif
-}
-
-qint32 MMF::VideoPlayer::transitionTime() const
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::transitionTime, EAudioApi);
- TRACE_ENTRY("state %d", m_state);
-
- // TODO: implement transition time
- const qint32 result = 0;
- TRACE_RETURN("%d", result);
-#endif
-}
-
-void MMF::VideoPlayer::setTransitionTime(qint32 time)
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::setTransitionTime, EAudioApi);
- TRACE_ENTRY("state %d time %d", m_state, time);
- Q_UNUSED(time); // to silence warnings in release builds
-
- // TODO: implement transition time
-
- TRACE_EXIT_0();
-#endif
-}
-
-
-//-----------------------------------------------------------------------------
-// Volume
-//-----------------------------------------------------------------------------
-
-qreal MMF::VideoPlayer::volume() const
-{
- //return m_volume;
-}
-
-bool MMF::VideoPlayer::setVolume(qreal volume)
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::setVolume, EAudioInternal);
- TRACE_ENTRY("state %d", m_state);
-
- bool volumeChanged = false;
-
- switch(m_state)
- {
- case GroundState:
- case LoadingState:
- case ErrorState:
- // Do nothing
- break;
-
- case StoppedState:
- case PausedState:
- case PlayingState:
- case BufferingState:
- {
- if(volume != m_volume)
- {
- const int err = m_player->SetVolume(volume * m_maxVolume);
- if(KErrNone == err)
- {
- m_volume = volume;
- volumeChanged = true;
- }
- else
- {
- m_error = NormalError;
- changeState(ErrorState);
- }
- }
- break;
- }
-
- // Protection against adding new states and forgetting to update this
- // switch
- default:
- TRACE_PANIC(InvalidStatePanic);
- }
-
- TRACE_RETURN("%d", volumeChanged);
-#endif
-}
-
-void MMF::VideoPlayer::setAudioOutput(AudioOutput* audioOutput)
-{
- //m_audioOutput = audioOutput;
+ // TODO
+ return 0;
}
//-----------------------------------------------------------------------------
-// Private functions
+// Symbian multimedia client observer callbacks
//-----------------------------------------------------------------------------
-qint64 MMF::VideoPlayer::toMilliSeconds(const TTimeIntervalMicroSeconds &in)
-{
- //return in.Int64() / 1000;
-}
-
-Phonon::State MMF::VideoPlayer::phononState(PrivateState state)
-{
-#if 0
- const Phonon::State phononState =
- GroundState == state
- ? Phonon::StoppedState
- : static_cast<Phonon::State>(state);
-
- return phononState;
-#endif
-}
-
-void MMF::VideoPlayer::changeState(PrivateState newState)
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::changeState, EAudioInternal);
- TRACE_ENTRY("state %d newState %d", m_state, newState);
-
- // TODO: add some invariants to check that the transition is valid
-
- const Phonon::State currentPhononState = phononState(m_state);
- const Phonon::State newPhononState = phononState(newState);
- if(currentPhononState != newPhononState)
- {
- TRACE("emit stateChanged(%d, %d)", newPhononState, currentPhononState);
- emit stateChanged(newPhononState, currentPhononState);
- }
+// TODO
- m_state = newState;
- TRACE_EXIT_0();
-#endif
-}
-
-void MMF::VideoPlayer::tick()
-{
-#if 0
- TRACE_CONTEXT(VideoPlayer::tick, EAudioInternal);
- TRACE_ENTRY("state %d", m_state);
-
- emit tick(currentTime());
-
- TRACE_EXIT_0();
-#endif
-}
diff --git a/src/3rdparty/phonon/mmf/videoplayer.h b/src/3rdparty/phonon/mmf/videoplayer.h
index a880966..65133c2 100644
--- a/src/3rdparty/phonon/mmf/videoplayer.h
+++ b/src/3rdparty/phonon/mmf/videoplayer.h
@@ -22,7 +22,7 @@ along with this library. If not, see <http://www.gnu.org/licenses/>.
/* We use the extra qualification include/ to avoid picking up the include
* Phonon has. */
#include <include/videoplayer.h>
-#include "abstractplayer.h"
+#include "abstractmediaplayer.h"
#include <Phonon/MediaSource>
@@ -42,7 +42,7 @@ namespace Phonon
* <a href="http://wiki.forum.nokia.com/index.php/How_to_play_a_video_file_using_CVideoPlayerUtility">How to
* play a video file using CVideoPlayerUtility</a>
*/
- class VideoPlayer : public AbstractPlayer
+ class VideoPlayer : public AbstractMediaPlayer
{
Q_OBJECT
public:
@@ -50,102 +50,24 @@ namespace Phonon
virtual ~VideoPlayer();
// AbstractPlayer
- virtual void play();
- virtual void pause();
- virtual void stop();
+ virtual void doPlay();
+ virtual void doPause();
+ virtual void doStop();
+ virtual int doSetVolume(int mmfVolume);
+ virtual int openFile(RFile& file);
+ virtual void close();
+
virtual void seek(qint64 milliseconds);
- virtual qint32 tickInterval() const;
- virtual void setTickInterval(qint32 interval);
virtual bool hasVideo() const;
- virtual bool isSeekable() const;
virtual qint64 currentTime() const;
- virtual Phonon::State state() const;
- virtual QString errorString() const;
- virtual Phonon::ErrorType errorType() const;
virtual qint64 totalTime() const;
- virtual MediaSource source() const;
-
- // This is a temporary hack to work around KErrInUse from MMF
- // client utility OpenFileL calls
- //virtual void setSource(const Phonon::MediaSource &);
- virtual void setFileSource
- (const Phonon::MediaSource&, RFile&);
- virtual void setNextSource(const MediaSource &source);
- virtual qint32 prefinishMark() const;
- virtual void setPrefinishMark(qint32);
- virtual qint32 transitionTime() const;
- virtual void setTransitionTime(qint32);
-
- qreal volume() const;
- bool setVolume(qreal volume);
-
- void setAudioOutput(AudioOutput* audioOutput);
-
Q_SIGNALS:
void totalTimeChanged();
void stateChanged(Phonon::State oldState,
Phonon::State newState);
void finished();
- void tick(qint64 time);
-
- private Q_SLOTS:
- /**
- * Receives signal from m_tickTimer
- */
- void tick();
-
- private:
- static qint64 toMilliSeconds(const TTimeIntervalMicroSeconds &);
-
- /**
- * Defined private state enumeration in order to add GroundState
- */
- enum PrivateState
- {
- LoadingState = Phonon::LoadingState,
- StoppedState = Phonon::StoppedState,
- PlayingState = Phonon::PlayingState,
- BufferingState = Phonon::BufferingState,
- PausedState = Phonon::PausedState,
- ErrorState = Phonon::ErrorState,
- GroundState
- };
-
- /**
- * Converts PrivateState into the corresponding Phonon::State
- */
- static Phonon::State phononState(PrivateState state);
-
- /**
- * Changes state and emits stateChanged()
- */
- void changeState(PrivateState newState);
-
- /**
- * Using CPlayerType typedef in order to be able to easily switch between
- * CMdaVideoPlayerUtility and CDrmPlayerUtility
- */
- // CPlayerType* m_player; TODO
-
- AudioOutput* m_audioOutput;
-
- ErrorType m_error;
-
- /**
- * Do not set this directly - call changeState() instead.
- */
- PrivateState m_state;
-
- qint32 m_tickInterval;
-
- QTimer* m_tickTimer;
-
- MediaSource m_mediaSource;
- MediaSource m_nextSource;
- qreal m_volume;
- int m_maxVolume;
};
}
}
diff --git a/src/plugins/phonon/mmf/mmf.pro b/src/plugins/phonon/mmf/mmf.pro
index 0f00832..040a6a7 100644
--- a/src/plugins/phonon/mmf/mmf.pro
+++ b/src/plugins/phonon/mmf/mmf.pro
@@ -21,21 +21,23 @@ phonon_mmf_audio_drm {
LIBS += -lmediaclientaudio.lib
}
-HEADERS += \
- $$PHONON_MMF_DIR/abstractplayer.h \
- $$PHONON_MMF_DIR/audiooutput.h \
- $$PHONON_MMF_DIR/audioplayer.h \
- $$PHONON_MMF_DIR/backend.h \
- $$PHONON_MMF_DIR/mediaobject.h \
- $$PHONON_MMF_DIR/utils.h \
+HEADERS += \
+ $$PHONON_MMF_DIR/abstractplayer.h \
+ $$PHONON_MMF_DIR/abstractmediaplayer.h \
+ $$PHONON_MMF_DIR/audiooutput.h \
+ $$PHONON_MMF_DIR/audioplayer.h \
+ $$PHONON_MMF_DIR/backend.h \
+ $$PHONON_MMF_DIR/mediaobject.h \
+ $$PHONON_MMF_DIR/utils.h \
$$PHONON_MMF_DIR/videoplayer.h
-SOURCES += \
- $$PHONON_MMF_DIR/audiooutput.cpp \
- $$PHONON_MMF_DIR/audioplayer.cpp \
- $$PHONON_MMF_DIR/backend.cpp \
- $$PHONON_MMF_DIR/mediaobject.cpp \
- $$PHONON_MMF_DIR/utils.cpp \
+SOURCES += \
+ $$PHONON_MMF_DIR/abstractmediaplayer.cpp \
+ $$PHONON_MMF_DIR/audiooutput.cpp \
+ $$PHONON_MMF_DIR/audioplayer.cpp \
+ $$PHONON_MMF_DIR/backend.cpp \
+ $$PHONON_MMF_DIR/mediaobject.cpp \
+ $$PHONON_MMF_DIR/utils.cpp \
$$PHONON_MMF_DIR/videoplayer.cpp
LIBS += -lefsrv # For file server
generated by cgit v0.12 at 2025-09-08 16:43:27 (GMT)