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

Timestamp:

Mar 8, 2010, 12:52:58 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.2 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/3rdparty/phonon/mmf/abstractaudioeffect.cpp (modified) (3 diffs)
• src/3rdparty/phonon/mmf/abstractaudioeffect.h (modified) (6 diffs)
• src/3rdparty/phonon/mmf/abstractplayer.h (modified) (2 diffs)
• src/3rdparty/phonon/mmf/audioequalizer.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/audioequalizer.h (modified) (2 diffs)
• src/3rdparty/phonon/mmf/backend.cpp (modified) (4 diffs)
• src/3rdparty/phonon/mmf/backend.h (modified) (2 diffs)
• src/3rdparty/phonon/mmf/bassboost.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/bassboost.h (modified) (3 diffs)
• src/3rdparty/phonon/mmf/effectfactory.cpp (modified) (2 diffs)
• src/3rdparty/phonon/mmf/effectfactory.h (modified) (4 diffs)
• src/3rdparty/phonon/mmf/effectparameter.cpp (copied) (copied from branches/vendor/nokia/qt/4.6.2/src/3rdparty/phonon/mmf/effectparameter.cpp )
• src/3rdparty/phonon/mmf/effectparameter.h (copied) (copied from branches/vendor/nokia/qt/4.6.2/src/3rdparty/phonon/mmf/effectparameter.h )
• src/3rdparty/phonon/mmf/environmentalreverb.cpp (copied) (copied from branches/vendor/nokia/qt/4.6.2/src/3rdparty/phonon/mmf/environmentalreverb.cpp )
• src/3rdparty/phonon/mmf/environmentalreverb.h (copied) (copied from branches/vendor/nokia/qt/4.6.2/src/3rdparty/phonon/mmf/environmentalreverb.h )
• src/3rdparty/phonon/mmf/loudness.cpp (copied) (copied from branches/vendor/nokia/qt/4.6.2/src/3rdparty/phonon/mmf/loudness.cpp )
• src/3rdparty/phonon/mmf/loudness.h (copied) (copied from branches/vendor/nokia/qt/4.6.2/src/3rdparty/phonon/mmf/loudness.h )
• src/3rdparty/phonon/mmf/mediaobject.cpp (modified) (1 diff)
• src/3rdparty/phonon/mmf/mediaobject.h (modified) (3 diffs)
• src/3rdparty/phonon/mmf/mmf_medianode.h (modified) (1 diff)
• src/3rdparty/phonon/mmf/stereowidening.cpp (copied) (copied from branches/vendor/nokia/qt/4.6.2/src/3rdparty/phonon/mmf/stereowidening.cpp )
• src/3rdparty/phonon/mmf/stereowidening.h (copied) (copied from branches/vendor/nokia/qt/4.6.2/src/3rdparty/phonon/mmf/stereowidening.h )
• src/3rdparty/phonon/mmf/utils.h (modified) (1 diff)
• src/3rdparty/phonon/mmf/videooutput.h (modified) (1 diff)
• src/3rdparty/phonon/mmf/videowidget.h (modified) (1 diff)

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

@@ -38 +38 @@
 AbstractAudioEffect::AbstractAudioEffect(QObject *parent,
                                          const QList<EffectParameter> &params)
-    :   MediaNode::MediaNode(parent)
+    :   MediaNode(parent)
+    ,   m_params(params)
     ,   m_player(0)
-    ,   m_params(params)
 {
+
 }
 
-QList<EffectParameter> AbstractAudioEffect::parameters() const
+QList<Phonon::EffectParameter> AbstractAudioEffect::parameters() const
 {
-    return m_params;
+    // Convert from QList<MMF::EffectParameter> to QList<Phonon::EffectParameter>
+    QList<Phonon::EffectParameter> result;
+    EffectParameter param;
+    foreach (param, m_params)
+        result += param;
+    return result;
 }
 
-QVariant AbstractAudioEffect::parameterValue(const EffectParameter &queriedParam) const
+QVariant AbstractAudioEffect::parameterValue(const Phonon::EffectParameter &queriedParam) const
 {
     const QVariant &val = m_values.value(queriedParam.id());
@@ -59 +65 @@
 }
 
