diff -r 000000000000 -r 1918ee327afb src/3rdparty/phonon/gstreamer/backend.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/3rdparty/phonon/gstreamer/backend.cpp	Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,455 @@
+/*  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 "common.h"
+#include "backend.h"
+#include "audiooutput.h"
+#include "audioeffect.h"
+#include "mediaobject.h"
+#include "videowidget.h"
+#include "devicemanager.h"
+#include "effectmanager.h"
+#include "message.h"
+#include "volumefadereffect.h"
+#include <gst/interfaces/propertyprobe.h>
+
+#include <QtCore/QSet>
+#include <QtCore/QVariant>
+#include <QtCore/QtPlugin>
+
+QT_BEGIN_NAMESPACE
+
+Q_EXPORT_PLUGIN2(phonon_gstreamer, Phonon::Gstreamer::Backend)
+
+namespace Phonon
+{
+namespace Gstreamer
+{
+
+class MediaNode;
+
+Backend::Backend(QObject *parent, const QVariantList &)
+        : QObject(parent)
+        , m_deviceManager(0)
+        , m_effectManager(0)
+        , m_debugLevel(Warning)
+        , m_isValid(false)
+{
+    GError *err = 0;
+    bool wasInit = gst_init_check(0, 0, &err);  //init gstreamer: must be called before any gst-related functions
+    if (err)
+        g_error_free(err);
+
+    qRegisterMetaType<Message>("Message");
+
+    setProperty("identifier",     QLatin1String("phonon_gstreamer"));
+    setProperty("backendName",    QLatin1String("Gstreamer"));
+    setProperty("backendComment", QLatin1String("Gstreamer plugin for Phonon"));
+    setProperty("backendVersion", QLatin1String("0.2"));
+    setProperty("backendWebsite", QLatin1String("http://qt.nokia.com/"));
+
+    //check if we should enable debug output
+    QString debugLevelString = qgetenv("PHONON_GST_DEBUG");
+    int debugLevel = debugLevelString.toInt();
+    if (debugLevel > 3) //3 is maximum
+        debugLevel = 3;
+    m_debugLevel = (DebugLevel)debugLevel;
+
+    if (wasInit) {
+        m_isValid = checkDependencies();
+        gchar *versionString = gst_version_string();
+        logMessage(QString("Using %0").arg(versionString));
+        g_free(versionString);
+    }
+    if (!m_isValid)
+        qWarning("Phonon::GStreamer::Backend: Failed to initialize GStreamer");
+
+    m_deviceManager = new DeviceManager(this);
+    m_effectManager = new EffectManager(this);
+}
+
+Backend::~Backend() 
+{
+    gst_deinit();
+}
+
+gboolean Backend::busCall(GstBus *bus, GstMessage *msg, gpointer data)
+{
+    Q_UNUSED(bus);
+    Q_ASSERT(msg);
+
+    MediaObject *mediaObject = static_cast<MediaObject*>(data);
+    Q_ASSERT(mediaObject);
+
+    Message message(msg, mediaObject);
+    QMetaObject::invokeMethod(mediaObject->backend(), "handleBusMessage", Qt::QueuedConnection, Q_ARG(Message, message));
+
+    return true;
+}
+
+/***
+ * !reimp
+ */
+QObject *Backend::createObject(BackendInterface::Class c, QObject *parent, const QList<QVariant> &args)
+{
+    // Return nothing if dependencies are not met
+
+    switch (c) {
+    case MediaObjectClass:
+        return new MediaObject(this, parent);
+
+    case AudioOutputClass: {
+            AudioOutput *ao = new AudioOutput(this, parent);
+            m_audioOutputs.append(ao);
+            return ao;
+        }
+    case EffectClass:
+        return new AudioEffect(this, args[0].toInt(), parent);
+
+    case AudioDataOutputClass:
+        logMessage("createObject() : AudioDataOutput not implemented");
+        break;
+
+    case VideoDataOutputClass:
+        logMessage("createObject() : VideoDataOutput not implemented");
+        break;
+
+    case VideoWidgetClass: {
+            QWidget *widget =  qobject_cast<QWidget*>(parent);
+            return new VideoWidget(this, widget);
+        }
+
+    case VolumeFaderEffectClass:
+        return new VolumeFaderEffect(this, parent);
+
+    case VisualizationClass:  //Fall through
+    default:
+        logMessage("createObject() : Backend object not available");
+    }
+    return 0;
+}
+
+// Returns true if all dependencies are met
+// and gstreamer is usable, otherwise false
+bool Backend::isValid() const
+{
+    return m_isValid;
+}
+
+bool Backend::supportsVideo() const
+{
+    return isValid();
+}
+
+bool Backend::checkDependencies() const
+{
+    bool success = false;
+    // Verify that gst-plugins-base is installed
+    GstElementFactory *acFactory = gst_element_factory_find ("audioconvert");
+    if (acFactory) {
+        gst_object_unref(acFactory);
+        success = true;
+        // Check if gst-plugins-good is installed
+        GstElementFactory *csFactory = gst_element_factory_find ("videobalance");
+        if (csFactory) {
+            gst_object_unref(csFactory);
+        } else {
+            QString message = tr("Warning: You do not seem to have the package gstreamer0.10-plugins-good installed.\n"
+                                 "          Some video features have been disabled.");
+            qDebug() << message;
+        }
+    } else {
+        qWarning() << tr("Warning: You do not seem to have the base GStreamer plugins installed.\n"
+                         "          All audio and video support has been disabled");
+    }
+    return success;
+}
+
+/***
+ * !reimp
+ */
+QStringList Backend::availableMimeTypes() const
+{
+    QStringList availableMimeTypes;
+
+    if (!isValid())
+        return availableMimeTypes;
+
+    GstElementFactory *mpegFactory;
+    // Add mp3 as a separate mime type as people are likely to look for it.
+    if ((mpegFactory = gst_element_factory_find ("ffmpeg")) || 
+        (mpegFactory = gst_element_factory_find ("mad"))) {
+        availableMimeTypes << QLatin1String("audio/x-mp3");
+        gst_object_unref(GST_OBJECT(mpegFactory));
+    }
+
+    // Iterate over all audio and video decoders and extract mime types from sink caps
+    GList* factoryList = gst_registry_get_feature_list(gst_registry_get_default (), GST_TYPE_ELEMENT_FACTORY);
+    for (GList* iter = g_list_first(factoryList) ; iter != NULL ; iter = g_list_next(iter)) {
+        GstPluginFeature *feature = GST_PLUGIN_FEATURE(iter->data);
+        QString klass = gst_element_factory_get_klass(GST_ELEMENT_FACTORY(feature));
+
+        if (klass == QLatin1String("Codec/Decoder/Audio") || 
+            klass == QLatin1String("Codec/Decoder/Video")) {
+
+            const GList *static_templates;
+            GstElementFactory *factory = GST_ELEMENT_FACTORY(feature);
+            static_templates = gst_element_factory_get_static_pad_templates(factory);
+
+            for (; static_templates != NULL ; static_templates = static_templates->next) {
+                GstStaticPadTemplate *padTemplate = (GstStaticPadTemplate *) static_templates->data;
+                if (padTemplate && padTemplate->direction == GST_PAD_SINK) {
+                    GstCaps *caps = gst_static_pad_template_get_caps (padTemplate);
+
+                    if (caps) {
+                        const GstStructure* capsStruct = gst_caps_get_structure (caps, 0);
+                        QString mime = QString::fromUtf8(gst_structure_get_name (capsStruct));
+                        if (!availableMimeTypes.contains(mime))
+                              availableMimeTypes.append(mime);
+                    }
+                }
+            }
+        }
+    }
+    g_list_free(factoryList);
+    availableMimeTypes.sort();
+    return availableMimeTypes;
+}
+
+/***
+ * !reimp
+ */
+QList<int> Backend::objectDescriptionIndexes(ObjectDescriptionType type) const
+{
+    QList<int> list;
+
+    if (!isValid())
+        return list;
+
+    switch (type) {
+    case Phonon::AudioOutputDeviceType: {
+            QList<AudioDevice> deviceList = deviceManager()->audioOutputDevices();
+            for (int dev = 0 ; dev < deviceList.size() ; ++dev)
+                list.append(deviceList[dev].id);
+            break;
+        }
+        break;
+
+    case Phonon::EffectType: {
+            QList<EffectInfo*> effectList = effectManager()->audioEffects();
+            for (int eff = 0 ; eff < effectList.size() ; ++eff)
+                list.append(eff);
+            break;
+        }
+        break;
+    default:
+        break;
+    }
+    return list;
+}
+
+/***
+ * !reimp
+ */
+QHash<QByteArray, QVariant> Backend::objectDescriptionProperties(ObjectDescriptionType type, int index) const
+{
+
+    QHash<QByteArray, QVariant> ret;
+
+    if (!isValid())
+        return ret;
+
+    switch (type) {
+    case Phonon::AudioOutputDeviceType: {
+            QList<AudioDevice> audioDevices = deviceManager()->audioOutputDevices();
+            if (index >= 0 && index < audioDevices.size()) {
+                ret.insert("name", audioDevices[index].gstId);
+                ret.insert("description", audioDevices[index].description);
+                ret.insert("icon", QLatin1String("audio-card"));
+            }
+        }
+        break;
+
+    case Phonon::EffectType: {
+            QList<EffectInfo*> effectList = effectManager()->audioEffects();
+            if (index >= 0 && index <= effectList.size()) {
+                const EffectInfo *effect = effectList[index];
+                ret.insert("name", effect->name());
+                ret.insert("description", effect->description());
+                ret.insert("author", effect->author());
+            } else
+                Q_ASSERT(1); // Since we use list position as ID, this should not happen
+        }
+    default:
+        break;
+    }
+    return ret;
+}
+
+/***
+ * !reimp
+ */
+bool Backend::startConnectionChange(QSet<QObject *> objects)
+{
+    foreach (QObject *object, objects) {
+        MediaNode *sourceNode = qobject_cast<MediaNode *>(object);
+        MediaObject *media = sourceNode->root();
+        if (media) {
+            media->saveState();
+            return true;
+        }
+    }
+    return true;
+}
+
+/***
+ * !reimp
+ */
+bool Backend::connectNodes(QObject *source, QObject *sink)
+{
+    if (isValid()) {
+        MediaNode *sourceNode = qobject_cast<MediaNode *>(source);
+        MediaNode *sinkNode = qobject_cast<MediaNode *>(sink);
+        if (sourceNode && sinkNode) {
+            if (sourceNode->connectNode(sink)) {
+                sourceNode->root()->invalidateGraph();
+                logMessage(QString("Backend connected %0 to %1").arg(source->metaObject()->className()).arg(sink->metaObject()->className()));
+                return true;
+            }
+        }
+    }
+    logMessage(QString("Linking %0 to %1 failed").arg(source->metaObject()->className()).arg(sink->metaObject()->className()), Warning);
+    return false;
+}
+
+/***
+ * !reimp
+ */
+bool Backend::disconnectNodes(QObject *source, QObject *sink)
+{
+    MediaNode *sourceNode = qobject_cast<MediaNode *>(source);
+    MediaNode *sinkNode = qobject_cast<MediaNode *>(sink);
+
+    if (sourceNode && sinkNode)
+        return sourceNode->disconnectNode(sink);
+    else
+        return false;
+}
+
+/***
+ * !reimp
+ */
+bool Backend::endConnectionChange(QSet<QObject *> objects)
+{
+    foreach (QObject *object, objects) {
+        MediaNode *sourceNode = qobject_cast<MediaNode *>(object);
+        MediaObject *media = sourceNode->root();
+        if (media) {
+            media->resumeState();
+            return true;
+        }
+    }
+    return true;
+}
+
+/***
+ * Request bus messages for this mediaobject
+ */
+void Backend::addBusWatcher(MediaObject* node)
+{
+    Q_ASSERT(node);
+    GstBus *bus = gst_pipeline_get_bus (GST_PIPELINE(node->pipeline()));
+    gst_bus_add_watch (bus, busCall, node);
+    gst_object_unref(bus);
+}
+
+/***
+ * Ignore bus messages for this mediaobject
+ */
+void Backend::removeBusWatcher(MediaObject* node)
+{
+    Q_ASSERT(node);
+    g_source_remove_by_user_data(node);
+}
+
+/***
+ * Polls each mediaobject's pipeline and delivers
+ * pending any pending messages
+ */
+void Backend::handleBusMessage(Message message)
+{
+    MediaObject *mediaObject = message.source();
+    mediaObject->handleBusMessage(message);
+}
+
+DeviceManager* Backend::deviceManager() const
+{
+    return m_deviceManager;
+}
+
+EffectManager* Backend::effectManager() const
+{
+    return m_effectManager;
+}
+
+/**
+ * Returns a debuglevel that is determined by the
+ * PHONON_GSTREAMER_DEBUG environment variable.
+ *
+ *  Warning - important warnings
+ *  Info    - general info
+ *  Debug   - gives extra info
+ */
+Backend::DebugLevel Backend::debugLevel() const
+{
+    return m_debugLevel;
+}
+
+/***
+ * Prints a conditional debug message based on the current debug level
+ * If obj is provided, classname and objectname will be printed as well
+ *
+ * see debugLevel()
+ */
+void Backend::logMessage(const QString &message, int priority, QObject *obj) const
+{
+    if (debugLevel() > 0) {
+        QString output;
+        if (obj) {
+            // Strip away namespace from className
+            QString className(obj->metaObject()->className());
+            int nameLength = className.length() - className.lastIndexOf(':') - 1;
+            className = className.right(nameLength);
+            output.sprintf("%s %s (%s %p)", message.toLatin1().constData(), 
+                                          obj->objectName().toLatin1().constData(), 
+                                          className.toLatin1().constData(), obj);
+        }
+        else {
+            output = message;
+        }
+        if (priority <= (int)debugLevel()) {
+            qDebug() << QString("PGST(%1): %2").arg(priority).arg(output);
+        }
+    }
+}
+
+}
+}
+
+QT_END_NAMESPACE
+
+#include "moc_backend.cpp"