-void AbstractAudioEffect::setParameterValue(const EffectParameter &param,
+void AbstractAudioEffect::setParameterValue(const Phonon::EffectParameter &param,
                                             const QVariant &newValue)
 {
     m_values.insert(param.id(), newValue);
-    parameterChanged(param.id(), newValue);
-    // TODO: handle audio effect errors
-    TRAP_IGNORE(m_effect->ApplyL());
+
+    if (m_effect.data()) {
+        const EffectParameter& internalParam = internalParameter(param.id());
+        int err = parameterChanged(internalParam, newValue);
+        // TODO: handle audio effect errors
+        Q_UNUSED(err);
+    }
+}
+
+void AbstractAudioEffect::abstractPlayerChanged(AbstractPlayer *player)
+{
+    m_player = qobject_cast<AbstractMediaPlayer *>(player);
+    m_effect.reset();
+}
+
+void AbstractAudioEffect::stateChanged(Phonon::State newState,
+                                       Phonon::State oldState)
+{
+    if (Phonon::LoadingState == oldState
+        && Phonon::LoadingState != newState)
+        createEffect();
 }
 
@@ -73 +97 @@
     Q_ASSERT_X(!m_effect.data(), Q_FUNC_INFO, "Effect already created");
 
-    AbstractMediaPlayer *const player =
-        qobject_cast<AbstractMediaPlayer *>(mediaObject->abstractPlayer());
+    abstractPlayerChanged(mediaObject->abstractPlayer());
 
-    if (player) {
-        m_player = player;
+    connect(mediaObject, SIGNAL(stateChanged(Phonon::State, Phonon::State)),
+            SLOT(stateChanged(Phonon::State, Phonon::State)));
 
-        if (AudioPlayer *audioPlayer = qobject_cast<AudioPlayer *>(player)) {
-            connectAudioPlayer(audioPlayer->nativePlayer());
-            applyParameters();
-            // TODO: handle audio effect errors
-            TRAP_IGNORE(m_effect->EnableL());
+    connect(mediaObject, SIGNAL(abstractPlayerChanged(AbstractPlayer *)),
+            SLOT(abstractPlayerChanged(AbstractPlayer *)));
+
+    if (mediaObject->state() != Phonon::LoadingState)
+        createEffect();
+}
+
+void AbstractAudioEffect::disconnectMediaObject(MediaObject *mediaObject)
+{
+    mediaObject->disconnect(this);
+    abstractPlayerChanged(0);
+}
+
+void AbstractAudioEffect::setEnabled(bool enabled)
+{
+    TInt err = KErrNone;
+
+    if (enabled)
+        // TODO: handle audio effect errors
+        TRAP(err, m_effect->EnableL())
+    else
+        // TODO: handle audio effect errors
+        TRAP(err, m_effect->DisableL())
+
+    Q_UNUSED(err);
+}
+
+void AbstractAudioEffect::createEffect()
+{
+    Q_ASSERT_X(m_player, Q_FUNC_INFO, "Invalid media player pointer");
+
+    if (AudioPlayer *audioPlayer = qobject_cast<AudioPlayer *>(m_player)) {
+        createEffect(audioPlayer->nativePlayer());
+    }
+
+    if (m_effect.data()) {
+        EffectParameter param;
+        int err = 0;
+        foreach (param, m_params) {
+            const QVariant value = parameterValue(param);
+            err = parameterChanged(param, value);
         }
+        Q_UNUSED(err)
     }
 }
 
-void AbstractAudioEffect::disconnectMediaObject(MediaObject * /*mediaObject*/)
+const MMF::EffectParameter& AbstractAudioEffect::internalParameter(int id) const
 {
-    m_player = 0;
-    m_effect.reset();
+    const EffectParameter *result = 0;
+    for (int i=0; i<m_params.count() && !result; ++i) {
+        if (m_params[i].id() == id)
+            result = &m_params[i];
+    }
+    Q_ASSERT_X(result, Q_FUNC_INFO, "Parameter not found");
+    return *result;
 }
+
+int AbstractAudioEffect::parameterChanged(const EffectParameter &param,
+            const QVariant &value)
+{
+    int err = 0;
+
+    switch (param.id()) {
+    case ParameterEnable:
+        setEnabled(value.toBool());
+        break;
+    default:
+        {
+        const EffectParameter& internalParam = internalParameter(param.id());
+        err = effectParameterChanged(internalParam, value);
+        }
+        break;
+    }
+
+    if (!err)
+        TRAP(err, m_effect->ApplyL());
+
+    return err;
+}
+
+int AbstractAudioEffect::effectParameterChanged(
+    const EffectParameter &param, const QVariant &value)
+{
+    // Default implementation
+    Q_ASSERT_X(false, Q_FUNC_INFO, "Effect has no parameters");
+    return 0;
+}
+
 
 QT_END_NAMESPACE

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

@@ -24 +24 @@
 #include <AudioEffectBase.h>
 
-#include <Phonon/effectinterface.h>
-#include <Phonon/effectparameter.h>
+#include <phonon/effectinterface.h>
 
 #include "audioplayer.h"
+#include "effectparameter.h"
 #include "mmf_medianode.h"
 #include "mmf_videoplayer.h"
+
+class CMdaAudioOutputStream;
 
 QT_BEGIN_NAMESPACE
@@ -37 +39 @@
 namespace MMF
 {
+class AbstractPlayer;
 class AbstractMediaPlayer;
 
@@ -64 +67 @@
                         const QList<EffectParameter> &params);
 
-    virtual QList<EffectParameter> parameters() const;
-    virtual QVariant parameterValue(const EffectParameter &param) const;
-    virtual void setParameterValue(const EffectParameter &,
+    // Phonon::EffectInterface
+    virtual QList<Phonon::EffectParameter> parameters() const;
+    virtual QVariant parameterValue(const Phonon::EffectParameter &param) const;
+    virtual void setParameterValue(const Phonon::EffectParameter &,
                                    const QVariant &newValue);
 
-    enum Type
+    // Parameters which are shared by all effects
+    enum CommonParameters
     {
-        EffectAudioEqualizer = 1,
-        EffectBassBoost,
-        EffectDistanceAttenuation,
-        EffectEnvironmentalReverb,
-        EffectListenerOrientation,
-        EffectLoudness,
-        EffectSourceOrientation,
-        EffectStereoWidening
+        ParameterEnable = 0,
+        ParameterBase // must be last entry in enum
     };
+
+public Q_SLOTS:
+    void abstractPlayerChanged(AbstractPlayer *player);
+    void stateChanged(Phonon::State newState,
+                      Phonon::State oldState);
 
 protected:
@@ -86 +90 @@
     void disconnectMediaObject(MediaObject *mediaObject);
 
-    virtual void connectAudioPlayer(AudioPlayer::NativePlayer *player) = 0;
-    virtual void applyParameters() = 0;
+    virtual void createEffect(AudioPlayer::NativePlayer *player) = 0;
 
-    virtual void parameterChanged(const int id,
-                                  const QVariant &value) = 0;
+    // Effect-specific parameter changed
+    virtual int effectParameterChanged(const EffectParameter &param,
+                                  const QVariant &value);
+
+private:
+    void createEffect();
+    void setEnabled(bool enabled);
+    const EffectParameter& internalParameter(int id) const;
+    int parameterChanged(const EffectParameter &param,
+            const QVariant &value);
 
 protected:
@@ -96 +107 @@
 
 private:
+    const QList<EffectParameter>    m_params;
     AbstractMediaPlayer *           m_player;
-    const QList<EffectParameter>    m_params;
     QHash<int, QVariant>            m_values;
 };
@@ -104 +115 @@
 }
 
+
+// Macro for defining functions which depend on the native class name
+// for each of the effects.  Using this reduces repetition of boilerplate
+// in the implementations of the backend effect nodes.
+
+#define PHONON_MMF_DEFINE_EFFECT_FUNCTIONS(Effect)                      \
+                                                                        \
+void Effect##::createEffect(AudioPlayer::NativePlayer *player)          \
+{                                                                       \
+    C##Effect *ptr = 0;                                                 \
+    QT_TRAP_THROWING(ptr = C##Effect::NewL(*player));                   \
+    m_effect.reset(ptr);                                                \
+}                                                                       \
+                                                                        \
+C##Effect* Effect::concreteEffect()                                     \
+{                                                                       \
+    return static_cast<C##Effect *>(m_effect.data());                   \
+}
+
 QT_END_NAMESPACE
 

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

@@ -20 +20 @@
 #define PHONON_MMF_ABSTRACTPLAYER_H
 
-#include <Phonon/phononnamespace.h>
-#include <Phonon/mediasource.h>
+#include <phonon/phononnamespace.h>
+#include <phonon/mediasource.h>
 
 #include <QObject>
@@ -107 +107 @@
     void tick(qint64 time);
     void bufferStatus(int percentFilled);
-    void stateChanged(Phonon::State oldState,
-                      Phonon::State newState);
+    void stateChanged(Phonon::State newState,
+                      Phonon::State oldState);
     void metaDataChanged(const QMultiMap<QString, QString>& metaData);
     void aboutToFinish();

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

@@ -29 +29 @@
 */
 
-AudioEqualizer::AudioEqualizer(QObject *parent) : AbstractAudioEffect::AbstractAudioEffect(parent, createParams())
+// Define functions which depend on concrete native effect class name
+PHONON_MMF_DEFINE_EFFECT_FUNCTIONS(AudioEqualizer)
+
+AudioEqualizer::AudioEqualizer(QObject *parent, const QList<EffectParameter>& parameters)
+    :   AbstractAudioEffect::AbstractAudioEffect(parent, parameters)
 {
+
 }
 
-void AudioEqualizer::parameterChanged(const int pid,
+int AudioEqualizer::effectParameterChanged(const EffectParameter &param,
                                       const QVariant &value)
 {
-    if (m_effect.data()) {
-        const int band = pid;
-        const int level = value.toInt();
-        setBandLevel(band, level);
-    }
+    const int band = param.id() - ParameterBase + 1;
+
+    const qreal externalLevel = value.toReal();
+    const int internalLevel = param.toInternalValue(externalLevel);
+
+    TRAPD(err, concreteEffect()->SetBandLevelL(band, internalLevel));
+    return err;
 }
 
-void AudioEqualizer::connectAudioPlayer(AudioPlayer::NativePlayer *player)
+
+//-----------------------------------------------------------------------------
+// Static functions
+//-----------------------------------------------------------------------------
+
+const char* AudioEqualizer::description()
 {
-    CAudioEqualizer *ptr = 0;
-    QT_TRAP_THROWING(ptr = CAudioEqualizer::NewL(*player));
-    m_effect.reset(ptr);
+    return "Audio equalizer";
 }
 
-void AudioEqualizer::applyParameters()
+bool AudioEqualizer::getParameters(CMdaAudioOutputStream *stream,
+    QList<EffectParameter>& parameters)
 {
-    if (m_effect.data()) {
-        EffectParameter param;
-        foreach (param, parameters()) {
-            const int band = param.id();
-            const int level = parameterValue(param).toInt();
-            setBandLevel(band, level);
+    bool supported = false;
+
+    QScopedPointer<CAudioEqualizer> effect;
+    TRAPD(err, effect.reset(CAudioEqualizer::NewL(*stream)));
+
+    if (KErrNone == err) {
+        supported = true;
+
+        TInt32 dbMin;
+        TInt32 dbMax;
+        effect->DbLevelLimits(dbMin, dbMax);
+
+        const int bandCount = effect->NumberOfBands();
+
+        for (int i = 0; i < bandCount; ++i) {
+            // For some reason, band IDs are 1-based, as opposed to the
+            // 0-based indices used in just about other Symbian API...!
+            const int band = i + 1;
+
+            const qint32 hz = effect->CenterFrequency(band);
+
+            // We pass a floating-point parameter range of -1.0 to +1.0 for
+            // each band in order to work around a limitation in
+            // Phonon::EffectWidget.  See documentation of EffectParameter
+            // for more details.
+            EffectParameter param(
+                 /* parameterId */        ParameterBase + i,
+                 /* name */               tr("%1 Hz").arg(hz),
+                 /* hints */              EffectParameter::LogarithmicHint,
+                 /* defaultValue */       QVariant(qreal(0.0)),
+                 /* minimumValue */       QVariant(qreal(-1.0)),
+                 /* maximumValue */       QVariant(qreal(+1.0)));
+
+            param.setInternalRange(dbMin, dbMax);
+            parameters.append(param);
         }
     }
-}
 
-void AudioEqualizer::setBandLevel(int band, int level)
-{
-    CAudioEqualizer *const effect = static_cast<CAudioEqualizer *>(m_effect.data());
-    // TODO: handle audio effect errors
-    TRAP_IGNORE(effect->SetBandLevelL(band, level));
-}
-
-QList<EffectParameter> AudioEqualizer::createParams()
-{
-    QList<EffectParameter> retval;
-
-    // We temporarily create an AudioPlayer, and run the effect on it, so
-    // we can extract the readonly data we need.
-    AudioPlayer dummyPlayer;
-
-    CAudioEqualizer *eqPtr = 0;
-    QT_TRAP_THROWING(eqPtr = CAudioEqualizer::NewL(*dummyPlayer.nativePlayer()));
-    QScopedPointer<CAudioEqualizer> e(eqPtr);
-
-    TInt32 dbMin;
-    TInt32 dbMax;
-    e->DbLevelLimits(dbMin, dbMax);
-
-    const int bandCount = e->NumberOfBands();
-
-    for (int i = 0; i < bandCount; ++i) {
-        const qint32 hz = e->CenterFrequency(i);
-
-        const qint32 defVol = e->BandLevel(i);
-
-        retval.append(EffectParameter(i,
-                                      tr("Frequency band, %1 Hz").arg(hz),
-                                      EffectParameter::LogarithmicHint,
-                                      QVariant(qint32(defVol)),
-                                      QVariant(qint32(dbMin)),
-                                      QVariant(qint32(dbMax)),
-                                      QVariantList(),
-                                      QString()));
-    }
-
-    return retval;
+    return supported;
 }
 

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

@@ -22 +22 @@
 #include "abstractaudioeffect.h"
 
+class CAudioEqualizer;
+
 QT_BEGIN_NAMESPACE
 
@@ -40 +42 @@
     Q_OBJECT
 public:
-    AudioEqualizer(QObject *parent);
+    AudioEqualizer(QObject *parent, const QList<EffectParameter> &parameters);
+
+    // Static interface required by EffectFactory
+    static const char* description();
+    static bool getParameters(CMdaAudioOutputStream *stream,
+        QList<EffectParameter>& parameters);
 
 protected:
     // AbstractAudioEffect
-    virtual void connectAudioPlayer(AudioPlayer::NativePlayer *player);
-    virtual void applyParameters();
-    virtual void parameterChanged(const int id, const QVariant &value);
+    virtual void createEffect(AudioPlayer::NativePlayer *player);
+    virtual int effectParameterChanged(const EffectParameter &param,
+                                       const QVariant &value);
 
 private:
-    void setBandLevel(int band, int level);
-
-private:
-    static QList<EffectParameter> createParams();
+    CAudioEqualizer *concreteEffect();
 
 };

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

@@ -46 +46 @@
     : QObject(parent)
     , m_ancestorMoveMonitor(new AncestorMoveMonitor(this))
+    , m_effectFactory(new EffectFactory(this))
 {
     TRACE_CONTEXT(Backend::Backend, EBackend);
@@ -82 +83 @@
         Q_ASSERT(args.count() == 1);
         Q_ASSERT(args.first().type() == QVariant::Int);
-        const AbstractAudioEffect::Type effect = AbstractAudioEffect::Type(args.first().toInt());
-
-        return EffectFactory::createAudioEffect(effect, parent);
+        const EffectFactory::Type type =
+            static_cast<EffectFactory::Type>(args.first().toInt());
+        return m_effectFactory->createAudioEffect(type, parent);
     }
     case VideoWidgetClass:
@@ -106 +107 @@
     {
         case EffectType:
-            retval.append(EffectFactory::effectIndexes());
+            retval.append(m_effectFactory->effectIndexes());
             break;
         case AudioOutputDeviceType:
@@ -127 +128 @@
     switch (type) {
         case EffectType:
-            return EffectFactory::audioEffectDescriptions(AbstractAudioEffect::Type(index));
+            return m_effectFactory->audioEffectDescriptions(EffectFactory::Type(index));
         case AudioOutputDeviceType:
             return AudioOutput::audioOutputDescription(index);

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

@@ -21 +21 @@
 
 #include "ancestormovemonitor.h"
+#include "effectfactory.h"
 
-#include <Phonon/mediasource.h>
-#include <Phonon/backendinterface.h>
+#include <phonon/mediasource.h>
+#include <phonon/backendinterface.h>
 #include <QScopedPointer>
 
@@ -54 +55 @@
 private:
     QScopedPointer<AncestorMoveMonitor> m_ancestorMoveMonitor;
+    QScopedPointer<EffectFactory>       m_effectFactory;
 
 };

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

@@ -25 +25 @@
 using namespace Phonon::MMF;
 
+// Define functions which depend on concrete native effect class name
+PHONON_MMF_DEFINE_EFFECT_FUNCTIONS(BassBoost)
+
 /*! \class MMF::BassBoost
   \internal
 */
 
-BassBoost::BassBoost(QObject *parent) : AbstractAudioEffect::AbstractAudioEffect(parent,
-                                                                                QList<EffectParameter>())
+BassBoost::BassBoost(QObject *parent, const QList<EffectParameter> &parameters)
+    :   AbstractAudioEffect::AbstractAudioEffect(parent, parameters)
 {
+
 }
 
-void BassBoost::parameterChanged(const int,
-                                 const QVariant &)
+//-----------------------------------------------------------------------------
+// Static functions
+//-----------------------------------------------------------------------------
+
+const char* BassBoost::description()
 {
-    Q_ASSERT_X(false, Q_FUNC_INFO, "BassBoost has not parameters");
+    return "Bass boost";
 }
 
-void BassBoost::connectAudioPlayer(AudioPlayer::NativePlayer *player)
+bool BassBoost::getParameters(CMdaAudioOutputStream *stream,
+    QList<EffectParameter> &parameters)
 {
-    CBassBoost *ptr = 0;
-    QT_TRAP_THROWING(ptr = CBassBoost::NewL(*player));
-    m_effect.reset(ptr);
-}
-
-void BassBoost::applyParameters()
-{
-    // No parameters to apply
+    QScopedPointer<CBassBoost> effect;
+    TRAPD(err, effect.reset(CBassBoost::NewL(*stream)));
+    return (KErrNone == err);
 }
 

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

@@ -22 +22 @@
 #include "abstractaudioeffect.h"
 
+class CBassBoost;
+
 QT_BEGIN_NAMESPACE
 
@@ -29 +31 @@
 {
 /**
- * @short An "bass boost" effect.
- *
- * The documentation does not say what "bass boost" is, neither has it anykind
- * of setting. It's an on or off thing.
+ * @short A "bass boost" effect.
  */
 class BassBoost : public AbstractAudioEffect
@@ -38 +37 @@
     Q_OBJECT
 public:
-    BassBoost(QObject *parent);
+    BassBoost(QObject *parent, const QList<EffectParameter> &parameters);
+
+    // Static interface required by EffectFactory
+    static const char* description();
+    static bool getParameters(CMdaAudioOutputStream *stream,
+        QList<EffectParameter>& parameters);
 
 protected:
     // AbstractAudioEffect
-    virtual void connectAudioPlayer(AudioPlayer::NativePlayer *player);
-    virtual void applyParameters();
-    virtual void parameterChanged(const int id, const QVariant &value);
+    virtual void createEffect(AudioPlayer::NativePlayer *player);
+
+private:
+    CBassBoost *concreteEffect();
 
 };

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

@@ -20 +20 @@
 #include <QCoreApplication>
 
-#include <AudioEqualizerBase.h>
-#include <BassBoostBase.h>
-#include <DistanceAttenuationBase.h>
-#include <DopplerBase.h>
-#include <EnvironmentalReverbBase.h>
-#include <ListenerOrientationBase.h>
-#include <LocationBase.h>
-#include <LoudnessBase.h>
-#include <SourceOrientationBase.h>
-#include <StereoWideningBase.h>
+#include <mdaaudiooutputstream.h>
 
 #include "audioequalizer.h"
 #include "bassboost.h"
+#include "environmentalreverb.h"
+#include "loudness.h"
+#include "stereowidening.h"
 
 #include "effectfactory.h"
@@ -45 +39 @@
 */
 
-QHash<QByteArray, QVariant> EffectFactory::constructEffectDescription(const QString &name,
-                                                                      const QString &description)
-{
-    QHash<QByteArray, QVariant> retval;
-
-    retval.insert("name", name);
-    retval.insert("description", description);
-    retval.insert("available", true);
-
-    return retval;
-}
-
-
-QHash<QByteArray, QVariant> EffectFactory::audioEffectDescriptions(AbstractAudioEffect::Type type)
-{
+EffectFactory::EffectFactory(QObject *parent)
+    :   QObject(parent)
+    ,   m_initialized(false)
+{
+
+}
+
+EffectFactory::~EffectFactory()
+{
+
+}
+
+//-----------------------------------------------------------------------------
+// Public functions
+//-----------------------------------------------------------------------------
+
+AbstractAudioEffect *EffectFactory::createAudioEffect(Type type,
+                                                      QObject *parent)
+{
+    // Lazily initialize
+    if (!m_initialized)
+        initialize();
+
+    Q_ASSERT(parent);
+
+    const QList<EffectParameter>& parameters = data(type).m_parameters;
+
+    AbstractAudioEffect *effect = 0;
+
     switch (type)
     {
-        case AbstractAudioEffect::EffectAudioEqualizer:
-            return constructEffectDescription(QCoreApplication::translate("Phonon::MMF::EffectFactory", "Audio Equalizer"), "Audio equalizer.");
-        case AbstractAudioEffect::EffectBassBoost:
-            return constructEffectDescription(QCoreApplication::translate("Phonon::MMF::EffectFactory", "Bass Boost"), "Bass boost.");
-        case AbstractAudioEffect::EffectDistanceAttenuation:
-            return constructEffectDescription(QCoreApplication::translate("Phonon::MMF::EffectFactory", "Distance Attenuation"), "Distance Attenuation.");
-        case AbstractAudioEffect::EffectEnvironmentalReverb:
-            return constructEffectDescription(QCoreApplication::translate("Phonon::MMF::EffectFactory", "Environmental Reverb"), "Environmental Reverb.");
-        case AbstractAudioEffect::EffectListenerOrientation:
-            return constructEffectDescription(QCoreApplication::translate("Phonon::MMF::EffectFactory", "Environmental Reverb"), "Environmental Reverb.");
-        case AbstractAudioEffect::EffectLoudness:
-            return constructEffectDescription(QCoreApplication::translate("Phonon::MMF::EffectFactory", "Loudness"), "Loudness.");
-        case AbstractAudioEffect::EffectSourceOrientation:
-            return constructEffectDescription(QCoreApplication::translate("Phonon::MMF::EffectFactory", "Source Orientation"), "Source Orientation.");
-        case AbstractAudioEffect::EffectStereoWidening:
-            return constructEffectDescription(QCoreApplication::translate("Phonon::MMF::EffectFactory", "Stereo Widening"), "Stereo Widening.");
-    }
-
-    Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown effect type.");
-    return QHash<QByteArray, QVariant>();
-}
-
-AbstractAudioEffect *EffectFactory::createAudioEffect(AbstractAudioEffect::Type type,
-                                                      QObject *parent)
-{
-    Q_ASSERT(parent);
-
-    switch (type)
+    case TypeBassBoost:
+        effect = new BassBoost(parent, parameters);
+        break;
+    case TypeAudioEqualizer:
+        effect = new AudioEqualizer(parent, parameters);
+        break;
+    case TypeEnvironmentalReverb:
+        effect = new EnvironmentalReverb(parent, parameters);
+        break;
+    case TypeLoudness:
+        effect = new Loudness(parent, parameters);
+        break;
+    case TypeStereoWidening:
+        effect = new StereoWidening(parent, parameters);
+        break;
+
+    // Not implemented
+    case TypeDistanceAttenuation:
+    case TypeListenerOrientation:
+    case TypeSourceOrientation:
+    // Fall through
+    default:
+        Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown effect");
+    }
+
+    return effect;
+}
+
+QHash<QByteArray, QVariant> EffectFactory::audioEffectDescriptions(Type type)
+{
+    // Lazily initialize
+    if (!m_initialized)
+        initialize();
+
+    return data(type).m_descriptions;
+}
+
+QList<int> EffectFactory::effectIndexes()
+{
+    // Lazily initialize
+    if (!m_initialized)
+        initialize();
+
+    QList<int> result;
+
+    QHash<Type, EffectData>::const_iterator i = m_effectData.begin();
+    for ( ; i != m_effectData.end(); ++i)
+        if (i.value().m_supported)
+            result.append(i.key());
+
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+// Private functions
+//-----------------------------------------------------------------------------
+
+#define INITIALIZE_EFFECT(Effect) \
+    { \
+    EffectData data = getData<Effect>(); \
+    m_effectData.insert(Type##Effect, data); \
+    }
+
+void EffectFactory::initialize()
+{
+    Q_ASSERT_X(!m_initialized, Q_FUNC_INFO, "Already initialized");
+
+    INITIALIZE_EFFECT(AudioEqualizer)
+    INITIALIZE_EFFECT(BassBoost)
+    INITIALIZE_EFFECT(EnvironmentalReverb)
+    INITIALIZE_EFFECT(Loudness)
+    INITIALIZE_EFFECT(StereoWidening)
+
+    m_initialized = true;
+}
+
+// This class is just a wrapper which allows us to instantiate a
+// CMdaAudioOutputStream object.  This is done in order to allow the
+// effects API to query the DevSound implementation, to discover
+// which effects are supported and what parameters they take.
+// Ideally, we would use CMMFDevSound directly, but this class is not
+// available in the public S60 SDK.
+class OutputStreamFactory : public MMdaAudioOutputStreamCallback
+{
+public:
+    CMdaAudioOutputStream* create()
     {
-        case AbstractAudioEffect::EffectBassBoost:
-            return new BassBoost(parent);
-        case AbstractAudioEffect::EffectAudioEqualizer:
-            return new AudioEqualizer(parent);
-        case AbstractAudioEffect::EffectDistanceAttenuation:
-        case AbstractAudioEffect::EffectEnvironmentalReverb:
-        case AbstractAudioEffect::EffectListenerOrientation:
-        case AbstractAudioEffect::EffectLoudness:
-        case AbstractAudioEffect::EffectSourceOrientation:
-        case AbstractAudioEffect::EffectStereoWidening:
-            ;
-    }
-
-    Q_ASSERT_X(false, Q_FUNC_INFO, "Unknown effect.");
-    return 0;
-}
-
-template<typename TEffect>
-bool isEffectSupported()
-{
-    AudioPlayer audioPlayer;
-
-    QScopedPointer<TEffect> eff;
-    TRAPD(errorCode, eff.reset(TEffect::NewL(*audioPlayer.nativePlayer())));
-
-    return errorCode != KErrNone;
-}
-
-QList<int> EffectFactory::effectIndexes()
-{
-    QList<int> retval;
-
-    if (isEffectSupported<CAudioEqualizer>())
-        retval.append(AbstractAudioEffect::EffectAudioEqualizer);
-
-    if (isEffectSupported<CBassBoost>())
-        retval.append(AbstractAudioEffect::EffectBassBoost);
-
-    /* We haven't implemented these yet.
-    if (isEffectSupported<CDistanceAttenuation>())
-        retval.append(AbstractAudioEffect::EffectDistanceAttenuation);
-
-    if (isEffectSupported<CEnvironmentalReverb>())
-        retval.append(AbstractAudioEffect::EffectEnvironmentalReverb);
-
-    if (isEffectSupported<CLoudness>())
-        retval.append(AbstractAudioEffect::EffectLoudness);
-
-    if (isEffectSupported<CListenerOrientation>())
-        retval.append(AbstractAudioEffect::EffectListenerOrientation);
-
-    if (isEffectSupported<CSourceOrientation>())
-        retval.append(AbstractAudioEffect::EffectSourceOrientation);
-
-    if (isEffectSupported<CStereoWidening>())
-        retval.append(AbstractAudioEffect::EffectStereoWidening);
-    */
-
-    return retval;
+        CMdaAudioOutputStream* stream = 0;
+        QT_TRAP_THROWING(stream = CMdaAudioOutputStream::NewL(*this));
+        return stream;
+    }
+private:
+    void MaoscOpenComplete(TInt /*aError*/) { }
+    void MaoscBufferCopied(TInt /*aError*/, const TDesC8& /*aBuffer*/) { }
+    void MaoscPlayComplete(TInt /*aError*/) { }
+};
+
+template<typename BackendNode>
+EffectFactory::EffectData EffectFactory::getData()
+{
+    EffectData data;
+
+    // Create a temporary CMdaAudioOutputStream object, so that the effects
+    // API can query DevSound to discover which effects are supported.
+    OutputStreamFactory streamFactory;
+    QScopedPointer<CMdaAudioOutputStream> stream(streamFactory.create());
+
+    EffectParameter param(
+         /* parameterId */        AbstractAudioEffect::ParameterEnable,
+         /* name */               tr("Enabled"),
+         /* hints */              EffectParameter::ToggledHint,
+         /* defaultValue */       QVariant(bool(true)));
+    data.m_parameters.append(param);
+
+    if (data.m_supported = BackendNode::getParameters
+            (stream.data(), data.m_parameters)) {
+        const QString description = QCoreApplication::translate
+            ("Phonon::MMF::EffectFactory", BackendNode::description());
+        data.m_descriptions.insert("name", description);
+        data.m_descriptions.insert("description", description);
+        data.m_descriptions.insert("available", true);
+    }
+
+    // Sanity check to ensure that all parameter IDs are unique
+    QSet<int> ids;
+    foreach (param, data.m_parameters) {
+        Q_ASSERT_X(ids.find(param.id()) == ids.end(), Q_FUNC_INFO,
+            "Parameter list contains duplicates");
+        ids.insert(param.id());
+    }
+
+    return data;
+}
+
+const EffectFactory::EffectData& EffectFactory::data(Type type) const
+{
+    QHash<Type, EffectData>::const_iterator i = m_effectData.find(type);
+    Q_ASSERT_X(i != m_effectData.end(), Q_FUNC_INFO, "Effect data not found");
+    return i.value();
 }
 

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

@@ -21 +21 @@
 
 #include "abstractaudioeffect.h"
+#include "effectparameter.h"
 
 QT_BEGIN_NAMESPACE
@@ -32 +33 @@
  * @short Contains utility functions related to effects.
  */
-class EffectFactory
+class EffectFactory : public QObject
 {
+    Q_OBJECT
+
 public:
+    EffectFactory(QObject *parent);
+    ~EffectFactory();
+
+    enum Type
+    {
+        TypeAudioEqualizer = 0
+    ,   TypeBassBoost
+    ,   TypeDistanceAttenuation
+    ,   TypeEnvironmentalReverb
+    ,   TypeListenerOrientation
+    ,   TypeLoudness
+    ,   TypeSourceOrientation
+    ,   TypeStereoWidening
+    };
+
     /**
      * @short Creates an audio effect of type @p type.
      */
-    static AbstractAudioEffect *createAudioEffect(AbstractAudioEffect::Type type,
-                                                  QObject *parent);
+    AbstractAudioEffect *createAudioEffect(Type type, QObject *parent);
 
     /**
@@ -47 +64 @@
      * BackendInterface::objectDescriptionProperties().
      */
-    static QHash<QByteArray, QVariant> audioEffectDescriptions(AbstractAudioEffect::Type type);
+    QHash<QByteArray, QVariant> audioEffectDescriptions(Type type);
 
     /**
@@ -55 +72 @@
      * BackendInterface::objectDescriptionIndexes().
      */
-    static QList<int> effectIndexes();
+    QList<int> effectIndexes();
 
 private:
-    static inline QHash<QByteArray, QVariant> constructEffectDescription(const QString &name,
-                                                                         const QString &description);
+    void initialize();
 
-    /**
-     * This class is not supposed to be instantiated, so disable
-     * the default constructor.
-     */
-    inline EffectFactory();
-    Q_DISABLE_COPY(EffectFactory)
+    struct EffectData
+    {
+        bool                            m_supported;
+        QHash<QByteArray, QVariant>     m_descriptions;
+        QList<EffectParameter>          m_parameters;
+    };
+
+    template<typename BackendNode> EffectData getData();
+    const EffectData& data(Type type) const;
+
+private:
+    bool                                m_initialized;
+    QHash<Type, EffectData>             m_effectData;
+
 };
+
 }
 }

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

@@ -298 +298 @@
     }
 
+    if (oldPlayer)
+        emit abstractPlayerChanged(0);
     m_player.reset(newPlayer);
+    emit abstractPlayerChanged(newPlayer);
 
     if (oldPlayerHasVideo != hasVideo()) {

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

@@ -20 +20 @@
 #define PHONON_MMF_MEDIAOBJECT_H
 
-#include <Phonon/mediasource.h>
-#include <Phonon/mediaobjectinterface.h>
+#include <phonon/mediasource.h>
+#include <phonon/mediaobjectinterface.h>
 #include <QScopedPointer>
 #include <QTimer>
@@ -93 +93 @@
 
 Q_SIGNALS:
+    void abstractPlayerChanged(AbstractPlayer *player);
     void totalTimeChanged(qint64 length);
     void hasVideoChanged(bool hasVideo);
@@ -102 +103 @@
     void metaDataChanged(const QMultiMap<QString, QString>& metaData);
     void currentSourceChanged(const MediaSource& source);
-    void stateChanged(Phonon::State oldState,
-                      Phonon::State newState);
+    void stateChanged(Phonon::State newState,
+                      Phonon::State oldState);
     void finished();
     void tick(qint64 time);

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

@@ -21 +21 @@
 
 #include <QObject>
-#include <Phonon/effectinterface.h>
+#include <phonon/effectinterface.h>
 #include "audioplayer.h"
 

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

@@ -45 +45 @@
 class Utils
 {
-    Q_DECLARE_TR_FUNCTIONS(Utils)
+    Q_DECLARE_TR_FUNCTIONS(Phonon::MMF)
 
 public:

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

@@ -25 +25 @@
 #include "defs.h"
 
-#include <Phonon/videowidget.h>
+#include <phonon/videowidget.h>
 
 #include <e32std.h>

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

@@ -24 +24 @@
 
 #include <QtGui/QWidget>
-#include <Phonon/videowidget.h>
-#include <Phonon/videowidgetinterface.h>
+#include <phonon/videowidget.h>
+#include <phonon/videowidgetinterface.h>
 
 QT_BEGIN_NAMESPACE