Merge branch '4.7' of git@scm.dev.nokia.troll.no:qt/oslo-staging-2 into 4.7

Conflicts:

	doc/src/modules.qdoc
	mkspecs/common/symbian/symbian.conf
	src/gui/graphicsview/qgraphicswidget.h
	src/s60installs/bwins/QtGuiu.def
	src/s60installs/eabi/QtGuiu.def

169 files changed, 32267 insertions, 758 deletions

diff --git a/src/plugins/accessible/widgets/qaccessiblewidgets.cpp b/src/plugins/accessible/widgets/qaccessiblewidgets.cpp
index ad33d0b..499eb1d 100644
--- a/src/plugins/accessible/widgets/qaccessiblewidgets.cpp
+++ b/src/plugins/accessible/widgets/qaccessiblewidgets.cpp
@@ -176,7 +176,7 @@ static inline QWidget *mdiAreaNavigate(QWidget *area,
 
     int minimumDistance = INT_MAX;
     QWidget *target = 0;
-    foreach (QWidget *candidate, candidates.values()) {
+    foreach (QWidget *candidate, candidates) {
         switch (relation) {
         case QAccessible::Up:
         case QAccessible::Down:
diff --git a/src/plugins/bearer/bearer.pro b/src/plugins/bearer/bearer.pro
new file mode 100644
index 0000000..f95e8af
--- /dev/null
+++ b/src/plugins/bearer/bearer.pro
@@ -0,0 +1,18 @@
+TEMPLATE = subdirs
+
+contains(QT_CONFIG, dbus) {
+    contains(QT_CONFIG, icd) {
+        SUBDIRS += icd
+    } else {
+        SUBDIRS += networkmanager generic
+    }
+}
+
+#win32:SUBDIRS += nla
+win32:SUBDIRS += generic
+win32:!wince*:SUBDIRS += nativewifi
+macx:contains(QT_CONFIG, corewlan):SUBDIRS += corewlan
+macx:SUBDIRS += generic
+symbian:SUBDIRS += symbian
+
+isEmpty(SUBDIRS):SUBDIRS += generic
diff --git a/src/plugins/bearer/corewlan/corewlan.pro b/src/plugins/bearer/corewlan/corewlan.pro
new file mode 100644
index 0000000..9786c03
--- /dev/null
+++ b/src/plugins/bearer/corewlan/corewlan.pro
@@ -0,0 +1,24 @@
+TARGET = qcorewlanbearer
+include(../../qpluginbase.pri)
+
+QT += network
+LIBS += -framework Foundation -framework SystemConfiguration
+
+contains(QT_CONFIG, corewlan) {
+    isEmpty(QMAKE_MAC_SDK)|contains(QMAKE_MAC_SDK, "/Developer/SDKs/MacOSX10.6.sdk") {
+         LIBS += -framework CoreWLAN -framework Security
+         DEFINES += MAC_SDK_10_6
+    }
+}
+
+HEADERS += qcorewlanengine.h \
+           ../qnetworksession_impl.h \
+           ../qbearerengine_impl.h
+
+SOURCES += main.cpp \
+           qcorewlanengine.mm \
+           ../qnetworksession_impl.cpp
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
diff --git a/src/plugins/bearer/corewlan/main.cpp b/src/plugins/bearer/corewlan/main.cpp
new file mode 100644
index 0000000..5be8c0e
--- /dev/null
+++ b/src/plugins/bearer/corewlan/main.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcorewlanengine.h"
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QCoreWlanEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QCoreWlanEnginePlugin();
+    ~QCoreWlanEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QCoreWlanEnginePlugin::QCoreWlanEnginePlugin()
+{
+}
+
+QCoreWlanEnginePlugin::~QCoreWlanEnginePlugin()
+{
+}
+
+QStringList QCoreWlanEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("corewlan");
+}
+
+QBearerEngine *QCoreWlanEnginePlugin::create(const QString &key) const
+{
+    if (key == QLatin1String("corewlan"))
+        return new QCoreWlanEngine;
+    else
+        return 0;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QCoreWlanEnginePlugin)
+Q_EXPORT_PLUGIN2(qcorewlanbearer, QCoreWlanEnginePlugin)
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/corewlan/qcorewlanengine.h b/src/plugins/bearer/corewlan/qcorewlanengine.h
new file mode 100644
index 0000000..11f5d96
--- /dev/null
+++ b/src/plugins/bearer/corewlan/qcorewlanengine.h
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCOREWLANENGINE_H
+#define QCOREWLANENGINE_H
+
+#include "../qbearerengine_impl.h"
+
+#include <QMap>
+#include <QTimer>
+#include <SystemConfiguration/SystemConfiguration.h>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkConfigurationPrivate;
+
+class QCoreWlanEngine : public QBearerEngineImpl
+{
+    Q_OBJECT
+
+public:
+    QCoreWlanEngine(QObject *parent = 0);
+    ~QCoreWlanEngine();
+
+    QString getInterfaceFromId(const QString &id);
+    bool hasIdentifier(const QString &id);
+
+    QString bearerName(const QString &id);
+
+    void connectToId(const QString &id);
+    void disconnectFromId(const QString &id);
+
+    Q_INVOKABLE void requestUpdate();
+
+    QNetworkSession::State sessionStateForId(const QString &id);
+
+    QNetworkConfigurationManager::Capabilities capabilities() const;
+
+    QNetworkSessionPrivate *createSessionBackend();
+
+    QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+    bool requiresPolling() const;
+
+private Q_SLOTS:
+    void doRequestUpdate();
+
+private:
+    bool isWifiReady(const QString &dev);
+    QMap<QString, QString> configurationInterface;
+    QStringList scanForSsids(const QString &interfaceName);
+
+    bool isKnownSsid(const QString &ssid);
+    QList<QNetworkConfigurationPrivate *> foundConfigurations;
+
+    SCDynamicStoreRef storeSession;
+    CFRunLoopSourceRef runloopSource;
+    bool hasWifi;
+
+protected:
+    QMap<QString, QMap<QString,QString> > userProfiles;
+
+    void startNetworkChangeLoop();
+    void getUserConfigurations();
+    QString getNetworkNameFromSsid(const QString &ssid);
+    QString getSsidFromNetworkName(const QString &name);
+    QStringList foundNetwork(const QString &id, const QString &ssid, const QNetworkConfiguration::StateFlags state, const QString &interfaceName, const QNetworkConfiguration::Purpose purpose);
+};
+
+QT_END_NAMESPACE
+
+#endif
+
diff --git a/src/plugins/bearer/corewlan/qcorewlanengine.mm b/src/plugins/bearer/corewlan/qcorewlanengine.mm
new file mode 100644
index 0000000..b59ccee
--- /dev/null
+++ b/src/plugins/bearer/corewlan/qcorewlanengine.mm
@@ -0,0 +1,781 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcorewlanengine.h"
+#include "../qnetworksession_impl.h"
+
+#include <QtNetwork/private/qnetworkconfiguration_p.h>
+
+#include <QtCore/qthread.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qstringlist.h>
+
+#include <QtCore/qdebug.h>
+
+#include <QDir>
+#include <CoreWLAN/CoreWLAN.h>
+#include <CoreWLAN/CWInterface.h>
+#include <CoreWLAN/CWNetwork.h>
+#include <CoreWLAN/CWNetwork.h>
+#include <CoreWLAN/CW8021XProfile.h>
+
+#include <Foundation/NSEnumerator.h>
+#include <Foundation/NSKeyValueObserving.h>
+#include <Foundation/NSAutoreleasePool.h>
+#include <Foundation/NSLock.h>
+
+#include <SystemConfiguration/SCNetworkConfiguration.h>
+#include <private/qt_cocoa_helpers_mac_p.h>
+#include "private/qcore_mac_p.h"
+
+@interface QNSListener : NSObject
+{
+    NSNotificationCenter *center;
+    CWInterface *currentInterface;
+    QCoreWlanEngine *engine;
+    NSLock *locker;
+}
+- (void)notificationHandler;//:(NSNotification *)notification;
+- (void)remove;
+- (void)setEngine:(QCoreWlanEngine *)coreEngine;
+- (void)dealloc;
+
+@property (assign) QCoreWlanEngine* engine;
+
+@end
+
+@implementation QNSListener
+@synthesize engine;
+
+- (id) init
+{
+    [locker lock];
+    QMacCocoaAutoReleasePool pool;
+    center = [NSNotificationCenter defaultCenter];
+    currentInterface = [CWInterface interface];
+//    [center addObserver:self selector:@selector(notificationHandler:) name:kCWLinkDidChangeNotification object:nil];
+    [center addObserver:self selector:@selector(notificationHandler:) name:kCWPowerDidChangeNotification object:nil];
+    [locker unlock];
+    return self;
+}
+
+-(void)dealloc
+{
+    [super dealloc];
+}
+
+-(void)setEngine:(QCoreWlanEngine *)coreEngine
+{
+    [locker lock];
+    if(!engine)
+        engine = coreEngine;
+    [locker unlock];
+}
+
+-(void)remove
+{
+    [locker lock];
+    [center removeObserver:self];
+    [locker unlock];
+}
+
+- (void)notificationHandler//:(NSNotification *)notification
+{
+    engine->requestUpdate();
+}
+@end
+
+QNSListener *listener = 0;
+
+QT_BEGIN_NAMESPACE
+
+void networkChangeCallback(SCDynamicStoreRef/* store*/, CFArrayRef changedKeys, void *info)
+{
+    for ( long i = 0; i < CFArrayGetCount(changedKeys); i++) {
+
+        QString changed =  QCFString::toQString((CFStringRef)CFArrayGetValueAtIndex(changedKeys, i));
+        if( changed.contains("/Network/Global/IPv4")) {
+            QCoreWlanEngine* wlanEngine = static_cast<QCoreWlanEngine*>(info);
+            wlanEngine->requestUpdate();
+        }
+    }
+    return;
+}
+
+QCoreWlanEngine::QCoreWlanEngine(QObject *parent)
+:   QBearerEngineImpl(parent)
+{
+    startNetworkChangeLoop();
+
+    QMacCocoaAutoReleasePool pool;
+    if([[CWInterface supportedInterfaces] count] > 0 && !listener) {
+        listener = [[QNSListener alloc] init];
+        listener.engine = this;
+        hasWifi = true;
+    } else {
+        hasWifi = false;
+    }
+    requestUpdate();
+}
+
+QCoreWlanEngine::~QCoreWlanEngine()
+{
+    while (!foundConfigurations.isEmpty())
+        delete foundConfigurations.takeFirst();
+    [listener remove];
+    [listener release];
+}
+
+QString QCoreWlanEngine::getInterfaceFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    return configurationInterface.value(id);
+}
+
+bool QCoreWlanEngine::hasIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    return configurationInterface.contains(id);
+}
+
+void QCoreWlanEngine::connectToId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+    QMacCocoaAutoReleasePool pool;
+    QString interfaceString = getInterfaceFromId(id);
+
+    CWInterface *wifiInterface =
+        [CWInterface interfaceWithName: qt_mac_QStringToNSString(interfaceString)];
+
+    if ([wifiInterface power]) {
+        NSError *err = nil;
+        NSMutableDictionary *params = [NSMutableDictionary dictionaryWithCapacity:0];
+
+        QString wantedSsid;
+
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+        const QString idHash = QString::number(qHash(QLatin1String("corewlan:") + ptr->name));
+        const QString idHash2 = QString::number(qHash(QLatin1String("corewlan:") + getNetworkNameFromSsid(ptr->name)));
+
+        bool using8021X = false;
+        if (idHash2 != id) {
+            NSArray *array = [CW8021XProfile allUser8021XProfiles];
+
+            for (NSUInteger i = 0; i < [array count]; ++i) {
+                const QString networkNameHashCheck = QString::number(qHash(QLatin1String("corewlan:") + qt_mac_NSStringToQString([[array objectAtIndex:i] userDefinedName])));
+
+                const QString ssidHash = QString::number(qHash(QLatin1String("corewlan:") + qt_mac_NSStringToQString([[array objectAtIndex:i] ssid])));
+
+                if (id == networkNameHashCheck || id == ssidHash) {
+                    const QString thisName = getSsidFromNetworkName(id);
+                    if (thisName.isEmpty())
+                        wantedSsid = id;
+                    else
+                        wantedSsid = thisName;
+
+                    [params setValue: [array objectAtIndex:i] forKey:kCWAssocKey8021XProfile];
+                    using8021X = true;
+                    break;
+                }
+            }
+        }
+
+        if (!using8021X) {
+            QString wantedNetwork;
+            QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
+            while (i.hasNext()) {
+                i.next();
+                wantedNetwork = i.key();
+                const QString networkNameHash = QString::number(qHash(QLatin1String("corewlan:") + wantedNetwork));
+                if (id == networkNameHash) {
+                    wantedSsid =  getSsidFromNetworkName(wantedNetwork);
+                    break;
+                }
+            }
+        }
+        NSDictionary *scanParameters = [NSDictionary dictionaryWithObjectsAndKeys:
+                                        [NSNumber numberWithBool:YES], kCWScanKeyMerge,
+                                        [NSNumber numberWithInteger:100], kCWScanKeyRestTime,
+                                        qt_mac_QStringToNSString(wantedSsid), kCWScanKeySSID,
+                                        nil];
+
+        NSArray *scanArray = [NSArray arrayWithArray:[wifiInterface scanForNetworksWithParameters:scanParameters error:&err]];
+
+        if(!err) {
+            for(uint row=0; row < [scanArray count]; row++ ) {
+                CWNetwork *apNetwork = [scanArray objectAtIndex:row];
+
+                if(wantedSsid == qt_mac_NSStringToQString([apNetwork ssid])) {
+
+                    if(!using8021X) {
+                        SecKeychainAttribute attributes[3];
+
+                        NSString *account = [apNetwork ssid];
+                        NSString *keyKind = @"AirPort network password";
+                        NSString *keyName = account;
+
+                        attributes[0].tag = kSecAccountItemAttr;
+                        attributes[0].data = (void *)[account UTF8String];
+                        attributes[0].length = [account length];
+
+                        attributes[1].tag = kSecDescriptionItemAttr;
+                        attributes[1].data = (void *)[keyKind UTF8String];
+                        attributes[1].length = [keyKind length];
+
+                        attributes[2].tag = kSecLabelItemAttr;
+                        attributes[2].data = (void *)[keyName UTF8String];
+                        attributes[2].length = [keyName length];
+
+                        SecKeychainAttributeList attributeList = {3,attributes};
+
+                        SecKeychainSearchRef searchRef;
+                        SecKeychainSearchCreateFromAttributes(NULL, kSecGenericPasswordItemClass, &attributeList, &searchRef);
+
+                        NSString *password = @"";
+                        SecKeychainItemRef searchItem;
+
+                        if (SecKeychainSearchCopyNext(searchRef, &searchItem) == noErr) {
+                            UInt32 realPasswordLength;
+                            SecKeychainAttribute attributesW[8];
+                            attributesW[0].tag = kSecAccountItemAttr;
+                            SecKeychainAttributeList listW = {1,attributesW};
+                            char *realPassword;
+                            OSStatus status = SecKeychainItemCopyContent(searchItem, NULL, &listW, &realPasswordLength,(void **)&realPassword);
+
+                            if (status == noErr) {
+                                if (realPassword != NULL) {
+
+                                    QByteArray pBuf;
+                                    pBuf.resize(realPasswordLength);
+                                    pBuf.prepend(realPassword);
+                                    pBuf.insert(realPasswordLength,'\0');
+
+                                    password = [NSString stringWithUTF8String:pBuf];
+                                }
+                                SecKeychainItemFreeContent(&listW, realPassword);
+                            }
+
+                            CFRelease(searchItem);
+                        } else {
+                            qDebug() << "SecKeychainSearchCopyNext error";
+                        }
+                        [params setValue: password forKey: kCWAssocKeyPassphrase];
+                    } // end using8021X
+
+
+                    bool result = [wifiInterface associateToNetwork: apNetwork parameters:[NSDictionary dictionaryWithDictionary:params] error:&err];
+
+                    if(!err) {
+                        if(!result) {
+                            emit connectionError(id, ConnectError);
+                        } else {
+                            return;
+                        }
+                    } else {
+                        qDebug() <<"associate ERROR"<<  qt_mac_NSStringToQString([err localizedDescription ]);
+                    }
+                }
+            } //end scan network
+        } else {
+            qDebug() <<"scan ERROR"<<  qt_mac_NSStringToQString([err localizedDescription ]);
+        }
+        emit connectionError(id, InterfaceLookupError);
+    }
+
+    locker.unlock();
+    emit connectionError(id, InterfaceLookupError);
+}
+
+void QCoreWlanEngine::disconnectFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QString interfaceString = getInterfaceFromId(id);
+    QMacCocoaAutoReleasePool pool;
+
+    CWInterface *wifiInterface =
+        [CWInterface interfaceWithName: qt_mac_QStringToNSString(interfaceString)];
+
+    [wifiInterface disassociate];
+    if ([[wifiInterface interfaceState]intValue] != kCWInterfaceStateInactive) {
+        locker.unlock();
+        emit connectionError(id, DisconnectionError);
+        locker.relock();
+    }
+}
+
+void QCoreWlanEngine::requestUpdate()
+{
+    getUserConfigurations();
+    doRequestUpdate();
+}
+
+void QCoreWlanEngine::doRequestUpdate()
+{
+    QMutexLocker locker(&mutex);
+
+    QMacCocoaAutoReleasePool pool;
+
+    QStringList previous = accessPointConfigurations.keys();
+
+    NSArray *wifiInterfaces = [CWInterface supportedInterfaces];
+    for (uint row = 0; row < [wifiInterfaces count]; ++row) {
+        foreach (const QString &interface,
+                 scanForSsids(qt_mac_NSStringToQString([wifiInterfaces objectAtIndex:row]))) {
+            previous.removeAll(interface);
+        }
+    }
+
+    while (!previous.isEmpty()) {
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(previous.takeFirst());
+
+        configurationInterface.remove(ptr->id);
+
+        locker.unlock();
+        emit configurationRemoved(ptr);
+        locker.relock();
+    }
+
+    locker.unlock();
+    emit updateCompleted();
+}
+
+QStringList QCoreWlanEngine::scanForSsids(const QString &interfaceName)
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList found;
+
+    if(!hasWifi) {
+        return found;
+    }
+    QMacCocoaAutoReleasePool pool;
+
+    CWInterface *currentInterface = [CWInterface interfaceWithName:qt_mac_QStringToNSString(interfaceName)];
+    QStringList addedConfigs;
+
+    if([currentInterface power]) {
+        NSError *err = nil;
+        NSDictionary *parametersDict =  [NSDictionary dictionaryWithObjectsAndKeys:
+                                   [NSNumber numberWithBool:YES], kCWScanKeyMerge,
+                                   [NSNumber numberWithInt:kCWScanTypeFast], kCWScanKeyScanType, // get the networks in the scan cache
+                                   [NSNumber numberWithInteger:100], kCWScanKeyRestTime, nil];
+        NSArray* apArray = [currentInterface scanForNetworksWithParameters:parametersDict error:&err];
+        CWNetwork *apNetwork;
+
+        if (!err) {
+
+            for(uint row=0; row < [apArray count]; row++ ) {
+                apNetwork = [apArray objectAtIndex:row];
+
+                const QString networkSsid = qt_mac_NSStringToQString([apNetwork ssid]);
+
+                const QString id = QString::number(qHash(QLatin1String("corewlan:") + networkSsid));
+                found.append(id);
+
+                QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
+                bool known = isKnownSsid(networkSsid);
+                if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
+                    if( networkSsid == qt_mac_NSStringToQString( [currentInterface ssid])) {
+                        state = QNetworkConfiguration::Active;
+                    }
+                }
+                if(state == QNetworkConfiguration::Undefined) {
+                    if(known) {
+                        state = QNetworkConfiguration::Discovered;
+                    } else {
+                        state = QNetworkConfiguration::Undefined;
+                    }
+                }
+                QNetworkConfiguration::Purpose purpose = QNetworkConfiguration::UnknownPurpose;
+                if([[apNetwork securityMode] intValue] == kCWSecurityModeOpen) {
+                    purpose = QNetworkConfiguration::PublicPurpose;
+                } else {
+                    purpose = QNetworkConfiguration::PrivatePurpose;
+                }
+
+                found.append(foundNetwork(id, networkSsid, state, interfaceName, purpose));
+
+            } //end row
+        } //end error
+    } // endwifi power
+
+    // add known configurations that are not around.
+    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
+    while (i.hasNext()) {
+        i.next();
+
+        QString networkName = i.key();
+        const QString id = QString::number(qHash(QLatin1String("corewlan:") + networkName));
+
+        if(!found.contains(id)) {
+            QString networkSsid = getSsidFromNetworkName(networkName);
+            const QString ssidId = QString::number(qHash(QLatin1String("corewlan:") + networkSsid));
+            QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
+            QString interfaceName;
+            QMapIterator<QString, QString> ij(i.value());
+            while (ij.hasNext()) {
+                ij.next();
+                interfaceName = ij.value();
+            }
+
+            if( [currentInterface.interfaceState intValue] == kCWInterfaceStateRunning) {
+                if( networkSsid == qt_mac_NSStringToQString([currentInterface ssid])) {
+                    state = QNetworkConfiguration::Active;
+                }
+            }
+            if(state == QNetworkConfiguration::Undefined) {
+                if( userProfiles.contains(networkName)
+                    && found.contains(ssidId)) {
+                    state = QNetworkConfiguration::Discovered;
+                }
+            }
+
+            if(state == QNetworkConfiguration::Undefined) {
+                state = QNetworkConfiguration::Defined;
+            }
+
+            found.append(foundNetwork(id, networkName, state, interfaceName, QNetworkConfiguration::UnknownPurpose));
+        }
+    }
+    return found;
+}
+
+QStringList QCoreWlanEngine::foundNetwork(const QString &id, const QString &name, const QNetworkConfiguration::StateFlags state, const QString &interfaceName, const QNetworkConfiguration::Purpose purpose)
+{
+    QStringList found;
+    QMutexLocker locker(&mutex);
+    if (accessPointConfigurations.contains(id)) {
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+        bool changed = false;
+
+        ptr->mutex.lock();
+
+        if (!ptr->isValid) {
+            ptr->isValid = true;
+            changed = true;
+        }
+
+        if (ptr->name != name) {
+            ptr->name = name;
+            changed = true;
+        }
+
+        if (ptr->id != id) {
+            ptr->id = id;
+            changed = true;
+        }
+
+        if (ptr->state != state) {
+            ptr->state = state;
+            changed = true;
+        }
+
+        if (ptr->purpose != purpose) {
+            ptr->purpose = purpose;
+            changed = true;
+        }
+        ptr->mutex.unlock();
+
+        if (changed) {
+            locker.unlock();
+            emit configurationChanged(ptr);
+            locker.relock();
+        }
+        found.append(id);
+    } else {
+        QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
+
+        ptr->name = name;
+        ptr->isValid = true;
+        ptr->id = id;
+        ptr->state = state;
+        ptr->type = QNetworkConfiguration::InternetAccessPoint;
+        ptr->bearer = QLatin1String("WLAN");
+        ptr->purpose = purpose;
+
+        accessPointConfigurations.insert(ptr->id, ptr);
+        configurationInterface.insert(ptr->id, interfaceName);
+
+        locker.unlock();
+        emit configurationAdded(ptr);
+        locker.relock();
+       found.append(id);
+    }
+    return found;
+}
+
+bool QCoreWlanEngine::isWifiReady(const QString &wifiDeviceName)
+{
+    QMutexLocker locker(&mutex);
+
+    if(hasWifi) {
+        QMacCocoaAutoReleasePool pool;
+        CWInterface *defaultInterface = [CWInterface interfaceWithName: qt_mac_QStringToNSString(wifiDeviceName)];
+        if([defaultInterface power])
+            return true;
+    }
+    return false;
+}
+
+bool QCoreWlanEngine::isKnownSsid(const QString &ssid)
+{
+    QMutexLocker locker(&mutex);
+
+    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
+    while (i.hasNext()) {
+        i.next();
+        QMap<QString,QString> map = i.value();
+        if(map.keys().contains(ssid)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+QNetworkSession::State QCoreWlanEngine::sessionStateForId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+    if (!ptr)
+        return QNetworkSession::Invalid;
+
+    if (!ptr->isValid) {
+        return QNetworkSession::Invalid;
+    } else if ((ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+        return QNetworkSession::Connected;
+    } else if ((ptr->state & QNetworkConfiguration::Discovered) ==
+                QNetworkConfiguration::Discovered) {
+        return QNetworkSession::Disconnected;
+    } else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) {
+        return QNetworkSession::NotAvailable;
+    } else if ((ptr->state & QNetworkConfiguration::Undefined) ==
+                QNetworkConfiguration::Undefined) {
+        return QNetworkSession::NotAvailable;
+    }
+
+    return QNetworkSession::Invalid;
+}
+
+QNetworkConfigurationManager::Capabilities QCoreWlanEngine::capabilities() const
+{
+    return QNetworkConfigurationManager::ForcedRoaming;
+}
+
+void QCoreWlanEngine::startNetworkChangeLoop()
+{
+    storeSession = NULL;
+
+    SCDynamicStoreContext dynStoreContext = { 0, this/*(void *)storeSession*/, NULL, NULL, NULL };
+    storeSession = SCDynamicStoreCreate(NULL,
+                                 CFSTR("networkChangeCallback"),
+                                 networkChangeCallback,
+                                 &dynStoreContext);
+    if (!storeSession ) {
+        qWarning() << "could not open dynamic store: error:" << SCErrorString(SCError());
+        return;
+    }
+
+    CFMutableArrayRef notificationKeys;
+    notificationKeys = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
+    CFMutableArrayRef patternsArray;
+    patternsArray = CFArrayCreateMutable(NULL, 0, &kCFTypeArrayCallBacks);
+
+    CFStringRef storeKey;
+    storeKey = SCDynamicStoreKeyCreateNetworkGlobalEntity(NULL,
+                                                     kSCDynamicStoreDomainState,
+                                                     kSCEntNetIPv4);
+    CFArrayAppendValue(notificationKeys, storeKey);
+    CFRelease(storeKey);
+
+    storeKey = SCDynamicStoreKeyCreateNetworkServiceEntity(NULL,
+                                                      kSCDynamicStoreDomainState,
+                                                      kSCCompAnyRegex,
+                                                      kSCEntNetIPv4);
+    CFArrayAppendValue(patternsArray, storeKey);
+    CFRelease(storeKey);
+
+    if (!SCDynamicStoreSetNotificationKeys(storeSession , notificationKeys, patternsArray)) {
+        qWarning() << "register notification error:"<< SCErrorString(SCError());
+        CFRelease(storeSession );
+        CFRelease(notificationKeys);
+        CFRelease(patternsArray);
+        return;
+    }
+    CFRelease(notificationKeys);
+    CFRelease(patternsArray);
+
+    runloopSource = SCDynamicStoreCreateRunLoopSource(NULL, storeSession , 0);
+    if (!runloopSource) {
+        qWarning() << "runloop source error:"<< SCErrorString(SCError());
+        CFRelease(storeSession );
+        return;
+    }
+
+    CFRunLoopAddSource(CFRunLoopGetCurrent(), runloopSource, kCFRunLoopDefaultMode);
+    return;
+}
+
+QNetworkSessionPrivate *QCoreWlanEngine::createSessionBackend()
+{
+    return new QNetworkSessionPrivateImpl;
+}
+
+QNetworkConfigurationPrivatePointer QCoreWlanEngine::defaultConfiguration()
+{
+    return QNetworkConfigurationPrivatePointer();
+}
+
+bool QCoreWlanEngine::requiresPolling() const
+{
+    return true;
+}
+
+QString QCoreWlanEngine::getSsidFromNetworkName(const QString &name)
+{
+    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
+    while (i.hasNext()) {
+        i.next();
+        QMap<QString,QString> map = i.value();
+        QMapIterator<QString, QString> ij(i.value());
+         while (ij.hasNext()) {
+             ij.next();
+             const QString networkNameHash = QString::number(qHash(QLatin1String("corewlan:") +i.key()));
+             if(name == i.key() || name == networkNameHash) {
+                 return ij.key();
+             }
+        }
+    }
+    return QString();
+}
+
+QString QCoreWlanEngine::getNetworkNameFromSsid(const QString &ssid)
+{
+    QMapIterator<QString, QMap<QString,QString> > i(userProfiles);
+    while (i.hasNext()) {
+        i.next();
+        QMap<QString,QString> map = i.value();
+        QMapIterator<QString, QString> ij(i.value());
+         while (ij.hasNext()) {
+             ij.next();
+             if(ij.key() == ssid) {
+                 return i.key();
+             }
+         }
+    }
+    return QString();
+}
+
+
+void QCoreWlanEngine::getUserConfigurations()
+{
+    QMacCocoaAutoReleasePool pool;
+    userProfiles.clear();
+
+    NSArray *wifiInterfaces = [CWInterface supportedInterfaces];
+    for(uint row=0; row < [wifiInterfaces count]; row++ ) {
+
+        CWInterface *wifiInterface = [CWInterface interfaceWithName: [wifiInterfaces objectAtIndex:row]];
+        NSString *nsInterfaceName = [wifiInterface name];
+// add user configured system networks
+        SCDynamicStoreRef dynRef = SCDynamicStoreCreate(kCFAllocatorSystemDefault, (CFStringRef)@"Qt corewlan", nil, nil);
+        NSDictionary * airportPlist = (NSDictionary *)SCDynamicStoreCopyValue(dynRef, (CFStringRef)[NSString stringWithFormat:@"Setup:/Network/Interface/%@/AirPort", nsInterfaceName]);
+        CFRelease(dynRef);
+
+        NSDictionary *prefNetDict = [airportPlist objectForKey:@"PreferredNetworks"];
+
+        NSArray *thisSsidarray = [prefNetDict valueForKey:@"SSID_STR"];
+        for(NSString *ssidkey in thisSsidarray) {
+            QString thisSsid = qt_mac_NSStringToQString(ssidkey);
+            if(!userProfiles.contains(thisSsid)) {
+                QMap <QString,QString> map;
+                map.insert(thisSsid, qt_mac_NSStringToQString(nsInterfaceName));
+                userProfiles.insert(thisSsid, map);
+            }
+        }
+        CFRelease(airportPlist);
+
+        // 802.1X user profiles
+        QString userProfilePath = QDir::homePath() + "/Library/Preferences/com.apple.eap.profiles.plist";
+        NSDictionary* eapDict = [[NSMutableDictionary alloc] initWithContentsOfFile:qt_mac_QStringToNSString(userProfilePath)];
+        NSString *profileStr= @"Profiles";
+        NSString *nameStr = @"UserDefinedName";
+        NSString *networkSsidStr = @"Wireless Network";
+        for (id profileKey in eapDict) {
+            if ([profileStr isEqualToString:profileKey]) {
+                NSDictionary *itemDict = [eapDict objectForKey:profileKey];
+                for (id itemKey in itemDict) {
+
+                    NSInteger dictSize = [itemKey count];
+                    id objects[dictSize];
+                    id keys[dictSize];
+
+                    [itemKey getObjects:objects andKeys:keys];
+                    QString networkName;
+                    QString ssid;
+                    for(int i = 0; i < dictSize; i++) {
+                        if([nameStr isEqualToString:keys[i]]) {
+                            networkName = qt_mac_NSStringToQString(objects[i]);
+                        }
+                        if([networkSsidStr isEqualToString:keys[i]]) {
+                            ssid = qt_mac_NSStringToQString(objects[i]);
+                        }
+                        if(!userProfiles.contains(networkName)
+                            && !ssid.isEmpty()) {
+                            QMap<QString,QString> map;
+                            map.insert(ssid, qt_mac_NSStringToQString(nsInterfaceName));
+                            userProfiles.insert(networkName, map);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/generic/generic.pro b/src/plugins/bearer/generic/generic.pro
new file mode 100644
index 0000000..1d141fd
--- /dev/null
+++ b/src/plugins/bearer/generic/generic.pro
@@ -0,0 +1,16 @@
+TARGET = qgenericbearer
+include(../../qpluginbase.pri)
+
+QT += network
+
+HEADERS += qgenericengine.h \
+           ../qnetworksession_impl.h \
+           ../qbearerengine_impl.h \
+           ../platformdefs_win.h
+SOURCES += qgenericengine.cpp \
+           ../qnetworksession_impl.cpp \
+           main.cpp
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
diff --git a/src/plugins/bearer/generic/main.cpp b/src/plugins/bearer/generic/main.cpp
new file mode 100644
index 0000000..ba85d93
--- /dev/null
+++ b/src/plugins/bearer/generic/main.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgenericengine.h"
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QGenericEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QGenericEnginePlugin();
+    ~QGenericEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QGenericEnginePlugin::QGenericEnginePlugin()
+{
+}
+
+QGenericEnginePlugin::~QGenericEnginePlugin()
+{
+}
+
+QStringList QGenericEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("generic");
+}
+
+QBearerEngine *QGenericEnginePlugin::create(const QString &key) const
+{
+    if (key == QLatin1String("generic"))
+        return new QGenericEngine;
+    else
+        return 0;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QGenericEnginePlugin)
+Q_EXPORT_PLUGIN2(qgenericbearer, QGenericEnginePlugin)
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/generic/qgenericengine.cpp b/src/plugins/bearer/generic/qgenericengine.cpp
new file mode 100644
index 0000000..d65025b
--- /dev/null
+++ b/src/plugins/bearer/generic/qgenericengine.cpp
@@ -0,0 +1,351 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgenericengine.h"
+#include "../qnetworksession_impl.h"
+
+#include <QtNetwork/private/qnetworkconfiguration_p.h>
+
+#include <QtCore/qthread.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qstringlist.h>
+
+#include <QtCore/qdebug.h>
+#include <QtCore/private/qcoreapplication_p.h>
+
+#ifdef Q_OS_WIN
+#include "../platformdefs_win.h"
+#endif
+
+#ifdef Q_OS_LINUX
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <unistd.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_NETWORKINTERFACE
+static QString qGetInterfaceType(const QString &interface)
+{
+#ifdef Q_OS_WIN32
+    unsigned long oid;
+    DWORD bytesWritten;
+
+    NDIS_MEDIUM medium;
+    NDIS_PHYSICAL_MEDIUM physicalMedium;
+
+    HANDLE handle = CreateFile((TCHAR *)QString("\\\\.\\%1").arg(interface).utf16(), 0,
+                               FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
+    if (handle == INVALID_HANDLE_VALUE)
+        return QLatin1String("Unknown");
+
+    oid = OID_GEN_MEDIA_SUPPORTED;
+    bytesWritten = 0;
+    bool result = DeviceIoControl(handle, IOCTL_NDIS_QUERY_GLOBAL_STATS, &oid, sizeof(oid),
+                                  &medium, sizeof(medium), &bytesWritten, 0);
+    if (!result) {
+        CloseHandle(handle);
+        return QLatin1String("Unknown");
+    }
+
+    oid = OID_GEN_PHYSICAL_MEDIUM;
+    bytesWritten = 0;
+    result = DeviceIoControl(handle, IOCTL_NDIS_QUERY_GLOBAL_STATS, &oid, sizeof(oid),
+                             &physicalMedium, sizeof(physicalMedium), &bytesWritten, 0);
+    if (!result) {
+        CloseHandle(handle);
+
+        if (medium == NdisMedium802_3)
+            return QLatin1String("Ethernet");
+        else
+            return QLatin1String("Unknown");
+    }
+
+    CloseHandle(handle);
+
+    if (medium == NdisMedium802_3) {
+        switch (physicalMedium) {
+        case NdisPhysicalMediumWirelessLan:
+            return QLatin1String("WLAN");
+        case NdisPhysicalMediumBluetooth:
+            return QLatin1String("Bluetooth");
+        case NdisPhysicalMediumWiMax:
+            return QLatin1String("WiMAX");
+        default:
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug() << "Physical Medium" << physicalMedium;
+#endif
+            return QLatin1String("Ethernet");
+        }
+    }
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+    qDebug() << medium << physicalMedium;
+#endif
+#elif defined(Q_OS_LINUX)
+    int sock = socket(AF_INET, SOCK_DGRAM, 0);
+
+    ifreq request;
+    strncpy(request.ifr_name, interface.toLocal8Bit().data(), sizeof(request.ifr_name));
+    int result = ioctl(sock, SIOCGIFHWADDR, &request);
+    close(sock);
+
+    if (result >= 0 && request.ifr_hwaddr.sa_family == ARPHRD_ETHER)
+        return QLatin1String("Ethernet");
+#else
+    Q_UNUSED(interface);
+#endif
+
+    return QLatin1String("Unknown");
+}
+#endif
+
+QGenericEngine::QGenericEngine(QObject *parent)
+:   QBearerEngineImpl(parent)
+{
+}
+
+QGenericEngine::~QGenericEngine()
+{
+}
+
+QString QGenericEngine::getInterfaceFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    return configurationInterface.value(id);
+}
+
+bool QGenericEngine::hasIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    return configurationInterface.contains(id);
+}
+
+void QGenericEngine::connectToId(const QString &id)
+{
+    emit connectionError(id, OperationNotSupported);
+}
+
+void QGenericEngine::disconnectFromId(const QString &id)
+{
+    emit connectionError(id, OperationNotSupported);
+}
+
+void QGenericEngine::requestUpdate()
+{
+    doRequestUpdate();
+}
+
+void QGenericEngine::doRequestUpdate()
+{
+#ifndef QT_NO_NETWORKINTERFACE
+    QMutexLocker locker(&mutex);
+
+    // Immediately after connecting with a wireless access point
+    // QNetworkInterface::allInterfaces() will sometimes return an empty list. Calling it again a
+    // second time results in a non-empty list. If we loose interfaces we will end up removing
+    // network configurations which will break current sessions.
+    QList<QNetworkInterface> interfaces = QNetworkInterface::allInterfaces();
+    if (interfaces.isEmpty())
+        interfaces = QNetworkInterface::allInterfaces();
+
+    QStringList previous = accessPointConfigurations.keys();
+
+    // create configuration for each interface
+    while (!interfaces.isEmpty()) {
+        QNetworkInterface interface = interfaces.takeFirst();
+
+        if (!interface.isValid())
+            continue;
+
+        // ignore loopback interface
+        if (interface.flags() & QNetworkInterface::IsLoopBack)
+            continue;
+
+        // ignore WLAN interface handled in separate engine
+        if (qGetInterfaceType(interface.name()) == QLatin1String("WLAN"))
+            continue;
+
+        uint identifier;
+        if (interface.index())
+            identifier = qHash(QLatin1String("generic:") + QString::number(interface.index()));
+        else
+            identifier = qHash(QLatin1String("generic:") + interface.hardwareAddress());
+
+        const QString id = QString::number(identifier);
+
+        previous.removeAll(id);
+
+        QString name = interface.humanReadableName();
+        if (name.isEmpty())
+            name = interface.name();
+
+        QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Defined;
+        if((interface.flags() & QNetworkInterface::IsUp) && !interface.addressEntries().isEmpty())
+            state |= QNetworkConfiguration::Active;
+
+        if (accessPointConfigurations.contains(id)) {
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+            bool changed = false;
+
+            ptr->mutex.lock();
+
+            if (!ptr->isValid) {
+                ptr->isValid = true;
+                changed = true;
+            }
+
+            if (ptr->name != name) {
+                ptr->name = name;
+                changed = true;
+            }
+
+            if (ptr->id != id) {
+                ptr->id = id;
+                changed = true;
+            }
+
+            if (ptr->state != state) {
+                ptr->state = state;
+                changed = true;
+            }
+
+            ptr->mutex.unlock();
+
+            if (changed) {
+                locker.unlock();
+                emit configurationChanged(ptr);
+                locker.relock();
+            }
+        } else {
+            QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
+
+            ptr->name = name;
+            ptr->isValid = true;
+            ptr->id = id;
+            ptr->state = state;
+            ptr->type = QNetworkConfiguration::InternetAccessPoint;
+            ptr->bearer = qGetInterfaceType(interface.name());
+
+            accessPointConfigurations.insert(id, ptr);
+            configurationInterface.insert(id, interface.name());
+
+            locker.unlock();
+            emit configurationAdded(ptr);
+            locker.relock();
+        }
+    }
+
+    while (!previous.isEmpty()) {
+        QNetworkConfigurationPrivatePointer ptr =
+            accessPointConfigurations.take(previous.takeFirst());
+
+        configurationInterface.remove(ptr->id);
+
+        locker.unlock();
+        emit configurationRemoved(ptr);
+        locker.relock();
+    }
+
+    locker.unlock();
+#endif
+
+    emit updateCompleted();
+}
+
+QNetworkSession::State QGenericEngine::sessionStateForId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+    if (!ptr)
+        return QNetworkSession::Invalid;
+
+    QMutexLocker configLocker(&ptr->mutex);
+
+    if (!ptr->isValid) {
+        return QNetworkSession::Invalid;
+    } else if ((ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+        return QNetworkSession::Connected;
+    } else if ((ptr->state & QNetworkConfiguration::Discovered) ==
+                QNetworkConfiguration::Discovered) {
+        return QNetworkSession::Disconnected;
+    } else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) {
+        return QNetworkSession::NotAvailable;
+    } else if ((ptr->state & QNetworkConfiguration::Undefined) ==
+                QNetworkConfiguration::Undefined) {
+        return QNetworkSession::NotAvailable;
+    }
+
+    return QNetworkSession::Invalid;
+}
+
+QNetworkConfigurationManager::Capabilities QGenericEngine::capabilities() const
+{
+    return QNetworkConfigurationManager::ForcedRoaming;
+}
+
+QNetworkSessionPrivate *QGenericEngine::createSessionBackend()
+{
+    return new QNetworkSessionPrivateImpl;
+}
+
+QNetworkConfigurationPrivatePointer QGenericEngine::defaultConfiguration()
+{
+    return QNetworkConfigurationPrivatePointer();
+}
+
+
+bool QGenericEngine::requiresPolling() const
+{
+    return true;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/bearer/generic/qgenericengine.h b/src/plugins/bearer/generic/qgenericengine.h
new file mode 100644
index 0000000..616a3fd
--- /dev/null
+++ b/src/plugins/bearer/generic/qgenericengine.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGENERICENGINE_H
+#define QGENERICENGINE_H
+
+#include "../qbearerengine_impl.h"
+
+#include <QMap>
+#include <QTimer>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkConfigurationPrivate;
+class QNetworkSessionPrivate;
+
+class QGenericEngine : public QBearerEngineImpl
+{
+    Q_OBJECT
+
+public:
+    QGenericEngine(QObject *parent = 0);
+    ~QGenericEngine();
+
+    QString getInterfaceFromId(const QString &id);
+    bool hasIdentifier(const QString &id);
+
+    QString bearerName(const QString &id);
+
+    void connectToId(const QString &id);
+    void disconnectFromId(const QString &id);
+
+    Q_INVOKABLE void requestUpdate();
+
+    QNetworkSession::State sessionStateForId(const QString &id);
+
+    QNetworkConfigurationManager::Capabilities capabilities() const;
+
+    QNetworkSessionPrivate *createSessionBackend();
+
+    QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+    bool requiresPolling() const;
+
+private Q_SLOTS:
+    void doRequestUpdate();
+
+private:
+    QMap<QString, QString> configurationInterface;
+};
+
+QT_END_NAMESPACE
+
+#endif
+
diff --git a/src/plugins/bearer/icd/icd.pro b/src/plugins/bearer/icd/icd.pro
new file mode 100644
index 0000000..f411de2
--- /dev/null
+++ b/src/plugins/bearer/icd/icd.pro
@@ -0,0 +1,22 @@
+TARGET = qicdbearer
+include(../../qpluginbase.pri)
+
+QT += network dbus
+
+QMAKE_CXXFLAGS += $$QT_CFLAGS_ICD
+LIBS += $$QT_LIBS_ICD
+
+HEADERS += qicdengine.h \
+           monitor.h \
+           qnetworksession_impl.h
+
+SOURCES += main.cpp \
+           qicdengine.cpp \
+           monitor.cpp \
+           qnetworksession_impl.cpp
+
+#DEFINES += BEARER_MANAGEMENT_DEBUG
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
diff --git a/src/plugins/bearer/icd/main.cpp b/src/plugins/bearer/icd/main.cpp
new file mode 100644
index 0000000..ad1a918
--- /dev/null
+++ b/src/plugins/bearer/icd/main.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qicdengine.h"
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QIcdEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QIcdEnginePlugin();
+    ~QIcdEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QIcdEnginePlugin::QIcdEnginePlugin()
+{
+}
+
+QIcdEnginePlugin::~QIcdEnginePlugin()
+{
+}
+
+QStringList QIcdEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("icd");
+}
+
+QBearerEngine *QIcdEnginePlugin::create(const QString &key) const
+{
+    if (key == QLatin1String("icd"))
+        return new QIcdEngine;
+    else
+        return 0;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QIcdEnginePlugin)
+Q_EXPORT_PLUGIN2(qicdbearer, QIcdEnginePlugin)
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/icd/monitor.cpp b/src/plugins/bearer/icd/monitor.cpp
new file mode 100644
index 0000000..5b0af7e
--- /dev/null
+++ b/src/plugins/bearer/icd/monitor.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "monitor.h"
+#include "qicdengine.h"
+
+#include <wlancond.h>
+#include <libicd-network-wlan-dev.h>
+#include <maemo_icd.h>
+#include <iapconf.h>
+
+
+void IapMonitor::setup(QIcdEngine *d_ptr)
+{
+    if (first_call) {
+        d = d_ptr;
+        first_call = false;
+    }
+}
+
+
+void IapMonitor::cleanup()
+{
+    if (!first_call) {
+        timers.removeAll();
+        first_call = true;
+    }
+}
+
+
+void IapMonitor::iapAdded(const QString &iap_id)
+{
+    /* We cannot know when the IAP is fully added to db, so a timer is
+     * installed instead. When the timer expires we hope that IAP is added ok.
+     */
+    QString id = iap_id;
+    timers.add(id, d);
+}
+
+
+void IapMonitor::iapRemoved(const QString &iap_id)
+{
+    QString id = iap_id;
+    d->deleteConfiguration(id);
+}
+
diff --git a/src/plugins/bearer/icd/monitor.h b/src/plugins/bearer/icd/monitor.h
new file mode 100644
index 0000000..10ffb30
--- /dev/null
+++ b/src/plugins/bearer/icd/monitor.h
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MONITOR_H
+#define MONITOR_H
+
+#include <QtCore/qhash.h>
+#include <QtCore/qtimer.h>
+
+#include <gconf/gconf.h>
+#include <gconf/gconf-client.h>
+
+#include <iapmonitor.h>
+
+class QIcdEngine;
+
+/* The IapAddTimer is a helper class that makes sure we update
+ * the configuration only after all db additions to certain
+ * iap are finished (after a certain timeout)
+ */
+class _IapAddTimer : public QObject
+{
+    Q_OBJECT
+
+public:
+    _IapAddTimer() {}
+    ~_IapAddTimer()
+    {
+        if (timer.isActive()) {
+            QObject::disconnect(&timer, SIGNAL(timeout()), this, SLOT(timeout()));
+            timer.stop();
+        }
+    }
+
+    void add(QString& iap_id, QIcdEngine *d);
+
+    QString iap_id;
+    QTimer timer;
+    QIcdEngine *d;
+
+public Q_SLOTS:
+    void timeout();
+};
+
+class IapAddTimer {
+    QHash<QString, _IapAddTimer* > timers;
+
+public:
+    IapAddTimer() {}
+    ~IapAddTimer() {}
+
+    void add(QString& iap_id, QIcdEngine *d);
+    void del(QString& iap_id);
+    void removeAll();
+};
+
+class IapMonitor : public Maemo::IAPMonitor
+{
+public:
+    IapMonitor() : first_call(true) { }
+
+    void setup(QIcdEngine *d);
+    void cleanup();
+
+protected:
+    void iapAdded(const QString &iapId);
+    void iapRemoved(const QString &iapId);
+
+private:
+    bool first_call;
+
+    QIcdEngine *d;
+    IapAddTimer timers;
+};
+
+#endif // MONITOR_H
diff --git a/src/plugins/bearer/icd/qicdengine.cpp b/src/plugins/bearer/icd/qicdengine.cpp
new file mode 100644
index 0000000..7a4cb9d
--- /dev/null
+++ b/src/plugins/bearer/icd/qicdengine.cpp
@@ -0,0 +1,437 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qicdengine.h"
+#include "monitor.h"
+#include "qnetworksession_impl.h"
+
+#include <libicd-network-wlan-dev.h>
+#include <maemo_icd.h>
+#include <iapconf.h>
+
+QT_BEGIN_NAMESPACE
+
+IcdNetworkConfigurationPrivate::IcdNetworkConfigurationPrivate()
+:   network_attrs(0), service_attrs(0)
+{
+}
+
+IcdNetworkConfigurationPrivate::~IcdNetworkConfigurationPrivate()
+{
+}
+
+QString IcdNetworkConfigurationPrivate::bearerName() const
+{
+    if (iap_type == QLatin1String("WLAN_INFRA") ||
+        iap_type == QLatin1String("WLAN_ADHOC")) {
+        return QLatin1String("WLAN");
+    } else if (iap_type == QLatin1String("GPRS")) {
+        return QLatin1String("HSPA");
+    } else {
+        return iap_type;
+    }
+}
+
+static inline QString network_attrs_to_security(uint network_attrs)
+{
+    uint cap = 0;
+    nwattr2cap(network_attrs, &cap); /* from libicd-network-wlan-dev.h */
+    if (cap & WLANCOND_OPEN)
+        return "NONE";
+    else if (cap & WLANCOND_WEP)
+        return "WEP";
+    else if (cap & WLANCOND_WPA_PSK)
+        return "WPA_PSK";
+    else if (cap & WLANCOND_WPA_EAP)
+        return "WPA_EAP";
+    return "";
+}
+
+QIcdEngine::QIcdEngine(QObject *parent)
+:   QBearerEngine(parent), iapMonitor(new IapMonitor)
+{
+    /* Turn on IAP monitoring */
+    iapMonitor->setup(this);
+
+    doRequestUpdate();
+}
+
+QIcdEngine::~QIcdEngine()
+{
+}
+
+bool QIcdEngine::hasIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    return accessPointConfigurations.contains(id) ||
+           snapConfigurations.contains(id) ||
+           userChoiceConfigurations.contains(id);
+}
+
+void QIcdEngine::requestUpdate()
+{
+    QMutexLocker locker(&mutex);
+
+    QTimer::singleShot(0, this, SLOT(doRequestUpdate()));
+}
+
+static uint32_t getNetworkAttrs(bool is_iap_id,
+                                QString& iap_id,
+                                QString& iap_type,
+                                QString security_method)
+{
+    guint network_attr = 0;
+    dbus_uint32_t cap = 0;
+
+    if (iap_type == "WLAN_INFRA")
+    cap |= WLANCOND_INFRA;
+    else if (iap_type == "WLAN_ADHOC")
+    cap |= WLANCOND_ADHOC;
+
+    if (security_method.isEmpty() && (cap & (WLANCOND_INFRA | WLANCOND_ADHOC))) {
+    Maemo::IAPConf saved_ap(iap_id);
+    security_method = saved_ap.value("wlan_security").toString();
+    }
+
+    if (!security_method.isEmpty()) {
+    if (security_method == "WEP")
+        cap |= WLANCOND_WEP;
+    else if (security_method == "WPA_PSK")
+        cap |= WLANCOND_WPA_PSK;
+    else if (security_method == "WPA_EAP")
+        cap |= WLANCOND_WPA_EAP;
+    else if (security_method == "NONE")
+        cap |= WLANCOND_OPEN;
+
+    if (cap & (WLANCOND_WPA_PSK | WLANCOND_WPA_EAP)) {
+        Maemo::IAPConf saved_iap(iap_id);
+        bool wpa2_only = saved_iap.value("EAP_wpa2_only_mode").toBool();
+        if (wpa2_only) {
+        cap |= WLANCOND_WPA2;
+        }
+    }
+    }
+
+    cap2nwattr(cap, &network_attr);
+    if (is_iap_id)
+    network_attr |= ICD_NW_ATTR_IAPNAME;
+
+    return (uint32_t)network_attr;
+}
+
+void QIcdEngine::doRequestUpdate()
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList previous = accessPointConfigurations.keys();
+
+    /* All the scanned access points */
+    QList<Maemo::IcdScanResult> scanned;
+
+    /* We create a default configuration which is a pseudo config */
+    if (!userChoiceConfigurations.contains(OSSO_IAP_ANY)) {
+        QNetworkConfigurationPrivatePointer ptr(new IcdNetworkConfigurationPrivate);
+
+        ptr->name = QLatin1String("UserChoice");
+        ptr->state = QNetworkConfiguration::Discovered;
+        ptr->isValid = true;
+        ptr->id = OSSO_IAP_ANY;
+        ptr->type = QNetworkConfiguration::UserChoice;
+        ptr->purpose = QNetworkConfiguration::UnknownPurpose;
+        ptr->roamingSupported = false;
+
+        userChoiceConfigurations.insert(ptr->id, ptr);
+
+        locker.unlock();
+        emit configurationAdded(ptr);
+        locker.relock();
+    }
+
+    /* We return currently configured IAPs in the first run and do the WLAN
+     * scan in subsequent runs.
+     */
+    QList<QString> all_iaps;
+    Maemo::IAPConf::getAll(all_iaps);
+
+    foreach (QString iap_id, all_iaps) {
+        QByteArray ssid;
+
+        previous.removeAll(iap_id);
+
+        Maemo::IAPConf saved_ap(iap_id);
+        bool is_temporary = saved_ap.value("temporary").toBool();
+        if (is_temporary) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug() << "IAP" << iap_id << "is temporary, skipping it.";
+#endif
+            continue;
+        }
+
+        QString iap_type = saved_ap.value("type").toString();
+        if (iap_type.startsWith("WLAN")) {
+            ssid = saved_ap.value("wlan_ssid").toByteArray();
+            if (ssid.isEmpty())
+                continue;
+
+            QString security_method = saved_ap.value("wlan_security").toString();
+        } else if (iap_type.isEmpty()) {
+            continue;
+        } else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug() << "IAP" << iap_id << "network type is" << iap_type;
+#endif
+            ssid.clear();
+        }
+
+        if (!accessPointConfigurations.contains(iap_id)) {
+            IcdNetworkConfigurationPrivate *cpPriv = new IcdNetworkConfigurationPrivate;
+
+            cpPriv->name = saved_ap.value("name").toString();
+            if (cpPriv->name.isEmpty()) {
+                    if (!ssid.isEmpty() && ssid.size() > 0)
+                        cpPriv->name = ssid.data();
+                    else
+                        cpPriv->name = iap_id;
+            }
+            cpPriv->isValid = true;
+            cpPriv->id = iap_id;
+            cpPriv->network_id = ssid;
+            cpPriv->network_attrs = getNetworkAttrs(true, iap_id, iap_type, QString());
+            cpPriv->iap_type = iap_type;
+            cpPriv->service_id = saved_ap.value("service_id").toString();
+            cpPriv->service_type = saved_ap.value("service_type").toString();
+            cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+            cpPriv->state = QNetworkConfiguration::Defined;
+
+            QNetworkConfigurationPrivatePointer ptr(cpPriv);
+            accessPointConfigurations.insert(iap_id, ptr);
+
+            locker.unlock();
+            emit configurationAdded(ptr);
+            locker.relock();
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("IAP: %s, name: %s, ssid: %s, added to known list",
+                   iap_id.toAscii().data(), ptr->name.toAscii().data(),
+                   !ssid.isEmpty() ? ssid.data() : "-");
+#endif
+        } else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("IAP: %s, ssid: %s, already exists in the known list",
+                   iap_id.toAscii().data(), !ssid.isEmpty() ? ssid.data() : "-");
+#endif
+        }
+    }
+
+    if (sender()) {
+        QStringList scannedNetworkTypes;
+        QStringList networkTypesToScan;
+        QString error;
+        Maemo::Icd icd(ICD_SHORT_SCAN_TIMEOUT);
+
+        scannedNetworkTypes = icd.scan(ICD_SCAN_REQUEST_ACTIVE,
+                                       networkTypesToScan,
+                                       scanned,
+                                       error);
+        if (!error.isEmpty()) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug() << "Network scanning failed" << error;
+#endif
+        } else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            if (!scanned.isEmpty())
+                qDebug() << "Scan returned" << scanned.size() << "networks";
+            else
+                qDebug() << "Scan returned nothing.";
+#endif
+        }
+    }
+
+    /* This is skipped in the first update as scanned size is zero */
+    if (!scanned.isEmpty()) {
+        for (int i=0; i<scanned.size(); ++i) {
+            const Maemo::IcdScanResult ap = scanned.at(i);
+
+            QByteArray scanned_ssid = ap.scan.network_id;
+
+            if (ap.scan.network_attrs & ICD_NW_ATTR_IAPNAME) {
+                /* The network_id is IAP id, so the IAP is a known one */
+                QString iapid = ap.scan.network_id.data();
+
+                previous.removeAll(iapid);
+
+                if (accessPointConfigurations.contains(iapid)) {
+                    QNetworkConfigurationPrivatePointer ptr =
+                        accessPointConfigurations.value(iapid);
+
+                    bool changed = false;
+
+                    ptr->mutex.lock();
+
+                    if (!ptr->isValid) {
+                        ptr->isValid = true;
+                        changed = true;
+                    }
+
+                    if (ptr->state != QNetworkConfiguration::Discovered) {
+                        ptr->state = QNetworkConfiguration::Discovered;
+                        changed = true;
+                    }
+
+                    toIcdConfig(ptr)->network_attrs = ap.scan.network_attrs;
+                    toIcdConfig(ptr)->service_id = ap.scan.service_id;
+                    toIcdConfig(ptr)->service_type = ap.scan.service_type;
+                    toIcdConfig(ptr)->service_attrs = ap.scan.service_attrs;
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+                    qDebug("IAP: %s, ssid: %s, discovered",
+                           iapid.toAscii().data(), scanned_ssid.data());
+#endif
+
+                    ptr->mutex.unlock();
+
+                    if (changed) {
+                        locker.unlock();
+                        emit configurationChanged(ptr);
+                        locker.relock();
+                    }
+
+                    if (!ap.scan.network_type.startsWith(QLatin1String("WLAN")))
+                        continue; // not a wlan AP
+                }
+            } else {
+                IcdNetworkConfigurationPrivate *cpPriv = new IcdNetworkConfigurationPrivate;
+
+                QString hrs = scanned_ssid.data();
+
+                cpPriv->name = ap.network_name.isEmpty() ? hrs : ap.network_name;
+                cpPriv->isValid = true;
+                // Note: id is now ssid, it should be set to IAP id if the IAP is saved
+                cpPriv->id = scanned_ssid.data();
+                cpPriv->network_id = scanned_ssid;
+                cpPriv->iap_type = ap.scan.network_type;
+                if (cpPriv->iap_type.isEmpty())
+                    cpPriv->iap_type = QLatin1String("WLAN");
+                cpPriv->network_attrs = ap.scan.network_attrs;
+                cpPriv->service_id = ap.scan.service_id;
+                cpPriv->service_type = ap.scan.service_type;
+                cpPriv->service_attrs = ap.scan.service_attrs;
+
+                cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+                cpPriv->state = QNetworkConfiguration::Undefined;
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+                qDebug() << "IAP with network id" << cpPriv->id << "was found in the scan.";
+#endif
+
+                previous.removeAll(cpPriv->id);
+
+                QNetworkConfigurationPrivatePointer ptr(cpPriv);
+                accessPointConfigurations.insert(ptr->id, ptr);
+
+                locker.unlock();
+                emit configurationAdded(ptr);
+                locker.relock();
+            }
+        }
+    }
+
+    while (!previous.isEmpty()) {
+        QNetworkConfigurationPrivatePointer ptr =
+            accessPointConfigurations.take(previous.takeFirst());
+
+        locker.unlock();
+        emit configurationRemoved(ptr);
+        locker.relock();
+    }
+
+    if (sender()) {
+        locker.unlock();
+        emit updateCompleted();
+    }
+}
+
+void QIcdEngine::deleteConfiguration(const QString &iap_id)
+{
+    QMutexLocker locker(&mutex);
+
+    /* Called when IAPs are deleted in db, in this case we do not scan
+     * or read all the IAPs from db because it might take too much power
+     * (multiple applications would need to scan and read all IAPs from db)
+     */
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(iap_id);
+    if (ptr) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug() << "IAP" << iap_id << "was removed from storage.";
+#endif
+
+        locker.unlock();
+        emit configurationRemoved(ptr);
+    } else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("IAP: %s, already missing from the known list", iap_id.toAscii().data());
+#endif
+    }
+}
+
+QNetworkConfigurationManager::Capabilities QIcdEngine::capabilities() const
+{
+    return QNetworkConfigurationManager::CanStartAndStopInterfaces |
+           QNetworkConfigurationManager::DataStatistics |
+           QNetworkConfigurationManager::ForcedRoaming |
+           QNetworkConfigurationManager::NetworkSessionRequired;
+}
+
+QNetworkSessionPrivate *QIcdEngine::createSessionBackend()
+{
+    return new QNetworkSessionPrivateImpl(this);
+}
+
+QNetworkConfigurationPrivatePointer QIcdEngine::defaultConfiguration()
+{
+    QMutexLocker locker(&mutex);
+
+    // Here we just return [ANY] request to icd and let the icd decide which IAP to connect.
+    return userChoiceConfigurations.value(OSSO_IAP_ANY);
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/icd/qicdengine.h b/src/plugins/bearer/icd/qicdengine.h
new file mode 100644
index 0000000..50cda62
--- /dev/null
+++ b/src/plugins/bearer/icd/qicdengine.h
@@ -0,0 +1,130 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QICDENGINE_H
+#define QICDENGINE_H
+
+#include <QtNetwork/private/qbearerengine_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkConfigurationPrivate;
+class IapMonitor;
+
+class IcdNetworkConfigurationPrivate : public QNetworkConfigurationPrivate
+{
+public:
+    IcdNetworkConfigurationPrivate();
+    ~IcdNetworkConfigurationPrivate();
+
+    QString bearerName() const;
+
+    // In Maemo the id field (defined in QNetworkConfigurationPrivate)
+    // is the IAP id (which typically is UUID)
+    QByteArray network_id;  // typically WLAN ssid or similar
+    QString iap_type;       // is this one WLAN or GPRS
+
+    // Network attributes for this IAP, this is the value returned by icd and
+    // passed to it when connecting.
+    uint32_t network_attrs;
+
+    QString service_type;
+    QString service_id;
+    uint32_t service_attrs;
+};
+
+inline IcdNetworkConfigurationPrivate *toIcdConfig(QNetworkConfigurationPrivatePointer ptr)
+{
+    return static_cast<IcdNetworkConfigurationPrivate *>(ptr.data());
+}
+
+class QIcdEngine : public QBearerEngine
+{
+    Q_OBJECT
+
+public:
+    QIcdEngine(QObject *parent = 0);
+    ~QIcdEngine();
+
+    bool hasIdentifier(const QString &id);
+
+    Q_INVOKABLE void requestUpdate();
+
+    QNetworkConfigurationManager::Capabilities capabilities() const;
+
+    QNetworkSessionPrivate *createSessionBackend();
+
+    QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+    void deleteConfiguration(const QString &iap_id);
+
+    inline QNetworkConfigurationPrivatePointer configuration(const QString &id)
+    {
+        QMutexLocker locker(&mutex);
+
+        return accessPointConfigurations.value(id);
+    }
+
+    inline void addSessionConfiguration(QNetworkConfigurationPrivatePointer ptr)
+    {
+        QMutexLocker locker(&mutex);
+
+        accessPointConfigurations.insert(ptr->id, ptr);
+        emit configurationAdded(ptr);
+    }
+
+    inline void changedSessionConfiguration(QNetworkConfigurationPrivatePointer ptr)
+    {
+        QMutexLocker locker(&mutex);
+
+        emit configurationChanged(ptr);
+    }
+
+private Q_SLOTS:
+    void doRequestUpdate();
+
+private:
+    IapMonitor *iapMonitor;
+};
+
+QT_END_NAMESPACE
+
+#endif // QICDENGINE_H
diff --git a/src/plugins/bearer/icd/qnetworksession_impl.cpp b/src/plugins/bearer/icd/qnetworksession_impl.cpp
new file mode 100644
index 0000000..5bf95dc
--- /dev/null
+++ b/src/plugins/bearer/icd/qnetworksession_impl.cpp
@@ -0,0 +1,1204 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnetworksession_impl.h"
+#include "qicdengine.h"
+
+#include <QHash>
+
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include <maemo_icd.h>
+#include <iapconf.h>
+#include <proxyconf.h>
+
+#include <sys/types.h>
+#include <ifaddrs.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+QT_BEGIN_NAMESPACE
+
+static QHash<QString, QVariant> properties;
+
+static QString get_network_interface();
+static DBusConnection *dbus_connection;
+static DBusHandlerResult signal_handler(DBusConnection *connection,
+					DBusMessage *message,
+					void *user_data);
+
+#define ICD_DBUS_MATCH		"type='signal'," \
+				"interface='" ICD_DBUS_INTERFACE "'," \
+				"path='" ICD_DBUS_PATH "'"
+
+
+static inline DBusConnection *get_dbus_conn(DBusError *error)
+{
+    DBusConnection *conn = dbus_bus_get(DBUS_BUS_SYSTEM, error);
+#ifdef BEARER_MANAGEMENT_DEBUG
+    qDebug() << "Listening to bus" << dbus_bus_get_unique_name(conn);
+#endif
+
+    return conn;
+}
+
+
+/* Helper class that monitors the Icd status messages and
+ * can change the IAP status accordingly. This is a singleton.
+ */
+class IcdListener : public QObject
+{
+    Q_OBJECT
+
+public:
+    IcdListener() : first_call(true) { }
+    friend DBusHandlerResult signal_handler(DBusConnection *connection,
+					    DBusMessage *message,
+					    void *user_data);
+    void setup(QNetworkSessionPrivateImpl *d);
+    void cleanup();
+    void cleanupSession(QNetworkSessionPrivateImpl *ptr);
+
+    enum IapConnectionStatus {
+	/* The IAP was connected */
+	CONNECTED = 0,
+	/* The IAP was disconnected */
+	DISCONNECTED,
+	/* The IAP is disconnecting */
+	DISCONNECTING,
+	/* The IAP has a network address, but is not yet fully connected */
+	NETWORK_UP
+    };
+
+private:
+    void icdSignalReceived(QString&, QString&, QString&);
+    bool first_call;
+    QHash<QString, QNetworkSessionPrivateImpl *> sessions;
+};
+
+Q_GLOBAL_STATIC(IcdListener, icdListener);
+ 
+
+static DBusHandlerResult signal_handler(DBusConnection *,
+					DBusMessage *message,
+					void *user_data)
+{
+    if (dbus_message_is_signal(message,
+				ICD_DBUS_INTERFACE,
+				ICD_STATUS_CHANGED_SIG)) {
+
+	IcdListener *icd = (IcdListener *)user_data;
+	DBusError error;
+	dbus_error_init(&error);
+
+	char *iap_id = 0;
+	char *network_type = 0;
+	char *state = 0;
+
+	if (dbus_message_get_args(message, &error,
+				    DBUS_TYPE_STRING, &iap_id,
+				    DBUS_TYPE_STRING, &network_type,
+				    DBUS_TYPE_STRING, &state,
+				    DBUS_TYPE_INVALID) == FALSE) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug() << QString("Failed to parse icd status signal: %1").arg(error.message);
+#endif
+        } else {
+	    QString _iap_id(iap_id);
+	    QString _network_type(network_type);
+	    QString _state(state);
+
+	    icd->icdSignalReceived(_iap_id, _network_type, _state);
+	}
+
+	dbus_error_free(&error);
+        return DBUS_HANDLER_RESULT_HANDLED;
+    }
+
+    return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+
+void IcdListener::setup(QNetworkSessionPrivateImpl *d)
+{
+    if (first_call) {
+	// We use the old Icd dbus interface like in ConIC
+	DBusError error;
+	dbus_error_init(&error);
+
+	dbus_connection = get_dbus_conn(&error);
+	if (dbus_error_is_set(&error)) {
+	    dbus_error_free(&error);
+	    return;
+	}
+
+	static struct DBusObjectPathVTable icd_vtable;
+	icd_vtable.message_function = signal_handler;
+
+	dbus_bus_add_match(dbus_connection, ICD_DBUS_MATCH, &error);
+	if (dbus_error_is_set(&error)) {
+	    dbus_error_free(&error);
+	    return;
+	}
+
+	if (dbus_connection_register_object_path(dbus_connection,
+						    ICD_DBUS_PATH,
+						    &icd_vtable,
+						    (void*)this) == FALSE) {
+	    dbus_error_free(&error);
+	    return;
+	}
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "Listening" << ICD_STATUS_CHANGED_SIG << "signal from" << ICD_DBUS_SERVICE;
+#endif
+	first_call = false;
+	dbus_error_free(&error);
+    }
+
+    QString id = d->activeConfig.identifier();
+    if (!sessions.contains(id)) {
+    QNetworkSessionPrivateImpl *ptr = d;
+	sessions.insert(id, ptr);
+    }
+}
+
+
+void IcdListener::icdSignalReceived(QString& iap_id,
+#ifdef BEARER_MANAGEMENT_DEBUG
+				    QString& network_type,
+#else
+				    QString&,
+#endif
+				    QString& state)
+{
+    if (iap_id == OSSO_IAP_SCAN) // icd sends scan status signals which we will ignore
+	return;
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+    qDebug() << "Status received:" << iap_id << "type" << network_type << "state" << state;
+#endif
+
+    if (!sessions.contains(iap_id)) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "No session for IAP" << iap_id;
+#endif
+	return;
+    }
+
+    QNetworkSessionPrivateImpl *session = sessions.value(iap_id);
+    QNetworkConfiguration ap_conf =
+        QNetworkConfigurationManager().configurationFromIdentifier(iap_id);
+    if (!ap_conf.isValid()) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "Unknown IAP" << iap_id;
+#endif
+	return;
+    }
+
+    IapConnectionStatus status;
+
+    if (state == "IDLE") {
+	status = DISCONNECTED;
+    } else if (state == "CONNECTED") {
+	status = CONNECTED;
+    } else if (state == "NETWORKUP") {
+	status = NETWORK_UP;
+    } else {
+	//qDebug() << "Unknown state" << state;
+	return;
+    }
+
+    if (status == DISCONNECTED) {
+	if (ap_conf.state() == QNetworkConfiguration::Active) {
+	    /* The IAP was just disconnected by Icd */
+	    session->updateState(QNetworkSession::Disconnected);
+	} else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	    qDebug() << "Got a network disconnect when in state" << ap_conf.state();
+#endif
+	}
+    } else if (status == CONNECTED) {
+	/* The IAP was just connected by Icd */
+	session->updateState(QNetworkSession::Connected);
+	session->updateIdentifier(iap_id);
+
+	if (session->publicConfig.identifier() == OSSO_IAP_ANY) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	    qDebug() << "IAP" << iap_id << "connected when connecting to" << OSSO_IAP_ANY;
+#endif
+	} else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	    qDebug() << "IAP" << iap_id << "connected";
+#endif
+	}
+    }
+
+    return;
+}
+
+
+void IcdListener::cleanup()
+{
+    if (!first_call) {
+	dbus_bus_remove_match(dbus_connection, ICD_DBUS_MATCH, NULL);
+	dbus_connection_unref(dbus_connection);
+    }
+}
+
+
+void IcdListener::cleanupSession(QNetworkSessionPrivateImpl *ptr)
+{
+    if (ptr->publicConfig.type() == QNetworkConfiguration::UserChoice)
+        (void)sessions.take(ptr->activeConfig.identifier());
+    else
+        (void)sessions.take(ptr->publicConfig.identifier());
+}
+
+
+void QNetworkSessionPrivateImpl::cleanupSession(void)
+{
+    icdListener()->cleanupSession(this);
+
+    QObject::disconnect(q, SIGNAL(stateChanged(QNetworkSession::State)), this, SLOT(updateProxies(QNetworkSession::State)));
+}
+
+
+void QNetworkSessionPrivateImpl::updateState(QNetworkSession::State newState)
+{
+    if (newState == state)
+        return;
+
+    state = newState;
+
+	if (state == QNetworkSession::Disconnected) {
+        isOpen = false;
+	    currentNetworkInterface.clear();
+        if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+            IcdNetworkConfigurationPrivate *icdConfig =
+                toIcdConfig(privateConfiguration(activeConfig));
+
+            icdConfig->mutex.lock();
+            icdConfig->state = QNetworkConfiguration::Defined;
+            icdConfig->mutex.unlock();
+        }
+
+        IcdNetworkConfigurationPrivate *icdConfig =
+            toIcdConfig(privateConfiguration(publicConfig));
+
+        icdConfig->mutex.lock();
+        icdConfig->state = QNetworkConfiguration::Defined;
+        icdConfig->mutex.unlock();
+
+	} else if (state == QNetworkSession::Connected) {
+        isOpen = true;
+	    if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+            IcdNetworkConfigurationPrivate *icdConfig =
+                toIcdConfig(privateConfiguration(activeConfig));
+
+            icdConfig->mutex.lock();
+            icdConfig->state = QNetworkConfiguration::Active;
+            icdConfig->type = QNetworkConfiguration::InternetAccessPoint;
+            icdConfig->mutex.unlock();
+	    }
+
+        IcdNetworkConfigurationPrivate *icdConfig =
+            toIcdConfig(privateConfiguration(publicConfig));
+
+        icdConfig->mutex.lock();
+        icdConfig->state = QNetworkConfiguration::Active;
+        icdConfig->mutex.unlock();
+	}
+
+    emit stateChanged(newState);
+}
+
+
+void QNetworkSessionPrivateImpl::updateIdentifier(QString &newId)
+{
+    if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+        IcdNetworkConfigurationPrivate *icdConfig =
+            toIcdConfig(privateConfiguration(activeConfig));
+
+        icdConfig->mutex.lock();
+        icdConfig->network_attrs |= ICD_NW_ATTR_IAPNAME;
+        icdConfig->id = newId;
+        icdConfig->mutex.unlock();
+    } else {
+        IcdNetworkConfigurationPrivate *icdConfig =
+            toIcdConfig(privateConfiguration(publicConfig));
+
+        icdConfig->mutex.lock();
+        icdConfig->network_attrs |= ICD_NW_ATTR_IAPNAME;
+        if (icdConfig->id != newId)
+            icdConfig->id = newId;
+        icdConfig->mutex.unlock();
+    }
+}
+
+
+quint64 QNetworkSessionPrivateImpl::getStatistics(bool sent) const
+{
+    /* This could be also implemented by using the Maemo::Icd::statistics()
+     * that gets the statistics data for a specific IAP. Change if
+     * necessary.
+     */
+    Maemo::Icd icd;
+    QList<Maemo::IcdStatisticsResult> stats_results;
+    quint64 counter_rx = 0, counter_tx = 0;
+
+    if (!icd.statistics(stats_results)) {
+	return 0;
+    }
+
+    foreach (const Maemo::IcdStatisticsResult &res, stats_results) {
+	if (res.params.network_attrs & ICD_NW_ATTR_IAPNAME) {
+	    /* network_id is the IAP UUID */
+	    if (QString(res.params.network_id.data()) == activeConfig.identifier()) {
+		counter_tx = res.bytes_sent;
+		counter_rx = res.bytes_received;
+	    }
+	} else {
+	    /* We probably will never get to this branch */
+        IcdNetworkConfigurationPrivate *icdConfig =
+            toIcdConfig(privateConfiguration(activeConfig));
+
+        icdConfig->mutex.lock();
+        if (res.params.network_id == icdConfig->network_id) {
+            counter_tx = res.bytes_sent;
+            counter_rx = res.bytes_received;
+	    }
+        icdConfig->mutex.unlock();
+	}
+    }
+
+    if (sent)
+	return counter_tx;
+    else
+	return counter_rx;
+}
+
+
+quint64 QNetworkSessionPrivateImpl::bytesWritten() const
+{
+    return getStatistics(true);
+}
+
+quint64 QNetworkSessionPrivateImpl::bytesReceived() const
+{
+    return getStatistics(false);
+}
+
+quint64 QNetworkSessionPrivateImpl::activeTime() const
+{
+    if (startTime.isNull()) {
+        return 0;
+    }
+    return startTime.secsTo(QDateTime::currentDateTime());
+}
+
+
+QNetworkConfiguration& QNetworkSessionPrivateImpl::copyConfig(QNetworkConfiguration &fromConfig,
+                                                              QNetworkConfiguration &toConfig,
+                                                              bool deepCopy)
+{
+    IcdNetworkConfigurationPrivate *cpPriv;
+    if (deepCopy) {
+        cpPriv = new IcdNetworkConfigurationPrivate;
+        setPrivateConfiguration(toConfig, QNetworkConfigurationPrivatePointer(cpPriv));
+    } else {
+        cpPriv = toIcdConfig(privateConfiguration(toConfig));
+    }
+
+    IcdNetworkConfigurationPrivate *fromPriv = toIcdConfig(privateConfiguration(fromConfig));
+
+    QMutexLocker toLocker(&cpPriv->mutex);
+    QMutexLocker fromLocker(&fromPriv->mutex);
+
+    cpPriv->name = fromPriv->name;
+    cpPriv->isValid = fromPriv->isValid;
+    // Note that we do not copy id field here as the publicConfig does
+    // not contain a valid IAP id.
+    cpPriv->state = fromPriv->state;
+    cpPriv->type = fromPriv->type;
+    cpPriv->roamingSupported = fromPriv->roamingSupported;
+    cpPriv->purpose = fromPriv->purpose;
+    cpPriv->network_id = fromPriv->network_id;
+    cpPriv->iap_type = fromPriv->iap_type;
+    cpPriv->network_attrs = fromPriv->network_attrs;
+    cpPriv->service_type = fromPriv->service_type;
+    cpPriv->service_id = fromPriv->service_id;
+    cpPriv->service_attrs = fromPriv->service_attrs;
+
+    return toConfig;
+}
+
+
+/* This is called by QNetworkSession constructor and it updates the current
+ * state of the configuration.
+ */
+void QNetworkSessionPrivateImpl::syncStateWithInterface()
+{
+    /* Start to listen Icd status messages. */
+    icdListener()->setup(this);
+
+    /* Initially we are not active although the configuration might be in
+     * connected state.
+     */
+    isOpen = false;
+    opened = false;
+
+    connect(&manager, SIGNAL(updateCompleted()), this, SLOT(networkConfigurationsChanged()));
+
+    connect(&manager, SIGNAL(configurationChanged(QNetworkConfiguration)),
+            this, SLOT(configurationChanged(QNetworkConfiguration)));
+
+    QObject::connect(q, SIGNAL(stateChanged(QNetworkSession::State)), this, SLOT(updateProxies(QNetworkSession::State)));
+
+    state = QNetworkSession::Invalid;
+    lastError = QNetworkSession::UnknownSessionError;
+
+    switch (publicConfig.type()) {
+    case QNetworkConfiguration::InternetAccessPoint:
+	activeConfig = publicConfig;
+        break;
+    case QNetworkConfiguration::ServiceNetwork:
+	serviceConfig = publicConfig;
+	break;
+    case QNetworkConfiguration::UserChoice:
+	// active config will contain correct data after open() has succeeded
+	copyConfig(publicConfig, activeConfig);
+
+	/* We create new configuration that holds the actual configuration
+	 * returned by icd. This way publicConfig still contains the
+	 * original user specified configuration.
+	 *
+	 * Note that the new activeConfig configuration is not inserted
+	 * to configurationManager as manager class will get the newly
+	 * connected configuration from gconf when the IAP is saved.
+	 * This configuration manager update is done by IapMonitor class.
+	 * If the ANY connection fails in open(), then the configuration
+	 * data is not saved to gconf and will not be added to
+	 * configuration manager IAP list.
+	 */
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug()<<"New configuration created for" << publicConfig.identifier();
+#endif
+	break;
+    default:
+	/* Invalid configuration, no point continuing */
+	return;
+    }
+
+    if (!activeConfig.isValid())
+	return;
+
+    /* Get the initial state from icd */
+    Maemo::Icd icd;
+    QList<Maemo::IcdStateResult> state_results;
+
+    /* Update the active config from first connection, this is ok as icd
+     * supports only one connection anyway.
+     */
+    if (icd.state(state_results) && !state_results.isEmpty()) {
+
+	/* If we did not get full state back, then we are not
+	 * connected and can skip the next part.
+	 */
+	if (!(state_results.first().params.network_attrs == 0 &&
+		state_results.first().params.network_id.isEmpty())) {
+
+	    /* If we try to connect to specific IAP and we get results back
+	     * that tell the icd is actually connected to another IAP,
+	     * then do not update current state etc.
+	     */
+	    if (publicConfig.type() == QNetworkConfiguration::UserChoice ||
+            publicConfig.identifier() == state_results.first().params.network_id) {
+
+		switch (state_results.first().state) {
+		case ICD_STATE_DISCONNECTED:
+		    state = QNetworkSession::Disconnected;
+            {
+                QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig);
+                if (ptr) {
+                    ptr->mutex.lock();
+                    ptr->isValid = true;
+                    ptr->mutex.unlock();
+                }
+            }
+		    break;
+		case ICD_STATE_CONNECTING:
+		    state = QNetworkSession::Connecting;
+            {
+                QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig);
+                if (ptr) {
+                    ptr->mutex.lock();
+                    ptr->isValid = true;
+                    ptr->mutex.unlock();
+                }
+            }
+		    break;
+		case ICD_STATE_CONNECTED:
+		    {
+			if (!state_results.first().error.isEmpty())
+			    break;
+                        
+            const QString id = state_results.first().params.network_id;
+
+            QNetworkConfiguration config = manager.configurationFromIdentifier(id);
+            if (config.isValid()) {
+                //we don't want the copied data if the config is already known by the manager
+                //just reuse it so that existing references to the old data get the same update
+                setPrivateConfiguration(activeConfig, privateConfiguration(config));
+            }
+
+            QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig);
+
+            QMutexLocker configLocker(&ptr->mutex);
+
+			state = QNetworkSession::Connected;
+            toIcdConfig(ptr)->network_id = state_results.first().params.network_id;
+            ptr->id = toIcdConfig(ptr)->network_id;
+            toIcdConfig(ptr)->network_attrs = state_results.first().params.network_attrs;
+            toIcdConfig(ptr)->iap_type = state_results.first().params.network_type;
+            toIcdConfig(ptr)->service_type = state_results.first().params.service_type;
+            toIcdConfig(ptr)->service_id = state_results.first().params.service_id;
+            toIcdConfig(ptr)->service_attrs = state_results.first().params.service_attrs;
+            ptr->type = QNetworkConfiguration::InternetAccessPoint;
+            ptr->state = QNetworkConfiguration::Active;
+            ptr->isValid = true;
+			currentNetworkInterface = get_network_interface();
+
+            Maemo::IAPConf iap_name(ptr->id);
+			QString name_value = iap_name.value("name").toString();
+			if (!name_value.isEmpty())
+                ptr->name = name_value;
+			else
+                ptr->name = ptr->id;
+
+
+			// Add the new active configuration to manager or update the old config
+            if (!engine->hasIdentifier(ptr->id)) {
+                configLocker.unlock();
+                engine->addSessionConfiguration(ptr);
+            } else {
+                configLocker.unlock();
+                engine->changedSessionConfiguration(ptr);
+            }
+            }
+		    break;
+
+		case ICD_STATE_DISCONNECTING:
+		    state = QNetworkSession::Closing;
+            {
+                QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig);
+                if (ptr) {
+                    ptr->mutex.lock();
+                    ptr->isValid = true;
+                    ptr->mutex.unlock();
+                }
+            }
+		    break;
+		default:
+		    break;
+		}
+	    }
+	} else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	    qDebug() << "status_req tells icd is not connected";
+#endif
+	}
+    } else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "status_req did not return any results from icd";
+#endif
+    }
+
+    networkConfigurationsChanged();
+}
+
+
+void QNetworkSessionPrivateImpl::networkConfigurationsChanged()
+{
+    if (serviceConfig.isValid())
+        updateStateFromServiceNetwork();
+    else
+        updateStateFromActiveConfig();
+}
+
+
+void QNetworkSessionPrivateImpl::updateStateFromServiceNetwork()
+{
+    QNetworkSession::State oldState = state;
+
+    foreach (const QNetworkConfiguration &config, serviceConfig.children()) {
+        if ((config.state() & QNetworkConfiguration::Active) != QNetworkConfiguration::Active)
+            continue;
+
+        if (activeConfig != config) {
+            activeConfig = config;
+            emit newConfigurationActivated();
+        }
+
+        state = QNetworkSession::Connected;
+        if (state != oldState)
+            emit stateChanged(state);
+
+        return;
+    }
+
+    if (serviceConfig.children().isEmpty())
+        state = QNetworkSession::NotAvailable;
+    else
+        state = QNetworkSession::Disconnected;
+
+    if (state != oldState)
+        emit stateChanged(state);
+}
+
+
+void QNetworkSessionPrivateImpl::clearConfiguration(QNetworkConfiguration &config)
+{
+    IcdNetworkConfigurationPrivate *icdConfig = toIcdConfig(privateConfiguration(config));
+
+    QMutexLocker locker(&icdConfig->mutex);
+
+    icdConfig->network_id.clear();
+    icdConfig->iap_type.clear();
+    icdConfig->network_attrs = 0;
+    icdConfig->service_type.clear();
+    icdConfig->service_id.clear();
+    icdConfig->service_attrs = 0;
+}
+
+
+void QNetworkSessionPrivateImpl::updateStateFromActiveConfig()
+{
+    QNetworkSession::State oldState = state;
+
+    bool newActive = false;
+
+    if (!activeConfig.isValid())
+        return;
+
+    if (!activeConfig.isValid()) {
+        state = QNetworkSession::Invalid;
+        clearConfiguration(activeConfig);
+    } else if ((activeConfig.state() & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+        state = QNetworkSession::Connected;
+        newActive = opened;
+    } else if ((activeConfig.state() & QNetworkConfiguration::Discovered) == QNetworkConfiguration::Discovered) {
+        state = QNetworkSession::Disconnected;
+    } else if ((activeConfig.state() & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) {
+        state = QNetworkSession::NotAvailable;
+    } else if ((activeConfig.state() & QNetworkConfiguration::Undefined) == QNetworkConfiguration::Undefined) {
+        state = QNetworkSession::NotAvailable;
+        //clearConfiguration(activeConfig);
+    }
+
+    bool oldActive = isOpen;
+    isOpen = newActive;
+
+    if (!oldActive && isOpen)
+        emit quitPendingWaitsForOpened();
+
+    if (oldActive && !isOpen)
+        emit closed();
+
+    if (oldState != state) {
+        emit stateChanged(state);
+
+	if (state == QNetworkSession::Disconnected) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	    //qDebug()<<"session aborted error emitted for"<<activeConfig.identifier();
+#endif
+	    lastError = QNetworkSession::SessionAbortedError;
+        emit QNetworkSessionPrivate::error(lastError);
+	}
+    }
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+    //qDebug()<<"oldState ="<<oldState<<" state ="<<state<<" oldActive ="<<oldActive<<" newActive ="<<newActive<<" opened ="<<opened;
+#endif
+}
+
+
+void QNetworkSessionPrivateImpl::configurationChanged(const QNetworkConfiguration &config)
+{
+    if (serviceConfig.isValid() && (config == serviceConfig || config == activeConfig))
+        updateStateFromServiceNetwork();
+    else if (config == activeConfig)
+        updateStateFromActiveConfig();
+}
+
+
+static QString get_network_interface()
+{
+    Maemo::Icd icd;
+    QList<Maemo::IcdAddressInfoResult> addr_results;
+    uint ret;
+    QString iface;
+
+    ret = icd.addrinfo(addr_results);
+    if (ret == 0) {
+	/* No results */
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "Cannot get addrinfo from icd, are you connected or is icd running?";
+#endif
+	return iface;
+    }
+
+    const char *address = addr_results.first().ip_info.first().address.toAscii().constData();
+    struct in_addr addr;
+    if (inet_aton(address, &addr) == 0) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "address" << address << "invalid";
+#endif
+	return iface;
+    }
+
+    struct ifaddrs *ifaddr, *ifa;
+    int family;
+
+    if (getifaddrs(&ifaddr) == -1) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "getifaddrs() failed";
+#endif
+	return iface;
+    }
+
+    for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+	family = ifa->ifa_addr->sa_family;
+	if (family != AF_INET) {
+	    continue; /* Currently only IPv4 is supported by icd dbus interface */
+	}
+	if (((struct sockaddr_in *)ifa->ifa_addr)->sin_addr.s_addr == addr.s_addr) {
+	    iface = QString(ifa->ifa_name);
+	    break;
+	}
+    }
+
+    freeifaddrs(ifaddr);
+    return iface;
+}
+
+
+void QNetworkSessionPrivateImpl::open()
+{
+    if (serviceConfig.isValid()) {
+        lastError = QNetworkSession::OperationNotSupportedError;
+        emit QNetworkSessionPrivate::error(lastError);
+    } else if (!isOpen) {
+
+	if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+	    /* Caller is trying to connect to default IAP.
+	     * At this time we will not know the IAP details so we just
+	     * connect and update the active config when the IAP is
+	     * connected.
+	     */
+	    opened = true;
+            state = QNetworkSession::Connecting;
+            emit stateChanged(state);
+	    QTimer::singleShot(0, this, SLOT(do_open()));
+	    return;
+	}
+
+	/* User is connecting to one specific IAP. If that IAP is not
+	 * in discovered state we cannot continue.
+	 */
+        if ((activeConfig.state() & QNetworkConfiguration::Discovered) !=
+            QNetworkConfiguration::Discovered) {
+            lastError =QNetworkSession::InvalidConfigurationError;
+            emit QNetworkSessionPrivate::error(lastError);
+            return;
+        }
+        opened = true;
+
+        if ((activeConfig.state() & QNetworkConfiguration::Active) != QNetworkConfiguration::Active) {
+            state = QNetworkSession::Connecting;
+            emit stateChanged(state);
+
+	    QTimer::singleShot(0, this, SLOT(do_open()));
+	    return;
+        }
+
+        isOpen = (activeConfig.state() & QNetworkConfiguration::Active) == QNetworkConfiguration::Active;
+        if (isOpen)
+            emit quitPendingWaitsForOpened();
+    } else {
+	/* We seem to be active so inform caller */
+	emit quitPendingWaitsForOpened();
+    }
+}
+
+
+void QNetworkSessionPrivateImpl::do_open()
+{
+    icd_connection_flags flags = connectFlags;
+    bool st;
+    QString result;
+    QString iap = publicConfig.identifier();
+
+    if (state == QNetworkSession::Connected) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "Already connected to" << activeConfig.identifier();
+#endif
+        emit stateChanged(QNetworkSession::Connected);
+	emit quitPendingWaitsForOpened();
+	return;
+    }
+
+    Maemo::IcdConnectResult connect_result;
+    Maemo::Icd icd(ICD_LONG_CONNECT_TIMEOUT);
+    QNetworkConfiguration config;
+    if (publicConfig.type() == QNetworkConfiguration::UserChoice)
+	config = activeConfig;
+    else
+	config = publicConfig;
+
+    if (iap == OSSO_IAP_ANY) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "connecting to default IAP" << iap;
+#endif
+	st = icd.connect(flags, connect_result);
+
+    } else {
+
+	QList<Maemo::ConnectParams> params;
+	Maemo::ConnectParams param;
+
+    IcdNetworkConfigurationPrivate *icdConfig = toIcdConfig(privateConfiguration(config));
+
+    icdConfig->mutex.lock();
+    param.connect.service_type = icdConfig->service_type;
+    param.connect.service_attrs = icdConfig->service_attrs;
+    param.connect.service_id = icdConfig->service_id;
+    param.connect.network_type = icdConfig->iap_type;
+    param.connect.network_attrs = icdConfig->network_attrs;
+    if (icdConfig->network_attrs & ICD_NW_ATTR_IAPNAME)
+	    param.connect.network_id = QByteArray(iap.toLatin1());
+	else
+        param.connect.network_id = icdConfig->network_id;
+	params.append(param);
+    icdConfig->mutex.unlock();
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug("connecting to %s/%s/0x%x/%s/0x%x/%s",
+	    param.connect.network_id.data(),
+	    param.connect.network_type.toAscii().constData(),
+	    param.connect.network_attrs,
+	    param.connect.service_type.toAscii().constData(),
+	    param.connect.service_attrs,
+	    param.connect.service_id.toAscii().constData());
+#endif
+	st = icd.connect(flags, params, connect_result);
+    }
+
+    if (st) {
+	result = connect_result.connect.network_id.data();
+	QString connected_iap = result;
+
+	if (connected_iap.isEmpty()) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	    qDebug() << "connect to"<< iap << "failed, result is empty";
+#endif
+	    updateState(QNetworkSession::Disconnected);
+        emit QNetworkSessionPrivate::error(QNetworkSession::InvalidConfigurationError);
+	    if (publicConfig.type() == QNetworkConfiguration::UserChoice)
+		cleanupAnyConfiguration();
+	    return;
+	}
+
+	/* If the user tried to connect to some specific connection (foo)
+	 * and we were already connected to some other connection (bar),
+	 * then we cannot activate this session although icd has a valid
+	 * connection to somewhere.
+	 */
+	if ((publicConfig.type() != QNetworkConfiguration::UserChoice) &&
+	    (connected_iap != config.identifier())) {
+	    updateState(QNetworkSession::Disconnected);
+        emit QNetworkSessionPrivate::error(QNetworkSession::InvalidConfigurationError);
+	    return;
+	}
+
+    IcdNetworkConfigurationPrivate *icdConfig = toIcdConfig(privateConfiguration(config));
+
+	/* Did we connect to non saved IAP? */
+    icdConfig->mutex.lock();
+    if (!(icdConfig->network_attrs & ICD_NW_ATTR_IAPNAME)) {
+	    /* Because the connection succeeded, the IAP is now known.
+	     */
+        icdConfig->network_attrs |= ICD_NW_ATTR_IAPNAME;
+        icdConfig->id = connected_iap;
+	}
+
+	/* User might have changed the IAP name when a new IAP was saved */
+    Maemo::IAPConf iap_name(icdConfig->id);
+	QString name = iap_name.value("name").toString();
+	if (!name.isEmpty())
+        icdConfig->name = name;
+
+    icdConfig->iap_type = connect_result.connect.network_type;
+
+    icdConfig->isValid = true;
+    icdConfig->state = QNetworkConfiguration::Active;
+    icdConfig->type = QNetworkConfiguration::InternetAccessPoint;
+
+    icdConfig->mutex.unlock();
+
+	startTime = QDateTime::currentDateTime();
+	updateState(QNetworkSession::Connected);
+
+	currentNetworkInterface = get_network_interface();
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+    qDebug() << "connected to" << result << config.name() << "at" << currentNetworkInterface;
+#endif
+
+	/* We first check if the configuration already exists in the manager
+	 * and if it is not found there, we then insert it. Note that this
+	 * is only done for user choice config only because it can be missing
+	 * from config manager list.
+	 */
+
+    if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+        if (!engine->hasIdentifier(result)) {
+            engine->addSessionConfiguration(privateConfiguration(config));
+        } else {
+            QNetworkConfigurationPrivatePointer priv = engine->configuration(result);
+            QNetworkConfiguration reference;
+            setPrivateConfiguration(reference, priv);
+            copyConfig(config, reference, false);
+            config = reference;
+            activeConfig = reference;
+            engine->changedSessionConfiguration(privateConfiguration(config));
+	    }
+	}
+
+	emit quitPendingWaitsForOpened();
+
+    } else {
+#ifdef BEARER_MANAGEMENT_DEBUG
+	qDebug() << "connect to"<< iap << "failed, status:" << connect_result.status;
+#endif
+	updateState(QNetworkSession::Disconnected);
+	if (publicConfig.type() == QNetworkConfiguration::UserChoice)
+	    cleanupAnyConfiguration();
+    emit QNetworkSessionPrivate::error(QNetworkSession::UnknownSessionError);
+    }
+}
+
+
+void QNetworkSessionPrivateImpl::cleanupAnyConfiguration()
+{
+#ifdef BEARER_MANAGEMENT_DEBUG
+    qDebug()<<"Removing configuration created for" << activeConfig.identifier();
+#endif
+    activeConfig = publicConfig;
+}
+
+
+void QNetworkSessionPrivateImpl::close()
+{
+    if (serviceConfig.isValid()) {
+        lastError = QNetworkSession::OperationNotSupportedError;
+        emit QNetworkSessionPrivate::error(lastError);
+    } else if (isOpen) {
+        opened = false;
+        isOpen = false;
+        emit closed();
+    }
+}
+
+
+void QNetworkSessionPrivateImpl::stop()
+{
+    if (serviceConfig.isValid()) {
+        lastError = QNetworkSession::OperationNotSupportedError;
+        emit QNetworkSessionPrivate::error(lastError);
+    } else {
+        if ((activeConfig.state() & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+            state = QNetworkSession::Closing;
+            emit stateChanged(state);
+
+	    Maemo::Icd icd;
+#ifdef BEARER_MANAGEMENT_DEBUG
+	    qDebug() << "stopping session" << publicConfig.identifier();
+#endif
+	    icd.disconnect(ICD_CONNECTION_FLAG_APPLICATION_EVENT);
+	    startTime = QDateTime();
+
+	    /* Note that the state will go disconnected in
+	     * updateStateFromActiveConfig() which gets called after
+	     * configurationChanged is emitted (below).
+	     */
+
+        QNetworkConfigurationPrivatePointer ptr = privateConfiguration(activeConfig);
+        ptr->mutex.lock();
+        ptr->state = QNetworkConfiguration::Discovered;
+        ptr->mutex.unlock();
+        engine->changedSessionConfiguration(ptr);
+
+	    opened = false;
+	    isOpen = false;
+
+        } else {
+	    opened = false;
+	    isOpen = false;
+        emit closed();
+	}
+    }
+}
+
+
+void QNetworkSessionPrivateImpl::migrate()
+{
+}
+
+
+void QNetworkSessionPrivateImpl::accept()
+{
+}
+
+
+void QNetworkSessionPrivateImpl::ignore()
+{
+}
+
+
+void QNetworkSessionPrivateImpl::reject()
+{
+}
+
+#ifndef QT_NO_NETWORKINTERFACE
+QNetworkInterface QNetworkSessionPrivateImpl::currentInterface() const
+{
+    if (!publicConfig.isValid() || state != QNetworkSession::Connected)
+        return QNetworkInterface();
+
+    if (currentNetworkInterface.isEmpty())
+        return QNetworkInterface();
+
+    return QNetworkInterface::interfaceFromName(currentNetworkInterface);
+}
+#endif
+
+void QNetworkSessionPrivateImpl::setSessionProperty(const QString& key, const QVariant& value)
+{
+    if (value.isValid()) {
+	properties.insert(key, value);
+
+	if (key == "ConnectInBackground") {
+	    bool v = value.toBool();
+	    if (v)
+		connectFlags = ICD_CONNECTION_FLAG_APPLICATION_EVENT;
+	    else
+		connectFlags = ICD_CONNECTION_FLAG_USER_EVENT;
+	}
+    } else {
+	properties.remove(key);
+
+	/* Set default value when property is removed */
+	if (key == "ConnectInBackground")
+	    connectFlags = ICD_CONNECTION_FLAG_USER_EVENT;
+    }
+}
+
+
+QVariant QNetworkSessionPrivateImpl::sessionProperty(const QString& key) const
+{
+    return properties.value(key);
+}
+
+
+QString QNetworkSessionPrivateImpl::errorString() const
+{
+    QString errorStr;
+    switch(q->error()) {
+    case QNetworkSession::RoamingError:
+        errorStr = QNetworkSessionPrivateImpl::tr("Roaming error");
+        break;
+    case QNetworkSession::SessionAbortedError:
+        errorStr = QNetworkSessionPrivateImpl::tr("Session aborted by user or system");
+        break;
+    default:
+    case QNetworkSession::UnknownSessionError:
+        errorStr = QNetworkSessionPrivateImpl::tr("Unidentified Error");
+        break;
+    }
+    return errorStr;
+}
+
+
+QNetworkSession::SessionError QNetworkSessionPrivateImpl::error() const
+{
+    return QNetworkSession::UnknownSessionError;
+}
+
+void QNetworkSessionPrivateImpl::updateProxies(QNetworkSession::State newState)
+{
+    if ((newState == QNetworkSession::Connected) &&
+	(newState != currentState))
+	updateProxyInformation();
+    else if ((newState == QNetworkSession::Disconnected) &&
+	    (currentState == QNetworkSession::Closing))
+	clearProxyInformation();
+
+    currentState = newState;
+}
+
+
+void QNetworkSessionPrivateImpl::updateProxyInformation()
+{
+    Maemo::ProxyConf::update();
+}
+
+
+void QNetworkSessionPrivateImpl::clearProxyInformation()
+{
+    Maemo::ProxyConf::clear();
+}
+
+#include "qnetworksession_impl.moc"
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/icd/qnetworksession_impl.h b/src/plugins/bearer/icd/qnetworksession_impl.h
new file mode 100644
index 0000000..c02faac
--- /dev/null
+++ b/src/plugins/bearer/icd/qnetworksession_impl.h
@@ -0,0 +1,149 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNETWORKSESSION_IMPL_H
+#define QNETWORKSESSION_IMPL_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtNetwork/private/qnetworksession_p.h>
+#include <QtNetwork/qnetworkconfigmanager.h>
+
+#include <QtCore/qdatetime.h>
+
+#include <icd/dbus_api.h>
+
+QT_BEGIN_NAMESPACE
+
+class QIcdEngine;
+
+class QNetworkSessionPrivateImpl : public QNetworkSessionPrivate
+{
+    Q_OBJECT
+
+public:
+    QNetworkSessionPrivateImpl(QIcdEngine *engine)
+    :   engine(engine), connectFlags(ICD_CONNECTION_FLAG_USER_EVENT), currentState(QNetworkSession::Invalid)
+    {
+    }
+
+    ~QNetworkSessionPrivateImpl()
+    {
+        cleanupSession();
+    }
+
+    //called by QNetworkSession constructor and ensures
+    //that the state is immediately updated (w/o actually opening
+    //a session). Also this function should take care of 
+    //notification hooks to discover future state changes.
+    void syncStateWithInterface();
+
+#ifndef QT_NO_NETWORKINTERFACE
+    QNetworkInterface currentInterface() const;
+#endif
+    QVariant sessionProperty(const QString& key) const;
+    void setSessionProperty(const QString& key, const QVariant& value);
+
+    void open();
+    void close();
+    void stop();
+
+    void migrate();
+    void accept();
+    void ignore();
+    void reject();
+
+    QString errorString() const; //must return translated string
+    QNetworkSession::SessionError error() const;
+
+    quint64 bytesWritten() const;
+    quint64 bytesReceived() const;
+    quint64 activeTime() const;
+
+private:
+    void updateStateFromServiceNetwork();
+    void updateStateFromActiveConfig();
+
+private Q_SLOTS:
+    void do_open();
+    void networkConfigurationsChanged();
+    void configurationChanged(const QNetworkConfiguration &config);
+    void updateProxies(QNetworkSession::State newState);
+
+private:
+    QNetworkConfigurationManager manager;
+    QIcdEngine *engine;
+
+    QNetworkConfiguration& copyConfig(QNetworkConfiguration &fromConfig, QNetworkConfiguration &toConfig, bool deepCopy = true);
+    void clearConfiguration(QNetworkConfiguration &config);
+    void cleanupAnyConfiguration();
+
+    bool opened;
+    icd_connection_flags connectFlags;
+
+    QNetworkSession::SessionError lastError;
+
+    QDateTime startTime;
+    QString currentNetworkInterface;
+    friend class IcdListener;
+    void updateState(QNetworkSession::State);
+    void updateIdentifier(QString &newId);
+    quint64 getStatistics(bool sent) const;
+    void cleanupSession(void);
+
+    void updateProxyInformation();
+    void clearProxyInformation();
+    QNetworkSession::State currentState;
+};
+
+QT_END_NAMESPACE
+
+#endif //QNETWORKSESSIONPRIVATE_H
+
diff --git a/src/plugins/bearer/nativewifi/main.cpp b/src/plugins/bearer/nativewifi/main.cpp
new file mode 100644
index 0000000..d77462e
--- /dev/null
+++ b/src/plugins/bearer/nativewifi/main.cpp
@@ -0,0 +1,139 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnativewifiengine.h"
+#include "platformdefs.h"
+
+#include <QtCore/qmutex.h>
+#include <QtCore/private/qmutexpool_p.h>
+#include <QtCore/qlibrary.h>
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+static void resolveLibrary()
+{
+    static volatile bool triedResolve = false;
+
+    if (!triedResolve) {
+#ifndef QT_NO_THREAD
+        QMutexLocker locker(QMutexPool::globalInstanceGet(&local_WlanOpenHandle));
+#endif
+
+        if (!triedResolve) {
+            local_WlanOpenHandle = (WlanOpenHandleProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanOpenHandle");
+            local_WlanRegisterNotification = (WlanRegisterNotificationProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanRegisterNotification");
+            local_WlanEnumInterfaces = (WlanEnumInterfacesProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanEnumInterfaces");
+            local_WlanGetAvailableNetworkList = (WlanGetAvailableNetworkListProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanGetAvailableNetworkList");
+            local_WlanQueryInterface = (WlanQueryInterfaceProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanQueryInterface");
+            local_WlanConnect = (WlanConnectProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanConnect");
+            local_WlanDisconnect = (WlanDisconnectProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanDisconnect");
+            local_WlanScan = (WlanScanProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanScan");
+            local_WlanFreeMemory = (WlanFreeMemoryProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanFreeMemory");
+            local_WlanCloseHandle = (WlanCloseHandleProto)
+                QLibrary::resolve(QLatin1String("wlanapi.dll"), "WlanCloseHandle");
+
+            triedResolve = true;
+        }
+    }
+}
+
+class QNativeWifiEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QNativeWifiEnginePlugin();
+    ~QNativeWifiEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QNativeWifiEnginePlugin::QNativeWifiEnginePlugin()
+{
+}
+
+QNativeWifiEnginePlugin::~QNativeWifiEnginePlugin()
+{
+}
+
+QStringList QNativeWifiEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("nativewifi");
+}
+
+QBearerEngine *QNativeWifiEnginePlugin::create(const QString &key) const
+{
+    if (key != QLatin1String("nativewifi"))
+        return 0;
+
+    resolveLibrary();
+
+    // native wifi dll not available
+    if (!local_WlanOpenHandle)
+        return 0;
+
+    QNativeWifiEngine *engine = new QNativeWifiEngine;
+
+    // could not initialise subsystem
+    if (engine && !engine->available()) {
+        delete engine;
+        return 0;
+    }
+
+    return engine;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QNativeWifiEnginePlugin)
+Q_EXPORT_PLUGIN2(qnativewifibearer, QNativeWifiEnginePlugin)
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/nativewifi/nativewifi.pro b/src/plugins/bearer/nativewifi/nativewifi.pro
new file mode 100644
index 0000000..f277a04
--- /dev/null
+++ b/src/plugins/bearer/nativewifi/nativewifi.pro
@@ -0,0 +1,17 @@
+TARGET = qnativewifibearer
+include(../../qpluginbase.pri)
+
+QT += network
+
+HEADERS += qnativewifiengine.h \
+           platformdefs.h \
+           ../qnetworksession_impl.h \
+           ../qbearerengine_impl.h
+
+SOURCES += main.cpp \
+           qnativewifiengine.cpp \
+           ../qnetworksession_impl.cpp
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
diff --git a/src/plugins/bearer/nativewifi/platformdefs.h b/src/plugins/bearer/nativewifi/platformdefs.h
new file mode 100644
index 0000000..57ae852
--- /dev/null
+++ b/src/plugins/bearer/nativewifi/platformdefs.h
@@ -0,0 +1,322 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef PLATFORMDEFS_H
+#define PLATFORMDEFS_H
+
+#include <wtypes.h>
+#undef interface
+
+#define WLAN_MAX_NAME_LENGTH 256
+#define WLAN_MAX_PHY_TYPE_NUMBER 8
+#define WLAN_NOTIFICATION_SOURCE_ALL 0x0000ffff
+#define WLAN_AVAILABLE_NETWORK_CONNECTED 1
+#define WLAN_AVAILABLE_NETWORK_HAS_PROFILE 2
+#define DOT11_SSID_MAX_LENGTH 32
+
+struct WLAN_NOTIFICATION_DATA {
+    DWORD NotificationSource;
+    DWORD NotificationCode;
+    GUID InterfaceGuid;
+    DWORD dwDataSize;
+    PVOID pData;
+};
+
+enum WLAN_INTERFACE_STATE {
+    wlan_interface_state_not_ready = 0,
+    wlan_interface_state_connected,
+    wlan_interface_state_ad_hoc_network_formed,
+    wlan_interface_state_disconnecting,
+    wlan_interface_state_disconnected,
+    wlan_interface_state_associating,
+    wlan_interface_state_discovering,
+    wlan_interface_state_authenticating
+};
+
+struct WLAN_INTERFACE_INFO {
+    GUID InterfaceGuid;
+    WCHAR strInterfaceDescription[WLAN_MAX_NAME_LENGTH];
+    WLAN_INTERFACE_STATE isState;
+};
+
+struct WLAN_INTERFACE_INFO_LIST {
+    DWORD dwNumberOfItems;
+    DWORD dwIndex;
+    WLAN_INTERFACE_INFO InterfaceInfo[1];
+};
+
+struct DOT11_SSID {
+    ULONG uSSIDLength;
+    UCHAR ucSSID[DOT11_SSID_MAX_LENGTH];
+};
+
+struct NDIS_OBJECT_HEADER {
+    UCHAR Type;
+    UCHAR Revision;
+    USHORT Size;
+};
+
+typedef UCHAR DOT11_MAC_ADDRESS[6];
+struct DOT11_BSSID_LIST {
+    NDIS_OBJECT_HEADER Header;
+    ULONG uNumberOfEntries;
+    ULONG uTotalNumOfEntries;
+    DOT11_MAC_ADDRESS BSSIDs[1];
+};
+
+enum DOT11_BSS_TYPE {
+    dot11_BSS_type_infrastructure = 1,
+    dot11_BSS_type_independent = 2,
+    dot11_BSS_type_any = 3
+};
+
+enum DOT11_PHY_TYPE {
+    dot11_phy_type_unknown = 0,
+    dot11_phy_type_any = dot11_phy_type_unknown,
+    dot11_phy_type_fhss = 1,
+    dot11_phy_type_dsss = 2,
+    dot11_phy_type_irbaseband = 3,
+    dot11_phy_type_ofdm = 4,
+    dot11_phy_type_hrdsss = 5,
+    dot11_phy_type_erp = 6,
+    dot11_phy_type_ht = 7,
+    dot11_phy_type_IHV_start = 0x80000000,
+    dot11_phy_type_IHV_end = 0xffffffff
+};
+
+enum DOT11_AUTH_ALGORITHM {
+    DOT11_AUTH_ALGO_80211_OPEN = 1,
+    DOT11_AUTH_ALGO_80211_SHARED_KEY = 2,
+    DOT11_AUTH_ALGO_WPA = 3,
+    DOT11_AUTH_ALGO_WPA_PSK = 4,
+    DOT11_AUTH_ALGO_WPA_NONE = 5,
+    DOT11_AUTH_ALGO_RSNA = 6,
+    DOT11_AUTH_ALGO_RSNA_PSK = 7,
+    DOT11_AUTH_ALGO_IHV_START = 0x80000000,
+    DOT11_AUTH_ALGO_IHV_END = 0xffffffff
+};
+
+enum DOT11_CIPHER_ALGORITHM {
+    DOT11_CIPHER_ALGO_NONE = 0x00,
+    DOT11_CIPHER_ALGO_WEP40 = 0x01,
+    DOT11_CIPHER_ALGO_TKIP = 0x02,
+    DOT11_CIPHER_ALGO_CCMP = 0x04,
+    DOT11_CIPHER_ALGO_WEP104 = 0x05,
+    DOT11_CIPHER_ALGO_WPA_USE_GROUP = 0x100,
+    DOT11_CIPHER_ALGO_RSN_USE_GROUP = 0x100,
+    DOT11_CIPHER_ALGO_WEP = 0x101,
+    DOT11_CIPHER_ALGO_IHV_START = 0x80000000,
+    DOT11_CIPHER_ALGO_IHV_END = 0xffffffff
+};
+
+struct WLAN_AVAILABLE_NETWORK {
+    WCHAR strProfileName[WLAN_MAX_NAME_LENGTH];
+    DOT11_SSID dot11Ssid;
+    DOT11_BSS_TYPE dot11BssType;
+    ULONG uNumberOfBssids;
+    BOOL bNetworkConnectable;
+    DWORD wlanNotConnectableReason;
+    ULONG uNumberOfPhyTypes;
+    DOT11_PHY_TYPE dot11PhyTypes[WLAN_MAX_PHY_TYPE_NUMBER];
+    BOOL bMorePhyTypes;
+    ULONG wlanSignalQuality;
+    BOOL bSecurityEnabled;
+    DOT11_AUTH_ALGORITHM dot11DefaultAuthAlgorithm;
+    DOT11_CIPHER_ALGORITHM dot11DefaultCipherAlgorithm;
+    DWORD dwFlags;
+    DWORD dwReserved;
+};
+
+struct WLAN_AVAILABLE_NETWORK_LIST {
+    DWORD dwNumberOfItems;
+    DWORD dwIndex;
+    WLAN_AVAILABLE_NETWORK Network[1];
+};
+
+enum WLAN_INTF_OPCODE {
+    wlan_intf_opcode_autoconf_start = 0x000000000,
+    wlan_intf_opcode_autoconf_enabled,
+    wlan_intf_opcode_background_scan_enabled,
+    wlan_intf_opcode_media_streaming_mode,
+    wlan_intf_opcode_radio_state,
+    wlan_intf_opcode_bss_type,
+    wlan_intf_opcode_interface_state,
+    wlan_intf_opcode_current_connection,
+    wlan_intf_opcode_channel_number,
+    wlan_intf_opcode_supported_infrastructure_auth_cipher_pairs,
+    wlan_intf_opcode_supported_adhoc_auth_cipher_pairs,
+    wlan_intf_opcode_supported_country_or_region_string_list,
+    wlan_intf_opcode_current_operation_mode,
+    wlan_intf_opcode_supported_safe_mode,
+    wlan_intf_opcode_certified_safe_mode,
+    wlan_intf_opcode_autoconf_end = 0x0fffffff,
+    wlan_intf_opcode_msm_start = 0x10000100,
+    wlan_intf_opcode_statistics,
+    wlan_intf_opcode_rssi,
+    wlan_intf_opcode_msm_end = 0x1fffffff,
+    wlan_intf_opcode_security_start = 0x20010000,
+    wlan_intf_opcode_security_end = 0x2fffffff,
+    wlan_intf_opcode_ihv_start = 0x30000000,
+    wlan_intf_opcode_ihv_end = 0x3fffffff
+};
+
+enum WLAN_OPCODE_VALUE_TYPE {
+    wlan_opcode_value_type_query_only = 0,
+    wlan_opcode_value_type_set_by_group_policy,
+    wlan_opcode_value_type_set_by_user,
+    wlan_opcode_value_type_invalid
+};
+
+enum WLAN_CONNECTION_MODE {
+    wlan_connection_mode_profile = 0,
+    wlan_connection_mode_temporary_profile,
+    wlan_connection_mode_discovery_secure,
+    wlan_connection_mode_discovery_unsecure,
+    wlan_connection_mode_auto,
+    wlan_connection_mode_invalid
+};
+
+struct WLAN_CONNECTION_PARAMETERS {
+    WLAN_CONNECTION_MODE wlanConnectionMode;
+    LPCWSTR strProfile;
+    DOT11_SSID *pDot11Ssid;
+    DOT11_BSSID_LIST *pDesiredBssidList;
+    DOT11_BSS_TYPE dot11BssType;
+    DWORD dwFlags;
+};
+
+struct WLAN_RAW_DATA {
+    DWORD dwDataSize;
+    BYTE DataBlob[1];
+};
+
+enum WLAN_NOTIFICATION_ACM {
+    wlan_notification_acm_start = 0,
+    wlan_notification_acm_autoconf_enabled,
+    wlan_notification_acm_autoconf_disabled,
+    wlan_notification_acm_background_scan_enabled,
+    wlan_notification_acm_background_scan_disabled,
+    wlan_notification_acm_bss_type_change,
+    wlan_notification_acm_power_setting_change,
+    wlan_notification_acm_scan_complete,
+    wlan_notification_acm_scan_fail,
+    wlan_notification_acm_connection_start,
+    wlan_notification_acm_connection_complete,
+    wlan_notification_acm_connection_attempt_fail,
+    wlan_notification_acm_filter_list_change,
+    wlan_notification_acm_interface_arrival,
+    wlan_notification_acm_interface_removal,
+    wlan_notification_acm_profile_change,
+    wlan_notification_acm_profile_name_change,
+    wlan_notification_acm_profiles_exhausted,
+    wlan_notification_acm_network_not_available,
+    wlan_notification_acm_network_available,
+    wlan_notification_acm_disconnecting,
+    wlan_notification_acm_disconnected,
+    wlan_notification_acm_adhoc_network_state_change,
+    wlan_notification_acm_end
+};
+
+struct WLAN_ASSOCIATION_ATTRIBUTES {
+    DOT11_SSID dot11Ssid;
+    DOT11_BSS_TYPE dot11BssType;
+    DOT11_MAC_ADDRESS dot11Bssid;
+    DOT11_PHY_TYPE dot11PhyType;
+    ULONG uDot11PhyIndex;
+    ULONG wlanSignalQuality;
+    ULONG ulRxRate;
+    ULONG ulTxRate;
+};
+
+struct WLAN_SECURITY_ATTRIBUTES {
+    BOOL bSecurityEnabled;
+    BOOL bOneXEnabled;
+    DOT11_AUTH_ALGORITHM dot11AuthAlgorithm;
+    DOT11_CIPHER_ALGORITHM dot11CipherAlgorithm;
+};
+
+struct WLAN_CONNECTION_ATTRIBUTES {
+    WLAN_INTERFACE_STATE isState;
+    WLAN_CONNECTION_MODE wlanConnectionMode;
+    WCHAR strProfileName[WLAN_MAX_NAME_LENGTH];
+    WLAN_ASSOCIATION_ATTRIBUTES wlanAssociationAttributes;
+    WLAN_SECURITY_ATTRIBUTES wlanSecurityAttributes;
+};
+
+typedef void (WINAPI *WLAN_NOTIFICATION_CALLBACK)(WLAN_NOTIFICATION_DATA *, PVOID);
+
+typedef DWORD (WINAPI *WlanOpenHandleProto)
+    (DWORD dwClientVersion, PVOID pReserved, PDWORD pdwNegotiatedVersion, PHANDLE phClientHandle);
+typedef DWORD (WINAPI *WlanRegisterNotificationProto)
+    (HANDLE hClientHandle, DWORD dwNotifSource, BOOL bIgnoreDuplicate,
+     WLAN_NOTIFICATION_CALLBACK funcCallback, PVOID pCallbackContext,
+     PVOID pReserved, PDWORD pdwPrevNotifSource);
+typedef DWORD (WINAPI *WlanEnumInterfacesProto)
+    (HANDLE hClientHandle, PVOID pReserved, WLAN_INTERFACE_INFO_LIST **ppInterfaceList);
+typedef DWORD (WINAPI *WlanGetAvailableNetworkListProto)
+    (HANDLE hClientHandle, const GUID* pInterfaceGuid, DWORD dwFlags, PVOID pReserved,
+     WLAN_AVAILABLE_NETWORK_LIST **ppAvailableNetworkList);
+typedef DWORD (WINAPI *WlanQueryInterfaceProto)
+    (HANDLE hClientHandle, const GUID *pInterfaceGuid, WLAN_INTF_OPCODE OpCode, PVOID pReserved,
+     PDWORD pdwDataSize, PVOID *ppData, WLAN_OPCODE_VALUE_TYPE *pWlanOpcodeValueType);
+typedef DWORD (WINAPI *WlanConnectProto)
+    (HANDLE hClientHandle, const GUID *pInterfaceGuid,
+     const WLAN_CONNECTION_PARAMETERS *pConnectionParameters, PVOID pReserved);
+typedef DWORD (WINAPI *WlanDisconnectProto)
+    (HANDLE hClientHandle, const GUID *pInterfaceGuid, PVOID pReserved);
+typedef DWORD (WINAPI *WlanScanProto)
+    (HANDLE hClientHandle, const GUID *pInterfaceGuid, const DOT11_SSID *pDot11Ssid,
+     const WLAN_RAW_DATA *pIeData, PVOID pReserved);
+typedef VOID (WINAPI *WlanFreeMemoryProto)(PVOID pMemory);
+typedef DWORD (WINAPI *WlanCloseHandleProto)(HANDLE hClientHandle, PVOID pReserved);
+
+extern WlanOpenHandleProto local_WlanOpenHandle;
+extern WlanRegisterNotificationProto local_WlanRegisterNotification;
+extern WlanEnumInterfacesProto local_WlanEnumInterfaces;
+extern WlanGetAvailableNetworkListProto local_WlanGetAvailableNetworkList;
+extern WlanQueryInterfaceProto local_WlanQueryInterface;
+extern WlanConnectProto local_WlanConnect;
+extern WlanDisconnectProto local_WlanDisconnect;
+extern WlanScanProto local_WlanScan;
+extern WlanFreeMemoryProto local_WlanFreeMemory;
+extern WlanCloseHandleProto local_WlanCloseHandle;
+
+#endif // PLATFORMDEFS_H
diff --git a/src/plugins/bearer/nativewifi/qnativewifiengine.cpp b/src/plugins/bearer/nativewifi/qnativewifiengine.cpp
new file mode 100644
index 0000000..6c74159
--- /dev/null
+++ b/src/plugins/bearer/nativewifi/qnativewifiengine.cpp
@@ -0,0 +1,560 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnativewifiengine.h"
+#include "platformdefs.h"
+#include "../qnetworksession_impl.h"
+
+#include <QtNetwork/private/qnetworkconfiguration_p.h>
+
+#include <QtCore/qstringlist.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+WlanOpenHandleProto local_WlanOpenHandle = 0;
+WlanRegisterNotificationProto local_WlanRegisterNotification = 0;
+WlanEnumInterfacesProto local_WlanEnumInterfaces = 0;
+WlanGetAvailableNetworkListProto local_WlanGetAvailableNetworkList = 0;
+WlanQueryInterfaceProto local_WlanQueryInterface = 0;
+WlanConnectProto local_WlanConnect = 0;
+WlanDisconnectProto local_WlanDisconnect = 0;
+WlanScanProto local_WlanScan = 0;
+WlanFreeMemoryProto local_WlanFreeMemory = 0;
+WlanCloseHandleProto local_WlanCloseHandle = 0;
+
+void qNotificationCallback(WLAN_NOTIFICATION_DATA *data, QNativeWifiEngine *d)
+{
+    Q_UNUSED(d);
+
+    switch (data->NotificationCode) {
+    case wlan_notification_acm_connection_complete:
+    case wlan_notification_acm_disconnected:
+        QMetaObject::invokeMethod(d, "scanComplete", Qt::QueuedConnection);
+        break;
+    default:
+        ;
+    }
+}
+
+QNativeWifiEngine::QNativeWifiEngine(QObject *parent)
+:   QBearerEngineImpl(parent), handle(0)
+{
+    DWORD clientVersion;
+
+    DWORD result = local_WlanOpenHandle(1, 0, &clientVersion, &handle);
+    if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        if (result != ERROR_SERVICE_NOT_ACTIVE)
+            qDebug("%s: WlanOpenHandle failed with error %ld\n", __FUNCTION__, result);
+#endif
+
+        return;
+    }
+
+    result = local_WlanRegisterNotification(handle, WLAN_NOTIFICATION_SOURCE_ALL, true,
+                                            WLAN_NOTIFICATION_CALLBACK(qNotificationCallback),
+                                            this, 0, 0);
+#ifdef BEARER_MANAGEMENT_DEBUG
+    if (result != ERROR_SUCCESS)
+        qDebug("%s: WlanRegisterNotification failed with error %ld\n", __FUNCTION__, result);
+#endif
+
+    scanComplete();
+}
+
+QNativeWifiEngine::~QNativeWifiEngine()
+{
+    local_WlanCloseHandle(handle, 0);
+}
+
+void QNativeWifiEngine::scanComplete()
+{
+    QMutexLocker locker(&mutex);
+
+    // enumerate interfaces
+    WLAN_INTERFACE_INFO_LIST *interfaceList;
+    DWORD result = local_WlanEnumInterfaces(handle, 0, &interfaceList);
+    if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: WlanEnumInterfaces failed with error %ld\n", __FUNCTION__, result);
+#endif
+
+        locker.unlock();
+        emit updateCompleted();
+
+        return;
+    }
+
+    QStringList previous = accessPointConfigurations.keys();
+
+    for (unsigned int i = 0; i < interfaceList->dwNumberOfItems; ++i) {
+        const WLAN_INTERFACE_INFO &interface = interfaceList->InterfaceInfo[i];
+
+        WLAN_AVAILABLE_NETWORK_LIST *networkList;
+        result = local_WlanGetAvailableNetworkList(handle, &interface.InterfaceGuid,
+                                                   3, 0, &networkList);
+        if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("%s: WlanGetAvailableNetworkList failed with error %ld\n",
+                   __FUNCTION__, result);
+#endif
+            continue;
+        }
+
+        QStringList seenNetworks;
+
+        for (unsigned int j = 0; j < networkList->dwNumberOfItems; ++j) {
+            WLAN_AVAILABLE_NETWORK &network = networkList->Network[j];
+
+            QString networkName;
+
+            if (network.strProfileName[0] != 0) {
+                networkName = QString::fromWCharArray(network.strProfileName);
+            } else {
+                networkName = QByteArray(reinterpret_cast<char *>(network.dot11Ssid.ucSSID),
+                                         network.dot11Ssid.uSSIDLength);
+            }
+
+            const QString id = QString::number(qHash(QLatin1String("WLAN:") + networkName));
+
+            previous.removeAll(id);
+
+            QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
+
+            if (!(network.dwFlags & WLAN_AVAILABLE_NETWORK_HAS_PROFILE))
+                state = QNetworkConfiguration::Undefined;
+
+            if (network.strProfileName[0] != 0) {
+                if (network.bNetworkConnectable) {
+                    if (network.dwFlags & WLAN_AVAILABLE_NETWORK_CONNECTED)
+                        state = QNetworkConfiguration::Active;
+                    else
+                        state = QNetworkConfiguration::Discovered;
+                } else {
+                    state = QNetworkConfiguration::Defined;
+                }
+            }
+
+            if (seenNetworks.contains(networkName))
+                continue;
+            else
+                seenNetworks.append(networkName);
+
+            if (accessPointConfigurations.contains(id)) {
+                QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+                bool changed = false;
+
+                ptr->mutex.lock();
+
+                if (!ptr->isValid) {
+                    ptr->isValid = true;
+                    changed = true;
+                }
+
+                if (ptr->name != networkName) {
+                    ptr->name = networkName;
+                    changed = true;
+                }
+
+                if (ptr->state != state) {
+                    ptr->state = state;
+                    changed = true;
+                }
+
+                ptr->mutex.unlock();
+
+                if (changed) {
+                    locker.unlock();
+                    emit configurationChanged(ptr);
+                    locker.relock();
+                }
+            } else {
+                QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
+
+                ptr->name = networkName;
+                ptr->isValid = true;
+                ptr->id = id;
+                ptr->state = state;
+                ptr->type = QNetworkConfiguration::InternetAccessPoint;
+                ptr->bearer = QLatin1String("WLAN");
+
+                accessPointConfigurations.insert(id, ptr);
+
+                locker.unlock();
+                emit configurationAdded(ptr);
+                locker.relock();
+            }
+        }
+
+        local_WlanFreeMemory(networkList);
+    }
+
+    local_WlanFreeMemory(interfaceList);
+
+    while (!previous.isEmpty()) {
+        QNetworkConfigurationPrivatePointer ptr =
+            accessPointConfigurations.take(previous.takeFirst());
+
+        locker.unlock();
+        emit configurationRemoved(ptr);
+        locker.relock();
+    }
+
+    locker.unlock();
+    emit updateCompleted();
+}
+
+QString QNativeWifiEngine::getInterfaceFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    // enumerate interfaces
+    WLAN_INTERFACE_INFO_LIST *interfaceList;
+    DWORD result = local_WlanEnumInterfaces(handle, 0, &interfaceList);
+    if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: WlanEnumInterfaces failed with error %ld\n", __FUNCTION__, result);
+#endif
+        return QString();
+    }
+
+    for (unsigned int i = 0; i < interfaceList->dwNumberOfItems; ++i) {
+        const WLAN_INTERFACE_INFO &interface = interfaceList->InterfaceInfo[i];
+
+        DWORD dataSize;
+        WLAN_CONNECTION_ATTRIBUTES *connectionAttributes;
+        result = local_WlanQueryInterface(handle, &interface.InterfaceGuid,
+                                          wlan_intf_opcode_current_connection, 0, &dataSize,
+                                          reinterpret_cast<PVOID *>(&connectionAttributes), 0);
+        if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            if (result != ERROR_INVALID_STATE)
+                qDebug("%s: WlanQueryInterface failed with error %ld\n", __FUNCTION__, result);
+#endif
+
+            continue;
+        }
+
+        if (qHash(QLatin1String("WLAN:") +
+                  QString::fromWCharArray(connectionAttributes->strProfileName)) == id.toUInt()) {
+            QString guid("{%1-%2-%3-%4%5-%6%7%8%9%10%11}");
+
+            guid = guid.arg(interface.InterfaceGuid.Data1, 8, 16, QChar('0'));
+            guid = guid.arg(interface.InterfaceGuid.Data2, 4, 16, QChar('0'));
+            guid = guid.arg(interface.InterfaceGuid.Data3, 4, 16, QChar('0'));
+            for (int i = 0; i < 8; ++i)
+                guid = guid.arg(interface.InterfaceGuid.Data4[i], 2, 16, QChar('0'));
+
+            local_WlanFreeMemory(connectionAttributes);
+            local_WlanFreeMemory(interfaceList);
+
+            return guid.toUpper();
+        }
+
+        local_WlanFreeMemory(connectionAttributes);
+    }
+
+    local_WlanFreeMemory(interfaceList);
+
+    return QString();
+}
+
+bool QNativeWifiEngine::hasIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    // enumerate interfaces
+    WLAN_INTERFACE_INFO_LIST *interfaceList;
+    DWORD result = local_WlanEnumInterfaces(handle, 0, &interfaceList);
+    if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: WlanEnumInterfaces failed with error %ld\n", __FUNCTION__, result);
+#endif
+        return false;
+    }
+
+    for (unsigned int i = 0; i < interfaceList->dwNumberOfItems; ++i) {
+        const WLAN_INTERFACE_INFO &interface = interfaceList->InterfaceInfo[i];
+
+        WLAN_AVAILABLE_NETWORK_LIST *networkList;
+        result = local_WlanGetAvailableNetworkList(handle, &interface.InterfaceGuid,
+                                                   3, 0, &networkList);
+        if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("%s: WlanGetAvailableNetworkList failed with error %ld\n",
+                   __FUNCTION__, result);
+#endif
+            continue;
+        }
+
+        for (unsigned int j = 0; j < networkList->dwNumberOfItems; ++j) {
+            WLAN_AVAILABLE_NETWORK &network = networkList->Network[j];
+
+            QString networkName;
+
+            if (network.strProfileName[0] != 0) {
+                networkName = QString::fromWCharArray(network.strProfileName);
+            } else {
+                networkName = QByteArray(reinterpret_cast<char *>(network.dot11Ssid.ucSSID),
+                                         network.dot11Ssid.uSSIDLength);
+            }
+
+            if (qHash(QLatin1String("WLAN:") + networkName) == id.toUInt()) {
+                local_WlanFreeMemory(networkList);
+                local_WlanFreeMemory(interfaceList);
+                return true;
+            }
+        }
+
+        local_WlanFreeMemory(networkList);
+    }
+
+    local_WlanFreeMemory(interfaceList);
+
+    return false;
+}
+
+/*QString QNativeWifiEngine::bearerName(const QString &)
+{
+    return QLatin1String("WLAN");
+}*/
+
+void QNativeWifiEngine::connectToId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    WLAN_INTERFACE_INFO_LIST *interfaceList;
+    DWORD result = local_WlanEnumInterfaces(handle, 0, &interfaceList);
+    if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: WlanEnumInterfaces failed with error %ld\n", __FUNCTION__, result);
+#endif
+        locker.unlock();
+        emit connectionError(id, InterfaceLookupError);
+        return;
+    }
+
+    QString profile;
+
+    for (unsigned int i = 0; i < interfaceList->dwNumberOfItems; ++i) {
+        const WLAN_INTERFACE_INFO &interface = interfaceList->InterfaceInfo[i];
+
+        WLAN_AVAILABLE_NETWORK_LIST *networkList;
+        result = local_WlanGetAvailableNetworkList(handle, &interface.InterfaceGuid,
+                                                   3, 0, &networkList);
+        if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("%s: WlanGetAvailableNetworkList failed with error %ld\n",
+                   __FUNCTION__, result);
+#endif
+            continue;
+        }
+
+        for (unsigned int j = 0; j < networkList->dwNumberOfItems; ++j) {
+            WLAN_AVAILABLE_NETWORK &network = networkList->Network[j];
+
+            profile = QString::fromWCharArray(network.strProfileName);
+
+            if (qHash(QLatin1String("WLAN:") + profile) == id.toUInt())
+                break;
+            else
+                profile.clear();
+        }
+
+        local_WlanFreeMemory(networkList);
+
+        if (!profile.isEmpty()) {
+            WLAN_CONNECTION_PARAMETERS parameters;
+            parameters.wlanConnectionMode = wlan_connection_mode_profile;
+            parameters.strProfile = reinterpret_cast<LPCWSTR>(profile.utf16());
+            parameters.pDot11Ssid = 0;
+            parameters.pDesiredBssidList = 0;
+            parameters.dot11BssType = dot11_BSS_type_any;
+            parameters.dwFlags = 0;
+
+            DWORD result = local_WlanConnect(handle, &interface.InterfaceGuid, &parameters, 0);
+            if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+                qDebug("%s: WlanConnect failed with error %ld\n", __FUNCTION__, result);
+#endif
+                locker.unlock();
+                emit connectionError(id, ConnectError);
+                locker.relock();
+                break;
+            }
+
+            break;
+        }
+    }
+
+    local_WlanFreeMemory(interfaceList);
+
+    if (profile.isEmpty()) {
+        locker.unlock();
+        emit connectionError(id, InterfaceLookupError);
+    }
+}
+
+void QNativeWifiEngine::disconnectFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QString interface = getInterfaceFromId(id);
+
+    if (interface.isEmpty()) {
+        locker.unlock();
+        emit connectionError(id, InterfaceLookupError);
+        return;
+    }
+
+    QStringList split = interface.mid(1, interface.length() - 2).split('-');
+
+    GUID guid;
+    guid.Data1 = split.at(0).toUInt(0, 16);
+    guid.Data2 = split.at(1).toUShort(0, 16);
+    guid.Data3 = split.at(2).toUShort(0, 16);
+    guid.Data4[0] = split.at(3).left(2).toUShort(0, 16);
+    guid.Data4[1] = split.at(3).right(2).toUShort(0, 16);
+    for (int i = 0; i < 6; ++i)
+        guid.Data4[i + 2] = split.at(4).mid(i*2, 2).toUShort(0, 16);
+
+    DWORD result = local_WlanDisconnect(handle, &guid, 0);
+    if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: WlanDisconnect failed with error %ld\n", __FUNCTION__, result);
+#endif
+        locker.unlock();
+        emit connectionError(id, DisconnectionError);
+        return;
+    }
+}
+
+void QNativeWifiEngine::requestUpdate()
+{
+    QMutexLocker locker(&mutex);
+
+    // enumerate interfaces
+    WLAN_INTERFACE_INFO_LIST *interfaceList;
+    DWORD result = local_WlanEnumInterfaces(handle, 0, &interfaceList);
+    if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: WlanEnumInterfaces failed with error %ld\n", __FUNCTION__, result);
+#endif
+
+        locker.unlock();
+        emit updateCompleted();
+
+        return;
+    }
+
+    bool requested = false;
+    for (unsigned int i = 0; i < interfaceList->dwNumberOfItems; ++i) {
+        result = local_WlanScan(handle, &interfaceList->InterfaceInfo[i].InterfaceGuid, 0, 0, 0);
+        if (result != ERROR_SUCCESS) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("%s: WlanScan failed with error %ld\n", __FUNCTION__, result);
+#endif
+        } else {
+            requested = true;
+        }
+    }
+
+    local_WlanFreeMemory(interfaceList);
+
+    if (!requested) {
+        locker.unlock();
+        emit updateCompleted();
+    }
+}
+
+QNetworkSession::State QNativeWifiEngine::sessionStateForId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+    if (!ptr)
+        return QNetworkSession::Invalid;
+
+    if (!ptr->isValid) {
+        return QNetworkSession::Invalid;
+    } else if ((ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+        return QNetworkSession::Connected;
+    } else if ((ptr->state & QNetworkConfiguration::Discovered) ==
+                QNetworkConfiguration::Discovered) {
+        return QNetworkSession::Disconnected;
+    } else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) {
+        return QNetworkSession::NotAvailable;
+    } else if ((ptr->state & QNetworkConfiguration::Undefined) ==
+                QNetworkConfiguration::Undefined) {
+        return QNetworkSession::NotAvailable;
+    }
+
+    return QNetworkSession::Invalid;
+}
+
+QNetworkConfigurationManager::Capabilities QNativeWifiEngine::capabilities() const
+{
+    return QNetworkConfigurationManager::ForcedRoaming |
+            QNetworkConfigurationManager::CanStartAndStopInterfaces;
+}
+
+QNetworkSessionPrivate *QNativeWifiEngine::createSessionBackend()
+{
+    return new QNetworkSessionPrivateImpl;
+}
+
+QNetworkConfigurationPrivatePointer QNativeWifiEngine::defaultConfiguration()
+{
+    return QNetworkConfigurationPrivatePointer();
+}
+
+bool QNativeWifiEngine::requiresPolling() const
+{
+    // On Windows XP SP2 and SP3 only connection and disconnection notifications are available.
+    // We need to poll for changes in available wireless networks.
+    return true;
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/nativewifi/qnativewifiengine.h b/src/plugins/bearer/nativewifi/qnativewifiengine.h
new file mode 100644
index 0000000..2005b2b
--- /dev/null
+++ b/src/plugins/bearer/nativewifi/qnativewifiengine.h
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNATIVEWIFIENGINE_P_H
+#define QNATIVEWIFIENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "../qbearerengine_impl.h"
+
+#include <QtCore/qtimer.h>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkConfigurationPrivate;
+struct WLAN_NOTIFICATION_DATA;
+
+class QNativeWifiEngine : public QBearerEngineImpl
+{
+    Q_OBJECT
+
+public:
+    QNativeWifiEngine(QObject *parent = 0);
+    ~QNativeWifiEngine();
+
+    QString getInterfaceFromId(const QString &id);
+    bool hasIdentifier(const QString &id);
+
+    //QString bearerName(const QString &id);
+
+    void connectToId(const QString &id);
+    void disconnectFromId(const QString &id);
+
+    Q_INVOKABLE void requestUpdate();
+
+    QNetworkSession::State sessionStateForId(const QString &id);
+
+    QNetworkConfigurationManager::Capabilities capabilities() const;
+
+    QNetworkSessionPrivate *createSessionBackend();
+
+    QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+    inline bool available() const { return handle != 0; }
+
+    bool requiresPolling() const;
+
+public Q_SLOTS:
+    void scanComplete();
+
+private:
+    Qt::HANDLE handle;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/plugins/bearer/networkmanager/main.cpp b/src/plugins/bearer/networkmanager/main.cpp
new file mode 100644
index 0000000..6c97a22
--- /dev/null
+++ b/src/plugins/bearer/networkmanager/main.cpp
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnetworkmanagerengine.h"
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkManagerEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QNetworkManagerEnginePlugin();
+    ~QNetworkManagerEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QNetworkManagerEnginePlugin::QNetworkManagerEnginePlugin()
+{
+}
+
+QNetworkManagerEnginePlugin::~QNetworkManagerEnginePlugin()
+{
+}
+
+QStringList QNetworkManagerEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("networkmanager");
+}
+
+QBearerEngine *QNetworkManagerEnginePlugin::create(const QString &key) const
+{
+    if (key == QLatin1String("networkmanager")) {
+        QNetworkManagerEngine *engine = new QNetworkManagerEngine;
+        if (engine->networkManagerAvailable())
+            return engine;
+        else
+            delete engine;
+    }
+
+    return 0;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QNetworkManagerEnginePlugin)
+Q_EXPORT_PLUGIN2(qnmbearer, QNetworkManagerEnginePlugin)
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/networkmanager/networkmanager.pro b/src/plugins/bearer/networkmanager/networkmanager.pro
new file mode 100644
index 0000000..bf0d29a
--- /dev/null
+++ b/src/plugins/bearer/networkmanager/networkmanager.pro
@@ -0,0 +1,20 @@
+TARGET = qnmbearer
+include(../../qpluginbase.pri)
+
+QT += network dbus
+
+HEADERS += qnmdbushelper.h \
+           qnetworkmanagerservice.h \
+           qnetworkmanagerengine.h \
+           ../qnetworksession_impl.h \
+           ../qbearerengine_impl.h
+
+SOURCES += main.cpp \
+           qnmdbushelper.cpp \
+           qnetworkmanagerservice.cpp \
+           qnetworkmanagerengine.cpp \
+           ../qnetworksession_impl.cpp
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
diff --git a/src/plugins/bearer/networkmanager/qnetworkmanagerengine.cpp b/src/plugins/bearer/networkmanager/qnetworkmanagerengine.cpp
new file mode 100644
index 0000000..72d6838
--- /dev/null
+++ b/src/plugins/bearer/networkmanager/qnetworkmanagerengine.cpp
@@ -0,0 +1,917 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnetworkmanagerengine.h"
+#include "qnetworkmanagerservice.h"
+#include "../qnetworksession_impl.h"
+
+#include <QtNetwork/private/qnetworkconfiguration_p.h>
+
+#include <QtNetwork/qnetworksession.h>
+
+#include <QtCore/qdebug.h>
+
+#include <QtDBus>
+#include <QDBusConnection>
+#include <QDBusError>
+#include <QDBusInterface>
+#include <QDBusMessage>
+#include <QDBusReply>
+
+QT_BEGIN_NAMESPACE
+
+QNetworkManagerEngine::QNetworkManagerEngine(QObject *parent)
+:   QBearerEngineImpl(parent),
+    interface(new QNetworkManagerInterface(this)),
+    systemSettings(new QNetworkManagerSettings(NM_DBUS_SERVICE_SYSTEM_SETTINGS, this)),
+    userSettings(new QNetworkManagerSettings(NM_DBUS_SERVICE_USER_SETTINGS, this))
+{
+    if (!interface->isValid())
+        return;
+
+    interface->setConnections();
+    connect(interface, SIGNAL(deviceAdded(QDBusObjectPath)),
+            this, SLOT(deviceAdded(QDBusObjectPath)));
+    connect(interface, SIGNAL(deviceRemoved(QDBusObjectPath)),
+            this, SLOT(deviceRemoved(QDBusObjectPath)));
+#if 0
+    connect(interface, SIGNAL(stateChanged(const QString,quint32)),
+            this, SIGNAL(configurationsChanged()));
+#endif
+    connect(interface, SIGNAL(activationFinished(QDBusPendingCallWatcher*)),
+            this, SLOT(activationFinished(QDBusPendingCallWatcher*)));
+    connect(interface, SIGNAL(propertiesChanged(QString,QMap<QString,QVariant>)),
+            this, SLOT(interfacePropertiesChanged(QString,QMap<QString,QVariant>)));
+
+    qDBusRegisterMetaType<QNmSettingsMap>();
+
+    systemSettings->setConnections();
+    connect(systemSettings, SIGNAL(newConnection(QDBusObjectPath)),
+            this, SLOT(newConnection(QDBusObjectPath)));
+
+    userSettings->setConnections();
+    connect(userSettings, SIGNAL(newConnection(QDBusObjectPath)),
+            this, SLOT(newConnection(QDBusObjectPath)));
+
+    QMetaObject::invokeMethod(this, "init", Qt::QueuedConnection);
+}
+
+QNetworkManagerEngine::~QNetworkManagerEngine()
+{
+}
+
+void QNetworkManagerEngine::init()
+{
+    // Get current list of access points.
+    foreach (const QDBusObjectPath &devicePath, interface->getDevices())
+        deviceAdded(devicePath);
+
+    // Get connections.
+    foreach (const QDBusObjectPath &settingsPath, systemSettings->listConnections())
+        newConnection(settingsPath, systemSettings);
+    foreach (const QDBusObjectPath &settingsPath, userSettings->listConnections())
+        newConnection(settingsPath, userSettings);
+
+    // Get active connections.
+    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {
+        QNetworkManagerConnectionActive *activeConnection =
+            new QNetworkManagerConnectionActive(acPath.path());
+        activeConnections.insert(acPath.path(), activeConnection);
+
+        activeConnection->setConnections();
+        connect(activeConnection, SIGNAL(propertiesChanged(QString,QMap<QString,QVariant>)),
+                this, SLOT(activeConnectionPropertiesChanged(QString,QMap<QString,QVariant>)));
+    }
+}
+
+bool QNetworkManagerEngine::networkManagerAvailable() const
+{
+    QMutexLocker locker(&mutex);
+
+    return interface->isValid();
+}
+
+void QNetworkManagerEngine::doRequestUpdate()
+{
+    emit updateCompleted();
+}
+
+QString QNetworkManagerEngine::getInterfaceFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {
+        QNetworkManagerConnectionActive activeConnection(acPath.path());
+
+        const QString identifier = QString::number(qHash(activeConnection.serviceName() + ' ' +
+                                                         activeConnection.connection().path()));
+
+        if (id == identifier) {
+            QList<QDBusObjectPath> devices = activeConnection.devices();
+
+            if (devices.isEmpty())
+                continue;
+
+            QNetworkManagerInterfaceDevice device(devices.at(0).path());
+            return device.networkInterface();
+        }
+    }
+
+    return QString();
+}
+
+bool QNetworkManagerEngine::hasIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    if (connectionFromId(id))
+        return true;
+
+    for (int i = 0; i < accessPoints.count(); ++i) {
+        QNetworkManagerInterfaceAccessPoint *accessPoint = accessPoints.at(i);
+
+        const QString identifier =
+            QString::number(qHash(accessPoint->connectionInterface()->path()));
+
+        if (id == identifier)
+            return true;
+    }
+
+    return false;
+}
+
+QString QNetworkManagerEngine::bearerName(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkManagerSettingsConnection *connection = connectionFromId(id);
+
+    if (!connection)
+        return QString();
+
+    QNmSettingsMap map = connection->getSettings();
+    const QString connectionType = map.value("connection").value("type").toString();
+
+    if (connectionType == "802-3-ethernet")
+        return QLatin1String("Ethernet");
+    else if (connectionType == "802-11-wireless")
+        return QLatin1String("WLAN");
+    else if (connectionType == "gsm")
+        return QLatin1String("2G");
+    else if (connectionType == "cdma")
+        return QLatin1String("CDMA2000");
+    else
+        return QString();
+}
+
+void QNetworkManagerEngine::connectToId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkManagerSettingsConnection *connection = connectionFromId(id);
+
+    if (!connection)
+        return;
+
+    QNmSettingsMap map = connection->getSettings();
+    const QString connectionType = map.value("connection").value("type").toString();
+
+    QString dbusDevicePath;
+    foreach (const QDBusObjectPath &devicePath, interface->getDevices()) {
+        QNetworkManagerInterfaceDevice device(devicePath.path());
+        if (device.deviceType() == DEVICE_TYPE_802_3_ETHERNET &&
+            connectionType == QLatin1String("802-3-ethernet")) {
+            dbusDevicePath = devicePath.path();
+            break;
+        } else if (device.deviceType() == DEVICE_TYPE_802_11_WIRELESS &&
+                   connectionType == QLatin1String("802-11-wireless")) {
+            dbusDevicePath = devicePath.path();
+            break;
+        }
+    }
+
+    const QString service = connection->connectionInterface()->service();
+    const QString settingsPath = connection->connectionInterface()->path();
+
+    interface->activateConnection(service, QDBusObjectPath(settingsPath),
+                                  QDBusObjectPath(dbusDevicePath), QDBusObjectPath("/"));
+}
+
+void QNetworkManagerEngine::disconnectFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {
+        QNetworkManagerConnectionActive activeConnection(acPath.path());
+
+        const QString identifier = QString::number(qHash(activeConnection.serviceName() + ' ' +
+                                                         activeConnection.connection().path()));
+
+        if (id == identifier && accessPointConfigurations.contains(id)) {
+            interface->deactivateConnection(acPath);
+            break;
+        }
+    }
+}
+
+void QNetworkManagerEngine::requestUpdate()
+{
+    QMutexLocker locker(&mutex);
+
+    QTimer::singleShot(0, this, SLOT(doRequestUpdate()));
+}
+
+void QNetworkManagerEngine::interfacePropertiesChanged(const QString &path,
+                                                       const QMap<QString, QVariant> &properties)
+{
+    QMutexLocker locker(&mutex);
+
+    Q_UNUSED(path)
+
+    QMapIterator<QString, QVariant> i(properties);
+    while (i.hasNext()) {
+        i.next();
+
+        if (i.key() == QLatin1String("ActiveConnections")) {
+            // Active connections changed, update configurations.
+
+            QList<QDBusObjectPath> activeConnections =
+                qdbus_cast<QList<QDBusObjectPath> >(i.value().value<QDBusArgument>());
+
+            QStringList identifiers = accessPointConfigurations.keys();
+            foreach (const QString &id, identifiers)
+                QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+            QStringList priorActiveConnections = this->activeConnections.keys();
+
+            foreach (const QDBusObjectPath &acPath, activeConnections) {
+                priorActiveConnections.removeOne(acPath.path());
+                QNetworkManagerConnectionActive *activeConnection =
+                    this->activeConnections.value(acPath.path());
+                if (!activeConnection) {
+                    activeConnection = new QNetworkManagerConnectionActive(acPath.path());
+                    this->activeConnections.insert(acPath.path(), activeConnection);
+
+                    activeConnection->setConnections();
+                    connect(activeConnection, SIGNAL(propertiesChanged(QString,QMap<QString,QVariant>)),
+                            this, SLOT(activeConnectionPropertiesChanged(QString,QMap<QString,QVariant>)));
+                }
+
+                const QString id = QString::number(qHash(activeConnection->serviceName() + ' ' +
+                                                         activeConnection->connection().path()));
+
+                identifiers.removeOne(id);
+
+                QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+                if (ptr) {
+                    ptr->mutex.lock();
+                    if (activeConnection->state() == 2 &&
+                        ptr->state != QNetworkConfiguration::Active) {
+                        ptr->state = QNetworkConfiguration::Active;
+                        ptr->mutex.unlock();
+
+                        locker.unlock();
+                        emit configurationChanged(ptr);
+                        locker.relock();
+                    } else {
+                        ptr->mutex.unlock();
+                    }
+                }
+            }
+
+            while (!priorActiveConnections.isEmpty())
+                delete this->activeConnections.take(priorActiveConnections.takeFirst());
+
+            while (!identifiers.isEmpty()) {
+                // These configurations are not active
+                QNetworkConfigurationPrivatePointer ptr =
+                    accessPointConfigurations.value(identifiers.takeFirst());
+
+                ptr->mutex.lock();
+                if ((ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+                    ptr->state = QNetworkConfiguration::Discovered;
+                    ptr->mutex.unlock();
+
+                    locker.unlock();
+                    emit configurationChanged(ptr);
+                    locker.relock();
+                } else {
+                    ptr->mutex.unlock();
+                }
+            }
+        }
+    }
+}
+
+void QNetworkManagerEngine::activeConnectionPropertiesChanged(const QString &path,
+                                                              const QMap<QString, QVariant> &properties)
+{
+    QMutexLocker locker(&mutex);
+
+    Q_UNUSED(properties)
+
+    QNetworkManagerConnectionActive *activeConnection = activeConnections.value(path);
+
+    if (!activeConnection)
+        return;
+
+    const QString id = QString::number(qHash(activeConnection->serviceName() + ' ' +
+                                             activeConnection->connection().path()));
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+    if (ptr) {
+        ptr->mutex.lock();
+        if (activeConnection->state() == 2 &&
+            ptr->state != QNetworkConfiguration::Active) {
+            ptr->state = QNetworkConfiguration::Active;
+            ptr->mutex.unlock();
+
+            locker.unlock();
+            emit configurationChanged(ptr);
+            locker.relock();
+        } else {
+            ptr->mutex.unlock();
+        }
+    }
+}
+
+void QNetworkManagerEngine::devicePropertiesChanged(const QString &path,
+                                                    const QMap<QString, QVariant> &properties)
+{
+    Q_UNUSED(path);
+    Q_UNUSED(properties);
+}
+
+void QNetworkManagerEngine::deviceAdded(const QDBusObjectPath &path)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkManagerInterfaceDevice device(path.path());
+    if (device.deviceType() == DEVICE_TYPE_802_11_WIRELESS) {
+        QNetworkManagerInterfaceDeviceWireless *wirelessDevice =
+            new QNetworkManagerInterfaceDeviceWireless(device.connectionInterface()->path());
+        wirelessDevices.insert(path.path(), wirelessDevice);
+
+        wirelessDevice->setConnections();
+        connect(wirelessDevice, SIGNAL(accessPointAdded(QString,QDBusObjectPath)),
+                this, SLOT(newAccessPoint(QString,QDBusObjectPath)));
+        connect(wirelessDevice, SIGNAL(accessPointRemoved(QString,QDBusObjectPath)),
+                this, SLOT(removeAccessPoint(QString,QDBusObjectPath)));
+        connect(wirelessDevice, SIGNAL(propertiesChanged(QString,QMap<QString,QVariant>)),
+                this, SLOT(devicePropertiesChanged(QString,QMap<QString,QVariant>)));
+
+        foreach (const QDBusObjectPath &apPath, wirelessDevice->getAccessPoints())
+            newAccessPoint(QString(), apPath);
+    }
+}
+
+void QNetworkManagerEngine::deviceRemoved(const QDBusObjectPath &path)
+{
+    QMutexLocker locker(&mutex);
+
+    delete wirelessDevices.value(path.path());
+}
+
+void QNetworkManagerEngine::newConnection(const QDBusObjectPath &path,
+                                          QNetworkManagerSettings *settings)
+{
+    QMutexLocker locker(&mutex);
+
+    if (!settings)
+        settings = qobject_cast<QNetworkManagerSettings *>(sender());
+
+    if (!settings)
+        return;
+
+    QNetworkManagerSettingsConnection *connection =
+        new QNetworkManagerSettingsConnection(settings->connectionInterface()->service(),
+                                              path.path());
+    connections.append(connection);
+
+    connect(connection, SIGNAL(removed(QString)), this, SLOT(removeConnection(QString)));
+    connect(connection, SIGNAL(updated(const QNmSettingsMap&)),
+            this, SLOT(updateConnection(const QNmSettingsMap&)));
+
+    const QString service = connection->connectionInterface()->service();
+    const QString settingsPath = connection->connectionInterface()->path();
+
+    QNetworkConfigurationPrivate *cpPriv =
+        parseConnection(service, settingsPath, connection->getSettings());
+
+    // Check if connection is active.
+    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {
+        QNetworkManagerConnectionActive activeConnection(acPath.path());
+
+        if (activeConnection.serviceName() == service &&
+            activeConnection.connection().path() == settingsPath &&
+            activeConnection.state() == 2) {
+            cpPriv->state |= QNetworkConfiguration::Active;
+            break;
+        }
+    }
+
+    QNetworkConfigurationPrivatePointer ptr(cpPriv);
+    accessPointConfigurations.insert(ptr->id, ptr);
+
+    locker.unlock();
+    emit configurationAdded(ptr);
+}
+
+void QNetworkManagerEngine::removeConnection(const QString &path)
+{
+    QMutexLocker locker(&mutex);
+
+    Q_UNUSED(path)
+
+    QNetworkManagerSettingsConnection *connection =
+        qobject_cast<QNetworkManagerSettingsConnection *>(sender());
+    if (!connection)
+        return;
+
+    connections.removeAll(connection);
+
+    const QString id = QString::number(qHash(connection->connectionInterface()->service() + ' ' +
+                                             connection->connectionInterface()->path()));
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(id);
+
+    locker.unlock();
+    emit configurationRemoved(ptr);
+}
+
+void QNetworkManagerEngine::updateConnection(const QNmSettingsMap &settings)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkManagerSettingsConnection *connection =
+        qobject_cast<QNetworkManagerSettingsConnection *>(sender());
+    if (!connection)
+        return;
+
+    const QString service = connection->connectionInterface()->service();
+    const QString settingsPath = connection->connectionInterface()->path();
+
+    QNetworkConfigurationPrivate *cpPriv = parseConnection(service, settingsPath, settings);
+
+    // Check if connection is active.
+    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {
+        QNetworkManagerConnectionActive activeConnection(acPath.path());
+
+        if (activeConnection.serviceName() == service &&
+            activeConnection.connection().path() == settingsPath &&
+            activeConnection.state() == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {
+            cpPriv->state |= QNetworkConfiguration::Active;
+            break;
+        }
+    }
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(cpPriv->id);
+
+    ptr->mutex.lock();
+
+    ptr->isValid = cpPriv->isValid;
+    ptr->name = cpPriv->name;
+    ptr->id = cpPriv->id;
+    ptr->state = cpPriv->state;
+
+    ptr->mutex.unlock();
+
+    locker.unlock();
+    emit configurationChanged(ptr);
+    delete cpPriv;
+}
+
+void QNetworkManagerEngine::activationFinished(QDBusPendingCallWatcher *watcher)
+{
+    QMutexLocker locker(&mutex);
+
+    QDBusPendingReply<QDBusObjectPath> reply = *watcher;
+    if (!reply.isError()) {
+        QDBusObjectPath result = reply.value();
+
+        QNetworkManagerConnectionActive activeConnection(result.path());
+
+        const QString id = QString::number(qHash(activeConnection.serviceName() + ' ' +
+                                                 activeConnection.connection().path()));
+
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+        if (ptr) {
+            ptr->mutex.lock();
+            if (activeConnection.state() == 2 &&
+                ptr->state != QNetworkConfiguration::Active) {
+                ptr->state = QNetworkConfiguration::Active;
+                ptr->mutex.unlock();
+
+                locker.unlock();
+                emit configurationChanged(ptr);
+                locker.relock();
+            } else {
+                ptr->mutex.unlock();
+            }
+        }
+    }
+}
+
+void QNetworkManagerEngine::newAccessPoint(const QString &path, const QDBusObjectPath &objectPath)
+{
+    QMutexLocker locker(&mutex);
+
+    Q_UNUSED(path)
+
+    QNetworkManagerInterfaceAccessPoint *accessPoint =
+        new QNetworkManagerInterfaceAccessPoint(objectPath.path());
+    accessPoints.append(accessPoint);
+
+    accessPoint->setConnections();
+    connect(accessPoint, SIGNAL(propertiesChanged(QMap<QString,QVariant>)),
+            this, SLOT(updateAccessPoint(QMap<QString,QVariant>)));
+
+    // Check if configuration for this SSID already exists.
+    for (int i = 0; i < accessPoints.count(); ++i) {
+        if (accessPoint != accessPoints.at(i) &&
+            accessPoint->ssid() == accessPoints.at(i)->ssid()) {
+            return;
+        }
+    }
+
+    // Check if configuration exists for connection.
+    if (!accessPoint->ssid().isEmpty()) {
+        for (int i = 0; i < connections.count(); ++i) {
+            QNetworkManagerSettingsConnection *connection = connections.at(i);
+
+            if (accessPoint->ssid() == connection->getSsid()) {
+                const QString service = connection->connectionInterface()->service();
+                const QString settingsPath = connection->connectionInterface()->path();
+                const QString connectionId = QString::number(qHash(service + ' ' + settingsPath));
+
+                QNetworkConfigurationPrivatePointer ptr =
+                    accessPointConfigurations.value(connectionId);
+                ptr->mutex.lock();
+                ptr->state = QNetworkConfiguration::Discovered;
+                ptr->mutex.unlock();
+
+                locker.unlock();
+                emit configurationChanged(ptr);
+                return;
+            }
+        }
+    }
+
+    // New access point.
+    QNetworkConfigurationPrivatePointer ptr(new QNetworkConfigurationPrivate);
+
+    ptr->name = accessPoint->ssid();
+    ptr->isValid = true;
+    ptr->id = QString::number(qHash(objectPath.path()));
+    ptr->type = QNetworkConfiguration::InternetAccessPoint;
+    if(accessPoint->flags() == NM_802_11_AP_FLAGS_PRIVACY) {
+        ptr->purpose = QNetworkConfiguration::PrivatePurpose;
+    } else {
+        ptr->purpose = QNetworkConfiguration::PublicPurpose;
+    }
+    ptr->state = QNetworkConfiguration::Undefined;
+    ptr->bearer = QLatin1String("WLAN");
+
+    accessPointConfigurations.insert(ptr->id, ptr);
+
+    locker.unlock();
+    emit configurationAdded(ptr);
+}
+
+void QNetworkManagerEngine::removeAccessPoint(const QString &path,
+                                              const QDBusObjectPath &objectPath)
+{
+    QMutexLocker locker(&mutex);
+
+    Q_UNUSED(path)
+
+    for (int i = 0; i < accessPoints.count(); ++i) {
+        QNetworkManagerInterfaceAccessPoint *accessPoint = accessPoints.at(i);
+
+        if (accessPoint->connectionInterface()->path() == objectPath.path()) {
+            accessPoints.removeOne(accessPoint);
+
+            if (configuredAccessPoints.contains(accessPoint)) {
+                // find connection and change state to Defined
+                configuredAccessPoints.removeOne(accessPoint);
+                for (int i = 0; i < connections.count(); ++i) {
+                    QNetworkManagerSettingsConnection *connection = connections.at(i);
+
+                    if (accessPoint->ssid() == connection->getSsid()) {
+                        const QString service = connection->connectionInterface()->service();
+                        const QString settingsPath = connection->connectionInterface()->path();
+                        const QString connectionId =
+                            QString::number(qHash(service + ' ' + settingsPath));
+
+                        QNetworkConfigurationPrivatePointer ptr =
+                            accessPointConfigurations.value(connectionId);
+                        ptr->mutex.lock();
+                        ptr->state = QNetworkConfiguration::Defined;
+                        ptr->mutex.unlock();
+
+                        locker.unlock();
+                        emit configurationChanged(ptr);
+                        return;
+                    }
+                }
+            } else {
+                QNetworkConfigurationPrivatePointer ptr =
+                    accessPointConfigurations.take(QString::number(qHash(objectPath.path())));
+
+                if (ptr) {
+                    locker.unlock();
+                    emit configurationRemoved(ptr);
+                    locker.relock();
+                }
+            }
+
+            delete accessPoint;
+
+            break;
+        }
+    }
+}
+
+void QNetworkManagerEngine::updateAccessPoint(const QMap<QString, QVariant> &map)
+{
+    QMutexLocker locker(&mutex);
+
+    Q_UNUSED(map)
+
+    QNetworkManagerInterfaceAccessPoint *accessPoint =
+        qobject_cast<QNetworkManagerInterfaceAccessPoint *>(sender());
+    if (!accessPoint)
+        return;
+
+    for (int i = 0; i < connections.count(); ++i) {
+        QNetworkManagerSettingsConnection *connection = connections.at(i);
+
+        if (accessPoint->ssid() == connection->getSsid()) {
+            const QString service = connection->connectionInterface()->service();
+            const QString settingsPath = connection->connectionInterface()->path();
+            const QString connectionId = QString::number(qHash(service + ' ' + settingsPath));
+
+            QNetworkConfigurationPrivatePointer ptr =
+                accessPointConfigurations.value(connectionId);
+            ptr->mutex.lock();
+            ptr->state = QNetworkConfiguration::Discovered;
+            ptr->mutex.unlock();
+
+            locker.unlock();
+            emit configurationChanged(ptr);
+            return;
+        }
+    }
+}
+
+QNetworkConfigurationPrivate *QNetworkManagerEngine::parseConnection(const QString &service,
+                                                                     const QString &settingsPath,
+                                                                     const QNmSettingsMap &map)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivate *cpPriv = new QNetworkConfigurationPrivate;
+    cpPriv->name = map.value("connection").value("id").toString();
+    cpPriv->isValid = true;
+    cpPriv->id = QString::number(qHash(service + ' ' + settingsPath));
+    cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+
+    cpPriv->purpose = QNetworkConfiguration::PublicPurpose;
+
+    cpPriv->state = QNetworkConfiguration::Defined;
+
+    const QString connectionType = map.value("connection").value("type").toString();
+
+    if (connectionType == QLatin1String("802-3-ethernet")) {
+        cpPriv->bearer = QLatin1String("Ethernet");
+        cpPriv->purpose = QNetworkConfiguration::PublicPurpose;
+
+        foreach (const QDBusObjectPath &devicePath, interface->getDevices()) {
+            QNetworkManagerInterfaceDevice device(devicePath.path());
+            if (device.deviceType() == DEVICE_TYPE_802_3_ETHERNET) {
+                QNetworkManagerInterfaceDeviceWired wiredDevice(device.connectionInterface()->path());
+                if (wiredDevice.carrier()) {
+                    cpPriv->state |= QNetworkConfiguration::Discovered;
+                    break;
+                }
+
+            }
+        }
+    } else if (connectionType == QLatin1String("802-11-wireless")) {
+        cpPriv->bearer = QLatin1String("WLAN");
+
+        const QString connectionSsid = map.value("802-11-wireless").value("ssid").toString();
+        const QString connectionSecurity = map.value("802-11-wireless").value("security").toString();
+        if(!connectionSecurity.isEmpty()) {
+            cpPriv->purpose = QNetworkConfiguration::PrivatePurpose;
+        } else {
+            cpPriv->purpose = QNetworkConfiguration::PublicPurpose;
+        }
+        for (int i = 0; i < accessPoints.count(); ++i) {
+            if (connectionSsid == accessPoints.at(i)->ssid()) {
+                cpPriv->state |= QNetworkConfiguration::Discovered;
+                if (!configuredAccessPoints.contains(accessPoints.at(i))) {
+                    configuredAccessPoints.append(accessPoints.at(i));
+
+                    const QString accessPointId =
+                        QString::number(qHash(accessPoints.at(i)->connectionInterface()->path()));
+                    QNetworkConfigurationPrivatePointer ptr =
+                        accessPointConfigurations.take(accessPointId);
+
+                    locker.unlock();
+                    emit configurationRemoved(ptr);
+                    locker.relock();
+                }
+                break;
+            }
+        }
+    } else if (connectionType == "gsm") {
+        cpPriv->bearer = QLatin1String("2G");
+    } else if (connectionType == "cdma") {
+        cpPriv->bearer = QLatin1String("CDMA2000");
+    }
+
+    return cpPriv;
+}
+
+QNetworkManagerSettingsConnection *QNetworkManagerEngine::connectionFromId(const QString &id) const
+{
+    QMutexLocker locker(&mutex);
+
+    for (int i = 0; i < connections.count(); ++i) {
+        QNetworkManagerSettingsConnection *connection = connections.at(i);
+        const QString service = connection->connectionInterface()->service();
+        const QString settingsPath = connection->connectionInterface()->path();
+
+        const QString identifier = QString::number(qHash(service + ' ' + settingsPath));
+
+        if (id == identifier)
+            return connection;
+    }
+
+    return 0;
+}
+
+QNetworkSession::State QNetworkManagerEngine::sessionStateForId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+    if (!ptr)
+        return QNetworkSession::Invalid;
+
+    if (!ptr->isValid)
+        return QNetworkSession::Invalid;
+
+    foreach (const QString &acPath, activeConnections.keys()) {
+        QNetworkManagerConnectionActive *activeConnection = activeConnections.value(acPath);
+
+        const QString identifier = QString::number(qHash(activeConnection->serviceName() + ' ' +
+                                                         activeConnection->connection().path()));
+
+        if (id == identifier) {
+            switch (activeConnection->state()) {
+            case 0:
+                return QNetworkSession::Disconnected;
+            case 1:
+                return QNetworkSession::Connecting;
+            case 2:
+                return QNetworkSession::Connected;
+            }
+        }
+    }
+
+    if ((ptr->state & QNetworkConfiguration::Discovered) == QNetworkConfiguration::Discovered)
+        return QNetworkSession::Disconnected;
+    else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined)
+        return QNetworkSession::NotAvailable;
+    else if ((ptr->state & QNetworkConfiguration::Undefined) == QNetworkConfiguration::Undefined)
+        return QNetworkSession::NotAvailable;
+
+    return QNetworkSession::Invalid;
+}
+
+quint64 QNetworkManagerEngine::bytesWritten(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+    if (ptr && (ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+        const QString networkInterface = getInterfaceFromId(id);
+        if (!networkInterface.isEmpty()) {
+            const QString devFile = QLatin1String("/sys/class/net/") +
+                                    networkInterface +
+                                    QLatin1String("/statistics/tx_bytes");
+
+            quint64 result = Q_UINT64_C(0);
+
+            QFile tx(devFile);
+            if (tx.exists() && tx.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                QTextStream in(&tx);
+                in >> result;
+                tx.close();
+            }
+
+            return result;
+        }
+    }
+
+    return Q_UINT64_C(0);
+}
+
+quint64 QNetworkManagerEngine::bytesReceived(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+    if (ptr && (ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+        const QString networkInterface = getInterfaceFromId(id);
+        if (!networkInterface.isEmpty()) {
+            const QString devFile = QLatin1String("/sys/class/net/") +
+                                    networkInterface +
+                                    QLatin1String("/statistics/rx_bytes");
+
+            quint64 result = Q_UINT64_C(0);
+
+            QFile tx(devFile);
+            if (tx.exists() && tx.open(QIODevice::ReadOnly | QIODevice::Text)) {
+                QTextStream in(&tx);
+                in >> result;
+                tx.close();
+            }
+
+            return result;
+        }
+    }
+
+    return Q_UINT64_C(0);
+}
+
+quint64 QNetworkManagerEngine::startTime(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkManagerSettingsConnection *connection = connectionFromId(id);
+    if (connection)
+        return connection->getTimestamp();
+    else
+        return Q_UINT64_C(0);
+}
+
+QNetworkConfigurationManager::Capabilities QNetworkManagerEngine::capabilities() const
+{
+    return QNetworkConfigurationManager::ForcedRoaming |
+           QNetworkConfigurationManager::CanStartAndStopInterfaces;
+}
+
+QNetworkSessionPrivate *QNetworkManagerEngine::createSessionBackend()
+{
+    return new QNetworkSessionPrivateImpl;
+}
+
+QNetworkConfigurationPrivatePointer QNetworkManagerEngine::defaultConfiguration()
+{
+    return QNetworkConfigurationPrivatePointer();
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/bearer/networkmanager/qnetworkmanagerengine.h b/src/plugins/bearer/networkmanager/qnetworkmanagerengine.h
new file mode 100644
index 0000000..af3f450
--- /dev/null
+++ b/src/plugins/bearer/networkmanager/qnetworkmanagerengine.h
@@ -0,0 +1,141 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNETWORKMANAGERENGINE_P_H
+#define QNETWORKMANAGERENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists for the convenience
+// of the QLibrary class.  This header file may change from
+// version to version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "../qbearerengine_impl.h"
+
+#include "qnetworkmanagerservice.h"
+
+#include <QMap>
+#include <QVariant>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkManagerEngine : public QBearerEngineImpl
+{
+    Q_OBJECT
+
+public:
+    QNetworkManagerEngine(QObject *parent = 0);
+    ~QNetworkManagerEngine();
+
+    Q_INVOKABLE void init();
+
+    bool networkManagerAvailable() const;
+
+    QString getInterfaceFromId(const QString &id);
+    bool hasIdentifier(const QString &id);
+
+    QString bearerName(const QString &id);
+
+    void connectToId(const QString &id);
+    void disconnectFromId(const QString &id);
+
+    Q_INVOKABLE void requestUpdate();
+
+    QNetworkSession::State sessionStateForId(const QString &id);
+
+    quint64 bytesWritten(const QString &id);
+    quint64 bytesReceived(const QString &id);
+    quint64 startTime(const QString &id);
+
+    QNetworkConfigurationManager::Capabilities capabilities() const;
+
+    QNetworkSessionPrivate *createSessionBackend();
+
+    QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+private Q_SLOTS:
+    void interfacePropertiesChanged(const QString &path,
+                                    const QMap<QString, QVariant> &properties);
+    void activeConnectionPropertiesChanged(const QString &path,
+                                           const QMap<QString, QVariant> &properties);
+    void devicePropertiesChanged(const QString &path,
+                                 const QMap<QString, QVariant> &properties);
+
+    void deviceAdded(const QDBusObjectPath &path);
+    void deviceRemoved(const QDBusObjectPath &path);
+
+    void newConnection(const QDBusObjectPath &path, QNetworkManagerSettings *settings = 0);
+    void removeConnection(const QString &path);
+    void updateConnection(const QNmSettingsMap &settings);
+    void activationFinished(QDBusPendingCallWatcher *watcher);
+
+    void newAccessPoint(const QString &path, const QDBusObjectPath &objectPath);
+    void removeAccessPoint(const QString &path, const QDBusObjectPath &objectPath);
+    void updateAccessPoint(const QMap<QString, QVariant> &map);
+
+    void doRequestUpdate();
+
+private:
+    QNetworkConfigurationPrivate *parseConnection(const QString &service,
+                                                  const QString &settingsPath,
+                                                  const QNmSettingsMap &map);
+    QNetworkManagerSettingsConnection *connectionFromId(const QString &id) const;
+
+private:
+    QNetworkManagerInterface *interface;
+    QNetworkManagerSettings *systemSettings;
+    QNetworkManagerSettings *userSettings;
+    QHash<QString, QNetworkManagerInterfaceDeviceWireless *> wirelessDevices;
+    QHash<QString, QNetworkManagerConnectionActive *> activeConnections;
+    QList<QNetworkManagerSettingsConnection *> connections;
+    QList<QNetworkManagerInterfaceAccessPoint *> accessPoints;
+    QList<QNetworkManagerInterfaceAccessPoint *> configuredAccessPoints;
+};
+
+QT_END_NAMESPACE
+
+#endif
+
diff --git a/src/plugins/bearer/networkmanager/qnetworkmanagerservice.cpp b/src/plugins/bearer/networkmanager/qnetworkmanagerservice.cpp
new file mode 100644
index 0000000..a20370b
--- /dev/null
+++ b/src/plugins/bearer/networkmanager/qnetworkmanagerservice.cpp
@@ -0,0 +1,995 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QObject>
+#include <QList>
+#include <QtDBus/QtDBus>
+#include <QtDBus/QDBusConnection>
+#include <QtDBus/QDBusError>
+#include <QtDBus/QDBusInterface>
+#include <QtDBus/QDBusMessage>
+#include <QtDBus/QDBusReply>
+#include <QtDBus/QDBusPendingCallWatcher>
+#include <QtDBus/QDBusObjectPath>
+#include <QtDBus/QDBusPendingCall>
+
+#include "qnetworkmanagerservice.h"
+#include "qnmdbushelper.h"
+
+QT_BEGIN_NAMESPACE
+
+static QDBusConnection dbusConnection = QDBusConnection::systemBus();
+
+class QNetworkManagerInterfacePrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    bool valid;
+};
+
+QNetworkManagerInterface::QNetworkManagerInterface(QObject *parent)
+        : QObject(parent)
+{
+    d = new QNetworkManagerInterfacePrivate();
+    d->connectionInterface = new QDBusInterface(QLatin1String(NM_DBUS_SERVICE),
+                                                QLatin1String(NM_DBUS_PATH),
+                                                QLatin1String(NM_DBUS_INTERFACE),
+                                                dbusConnection);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+    nmDBusHelper = new QNmDBusHelper(this);
+    connect(nmDBusHelper, SIGNAL(pathForPropertiesChanged(const QString &,QMap<QString,QVariant>)),
+                    this,SIGNAL(propertiesChanged( const QString &, QMap<QString,QVariant>)));
+    connect(nmDBusHelper,SIGNAL(pathForStateChanged(const QString &, quint32)),
+            this, SIGNAL(stateChanged(const QString&, quint32)));
+
+}
+
+QNetworkManagerInterface::~QNetworkManagerInterface()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerInterface::isValid()
+{
+    return d->valid;
+}
+
+bool QNetworkManagerInterface::setConnections()
+{
+    if(!isValid() )
+        return false;
+    bool allOk = false;
+    if (!dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                                  QLatin1String(NM_DBUS_PATH),
+                                  QLatin1String(NM_DBUS_INTERFACE),
+                                  QLatin1String("PropertiesChanged"),
+                                nmDBusHelper,SLOT(slotPropertiesChanged( QMap<QString,QVariant>)))) {
+        allOk = true;
+    }
+    if (!dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                                  QLatin1String(NM_DBUS_PATH),
+                                  QLatin1String(NM_DBUS_INTERFACE),
+                                  QLatin1String("DeviceAdded"),
+                                this,SIGNAL(deviceAdded(QDBusObjectPath)))) {
+        allOk = true;
+    }
+    if (!dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                                  QLatin1String(NM_DBUS_PATH),
+                                  QLatin1String(NM_DBUS_INTERFACE),
+                                  QLatin1String("DeviceRemoved"),
+                                  this,SIGNAL(deviceRemoved(QDBusObjectPath)))) {
+        allOk = true;
+    }
+
+    return allOk;
+}
+
+QDBusInterface *QNetworkManagerInterface::connectionInterface()  const
+{
+    return d->connectionInterface;
+}
+
+QList <QDBusObjectPath> QNetworkManagerInterface::getDevices() const
+{
+    QDBusReply<QList<QDBusObjectPath> > reply =  d->connectionInterface->call(QLatin1String("GetDevices"));
+    return reply.value();
+}
+
+void QNetworkManagerInterface::activateConnection( const QString &serviceName,
+                                                  QDBusObjectPath connectionPath,
+                                                  QDBusObjectPath devicePath,
+                                                  QDBusObjectPath specificObject)
+{
+    QDBusPendingCall pendingCall = d->connectionInterface->asyncCall(QLatin1String("ActivateConnection"),
+                                                                    QVariant(serviceName),
+                                                                    QVariant::fromValue(connectionPath),
+                                                                    QVariant::fromValue(devicePath),
+                                                                    QVariant::fromValue(specificObject));
+
+   QDBusPendingCallWatcher *callWatcher = new QDBusPendingCallWatcher(pendingCall, this);
+   connect(callWatcher, SIGNAL(finished(QDBusPendingCallWatcher*)),
+                    this, SIGNAL(activationFinished(QDBusPendingCallWatcher*)));
+}
+
+void QNetworkManagerInterface::deactivateConnection(QDBusObjectPath connectionPath)  const
+{
+    d->connectionInterface->call(QLatin1String("DeactivateConnection"), QVariant::fromValue(connectionPath));
+}
+
+bool QNetworkManagerInterface::wirelessEnabled()  const
+{
+    return d->connectionInterface->property("WirelessEnabled").toBool();
+}
+
+bool QNetworkManagerInterface::wirelessHardwareEnabled()  const
+{
+    return d->connectionInterface->property("WirelessHardwareEnabled").toBool();
+}
+
+QList <QDBusObjectPath> QNetworkManagerInterface::activeConnections() const
+{
+    QVariant prop = d->connectionInterface->property("ActiveConnections");
+    return prop.value<QList<QDBusObjectPath> >();
+}
+
+quint32 QNetworkManagerInterface::state()
+{
+    return d->connectionInterface->property("State").toUInt();
+}
+
+class QNetworkManagerInterfaceAccessPointPrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    QString path;
+    bool valid;
+};
+
+QNetworkManagerInterfaceAccessPoint::QNetworkManagerInterfaceAccessPoint(const QString &dbusPathName, QObject *parent)
+        : QObject(parent), nmDBusHelper(0)
+{
+    d = new QNetworkManagerInterfaceAccessPointPrivate();
+    d->path = dbusPathName;
+    d->connectionInterface = new QDBusInterface(QLatin1String(NM_DBUS_SERVICE),
+                                                d->path,
+                                                QLatin1String(NM_DBUS_INTERFACE_ACCESS_POINT),
+                                                dbusConnection);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+
+}
+
+QNetworkManagerInterfaceAccessPoint::~QNetworkManagerInterfaceAccessPoint()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerInterfaceAccessPoint::isValid()
+{
+    return d->valid;
+}
+
+bool QNetworkManagerInterfaceAccessPoint::setConnections()
+{
+    if(!isValid() )
+        return false;
+
+    bool allOk = false;
+    delete nmDBusHelper;
+    nmDBusHelper = new QNmDBusHelper(this);
+    connect(nmDBusHelper, SIGNAL(pathForPropertiesChanged(const QString &,QMap<QString,QVariant>)),
+            this,SIGNAL(propertiesChanged( const QString &, QMap<QString,QVariant>)));
+
+    if(dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                              d->path,
+                              QLatin1String(NM_DBUS_INTERFACE_ACCESS_POINT),
+                              QLatin1String("PropertiesChanged"),
+                              nmDBusHelper,SLOT(slotPropertiesChanged( QMap<QString,QVariant>))) ) {
+        allOk = true;
+
+    }
+    return allOk;
+}
+
+QDBusInterface *QNetworkManagerInterfaceAccessPoint::connectionInterface() const
+{
+    return d->connectionInterface;
+}
+
+quint32 QNetworkManagerInterfaceAccessPoint::flags() const
+{
+    return d->connectionInterface->property("Flags").toUInt();
+}
+
+quint32 QNetworkManagerInterfaceAccessPoint::wpaFlags() const
+{
+    return d->connectionInterface->property("WpaFlags").toUInt();
+}
+
+quint32 QNetworkManagerInterfaceAccessPoint::rsnFlags() const
+{
+    return d->connectionInterface->property("RsnFlags").toUInt();
+}
+
+QString QNetworkManagerInterfaceAccessPoint::ssid() const
+{
+    return d->connectionInterface->property("Ssid").toString();
+}
+
+quint32 QNetworkManagerInterfaceAccessPoint::frequency() const
+{
+    return d->connectionInterface->property("Frequency").toUInt();
+}
+
+QString QNetworkManagerInterfaceAccessPoint::hwAddress() const
+{
+    return d->connectionInterface->property("HwAddress").toString();
+}
+
+quint32 QNetworkManagerInterfaceAccessPoint::mode() const
+{
+    return d->connectionInterface->property("Mode").toUInt();
+}
+
+quint32 QNetworkManagerInterfaceAccessPoint::maxBitrate() const
+{
+    return d->connectionInterface->property("MaxBitrate").toUInt();
+}
+
+quint32 QNetworkManagerInterfaceAccessPoint::strength() const
+{
+    return d->connectionInterface->property("Strength").toUInt();
+}
+
+class QNetworkManagerInterfaceDevicePrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    QString path;
+    bool valid;
+};
+
+QNetworkManagerInterfaceDevice::QNetworkManagerInterfaceDevice(const QString &deviceObjectPath, QObject *parent)
+        : QObject(parent), nmDBusHelper(0)
+{
+    d = new QNetworkManagerInterfaceDevicePrivate();
+    d->path = deviceObjectPath;
+    d->connectionInterface = new QDBusInterface(QLatin1String(NM_DBUS_SERVICE),
+                                                d->path,
+                                                QLatin1String(NM_DBUS_INTERFACE_DEVICE),
+                                                dbusConnection);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+}
+
+QNetworkManagerInterfaceDevice::~QNetworkManagerInterfaceDevice()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerInterfaceDevice::isValid()
+{
+    return d->valid;
+}
+
+bool QNetworkManagerInterfaceDevice::setConnections()
+{
+    if(!isValid() )
+        return false;
+
+    bool allOk = false;
+    delete nmDBusHelper;
+    nmDBusHelper = new QNmDBusHelper(this);
+    connect(nmDBusHelper,SIGNAL(pathForStateChanged(const QString &, quint32)),
+            this, SIGNAL(stateChanged(const QString&, quint32)));
+    if(dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                              d->path,
+                              QLatin1String(NM_DBUS_INTERFACE_DEVICE),
+                              QLatin1String("StateChanged"),
+                              nmDBusHelper,SLOT(deviceStateChanged(quint32)))) {
+        allOk = true;
+    }
+    return allOk;
+}
+
+QDBusInterface *QNetworkManagerInterfaceDevice::connectionInterface() const
+{
+    return d->connectionInterface;
+}
+
+QString QNetworkManagerInterfaceDevice::udi() const
+{
+    return d->connectionInterface->property("Udi").toString();
+}
+
+QString QNetworkManagerInterfaceDevice::networkInterface() const
+{
+    return d->connectionInterface->property("Interface").toString();
+}
+
+quint32 QNetworkManagerInterfaceDevice::ip4Address() const
+{
+    return d->connectionInterface->property("Ip4Address").toUInt();
+}
+
+quint32 QNetworkManagerInterfaceDevice::state() const
+{
+    return d->connectionInterface->property("State").toUInt();
+}
+
+quint32 QNetworkManagerInterfaceDevice::deviceType() const
+{
+    return d->connectionInterface->property("DeviceType").toUInt();
+}
+
+QDBusObjectPath QNetworkManagerInterfaceDevice::ip4config() const
+{
+    QVariant prop = d->connectionInterface->property("Ip4Config");
+    return prop.value<QDBusObjectPath>();
+}
+
+class QNetworkManagerInterfaceDeviceWiredPrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    QString path;
+    bool valid;
+};
+
+QNetworkManagerInterfaceDeviceWired::QNetworkManagerInterfaceDeviceWired(const QString &ifaceDevicePath, QObject *parent)
+    : QObject(parent), nmDBusHelper(0)
+{
+    d = new QNetworkManagerInterfaceDeviceWiredPrivate();
+    d->path = ifaceDevicePath;
+    d->connectionInterface = new QDBusInterface(QLatin1String(NM_DBUS_SERVICE),
+                                                d->path,
+                                                QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRED),
+                                                dbusConnection, parent);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+}
+
+QNetworkManagerInterfaceDeviceWired::~QNetworkManagerInterfaceDeviceWired()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerInterfaceDeviceWired::isValid()
+{
+
+    return d->valid;
+}
+
+bool QNetworkManagerInterfaceDeviceWired::setConnections()
+{
+    if(!isValid() )
+        return false;
+
+    bool allOk = false;
+
+    delete nmDBusHelper;
+    nmDBusHelper = new QNmDBusHelper(this);
+    connect(nmDBusHelper, SIGNAL(pathForPropertiesChanged(const QString &,QMap<QString,QVariant>)),
+            this,SIGNAL(propertiesChanged( const QString &, QMap<QString,QVariant>)));
+    if(dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                              d->path,
+                              QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRED),
+                              QLatin1String("PropertiesChanged"),
+                              nmDBusHelper,SLOT(slotPropertiesChanged( QMap<QString,QVariant>))) )  {
+        allOk = true;
+    }
+    return allOk;
+}
+
+QDBusInterface *QNetworkManagerInterfaceDeviceWired::connectionInterface() const
+{
+    return d->connectionInterface;
+}
+
+QString QNetworkManagerInterfaceDeviceWired::hwAddress() const
+{
+    return d->connectionInterface->property("HwAddress").toString();
+}
+
+quint32 QNetworkManagerInterfaceDeviceWired::speed() const
+{
+    return d->connectionInterface->property("Speed").toUInt();
+}
+
+bool QNetworkManagerInterfaceDeviceWired::carrier() const
+{
+    return d->connectionInterface->property("Carrier").toBool();
+}
+
+class QNetworkManagerInterfaceDeviceWirelessPrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    QString path;
+    bool valid;
+};
+
+QNetworkManagerInterfaceDeviceWireless::QNetworkManagerInterfaceDeviceWireless(const QString &ifaceDevicePath, QObject *parent)
+    : QObject(parent), nmDBusHelper(0)
+{
+    d = new QNetworkManagerInterfaceDeviceWirelessPrivate();
+    d->path = ifaceDevicePath;
+    d->connectionInterface = new QDBusInterface(QLatin1String(NM_DBUS_SERVICE),
+                                                d->path,
+                                                QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS),
+                                                dbusConnection, parent);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+}
+
+QNetworkManagerInterfaceDeviceWireless::~QNetworkManagerInterfaceDeviceWireless()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerInterfaceDeviceWireless::isValid()
+{
+    return d->valid;
+}
+
+bool QNetworkManagerInterfaceDeviceWireless::setConnections()
+{
+    if(!isValid() )
+        return false;
+
+    bool allOk = false;
+    delete nmDBusHelper;
+    nmDBusHelper = new QNmDBusHelper(this);
+    connect(nmDBusHelper, SIGNAL(pathForPropertiesChanged(const QString &,QMap<QString,QVariant>)),
+            this,SIGNAL(propertiesChanged( const QString &, QMap<QString,QVariant>)));
+
+    connect(nmDBusHelper, SIGNAL(pathForAccessPointAdded(const QString &,QDBusObjectPath)),
+            this,SIGNAL(accessPointAdded(const QString &,QDBusObjectPath)));
+
+    connect(nmDBusHelper, SIGNAL(pathForAccessPointRemoved(const QString &,QDBusObjectPath)),
+            this,SIGNAL(accessPointRemoved(const QString &,QDBusObjectPath)));
+
+    if(!dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                              d->path,
+                              QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS),
+                              QLatin1String("AccessPointAdded"),
+                              nmDBusHelper, SLOT(slotAccessPointAdded( QDBusObjectPath )))) {
+        allOk = true;
+    }
+
+
+    if(!dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                              d->path,
+                              QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS),
+                              QLatin1String("AccessPointRemoved"),
+                              nmDBusHelper, SLOT(slotAccessPointRemoved( QDBusObjectPath )))) {
+        allOk = true;
+    }
+
+
+    if(!dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                              d->path,
+                              QLatin1String(NM_DBUS_INTERFACE_DEVICE_WIRELESS),
+                              QLatin1String("PropertiesChanged"),
+                              nmDBusHelper,SLOT(slotPropertiesChanged( QMap<QString,QVariant>)))) {
+        allOk = true;
+    }
+
+    return allOk;
+}
+
+QDBusInterface *QNetworkManagerInterfaceDeviceWireless::connectionInterface() const
+{
+    return d->connectionInterface;
+}
+
+QList <QDBusObjectPath> QNetworkManagerInterfaceDeviceWireless::getAccessPoints()
+{
+    QDBusReply<QList<QDBusObjectPath> > reply = d->connectionInterface->call(QLatin1String("GetAccessPoints"));
+    return reply.value();
+}
+
+QString QNetworkManagerInterfaceDeviceWireless::hwAddress() const
+{
+    return d->connectionInterface->property("HwAddress").toString();
+}
+
+quint32 QNetworkManagerInterfaceDeviceWireless::mode() const
+{
+    return d->connectionInterface->property("Mode").toUInt();
+}
+
+quint32 QNetworkManagerInterfaceDeviceWireless::bitrate() const
+{
+    return d->connectionInterface->property("Bitrate").toUInt();
+}
+
+QDBusObjectPath QNetworkManagerInterfaceDeviceWireless::activeAccessPoint() const
+{
+    return d->connectionInterface->property("ActiveAccessPoint").value<QDBusObjectPath>();
+}
+
+quint32 QNetworkManagerInterfaceDeviceWireless::wirelessCapabilities() const
+{
+    return d->connectionInterface->property("WirelelessCapabilities").toUInt();
+}
+
+class QNetworkManagerSettingsPrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    QString path;
+    bool valid;
+};
+
+QNetworkManagerSettings::QNetworkManagerSettings(const QString &settingsService, QObject *parent)
+        : QObject(parent)
+{
+    d = new QNetworkManagerSettingsPrivate();
+    d->path = settingsService;
+    d->connectionInterface = new QDBusInterface(settingsService,
+                                                QLatin1String(NM_DBUS_PATH_SETTINGS),
+                                                QLatin1String(NM_DBUS_IFACE_SETTINGS),
+                                                dbusConnection);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+}
+
+QNetworkManagerSettings::~QNetworkManagerSettings()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerSettings::isValid()
+{
+    return d->valid;
+}
+
+bool QNetworkManagerSettings::setConnections()
+{
+    bool allOk = false;
+
+    if (!dbusConnection.connect(d->path, QLatin1String(NM_DBUS_PATH_SETTINGS),
+                           QLatin1String(NM_DBUS_IFACE_SETTINGS), QLatin1String("NewConnection"),
+                           this, SIGNAL(newConnection(QDBusObjectPath)))) {
+        allOk = true;
+    }
+
+    return allOk;
+}
+
+QList <QDBusObjectPath> QNetworkManagerSettings::listConnections()
+{
+    QDBusReply<QList<QDBusObjectPath> > reply = d->connectionInterface->call(QLatin1String("ListConnections"));
+    return  reply.value();
+}
+
+QDBusInterface *QNetworkManagerSettings::connectionInterface() const
+{
+    return d->connectionInterface;
+}
+
+
+class QNetworkManagerSettingsConnectionPrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    QString path;
+    QString service;
+    QNmSettingsMap settingsMap;
+    bool valid;
+};
+
+QNetworkManagerSettingsConnection::QNetworkManagerSettingsConnection(const QString &settingsService, const QString &connectionObjectPath, QObject *parent)
+    : QObject(parent), nmDBusHelper(0)
+{
+    qDBusRegisterMetaType<QNmSettingsMap>();
+    d = new QNetworkManagerSettingsConnectionPrivate();
+    d->path = connectionObjectPath;
+    d->service = settingsService;
+    d->connectionInterface = new QDBusInterface(settingsService,
+                                                d->path,
+                                                QLatin1String(NM_DBUS_IFACE_SETTINGS_CONNECTION),
+                                                dbusConnection, parent);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+    QDBusReply< QNmSettingsMap > rep = d->connectionInterface->call(QLatin1String("GetSettings"));
+    d->settingsMap = rep.value();
+}
+
+QNetworkManagerSettingsConnection::~QNetworkManagerSettingsConnection()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerSettingsConnection::isValid()
+{
+    return d->valid;
+}
+
+bool QNetworkManagerSettingsConnection::setConnections()
+{
+    if(!isValid() )
+        return false;
+
+    bool allOk = false;
+    if(!dbusConnection.connect(d->service, d->path,
+                           QLatin1String(NM_DBUS_IFACE_SETTINGS_CONNECTION), QLatin1String("Updated"),
+                           this, SIGNAL(updated(QNmSettingsMap)))) {
+        allOk = true;
+    } else {
+        QDBusError error = dbusConnection.lastError();
+    }
+
+    delete nmDBusHelper;
+    nmDBusHelper = new QNmDBusHelper(this);
+    connect(nmDBusHelper, SIGNAL(pathForSettingsRemoved(const QString &)),
+            this,SIGNAL(removed( const QString &)));
+
+    if (!dbusConnection.connect(d->service, d->path,
+                           QLatin1String(NM_DBUS_IFACE_SETTINGS_CONNECTION), QLatin1String("Removed"),
+                           nmDBusHelper, SIGNAL(slotSettingsRemoved()))) {
+        allOk = true;
+    }
+
+    return allOk;
+}
+
+QDBusInterface *QNetworkManagerSettingsConnection::connectionInterface() const
+{
+    return d->connectionInterface;
+}
+
+QNmSettingsMap QNetworkManagerSettingsConnection::getSettings()
+{
+    QDBusReply< QNmSettingsMap > rep = d->connectionInterface->call(QLatin1String("GetSettings"));
+    d->settingsMap = rep.value();
+    return d->settingsMap;
+}
+
+NMDeviceType QNetworkManagerSettingsConnection::getType()
+{
+    QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("connection"));
+    while (i != d->settingsMap.end() && i.key() == QLatin1String("connection")) {
+        QMap<QString,QVariant> innerMap = i.value();
+        QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("type"));
+        while (ii != innerMap.end() && ii.key() == QLatin1String("type")) {
+            QString devType = ii.value().toString();
+            if (devType == QLatin1String("802-3-ethernet")) {
+                return 	DEVICE_TYPE_802_3_ETHERNET;
+            }
+            if (devType == QLatin1String("802-11-wireless")) {
+                return 	DEVICE_TYPE_802_11_WIRELESS;
+            }
+            ii++;
+        }
+        i++;
+    }
+    return 	DEVICE_TYPE_UNKNOWN;
+}
+
+bool QNetworkManagerSettingsConnection::isAutoConnect()
+{
+    QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("connection"));
+    while (i != d->settingsMap.end() && i.key() == QLatin1String("connection")) {
+        QMap<QString,QVariant> innerMap = i.value();
+        QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("autoconnect"));
+        while (ii != innerMap.end() && ii.key() == QLatin1String("autoconnect")) {
+            return ii.value().toBool();
+            ii++;
+        }
+        i++;
+    }
+    return true; //default networkmanager is autoconnect
+}
+
+quint64 QNetworkManagerSettingsConnection::getTimestamp()
+{
+    QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("connection"));
+    while (i != d->settingsMap.end() && i.key() == QLatin1String("connection")) {
+        QMap<QString,QVariant> innerMap = i.value();
+        QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("timestamp"));
+        while (ii != innerMap.end() && ii.key() == QLatin1String("timestamp")) {
+            return ii.value().toUInt();
+            ii++;
+        }
+        i++;
+    }
+    return 	0;
+}
+
+QString QNetworkManagerSettingsConnection::getId()
+{
+    QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("connection"));
+    while (i != d->settingsMap.end() && i.key() == QLatin1String("connection")) {
+        QMap<QString,QVariant> innerMap = i.value();
+        QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("id"));
+        while (ii != innerMap.end() && ii.key() == QLatin1String("id")) {
+            return ii.value().toString();
+            ii++;
+        }
+        i++;
+    }
+    return 	QString();
+}
+
+QString QNetworkManagerSettingsConnection::getUuid()
+{
+    QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("connection"));
+    while (i != d->settingsMap.end() && i.key() == QLatin1String("connection")) {
+        QMap<QString,QVariant> innerMap = i.value();
+        QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("uuid"));
+        while (ii != innerMap.end() && ii.key() == QLatin1String("uuid")) {
+            return ii.value().toString();
+            ii++;
+        }
+        i++;
+    }
+    // is no uuid, return the connection path
+    return 	d->connectionInterface->path();
+}
+
+QString QNetworkManagerSettingsConnection::getSsid()
+{
+    QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("802-11-wireless"));
+    while (i != d->settingsMap.end() && i.key() == QLatin1String("802-11-wireless")) {
+        QMap<QString,QVariant> innerMap = i.value();
+        QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("ssid"));
+        while (ii != innerMap.end() && ii.key() == QLatin1String("ssid")) {
+            return ii.value().toString();
+            ii++;
+        }
+        i++;
+    }
+    return 	QString();
+}
+
+QString QNetworkManagerSettingsConnection::getMacAddress()
+{
+    if(getType() == DEVICE_TYPE_802_3_ETHERNET) {
+        QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("802-3-ethernet"));
+        while (i != d->settingsMap.end() && i.key() == QLatin1String("802-3-ethernet")) {
+            QMap<QString,QVariant> innerMap = i.value();
+            QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("mac-address"));
+            while (ii != innerMap.end() && ii.key() == QLatin1String("mac-address")) {
+                return ii.value().toString();
+                ii++;
+            }
+            i++;
+        }
+    }
+
+    else if(getType() == DEVICE_TYPE_802_11_WIRELESS) {
+        QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("802-11-wireless"));
+        while (i != d->settingsMap.end() && i.key() == QLatin1String("802-11-wireless")) {
+            QMap<QString,QVariant> innerMap = i.value();
+            QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("mac-address"));
+            while (ii != innerMap.end() && ii.key() == QLatin1String("mac-address")) {
+                return ii.value().toString();
+                ii++;
+            }
+            i++;
+        }
+    }
+    return 	QString();
+}
+
+QStringList  QNetworkManagerSettingsConnection::getSeenBssids()
+{
+ if(getType() == DEVICE_TYPE_802_11_WIRELESS) {
+        QNmSettingsMap::const_iterator i = d->settingsMap.find(QLatin1String("802-11-wireless"));
+        while (i != d->settingsMap.end() && i.key() == QLatin1String("802-11-wireless")) {
+            QMap<QString,QVariant> innerMap = i.value();
+            QMap<QString,QVariant>::const_iterator ii = innerMap.find(QLatin1String("seen-bssids"));
+            while (ii != innerMap.end() && ii.key() == QLatin1String("seen-bssids")) {
+                return ii.value().toStringList();
+                ii++;
+            }
+            i++;
+        }
+    }
+ return QStringList();
+}
+
+class QNetworkManagerConnectionActivePrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    QString path;
+    bool valid;
+};
+
+QNetworkManagerConnectionActive::QNetworkManagerConnectionActive( const QString &activeConnectionObjectPath, QObject *parent)
+    : QObject(parent), nmDBusHelper(0)
+{
+    d = new QNetworkManagerConnectionActivePrivate();
+    d->path = activeConnectionObjectPath;
+    d->connectionInterface = new QDBusInterface(QLatin1String(NM_DBUS_SERVICE),
+                                                d->path,
+                                                QLatin1String(NM_DBUS_INTERFACE_ACTIVE_CONNECTION),
+                                                dbusConnection, parent);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+}
+
+QNetworkManagerConnectionActive::~QNetworkManagerConnectionActive()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerConnectionActive::isValid()
+{
+    return d->valid;
+}
+
+bool QNetworkManagerConnectionActive::setConnections()
+{
+    if(!isValid() )
+        return false;
+
+    bool allOk = false;
+    delete nmDBusHelper;
+    nmDBusHelper = new QNmDBusHelper(this);
+    connect(nmDBusHelper, SIGNAL(pathForPropertiesChanged(const QString &,QMap<QString,QVariant>)),
+            this,SIGNAL(propertiesChanged( const QString &, QMap<QString,QVariant>)));
+    if(dbusConnection.connect(QLatin1String(NM_DBUS_SERVICE),
+                              d->path,
+                              QLatin1String(NM_DBUS_INTERFACE_ACTIVE_CONNECTION),
+                              QLatin1String("PropertiesChanged"),
+                              nmDBusHelper,SLOT(slotPropertiesChanged( QMap<QString,QVariant>))) )  {
+        allOk = true;
+    }
+
+    return allOk;
+}
+
+QDBusInterface *QNetworkManagerConnectionActive::connectionInterface() const
+{
+    return d->connectionInterface;
+}
+
+QString QNetworkManagerConnectionActive::serviceName() const
+{
+    return d->connectionInterface->property("ServiceName").toString();
+}
+
+QDBusObjectPath QNetworkManagerConnectionActive::connection() const
+{
+    QVariant prop = d->connectionInterface->property("Connection");
+    return prop.value<QDBusObjectPath>();
+}
+
+QDBusObjectPath QNetworkManagerConnectionActive::specificObject() const
+{
+    QVariant prop = d->connectionInterface->property("SpecificObject");
+    return prop.value<QDBusObjectPath>();
+}
+
+QList<QDBusObjectPath> QNetworkManagerConnectionActive::devices() const
+{
+    QVariant prop = d->connectionInterface->property("Devices");
+    return prop.value<QList<QDBusObjectPath> >();
+}
+
+quint32 QNetworkManagerConnectionActive::state() const
+{
+    return d->connectionInterface->property("State").toUInt();
+}
+
+bool QNetworkManagerConnectionActive::defaultRoute() const
+{
+    return d->connectionInterface->property("Default").toBool();
+}
+
+class QNetworkManagerIp4ConfigPrivate
+{
+public:
+    QDBusInterface *connectionInterface;
+    QString path;
+    bool valid;
+};
+
+QNetworkManagerIp4Config::QNetworkManagerIp4Config( const QString &deviceObjectPath, QObject *parent)
+    : QObject(parent)
+{
+    d = new QNetworkManagerIp4ConfigPrivate();
+    d->path = deviceObjectPath;
+    d->connectionInterface = new QDBusInterface(QLatin1String(NM_DBUS_SERVICE),
+                                                d->path,
+                                                QLatin1String(NM_DBUS_INTERFACE_IP4_CONFIG),
+                                                dbusConnection, parent);
+    if (!d->connectionInterface->isValid()) {
+        d->valid = false;
+        return;
+    }
+    d->valid = true;
+}
+
+QNetworkManagerIp4Config::~QNetworkManagerIp4Config()
+{
+    delete d->connectionInterface;
+    delete d;
+}
+
+bool QNetworkManagerIp4Config::isValid()
+{
+    return d->valid;
+}
+
+QStringList QNetworkManagerIp4Config::domains() const
+{
+    return d->connectionInterface->property("Domains").toStringList();
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/networkmanager/qnetworkmanagerservice.h b/src/plugins/bearer/networkmanager/qnetworkmanagerservice.h
new file mode 100644
index 0000000..95f5b4a
--- /dev/null
+++ b/src/plugins/bearer/networkmanager/qnetworkmanagerservice.h
@@ -0,0 +1,445 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNETWORKMANAGERSERVICE_H
+#define QNETWORKMANAGERSERVICE_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtDBus/QtDBus>
+#include <QtDBus/QDBusConnection>
+#include <QtDBus/QDBusError>
+#include <QtDBus/QDBusInterface>
+#include <QtDBus/QDBusMessage>
+#include <QtDBus/QDBusReply>
+
+#include <QtDBus/QDBusPendingCallWatcher>
+#include <QtDBus/QDBusObjectPath>
+#include <QtDBus/QDBusContext>
+#include <QMap>
+#include "qnmdbushelper.h"
+
+#ifndef NETWORK_MANAGER_H
+typedef enum NMDeviceType
+{
+    DEVICE_TYPE_UNKNOWN = 0,
+    DEVICE_TYPE_802_3_ETHERNET,
+    DEVICE_TYPE_802_11_WIRELESS,
+    DEVICE_TYPE_GSM,
+    DEVICE_TYPE_CDMA
+} NMDeviceType;
+
+typedef enum
+{
+    NM_DEVICE_STATE_UNKNOWN = 0,
+    NM_DEVICE_STATE_UNMANAGED,
+    NM_DEVICE_STATE_UNAVAILABLE,
+    NM_DEVICE_STATE_DISCONNECTED,
+    NM_DEVICE_STATE_PREPARE,
+    NM_DEVICE_STATE_CONFIG,
+    NM_DEVICE_STATE_NEED_AUTH,
+    NM_DEVICE_STATE_IP_CONFIG,
+    NM_DEVICE_STATE_ACTIVATED,
+    NM_DEVICE_STATE_FAILED
+} NMDeviceState;
+
+typedef enum
+{
+    NM_ACTIVE_CONNECTION_STATE_UNKNOWN = 0,
+    NM_ACTIVE_CONNECTION_STATE_ACTIVATING,
+    NM_ACTIVE_CONNECTION_STATE_ACTIVATED
+} NMActiveConnectionState;
+
+#define	NM_DBUS_SERVICE			"org.freedesktop.NetworkManager"
+
+#define	NM_DBUS_PATH				        "/org/freedesktop/NetworkManager"
+#define	NM_DBUS_INTERFACE			        "org.freedesktop.NetworkManager"
+#define	NM_DBUS_INTERFACE_DEVICE	        NM_DBUS_INTERFACE ".Device"
+#define NM_DBUS_INTERFACE_DEVICE_WIRED      NM_DBUS_INTERFACE_DEVICE ".Wired"
+#define NM_DBUS_INTERFACE_DEVICE_WIRELESS   NM_DBUS_INTERFACE_DEVICE ".Wireless"
+#define NM_DBUS_PATH_ACCESS_POINT           NM_DBUS_PATH "/AccessPoint"
+#define NM_DBUS_INTERFACE_ACCESS_POINT      NM_DBUS_INTERFACE ".AccessPoint"
+
+#define NM_DBUS_PATH_SETTINGS             "/org/freedesktop/NetworkManagerSettings"
+
+#define NM_DBUS_IFACE_SETTINGS_CONNECTION "org.freedesktop.NetworkManagerSettings.Connection"
+#define NM_DBUS_IFACE_SETTINGS            "org.freedesktop.NetworkManagerSettings"
+#define NM_DBUS_INTERFACE_ACTIVE_CONNECTION NM_DBUS_INTERFACE ".Connection.Active"
+#define NM_DBUS_INTERFACE_IP4_CONFIG        NM_DBUS_INTERFACE ".IP4Config"
+
+#define NM_DBUS_SERVICE_USER_SETTINGS     "org.freedesktop.NetworkManagerUserSettings"
+#define NM_DBUS_SERVICE_SYSTEM_SETTINGS   "org.freedesktop.NetworkManagerSystemSettings"
+
+#define NM_802_11_AP_FLAGS_NONE				0x00000000
+#define NM_802_11_AP_FLAGS_PRIVACY			0x00000001
+#endif
+
+QT_BEGIN_NAMESPACE
+
+typedef QMap< QString, QMap<QString,QVariant> > QNmSettingsMap;
+typedef QList<quint32> ServerThing;
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(QT_PREPEND_NAMESPACE(QNmSettingsMap))
+Q_DECLARE_METATYPE(QT_PREPEND_NAMESPACE(ServerThing))
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkManagerInterfacePrivate;
+class QNetworkManagerInterface : public QObject
+{
+    Q_OBJECT
+    
+public:
+    
+    QNetworkManagerInterface(QObject *parent = 0);
+    ~QNetworkManagerInterface();
+    
+    QList <QDBusObjectPath> getDevices() const;
+    void activateConnection(const QString &serviceName, QDBusObjectPath connection, QDBusObjectPath device, QDBusObjectPath specificObject);
+    void deactivateConnection(QDBusObjectPath connectionPath) const;
+    
+    QDBusObjectPath path() const;
+    QDBusInterface *connectionInterface() const;
+    
+    bool wirelessEnabled() const;
+    bool wirelessHardwareEnabled() const;
+    QList <QDBusObjectPath> activeConnections() const;
+    quint32 state();
+    bool setConnections();
+    bool isValid();
+    
+Q_SIGNALS:
+    void deviceAdded(QDBusObjectPath);
+    void deviceRemoved(QDBusObjectPath);
+    void propertiesChanged( const QString &, QMap<QString,QVariant>);
+    void stateChanged(const QString&, quint32);
+    void activationFinished(QDBusPendingCallWatcher*);
+
+private Q_SLOTS:
+private:
+    QNetworkManagerInterfacePrivate *d;
+    QNmDBusHelper *nmDBusHelper;
+};
+
+class QNetworkManagerInterfaceAccessPointPrivate;
+class QNetworkManagerInterfaceAccessPoint : public QObject
+{
+    Q_OBJECT
+    
+public:
+    
+    enum DeviceState {
+        Unknown = 0,
+        Unmanaged,
+        Unavailable,
+        Disconnected,
+        Prepare,
+        Config,
+        NeedAuthentication,
+        IpConfig,
+        Activated,
+        Failed
+    };
+    
+    enum ApFlag {
+        ApNone = 0x0,
+        Privacy = 0x1
+    };
+    
+    Q_DECLARE_FLAGS(ApFlags, ApFlag);
+    
+    enum ApSecurityFlag {
+        ApSecurityNone = 0x0,
+        PairWep40 = 0x1,
+        PairWep104 = 0x2,
+        PairTkip = 0x4,
+        PairCcmp = 0x8,
+        GroupWep40 = 0x10,
+        GroupWep104 = 0x20,
+        GroupTkip = 0x40,
+        GroupCcmp = 0x80,
+        KeyPsk = 0x100,
+        Key8021x = 0x200
+    };
+    
+    Q_DECLARE_FLAGS(ApSecurityFlags, ApSecurityFlag);
+    
+    explicit QNetworkManagerInterfaceAccessPoint(const QString &dbusPathName, QObject *parent = 0);
+    ~QNetworkManagerInterfaceAccessPoint();
+
+    QDBusInterface *connectionInterface() const;
+
+    quint32 flags() const;
+    quint32 wpaFlags() const;
+    quint32 rsnFlags() const;
+    QString ssid() const;
+    quint32 frequency() const;
+    QString hwAddress() const;
+    quint32 mode() const;
+    quint32 maxBitrate() const;
+    quint32 strength() const;
+    bool setConnections();
+    bool isValid();
+    
+Q_SIGNALS:
+    void propertiesChanged(QMap <QString,QVariant>);
+    void propertiesChanged( const QString &, QMap<QString,QVariant>);
+private:
+    QNetworkManagerInterfaceAccessPointPrivate *d;
+    QNmDBusHelper *nmDBusHelper;
+
+};
+
+class QNetworkManagerInterfaceDevicePrivate;
+class QNetworkManagerInterfaceDevice : public QObject
+{
+    Q_OBJECT
+    
+public:
+    
+    explicit QNetworkManagerInterfaceDevice(const QString &deviceObjectPath, QObject *parent = 0);
+    ~QNetworkManagerInterfaceDevice();
+    
+    QString udi() const;
+    QString networkInterface() const;
+    QDBusInterface *connectionInterface() const;
+    quint32 ip4Address() const;
+    quint32 state() const;
+    quint32 deviceType() const;
+    
+    QDBusObjectPath ip4config() const;
+    bool setConnections();
+    bool isValid();
+    
+Q_SIGNALS:
+    void stateChanged(const QString &, quint32);
+
+private:
+    QNetworkManagerInterfaceDevicePrivate *d;
+    QNmDBusHelper *nmDBusHelper;
+};
+
+class QNetworkManagerInterfaceDeviceWiredPrivate;
+class QNetworkManagerInterfaceDeviceWired : public QObject
+{
+    Q_OBJECT
+    
+public:
+    
+    explicit QNetworkManagerInterfaceDeviceWired(const QString &ifaceDevicePath,
+                                                 QObject *parent = 0);
+    ~QNetworkManagerInterfaceDeviceWired();
+    
+    QDBusInterface  *connectionInterface() const;
+    QString hwAddress() const;
+    quint32 speed() const;
+    bool carrier() const;
+    bool setConnections();
+    bool isValid();
+    
+Q_SIGNALS:
+    void propertiesChanged( const QString &, QMap<QString,QVariant>);
+private:
+    QNetworkManagerInterfaceDeviceWiredPrivate *d;
+    QNmDBusHelper *nmDBusHelper;
+};
+
+class QNetworkManagerInterfaceDeviceWirelessPrivate;
+class QNetworkManagerInterfaceDeviceWireless : public QObject
+{
+    Q_OBJECT
+    
+public:
+    
+    enum DeviceCapability {
+        None = 0x0,
+        Wep40 = 0x1,
+        Wep104 = 0x2,
+        Tkip = 0x4,
+        Ccmp = 0x8,
+        Wpa = 0x10,
+        Rsn = 0x20
+       };
+    
+    explicit QNetworkManagerInterfaceDeviceWireless(const QString &ifaceDevicePath,
+                                                    QObject *parent = 0);
+    ~QNetworkManagerInterfaceDeviceWireless();
+    
+    QDBusObjectPath path() const;
+    QList <QDBusObjectPath> getAccessPoints();
+    QDBusInterface *connectionInterface() const;
+
+    QString hwAddress() const;
+    quint32 mode() const;
+    quint32 bitrate() const;
+    QDBusObjectPath activeAccessPoint() const;
+    quint32 wirelessCapabilities() const;
+    bool setConnections();
+    bool isValid();
+    
+Q_SIGNALS:
+    void propertiesChanged( const QString &, QMap<QString,QVariant>);
+    void accessPointAdded(const QString &,QDBusObjectPath);
+    void accessPointRemoved(const QString &,QDBusObjectPath);
+private:
+    QNetworkManagerInterfaceDeviceWirelessPrivate *d;
+    QNmDBusHelper *nmDBusHelper;
+};
+
+class QNetworkManagerSettingsPrivate;
+class QNetworkManagerSettings : public QObject
+{
+    Q_OBJECT
+    
+public:
+    
+    explicit QNetworkManagerSettings(const QString &settingsService, QObject *parent = 0);
+    ~QNetworkManagerSettings();
+    
+    QDBusInterface  *connectionInterface() const;
+    QList <QDBusObjectPath> listConnections();
+    bool setConnections();
+    bool isValid();
+
+Q_SIGNALS:
+    void newConnection(QDBusObjectPath);
+private:
+    QNetworkManagerSettingsPrivate *d;
+};
+
+class QNetworkManagerSettingsConnectionPrivate;
+class QNetworkManagerSettingsConnection : public QObject
+{
+    Q_OBJECT
+    
+public:
+    
+    QNetworkManagerSettingsConnection(const QString &settingsService, const QString &connectionObjectPath, QObject *parent = 0);
+    ~QNetworkManagerSettingsConnection();
+    
+    QDBusInterface  *connectionInterface() const;
+    QNmSettingsMap getSettings();
+    bool setConnections();
+    NMDeviceType getType();
+    bool isAutoConnect();
+    quint64 getTimestamp();
+    QString getId();
+    QString getUuid();
+    QString getSsid();
+    QString getMacAddress();
+    QStringList getSeenBssids();
+    bool isValid();
+
+Q_SIGNALS:
+    
+    void updated(const QNmSettingsMap &settings);
+    void removed(const QString &path);
+
+private:
+    QNmDBusHelper *nmDBusHelper;
+    QNetworkManagerSettingsConnectionPrivate *d;
+};
+
+class QNetworkManagerConnectionActivePrivate;
+class QNetworkManagerConnectionActive : public QObject
+{
+    Q_OBJECT
+    
+public:
+    
+    enum ActiveConnectionState {
+        Unknown = 0,
+        Activating = 1,
+        Activated = 2
+       };
+    
+    explicit QNetworkManagerConnectionActive(const QString &dbusPathName, QObject *parent = 0);
+    ~ QNetworkManagerConnectionActive();
+    
+    QDBusInterface  *connectionInterface() const;
+    QString serviceName() const;
+    QDBusObjectPath connection() const;
+    QDBusObjectPath specificObject() const;
+    QList<QDBusObjectPath> devices() const;
+    quint32 state() const;
+    bool defaultRoute() const;
+    bool setConnections();
+    bool isValid();
+
+    
+Q_SIGNALS:
+    void propertiesChanged(QList<QDBusObjectPath>);
+    void propertiesChanged( const QString &, QMap<QString,QVariant>);
+private:
+    QNetworkManagerConnectionActivePrivate *d;
+    QNmDBusHelper *nmDBusHelper;
+};
+
+class QNetworkManagerIp4ConfigPrivate;
+class QNetworkManagerIp4Config : public QObject
+{
+    Q_OBJECT
+    
+public:
+    explicit QNetworkManagerIp4Config(const QString &dbusPathName, QObject *parent = 0);
+	~QNetworkManagerIp4Config();
+
+    QStringList domains() const;
+    bool isValid();
+
+ private:
+	QNetworkManagerIp4ConfigPrivate *d;    
+};
+
+QT_END_NAMESPACE
+
+#endif //QNETWORKMANAGERSERVICE_H
diff --git a/src/plugins/bearer/networkmanager/qnmdbushelper.cpp b/src/plugins/bearer/networkmanager/qnmdbushelper.cpp
new file mode 100644
index 0000000..e195eeb
--- /dev/null
+++ b/src/plugins/bearer/networkmanager/qnmdbushelper.cpp
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+// this class is for helping qdbus get stuff
+
+#include "qnmdbushelper.h"
+
+#include "qnetworkmanagerservice.h"
+
+#include <QDBusError>
+#include <QDBusInterface>
+#include <QDBusMessage>
+#include <QDBusReply>
+
+#include <QDebug>
+
+QT_BEGIN_NAMESPACE
+
+QNmDBusHelper::QNmDBusHelper(QObject * parent)
+        : QObject(parent)
+{
+}
+
+QNmDBusHelper::~QNmDBusHelper()
+{
+}
+
+void QNmDBusHelper::deviceStateChanged(quint32 state)
+ {
+    QDBusMessage msg = this->message();
+    if(state == NM_DEVICE_STATE_ACTIVATED
+       || state == NM_DEVICE_STATE_DISCONNECTED
+       || state == NM_DEVICE_STATE_UNAVAILABLE
+       || state == NM_DEVICE_STATE_FAILED) {
+        emit pathForStateChanged(msg.path(), state);
+    }
+ }
+
+void QNmDBusHelper::slotAccessPointAdded(QDBusObjectPath path)
+{
+    if(path.path().length() > 2) {
+        QDBusMessage msg = this->message();
+        emit pathForAccessPointAdded(msg.path(), path);
+    }
+}
+
+void QNmDBusHelper::slotAccessPointRemoved(QDBusObjectPath path)
+{
+    if(path.path().length() > 2) {
+        QDBusMessage msg = this->message();
+        emit pathForAccessPointRemoved(msg.path(), path);
+    }
+}
+
+void QNmDBusHelper::slotPropertiesChanged(QMap<QString,QVariant> map)
+{
+    QDBusMessage msg = this->message();
+    QMapIterator<QString, QVariant> i(map);
+    while (i.hasNext()) {
+        i.next();
+        if( i.key() == "State") { //state only applies to device interfaces
+            quint32 state = i.value().toUInt();
+            if( state == NM_DEVICE_STATE_ACTIVATED
+                || state == NM_DEVICE_STATE_DISCONNECTED
+                || state == NM_DEVICE_STATE_UNAVAILABLE
+                || state == NM_DEVICE_STATE_FAILED) {
+                emit  pathForPropertiesChanged( msg.path(), map);
+            }
+        } else if( i.key() == "ActiveAccessPoint") {
+            emit pathForPropertiesChanged(msg.path(), map);
+            //            qWarning()  << __PRETTY_FUNCTION__ << i.key() << ": " << i.value().value<QDBusObjectPath>().path();
+            //      } else if( i.key() == "Strength")
+            //            qWarning()  << __PRETTY_FUNCTION__ << i.key() << ": " << i.value().toUInt();
+            //   else
+            //            qWarning()  << __PRETTY_FUNCTION__ << i.key() << ": " << i.value();
+        } else if (i.key() == "ActiveConnections") {
+            emit pathForPropertiesChanged(msg.path(), map);
+        }
+    }
+}
+
+void QNmDBusHelper::slotSettingsRemoved()
+{
+    QDBusMessage msg = this->message();
+    emit pathForSettingsRemoved(msg.path());
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/networkmanager/qnmdbushelper.h b/src/plugins/bearer/networkmanager/qnmdbushelper.h
new file mode 100644
index 0000000..933d55a
--- /dev/null
+++ b/src/plugins/bearer/networkmanager/qnmdbushelper.h
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNMDBUSHELPERPRIVATE_H
+#define QNMDBUSHELPERPRIVATE_H
+
+#include <QDBusObjectPath>
+#include <QDBusContext>
+#include <QMap>
+
+QT_BEGIN_NAMESPACE
+
+class QNmDBusHelper: public QObject, protected QDBusContext
+ {
+     Q_OBJECT
+ public:
+    QNmDBusHelper(QObject *parent = 0);
+    ~QNmDBusHelper();
+
+ public slots:
+    void deviceStateChanged(quint32);
+    void slotAccessPointAdded( QDBusObjectPath );
+    void slotAccessPointRemoved( QDBusObjectPath );
+    void slotPropertiesChanged( QMap<QString,QVariant>);
+    void slotSettingsRemoved();
+
+Q_SIGNALS:
+    void pathForStateChanged(const QString &, quint32);
+    void pathForAccessPointAdded(const QString &,  QDBusObjectPath );
+    void pathForAccessPointRemoved(const QString &,  QDBusObjectPath );
+    void pathForPropertiesChanged(const QString &, QMap<QString,QVariant>);
+    void pathForSettingsRemoved(const QString &);
+};
+
+QT_END_NAMESPACE
+
+#endif// QNMDBUSHELPERPRIVATE_H
diff --git a/src/plugins/bearer/nla/main.cpp b/src/plugins/bearer/nla/main.cpp
new file mode 100644
index 0000000..479a933
--- /dev/null
+++ b/src/plugins/bearer/nla/main.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnlaengine.h"
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QNlaEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QNlaEnginePlugin();
+    ~QNlaEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QNlaEnginePlugin::QNlaEnginePlugin()
+{
+}
+
+QNlaEnginePlugin::~QNlaEnginePlugin()
+{
+}
+
+QStringList QNlaEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("nla");
+}
+
+QBearerEngine *QNlaEnginePlugin::create(const QString &key) const
+{
+    if (key == QLatin1String("nla"))
+        return new QNlaEngine;
+    else
+        return 0;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QNlaEnginePlugin)
+Q_EXPORT_PLUGIN2(qnlabearer, QNlaEnginePlugin)
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/nla/nla.pro b/src/plugins/bearer/nla/nla.pro
new file mode 100644
index 0000000..5148b09
--- /dev/null
+++ b/src/plugins/bearer/nla/nla.pro
@@ -0,0 +1,23 @@
+TARGET = qnlabearer
+include(../../qpluginbase.pri)
+
+QT += network
+
+!wince* {
+    LIBS += -lWs2_32
+} else {
+    LIBS += -lWs2
+}
+
+HEADERS += qnlaengine.h \
+           ../platformdefs_win.h \
+           ../qnetworksession_impl.h \
+           ../qbearerengine_impl.h
+
+SOURCES += main.cpp \
+           qnlaengine.cpp \
+           ../qnetworksession_impl.cpp
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
diff --git a/src/plugins/bearer/nla/qnlaengine.cpp b/src/plugins/bearer/nla/qnlaengine.cpp
new file mode 100644
index 0000000..9ab9924
--- /dev/null
+++ b/src/plugins/bearer/nla/qnlaengine.cpp
@@ -0,0 +1,659 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnlaengine.h"
+#include "../qnetworksession_impl.h"
+
+#include <QtNetwork/private/qnetworkconfiguration_p.h>
+
+#include <QtCore/qthread.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qstringlist.h>
+
+#include <QtCore/qdebug.h>
+
+#include "../platformdefs_win.h"
+
+QT_BEGIN_NAMESPACE
+
+QWindowsSockInit2::QWindowsSockInit2()
+:   version(0)
+{
+    //### should we try for 2.2 on all platforms ??
+    WSAData wsadata;
+
+    // IPv6 requires Winsock v2.0 or better.
+    if (WSAStartup(MAKEWORD(2,0), &wsadata) != 0) {
+        qWarning("QBearerManagementAPI: WinSock v2.0 initialization failed.");
+    } else {
+        version = 0x20;
+    }
+}
+
+QWindowsSockInit2::~QWindowsSockInit2()
+{
+    WSACleanup();
+}
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+static void printBlob(NLA_BLOB *blob)
+{
+    qDebug() << "==== BEGIN NLA_BLOB ====";
+
+    qDebug() << "type:" << blob->header.type;
+    qDebug() << "size:" << blob->header.dwSize;
+    qDebug() << "next offset:" << blob->header.nextOffset;
+
+    switch (blob->header.type) {
+    case NLA_RAW_DATA:
+        qDebug() << "Raw Data";
+        qDebug() << '\t' << blob->data.rawData;
+        break;
+    case NLA_INTERFACE:
+        qDebug() << "Interface";
+        qDebug() << "\ttype:" << blob->data.interfaceData.dwType;
+        qDebug() << "\tspeed:" << blob->data.interfaceData.dwSpeed;
+        qDebug() << "\tadapter:" << blob->data.interfaceData.adapterName;
+        break;
+    case NLA_802_1X_LOCATION:
+        qDebug() << "802.1x Location";
+        qDebug() << '\t' << blob->data.locationData.information;
+        break;
+    case NLA_CONNECTIVITY:
+        qDebug() << "Connectivity";
+        qDebug() << "\ttype:" << blob->data.connectivity.type;
+        qDebug() << "\tinternet:" << blob->data.connectivity.internet;
+        break;
+    case NLA_ICS:
+        qDebug() << "ICS";
+        qDebug() << "\tspeed:" << blob->data.ICS.remote.speed;
+        qDebug() << "\ttype:" << blob->data.ICS.remote.type;
+        qDebug() << "\tstate:" << blob->data.ICS.remote.state;
+        qDebug() << "\tmachine name:" << blob->data.ICS.remote.machineName;
+        qDebug() << "\tshared adapter name:" << blob->data.ICS.remote.sharedAdapterName;
+        break;
+    default:
+        qDebug() << "UNKNOWN BLOB TYPE";
+    }
+
+    qDebug() << "===== END NLA_BLOB =====";
+}
+#endif
+
+static QString qGetInterfaceType(const QString &interface)
+{
+#ifdef Q_OS_WINCE
+    Q_UNUSED(interface)
+#else
+    unsigned long oid;
+    DWORD bytesWritten;
+
+    NDIS_MEDIUM medium;
+    NDIS_PHYSICAL_MEDIUM physicalMedium;
+
+    HANDLE handle = CreateFile((TCHAR *)QString(QLatin1String("\\\\.\\%1")).arg(interface).utf16(),
+                               0, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
+    if (handle == INVALID_HANDLE_VALUE)
+        return QLatin1String("Unknown");
+
+    oid = OID_GEN_MEDIA_SUPPORTED;
+    bytesWritten = 0;
+    bool result = DeviceIoControl(handle, IOCTL_NDIS_QUERY_GLOBAL_STATS, &oid, sizeof(oid),
+                                  &medium, sizeof(medium), &bytesWritten, 0);
+    if (!result) {
+        CloseHandle(handle);
+        return QLatin1String("Unknown");
+    }
+
+    oid = OID_GEN_PHYSICAL_MEDIUM;
+    bytesWritten = 0;
+    result = DeviceIoControl(handle, IOCTL_NDIS_QUERY_GLOBAL_STATS, &oid, sizeof(oid),
+                             &physicalMedium, sizeof(physicalMedium), &bytesWritten, 0);
+    if (!result) {
+        CloseHandle(handle);
+
+        if (medium == NdisMedium802_3)
+            return QLatin1String("Ethernet");
+        else
+            return QLatin1String("Unknown");
+    }
+
+    CloseHandle(handle);
+
+    if (medium == NdisMedium802_3) {
+        switch (physicalMedium) {
+        case NdisPhysicalMediumWirelessLan:
+            return QLatin1String("WLAN");
+        case NdisPhysicalMediumBluetooth:
+            return QLatin1String("Bluetooth");
+        case NdisPhysicalMediumWiMax:
+            return QLatin1String("WiMAX");
+        default:
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug() << "Physical Medium" << physicalMedium;
+#endif
+            return QLatin1String("Ethernet");
+        }
+    }
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+    qDebug() << medium << physicalMedium;
+#endif
+
+#endif
+
+    return QLatin1String("Unknown");
+}
+
+class QNlaThread : public QThread
+{
+    Q_OBJECT
+
+public:
+    QNlaThread(QNlaEngine *parent = 0);
+    ~QNlaThread();
+
+    QList<QNetworkConfigurationPrivate *> getConfigurations();
+
+    void forceUpdate();
+
+protected:
+    virtual void run();
+
+private:
+    void updateConfigurations(QList<QNetworkConfigurationPrivate *> &configs);
+    DWORD parseBlob(NLA_BLOB *blob, QNetworkConfigurationPrivate *cpPriv) const;
+    QNetworkConfigurationPrivate *parseQuerySet(const WSAQUERYSET *querySet) const;
+    void fetchConfigurations();
+
+signals:
+    void networksChanged();
+
+private:
+    QMutex mutex;
+    HANDLE handle;
+    bool done;
+    QList<QNetworkConfigurationPrivate *> fetchedConfigurations;
+};
+
+QNlaThread::QNlaThread(QNlaEngine *parent)
+:   QThread(parent), handle(0), done(false)
+{
+}
+
+QNlaThread::~QNlaThread()
+{
+    mutex.lock();
+
+    done = true;
+
+    if (handle) {
+        /* cancel completion event */
+        if (WSALookupServiceEnd(handle) == SOCKET_ERROR) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("WSALookupServiceEnd error %d", WSAGetLastError());
+#endif
+        }
+    }
+    mutex.unlock();
+
+    wait();
+}
+
+QList<QNetworkConfigurationPrivate *> QNlaThread::getConfigurations()
+{
+    QMutexLocker locker(&mutex);
+
+    QList<QNetworkConfigurationPrivate *> foundConfigurations = fetchedConfigurations;
+    fetchedConfigurations.clear();
+
+    return foundConfigurations;
+}
+
+void QNlaThread::forceUpdate()
+{
+    mutex.lock();
+
+    if (handle) {
+        /* cancel completion event */
+        if (WSALookupServiceEnd(handle) == SOCKET_ERROR) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("WSALookupServiceEnd error %d", WSAGetLastError());
+#endif
+        }
+        handle = 0;
+    }
+    mutex.unlock();
+}
+
+void QNlaThread::run()
+{
+    WSAEVENT changeEvent = WSACreateEvent();
+    if (changeEvent == WSA_INVALID_EVENT)
+        return;
+
+    while (true) {
+        fetchConfigurations();
+
+        WSAQUERYSET qsRestrictions;
+
+        memset(&qsRestrictions, 0, sizeof(qsRestrictions));
+        qsRestrictions.dwSize = sizeof(qsRestrictions);
+        qsRestrictions.dwNameSpace = NS_NLA;
+
+        mutex.lock();
+        if (done) {
+            mutex.unlock();
+            break;
+        }
+        int result = WSALookupServiceBegin(&qsRestrictions, LUP_RETURN_ALL, &handle);
+        mutex.unlock();
+
+        if (result == SOCKET_ERROR)
+            break;
+
+        WSACOMPLETION completion;
+        WSAOVERLAPPED overlapped;
+
+        memset(&overlapped, 0, sizeof(overlapped));
+        overlapped.hEvent = changeEvent;
+
+        memset(&completion, 0, sizeof(completion));
+        completion.Type = NSP_NOTIFY_EVENT;
+        completion.Parameters.Event.lpOverlapped = &overlapped;
+
+        DWORD bytesReturned = 0;
+        result = WSANSPIoctl(handle, SIO_NSP_NOTIFY_CHANGE, 0, 0, 0, 0,
+                             &bytesReturned, &completion);
+        if (result == SOCKET_ERROR) {
+            if (WSAGetLastError() != WSA_IO_PENDING)
+                break;
+        }
+
+#ifndef Q_OS_WINCE
+        // Not interested in unrelated IO completion events
+        // although we also don't want to block them
+        while (WaitForSingleObjectEx(changeEvent, WSA_INFINITE, true) != WAIT_IO_COMPLETION &&
+               handle)
+        {
+        }
+#else
+        WaitForSingleObject(changeEvent, WSA_INFINITE);
+#endif
+
+        mutex.lock();
+        if (handle) {
+            result = WSALookupServiceEnd(handle);
+            if (result == SOCKET_ERROR) {
+                mutex.unlock();
+                break;
+            }
+            handle = 0;
+        }
+        mutex.unlock();
+    }
+
+    WSACloseEvent(changeEvent);
+}
+
+void QNlaThread::updateConfigurations(QList<QNetworkConfigurationPrivate *> &configs)
+{
+    mutex.lock();
+
+    while (!fetchedConfigurations.isEmpty())
+        delete fetchedConfigurations.takeFirst();
+
+    fetchedConfigurations = configs;
+
+    mutex.unlock();
+
+    emit networksChanged();
+}
+
+DWORD QNlaThread::parseBlob(NLA_BLOB *blob, QNetworkConfigurationPrivate *cpPriv) const
+{
+#ifdef BEARER_MANAGEMENT_DEBUG
+    printBlob(blob);
+#endif
+
+    switch (blob->header.type) {
+    case NLA_RAW_DATA:
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: unhandled header type NLA_RAW_DATA", __FUNCTION__);
+#endif
+        break;
+    case NLA_INTERFACE:
+        cpPriv->state = QNetworkConfiguration::Active;
+        if (QNlaEngine *engine = qobject_cast<QNlaEngine *>(parent())) {
+            engine->configurationInterface[cpPriv->id.toUInt()] =
+                QString::fromLatin1(blob->data.interfaceData.adapterName);
+        }
+        break;
+    case NLA_802_1X_LOCATION:
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: unhandled header type NLA_802_1X_LOCATION", __FUNCTION__);
+#endif
+        break;
+    case NLA_CONNECTIVITY:
+        if (blob->data.connectivity.internet == NLA_INTERNET_YES)
+            cpPriv->internet = true;
+        else
+            cpPriv->internet = false;
+        break;
+    case NLA_ICS:
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: unhandled header type NLA_ICS", __FUNCTION__);
+#endif
+        break;
+    default:
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug("%s: unhandled header type %d", __FUNCTION__, blob->header.type);
+#endif
+        ;
+    }
+
+    return blob->header.nextOffset;
+}
+
+QNetworkConfigurationPrivate *QNlaThread::parseQuerySet(const WSAQUERYSET *querySet) const
+{
+    QNetworkConfigurationPrivate *cpPriv = new QNetworkConfigurationPrivate;
+
+    cpPriv->name = QString::fromWCharArray(querySet->lpszServiceInstanceName);
+    cpPriv->isValid = true;
+    cpPriv->id = QString::number(qHash(QLatin1String("NLA:") + cpPriv->name));
+    cpPriv->state = QNetworkConfiguration::Defined;
+    cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+
+#ifdef BEARER_MANAGEMENT_DEBUG
+    qDebug() << "size:" << querySet->dwSize;
+    qDebug() << "service instance name:" << QString::fromUtf16(querySet->lpszServiceInstanceName);
+    qDebug() << "service class id:" << querySet->lpServiceClassId;
+    qDebug() << "version:" << querySet->lpVersion;
+    qDebug() << "comment:" << QString::fromUtf16(querySet->lpszComment);
+    qDebug() << "namespace:" << querySet->dwNameSpace;
+    qDebug() << "namespace provider id:" << querySet->lpNSProviderId;
+    qDebug() << "context:" << QString::fromUtf16(querySet->lpszContext);
+    qDebug() << "number of protocols:" << querySet->dwNumberOfProtocols;
+    qDebug() << "protocols:" << querySet->lpafpProtocols;
+    qDebug() << "query string:" << QString::fromUtf16(querySet->lpszQueryString);
+    qDebug() << "number of cs addresses:" << querySet->dwNumberOfCsAddrs;
+    qDebug() << "cs addresses:" << querySet->lpcsaBuffer;
+    qDebug() << "output flags:" << querySet->dwOutputFlags;
+#endif
+
+    if (querySet->lpBlob) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+        qDebug() << "blob size:" << querySet->lpBlob->cbSize;
+        qDebug() << "blob data:" << querySet->lpBlob->pBlobData;
+#endif
+
+        DWORD offset = 0;
+        do {
+            NLA_BLOB *blob = reinterpret_cast<NLA_BLOB *>(querySet->lpBlob->pBlobData + offset);
+            DWORD nextOffset = parseBlob(blob, cpPriv);
+            if (nextOffset == offset)
+                break;
+            else
+                offset = nextOffset;
+        } while (offset != 0 && offset < querySet->lpBlob->cbSize);
+    }
+
+    if (QNlaEngine *engine = qobject_cast<QNlaEngine *>(parent()))
+        cpPriv->bearer = engine->bearerName(cpPriv->id);
+
+    return cpPriv;
+}
+
+void QNlaThread::fetchConfigurations()
+{
+    QList<QNetworkConfigurationPrivate *> foundConfigurations;
+
+    WSAQUERYSET qsRestrictions;
+    HANDLE hLookup = 0;
+
+    memset(&qsRestrictions, 0, sizeof(qsRestrictions));
+    qsRestrictions.dwSize = sizeof(qsRestrictions);
+    qsRestrictions.dwNameSpace = NS_NLA;
+
+    int result = WSALookupServiceBegin(&qsRestrictions, LUP_RETURN_ALL | LUP_DEEP, &hLookup);
+    if (result == SOCKET_ERROR) {
+        mutex.lock();
+        fetchedConfigurations.clear();
+        mutex.unlock();
+    }
+
+    char buffer[0x10000];
+    while (result == 0) {
+        DWORD bufferLength = sizeof(buffer);
+        result = WSALookupServiceNext(hLookup, LUP_RETURN_ALL,
+                                      &bufferLength, reinterpret_cast<WSAQUERYSET *>(buffer));
+
+        if (result == SOCKET_ERROR)
+            break;
+
+        QNetworkConfigurationPrivate *cpPriv =
+            parseQuerySet(reinterpret_cast<WSAQUERYSET *>(buffer));
+
+        foundConfigurations.append(cpPriv);
+    }
+
+    if (hLookup) {
+        result = WSALookupServiceEnd(hLookup);
+        if (result == SOCKET_ERROR) {
+#ifdef BEARER_MANAGEMENT_DEBUG
+            qDebug("WSALookupServiceEnd error %d", WSAGetLastError());
+#endif
+        }
+    }
+
+    updateConfigurations(foundConfigurations);
+}
+
+QNlaEngine::QNlaEngine(QObject *parent)
+:   QBearerEngineImpl(parent), nlaThread(0)
+{
+    nlaThread = new QNlaThread(this);
+    connect(nlaThread, SIGNAL(networksChanged()),
+            this, SLOT(networksChanged()));
+    nlaThread->start();
+
+    qApp->processEvents(QEventLoop::ExcludeUserInputEvents);
+}
+
+QNlaEngine::~QNlaEngine()
+{
+    delete nlaThread;
+}
+
+void QNlaEngine::networksChanged()
+{
+    QMutexLocker locker(&mutex);
+
+    QStringList previous = accessPointConfigurations.keys();
+
+    QList<QNetworkConfigurationPrivate *> foundConfigurations = nlaThread->getConfigurations();
+    while (!foundConfigurations.isEmpty()) {
+        QNetworkConfigurationPrivate *cpPriv = foundConfigurations.takeFirst();
+
+        previous.removeAll(cpPriv->id);
+
+        if (accessPointConfigurations.contains(cpPriv->id)) {
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(cpPriv->id);
+
+            bool changed = false;
+
+            ptr->mutex.lock();
+
+            if (ptr->isValid != cpPriv->isValid) {
+                ptr->isValid = cpPriv->isValid;
+                changed = true;
+            }
+
+            if (ptr->name != cpPriv->name) {
+                ptr->name = cpPriv->name;
+                changed = true;
+            }
+
+            if (ptr->state != cpPriv->state) {
+                ptr->state = cpPriv->state;
+                changed = true;
+            }
+
+            ptr->mutex.unlock();
+
+            if (changed) {
+                locker.unlock();
+                emit configurationChanged(ptr);
+                locker.relock();
+            }
+
+            delete cpPriv;
+        } else {
+            QNetworkConfigurationPrivatePointer ptr(cpPriv);
+
+            accessPointConfigurations.insert(ptr->id, ptr);
+
+            locker.unlock();
+            emit configurationAdded(ptr);
+            locker.relock();
+        }
+    }
+
+    while (!previous.isEmpty()) {
+        QNetworkConfigurationPrivatePointer ptr =
+            accessPointConfigurations.take(previous.takeFirst());
+
+        locker.unlock();
+        emit configurationRemoved(ptr);
+        locker.relock();
+    }
+
+    locker.unlock();
+    emit updateCompleted();
+}
+
+QString QNlaEngine::getInterfaceFromId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    return configurationInterface.value(id.toUInt());
+}
+
+bool QNlaEngine::hasIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    return configurationInterface.contains(id.toUInt());
+}
+
+QString QNlaEngine::bearerName(const QString &id)
+{
+    QString interface = getInterfaceFromId(id);
+
+    if (interface.isEmpty())
+        return QString();
+
+    return qGetInterfaceType(interface);
+}
+
+void QNlaEngine::connectToId(const QString &id)
+{
+    emit connectionError(id, OperationNotSupported);
+}
+
+void QNlaEngine::disconnectFromId(const QString &id)
+{
+    emit connectionError(id, OperationNotSupported);
+}
+
+void QNlaEngine::requestUpdate()
+{
+    QMutexLocker locker(&mutex);
+
+    nlaThread->forceUpdate();
+}
+
+QNetworkSession::State QNlaEngine::sessionStateForId(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);
+
+    if (!ptr)
+        return QNetworkSession::Invalid;
+
+    if (!ptr->isValid) {
+        return QNetworkSession::Invalid;
+    } else if ((ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+        return QNetworkSession::Connected;
+    } else if ((ptr->state & QNetworkConfiguration::Discovered) ==
+                QNetworkConfiguration::Discovered) {
+        return QNetworkSession::Disconnected;
+    } else if ((ptr->state & QNetworkConfiguration::Defined) == QNetworkConfiguration::Defined) {
+        return QNetworkSession::NotAvailable;
+    } else if ((ptr->state & QNetworkConfiguration::Undefined) ==
+                QNetworkConfiguration::Undefined) {
+        return QNetworkSession::NotAvailable;
+    }
+
+    return QNetworkSession::Invalid;
+}
+
+QNetworkConfigurationManager::Capabilities QNlaEngine::capabilities() const
+{
+    return QNetworkConfigurationManager::ForcedRoaming;
+}
+
+QNetworkSessionPrivate *QNlaEngine::createSessionBackend()
+{
+    return new QNetworkSessionPrivateImpl;
+}
+
+QNetworkConfigurationPrivatePointer QNlaEngine::defaultConfiguration()
+{
+    return QNetworkConfigurationPrivatePointer();
+}
+
+#include "qnlaengine.moc"
+QT_END_NAMESPACE
+
diff --git a/src/plugins/bearer/nla/qnlaengine.h b/src/plugins/bearer/nla/qnlaengine.h
new file mode 100644
index 0000000..1d49464
--- /dev/null
+++ b/src/plugins/bearer/nla/qnlaengine.h
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNLAENGINE_P_H
+#define QNLAENGINE_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "../qbearerengine_impl.h"
+
+#include <QtNetwork/private/qnativesocketengine_p.h>
+
+#include <QMap>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkConfigurationPrivate;
+class QNlaThread;
+
+class QWindowsSockInit2
+{
+public:
+    QWindowsSockInit2();
+    ~QWindowsSockInit2();
+    int version;
+};
+
+class QNlaEngine : public QBearerEngineImpl
+{
+    Q_OBJECT
+
+    friend class QNlaThread;
+
+public:
+    QNlaEngine(QObject *parent = 0);
+    ~QNlaEngine();
+
+    QString getInterfaceFromId(const QString &id);
+    bool hasIdentifier(const QString &id);
+
+    QString bearerName(const QString &id);
+
+    void connectToId(const QString &id);
+    void disconnectFromId(const QString &id);
+
+    Q_INVOKABLE void requestUpdate();
+
+    QNetworkSession::State sessionStateForId(const QString &id);
+
+    QNetworkConfigurationManager::Capabilities capabilities() const;
+
+    QNetworkSessionPrivate *createSessionBackend();
+
+    QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+private Q_SLOTS:
+    void networksChanged();
+
+private:
+    QWindowsSockInit2 winSock;
+    QNlaThread *nlaThread;
+    QMap<uint, QString> configurationInterface;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/plugins/bearer/platformdefs_win.h b/src/plugins/bearer/platformdefs_win.h
new file mode 100644
index 0000000..37d099c
--- /dev/null
+++ b/src/plugins/bearer/platformdefs_win.h
@@ -0,0 +1,134 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPLATFORMDEFS_WIN_H
+#define QPLATFORMDEFS_WIN_H
+
+#include <winsock2.h>
+#include <mswsock.h>
+#undef interface
+#include <winioctl.h>
+
+#ifndef NS_NLA
+
+#define NS_NLA 15
+
+enum NLA_BLOB_DATA_TYPE {
+    NLA_RAW_DATA = 0,
+    NLA_INTERFACE = 1,
+    NLA_802_1X_LOCATION = 2,
+    NLA_CONNECTIVITY = 3,
+    NLA_ICS = 4
+};
+
+enum NLA_CONNECTIVITY_TYPE {
+    NLA_NETWORK_AD_HOC = 0,
+    NLA_NETWORK_MANAGED = 1,
+    NLA_NETWORK_UNMANAGED = 2,
+    NLA_NETWORK_UNKNOWN = 3
+};
+
+enum NLA_INTERNET {
+    NLA_INTERNET_UNKNOWN = 0,
+    NLA_INTERNET_NO = 1,
+    NLA_INTERNET_YES = 2
+};
+
+struct NLA_BLOB {
+    struct {
+        NLA_BLOB_DATA_TYPE type;
+        DWORD dwSize;
+        DWORD nextOffset;
+    } header;
+
+    union {
+        // NLA_RAW_DATA
+        CHAR rawData[1];
+
+        // NLA_INTERFACE
+        struct {
+            DWORD dwType;
+            DWORD dwSpeed;
+            CHAR adapterName[1];
+        } interfaceData;
+
+        // NLA_802_1X_LOCATION
+        struct {
+            CHAR information[1];
+        } locationData;
+
+        // NLA_CONNECTIVITY
+        struct {
+            NLA_CONNECTIVITY_TYPE type;
+            NLA_INTERNET internet;
+        } connectivity;
+
+        // NLA_ICS
+        struct {
+            struct {
+                DWORD speed;
+                DWORD type;
+                DWORD state;
+                WCHAR machineName[256];
+                WCHAR sharedAdapterName[256];
+            } remote;
+        } ICS;
+    } data;
+};
+#endif
+
+enum NDIS_MEDIUM {
+    NdisMedium802_3 = 0,
+};
+
+enum NDIS_PHYSICAL_MEDIUM {
+    NdisPhysicalMediumWirelessLan = 1,
+    NdisPhysicalMediumBluetooth = 10,
+    NdisPhysicalMediumWiMax = 12,
+};
+
+#define OID_GEN_MEDIA_SUPPORTED 0x00010103
+#define OID_GEN_PHYSICAL_MEDIUM 0x00010202
+
+#define IOCTL_NDIS_QUERY_GLOBAL_STATS \
+    CTL_CODE(FILE_DEVICE_PHYSICAL_NETCARD, 0, METHOD_OUT_DIRECT, FILE_ANY_ACCESS)
+
+#endif
diff --git a/src/plugins/bearer/qbearerengine_impl.h b/src/plugins/bearer/qbearerengine_impl.h
new file mode 100644
index 0000000..740def3
--- /dev/null
+++ b/src/plugins/bearer/qbearerengine_impl.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBEARERENGINE_IMPL_H
+#define QBEARERENGINE_IMPL_H
+
+#include <QtNetwork/private/qbearerengine_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QBearerEngineImpl : public QBearerEngine
+{
+    Q_OBJECT
+
+public:
+    enum ConnectionError {
+        InterfaceLookupError = 0,
+        ConnectError,
+        OperationNotSupported,
+        DisconnectionError,
+    };
+
+    QBearerEngineImpl(QObject *parent = 0) : QBearerEngine(parent) { }
+    ~QBearerEngineImpl() { }
+
+    virtual void connectToId(const QString &id) = 0;
+    virtual void disconnectFromId(const QString &id) = 0;
+
+    virtual QString getInterfaceFromId(const QString &id) = 0;
+
+    virtual QNetworkSession::State sessionStateForId(const QString &id) = 0;
+
+    virtual quint64 bytesWritten(const QString &) { return Q_UINT64_C(0); }
+    virtual quint64 bytesReceived(const QString &) { return Q_UINT64_C(0); }
+    virtual quint64 startTime(const QString &) { return Q_UINT64_C(0); }
+
+Q_SIGNALS:
+    void connectionError(const QString &id, QBearerEngineImpl::ConnectionError error);
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/plugins/bearer/qnetworksession_impl.cpp b/src/plugins/bearer/qnetworksession_impl.cpp
new file mode 100644
index 0000000..33cce69
--- /dev/null
+++ b/src/plugins/bearer/qnetworksession_impl.cpp
@@ -0,0 +1,441 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnetworksession_impl.h"
+#include "qbearerengine_impl.h"
+
+#include <QtNetwork/qnetworksession.h>
+#include <QtNetwork/private/qnetworkconfigmanager_p.h>
+
+#include <QtCore/qstringlist.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/qmutex.h>
+
+QT_BEGIN_NAMESPACE
+
+static QBearerEngineImpl *getEngineFromId(const QString &id)
+{
+    QNetworkConfigurationManagerPrivate *priv = qNetworkConfigurationManagerPrivate();
+
+    foreach (QBearerEngine *engine, priv->engines()) {
+        QBearerEngineImpl *engineImpl = qobject_cast<QBearerEngineImpl *>(engine);
+        if (engineImpl && engineImpl->hasIdentifier(id))
+            return engineImpl;
+    }
+
+    return 0;
+}
+
+class QNetworkSessionManagerPrivate : public QObject
+{
+    Q_OBJECT
+
+public:
+    QNetworkSessionManagerPrivate(QObject *parent = 0);
+    ~QNetworkSessionManagerPrivate();
+
+    void forceSessionClose(const QNetworkConfiguration &config);
+
+Q_SIGNALS:
+    void forcedSessionClose(const QNetworkConfiguration &config);
+};
+
+#include "qnetworksession_impl.moc"
+
+Q_GLOBAL_STATIC(QNetworkSessionManagerPrivate, sessionManager);
+
+QNetworkSessionManagerPrivate::QNetworkSessionManagerPrivate(QObject *parent)
+:   QObject(parent)
+{
+}
+
+QNetworkSessionManagerPrivate::~QNetworkSessionManagerPrivate()
+{
+}
+
+void QNetworkSessionManagerPrivate::forceSessionClose(const QNetworkConfiguration &config)
+{
+    emit forcedSessionClose(config);
+}
+
+void QNetworkSessionPrivateImpl::syncStateWithInterface()
+{
+    connect(sessionManager(), SIGNAL(forcedSessionClose(QNetworkConfiguration)),
+            this, SLOT(forcedSessionClose(QNetworkConfiguration)));
+
+    opened = false;
+    isOpen = false;
+    state = QNetworkSession::Invalid;
+    lastError = QNetworkSession::UnknownSessionError;
+
+    qRegisterMetaType<QBearerEngineImpl::ConnectionError>
+        ("QBearerEngineImpl::ConnectionError");
+
+    switch (publicConfig.type()) {
+    case QNetworkConfiguration::InternetAccessPoint:
+        activeConfig = publicConfig;
+        engine = getEngineFromId(activeConfig.identifier());
+        if (engine) {
+            qRegisterMetaType<QNetworkConfigurationPrivatePointer>("QNetworkConfigurationPrivatePointer");
+            connect(engine, SIGNAL(configurationChanged(QNetworkConfigurationPrivatePointer)),
+                    this, SLOT(configurationChanged(QNetworkConfigurationPrivatePointer)),
+                    Qt::QueuedConnection);
+            connect(engine, SIGNAL(connectionError(QString,QBearerEngineImpl::ConnectionError)),
+                    this, SLOT(connectionError(QString,QBearerEngineImpl::ConnectionError)),
+                    Qt::QueuedConnection);
+        }
+        break;
+    case QNetworkConfiguration::ServiceNetwork:
+        serviceConfig = publicConfig;
+        // Defer setting engine and signals until open().
+        // fall through
+    case QNetworkConfiguration::UserChoice:
+        // Defer setting serviceConfig and activeConfig until open().
+        // fall through
+    default:
+        engine = 0;
+    }
+
+    networkConfigurationsChanged();
+}
+
+void QNetworkSessionPrivateImpl::open()
+{
+    if (serviceConfig.isValid()) {
+        lastError = QNetworkSession::OperationNotSupportedError;
+        emit QNetworkSessionPrivate::error(lastError);
+    } else if (!isOpen) {
+        if ((activeConfig.state() & QNetworkConfiguration::Discovered) !=
+            QNetworkConfiguration::Discovered) {
+            lastError =QNetworkSession::InvalidConfigurationError;
+            state = QNetworkSession::Invalid;
+            emit stateChanged(state);
+            emit QNetworkSessionPrivate::error(lastError);
+            return;
+        }
+        opened = true;
+
+        if ((activeConfig.state() & QNetworkConfiguration::Active) != QNetworkConfiguration::Active &&
+            (activeConfig.state() & QNetworkConfiguration::Discovered) == QNetworkConfiguration::Discovered) {
+            state = QNetworkSession::Connecting;
+            emit stateChanged(state);
+
+            engine->connectToId(activeConfig.identifier());
+        }
+
+        isOpen = (activeConfig.state() & QNetworkConfiguration::Active) == QNetworkConfiguration::Active;
+        if (isOpen)
+            emit quitPendingWaitsForOpened();
+    }
+}
+
+void QNetworkSessionPrivateImpl::close()
+{
+    if (serviceConfig.isValid()) {
+        lastError = QNetworkSession::OperationNotSupportedError;
+        emit QNetworkSessionPrivate::error(lastError);
+    } else if (isOpen) {
+        opened = false;
+        isOpen = false;
+        emit closed();
+    }
+}
+
+void QNetworkSessionPrivateImpl::stop()
+{
+    if (serviceConfig.isValid()) {
+        lastError = QNetworkSession::OperationNotSupportedError;
+        emit QNetworkSessionPrivate::error(lastError);
+    } else {
+        if ((activeConfig.state() & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {
+            state = QNetworkSession::Closing;
+            emit stateChanged(state);
+
+            engine->disconnectFromId(activeConfig.identifier());
+
+            sessionManager()->forceSessionClose(activeConfig);
+        }
+
+        opened = false;
+        isOpen = false;
+        emit closed();
+    }
+}
+
+void QNetworkSessionPrivateImpl::migrate()
+{
+}
+
+void QNetworkSessionPrivateImpl::accept()
+{
+}
+
+void QNetworkSessionPrivateImpl::ignore()
+{
+}
+
+void QNetworkSessionPrivateImpl::reject()
+{
+}
+
+#ifndef QT_NO_NETWORKINTERFACE
+QNetworkInterface QNetworkSessionPrivateImpl::currentInterface() const
+{
+    if (!publicConfig.isValid() || !engine || state != QNetworkSession::Connected)
+        return QNetworkInterface();
+
+    QString interface = engine->getInterfaceFromId(activeConfig.identifier());
+
+    if (interface.isEmpty())
+        return QNetworkInterface();
+    return QNetworkInterface::interfaceFromName(interface);
+}
+#endif
+
+QVariant QNetworkSessionPrivateImpl::sessionProperty(const QString &key) const
+{
+    if (key == QLatin1String("AutoCloseSessionTimeout")) {
+        if (engine && engine->requiresPolling() &&
+            !(engine->capabilities() & QNetworkConfigurationManager::CanStartAndStopInterfaces)) {
+            if (sessionTimeout >= 0)
+                return sessionTimeout * 10000;
+            else
+                return -1;
+        }
+    }
+
+    return QVariant();
+}
+
+void QNetworkSessionPrivateImpl::setSessionProperty(const QString &key, const QVariant &value)
+{
+    if (key == QLatin1String("AutoCloseSessionTimeout")) {
+        if (engine && engine->requiresPolling() &&
+            !(engine->capabilities() & QNetworkConfigurationManager::CanStartAndStopInterfaces)) {
+            int timeout = value.toInt();
+            if (timeout >= 0) {
+                connect(engine, SIGNAL(updateCompleted()),
+                        this, SLOT(decrementTimeout()), Qt::UniqueConnection);
+                sessionTimeout = timeout / 10000;   // convert to poll intervals
+            } else {
+                disconnect(engine, SIGNAL(updateCompleted()), this, SLOT(decrementTimeout()));
+                sessionTimeout = -1;
+            }
+        }
+    }
+}
+
+QString QNetworkSessionPrivateImpl::errorString() const
+{
+    switch (lastError) {
+    case QNetworkSession::UnknownSessionError:
+        return tr("Unknown session error.");
+    case QNetworkSession::SessionAbortedError:
+        return tr("The session was aborted by the user or system.");
+    case QNetworkSession::OperationNotSupportedError:
+        return tr("The requested operation is not supported by the system.");
+    case QNetworkSession::InvalidConfigurationError:
+        return tr("The specified configuration cannot be used.");
+    case QNetworkSession::RoamingError:
+        return tr("Roaming was aborted or is not possible.");
+
+    }
+
+    return QString();
+}
+
+QNetworkSession::SessionError QNetworkSessionPrivateImpl::error() const
+{
+    return lastError;
+}
+
+quint64 QNetworkSessionPrivateImpl::bytesWritten() const
+{
+    if (engine && state == QNetworkSession::Connected)
+        return engine->bytesWritten(activeConfig.identifier());
+    else
+        return Q_UINT64_C(0);
+}
+
+quint64 QNetworkSessionPrivateImpl::bytesReceived() const
+{
+    if (engine && state == QNetworkSession::Connected)
+        return engine->bytesReceived(activeConfig.identifier());
+    else
+        return Q_UINT64_C(0);
+}
+
+quint64 QNetworkSessionPrivateImpl::activeTime() const
+{
+    if (state == QNetworkSession::Connected && startTime != Q_UINT64_C(0))
+        return QDateTime::currentDateTime().toTime_t() - startTime;
+    else
+        return Q_UINT64_C(0);
+}
+
+void QNetworkSessionPrivateImpl::updateStateFromServiceNetwork()
+{
+    QNetworkSession::State oldState = state;
+
+    foreach (const QNetworkConfiguration &config, serviceConfig.children()) {
+        if ((config.state() & QNetworkConfiguration::Active) != QNetworkConfiguration::Active)
+            continue;
+
+        if (activeConfig != config) {
+            if (engine) {
+                disconnect(engine,
+                           SIGNAL(connectionError(QString,QBearerEngineImpl::ConnectionError)),
+                           this,
+                           SLOT(connectionError(QString,QBearerEngineImpl::ConnectionError)));
+            }
+
+            activeConfig = config;
+            engine = getEngineFromId(activeConfig.identifier());
+            if (engine) {
+                connect(engine,
+                        SIGNAL(connectionError(QString,QBearerEngineImpl::ConnectionError)),
+                        this, SLOT(connectionError(QString,QBearerEngineImpl::ConnectionError)),
+                        Qt::QueuedConnection);
+            }
+            emit newConfigurationActivated();
+        }
+
+        state = QNetworkSession::Connected;
+        if (state != oldState)
+            emit stateChanged(state);
+
+        return;
+    }
+
+    if (serviceConfig.children().isEmpty())
+        state = QNetworkSession::NotAvailable;
+    else
+        state = QNetworkSession::Disconnected;
+
+    if (state != oldState)
+        emit stateChanged(state);
+}
+
+void QNetworkSessionPrivateImpl::updateStateFromActiveConfig()
+{
+    if (!engine)
+        return;
+
+    QNetworkSession::State oldState = state;
+
+    state = engine->sessionStateForId(activeConfig.identifier());
+
+    bool oldActive = isOpen;
+    isOpen = (state == QNetworkSession::Connected) ? opened : false;
+
+    if (!oldActive && isOpen)
+        emit quitPendingWaitsForOpened();
+    if (oldActive && !isOpen)
+        emit closed();
+
+    if (oldState != state)
+        emit stateChanged(state);
+}
+
+void QNetworkSessionPrivateImpl::networkConfigurationsChanged()
+{
+    if (serviceConfig.isValid())
+        updateStateFromServiceNetwork();
+    else
+        updateStateFromActiveConfig();
+
+    startTime = engine->startTime(activeConfig.identifier());
+}
+
+void QNetworkSessionPrivateImpl::configurationChanged(QNetworkConfigurationPrivatePointer config)
+{
+    if (serviceConfig.isValid() &&
+        (config->id == serviceConfig.identifier() || config->id == activeConfig.identifier())) {
+        updateStateFromServiceNetwork();
+    } else if (config->id == activeConfig.identifier()) {
+        updateStateFromActiveConfig();
+    }
+}
+
+void QNetworkSessionPrivateImpl::forcedSessionClose(const QNetworkConfiguration &config)
+{
+    if (activeConfig == config) {
+        opened = false;
+        isOpen = false;
+
+        emit closed();
+
+        lastError = QNetworkSession::SessionAbortedError;
+        emit QNetworkSessionPrivate::error(lastError);
+    }
+}
+
+void QNetworkSessionPrivateImpl::connectionError(const QString &id,
+                                                 QBearerEngineImpl::ConnectionError error)
+{
+    if (activeConfig.identifier() == id) {
+        networkConfigurationsChanged();
+        switch (error) {
+        case QBearerEngineImpl::OperationNotSupported:
+            lastError = QNetworkSession::OperationNotSupportedError;
+            opened = false;
+            break;
+        case QBearerEngineImpl::InterfaceLookupError:
+        case QBearerEngineImpl::ConnectError:
+        case QBearerEngineImpl::DisconnectionError:
+        default:
+            lastError = QNetworkSession::UnknownSessionError;
+        }
+
+        emit QNetworkSessionPrivate::error(lastError);
+    }
+}
+
+void QNetworkSessionPrivateImpl::decrementTimeout()
+{
+    if (--sessionTimeout <= 0) {
+        disconnect(engine, SIGNAL(updateCompleted()), this, SLOT(decrementTimeout()));
+        sessionTimeout = -1;
+        close();
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/qnetworksession_impl.h b/src/plugins/bearer/qnetworksession_impl.h
new file mode 100644
index 0000000..3becbf0
--- /dev/null
+++ b/src/plugins/bearer/qnetworksession_impl.h
@@ -0,0 +1,133 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNETWORKSESSION_IMPL_H
+#define QNETWORKSESSION_IMPL_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include "qbearerengine_impl.h"
+
+#include <QtNetwork/private/qnetworkconfigmanager_p.h>
+#include <QtNetwork/private/qnetworksession_p.h>
+
+#include <QtCore/qdatetime.h>
+
+QT_BEGIN_NAMESPACE
+
+class QBearerEngineImpl;
+
+class QNetworkSessionPrivateImpl : public QNetworkSessionPrivate
+{
+    Q_OBJECT
+public:
+    QNetworkSessionPrivateImpl()
+    :   startTime(0), sessionTimeout(-1)
+    {
+    }
+
+    ~QNetworkSessionPrivateImpl()
+    {
+    }
+
+    //called by QNetworkSession constructor and ensures
+    //that the state is immediately updated (w/o actually opening
+    //a session). Also this function should take care of 
+    //notification hooks to discover future state changes.
+    void syncStateWithInterface();
+
+#ifndef QT_NO_NETWORKINTERFACE
+    QNetworkInterface currentInterface() const;
+#endif
+    QVariant sessionProperty(const QString& key) const;
+    void setSessionProperty(const QString& key, const QVariant& value);
+
+    void open();
+    void close();
+    void stop();
+    void migrate();
+    void accept();
+    void ignore();
+    void reject();
+
+    QString errorString() const; //must return translated string
+    QNetworkSession::SessionError error() const;
+
+    quint64 bytesWritten() const;
+    quint64 bytesReceived() const;
+    quint64 activeTime() const;
+
+private:
+    void updateStateFromServiceNetwork();
+    void updateStateFromActiveConfig();
+
+private Q_SLOTS:
+    void networkConfigurationsChanged();
+    void configurationChanged(QNetworkConfigurationPrivatePointer config);
+    void forcedSessionClose(const QNetworkConfiguration &config);
+    void connectionError(const QString &id, QBearerEngineImpl::ConnectionError error);
+    void decrementTimeout();
+
+private:
+    bool opened;
+
+    QBearerEngineImpl *engine;
+
+    QNetworkSession::SessionError lastError;
+
+    quint64 startTime;
+
+    int sessionTimeout;
+};
+
+QT_END_NAMESPACE
+
+#endif //QNETWORKSESSION_IMPL_H
+
diff --git a/src/plugins/bearer/symbian/main.cpp b/src/plugins/bearer/symbian/main.cpp
new file mode 100644
index 0000000..0321451
--- /dev/null
+++ b/src/plugins/bearer/symbian/main.cpp
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "symbianengine.h"
+
+#include <QtNetwork/private/qbearerplugin_p.h>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+class QSymbianEnginePlugin : public QBearerEnginePlugin
+{
+public:
+    QSymbianEnginePlugin();
+    ~QSymbianEnginePlugin();
+
+    QStringList keys() const;
+    QBearerEngine *create(const QString &key) const;
+};
+
+QSymbianEnginePlugin::QSymbianEnginePlugin()
+{
+}
+
+QSymbianEnginePlugin::~QSymbianEnginePlugin()
+{
+}
+
+QStringList QSymbianEnginePlugin::keys() const
+{
+    return QStringList() << QLatin1String("symbian");
+}
+
+QBearerEngine *QSymbianEnginePlugin::create(const QString &key) const
+{
+    if (key == QLatin1String("symbian"))
+        return new SymbianEngine;
+    else
+        return 0;
+}
+
+Q_EXPORT_STATIC_PLUGIN(QSymbianEnginePlugin)
+Q_EXPORT_PLUGIN2(qsymbianbearer, QSymbianEnginePlugin)
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/symbian/qnetworksession_impl.cpp b/src/plugins/bearer/symbian/qnetworksession_impl.cpp
new file mode 100644
index 0000000..512ea51
--- /dev/null
+++ b/src/plugins/bearer/symbian/qnetworksession_impl.cpp
@@ -0,0 +1,1315 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qnetworksession_impl.h"
+#include "symbianengine.h"
+
+#include <es_enum.h>
+#include <es_sock.h>
+#include <in_sock.h>
+#include <stdapis/sys/socket.h>
+#include <stdapis/net/if.h>
+
+QT_BEGIN_NAMESPACE
+
+QNetworkSessionPrivateImpl::QNetworkSessionPrivateImpl(SymbianEngine *engine)
+    : CActive(CActive::EPriorityStandard), engine(engine), ipConnectionNotifier(0),
+      iError(QNetworkSession::UnknownSessionError),
+      iALREnabled(0)
+{
+    CActiveScheduler::Add(this);
+    
+    // Try to load "Open C" dll dynamically and
+    // try to attach to setdefaultif function dynamically.
+    if (iOpenCLibrary.Load(_L("libc")) == KErrNone) {
+        iDynamicSetdefaultif = (TOpenCSetdefaultifFunction)iOpenCLibrary.Lookup(564);
+    }
+
+    TRAP_IGNORE(iConnectionMonitor.ConnectL());
+}
+
+QNetworkSessionPrivateImpl::~QNetworkSessionPrivateImpl()
+{
+    isOpen = false;
+
+    // Cancel Connection Progress Notifications first.
+    // Note: ConnectionNotifier must be destroyed before Canceling RConnection::Start()
+    //       => deleting ipConnectionNotifier results RConnection::CancelProgressNotification()
+    delete ipConnectionNotifier;
+    ipConnectionNotifier = NULL;
+
+    // Cancel possible RConnection::Start()
+    Cancel();
+    
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    if (iMobility) {
+        delete iMobility;
+        iMobility = NULL;
+    }
+#endif
+
+    iConnection.Close();
+    iSocketServ.Close();
+    if (iDynamicSetdefaultif) {
+        iDynamicSetdefaultif(0);
+    }
+
+    iConnectionMonitor.CancelNotifications();
+    iConnectionMonitor.Close();
+
+    iOpenCLibrary.Close();
+}
+
+void QNetworkSessionPrivateImpl::syncStateWithInterface()
+{
+    if (!publicConfig.isValid())
+        return;
+
+    // Start monitoring changes in IAP states
+    TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));
+
+    // Check open connections to see if there is already
+    // an open connection to selected IAP or SNAP
+    TUint count;
+    TRequestStatus status;
+    iConnectionMonitor.GetConnectionCount(count, status);
+    User::WaitForRequest(status);
+    if (status.Int() != KErrNone) {
+        return;
+    }
+
+    TUint numSubConnections;
+    TUint connectionId;
+    for (TUint i = 1; i <= count; i++) {
+        TInt ret = iConnectionMonitor.GetConnectionInfo(i, connectionId, numSubConnections);
+        if (ret == KErrNone) {
+            TUint apId;
+            iConnectionMonitor.GetUintAttribute(connectionId, 0, KIAPId, apId, status);
+            User::WaitForRequest(status);
+            if (status.Int() == KErrNone) {
+                TInt connectionStatus;
+                iConnectionMonitor.GetIntAttribute(connectionId, 0, KConnectionStatus, connectionStatus, status);
+                User::WaitForRequest(status);
+                if (connectionStatus == KLinkLayerOpen) {
+                    if (state != QNetworkSession::Closing) {
+                        if (newState(QNetworkSession::Connected, apId)) {
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (state != QNetworkSession::Connected) {
+        // There were no open connections to used IAP or SNAP
+        if (iError == QNetworkSession::InvalidConfigurationError) {
+            newState(QNetworkSession::Invalid);
+        } else if ((publicConfig.state() & QNetworkConfiguration::Discovered) ==
+                   QNetworkConfiguration::Discovered) {
+            newState(QNetworkSession::Disconnected);
+        } else {
+            newState(QNetworkSession::NotAvailable);
+        }
+    }
+}
+
+#ifndef QT_NO_NETWORKINTERFACE
+QNetworkInterface QNetworkSessionPrivateImpl::interface(TUint iapId) const
+{
+    QString interfaceName;
+
+    TSoInetInterfaceInfo ifinfo;
+    TPckg<TSoInetInterfaceInfo> ifinfopkg(ifinfo);
+    TSoInetIfQuery ifquery;
+    TPckg<TSoInetIfQuery> ifquerypkg(ifquery);
+ 
+    // Open dummy socket for interface queries
+    RSocket socket;
+    TInt retVal = socket.Open(iSocketServ, _L("udp"));
+    if (retVal != KErrNone) {
+        return QNetworkInterface();
+    }
+ 
+    // Start enumerating interfaces
+    socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl);
+    while(socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, ifinfopkg) == KErrNone) {
+        ifquery.iName = ifinfo.iName;
+        TInt err = socket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, ifquerypkg);
+        if(err == KErrNone && ifquery.iZone[1] == iapId) { // IAP ID is index 1 of iZone
+            if(ifinfo.iAddress.Address() > 0) {
+                interfaceName = QString::fromUtf16(ifinfo.iName.Ptr(),ifinfo.iName.Length());
+                break;
+            }
+        }
+    }
+ 
+    socket.Close();
+ 
+    if (interfaceName.isEmpty()) {
+        return QNetworkInterface();
+    }
+ 
+    return QNetworkInterface::interfaceFromName(interfaceName);
+}
+#endif
+
+#ifndef QT_NO_NETWORKINTERFACE
+QNetworkInterface QNetworkSessionPrivateImpl::currentInterface() const
+{
+    if (!publicConfig.isValid() || state != QNetworkSession::Connected) {
+        return QNetworkInterface();
+    }
+    
+    return activeInterface;
+}
+#endif
+
+QVariant QNetworkSessionPrivateImpl::sessionProperty(const QString& /*key*/) const
+{
+    return QVariant();
+}
+
+void QNetworkSessionPrivateImpl::setSessionProperty(const QString& /*key*/, const QVariant& /*value*/)
+{
+}
+
+QString QNetworkSessionPrivateImpl::errorString() const
+{
+    switch (iError) {
+    case QNetworkSession::UnknownSessionError:
+        return tr("Unknown session error.");
+    case QNetworkSession::SessionAbortedError:
+        return tr("The session was aborted by the user or system.");
+    case QNetworkSession::OperationNotSupportedError:
+        return tr("The requested operation is not supported by the system.");
+    case QNetworkSession::InvalidConfigurationError:
+        return tr("The specified configuration cannot be used.");
+    case QNetworkSession::RoamingError:
+        return tr("Roaming was aborted or is not possible.");
+    }
+ 
+    return QString();
+}
+
+QNetworkSession::SessionError QNetworkSessionPrivateImpl::error() const
+{
+    return iError;
+}
+
+void QNetworkSessionPrivateImpl::open()
+{
+    if (isOpen || (state == QNetworkSession::Connecting)) {
+        return;
+    }
+
+    // Cancel notifications from RConnectionMonitor
+    // => RConnection::ProgressNotification will be used for IAP/SNAP monitoring
+    iConnectionMonitor.CancelNotifications();
+
+    // Configuration may have been invalidated after session creation by platform
+    // (e.g. configuration has been deleted).
+    if (!publicConfig.isValid()) {
+        newState(QNetworkSession::Invalid);
+        iError = QNetworkSession::InvalidConfigurationError;
+        emit QNetworkSessionPrivate::error(iError);
+        syncStateWithInterface();
+        return;
+    }
+    // If opening a (un)defined configuration, session emits error and enters
+    // NotAvailable -state.
+    if (publicConfig.state() == QNetworkConfiguration::Undefined ||
+        publicConfig.state() == QNetworkConfiguration::Defined) {
+        newState(QNetworkSession::NotAvailable);
+        iError = QNetworkSession::InvalidConfigurationError;
+        emit QNetworkSessionPrivate::error(iError);
+        return;
+    }
+    
+    TInt error = iSocketServ.Connect();
+    if (error != KErrNone) {
+        // Could not open RSocketServ
+        newState(QNetworkSession::Invalid);
+        iError = QNetworkSession::UnknownSessionError;
+        emit QNetworkSessionPrivate::error(iError);
+        syncStateWithInterface();    
+        return;
+    }
+    
+    error = iConnection.Open(iSocketServ);
+    if (error != KErrNone) {
+        // Could not open RConnection
+        iSocketServ.Close();
+        newState(QNetworkSession::Invalid);
+        iError = QNetworkSession::UnknownSessionError;
+        emit QNetworkSessionPrivate::error(iError);
+        syncStateWithInterface();    
+        return;
+    }
+    
+    // Use RConnection::ProgressNotification for IAP/SNAP monitoring
+    // (<=> ConnectionProgressNotifier uses RConnection::ProgressNotification)
+    if (!ipConnectionNotifier) {
+        ipConnectionNotifier = new ConnectionProgressNotifier(*this,iConnection);
+    }
+    if (ipConnectionNotifier) {
+        ipConnectionNotifier->StartNotifications();
+    }
+    
+    if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+        // Search through existing connections.
+        // If there is already connection which matches to given IAP
+        // try to attach to existing connection.
+        TBool connected(EFalse);
+        TConnectionInfoBuf connInfo;
+        TUint count;
+        if (iConnection.EnumerateConnections(count) == KErrNone) {
+            for (TUint i=1; i<=count; i++) {
+                // Note: GetConnectionInfo expects 1-based index.
+                if (iConnection.GetConnectionInfo(i, connInfo) == KErrNone) {
+                    SymbianNetworkConfigurationPrivate *symbianConfig =
+                        toSymbianConfig(privateConfiguration(publicConfig));
+
+                    QMutexLocker configLocker(&symbianConfig->mutex);
+
+                    if (connInfo().iIapId == symbianConfig->numericId) {
+                        if (iConnection.Attach(connInfo, RConnection::EAttachTypeNormal) == KErrNone) {
+                            activeConfig = publicConfig;
+#ifndef QT_NO_NETWORKINTERFACE
+                            activeInterface = interface(symbianConfig->numericId);
+#endif
+                            connected = ETrue;
+                            startTime = QDateTime::currentDateTime();
+                            if (iDynamicSetdefaultif) {
+                                // Use name of the IAP to set default IAP
+                                QByteArray nameAsByteArray = publicConfig.name().toUtf8();
+                                ifreq ifr;
+                                strcpy(ifr.ifr_name, nameAsByteArray.constData());
+
+                                error = iDynamicSetdefaultif(&ifr);
+                            }
+                            isOpen = true;
+                            // Make sure that state will be Connected
+                            newState(QNetworkSession::Connected);
+                            emit quitPendingWaitsForOpened();
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!connected) {
+            TCommDbConnPref pref;
+            pref.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);
+            SymbianNetworkConfigurationPrivate *symbianConfig =
+                toSymbianConfig(privateConfiguration(publicConfig));
+
+            symbianConfig->mutex.lock();
+            pref.SetIapId(symbianConfig->numericId);
+            symbianConfig->mutex.unlock();
+            iConnection.Start(pref, iStatus);
+            if (!IsActive()) {
+                SetActive();
+            }
+            newState(QNetworkSession::Connecting);
+        }
+    } else if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+        SymbianNetworkConfigurationPrivate *symbianConfig =
+            toSymbianConfig(privateConfiguration(publicConfig));
+
+        symbianConfig->mutex.lock();
+        TConnSnapPref snapPref(symbianConfig->numericId);
+        symbianConfig->mutex.unlock();
+        iConnection.Start(snapPref, iStatus);
+        if (!IsActive()) {
+            SetActive();
+        }
+        newState(QNetworkSession::Connecting);
+    } else if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+        iKnownConfigsBeforeConnectionStart = engine->accessPointConfigurationIdentifiers();
+        iConnection.Start(iStatus);
+        if (!IsActive()) {
+            SetActive();
+        }
+        newState(QNetworkSession::Connecting);
+    }
+ 
+    if (error != KErrNone) {
+        isOpen = false;
+        iError = QNetworkSession::UnknownSessionError;
+        emit QNetworkSessionPrivate::error(iError);
+        if (ipConnectionNotifier) {
+            ipConnectionNotifier->StopNotifications();
+        }
+        syncStateWithInterface();    
+    }
+}
+
+TUint QNetworkSessionPrivateImpl::iapClientCount(TUint aIAPId) const
+{
+    TRequestStatus status;
+    TUint connectionCount;
+    iConnectionMonitor.GetConnectionCount(connectionCount, status);
+    User::WaitForRequest(status);
+    if (status.Int() == KErrNone) {
+        for (TUint i = 1; i <= connectionCount; i++) {
+            TUint connectionId;
+            TUint subConnectionCount;
+            iConnectionMonitor.GetConnectionInfo(i, connectionId, subConnectionCount);
+            TUint apId;
+            iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
+            User::WaitForRequest(status);
+            if (apId == aIAPId) {
+                TConnMonClientEnumBuf buf;
+                iConnectionMonitor.GetPckgAttribute(connectionId, 0, KClientInfo, buf, status);
+                User::WaitForRequest(status);
+                if (status.Int() == KErrNone) {
+                    return buf().iCount;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+void QNetworkSessionPrivateImpl::close(bool allowSignals)
+{
+    if (!isOpen) {
+        return;
+    }
+
+    SymbianNetworkConfigurationPrivate *symbianConfig =
+        toSymbianConfig(privateConfiguration(activeConfig));
+
+    symbianConfig->mutex.lock();
+    TUint activeIap = symbianConfig->numericId;
+    symbianConfig->mutex.unlock();
+
+    isOpen = false;
+    activeConfig = QNetworkConfiguration();
+    serviceConfig = QNetworkConfiguration();
+    
+    Cancel();
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    if (iMobility) {
+        delete iMobility;
+        iMobility = NULL;
+    }
+#endif
+
+    if (ipConnectionNotifier) {
+        ipConnectionNotifier->StopNotifications();
+    }
+    
+    iConnection.Close();
+    iSocketServ.Close();
+    if (iDynamicSetdefaultif) {
+        iDynamicSetdefaultif(0);
+    }
+
+#ifdef Q_CC_NOKIAX86
+    if ((allowSignals && iapClientCount(activeIap) <= 0) ||
+#else
+    if ((allowSignals && iapClientCount(activeIap) <= 1) ||
+#endif
+        (publicConfig.type() == QNetworkConfiguration::UserChoice)) {
+        newState(QNetworkSession::Closing);
+    }
+    
+    syncStateWithInterface();
+    if (allowSignals) {
+        if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+            newState(QNetworkSession::Disconnected);
+        }
+        emit closed();
+    }
+}
+
+void QNetworkSessionPrivateImpl::stop()
+{
+    if (!isOpen &&
+        publicConfig.isValid() &&
+        publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+        // If the publicConfig is type of IAP, enumerate through connections at
+        // connection monitor. If publicConfig is active in that list, stop it.
+        // Otherwise there is nothing to stop. Note: because this QNetworkSession is not open,
+        // activeConfig is not usable.
+        TUint count;
+        TRequestStatus status;
+        iConnectionMonitor.GetConnectionCount(count, status);
+        User::WaitForRequest(status);
+        if (status.Int() != KErrNone) {
+            return;
+        }
+        TUint numSubConnections; // Not used but needed by GetConnectionInfo i/f
+        TUint connectionId;
+        for (TInt i = 1; i <= count; ++i) {
+            // Get (connection monitor's assigned) connection ID
+            TInt ret = iConnectionMonitor.GetConnectionInfo(i, connectionId, numSubConnections);            
+            if (ret == KErrNone) {
+                SymbianNetworkConfigurationPrivate *symbianConfig =
+                    toSymbianConfig(privateConfiguration(publicConfig));
+
+                QMutexLocker configLocker(&symbianConfig->mutex);
+
+                // See if connection Id matches with our Id. If so, stop() it.
+                if (symbianConfig->connectionId == connectionId) {
+                    ret = iConnectionMonitor.SetBoolAttribute(connectionId,
+                                                              0, // subConnectionId don't care
+                                                              KConnectionStop,
+                                                              ETrue);
+                }
+            }
+        }
+    } else if (isOpen) {
+        // Since we are open, use RConnection to stop the interface
+        isOpen = false;
+        newState(QNetworkSession::Closing);
+        iConnection.Stop(RConnection::EStopAuthoritative);
+        isOpen = true;
+        close(false);
+        emit closed();
+    }
+}
+
+void QNetworkSessionPrivateImpl::migrate()
+{
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    iMobility->MigrateToPreferredCarrier();
+#endif
+}
+
+void QNetworkSessionPrivateImpl::ignore()
+{
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    iMobility->IgnorePreferredCarrier();
+    if (!iALRUpgradingConnection) {
+        newState(QNetworkSession::Disconnected);
+    } else {
+        newState(QNetworkSession::Connected,iOldRoamingIap);
+    }
+#endif
+}
+
+void QNetworkSessionPrivateImpl::accept()
+{
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    iMobility->NewCarrierAccepted();
+    if (iDynamicSetdefaultif) {
+        // Use name of the IAP to set default IAP
+        QByteArray nameAsByteArray = activeConfig.name().toUtf8();
+        ifreq ifr;
+        strcpy(ifr.ifr_name, nameAsByteArray.constData());
+
+        iDynamicSetdefaultif(&ifr);
+    }
+    newState(QNetworkSession::Connected, iNewRoamingIap);
+#endif
+}
+
+void QNetworkSessionPrivateImpl::reject()
+{
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    iMobility->NewCarrierRejected();
+    if (!iALRUpgradingConnection) {
+        newState(QNetworkSession::Disconnected);
+    } else {
+        newState(QNetworkSession::Connected, iOldRoamingIap);
+    }
+#endif
+}
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+void QNetworkSessionPrivateImpl::PreferredCarrierAvailable(TAccessPointInfo aOldAPInfo,
+                                                       TAccessPointInfo aNewAPInfo,
+                                                       TBool aIsUpgrade,
+                                                       TBool aIsSeamless)
+{
+    iOldRoamingIap = aOldAPInfo.AccessPoint();
+    iNewRoamingIap = aNewAPInfo.AccessPoint();
+    newState(QNetworkSession::Roaming);
+    if (iALREnabled > 0) {
+        iALRUpgradingConnection = aIsUpgrade;
+        QList<QNetworkConfiguration> configs = publicConfig.children();
+        for (int i=0; i < configs.count(); i++) {
+            SymbianNetworkConfigurationPrivate *symbianConfig =
+                toSymbianConfig(privateConfiguration(configs[i]));
+
+            QMutexLocker configLocker(&symbianConfig->mutex);
+
+            if (symbianConfig->numericId == aNewAPInfo.AccessPoint()) {
+                configLocker.unlock();
+                emit preferredConfigurationChanged(configs[i], aIsSeamless);
+            }
+        }
+    } else {
+        migrate();
+    }
+}
+
+void QNetworkSessionPrivateImpl::NewCarrierActive(TAccessPointInfo /*aNewAPInfo*/, TBool /*aIsSeamless*/)
+{
+    if (iALREnabled > 0) {
+        emit newConfigurationActivated();
+    } else {
+        accept();
+    }
+}
+
+void QNetworkSessionPrivateImpl::Error(TInt /*aError*/)
+{
+    if (isOpen) {
+        isOpen = false;
+        activeConfig = QNetworkConfiguration();
+        serviceConfig = QNetworkConfiguration();
+        iError = QNetworkSession::RoamingError;
+        emit QNetworkSessionPrivate::error(iError);
+        Cancel();
+        if (ipConnectionNotifier) {
+            ipConnectionNotifier->StopNotifications();
+        }
+        syncStateWithInterface();
+        // In some cases IAP is still in Connected state when
+        // syncStateWithInterface(); is called
+        // => Following call makes sure that Session state
+        //    changes immediately to Disconnected.
+        newState(QNetworkSession::Disconnected);
+        emit closed();
+    }
+}
+#endif
+
+void QNetworkSessionPrivateImpl::setALREnabled(bool enabled)
+{
+    if (enabled) {
+        iALREnabled++;
+    } else {
+        iALREnabled--;
+    }
+}
+
+QNetworkConfiguration QNetworkSessionPrivateImpl::bestConfigFromSNAP(const QNetworkConfiguration& snapConfig) const
+{
+    QNetworkConfiguration config;
+    QList<QNetworkConfiguration> subConfigurations = snapConfig.children();
+    for (int i = 0; i < subConfigurations.count(); i++ ) {
+        if (subConfigurations[i].state() == QNetworkConfiguration::Active) {
+            config = subConfigurations[i];
+            break;
+        } else if (!config.isValid() && subConfigurations[i].state() == QNetworkConfiguration::Discovered) {
+            config = subConfigurations[i];
+        }
+    }
+    if (!config.isValid() && subConfigurations.count() > 0) {
+        config = subConfigurations[0];
+    }
+    return config;
+}
+
+quint64 QNetworkSessionPrivateImpl::bytesWritten() const
+{
+    return transferredData(KUplinkData);
+}
+
+quint64 QNetworkSessionPrivateImpl::bytesReceived() const
+{
+    return transferredData(KDownlinkData);
+}
+
+quint64 QNetworkSessionPrivateImpl::transferredData(TUint dataType) const
+{
+    if (!publicConfig.isValid()) {
+        return 0;
+    }
+    
+    QNetworkConfiguration config;
+    if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+        if (serviceConfig.isValid()) {
+            config = serviceConfig;
+        } else {
+            if (activeConfig.isValid()) {
+                config = activeConfig;
+            }
+        }
+    } else {
+        config = publicConfig;
+    }
+
+    if (!config.isValid()) {
+        return 0;
+    }
+    
+    TUint count;
+    TRequestStatus status;
+    iConnectionMonitor.GetConnectionCount(count, status);
+    User::WaitForRequest(status);
+    if (status.Int() != KErrNone) {
+        return 0;
+    }
+    
+    TUint transferredData = 0;
+    TUint numSubConnections;
+    TUint connectionId;
+    bool configFound;
+    for (TUint i = 1; i <= count; i++) {
+        TInt ret = iConnectionMonitor.GetConnectionInfo(i, connectionId, numSubConnections);
+        if (ret == KErrNone) {
+            TUint apId;
+            iConnectionMonitor.GetUintAttribute(connectionId, 0, KIAPId, apId, status);
+            User::WaitForRequest(status);
+            if (status.Int() == KErrNone) {
+                configFound = false;
+                if (config.type() == QNetworkConfiguration::ServiceNetwork) {
+                    QList<QNetworkConfiguration> configs = config.children();
+                    for (int i=0; i < configs.count(); i++) {
+                        SymbianNetworkConfigurationPrivate *symbianConfig =
+                            toSymbianConfig(privateConfiguration(configs[i]));
+
+                        QMutexLocker configLocker(&symbianConfig->mutex);
+
+                        if (symbianConfig->numericId == apId) {
+                            configFound = true;
+                            break;
+                        }
+                    }
+                } else {
+                    SymbianNetworkConfigurationPrivate *symbianConfig =
+                        toSymbianConfig(privateConfiguration(config));
+
+                    symbianConfig->mutex.lock();
+                    if (symbianConfig->numericId == apId)
+                        configFound = true;
+                    symbianConfig->mutex.unlock();
+                }
+                if (configFound) {
+                    TUint tData;
+                    iConnectionMonitor.GetUintAttribute(connectionId, 0, dataType, tData, status );
+                    User::WaitForRequest(status);
+                    if (status.Int() == KErrNone) {
+                    transferredData += tData;
+                    }
+                }
+            }
+        }
+    }
+    
+    return transferredData;
+}
+
+quint64 QNetworkSessionPrivateImpl::activeTime() const
+{
+    if (!isOpen || startTime.isNull()) {
+        return 0;
+    }
+    return startTime.secsTo(QDateTime::currentDateTime());
+}
+
+QNetworkConfiguration QNetworkSessionPrivateImpl::activeConfiguration(TUint32 iapId) const
+{
+    if (iapId == 0) {
+        _LIT(KSetting, "IAP\\Id");
+        iConnection.GetIntSetting(KSetting, iapId);
+    }
+ 
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+        // Try to search IAP from the used SNAP using IAP Id
+        QList<QNetworkConfiguration> children = publicConfig.children();
+        for (int i=0; i < children.count(); i++) {
+            SymbianNetworkConfigurationPrivate *childConfig =
+                toSymbianConfig(privateConfiguration(children[i]));
+
+            QMutexLocker childLocker(&childConfig->mutex);
+            if (childConfig->numericId == iapId)
+                return children[i];
+        }
+
+        // Given IAP Id was not found from the used SNAP
+        // => Try to search matching IAP using mappingName
+        //    mappingName contains:
+        //      1. "Access point name" for "Packet data" Bearer
+        //      2. "WLAN network name" (= SSID) for "Wireless LAN" Bearer
+        //      3. "Dial-up number" for "Data call Bearer" or "High Speed (GSM)" Bearer
+        //    <=> Note: It's possible that in this case reported IAP is
+        //              clone of the one of the IAPs of the used SNAP
+        //              => If mappingName matches, clone has been found
+        QNetworkConfiguration pt = QNetworkConfigurationManager()
+                                    .configurationFromIdentifier(QString::number(qHash(iapId)));
+
+        SymbianNetworkConfigurationPrivate *symbianConfig =
+            toSymbianConfig(privateConfiguration(pt));
+        if (symbianConfig) {
+            QMutexLocker configLocker(&symbianConfig->mutex);
+
+            for (int i=0; i < children.count(); i++) {
+                SymbianNetworkConfigurationPrivate *childConfig =
+                    toSymbianConfig(privateConfiguration(children[i]));
+
+                QMutexLocker childLocker(&childConfig->mutex);
+
+                if (childConfig->mappingName == symbianConfig->mappingName) {
+                    return children[i];
+                }
+            }
+        } else {
+            // Given IAP Id was not found from known IAPs array
+            return QNetworkConfiguration();
+        }
+
+        // Matching IAP was not found from used SNAP
+        // => IAP from another SNAP is returned
+        //    (Note: Returned IAP matches to given IAP Id)
+        return pt;
+    }
+#endif
+    
+    if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+        if (engine) {
+            QNetworkConfiguration pt = QNetworkConfigurationManager().configurationFromIdentifier(QString::number(qHash(iapId)));
+            // Try to found User Selected IAP from known IAPs (accessPointConfigurations)
+            if (pt.isValid()) {
+                return pt;
+            } else {
+                // Check if new (WLAN) IAP was created in IAP/SNAP dialog
+                // 1. Sync internal configurations array to commsdb first
+                engine->updateConfigurations();
+                // 2. Check if new configuration was created during connection creation
+                QStringList knownConfigs = engine->accessPointConfigurationIdentifiers();
+                if (knownConfigs.count() > iKnownConfigsBeforeConnectionStart.count()) {
+                    // Configuration count increased => new configuration was created
+                    // => Search new, created configuration
+                    QString newIapId;
+                    for (int i=0; i < iKnownConfigsBeforeConnectionStart.count(); i++) {
+                        if (knownConfigs[i] != iKnownConfigsBeforeConnectionStart[i]) {
+                            newIapId = knownConfigs[i];
+                            break;
+                        }
+                    }
+                    if (newIapId.isEmpty()) {
+                        newIapId = knownConfigs[knownConfigs.count()-1];
+                    }
+                    pt = QNetworkConfigurationManager().configurationFromIdentifier(newIapId);
+                    if (pt.isValid())
+                        return pt;
+                }
+            }
+        }
+        return QNetworkConfiguration();
+    }
+
+    return publicConfig;
+}
+
+void QNetworkSessionPrivateImpl::RunL()
+{
+    TInt statusCode = iStatus.Int();
+
+    switch (statusCode) {
+        case KErrNone: // Connection created successfully
+            {
+            TInt error = KErrNone;
+            QNetworkConfiguration newActiveConfig = activeConfiguration();
+            if (!newActiveConfig.isValid()) {
+                error = KErrGeneral;
+            } else if (iDynamicSetdefaultif) {
+                // Use name of the IAP to set default IAP
+                QByteArray nameAsByteArray = newActiveConfig.name().toUtf8();
+                ifreq ifr;
+                strcpy(ifr.ifr_name, nameAsByteArray.constData());
+
+                error = iDynamicSetdefaultif(&ifr);
+            }
+            
+            if (error != KErrNone) {
+                isOpen = false;
+                iError = QNetworkSession::UnknownSessionError;
+                emit QNetworkSessionPrivate::error(iError);
+                Cancel();
+                if (ipConnectionNotifier) {
+                    ipConnectionNotifier->StopNotifications();
+                }
+                syncStateWithInterface();
+                return;
+            }
+ 
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+            if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+                // Activate ALR monitoring
+                iMobility = CActiveCommsMobilityApiExt::NewL(iConnection, *this);
+            }
+#endif
+
+            isOpen = true;
+            activeConfig = newActiveConfig;
+
+            SymbianNetworkConfigurationPrivate *symbianConfig =
+                toSymbianConfig(privateConfiguration(activeConfig));
+
+            symbianConfig->mutex.lock();
+#ifndef QT_NO_NETWORKINTERFACE
+            activeInterface = interface(symbianConfig->numericId);
+#endif
+            if (publicConfig.type() == QNetworkConfiguration::UserChoice) {
+                serviceConfig = QNetworkConfigurationManager()
+                    .configurationFromIdentifier(symbianConfig->serviceNetworkPtr->id);
+            }
+            symbianConfig->mutex.unlock();
+
+            startTime = QDateTime::currentDateTime();
+
+            newState(QNetworkSession::Connected);
+            emit quitPendingWaitsForOpened();
+            }
+            break;
+        case KErrNotFound: // Connection failed
+            isOpen = false;
+            activeConfig = QNetworkConfiguration();
+            serviceConfig = QNetworkConfiguration();
+            iError = QNetworkSession::InvalidConfigurationError;
+            emit QNetworkSessionPrivate::error(iError);
+            Cancel();
+            if (ipConnectionNotifier) {
+                ipConnectionNotifier->StopNotifications();
+            }
+            syncStateWithInterface();
+            break;
+        case KErrCancel: // Connection attempt cancelled
+        case KErrAlreadyExists: // Connection already exists
+        default:
+            isOpen = false;
+            activeConfig = QNetworkConfiguration();
+            serviceConfig = QNetworkConfiguration();
+            iError = QNetworkSession::UnknownSessionError;
+            emit QNetworkSessionPrivate::error(iError);
+            Cancel();
+            if (ipConnectionNotifier) {
+                ipConnectionNotifier->StopNotifications();
+            }
+            syncStateWithInterface();
+            break;
+    }
+}
+
+void QNetworkSessionPrivateImpl::DoCancel()
+{
+    iConnection.Close();
+}
+
+bool QNetworkSessionPrivateImpl::newState(QNetworkSession::State newState, TUint accessPointId)
+{
+    // Make sure that activeConfig is always updated when SNAP is signaled to be
+    // connected.
+    if (isOpen && publicConfig.type() == QNetworkConfiguration::ServiceNetwork &&
+        newState == QNetworkSession::Connected) {
+        activeConfig = activeConfiguration(accessPointId);
+
+        SymbianNetworkConfigurationPrivate *symbianConfig =
+            toSymbianConfig(privateConfiguration(activeConfig));
+
+#ifndef QT_NO_NETWORKINTERFACE
+        symbianConfig->mutex.lock();
+        activeInterface = interface(symbianConfig->numericId);
+        symbianConfig->mutex.unlock();
+#endif
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+        if (iDynamicSetdefaultif) {
+            // Use name of the IAP to set default IAP
+            QByteArray nameAsByteArray = activeConfig.name().toUtf8();
+            ifreq ifr;
+            strcpy(ifr.ifr_name, nameAsByteArray.constData());
+
+            iDynamicSetdefaultif(&ifr);
+        }
+#endif
+    }
+
+    // Make sure that same state is not signaled twice in a row.
+    if (state == newState) {
+        return true;
+    }
+
+    // Make sure that Connecting state does not overwrite Roaming state
+    if (state == QNetworkSession::Roaming && newState == QNetworkSession::Connecting) {
+        return false;
+    }
+
+    bool emitSessionClosed = false;
+    if (isOpen && state == QNetworkSession::Connected && newState == QNetworkSession::Disconnected) {
+        // Active & Connected state should change directly to Disconnected state
+        // only when something forces connection to close (eg. when another
+        // application or session stops connection or when network drops
+        // unexpectedly).
+        isOpen = false;
+        activeConfig = QNetworkConfiguration();
+        serviceConfig = QNetworkConfiguration();
+        iError = QNetworkSession::SessionAbortedError;
+        emit QNetworkSessionPrivate::error(iError);
+        Cancel();
+        if (ipConnectionNotifier) {
+            ipConnectionNotifier->StopNotifications();
+        }
+        // Start monitoring changes in IAP states
+        TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));
+        emitSessionClosed = true; // Emit SessionClosed after state change has been reported
+    }
+
+    bool retVal = false;
+    if (accessPointId == 0) {
+        state = newState;
+        emit stateChanged(state);
+        retVal = true;
+    } else {
+        if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+            SymbianNetworkConfigurationPrivate *symbianConfig =
+                toSymbianConfig(privateConfiguration(publicConfig));
+
+            QMutexLocker configLocker(&symbianConfig->mutex);
+            if (symbianConfig->numericId == accessPointId) {
+                configLocker.unlock();
+
+                state = newState;
+                emit stateChanged(state);
+                retVal = true;
+            }
+        } else if (publicConfig.type() == QNetworkConfiguration::UserChoice && isOpen) {
+            SymbianNetworkConfigurationPrivate *symbianConfig =
+                toSymbianConfig(privateConfiguration(activeConfig));
+
+            QMutexLocker configLocker(&symbianConfig->mutex);
+            if (symbianConfig->numericId == accessPointId) {
+                configLocker.unlock();
+
+                state = newState;
+                emit stateChanged(state);
+                retVal = true;
+            }
+        } else if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+            QList<QNetworkConfiguration> subConfigurations = publicConfig.children();
+            for (int i = 0; i < subConfigurations.count(); i++) {
+                SymbianNetworkConfigurationPrivate *symbianConfig =
+                    toSymbianConfig(privateConfiguration(subConfigurations[i]));
+
+                QMutexLocker configLocker(&symbianConfig->mutex);
+
+                if (symbianConfig->numericId == accessPointId) {
+                    if (newState == QNetworkSession::Connected) {
+                        // Make sure that when AccessPoint is reported to be Connected
+                        // also state of the related configuration changes to Active.
+                        symbianConfig->state = QNetworkConfiguration::Active;
+                        configLocker.unlock();
+    
+                        state = newState;
+                        emit stateChanged(state);
+                        retVal = true;
+                    } else {
+                        if (newState == QNetworkSession::Disconnected) {
+                            // Make sure that when AccessPoint is reported to be disconnected
+                            // also state of the related configuration changes from Active to Defined.
+                            symbianConfig->state = QNetworkConfiguration::Defined;
+                        }
+                        QNetworkConfiguration config = bestConfigFromSNAP(publicConfig);
+                        if ((config.state() == QNetworkConfiguration::Defined) ||
+                            (config.state() == QNetworkConfiguration::Discovered)) {
+
+                            configLocker.unlock();
+
+                            state = newState;
+                            emit stateChanged(state);
+                            retVal = true;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    if (emitSessionClosed) {
+        emit closed();
+    }
+
+    return retVal;
+}
+
+void QNetworkSessionPrivateImpl::handleSymbianConnectionStatusChange(TInt aConnectionStatus,
+                                                                 TInt aError,
+                                                                 TUint accessPointId)
+{
+    switch (aConnectionStatus)
+        {
+        // Connection unitialised
+        case KConnectionUninitialised:
+            break;
+
+        // Starting connetion selection
+        case KStartingSelection:
+            break;
+
+        // Selection finished
+        case KFinishedSelection:
+            if (aError == KErrNone)
+                {
+                // The user successfully selected an IAP to be used
+                break;
+                }
+            else
+                {
+                // The user pressed e.g. "Cancel" and did not select an IAP
+                newState(QNetworkSession::Disconnected,accessPointId);
+                }
+            break;
+
+        // Connection failure
+        case KConnectionFailure:
+            newState(QNetworkSession::NotAvailable);
+            break;
+
+        // Prepearing connection (e.g. dialing)
+        case KPsdStartingConfiguration:
+        case KPsdFinishedConfiguration:
+        case KCsdFinishedDialling:
+        case KCsdScanningScript:
+        case KCsdGettingLoginInfo:
+        case KCsdGotLoginInfo:
+            break;
+
+        // Creating connection (e.g. GPRS activation)
+        case KCsdStartingConnect:
+        case KCsdFinishedConnect:
+            newState(QNetworkSession::Connecting,accessPointId);
+            break;
+
+        // Starting log in
+        case KCsdStartingLogIn:
+            break;
+
+        // Finished login
+        case KCsdFinishedLogIn:
+            break;
+
+        // Connection open
+        case KConnectionOpen:
+            break;
+
+        case KLinkLayerOpen:
+            newState(QNetworkSession::Connected,accessPointId);
+            break;
+
+        // Connection blocked or suspended
+        case KDataTransferTemporarilyBlocked:
+            break;
+
+        // Hangup or GRPS deactivation
+        case KConnectionStartingClose:
+            newState(QNetworkSession::Closing,accessPointId);
+            break;
+
+        // Connection closed
+        case KConnectionClosed:
+            break;
+
+        case KLinkLayerClosed:
+            newState(QNetworkSession::Disconnected,accessPointId);
+            break;
+
+        // Unhandled state
+        default:
+            break;
+        }
+}
+
+void QNetworkSessionPrivateImpl::EventL(const CConnMonEventBase& aEvent)
+{
+    switch (aEvent.EventType())
+    {
+        case EConnMonConnectionStatusChange:
+            {
+            CConnMonConnectionStatusChange* realEvent;
+            realEvent = (CConnMonConnectionStatusChange*) &aEvent;
+
+            TUint connectionId = realEvent->ConnectionId();
+            TInt connectionStatus = realEvent->ConnectionStatus();
+
+            // Try to Find IAP Id using connection Id
+            TUint apId = 0;
+            if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+                QList<QNetworkConfiguration> subConfigurations = publicConfig.children();
+                for (int i = 0; i < subConfigurations.count(); i++ ) {
+                    SymbianNetworkConfigurationPrivate *symbianConfig =
+                        toSymbianConfig(privateConfiguration(subConfigurations[i]));
+
+                    QMutexLocker configLocker(&symbianConfig->mutex);
+
+                    if (symbianConfig->connectionId == connectionId) {
+                        apId = symbianConfig->numericId;
+                        break;
+                    }
+                }
+            } else if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+                SymbianNetworkConfigurationPrivate *symbianConfig =
+                    toSymbianConfig(privateConfiguration(publicConfig));
+
+                symbianConfig->mutex.lock();
+                if (symbianConfig->connectionId == connectionId)
+                    apId = symbianConfig->numericId;
+                symbianConfig->mutex.unlock();
+            }
+
+            if (apId > 0) {
+                handleSymbianConnectionStatusChange(connectionStatus, KErrNone, apId);
+            }
+            }
+            break;
+
+        case EConnMonCreateConnection:
+            {
+            CConnMonCreateConnection* realEvent;
+            realEvent = (CConnMonCreateConnection*) &aEvent;
+            TUint apId;
+            TUint connectionId = realEvent->ConnectionId();
+            TRequestStatus status;
+            iConnectionMonitor.GetUintAttribute(connectionId, 0, KIAPId, apId, status);
+            User::WaitForRequest(status);
+            if (status.Int() == KErrNone) {
+                // Store connection id to related AccessPoint Configuration
+                if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+                    QList<QNetworkConfiguration> subConfigurations = publicConfig.children();
+                    for (int i = 0; i < subConfigurations.count(); i++ ) {
+                        SymbianNetworkConfigurationPrivate *symbianConfig =
+                            toSymbianConfig(privateConfiguration(subConfigurations[i]));
+
+                        QMutexLocker configLocker(&symbianConfig->mutex);
+
+                        if (symbianConfig->numericId == apId) {
+                            symbianConfig->connectionId = connectionId;
+                            break;
+                        }
+                    }
+                } else if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+                    SymbianNetworkConfigurationPrivate *symbianConfig =
+                        toSymbianConfig(privateConfiguration(publicConfig));
+
+                    symbianConfig->mutex.lock();
+                    if (symbianConfig->numericId == apId)
+                        symbianConfig->connectionId = connectionId;
+                    symbianConfig->mutex.unlock();
+                }
+            }
+            }
+            break;
+
+        case EConnMonDeleteConnection:
+            {
+            CConnMonDeleteConnection* realEvent;
+            realEvent = (CConnMonDeleteConnection*) &aEvent;
+            TUint connectionId = realEvent->ConnectionId();
+            // Remove connection id from related AccessPoint Configuration
+            if (publicConfig.type() == QNetworkConfiguration::ServiceNetwork) {
+                QList<QNetworkConfiguration> subConfigurations = publicConfig.children();
+                for (int i = 0; i < subConfigurations.count(); i++ ) {
+                    SymbianNetworkConfigurationPrivate *symbianConfig =
+                        toSymbianConfig(privateConfiguration(subConfigurations[i]));
+
+                    QMutexLocker configLocker(&symbianConfig->mutex);
+
+                    if (symbianConfig->connectionId == connectionId) {
+                        symbianConfig->connectionId = 0;
+                        break;
+                    }
+                }
+            } else if (publicConfig.type() == QNetworkConfiguration::InternetAccessPoint) {
+                SymbianNetworkConfigurationPrivate *symbianConfig =
+                    toSymbianConfig(privateConfiguration(publicConfig));
+
+                symbianConfig->mutex.lock();
+                if (symbianConfig->connectionId == connectionId)
+                    symbianConfig->connectionId = 0;
+                symbianConfig->mutex.unlock();
+            }
+            }
+            break;
+
+        default:
+            // For unrecognized events
+            break;
+    }
+}
+
+ConnectionProgressNotifier::ConnectionProgressNotifier(QNetworkSessionPrivateImpl &owner, RConnection &connection)
+    : CActive(CActive::EPriorityStandard), iOwner(owner), iConnection(connection)
+{
+    CActiveScheduler::Add(this);
+}
+
+ConnectionProgressNotifier::~ConnectionProgressNotifier()
+{
+    Cancel();
+}
+
+void ConnectionProgressNotifier::StartNotifications()
+{
+    if (!IsActive()) {
+        SetActive();
+    }
+    iConnection.ProgressNotification(iProgress, iStatus);
+}
+
+void ConnectionProgressNotifier::StopNotifications()
+{
+    Cancel();
+}
+
+void ConnectionProgressNotifier::DoCancel()
+{
+    iConnection.CancelProgressNotification();
+}
+
+void ConnectionProgressNotifier::RunL()
+{
+    if (iStatus == KErrNone) {
+        iOwner.handleSymbianConnectionStatusChange(iProgress().iStage, iProgress().iError);
+    
+        SetActive();
+        iConnection.ProgressNotification(iProgress, iStatus);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/symbian/qnetworksession_impl.h b/src/plugins/bearer/symbian/qnetworksession_impl.h
new file mode 100644
index 0000000..9a57eae
--- /dev/null
+++ b/src/plugins/bearer/symbian/qnetworksession_impl.h
@@ -0,0 +1,201 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QNETWORKSESSION_IMPL_H
+#define QNETWORKSESSION_IMPL_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtNetwork/private/qnetworksession_p.h>
+
+#include <QDateTime>
+
+#include <e32base.h>
+#include <commdbconnpref.h>
+#include <es_sock.h>
+#include <rconnmon.h>
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    #include <comms-infras/cs_mobility_apiext.h>
+#endif
+
+typedef int(*TOpenCSetdefaultifFunction)(const struct ifreq*);
+
+QT_BEGIN_NAMESPACE
+
+class ConnectionProgressNotifier;
+class SymbianEngine;
+
+class QNetworkSessionPrivateImpl : public QNetworkSessionPrivate, public CActive,
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+                                   public MMobilityProtocolResp,
+#endif
+                                   public MConnectionMonitorObserver
+{
+    Q_OBJECT
+public:
+    QNetworkSessionPrivateImpl(SymbianEngine *engine);
+    ~QNetworkSessionPrivateImpl();
+    
+    //called by QNetworkSession constructor and ensures
+    //that the state is immediately updated (w/o actually opening
+    //a session). Also this function should take care of 
+    //notification hooks to discover future state changes.
+    void syncStateWithInterface();
+
+#ifndef QT_NO_NETWORKINTERFACE
+    QNetworkInterface currentInterface() const;
+#endif
+    QVariant sessionProperty(const QString& key) const;
+    void setSessionProperty(const QString& key, const QVariant& value);
+    
+    void setALREnabled(bool enabled);
+
+    void open();
+    inline void close() { close(true); }
+    void close(bool allowSignals);
+    void stop();
+    void migrate();
+    void accept();
+    void ignore();
+    void reject();
+
+    QString errorString() const; //must return translated string
+    QNetworkSession::SessionError error() const;
+
+    quint64 bytesWritten() const;
+    quint64 bytesReceived() const;
+    quint64 activeTime() const;
+    
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+public: // From MMobilityProtocolResp
+    void PreferredCarrierAvailable(TAccessPointInfo aOldAPInfo,
+                                   TAccessPointInfo aNewAPInfo,
+                                   TBool aIsUpgrade,
+                                   TBool aIsSeamless);
+
+    void NewCarrierActive(TAccessPointInfo aNewAPInfo, TBool aIsSeamless);
+
+    void Error(TInt aError);
+#endif    
+
+protected: // From CActive
+    void RunL();
+    void DoCancel();
+    
+private: // MConnectionMonitorObserver
+    void EventL(const CConnMonEventBase& aEvent);
+    
+private:
+    TUint iapClientCount(TUint aIAPId) const;
+    quint64 transferredData(TUint dataType) const;
+    bool newState(QNetworkSession::State newState, TUint accessPointId = 0);
+    void handleSymbianConnectionStatusChange(TInt aConnectionStatus, TInt aError, TUint accessPointId = 0);
+    QNetworkConfiguration bestConfigFromSNAP(const QNetworkConfiguration& snapConfig) const;
+    QNetworkConfiguration activeConfiguration(TUint32 iapId = 0) const;
+#ifndef QT_NO_NETWORKINTERFACE
+    QNetworkInterface interface(TUint iapId) const;
+#endif
+
+private: // data
+    SymbianEngine *engine;
+
+#ifndef QT_NO_NETWORKINTERFACE
+    mutable QNetworkInterface activeInterface;
+#endif
+
+    QDateTime startTime;
+
+    RLibrary iOpenCLibrary;
+    TOpenCSetdefaultifFunction iDynamicSetdefaultif;
+
+    mutable RSocketServ iSocketServ;
+    mutable RConnection iConnection;
+    mutable RConnectionMonitor iConnectionMonitor;
+    ConnectionProgressNotifier* ipConnectionNotifier;
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+    CActiveCommsMobilityApiExt* iMobility;
+#endif    
+    
+    QNetworkSession::SessionError iError;
+    TInt iALREnabled;
+    TBool iALRUpgradingConnection;
+    
+    QList<QString> iKnownConfigsBeforeConnectionStart;
+    
+    TUint32 iOldRoamingIap;
+    TUint32 iNewRoamingIap;
+
+    friend class ConnectionProgressNotifier;
+};
+
+class ConnectionProgressNotifier : public CActive
+{
+public:
+    ConnectionProgressNotifier(QNetworkSessionPrivateImpl &owner, RConnection &connection);
+    ~ConnectionProgressNotifier();
+    
+    void StartNotifications();
+    void StopNotifications();
+    
+protected: // From CActive
+    void RunL();
+    void DoCancel();
+
+private: // Data
+    QNetworkSessionPrivateImpl &iOwner;
+    RConnection& iConnection;
+    TNifProgressBuf iProgress;
+    
+};
+
+QT_END_NAMESPACE
+
+#endif //QNETWORKSESSION_IMPL_H
+
diff --git a/src/plugins/bearer/symbian/symbian.pro b/src/plugins/bearer/symbian/symbian.pro
new file mode 100644
index 0000000..f915570
--- /dev/null
+++ b/src/plugins/bearer/symbian/symbian.pro
@@ -0,0 +1,40 @@
+TARGET = qsymbianbearer
+include(../../qpluginbase.pri)
+
+QT += network
+
+HEADERS += symbianengine.h \
+           qnetworksession_impl.h
+
+SOURCES += symbianengine.cpp \
+           qnetworksession_impl.cpp \
+           main.cpp
+
+symbian {
+    exists($${EPOCROOT}epoc32/release/winscw/udeb/cmmanager.lib)| \
+    exists($${EPOCROOT}epoc32/release/armv5/lib/cmmanager.lib) {
+        message("Building with SNAP support")
+        DEFINES += SNAP_FUNCTIONALITY_AVAILABLE
+        LIBS += -lcmmanager
+    } else {
+        message("Building without SNAP support")
+        LIBS += -lapengine
+    }
+}
+
+INCLUDEPATH += $$APP_LAYER_SYSTEMINCLUDE
+symbian-abld:INCLUDEPATH += $$QT_BUILD_TREE/include/QtNetwork/private
+
+LIBS += -lcommdb \
+        -lapsettingshandlerui \
+        -lconnmon \
+        -lcentralrepository \
+        -lesock \
+        -linsock \
+        -lecom \
+        -lefsrv \
+        -lnetmeta
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/bearer
+target.path += $$[QT_INSTALL_PLUGINS]/bearer
+INSTALLS += target
diff --git a/src/plugins/bearer/symbian/symbianengine.cpp b/src/plugins/bearer/symbian/symbianengine.cpp
new file mode 100644
index 0000000..440f463
--- /dev/null
+++ b/src/plugins/bearer/symbian/symbianengine.cpp
@@ -0,0 +1,1132 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "symbianengine.h"
+#include "qnetworksession_impl.h"
+
+#include <commdb.h>
+#include <cdbcols.h>
+#include <d32dbms.h>
+#include <QEventLoop>
+#include <QTimer>
+#include <QTime>  // For randgen seeding
+#include <QtCore> // For randgen seeding
+
+// #define QT_BEARERMGMT_CONFIGMGR_DEBUG
+
+#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+#include <QDebug>
+#endif
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    #include <cmdestination.h>
+    #include <cmconnectionmethod.h>
+    #include <cmconnectionmethoddef.h>
+    #include <cmpluginwlandef.h>
+    #include <cmpluginpacketdatadef.h>
+    #include <cmplugindialcommondefs.h>
+#else
+    #include <apaccesspointitem.h>
+    #include <apdatahandler.h>
+    #include <aputils.h> 
+#endif
+
+QT_BEGIN_NAMESPACE
+
+static const int KValueThatWillBeAddedToSNAPId = 1000;
+static const int KUserChoiceIAPId = 0;
+
+SymbianNetworkConfigurationPrivate::SymbianNetworkConfigurationPrivate()
+:   bearer(BearerUnknown), numericId(0), connectionId(0)
+{
+}
+
+SymbianNetworkConfigurationPrivate::~SymbianNetworkConfigurationPrivate()
+{
+}
+
+QString SymbianNetworkConfigurationPrivate::bearerName() const
+{
+    QMutexLocker locker(&mutex);
+
+    switch (bearer) {
+    case BearerEthernet:
+        return QLatin1String("Ethernet");
+    case BearerWLAN:
+        return QLatin1String("WLAN");
+    case Bearer2G:
+        return QLatin1String("2G");
+    case BearerCDMA2000:
+        return QLatin1String("CDMA2000");
+    case BearerWCDMA:
+        return QLatin1String("WCDMA");
+    case BearerHSPA:
+        return QLatin1String("HSPA");
+    case BearerBluetooth:
+        return QLatin1String("Bluetooth");
+    case BearerWiMAX:
+        return QLatin1String("WiMAX");
+    default:
+        return QString();
+    }
+}
+
+SymbianEngine::SymbianEngine(QObject *parent)
+:   QBearerEngine(parent), CActive(CActive::EPriorityIdle), iFirstUpdate(true), iInitOk(true),
+    iIgnoringUpdates(false), iTimeToWait(0), iIgnoreEventLoop(0)
+{
+    CActiveScheduler::Add(this);
+
+    // Seed the randomgenerator
+    qsrand(QTime(0,0,0).secsTo(QTime::currentTime()) + QCoreApplication::applicationPid());
+    iIgnoreEventLoop = new QEventLoop(this);
+
+    TRAPD(error, ipCommsDB = CCommsDatabase::NewL(EDatabaseTypeIAP));
+    if (error != KErrNone) {
+        iInitOk = false;
+        return;
+    }
+
+    TRAP_IGNORE(iConnectionMonitor.ConnectL());
+    TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+    TRAP(error, iCmManager.OpenL());
+    if (error != KErrNone) {
+        iInitOk = false;
+        return;
+    }
+#endif
+    
+    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
+    cpPriv->name = "UserChoice";
+    cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+    cpPriv->state = QNetworkConfiguration::Discovered;
+    cpPriv->isValid = true;
+    cpPriv->id = QString::number(qHash(KUserChoiceIAPId));
+    cpPriv->numericId = KUserChoiceIAPId;
+    cpPriv->connectionId = 0;
+    cpPriv->type = QNetworkConfiguration::UserChoice;
+    cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
+    cpPriv->roamingSupported = false;
+
+    QNetworkConfigurationPrivatePointer ptr(cpPriv);
+    userChoiceConfigurations.insert(ptr->id, ptr);
+
+    updateConfigurations();
+    updateStatesToSnaps();
+    updateAvailableAccessPoints(); // On first time updates synchronously (without WLAN scans)
+    // Start monitoring IAP and/or SNAP changes in Symbian CommsDB
+    startCommsDatabaseNotifications();
+    iFirstUpdate = false;
+}
+
+SymbianEngine::~SymbianEngine()
+{
+    Cancel();
+
+    iConnectionMonitor.CancelNotifications();
+    iConnectionMonitor.Close();
+    
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+    iCmManager.Close();
+#endif
+    
+    delete ipAccessPointsAvailabilityScanner;
+
+    // CCommsDatabase destructor uses cleanup stack. Since QNetworkConfigurationManager
+    // is a global static, but the time we are here, E32Main() has been exited already and
+    // the thread's default cleanup stack has been deleted. Without this line, a
+    // 'E32USER-CBase 69' -panic will occur.
+    CTrapCleanup* cleanup = CTrapCleanup::New();
+    delete ipCommsDB;
+    delete cleanup;
+}
+
+bool SymbianEngine::hasIdentifier(const QString &id)
+{
+    QMutexLocker locker(&mutex);
+
+    return accessPointConfigurations.contains(id) ||
+           snapConfigurations.contains(id) ||
+           userChoiceConfigurations.contains(id);
+}
+
+QNetworkConfigurationManager::Capabilities SymbianEngine::capabilities() const
+{
+    QNetworkConfigurationManager::Capabilities capFlags;
+
+    capFlags = QNetworkConfigurationManager::CanStartAndStopInterfaces |
+               QNetworkConfigurationManager::DirectConnectionRouting |
+               QNetworkConfigurationManager::SystemSessionSupport |
+               QNetworkConfigurationManager::DataStatistics |
+               QNetworkConfigurationManager::NetworkSessionRequired;
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    capFlags |= QNetworkConfigurationManager::ApplicationLevelRoaming |
+                QNetworkConfigurationManager::ForcedRoaming;
+#endif
+
+    return capFlags;
+}
+
+QNetworkSessionPrivate *SymbianEngine::createSessionBackend()
+{
+    return new QNetworkSessionPrivateImpl(this);
+}
+
+void SymbianEngine::requestUpdate()
+{
+    QMutexLocker locker(&mutex);
+
+    if (!iInitOk || iUpdateGoingOn) {
+        return;
+    }
+    iUpdateGoingOn = true;
+
+    stopCommsDatabaseNotifications();
+    updateConfigurations(); // Synchronous call
+    updateAvailableAccessPoints(); // Asynchronous call
+}
+
+void SymbianEngine::updateConfigurations()
+{
+    QMutexLocker locker(&mutex);
+
+    if (!iInitOk) {
+        return;
+    }
+
+    TRAP_IGNORE(updateConfigurationsL());
+}
+
+void SymbianEngine::updateConfigurationsL()
+{
+    QMutexLocker locker(&mutex);
+
+    QList<QString> knownConfigs = accessPointConfigurations.keys();
+    QList<QString> knownSnapConfigs = snapConfigurations.keys();
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE    
+    // S60 version is >= Series60 3rd Edition Feature Pack 2
+    TInt error = KErrNone;
+    
+    // Loop through all IAPs
+    RArray<TUint32> connectionMethods; // IAPs
+    CleanupClosePushL(connectionMethods);
+    iCmManager.ConnectionMethodL(connectionMethods);
+    for(int i = 0; i < connectionMethods.Count(); i++) {
+        RCmConnectionMethod connectionMethod = iCmManager.ConnectionMethodL(connectionMethods[i]);
+        CleanupClosePushL(connectionMethod);
+        TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
+        QString ident = QString::number(qHash(iapId));
+        if (accessPointConfigurations.contains(ident)) {
+            knownConfigs.removeOne(ident);
+        } else {
+            SymbianNetworkConfigurationPrivate* cpPriv = NULL;
+            TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));
+            if (error == KErrNone) {
+                QNetworkConfigurationPrivatePointer ptr(cpPriv);
+                accessPointConfigurations.insert(ptr->id, ptr);
+
+                locker.unlock();
+                emit configurationAdded(ptr);
+                locker.relock();
+            }
+        }
+        CleanupStack::PopAndDestroy(&connectionMethod);
+    }
+    CleanupStack::PopAndDestroy(&connectionMethods);
+    
+    // Loop through all SNAPs
+    RArray<TUint32> destinations;
+    CleanupClosePushL(destinations);
+    iCmManager.AllDestinationsL(destinations);
+    for(int i = 0; i < destinations.Count(); i++) {
+        RCmDestination destination;
+        destination = iCmManager.DestinationL(destinations[i]);
+        CleanupClosePushL(destination);
+        QString ident = QString::number(qHash(destination.Id()+KValueThatWillBeAddedToSNAPId)); //TODO: Check if it's ok to add 1000 SNAP Id to prevent SNAP ids overlapping IAP ids
+        if (snapConfigurations.contains(ident)) {
+            knownSnapConfigs.removeOne(ident);
+        } else {
+            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
+            CleanupStack::PushL(cpPriv);
+    
+            HBufC *pName = destination.NameLC();
+            cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length());
+            CleanupStack::PopAndDestroy(pName);
+            pName = NULL;
+    
+            cpPriv->isValid = true;
+            cpPriv->id = ident;
+            cpPriv->numericId = destination.Id();
+            cpPriv->connectionId = 0;
+            cpPriv->state = QNetworkConfiguration::Defined;
+            cpPriv->type = QNetworkConfiguration::ServiceNetwork;
+            cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
+            cpPriv->roamingSupported = false;
+
+            QNetworkConfigurationPrivatePointer ptr(cpPriv);
+            snapConfigurations.insert(ident, ptr);
+
+            locker.unlock();
+            emit configurationAdded(ptr);
+            locker.relock();
+            
+            CleanupStack::Pop(cpPriv);
+        }
+        QNetworkConfigurationPrivatePointer privSNAP = snapConfigurations.value(ident);
+            
+        for (int j=0; j < destination.ConnectionMethodCount(); j++) {
+            RCmConnectionMethod connectionMethod = destination.ConnectionMethodL(j);
+            CleanupClosePushL(connectionMethod);
+            
+            TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
+            QString iface = QString::number(qHash(iapId));
+            // Check that IAP can be found from accessPointConfigurations list
+            QNetworkConfigurationPrivatePointer priv = accessPointConfigurations.value(iface);
+            if (!priv) {
+                SymbianNetworkConfigurationPrivate *cpPriv = NULL;
+                TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));
+                if (error == KErrNone) {
+                    QNetworkConfigurationPrivatePointer ptr(cpPriv);
+                    toSymbianConfig(ptr)->serviceNetworkPtr = privSNAP;
+                    accessPointConfigurations.insert(ptr->id, ptr);
+
+                    locker.unlock();
+                    emit configurationAdded(ptr);
+                    locker.relock();
+
+                    privSNAP->serviceNetworkMembers.append(ptr);
+                }
+            } else {
+                knownConfigs.removeOne(iface);
+                // Check that IAP can be found from related SNAP's configuration list
+                bool iapFound = false;
+                for (int i = 0; i < privSNAP->serviceNetworkMembers.count(); i++) {
+                    if (toSymbianConfig(privSNAP->serviceNetworkMembers[i])->numericId == iapId) {
+                        iapFound = true;
+                        break;
+                    }
+                }
+                if (!iapFound) {
+                    toSymbianConfig(priv)->serviceNetworkPtr = privSNAP;
+                    privSNAP->serviceNetworkMembers.append(priv);
+                }
+            }
+            
+            CleanupStack::PopAndDestroy(&connectionMethod);
+        }
+        
+        if (privSNAP->serviceNetworkMembers.count() > 1) {
+            // Roaming is supported only if SNAP contains more than one IAP
+            privSNAP->roamingSupported = true;
+        }
+        
+        CleanupStack::PopAndDestroy(&destination);
+    }
+    CleanupStack::PopAndDestroy(&destinations);
+    
+#else
+    // S60 version is < Series60 3rd Edition Feature Pack 2
+    CCommsDbTableView* pDbTView = ipCommsDB->OpenTableLC(TPtrC(IAP));
+
+    // Loop through all IAPs
+    TUint32 apId = 0;
+    TInt retVal = pDbTView->GotoFirstRecord();
+    while (retVal == KErrNone) {
+        pDbTView->ReadUintL(TPtrC(COMMDB_ID), apId);
+        QString ident = QString::number(qHash(apId));
+        if (accessPointConfigurations.contains(ident)) {
+            knownConfigs.removeOne(ident);
+        } else {
+            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
+            if (readNetworkConfigurationValuesFromCommsDb(apId, cpPriv)) {
+                QNetworkConfigurationPrivatePointer ptr(cpPriv);
+                accessPointConfigurations.insert(ident, ptr);
+
+                locker.unlock();
+                emit configurationAdded(ptr);
+                locker.relock();
+            } else {
+                delete cpPriv;
+            }
+        }
+        retVal = pDbTView->GotoNextRecord();
+    }
+    CleanupStack::PopAndDestroy(pDbTView);
+#endif
+    updateActiveAccessPoints();
+    
+    foreach (const QString &oldIface, knownConfigs) {
+        //remove non existing IAP
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(oldIface);
+
+        locker.unlock();
+        emit configurationRemoved(ptr);
+        locker.relock();
+
+        // Remove non existing IAP from SNAPs
+        foreach (const QString &iface, snapConfigurations.keys()) {
+            QNetworkConfigurationPrivatePointer ptr2 = snapConfigurations.value(iface);
+            // => Check if one of the IAPs of the SNAP is active
+            for (int i = 0; i < ptr2->serviceNetworkMembers.count(); ++i) {
+                if (toSymbianConfig(ptr2->serviceNetworkMembers[i])->numericId ==
+                    toSymbianConfig(ptr)->numericId) {
+                    ptr2->serviceNetworkMembers.removeAt(i);
+                    break;
+                }
+            }
+        }    
+    }
+
+    foreach (const QString &oldIface, knownSnapConfigs) {
+        //remove non existing SNAPs
+        QNetworkConfigurationPrivatePointer ptr = snapConfigurations.take(oldIface);
+
+        locker.unlock();
+        emit configurationRemoved(ptr);
+        locker.relock();
+    }
+}
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+SymbianNetworkConfigurationPrivate *SymbianEngine::configFromConnectionMethodL(
+        RCmConnectionMethod& connectionMethod)
+{
+    QMutexLocker locker(&mutex);
+
+    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;
+    CleanupStack::PushL(cpPriv);
+    
+    TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);
+    QString ident = QString::number(qHash(iapId));
+    
+    HBufC *pName = connectionMethod.GetStringAttributeL(CMManager::ECmName);
+    CleanupStack::PushL(pName);
+    cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length());
+    CleanupStack::PopAndDestroy(pName);
+    pName = NULL;
+    
+    TUint32 bearerId = connectionMethod.GetIntAttributeL(CMManager::ECmCommsDBBearerType);
+    switch (bearerId) {
+    case KCommDbBearerCSD:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::Bearer2G;
+        break;
+    case KCommDbBearerWcdma:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerWCDMA;
+        break;
+    case KCommDbBearerLAN:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerEthernet;
+        break;
+    case KCommDbBearerVirtual:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+        break;
+    case KCommDbBearerPAN:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+        break;
+    case KCommDbBearerWLAN:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerWLAN;
+        break;
+    default:
+        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+        break;
+    }
+    
+    TInt error = KErrNone;
+    TUint32 bearerType = connectionMethod.GetIntAttributeL(CMManager::ECmBearerType);
+    switch (bearerType) {
+    case KUidPacketDataBearerType:
+        // "Packet data" Bearer => Mapping is done using "Access point name"
+        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EPacketDataAPName));
+        break;
+    case KUidWlanBearerType:
+        // "Wireless LAN" Bearer => Mapping is done using "WLAN network name" = SSID
+        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EWlanSSID));
+        break;
+    }
+    if (!pName) {
+        // "Data call" Bearer or "High Speed (GSM)" Bearer => Mapping is done using "Dial-up number"
+        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EDialDefaultTelNum));
+    }
+
+    if (error == KErrNone && pName) {
+        CleanupStack::PushL(pName);
+        cpPriv->mappingName = QString::fromUtf16(pName->Ptr(),pName->Length());
+        CleanupStack::PopAndDestroy(pName);
+        pName = NULL;
+    }
+ 
+    cpPriv->state = QNetworkConfiguration::Defined;
+    TBool isConnected = connectionMethod.GetBoolAttributeL(CMManager::ECmConnected);
+    if (isConnected) {
+        cpPriv->state = QNetworkConfiguration::Active;
+    }
+    
+    cpPriv->isValid = true;
+    cpPriv->id = ident;
+    cpPriv->numericId = iapId;
+    cpPriv->connectionId = 0;
+    cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+    cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;
+    cpPriv->roamingSupported = false;
+    
+    CleanupStack::Pop(cpPriv);
+    return cpPriv;
+}
+#else
+bool SymbianEngine::readNetworkConfigurationValuesFromCommsDb(
+        TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration)
+{
+    QMutexLocker locker(&mutex);
+
+    TRAPD(error, readNetworkConfigurationValuesFromCommsDbL(aApId,apNetworkConfiguration));
+    if (error != KErrNone) {
+        return false;        
+    }
+    return true;
+}
+
+void SymbianEngine::readNetworkConfigurationValuesFromCommsDbL(
+        TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration)
+{
+    QMutexLocker locker(&mutex);
+
+    CApDataHandler* pDataHandler = CApDataHandler::NewLC(*ipCommsDB); 
+    CApAccessPointItem* pAPItem = CApAccessPointItem::NewLC(); 
+    TBuf<KCommsDbSvrMaxColumnNameLength> name;
+    
+    CApUtils* pApUtils = CApUtils::NewLC(*ipCommsDB);
+    TUint32 apId = pApUtils->WapIdFromIapIdL(aApId);
+    
+    pDataHandler->AccessPointDataL(apId,*pAPItem);
+    pAPItem->ReadTextL(EApIapName, name);
+    if (name.Compare(_L("Easy WLAN")) == 0) {
+        // "Easy WLAN" won't be accepted to the Configurations list
+        User::Leave(KErrNotFound);
+    }
+    
+    QString ident = QString::number(qHash(aApId));
+    
+    apNetworkConfiguration->name = QString::fromUtf16(name.Ptr(),name.Length());
+    apNetworkConfiguration->isValid = true;
+    apNetworkConfiguration->id = ident;
+    apNetworkConfiguration->numericId = aApId;
+    apNetworkConfiguration->connectionId = 0;
+    apNetworkConfiguration->state = (QNetworkConfiguration::Defined);
+    apNetworkConfiguration->type = QNetworkConfiguration::InternetAccessPoint;
+    apNetworkConfiguration->purpose = QNetworkConfiguration::UnknownPurpose;
+    apNetworkConfiguration->roamingSupported = false;
+    switch (pAPItem->BearerTypeL()) {
+    case EApBearerTypeCSD:      
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::Bearer2G;
+        break;
+    case EApBearerTypeGPRS:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::Bearer2G;
+        break;
+    case EApBearerTypeHSCSD:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerHSPA;
+        break;
+    case EApBearerTypeCDMA:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerCDMA2000;
+        break;
+    case EApBearerTypeWLAN:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerWLAN;
+        break;
+    case EApBearerTypeLAN:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerEthernet;
+        break;
+    case EApBearerTypeLANModem:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerEthernet;
+        break;
+    default:
+        apNetworkConfiguration->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;
+        break;
+    }
+    
+    CleanupStack::PopAndDestroy(pApUtils);
+    CleanupStack::PopAndDestroy(pAPItem);
+    CleanupStack::PopAndDestroy(pDataHandler);
+}
+#endif
+
+QNetworkConfigurationPrivatePointer SymbianEngine::defaultConfiguration()
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr;
+
+    if (iInitOk) {
+        stopCommsDatabaseNotifications();
+        TRAP_IGNORE(ptr = defaultConfigurationL());
+        startCommsDatabaseNotifications();
+    }
+
+    return ptr;
+}
+
+QStringList SymbianEngine::accessPointConfigurationIdentifiers()
+{
+    QMutexLocker locker(&mutex);
+
+    return accessPointConfigurations.keys();
+}
+
+QNetworkConfigurationPrivatePointer SymbianEngine::defaultConfigurationL()
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfigurationPrivatePointer ptr;
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    // Check Default Connection (SNAP or IAP)
+    TCmDefConnValue defaultConnectionValue;
+    iCmManager.ReadDefConnL(defaultConnectionValue);
+    if (defaultConnectionValue.iType == ECmDefConnDestination) {
+        QString iface = QString::number(qHash(defaultConnectionValue.iId+KValueThatWillBeAddedToSNAPId));
+        ptr = snapConfigurations.value(iface);
+    } else if (defaultConnectionValue.iType == ECmDefConnConnectionMethod) {
+        QString iface = QString::number(qHash(defaultConnectionValue.iId));
+        ptr = accessPointConfigurations.value(iface);
+    }
+#endif
+    
+    if (!ptr || !ptr->isValid) {
+        QString iface = QString::number(qHash(KUserChoiceIAPId));
+        ptr = userChoiceConfigurations.value(iface);
+    }
+    
+    return ptr;
+}
+
+void SymbianEngine::updateActiveAccessPoints()
+{
+    QMutexLocker locker(&mutex);
+
+    bool online = false;
+    QList<QString> inactiveConfigs = accessPointConfigurations.keys();
+
+    TRequestStatus status;
+    TUint connectionCount;
+    iConnectionMonitor.GetConnectionCount(connectionCount, status);
+    User::WaitForRequest(status);
+    
+    // Go through all connections and set state of related IAPs to Active
+    TUint connectionId;
+    TUint subConnectionCount;
+    TUint apId;
+    if (status.Int() == KErrNone) {
+        for (TUint i = 1; i <= connectionCount; i++) {
+            iConnectionMonitor.GetConnectionInfo(i, connectionId, subConnectionCount);
+            iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
+            User::WaitForRequest(status);
+            QString ident = QString::number(qHash(apId));
+
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
+            if (ptr) {
+                online = true;
+                inactiveConfigs.removeOne(ident);
+
+                toSymbianConfig(ptr)->connectionId = connectionId;
+
+                // Configuration is Active
+                changeConfigurationStateTo(ptr, QNetworkConfiguration::Active);
+            }
+        }
+    }
+
+    // Make sure that state of rest of the IAPs won't be Active
+    foreach (const QString &iface, inactiveConfigs) {
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);
+        if (ptr) {
+            // Configuration is either Defined or Discovered
+            changeConfigurationStateAtMaxTo(ptr, QNetworkConfiguration::Discovered);
+        }
+    }
+
+    if (iOnline != online) {
+        iOnline = online;
+        locker.unlock();
+        emit this->onlineStateChanged(iOnline);
+        locker.relock();
+    }
+}
+
+void SymbianEngine::updateAvailableAccessPoints()
+{
+    QMutexLocker locker(&mutex);
+
+    if (!ipAccessPointsAvailabilityScanner) {
+        ipAccessPointsAvailabilityScanner = new AccessPointsAvailabilityScanner(*this, iConnectionMonitor);
+    }
+    if (ipAccessPointsAvailabilityScanner) {
+        // Scanning may take a while because WLAN scanning will be done (if device supports WLAN).
+        ipAccessPointsAvailabilityScanner->StartScanning();
+    }
+}
+
+void SymbianEngine::accessPointScanningReady(TBool scanSuccessful, TConnMonIapInfo iapInfo)
+{
+    QMutexLocker locker(&mutex);
+
+    iUpdateGoingOn = false;
+    if (scanSuccessful) {
+        QList<QString> unavailableConfigs = accessPointConfigurations.keys();
+        
+        // Set state of returned IAPs to Discovered
+        // if state is not already Active
+        for(TUint i=0; i<iapInfo.iCount; i++) {
+            QString ident = QString::number(qHash(iapInfo.iIap[i].iIapId));
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
+            if (ptr) {
+                unavailableConfigs.removeOne(ident);
+                if (ptr->state < QNetworkConfiguration::Active) {
+                    // Configuration is either Discovered or Active
+                    changeConfigurationStateAtMinTo(ptr, QNetworkConfiguration::Discovered);
+                }
+            }
+        }
+        
+        // Make sure that state of rest of the IAPs won't be Discovered or Active
+        foreach (const QString &iface, unavailableConfigs) {
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);
+            if (ptr) {
+                // Configuration is Defined
+                changeConfigurationStateAtMaxTo(ptr, QNetworkConfiguration::Defined);
+            }
+        }
+    }
+
+    updateStatesToSnaps();
+    
+    if (!iFirstUpdate) {
+        startCommsDatabaseNotifications();
+        locker.unlock();
+        emit updateCompleted();
+        locker.relock();
+    }
+}
+
+void SymbianEngine::updateStatesToSnaps()
+{
+    QMutexLocker locker(&mutex);
+
+    // Go through SNAPs and set correct state to SNAPs
+    foreach (const QString &iface, snapConfigurations.keys()) {
+        bool discovered = false;
+        bool active = false;
+        QNetworkConfigurationPrivatePointer ptr = snapConfigurations.value(iface);
+        // => Check if one of the IAPs of the SNAP is discovered or active
+        //    => If one of IAPs is active, also SNAP is active
+        //    => If one of IAPs is discovered but none of the IAPs is active, SNAP is discovered
+        for (int i=0; i<ptr->serviceNetworkMembers.count(); i++) {
+            if ((ptr->serviceNetworkMembers[i]->state & QNetworkConfiguration::Active)
+                    == QNetworkConfiguration::Active) {
+                active = true;
+                break;
+            } else if ((ptr->serviceNetworkMembers[i]->state & QNetworkConfiguration::Discovered)
+                        == QNetworkConfiguration::Discovered) {
+                discovered = true;
+            }
+        }
+        if (active) {
+            changeConfigurationStateTo(ptr, QNetworkConfiguration::Active);
+        } else if (discovered) {
+            changeConfigurationStateTo(ptr, QNetworkConfiguration::Discovered);
+        } else {
+            changeConfigurationStateTo(ptr, QNetworkConfiguration::Defined);
+        }
+    }    
+}
+
+bool SymbianEngine::changeConfigurationStateTo(QNetworkConfigurationPrivatePointer ptr,
+                                               QNetworkConfiguration::StateFlags newState)
+{
+    QMutexLocker locker(&mutex);
+
+    ptr->mutex.lock();
+    if (newState != ptr->state) {
+        ptr->state = newState;
+        ptr->mutex.unlock();
+
+        locker.unlock();
+        emit configurationChanged(ptr);
+        locker.relock();
+
+        return true;
+    } else {
+        ptr->mutex.unlock();
+    }
+    return false;
+}
+
+/* changeConfigurationStateAtMinTo function does not overwrite possible better
+ * state (e.g. Discovered state does not overwrite Active state) but
+ * makes sure that state is at minimum given state.
+*/
+bool SymbianEngine::changeConfigurationStateAtMinTo(QNetworkConfigurationPrivatePointer ptr,
+                                                    QNetworkConfiguration::StateFlags newState)
+{
+    QMutexLocker locker(&mutex);
+
+    ptr->mutex.lock();
+    if ((newState | ptr->state) != ptr->state) {
+        ptr->state = (ptr->state | newState);
+        ptr->mutex.unlock();
+
+        locker.unlock();
+        emit configurationChanged(ptr);
+        locker.relock();
+
+        return true;
+    } else {
+        ptr->mutex.unlock();
+    }
+    return false;
+}
+
+/* changeConfigurationStateAtMaxTo function overwrites possible better
+ * state (e.g. Discovered state overwrites Active state) and
+ * makes sure that state is at maximum given state (e.g. Discovered state
+ * does not overwrite Defined state).
+*/
+bool SymbianEngine::changeConfigurationStateAtMaxTo(QNetworkConfigurationPrivatePointer ptr,
+                                                    QNetworkConfiguration::StateFlags newState)
+{
+    QMutexLocker locker(&mutex);
+
+    ptr->mutex.lock();
+    if ((newState & ptr->state) != ptr->state) {
+        ptr->state = (newState & ptr->state);
+        ptr->mutex.unlock();
+
+        locker.unlock();
+        emit configurationChanged(ptr);
+        locker.relock();
+
+        return true;
+    } else {
+        ptr->mutex.unlock();
+    }
+    return false;
+}
+
+void SymbianEngine::startCommsDatabaseNotifications()
+{
+    QMutexLocker locker(&mutex);
+
+    if (!iWaitingCommsDatabaseNotifications) {
+        iWaitingCommsDatabaseNotifications = ETrue;
+        if (!IsActive()) {
+            SetActive();
+            // Start waiting for new notification
+            ipCommsDB->RequestNotification(iStatus);
+        }
+    }
+}
+
+void SymbianEngine::stopCommsDatabaseNotifications()
+{
+    QMutexLocker locker(&mutex);
+
+    if (iWaitingCommsDatabaseNotifications) {
+        iWaitingCommsDatabaseNotifications = EFalse;
+        if (!IsActive()) {
+            SetActive();
+            // Make sure that notifier recorded events will not be returned
+            // as soon as the client issues the next RequestNotification() request.
+            ipCommsDB->RequestNotification(iStatus);
+            ipCommsDB->CancelRequestNotification();
+        } else {
+            ipCommsDB->CancelRequestNotification();
+        }
+    }
+}
+
+void SymbianEngine::RunL()
+{
+    QMutexLocker locker(&mutex);
+
+    if (iIgnoringUpdates) {
+#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+        qDebug("CommsDB event handling postponed (postpone-timer running because IAPs/SNAPs were updated very recently).");
+#endif
+        return;
+    }
+
+    if (iStatus != KErrCancel) {
+        RDbNotifier::TEvent event = STATIC_CAST(RDbNotifier::TEvent, iStatus.Int());
+        switch (event) {
+        case RDbNotifier::EUnlock:   /** All read locks have been removed.  */
+        case RDbNotifier::ECommit:   /** A transaction has been committed.  */ 
+        case RDbNotifier::ERollback: /** A transaction has been rolled back */
+        case RDbNotifier::ERecover:  /** The database has been recovered    */
+#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+            qDebug("CommsDB event (of type RDbNotifier::TEvent) received: %d", iStatus.Int());
+#endif
+            iIgnoringUpdates = true;
+            // Other events than ECommit get lower priority. In practice with those events,
+            // we delay_before_updating methods, whereas
+            // with ECommit we _update_before_delaying the reaction to next event.
+            // Few important notes: 1) listening to only ECommit does not seem to be adequate,
+            // but updates will be missed. Hence other events are reacted upon too.
+            // 2) RDbNotifier records the most significant event, and that will be returned once
+            // we issue new RequestNotification, and hence updates will not be missed even
+            // when we are 'not reacting to them' for few seconds.
+            if (event == RDbNotifier::ECommit) {
+                TRAPD(error, updateConfigurationsL());
+                if (error == KErrNone) {
+                    updateStatesToSnaps();
+                }
+                waitRandomTime();
+            } else {
+                waitRandomTime();
+                TRAPD(error, updateConfigurationsL());
+                if (error == KErrNone) {
+                    updateStatesToSnaps();
+                }   
+            }
+            iIgnoringUpdates = false; // Wait time done, allow updating again
+            iWaitingCommsDatabaseNotifications = true;
+            break;
+        default:
+            // Do nothing
+            break;
+        }
+    }
+
+    if (iWaitingCommsDatabaseNotifications) {
+        if (!IsActive()) {
+            SetActive();
+            // Start waiting for new notification
+            ipCommsDB->RequestNotification(iStatus);
+        }
+    }
+}
+
+void SymbianEngine::DoCancel()
+{
+    QMutexLocker locker(&mutex);
+
+    ipCommsDB->CancelRequestNotification();
+}
+
+
+void SymbianEngine::EventL(const CConnMonEventBase& aEvent)
+{
+    QMutexLocker locker(&mutex);
+
+    switch (aEvent.EventType()) {
+    case EConnMonCreateConnection:
+        {
+        CConnMonCreateConnection* realEvent;
+        realEvent = (CConnMonCreateConnection*) &aEvent;
+        TUint subConnectionCount = 0;
+        TUint apId;            
+        TUint connectionId = realEvent->ConnectionId();
+        TRequestStatus status;
+        iConnectionMonitor.GetUintAttribute(connectionId, subConnectionCount, KIAPId, apId, status);
+        User::WaitForRequest(status);
+        QString ident = QString::number(qHash(apId));
+
+        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
+        if (ptr) {
+            toSymbianConfig(ptr)->connectionId = connectionId;
+            // Configuration is Active
+            if (changeConfigurationStateTo(ptr, QNetworkConfiguration::Active))
+                updateStatesToSnaps();
+
+            if (!iOnline) {
+                iOnline = true;
+
+                locker.unlock();
+                emit this->onlineStateChanged(iOnline);
+                locker.relock();
+            }
+        }
+        }
+        break;
+
+    case EConnMonDeleteConnection:
+        {
+        CConnMonDeleteConnection* realEvent;
+        realEvent = (CConnMonDeleteConnection*) &aEvent;
+        TUint connectionId = realEvent->ConnectionId();
+
+        QNetworkConfigurationPrivatePointer ptr = dataByConnectionId(connectionId);
+        if (ptr) {
+            toSymbianConfig(ptr)->connectionId = 0;
+            // Configuration is either Defined or Discovered
+            if (changeConfigurationStateAtMaxTo(ptr, QNetworkConfiguration::Discovered))
+                updateStatesToSnaps();
+        }
+        
+        bool online = false;
+        foreach (const QString &iface, accessPointConfigurations.keys()) {
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);
+            if (ptr->state == QNetworkConfiguration::Active) {
+                online = true;
+                break;
+            }
+        }
+        if (iOnline != online) {
+            iOnline = online;
+
+            locker.unlock();
+            emit this->onlineStateChanged(iOnline);
+            locker.relock();
+        }
+        }
+        break;
+
+    case EConnMonIapAvailabilityChange:
+        {
+        CConnMonIapAvailabilityChange* realEvent;
+        realEvent = (CConnMonIapAvailabilityChange*) &aEvent;
+        TConnMonIapInfo iaps = realEvent->IapAvailability();
+        QList<QString> unDiscoveredConfigs = accessPointConfigurations.keys();
+        for ( TUint i = 0; i < iaps.Count(); i++ ) {
+            QString ident = QString::number(qHash(iaps.iIap[i].iIapId));
+
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(ident);
+            if (ptr) {
+                // Configuration is either Discovered or Active 
+                changeConfigurationStateAtMinTo(ptr, QNetworkConfiguration::Discovered);
+                unDiscoveredConfigs.removeOne(ident);
+            }
+        }
+        foreach (const QString &iface, unDiscoveredConfigs) {
+            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);
+            if (ptr) {
+                // Configuration is Defined
+                changeConfigurationStateAtMaxTo(ptr, QNetworkConfiguration::Defined);
+            }
+        }
+        }
+        break;
+
+    default:
+        // For unrecognized events
+        break;
+    }
+}
+
+// Waits for 1..4 seconds.
+void SymbianEngine::waitRandomTime()
+{
+    iTimeToWait = (qAbs(qrand()) % 5) * 1000;
+    if (iTimeToWait < 1000) {
+        iTimeToWait = 1000;
+    }
+#ifdef QT_BEARERMGMT_CONFIGMGR_DEBUG
+    qDebug("QNetworkConfigurationManager waiting random time: %d ms", iTimeToWait);
+#endif
+    QTimer::singleShot(iTimeToWait, iIgnoreEventLoop, SLOT(quit()));
+    iIgnoreEventLoop->exec();
+}
+
+QNetworkConfigurationPrivatePointer SymbianEngine::dataByConnectionId(TUint aConnectionId)
+{
+    QMutexLocker locker(&mutex);
+
+    QNetworkConfiguration item;
+    
+    QHash<QString, QNetworkConfigurationPrivatePointer>::const_iterator i =
+            accessPointConfigurations.constBegin();
+    while (i != accessPointConfigurations.constEnd()) {
+        QNetworkConfigurationPrivatePointer ptr = i.value();
+        if (toSymbianConfig(ptr)->connectionId == aConnectionId)
+            return ptr;
+
+        ++i;
+    }
+
+    return QNetworkConfigurationPrivatePointer();
+}
+
+AccessPointsAvailabilityScanner::AccessPointsAvailabilityScanner(SymbianEngine& owner,
+                                                               RConnectionMonitor& connectionMonitor)
+    : CActive(CActive::EPriorityStandard), iOwner(owner), iConnectionMonitor(connectionMonitor)
+{
+    CActiveScheduler::Add(this);  
+}
+
+AccessPointsAvailabilityScanner::~AccessPointsAvailabilityScanner()
+{
+    Cancel();
+}
+
+void AccessPointsAvailabilityScanner::DoCancel()
+{
+    iConnectionMonitor.CancelAsyncRequest(EConnMonGetPckgAttribute);
+}
+
+void AccessPointsAvailabilityScanner::StartScanning()
+{
+    if (iOwner.iFirstUpdate) {
+        // On first update (the mgr is being instantiated) update only those bearers who
+        // don't need time-consuming scans (WLAN).
+        // Note: EBearerIdWCDMA covers also GPRS bearer
+        iConnectionMonitor.GetPckgAttribute(EBearerIdWCDMA, 0, KIapAvailability, iIapBuf, iStatus);
+        User::WaitForRequest(iStatus);
+        if (iStatus.Int() == KErrNone) {
+            iOwner.accessPointScanningReady(true,iIapBuf());
+        }
+    } else {
+        iConnectionMonitor.GetPckgAttribute(EBearerIdAll, 0, KIapAvailability, iIapBuf, iStatus);
+        if (!IsActive()) {
+            SetActive();
+        }
+    }
+}
+
+void AccessPointsAvailabilityScanner::RunL()
+{
+    if (iStatus.Int() != KErrNone) {
+        iIapBuf().iCount = 0;
+        iOwner.accessPointScanningReady(false,iIapBuf());
+    } else {
+        iOwner.accessPointScanningReady(true,iIapBuf());
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/bearer/symbian/symbianengine.h b/src/plugins/bearer/symbian/symbianengine.h
new file mode 100644
index 0000000..2e7ae60
--- /dev/null
+++ b/src/plugins/bearer/symbian/symbianengine.h
@@ -0,0 +1,210 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef SYMBIANENGINE_H
+#define SYMBIANENGINE_H
+
+#include <QtCore/qstringlist.h>
+#include <QtNetwork/private/qbearerengine_p.h>
+#include <QtNetwork/qnetworkconfigmanager.h>
+
+#include <QHash>
+#include <rconnmon.h>
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    #include <cmmanager.h>
+#endif
+
+class CCommsDatabase;
+class QEventLoop;
+
+QT_BEGIN_NAMESPACE
+class QTimer;
+QT_END_NAMESPACE
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkSessionPrivate;
+class AccessPointsAvailabilityScanner;
+
+class SymbianNetworkConfigurationPrivate : public QNetworkConfigurationPrivate
+{
+public:
+    enum Bearer {
+        BearerEthernet,
+        BearerWLAN,
+        Bearer2G,
+        BearerCDMA2000,
+        BearerWCDMA,
+        BearerHSPA,
+        BearerBluetooth,
+        BearerWiMAX,
+        BearerUnknown = -1
+    };
+
+    SymbianNetworkConfigurationPrivate();
+    ~SymbianNetworkConfigurationPrivate();
+
+    QString bearerName() const;
+
+    Bearer bearer;
+
+    TUint32 numericId;
+    TUint connectionId;
+
+    QNetworkConfigurationPrivatePointer serviceNetworkPtr;
+
+    QString mappingName;
+};
+
+inline SymbianNetworkConfigurationPrivate *toSymbianConfig(QNetworkConfigurationPrivatePointer ptr)
+{
+    return static_cast<SymbianNetworkConfigurationPrivate *>(ptr.data());
+}
+
+class SymbianEngine : public QBearerEngine, public CActive,
+                      public MConnectionMonitorObserver
+{
+    Q_OBJECT
+
+public:
+    SymbianEngine(QObject *parent = 0);
+    virtual ~SymbianEngine();
+
+    bool hasIdentifier(const QString &id);
+
+    Q_INVOKABLE void requestUpdate();
+
+    QNetworkConfigurationManager::Capabilities capabilities() const;
+
+    QNetworkSessionPrivate *createSessionBackend();
+
+    QNetworkConfigurationPrivatePointer defaultConfiguration();
+
+    QStringList accessPointConfigurationIdentifiers();
+
+Q_SIGNALS:
+    void onlineStateChanged(bool isOnline);
+    
+public Q_SLOTS:
+    void updateConfigurations();
+
+private:
+    void updateStatesToSnaps();
+    bool changeConfigurationStateTo(QNetworkConfigurationPrivatePointer ptr,
+                                    QNetworkConfiguration::StateFlags newState);
+    bool changeConfigurationStateAtMinTo(QNetworkConfigurationPrivatePointer ptr,
+                                         QNetworkConfiguration::StateFlags newState);
+    bool changeConfigurationStateAtMaxTo(QNetworkConfigurationPrivatePointer ptr,
+                                         QNetworkConfiguration::StateFlags newState);
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    SymbianNetworkConfigurationPrivate *configFromConnectionMethodL(RCmConnectionMethod& connectionMethod);
+#else
+    bool readNetworkConfigurationValuesFromCommsDb(
+            TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration);
+    void readNetworkConfigurationValuesFromCommsDbL(
+            TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration);
+#endif    
+    
+    void updateConfigurationsL();
+    void updateActiveAccessPoints();
+    void updateAvailableAccessPoints();
+    void accessPointScanningReady(TBool scanSuccessful, TConnMonIapInfo iapInfo);
+    void startCommsDatabaseNotifications();
+    void stopCommsDatabaseNotifications();
+    void waitRandomTime();
+
+    QNetworkConfigurationPrivatePointer defaultConfigurationL();
+    TBool GetS60PlatformVersion(TUint& aMajor, TUint& aMinor) const;
+    void startMonitoringIAPData(TUint32 aIapId);
+    QNetworkConfigurationPrivatePointer dataByConnectionId(TUint aConnectionId);
+
+protected: // From CActive
+    void RunL();
+    void DoCancel();
+    
+private: // MConnectionMonitorObserver
+    void EventL(const CConnMonEventBase& aEvent);
+
+private: // Data
+    bool               iFirstUpdate; 
+    CCommsDatabase*    ipCommsDB;
+    RConnectionMonitor iConnectionMonitor;
+
+    TBool              iWaitingCommsDatabaseNotifications;
+    TBool              iOnline;
+    TBool              iInitOk;
+    TBool              iUpdateGoingOn;
+    TBool              iIgnoringUpdates;
+    TUint              iTimeToWait;
+    QEventLoop*        iIgnoreEventLoop;
+
+    AccessPointsAvailabilityScanner* ipAccessPointsAvailabilityScanner;
+    
+    friend class QNetworkSessionPrivate;
+    friend class AccessPointsAvailabilityScanner;
+
+#ifdef SNAP_FUNCTIONALITY_AVAILABLE
+    RCmManager iCmManager;
+#endif
+};
+
+class AccessPointsAvailabilityScanner : public CActive
+{
+public:
+    AccessPointsAvailabilityScanner(SymbianEngine& owner,
+                                   RConnectionMonitor& connectionMonitor); 
+    ~AccessPointsAvailabilityScanner();
+
+    void StartScanning();
+    
+protected: // From CActive
+    void RunL();
+    void DoCancel();
+
+private: // Data
+    SymbianEngine& iOwner;
+    RConnectionMonitor& iConnectionMonitor;
+    TConnMonIapInfoBuf iIapBuf;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/plugins/codecs/cn/qgb18030codec.cpp b/src/plugins/codecs/cn/qgb18030codec.cpp
index 5537cf7..3f2eec7 100644
--- a/src/plugins/codecs/cn/qgb18030codec.cpp
+++ b/src/plugins/codecs/cn/qgb18030codec.cpp
@@ -60,7 +60,7 @@ QT_BEGIN_NAMESPACE
 #define Is3rdByte(c)        (InRange((c), 0x81, 0xFE))
 #define Is4thByte(c)        (InRange((c), 0x30, 0x39))
 
-#define QValidChar(u)        ((u) ? QChar((ushort)(u)) : QChar(QChar::ReplacementCharacter))
+#define qValidChar(u)        ((u) ? (u) : static_cast<ushort>(QChar::ReplacementCharacter))
 
 /* User-defined areas:        UDA 1: 0xAAA1 - 0xAFFE (564/0)
                         UDA 2: 0xF8A1 - 0xFEFE (658/0)
@@ -160,7 +160,7 @@ QString QGb18030Codec::convertToUnicode(const char* chars, int len, ConverterSta
 {
     uchar buf[4];
     int nbuf = 0;
-    QChar replacement = QChar::ReplacementCharacter;
+    ushort replacement = QChar::ReplacementCharacter;
     if (state) {
         if (state->flags & ConvertInvalidToNull)
             replacement = QChar::Null;
@@ -173,6 +173,9 @@ QString QGb18030Codec::convertToUnicode(const char* chars, int len, ConverterSta
     int invalid = 0;
 
     QString result;
+    result.resize(len);
+    int unicodeLen = 0;
+    ushort *const resultData = reinterpret_cast<ushort*>(result.data());
     //qDebug("QGb18030Decoder::toUnicode(const char* chars, int len = %d)", len);
     for (int i = 0; i < len; i++) {
         uchar ch = chars[i];
@@ -180,14 +183,16 @@ QString QGb18030Codec::convertToUnicode(const char* chars, int len, ConverterSta
         case 0:
             if (ch < 0x80) {
                 // ASCII
-                result += QLatin1Char(ch);
+                resultData[unicodeLen] = ch;
+                ++unicodeLen;
             } else if (Is1stByte(ch)) {
                 // GB18030?
                 buf[0] = ch;
                 nbuf = 1;
             } else {
                 // Invalid
-                result += replacement;
+                resultData[unicodeLen] = replacement;
+                ++unicodeLen;
                 ++invalid;
             }
             break;
@@ -198,9 +203,11 @@ QString QGb18030Codec::convertToUnicode(const char* chars, int len, ConverterSta
                 int clen = 2;
                 uint u = qt_Gb18030ToUnicode(buf, clen);
                 if (clen == 2) {
-                    result += QValidChar(u);
+                    resultData[unicodeLen] = qValidChar(static_cast<ushort>(u));
+                    ++unicodeLen;
                 } else {
-                    result += replacement;
+                    resultData[unicodeLen] = replacement;
+                    ++unicodeLen;
                     ++invalid;
                 }
                 nbuf = 0;
@@ -209,7 +216,8 @@ QString QGb18030Codec::convertToUnicode(const char* chars, int len, ConverterSta
                 nbuf = 2;
             } else {
                 // Error
-                result += replacement;
+                resultData[unicodeLen] = replacement;
+                ++unicodeLen;
                 ++invalid;
                 nbuf = 0;
             }
@@ -220,7 +228,8 @@ QString QGb18030Codec::convertToUnicode(const char* chars, int len, ConverterSta
                 buf[2] = ch;
                 nbuf = 3;
             } else {
-                result += replacement;
+                resultData[unicodeLen] = replacement;
+                ++unicodeLen;
                 ++invalid;
                 nbuf = 0;
             }
@@ -232,19 +241,24 @@ QString QGb18030Codec::convertToUnicode(const char* chars, int len, ConverterSta
                 int clen = 4;
                 uint u = qt_Gb18030ToUnicode(buf, clen);
                 if (clen == 4) {
-                    result += QValidChar(u);
+                    resultData[unicodeLen] = qValidChar(u);
+                    ++unicodeLen;
                 } else {
-                    result += replacement;
+                    resultData[unicodeLen] = replacement;
+                    ++unicodeLen;
                     ++invalid;
                 }
             } else {
-                result += replacement;
+                resultData[unicodeLen] = replacement;
+                ++unicodeLen;
                 ++invalid;
             }
             nbuf = 0;
             break;
         }
     }
+    result.resize(unicodeLen);
+
     if (state) {
         state->remainingChars = nbuf;
         state->state_data[0] = (buf[0] << 24) + (buf[1] << 16) + (buf[2] << 8) + buf[3];
@@ -342,7 +356,7 @@ QString QGbkCodec::convertToUnicode(const char* chars, int len, ConverterState *
                 int clen = 2;
                 uint u = qt_Gb18030ToUnicode(buf, clen);
                 if (clen == 2) {
-                    result += QValidChar(u);
+                    result += qValidChar(u);
                 } else {
                     result += replacement;
                     ++invalid;
@@ -445,7 +459,7 @@ QString QGb2312Codec::convertToUnicode(const char* chars, int len, ConverterStat
 {
     uchar buf[2];
     int nbuf = 0;
-    QChar replacement = QChar::ReplacementCharacter;
+    ushort replacement = QChar::ReplacementCharacter;
     if (state) {
         if (state->flags & ConvertInvalidToNull)
             replacement = QChar::Null;
@@ -456,6 +470,9 @@ QString QGb2312Codec::convertToUnicode(const char* chars, int len, ConverterStat
     int invalid = 0;
 
     QString result;
+    result.resize(len);
+    int unicodeLen = 0;
+    ushort *const resultData = reinterpret_cast<ushort*>(result.data());
     //qDebug("QGb2312Decoder::toUnicode(const char* chars, int len = %d)", len);
     for (int i=0; i<len; i++) {
         uchar ch = chars[i];
@@ -463,14 +480,16 @@ QString QGb2312Codec::convertToUnicode(const char* chars, int len, ConverterStat
         case 0:
             if (ch < 0x80) {
                 // ASCII
-                result += QLatin1Char(ch);
+                resultData[unicodeLen] = ch;
+                ++unicodeLen;
             } else if (IsByteInGb2312(ch)) {
                 // GB2312 1st byte?
                 buf[0] = ch;
                 nbuf = 1;
             } else {
                 // Invalid
-                result += replacement;
+                resultData[unicodeLen] = replacement;
+                ++unicodeLen;
                 ++invalid;
             }
             break;
@@ -481,21 +500,25 @@ QString QGb2312Codec::convertToUnicode(const char* chars, int len, ConverterStat
                 int clen = 2;
                 uint u = qt_Gb18030ToUnicode(buf, clen);
                 if (clen == 2) {
-                    result += QValidChar(u);
+                    resultData[unicodeLen] = qValidChar(static_cast<ushort>(u));
+                    ++unicodeLen;
                 } else {
-                    result += replacement;
+                    resultData[unicodeLen] = replacement;
+                    ++unicodeLen;
                     ++invalid;
                 }
                 nbuf = 0;
             } else {
                 // Error
-                result += replacement;
+                resultData[unicodeLen] = replacement;
+                ++unicodeLen;
                 ++invalid;
                 nbuf = 0;
             }
             break;
         }
     }
+    result.resize(unicodeLen);
 
     if (state) {
         state->remainingChars = nbuf;
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
index b76c6a7..e4a0135 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.cpp
@@ -175,7 +175,7 @@ enum PaintOperation {
     DRAW_PATH = 0x0040, DRAW_POINTS = 0x0080, DRAW_ELLIPSE = 0x0100,
     DRAW_POLYGON = 0x0200, DRAW_TEXT = 0x0400, FILL_PATH = 0x0800,
     FILL_RECT = 0x1000, DRAW_COLORSPANS = 0x2000, DRAW_ROUNDED_RECT = 0x4000,
-    ALL = 0xffff
+    DRAW_STATICTEXT = 0x8000, ALL = 0xffff
 };
 
 #ifdef QT_DEBUG
@@ -797,6 +797,14 @@ void QDirectFBPaintEngine::drawRoundedRect(const QRectF &rect, qreal xrad, qreal
     QRasterPaintEngine::drawRoundedRect(rect, xrad, yrad, mode);
 }
 
+void QDirectFBPaintEngine::drawStaticTextItem(QStaticTextItem *item)
+{
+    RASTERFALLBACK(DRAW_STATICTEXT, item, VOID_ARG(), VOID_ARG());
+    Q_D(QDirectFBPaintEngine);
+    d->lock();
+    QRasterPaintEngine::drawStaticTextItem(item);
+}
+
 void QDirectFBPaintEngine::fillRect(const QRectF &rect, const QBrush &brush)
 {
     Q_D(QDirectFBPaintEngine);
diff --git a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
index 64609d7..19e8b84 100644
--- a/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
+++ b/src/plugins/gfxdrivers/directfb/qdirectfbpaintengine.h
@@ -109,6 +109,8 @@ public:
     virtual void clip(const QRegion &region, Qt::ClipOperation op);
     virtual void clip(const QRect &rect, Qt::ClipOperation op);
 
+    virtual void drawStaticTextItem(QStaticTextItem *item);
+
     static void initImageCache(int size);
 };
 
diff --git a/src/plugins/graphicssystems/opengl/main.cpp b/src/plugins/graphicssystems/opengl/main.cpp
index 19631b6..abcfb7f 100644
--- a/src/plugins/graphicssystems/opengl/main.cpp
+++ b/src/plugins/graphicssystems/opengl/main.cpp
@@ -56,7 +56,7 @@ QStringList QGLGraphicsSystemPlugin::keys() const
 {
     QStringList list;
     list << QLatin1String("OpenGL") << QLatin1String("OpenGL1");
-#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
     list << QLatin1String("OpenGL2");
 #endif
     return list;
@@ -69,7 +69,7 @@ QGraphicsSystem* QGLGraphicsSystemPlugin::create(const QString& system)
         return new QGLGraphicsSystem;
     }
 
-#if !defined(QT_OPENGL_ES_1) && !defined(QT_OPENGL_ES_1_CL)
+#if !defined(QT_OPENGL_ES_1)
     if (system.toLower() == QLatin1String("opengl2")) {
         QGL::setPreferredPaintEngine(QPaintEngine::OpenGL2);
         return new QGLGraphicsSystem;
diff --git a/src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp b/src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp
index 13044f4..6bf9d6b 100644
--- a/src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp
+++ b/src/plugins/graphicssystems/trace/qgraphicssystem_trace.cpp
@@ -82,8 +82,13 @@ QTraceWindowSurface::~QTraceWindowSurface()
         QFile outputFile(QString(QLatin1String("qtgraphics-%0.trace")).arg(winId));
         if (outputFile.open(QIODevice::WriteOnly)) {
             QDataStream out(&outputFile);
-            out.writeBytes("qttrace", 7);
-            out << *buffer << updates;
+            out.setFloatingPointPrecision(QDataStream::SinglePrecision);
+
+            out.writeBytes("qttraceV2", 9);
+
+            uint version = 1;
+
+            out << version << *buffer << updates;
         }
         delete buffer;
     }
diff --git a/src/plugins/graphicssystems/trace/trace.pro b/src/plugins/graphicssystems/trace/trace.pro
index d548a6c..07472e2 100644
--- a/src/plugins/graphicssystems/trace/trace.pro
+++ b/src/plugins/graphicssystems/trace/trace.pro
@@ -4,6 +4,7 @@ include(../../qpluginbase.pri)
 QT += network
 
 QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/graphicssystems
+symbian:TARGET.UID3 = 0x2002130E
 
 SOURCES = main.cpp qgraphicssystem_trace.cpp
 
diff --git a/src/plugins/imageformats/ico/qicohandler.cpp b/src/plugins/imageformats/ico/qicohandler.cpp
index 4edb87a..032ff85 100644
--- a/src/plugins/imageformats/ico/qicohandler.cpp
+++ b/src/plugins/imageformats/ico/qicohandler.cpp
@@ -54,6 +54,9 @@
 #include <QtCore/QFile>
 #include <QtCore/QBuffer>
 #include <qvariant.h>
+
+QT_BEGIN_NAMESPACE
+
 // These next two structs represent how the icon information is stored
 // in an ICO file.
 typedef struct
@@ -891,3 +894,4 @@ bool QtIcoHandler::jumpToNextImage()
     return jumpToImage(m_currentIconIndex + 1);
 }
 
+QT_END_NAMESPACE
diff --git a/src/plugins/imageformats/ico/qicohandler.h b/src/plugins/imageformats/ico/qicohandler.h
index 394a5eb..4334ad9 100644
--- a/src/plugins/imageformats/ico/qicohandler.h
+++ b/src/plugins/imageformats/ico/qicohandler.h
@@ -43,6 +43,8 @@
 
 #include <QtGui/QImageIOHandler>
 
+QT_BEGIN_NAMESPACE
+
 class ICOReader;
 class QtIcoHandler: public QImageIOHandler
 {
@@ -71,5 +73,7 @@ private:
 
 };
 
+QT_END_NAMESPACE
+
 #endif /* QTICOHANDLER_H */
 
diff --git a/src/plugins/imageformats/jpeg/jpeg.pro b/src/plugins/imageformats/jpeg/jpeg.pro
index ebc79cc..5b45422 100644
--- a/src/plugins/imageformats/jpeg/jpeg.pro
+++ b/src/plugins/imageformats/jpeg/jpeg.pro
@@ -13,10 +13,12 @@ wince*: {
 	contains(CE_ARCH,x86):CONFIG += exceptions_off
 }
 
+#Disable warnings in 3rdparty code due to unused arguments
 symbian: {
-        #Disable warnings in 3rdparty code due to unused arguments
         QMAKE_CXXFLAGS.CW += -W nounusedarg
         TARGET.UID3=0x2001E61B
+} else:contains(QMAKE_CC, gcc): {
+	QMAKE_CFLAGS_WARN_ON += -Wno-unused-parameter -Wno-main
 }
 
 contains(QT_CONFIG, system-jpeg) {
@@ -26,8 +28,10 @@ contains(QT_CONFIG, system-jpeg) {
 !contains(QT_CONFIG, system-jpeg) {
 	INCLUDEPATH += ../../../3rdparty/libjpeg
 	SOURCES  += \
+	    ../../../3rdparty/libjpeg/jaricom.c \
 	    ../../../3rdparty/libjpeg/jcapimin.c \
 	    ../../../3rdparty/libjpeg/jcapistd.c \
+	    ../../../3rdparty/libjpeg/jcarith.c \
 	    ../../../3rdparty/libjpeg/jccoefct.c \
 	    ../../../3rdparty/libjpeg/jccolor.c \
 	    ../../../3rdparty/libjpeg/jcdctmgr.c \
@@ -38,12 +42,12 @@ contains(QT_CONFIG, system-jpeg) {
 	    ../../../3rdparty/libjpeg/jcmaster.c \
 	    ../../../3rdparty/libjpeg/jcomapi.c \
 	    ../../../3rdparty/libjpeg/jcparam.c \
-	    ../../../3rdparty/libjpeg/jcphuff.c \
 	    ../../../3rdparty/libjpeg/jcprepct.c \
 	    ../../../3rdparty/libjpeg/jcsample.c \
 	    ../../../3rdparty/libjpeg/jctrans.c \
 	    ../../../3rdparty/libjpeg/jdapimin.c \
 	    ../../../3rdparty/libjpeg/jdapistd.c \
+	    ../../../3rdparty/libjpeg/jdarith.c \
 	    ../../../3rdparty/libjpeg/jdatadst.c \
 	    ../../../3rdparty/libjpeg/jdatasrc.c \
 	    ../../../3rdparty/libjpeg/jdcoefct.c \
@@ -55,7 +59,6 @@ contains(QT_CONFIG, system-jpeg) {
 	    ../../../3rdparty/libjpeg/jdmarker.c \
 	    ../../../3rdparty/libjpeg/jdmaster.c \
 	    ../../../3rdparty/libjpeg/jdmerge.c \
-	    ../../../3rdparty/libjpeg/jdphuff.c \
 	    ../../../3rdparty/libjpeg/jdpostct.c \
 	    ../../../3rdparty/libjpeg/jdsample.c \
 	    ../../../3rdparty/libjpeg/jdtrans.c \
@@ -66,11 +69,10 @@ contains(QT_CONFIG, system-jpeg) {
 	    ../../../3rdparty/libjpeg/jidctflt.c \
 	    ../../../3rdparty/libjpeg/jidctfst.c \
 	    ../../../3rdparty/libjpeg/jidctint.c \
-	    ../../../3rdparty/libjpeg/jidctred.c \
-	    ../../../3rdparty/libjpeg/jmemmgr.c \
 	    ../../../3rdparty/libjpeg/jquant1.c \
 	    ../../../3rdparty/libjpeg/jquant2.c \
 	    ../../../3rdparty/libjpeg/jutils.c \
+	    ../../../3rdparty/libjpeg/jmemmgr.c \
 	    ../../../3rdparty/libjpeg/jmemnobs.c
 }
 
diff --git a/src/plugins/imageformats/jpeg/qjpeghandler.cpp b/src/plugins/imageformats/jpeg/qjpeghandler.cpp
index 98bd88f..93b7cc6 100644
--- a/src/plugins/imageformats/jpeg/qjpeghandler.cpp
+++ b/src/plugins/imageformats/jpeg/qjpeghandler.cpp
@@ -52,8 +52,6 @@
 #undef FAR
 #endif
 
-// hw: optimize smoothscaler for returning 24-bit images
-
 // including jpeglib.h seems to be a little messy
 extern "C" {
 // mingw includes rpcndr.h but does not define boolean
@@ -76,433 +74,6 @@ extern "C" {
 
 QT_BEGIN_NAMESPACE
 
-//#define QT_NO_IMAGE_SMOOTHSCALE
-#ifndef QT_NO_IMAGE_SMOOTHSCALE
-class QImageSmoothScalerPrivate;
-class QImageSmoothScaler
-{
-public:
-    QImageSmoothScaler(const int w, const int h, const QImage &src);
-    QImageSmoothScaler(const int srcWidth, const int srcHeight,
-                       const int dstWidth, const int dstHeight);
-
-    virtual ~QImageSmoothScaler(void);
-
-    QImage  scale();
-
-private:
-    QImageSmoothScalerPrivate	*d;
-    virtual QRgb *scanLine(const int line = 0, const QImage *src = 0);
-};
-
-class QImageSmoothScalerPrivate
-{
-public:
-    int	    cols;
-    int	    newcols;
-    int	    rows;
-    int	    newrows;
-    bool    hasAlpha;
-
-    const QImage  *src;
-
-    void setup(const int srcWidth, const int srcHeight, const int dstWidth,
-               const int dstHeight, bool hasAlphaChannel);
-};
-
-QImageSmoothScaler::QImageSmoothScaler(const int w, const int h,
-                                       const QImage &src)
-{
-    d = new QImageSmoothScalerPrivate;
-
-    d->setup(src.width(), src.height(), w, h, src.hasAlphaChannel() );
-    this->d->src = &src;
-}
-
-QImageSmoothScaler::QImageSmoothScaler(const int srcWidth, const int srcHeight,
-                                       const int dstWidth, const int dstHeight)
-{
-    d = new QImageSmoothScalerPrivate;
-    d->setup(srcWidth, srcHeight, dstWidth, dstHeight, 0);
-}
-
-void QImageSmoothScalerPrivate::setup(const int srcWidth, const int srcHeight,
-                                      const int dstWidth, const int dstHeight,
-                                      bool hasAlphaChannel)
-{
-    cols = srcWidth;
-    rows = srcHeight;
-    newcols = dstWidth;
-    newrows = dstHeight;
-    hasAlpha = hasAlphaChannel;
-}
-
-QImageSmoothScaler::~QImageSmoothScaler()
-{
-    delete d;
-}
-
-inline QRgb *QImageSmoothScaler::scanLine(const int line, const QImage *src)
-{
-    return (QRgb*)src->scanLine(line);
-}
-
-/*
-  This function uses code based on pnmscale.c by Jef Poskanzer.
-
-  pnmscale.c - read a portable anymap and scale it
-
-  Copyright (C) 1989, 1991 by Jef Poskanzer.
-
-  Permission to use, copy, modify, and distribute this software and its
-  documentation for any purpose and without fee is hereby granted, provided
-  that the above copyright notice appear in all copies and that both that
-  copyright notice and this permission notice appear in supporting
-  documentation.  This software is provided "as is" without express or
-  implied warranty.
-*/
-
-QImage QImageSmoothScaler::scale()
-{
-    long SCALE;
-    long HALFSCALE;
-    QRgb *xelrow = 0;
-    QRgb *tempxelrow = 0;
-    QRgb *xP;
-    QRgb *nxP;
-    int row, rowsread;
-    int col, needtoreadrow;
-    uchar maxval = 255;
-    qreal xscale, yscale;
-    long sxscale, syscale;
-    long fracrowtofill, fracrowleft;
-    long *as;
-    long *rs;
-    long *gs;
-    long *bs;
-    int rowswritten = 0;
-    QImage dst;
-
-    if (d->cols > 4096) {
-        SCALE = 4096;
-        HALFSCALE = 2048;
-    } else {
-        int fac = 4096;
-        while (d->cols * fac > 4096)
-            fac /= 2;
-
-        SCALE = fac * d->cols;
-        HALFSCALE = fac * d->cols / 2;
-    }
-
-    xscale = (qreal)d->newcols / (qreal)d->cols;
-    yscale = (qreal)d->newrows / (qreal)d->rows;
-    sxscale = (long)(xscale * SCALE);
-    syscale = (long)(yscale * SCALE);
-
-    // shortcut Y scaling if possible
-    if (d->newrows != d->rows)
-        tempxelrow = new QRgb[d->cols];
-
-    if (d->hasAlpha) {
-        as = new long[d->cols];
-        for (col = 0; col < d->cols; ++col)
-            as[col] = HALFSCALE;
-    } else {
-        as = 0;
-    }
-    rs = new long[d->cols];
-    gs = new long[d->cols];
-    bs = new long[d->cols];
-    rowsread = 0;
-    fracrowleft = syscale;
-    needtoreadrow = 1;
-    for (col = 0; col < d->cols; ++col)
-        rs[col] = gs[col] = bs[col] = HALFSCALE;
-    fracrowtofill = SCALE;
-
-    dst = QImage(d->newcols, d->newrows, d->hasAlpha ? QImage::Format_ARGB32 : QImage::Format_RGB32);
-
-    for (row = 0; row < d->newrows; ++row) {
-        // First scale Y from xelrow into tempxelrow.
-        if (d->newrows == d->rows) {
-            // shortcut Y scaling if possible
-            tempxelrow = xelrow = scanLine(rowsread++, d->src);
-        } else {
-            while (fracrowleft < fracrowtofill) {
-                if (needtoreadrow && rowsread < d->rows)
-                    xelrow = scanLine(rowsread++, d->src);
-                for (col = 0, xP = xelrow; col < d->cols; ++col, ++xP) {
-                    if (as) {
-                        as[col] += fracrowleft * qAlpha(*xP);
-                        rs[col] += fracrowleft * qRed(*xP) * qAlpha(*xP) / 255;
-                        gs[col] += fracrowleft * qGreen(*xP) * qAlpha(*xP) / 255;
-                        bs[col] += fracrowleft * qBlue(*xP) * qAlpha(*xP) / 255;
-                    } else {
-                        rs[col] += fracrowleft * qRed(*xP);
-                        gs[col] += fracrowleft * qGreen(*xP);
-                        bs[col] += fracrowleft * qBlue(*xP);
-                    }
-                }
-                fracrowtofill -= fracrowleft;
-                fracrowleft = syscale;
-                needtoreadrow = 1;
-            }
-            // Now fracrowleft is >= fracrowtofill, so we can produce a row.
-            if (needtoreadrow && rowsread < d->rows) {
-                xelrow = scanLine(rowsread++, d->src);
-                needtoreadrow = 0;
-            }
-            for (col = 0, xP = xelrow, nxP = tempxelrow; col < d->cols; ++col, ++xP, ++nxP) {
-                register long a, r, g, b;
-
-                if (as) {
-                    r = rs[col] + fracrowtofill * qRed(*xP) * qAlpha(*xP) / 255;
-                    g = gs[col] + fracrowtofill * qGreen(*xP) * qAlpha(*xP) / 255;
-                    b = bs[col] + fracrowtofill * qBlue(*xP) * qAlpha(*xP) / 255;
-                    a = as[col] + fracrowtofill * qAlpha(*xP);
-                    if (a) {
-                        r = r * 255 / a * SCALE;
-                        g = g * 255 / a * SCALE;
-                        b = b * 255 / a * SCALE;
-                    }
-                } else {
-                    r = rs[col] + fracrowtofill * qRed(*xP);
-                    g = gs[col] + fracrowtofill * qGreen(*xP);
-                    b = bs[col] + fracrowtofill * qBlue(*xP);
-                    a = 0; // unwarn
-                }
-                r /= SCALE;
-                if (r > maxval)
-                    r = maxval;
-                g /= SCALE;
-                if (g > maxval)
-                    g = maxval;
-                b /= SCALE;
-                if (b > maxval)
-                    b = maxval;
-                if (as) {
-                    a /= SCALE;
-                    if (a > maxval)
-                        a = maxval;
-                    *nxP = qRgba((int)r, (int)g, (int)b, (int)a);
-                    as[col] = HALFSCALE;
-                } else {
-                    *nxP = qRgb((int)r, (int)g, (int)b);
-                }
-                rs[col] = gs[col] = bs[col] = HALFSCALE;
-            }
-            fracrowleft -= fracrowtofill;
-            if (fracrowleft == 0) {
-                fracrowleft = syscale;
-                needtoreadrow = 1;
-            }
-            fracrowtofill = SCALE;
-        }
-
-        // Now scale X from tempxelrow into dst and write it out.
-        if (d->newcols == d->cols) {
-            // shortcut X scaling if possible
-            memcpy(dst.scanLine(rowswritten++), tempxelrow, d->newcols * 4);
-        } else {
-            register long a, r, g, b;
-            register long fraccoltofill, fraccolleft = 0;
-            register int needcol;
-
-            nxP = (QRgb *)dst.scanLine(rowswritten++);
-            QRgb *nxPEnd = nxP + d->newcols;
-            fraccoltofill = SCALE;
-            a = r = g = b = HALFSCALE;
-            needcol = 0;
-            for (col = 0, xP = tempxelrow; col < d->cols; ++col, ++xP) {
-                fraccolleft = sxscale;
-                while (fraccolleft >= fraccoltofill) {
-                    if (needcol) {
-                        ++nxP;
-                        a = r = g = b = HALFSCALE;
-                    }
-                    if (as) {
-                        r += fraccoltofill * qRed(*xP) * qAlpha(*xP) / 255;
-                        g += fraccoltofill * qGreen(*xP) * qAlpha(*xP) / 255;
-                        b += fraccoltofill * qBlue(*xP) * qAlpha(*xP) / 255;
-                        a += fraccoltofill * qAlpha(*xP);
-                        if (a) {
-                            r = r * 255 / a * SCALE;
-                            g = g * 255 / a * SCALE;
-                            b = b * 255 / a * SCALE;
-                        }
-                    } else {
-                        r += fraccoltofill * qRed(*xP);
-                        g += fraccoltofill * qGreen(*xP);
-                        b += fraccoltofill * qBlue(*xP);
-                    }
-                    r /= SCALE;
-                    if (r > maxval)
-                        r = maxval;
-                    g /= SCALE;
-                    if (g > maxval)
-                        g = maxval;
-                    b /= SCALE;
-                    if (b > maxval)
-                        b = maxval;
-                    if (as) {
-                        a /= SCALE;
-                        if (a > maxval)
-                            a = maxval;
-                        *nxP = qRgba((int)r, (int)g, (int)b, (int)a);
-                    } else {
-                        *nxP = qRgb((int)r, (int)g, (int)b);
-                    }
-                    fraccolleft -= fraccoltofill;
-                    fraccoltofill = SCALE;
-                    needcol = 1;
-                }
-                if (fraccolleft > 0) {
-                    if (needcol) {
-                        ++nxP;
-                        a = r = g = b = HALFSCALE;
-                        needcol = 0;
-                    }
-                    if (as) {
-                        a += fraccolleft * qAlpha(*xP);
-                        r += fraccolleft * qRed(*xP) * qAlpha(*xP) / 255;
-                        g += fraccolleft * qGreen(*xP) * qAlpha(*xP) / 255;
-                        b += fraccolleft * qBlue(*xP) * qAlpha(*xP) / 255;
-                    } else {
-                        r += fraccolleft * qRed(*xP);
-                        g += fraccolleft * qGreen(*xP);
-                        b += fraccolleft * qBlue(*xP);
-                    }
-                    fraccoltofill -= fraccolleft;
-                }
-            }
-            if (fraccoltofill > 0) {
-                --xP;
-                if (as) {
-                    a += fraccolleft * qAlpha(*xP);
-                    r += fraccoltofill * qRed(*xP) * qAlpha(*xP) / 255;
-                    g += fraccoltofill * qGreen(*xP) * qAlpha(*xP) / 255;
-                    b += fraccoltofill * qBlue(*xP) * qAlpha(*xP) / 255;
-                    if (a) {
-                        r = r * 255 / a * SCALE;
-                        g = g * 255 / a * SCALE;
-                        b = b * 255 / a * SCALE;
-                    }
-                } else {
-                    r += fraccoltofill * qRed(*xP);
-                    g += fraccoltofill * qGreen(*xP);
-                    b += fraccoltofill * qBlue(*xP);
-                }
-            }
-            if (nxP < nxPEnd) {
-                r /= SCALE;
-                if (r > maxval)
-                    r = maxval;
-                g /= SCALE;
-                if (g > maxval)
-                    g = maxval;
-                b /= SCALE;
-                if (b > maxval)
-                    b = maxval;
-                if (as) {
-                    a /= SCALE;
-                    if (a > maxval)
-                        a = maxval;
-                    *nxP = qRgba((int)r, (int)g, (int)b, (int)a);
-                } else {
-                    *nxP = qRgb((int)r, (int)g, (int)b);
-                }
-                while (++nxP != nxPEnd)
-                    nxP[0] = nxP[-1];
-            }
-        }
-    }
-
-    if (d->newrows != d->rows && tempxelrow)// Robust, tempxelrow might be 0 1 day
-        delete [] tempxelrow;
-    if (as)				// Avoid purify complaint
-        delete [] as;
-    if (rs)				// Robust, rs might be 0 one day
-        delete [] rs;
-    if (gs)				// Robust, gs might be 0 one day
-        delete [] gs;
-    if (bs)				// Robust, bs might be 0 one day
-        delete [] bs;
-
-    return dst;
-}
-
-class jpegSmoothScaler : public QImageSmoothScaler
-{
-public:
-    jpegSmoothScaler(struct jpeg_decompress_struct *info, const QSize& dstSize, const QRect& clipRect)
-        : QImageSmoothScaler(clipRect.width(), clipRect.height(),
-                             dstSize.width(), dstSize.height())
-    {
-        cinfo = info;
-        clip = clipRect;
-        imageCache = QImage(info->output_width, 1, QImage::Format_RGB32);
-    }
-
-private:
-    QRect   clip;
-    QImage  imageCache;
-    struct jpeg_decompress_struct *cinfo;
-
-    QRgb *scanLine(const int line = 0, const QImage *src = 0)
-    {
-	QRgb    *out;
-	uchar	*in;
-
-	Q_UNUSED(line);
-	Q_UNUSED(src);
-
-        uchar* data = imageCache.bits();
-
-        // Read ahead if we haven't reached the first clipped scanline yet.
-        while (int(cinfo->output_scanline) < clip.y() &&
-               cinfo->output_scanline < cinfo->output_height)
-	    jpeg_read_scanlines(cinfo, &data, 1);
-
-        // Read the next scanline.  We assume that "line"
-        // will never be >= clip.height().
-	jpeg_read_scanlines(cinfo, &data, 1);
-        if (cinfo->output_scanline == cinfo->output_height)
-            jpeg_finish_decompress(cinfo);
-
-	out = ((QRgb*)data) + clip.x();
-
-	//
-	// The smooth scale algorithm only works on 32-bit images;
-	// convert from (8|24) bits to 32.
-	//
-	if (cinfo->output_components == 1) {
-	    in = data + clip.right();
-	    for (int i = clip.width(); i--; ) {
-		out[i] = qRgb(*in, *in, *in);
-		in--;
-	    }
-        } else if (cinfo->out_color_space == JCS_CMYK) {
-            in = data + clip.right() * 4;
-            for (int i = clip.width(); i--; ) {
-                int k = in[3];
-                out[i] = qRgb(k * in[0] / 255, k * in[1] / 255, k * in[2] / 255);
-                in -= 4;
-            }
-        } else {
-	    in = data + clip.right() * 3;
-	    for (int i = clip.width(); i--; ) {
-		out[i] = qRgb(in[0], in[1], in[2]);
-		in -= 3;
-	    }
-	}
-
-	return out;
-    }
-
-};
-#endif
-
 struct my_error_mgr : public jpeg_error_mgr {
     jmp_buf setjmp_buffer;
 };
@@ -612,82 +183,34 @@ inline my_jpeg_source_mgr::my_jpeg_source_mgr(QIODevice *device)
 }
 
 
-static bool read_jpeg_size(QIODevice *device, int &w, int &h)
+inline static bool read_jpeg_size(int &w, int &h, j_decompress_ptr cinfo)
 {
-    bool rt = false;
-    struct jpeg_decompress_struct cinfo;
-
-    struct my_jpeg_source_mgr *iod_src = new my_jpeg_source_mgr(device);
-    struct my_error_mgr jerr;
-
-    jpeg_create_decompress(&cinfo);
-
-    cinfo.src = iod_src;
-
-    cinfo.err = jpeg_std_error(&jerr);
-    jerr.error_exit = my_error_exit;
-
-    if (!setjmp(jerr.setjmp_buffer)) {
-#if defined(Q_OS_UNIXWARE)
-        (void) jpeg_read_header(&cinfo, B_TRUE);
-#else
-        (void) jpeg_read_header(&cinfo, true);
-#endif
-        (void) jpeg_calc_output_dimensions(&cinfo);
+    (void) jpeg_calc_output_dimensions(cinfo);
 
-        w = cinfo.output_width;
-        h = cinfo.output_height;
-        rt = true;
-    }
-    jpeg_destroy_decompress(&cinfo);
-    delete iod_src;
-    return rt;
+    w = cinfo->output_width;
+    h = cinfo->output_height;
+    return true;
 }
 
 #define HIGH_QUALITY_THRESHOLD 50
 
-static bool read_jpeg_format(QIODevice *device, QImage::Format &format)
+inline static bool read_jpeg_format(QImage::Format &format, j_decompress_ptr cinfo)
 {
-    bool result = false;
-    struct jpeg_decompress_struct cinfo;
-
-    struct my_jpeg_source_mgr *iod_src = new my_jpeg_source_mgr(device);
-    struct my_error_mgr jerr;
-
-    jpeg_create_decompress(&cinfo);
-
-    cinfo.src = iod_src;
-
-    cinfo.err = jpeg_std_error(&jerr);
-    jerr.error_exit = my_error_exit;
 
-    if (!setjmp(jerr.setjmp_buffer)) {
-#if defined(Q_OS_UNIXWARE)
-        (void) jpeg_read_header(&cinfo, B_TRUE);
-#else
-        (void) jpeg_read_header(&cinfo, true);
-#endif
-        // This does not allocate memory for the whole image
-        // or such, so we are safe.
-        (void) jpeg_start_decompress(&cinfo);
-        result = true;
-        switch (cinfo.output_components) {
-        case 1:
-            format = QImage::Format_Indexed8;
-            break;
-        case 3:
-        case 4:
-            format = QImage::Format_RGB32;
-            break;
-        default:
-            result = false;
-            break;
-        }
-        cinfo.output_scanline = cinfo.output_height;
-        (void) jpeg_finish_decompress(&cinfo);
+    bool result = true;
+    switch (cinfo->output_components) {
+    case 1:
+        format = QImage::Format_Indexed8;
+        break;
+    case 3:
+    case 4:
+        format = QImage::Format_RGB32;
+        break;
+    default:
+        result = false;
+        break;
     }
-    jpeg_destroy_decompress(&cinfo);
-    delete iod_src;
+    cinfo->output_scanline = cinfo->output_height;
     return result;
 }
 
@@ -720,29 +243,11 @@ static bool ensureValidImage(QImage *dest, struct jpeg_decompress_struct *info,
     return !dest->isNull();
 }
 
-static bool read_jpeg_image(QIODevice *device, QImage *outImage,
+static bool read_jpeg_image(QImage *outImage,
                             QSize scaledSize, QRect scaledClipRect,
-                            QRect clipRect, int inQuality )
+                            QRect clipRect, int inQuality, j_decompress_ptr info, struct my_error_mgr* err  )
 {
-    struct jpeg_decompress_struct cinfo;
-
-    struct my_jpeg_source_mgr *iod_src = new my_jpeg_source_mgr(device);
-    struct my_error_mgr jerr;
-
-    jpeg_create_decompress(&cinfo);
-
-    cinfo.src = iod_src;
-
-    cinfo.err = jpeg_std_error(&jerr);
-    jerr.error_exit = my_error_exit;
-
-    if (!setjmp(jerr.setjmp_buffer)) {
-#if defined(Q_OS_UNIXWARE)
-        (void) jpeg_read_header(&cinfo, B_TRUE);
-#else
-        (void) jpeg_read_header(&cinfo, true);
-#endif
-
+    if (!setjmp(err->setjmp_buffer)) {
         // -1 means default quality.
         int quality = inQuality;
         if (quality < 0)
@@ -764,16 +269,16 @@ static bool read_jpeg_image(QIODevice *device, QImage *outImage,
             } else if (clipRect.isEmpty()) {
                 // No clipping, but scaling: if we can map back to an
                 // integer pixel boundary, then clip before scaling.
-                if ((cinfo.image_width % scaledSize.width()) == 0 &&
-                        (cinfo.image_height % scaledSize.height()) == 0) {
-                    int x = scaledClipRect.x() * cinfo.image_width /
+                if ((info->image_width % scaledSize.width()) == 0 &&
+                        (info->image_height % scaledSize.height()) == 0) {
+                    int x = scaledClipRect.x() * info->image_width /
                             scaledSize.width();
-                    int y = scaledClipRect.y() * cinfo.image_height /
+                    int y = scaledClipRect.y() * info->image_height /
                             scaledSize.height();
                     int width = (scaledClipRect.right() + 1) *
-                                cinfo.image_width / scaledSize.width() - x;
+                                info->image_width / scaledSize.width() - x;
                     int height = (scaledClipRect.bottom() + 1) *
-                                 cinfo.image_height / scaledSize.height() - y;
+                                 info->image_height / scaledSize.height() - y;
                     clipRect = QRect(x, y, width, height);
                     scaledSize = scaledClipRect.size();
                     scaledClipRect = QRect();
@@ -787,161 +292,149 @@ static bool read_jpeg_image(QIODevice *device, QImage *outImage,
         // Determine the scale factor to pass to libjpeg for quick downscaling.
         if (!scaledSize.isEmpty()) {
             if (clipRect.isEmpty()) {
-                cinfo.scale_denom =
-                    qMin(cinfo.image_width / scaledSize.width(),
-                         cinfo.image_height / scaledSize.height());
+                info->scale_denom =
+                    qMin(info->image_width / scaledSize.width(),
+                         info->image_height / scaledSize.height());
             } else {
-                cinfo.scale_denom =
+                info->scale_denom =
                     qMin(clipRect.width() / scaledSize.width(),
                          clipRect.height() / scaledSize.height());
             }
-            if (cinfo.scale_denom < 2) {
-                cinfo.scale_denom = 1;
-            } else if (cinfo.scale_denom < 4) {
-                cinfo.scale_denom = 2;
-            } else if (cinfo.scale_denom < 8) {
-                cinfo.scale_denom = 4;
+            if (info->scale_denom < 2) {
+                info->scale_denom = 1;
+            } else if (info->scale_denom < 4) {
+                info->scale_denom = 2;
+            } else if (info->scale_denom < 8) {
+                info->scale_denom = 4;
             } else {
-                cinfo.scale_denom = 8;
+                info->scale_denom = 8;
             }
-            cinfo.scale_num = 1;
+            info->scale_num = 1;
             if (!clipRect.isEmpty()) {
                 // Correct the scale factor so that we clip accurately.
                 // It is recommended that the clip rectangle be aligned
                 // on an 8-pixel boundary for best performance.
-                while (cinfo.scale_denom > 1 &&
-                       ((clipRect.x() % cinfo.scale_denom) != 0 ||
-                        (clipRect.y() % cinfo.scale_denom) != 0 ||
-                        (clipRect.width() % cinfo.scale_denom) != 0 ||
-                        (clipRect.height() % cinfo.scale_denom) != 0)) {
-                    cinfo.scale_denom /= 2;
+                while (info->scale_denom > 1 &&
+                       ((clipRect.x() % info->scale_denom) != 0 ||
+                        (clipRect.y() % info->scale_denom) != 0 ||
+                        (clipRect.width() % info->scale_denom) != 0 ||
+                        (clipRect.height() % info->scale_denom) != 0)) {
+                    info->scale_denom /= 2;
                 }
             }
         }
 
         // If high quality not required, use fast decompression
         if( quality < HIGH_QUALITY_THRESHOLD ) {
-            cinfo.dct_method = JDCT_IFAST;
-            cinfo.do_fancy_upsampling = FALSE;
+            info->dct_method = JDCT_IFAST;
+            info->do_fancy_upsampling = FALSE;
         }
 
-        (void) jpeg_calc_output_dimensions(&cinfo);
+        (void) jpeg_calc_output_dimensions(info);
 
         // Determine the clip region to extract.
-        QRect imageRect(0, 0, cinfo.output_width, cinfo.output_height);
+        QRect imageRect(0, 0, info->output_width, info->output_height);
         QRect clip;
         if (clipRect.isEmpty()) {
             clip = imageRect;
-        } else if (cinfo.scale_denom == 1) {
+        } else if (info->scale_denom == info->scale_num) {
             clip = clipRect.intersected(imageRect);
         } else {
             // The scale factor was corrected above to ensure that
             // we don't miss pixels when we scale the clip rectangle.
-            clip = QRect(clipRect.x() / int(cinfo.scale_denom),
-                         clipRect.y() / int(cinfo.scale_denom),
-                         clipRect.width() / int(cinfo.scale_denom),
-                         clipRect.height() / int(cinfo.scale_denom));
+            clip = QRect(clipRect.x() / int(info->scale_denom),
+                         clipRect.y() / int(info->scale_denom),
+                         clipRect.width() / int(info->scale_denom),
+                         clipRect.height() / int(info->scale_denom));
             clip = clip.intersected(imageRect);
         }
 
-#ifndef QT_NO_IMAGE_SMOOTHSCALE
-        if (scaledSize.isValid() && scaledSize != clip.size()
-            && quality >= HIGH_QUALITY_THRESHOLD) {
-
-            (void) jpeg_start_decompress(&cinfo);
-
-            jpegSmoothScaler scaler(&cinfo, scaledSize, clip);
-            *outImage = scaler.scale();
-        } else
-#endif
-        {
-            // Allocate memory for the clipped QImage.
-            if (!ensureValidImage(outImage, &cinfo, clip.size()))
-                longjmp(jerr.setjmp_buffer, 1);
-
-            // Avoid memcpy() overhead if grayscale with no clipping.
-            bool quickGray = (cinfo.output_components == 1 &&
-                              clip == imageRect);
-            if (!quickGray) {
-                // Ask the jpeg library to allocate a temporary row.
-                // The library will automatically delete it for us later.
-                // The libjpeg docs say we should do this before calling
-                // jpeg_start_decompress().  We can't use "new" here
-                // because we are inside the setjmp() block and an error
-                // in the jpeg input stream would cause a memory leak.
-                JSAMPARRAY rows = (cinfo.mem->alloc_sarray)
-                    ((j_common_ptr)&cinfo, JPOOL_IMAGE,
-                     cinfo.output_width * cinfo.output_components, 1);
-
-                (void) jpeg_start_decompress(&cinfo);
-
-                while (cinfo.output_scanline < cinfo.output_height) {
-                    int y = int(cinfo.output_scanline) - clip.y();
-                    if (y >= clip.height())
-                        break;      // We've read the entire clip region, so abort.
-
-                    (void) jpeg_read_scanlines(&cinfo, rows, 1);
-
-                    if (y < 0)
-                        continue;   // Haven't reached the starting line yet.
-
-                    if (cinfo.output_components == 3) {
-                        // Expand 24->32 bpp.
-                        uchar *in = rows[0] + clip.x() * 3;
-                        QRgb *out = (QRgb*)outImage->scanLine(y);
-                        for (int i = 0; i < clip.width(); ++i) {
-                            *out++ = qRgb(in[0], in[1], in[2]);
-                            in += 3;
-                        }
-                    } else if (cinfo.out_color_space == JCS_CMYK) {
-                        // Convert CMYK->RGB.
-                        uchar *in = rows[0] + clip.x() * 4;
-                        QRgb *out = (QRgb*)outImage->scanLine(y);
-                        for (int i = 0; i < clip.width(); ++i) {
-                            int k = in[3];
-                            *out++ = qRgb(k * in[0] / 255, k * in[1] / 255,
-                                          k * in[2] / 255);
-                            in += 4;
-                        }
-                    } else if (cinfo.output_components == 1) {
-                        // Grayscale.
-                        memcpy(outImage->scanLine(y),
-                               rows[0] + clip.x(), clip.width());
+        // Allocate memory for the clipped QImage.
+        if (!ensureValidImage(outImage, info, clip.size()))
+            longjmp(err->setjmp_buffer, 1);
+
+        // Avoid memcpy() overhead if grayscale with no clipping.
+        bool quickGray = (info->output_components == 1 &&
+                          clip == imageRect);
+        if (!quickGray) {
+            // Ask the jpeg library to allocate a temporary row.
+            // The library will automatically delete it for us later.
+            // The libjpeg docs say we should do this before calling
+            // jpeg_start_decompress().  We can't use "new" here
+            // because we are inside the setjmp() block and an error
+            // in the jpeg input stream would cause a memory leak.
+            JSAMPARRAY rows = (info->mem->alloc_sarray)
+                              ((j_common_ptr)info, JPOOL_IMAGE,
+                               info->output_width * info->output_components, 1);
+
+            (void) jpeg_start_decompress(info);
+
+            while (info->output_scanline < info->output_height) {
+                int y = int(info->output_scanline) - clip.y();
+                if (y >= clip.height())
+                    break;      // We've read the entire clip region, so abort.
+
+                (void) jpeg_read_scanlines(info, rows, 1);
+
+                if (y < 0)
+                    continue;   // Haven't reached the starting line yet.
+
+                if (info->output_components == 3) {
+                    // Expand 24->32 bpp.
+                    uchar *in = rows[0] + clip.x() * 3;
+                    QRgb *out = (QRgb*)outImage->scanLine(y);
+                    for (int i = 0; i < clip.width(); ++i) {
+                        *out++ = qRgb(in[0], in[1], in[2]);
+                        in += 3;
                     }
+                } else if (info->out_color_space == JCS_CMYK) {
+                    // Convert CMYK->RGB.
+                    uchar *in = rows[0] + clip.x() * 4;
+                    QRgb *out = (QRgb*)outImage->scanLine(y);
+                    for (int i = 0; i < clip.width(); ++i) {
+                        int k = in[3];
+                        *out++ = qRgb(k * in[0] / 255, k * in[1] / 255,
+                                      k * in[2] / 255);
+                        in += 4;
+                    }
+                } else if (info->output_components == 1) {
+                    // Grayscale.
+                    memcpy(outImage->scanLine(y),
+                           rows[0] + clip.x(), clip.width());
                 }
-            } else {
-                // Load unclipped grayscale data directly into the QImage.
-                (void) jpeg_start_decompress(&cinfo);
-                while (cinfo.output_scanline < cinfo.output_height) {
-                    uchar *row = outImage->scanLine(cinfo.output_scanline);
-                    (void) jpeg_read_scanlines(&cinfo, &row, 1);
-                }
             }
+        } else {
+            // Load unclipped grayscale data directly into the QImage.
+            (void) jpeg_start_decompress(info);
+            while (info->output_scanline < info->output_height) {
+                uchar *row = outImage->scanLine(info->output_scanline);
+                (void) jpeg_read_scanlines(info, &row, 1);
+            }
+        }
 
-            if (cinfo.output_scanline == cinfo.output_height)
-                (void) jpeg_finish_decompress(&cinfo);
+        if (info->output_scanline == info->output_height)
+            (void) jpeg_finish_decompress(info);
 
-            if (cinfo.density_unit == 1) {
-                outImage->setDotsPerMeterX(int(100. * cinfo.X_density / 2.54));
-                outImage->setDotsPerMeterY(int(100. * cinfo.Y_density / 2.54));
-            } else if (cinfo.density_unit == 2) {
-                outImage->setDotsPerMeterX(int(100. * cinfo.X_density));
-                outImage->setDotsPerMeterY(int(100. * cinfo.Y_density));
-            }
+        if (info->density_unit == 1) {
+            outImage->setDotsPerMeterX(int(100. * info->X_density / 2.54));
+            outImage->setDotsPerMeterY(int(100. * info->Y_density / 2.54));
+        } else if (info->density_unit == 2) {
+            outImage->setDotsPerMeterX(int(100. * info->X_density));
+            outImage->setDotsPerMeterY(int(100. * info->Y_density));
+        }
 
-            if (scaledSize.isValid() && scaledSize != clip.size())
-                *outImage = outImage->scaled(scaledSize, Qt::IgnoreAspectRatio, Qt::FastTransformation);
+        if (scaledSize.isValid() && scaledSize != clip.size()) {
+            *outImage = outImage->scaled(scaledSize, Qt::IgnoreAspectRatio, quality >= HIGH_QUALITY_THRESHOLD ? Qt::SmoothTransformation : Qt::FastTransformation);
         }
-    }
 
-    jpeg_destroy_decompress(&cinfo);
-    delete iod_src;
-    if (!scaledClipRect.isEmpty())
-        *outImage = outImage->copy(scaledClipRect);
-    return !outImage->isNull();
+        if (!scaledClipRect.isEmpty())
+            *outImage = outImage->copy(scaledClipRect);
+        return !outImage->isNull();
+    }
+    else
+        return false;
 }
 
-
 struct my_jpeg_destination_mgr : public jpeg_destination_mgr {
     // Nothing dynamic - cannot rely on destruction over longjump
     QIODevice *device;
@@ -1002,11 +495,29 @@ inline my_jpeg_destination_mgr::my_jpeg_destination_mgr(QIODevice *device)
     free_in_buffer = max_buf;
 }
 
+static bool can_write_format(QImage::Format fmt)
+{
+    switch (fmt) {
+    case QImage::Format_Mono:
+    case QImage::Format_MonoLSB:
+    case QImage::Format_Indexed8:
+    case QImage::Format_RGB888:
+    case QImage::Format_RGB32:
+    case QImage::Format_ARGB32:
+    case QImage::Format_ARGB32_Premultiplied:
+        return true;
+        break;
+    default:
+        break;
+    }
+    return false;
+}
 
 static bool write_jpeg_image(const QImage &sourceImage, QIODevice *device, int sourceQuality)
 {
     bool success = false;
-    const QImage image = sourceImage;
+    const QImage image = can_write_format(sourceImage.format()) ?
+                         sourceImage : sourceImage.convertToFormat(QImage::Format_RGB888);
     const QVector<QRgb> cmap = image.colorTable();
 
     struct jpeg_compress_struct cinfo;
@@ -1167,18 +678,124 @@ static bool write_jpeg_image(const QImage &sourceImage, QIODevice *device, int s
     return success;
 }
 
+class QJpegHandlerPrivate
+{
+public:
+    enum State {
+        Ready,
+        ReadHeader,
+        Error
+    };
+
+    QJpegHandlerPrivate(QJpegHandler *qq)
+        : quality(75), iod_src(0), state(Ready), q(qq)
+    {}
+
+    ~QJpegHandlerPrivate()
+    {
+        if(iod_src)
+        {
+            jpeg_destroy_decompress(&info);
+            delete iod_src;
+            iod_src = 0;
+        }
+    }
+
+    bool readJpegHeader(QIODevice*);
+    bool read(QImage *image);
+
+    int quality;
+    QVariant size;
+    QImage::Format format;
+    QSize scaledSize;
+    QRect scaledClipRect;
+    QRect clipRect;
+    struct jpeg_decompress_struct info;
+    struct my_jpeg_source_mgr * iod_src;
+    struct my_error_mgr err;
+
+    State state;
+
+    QJpegHandler *q;
+};
+
+/*!
+    \internal
+*/
+bool QJpegHandlerPrivate::readJpegHeader(QIODevice *device)
+{
+    if(state == Ready)
+    {
+        state = Error;
+        iod_src = new my_jpeg_source_mgr(device);
+
+        jpeg_create_decompress(&info);
+        info.src = iod_src;
+        info.err = jpeg_std_error(&err);
+        err.error_exit = my_error_exit;
+
+        if (!setjmp(err.setjmp_buffer)) {
+    #if defined(Q_OS_UNIXWARE)
+            (void) jpeg_read_header(&info, B_TRUE);
+    #else
+            (void) jpeg_read_header(&info, true);
+    #endif
+
+            int width = 0;
+            int height = 0;
+            read_jpeg_size(width, height, &info);
+            size = QSize(width, height);
+
+            format = QImage::Format_Invalid;
+            read_jpeg_format(format, &info);
+            state = ReadHeader;
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+    else if(state == Error)
+        return false;
+    return true;
+}
+
+bool QJpegHandlerPrivate::read(QImage *image)
+{
+    if(state == Ready)
+        readJpegHeader(q->device());
+
+    if(state == ReadHeader)
+    {
+        bool success = read_jpeg_image(image, scaledSize, scaledClipRect, clipRect, quality,  &info, &err);
+        state = success ? Ready : Error;
+        return success;
+    }
+
+    return false;
+
+}
+
 QJpegHandler::QJpegHandler()
+    : d(new QJpegHandlerPrivate(this))
 {
-    quality = 75;
+}
+
+QJpegHandler::~QJpegHandler()
+{
+    delete d;
 }
 
 bool QJpegHandler::canRead() const
 {
-    if (canRead(device())) {
+    if(d->state == QJpegHandlerPrivate::Ready) {
+        if (!canRead(device()))
+            return false;
         setFormat("jpeg");
         return true;
     }
-    return false;
+    return d->state != QJpegHandlerPrivate::Error;
 }
 
 bool QJpegHandler::canRead(QIODevice *device)
@@ -1191,7 +808,6 @@ bool QJpegHandler::canRead(QIODevice *device)
     char buffer[2];
     if (device->peek(buffer, 2) != 2)
         return false;
-
     return uchar(buffer[0]) == 0xff && uchar(buffer[1]) == 0xd8;
 }
 
@@ -1199,12 +815,12 @@ bool QJpegHandler::read(QImage *image)
 {
     if (!canRead())
         return false;
-    return read_jpeg_image(device(), image, scaledSize, scaledClipRect, clipRect, quality);
+    return d->read(image);
 }
 
 bool QJpegHandler::write(const QImage &image)
 {
-    return write_jpeg_image(image, device(), quality);
+    return write_jpeg_image(image, device(), d->quality);
 }
 
 bool QJpegHandler::supportsOption(ImageOption option) const
@@ -1219,46 +835,44 @@ bool QJpegHandler::supportsOption(ImageOption option) const
 
 QVariant QJpegHandler::option(ImageOption option) const
 {
-    if (option == Quality) {
-        return quality;
-    } else if  (option == ScaledSize) {
-        return scaledSize;
-    } else if  (option == ScaledClipRect) {
-        return scaledClipRect;
-    } else if  (option == ClipRect) {
-        return clipRect;
-    } else if (option == Size) {
-        if (canRead() && !device()->isSequential()) {
-            qint64 pos = device()->pos();
-            int width = 0;
-            int height = 0;
-            read_jpeg_size(device(), width, height);
-            device()->seek(pos);
-            return QSize(width, height);
-        }
-    } else if (option == ImageFormat) {
-        if (canRead() && !device()->isSequential()) {
-            qint64 pos = device()->pos();
-            QImage::Format format = QImage::Format_Invalid;
-            read_jpeg_format(device(), format);
-            device()->seek(pos);
-            return format;
-        }
-        return QImage::Format_Invalid;
+    switch(option) {
+    case Quality:
+        return d->quality;
+    case ScaledSize:
+        return d->scaledSize;
+    case ScaledClipRect:
+        return d->scaledClipRect;
+    case ClipRect:
+        return d->clipRect;
+    case Size:
+        d->readJpegHeader(device());
+        return d->size;
+    case ImageFormat:
+        d->readJpegHeader(device());
+        return d->format;
+    default:
+        return QVariant();
     }
-    return QVariant();
 }
 
 void QJpegHandler::setOption(ImageOption option, const QVariant &value)
 {
-    if (option == Quality)
-        quality = value.toInt();
-    else if ( option == ScaledSize )
-        scaledSize = value.toSize();
-    else if ( option == ScaledClipRect )
-        scaledClipRect = value.toRect();
-    else if ( option == ClipRect )
-        clipRect = value.toRect();
+    switch(option) {
+    case Quality:
+        d->quality = value.toInt();
+        break;
+    case ScaledSize:
+        d->scaledSize = value.toSize();
+        break;
+    case ScaledClipRect:
+        d->scaledClipRect = value.toRect();
+        break;
+    case ClipRect:
+        d->clipRect = value.toRect();
+        break;
+    default:
+        break;
+    }
 }
 
 QByteArray QJpegHandler::name() const
@@ -1266,4 +880,7 @@ QByteArray QJpegHandler::name() const
     return "jpeg";
 }
 
+
+
+
 QT_END_NAMESPACE
diff --git a/src/plugins/imageformats/jpeg/qjpeghandler.h b/src/plugins/imageformats/jpeg/qjpeghandler.h
index dfb6b47..c879f21 100644
--- a/src/plugins/imageformats/jpeg/qjpeghandler.h
+++ b/src/plugins/imageformats/jpeg/qjpeghandler.h
@@ -48,10 +48,12 @@
 
 QT_BEGIN_NAMESPACE
 
+class QJpegHandlerPrivate;
 class QJpegHandler : public QImageIOHandler
 {
 public:
     QJpegHandler();
+    ~QJpegHandler();
 
     bool canRead() const;
     bool read(QImage *image);
@@ -66,10 +68,7 @@ public:
     bool supportsOption(ImageOption option) const;
 
 private:
-    int quality;
-    QSize scaledSize;
-    QRect scaledClipRect;
-    QRect clipRect;
+    QJpegHandlerPrivate *d;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/imageformats/tiff/qtiffhandler.cpp b/src/plugins/imageformats/tiff/qtiffhandler.cpp
index 31e0c92..619aa4e 100644
--- a/src/plugins/imageformats/tiff/qtiffhandler.cpp
+++ b/src/plugins/imageformats/tiff/qtiffhandler.cpp
@@ -385,8 +385,8 @@ static bool checkGrayscale(const QVector<QRgb> &colorTable)
 
     const bool increasing = (colorTable.at(0) == 0xff000000);
     for (int i = 0; i < 256; ++i) {
-        if (increasing && colorTable.at(i) != qRgb(i, i, i)
-            || !increasing && colorTable.at(i) != qRgb(255 - i, 255 - i, 255 - i))
+        if ((increasing && colorTable.at(i) != qRgb(i, i, i))
+            || (!increasing && colorTable.at(i) != qRgb(255 - i, 255 - i, 255 - i)))
             return false;
     }
     return true;
diff --git a/src/plugins/imageformats/tiff/tiff.pro b/src/plugins/imageformats/tiff/tiff.pro
index 312f99c..3cb64ad 100644
--- a/src/plugins/imageformats/tiff/tiff.pro
+++ b/src/plugins/imageformats/tiff/tiff.pro
@@ -47,16 +47,18 @@ contains(QT_CONFIG, system-tiff) {
 	    ../../../3rdparty/libtiff/libtiff/tif_warning.c \
 	    ../../../3rdparty/libtiff/libtiff/tif_write.c \
 	    ../../../3rdparty/libtiff/libtiff/tif_zip.c
-	    win32 {
+	    win32:!wince*: {
 	       SOURCES += ../../../3rdparty/libtiff/libtiff/tif_win32.c
 	    }
             unix: {
 	       SOURCES += ../../../3rdparty/libtiff/libtiff/tif_unix.c
             }
             wince*: {
-               SOURCES += ../../../corelib/kernel/qfunctions_wince.cpp
+               SOURCES += ../../../corelib/kernel/qfunctions_wince.cpp \
+                          ../../../3rdparty/libtiff/libtiff/tif_wince.c \
+			  ../../../3rdparty/libtiff/libtiff/tif_win32.c
             }
-            symbian*: {
+            symbian: {
                SOURCES += ../../../3rdparty/libtiff/port/lfind.c
             }
 }
diff --git a/src/plugins/mediaservices/directshow/directshow.pro b/src/plugins/mediaservices/directshow/directshow.pro
new file mode 100644
index 0000000..ea133f9
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/directshow.pro
@@ -0,0 +1,14 @@
+TARGET = dsengine
+include(../../qpluginbase.pri)
+
+QT += multimedia
+
+HEADERS += dsserviceplugin.h
+SOURCES += dsserviceplugin.cpp
+
+include(mediaplayer/mediaplayer.pri)
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/mediaservices
+target.path = $$[QT_INSTALL_PLUGINS]/mediaservices
+INSTALLS += target
+
diff --git a/src/plugins/mediaservices/directshow/dsserviceplugin.cpp b/src/plugins/mediaservices/directshow/dsserviceplugin.cpp
new file mode 100644
index 0000000..c482fd5
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/dsserviceplugin.cpp
@@ -0,0 +1,188 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qstring.h>
+#include <QtCore/qdebug.h>
+#include <QtCore/QFile>
+
+#include "dsserviceplugin.h"
+
+#ifdef QMEDIA_DIRECTSHOW_CAMERA
+#include "dscameraservice.h"
+#endif
+
+#ifdef QMEDIA_DIRECTSHOW_PLAYER
+#include "directshowplayerservice.h"
+#endif
+
+#include <qmediaserviceprovider.h>
+
+
+#ifdef QMEDIA_DIRECTSHOW_CAMERA
+#ifndef _STRSAFE_H_INCLUDED_
+#include <tchar.h>
+#endif
+#include <dshow.h>
+#include <objbase.h>
+#include <initguid.h>
+#pragma comment(lib, "strmiids.lib")
+#pragma comment(lib, "ole32.lib")
+#include <windows.h>
+#endif
+
+
+QT_BEGIN_NAMESPACE
+
+QStringList DSServicePlugin::keys() const
+{
+    return QStringList()
+#ifdef QMEDIA_DIRECTSHOW_CAMERA
+            << QLatin1String(Q_MEDIASERVICE_CAMERA)
+#endif
+#ifdef QMEDIA_DIRECTSHOW_PLAYER
+            << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER)
+#endif
+            ;
+}
+
+QMediaService* DSServicePlugin::create(QString const& key)
+{
+#ifdef QMEDIA_DIRECTSHOW_CAMERA
+    if (key == QLatin1String(Q_MEDIASERVICE_CAMERA))
+        return new DSCameraService;
+#endif
+#ifdef QMEDIA_DIRECTSHOW_PLAYER
+    if (key == QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER))
+        return new DirectShowPlayerService;
+#endif
+
+    qWarning() << "DirectShow service plugin: unsupported service -" << key;
+    return 0;
+}
+
+void DSServicePlugin::release(QMediaService *service)
+{
+    delete service;
+}
+
+QList<QByteArray> DSServicePlugin::devices(const QByteArray &service) const
+{
+#ifdef QMEDIA_DIRECTSHOW_CAMERA
+    if (service == Q_MEDIASERVICE_CAMERA) {
+        if (m_cameraDevices.isEmpty())
+            updateDevices();
+
+        return m_cameraDevices;
+    }
+#endif
+
+    return QList<QByteArray>();
+}
+
+QString DSServicePlugin::deviceDescription(const QByteArray &service, const QByteArray &device)
+{
+#ifdef QMEDIA_DIRECTSHOW_CAMERA
+    if (service == Q_MEDIASERVICE_CAMERA) {
+        if (m_cameraDevices.isEmpty())
+            updateDevices();
+
+        for (int i=0; i<m_cameraDevices.count(); i++)
+            if (m_cameraDevices[i] == device)
+                return m_cameraDescriptions[i];
+    }
+#endif
+    return QString();
+}
+
+#ifdef QMEDIA_DIRECTSHOW_CAMERA
+void DSServicePlugin::updateDevices() const
+{
+    m_cameraDevices.clear();
+    m_cameraDescriptions.clear();
+
+    CoInitialize(NULL);
+    ICreateDevEnum* pDevEnum = NULL;
+    IEnumMoniker* pEnum = NULL;
+    // Create the System device enumerator
+    HRESULT hr = CoCreateInstance(CLSID_SystemDeviceEnum, NULL,
+                 CLSCTX_INPROC_SERVER, IID_ICreateDevEnum,
+		 reinterpret_cast<void**>(&pDevEnum));
+    if(SUCCEEDED(hr)) {
+        // Create the enumerator for the video capture category
+	hr = pDevEnum->CreateClassEnumerator(
+	     CLSID_VideoInputDeviceCategory, &pEnum, 0);
+	pEnum->Reset();
+	// go through and find all video capture devices
+	IMoniker* pMoniker = NULL;
+	while(pEnum->Next(1, &pMoniker, NULL) == S_OK) {
+	    IPropertyBag *pPropBag;
+	    hr = pMoniker->BindToStorage(0,0,IID_IPropertyBag,
+	         (void**)(&pPropBag));
+            if(FAILED(hr)) {
+	        pMoniker->Release();
+		continue; // skip this one
+	    }
+	    // Find the description
+	    WCHAR str[120];
+	    VARIANT varName;
+	    varName.vt = VT_BSTR;
+            hr = pPropBag->Read(L"FriendlyName", &varName, 0);
+	    if(SUCCEEDED(hr)) {
+	        StringCchCopyW(str,sizeof(str)/sizeof(str[0]),varName.bstrVal);
+		QString temp(QString::fromUtf16((unsigned short*)str));
+		m_cameraDevices.append(QString("ds:%1").arg(temp).toLocal8Bit().constData());
+	        hr = pPropBag->Read(L"Description", &varName, 0);
+	        StringCchCopyW(str,sizeof(str)/sizeof(str[0]),varName.bstrVal);
+		QString temp2(QString::fromUtf16((unsigned short*)str));
+		m_cameraDescriptions.append(temp2);
+	    }
+	    pPropBag->Release();
+	    pMoniker->Release();
+	}
+    }
+    CoUninitialize();
+}
+#endif
+
+QT_END_NAMESPACE
+
+Q_EXPORT_PLUGIN2(dsengine, DSServicePlugin);
+
diff --git a/src/plugins/mediaservices/directshow/dsserviceplugin.h b/src/plugins/mediaservices/directshow/dsserviceplugin.h
new file mode 100644
index 0000000..3c6f1b8
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/dsserviceplugin.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DSSERVICEPLUGIN_H
+#define DSSERVICEPLUGIN_H
+
+#include <qmediaserviceproviderplugin.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+
+class DSServicePlugin : public QMediaServiceProviderPlugin, public QMediaServiceSupportedDevicesInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
+public:
+    QStringList keys() const;
+    QMediaService* create(QString const& key);
+    void release(QMediaService *service);
+
+    QList<QByteArray> devices(const QByteArray &service) const;
+    QString deviceDescription(const QByteArray &service, const QByteArray &device);
+
+private:
+#ifdef QMEDIA_DIRECTSHOW_CAMERA
+    void updateDevices() const;
+
+    mutable QList<QByteArray> m_cameraDevices;
+    mutable QStringList m_cameraDescriptions;
+#endif
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // DSSERVICEPLUGIN_H
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowaudioendpointcontrol.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowaudioendpointcontrol.cpp
new file mode 100644
index 0000000..5f72ca6
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowaudioendpointcontrol.cpp
@@ -0,0 +1,166 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowaudioendpointcontrol.h"
+
+#include "directshowglobal.h"
+#include "directshowplayerservice.h"
+
+
+QT_BEGIN_NAMESPACE
+
+DirectShowAudioEndpointControl::DirectShowAudioEndpointControl(
+        DirectShowPlayerService *service, QObject *parent)
+    : QMediaControl(parent)
+    , m_service(service)
+    , m_bindContext(0)
+    , m_deviceEnumerator(0)
+{
+    if (CreateBindCtx(0, &m_bindContext) == S_OK) {
+        m_deviceEnumerator = com_new<ICreateDevEnum>(CLSID_SystemDeviceEnum, IID_ICreateDevEnum);
+
+        updateEndpoints();
+
+        setActiveEndpoint(m_defaultEndpoint);
+    }
+}
+
+DirectShowAudioEndpointControl::~DirectShowAudioEndpointControl()
+{
+    foreach (IMoniker *moniker, m_devices)
+        moniker->Release();
+
+    if (m_bindContext)
+        m_bindContext->Release();
+
+    if (m_deviceEnumerator)
+        m_deviceEnumerator->Release();
+}
+
+QList<QString> DirectShowAudioEndpointControl::availableEndpoints() const
+{
+    return m_devices.keys();
+}
+
+QString DirectShowAudioEndpointControl::endpointDescription(const QString &name) const
+{
+#ifdef __IPropertyBag_INTERFACE_DEFINED__
+    QString description;
+
+    if (IMoniker *moniker = m_devices.value(name, 0)) {
+        IPropertyBag *propertyBag = 0;
+        if (SUCCEEDED(moniker->BindToStorage(
+                0, 0, IID_IPropertyBag, reinterpret_cast<void **>(&propertyBag)))) {
+            VARIANT name;
+            VariantInit(&name);
+            if (SUCCEEDED(propertyBag->Read(L"FriendlyName", &name, 0)))
+                description = QString::fromWCharArray(name.bstrVal);
+            VariantClear(&name);
+            propertyBag->Release();
+        }
+    }
+
+    return description;
+#else
+    return name.section(QLatin1Char('\\'), -1);
+#endif
+}
+
+QString DirectShowAudioEndpointControl::defaultEndpoint() const
+{
+    return m_defaultEndpoint;
+}
+
+QString DirectShowAudioEndpointControl::activeEndpoint() const
+{
+    return m_activeEndpoint;
+}
+
+void DirectShowAudioEndpointControl::setActiveEndpoint(const QString &name)
+{
+    if (m_activeEndpoint == name)
+        return;
+
+    if (IMoniker *moniker = m_devices.value(name, 0)) {
+        IBaseFilter *filter = 0;
+
+        if (moniker->BindToObject(
+                m_bindContext,
+                0,
+                IID_IBaseFilter,
+                reinterpret_cast<void **>(&filter)) == S_OK) {
+            m_service->setAudioOutput(filter);
+
+            filter->Release();
+        }
+    }
+}
+
+void DirectShowAudioEndpointControl::updateEndpoints()
+{
+    IMalloc *oleMalloc = 0;
+    if (m_deviceEnumerator && CoGetMalloc(1, &oleMalloc) == S_OK) {
+        IEnumMoniker *monikers = 0;
+
+        if (m_deviceEnumerator->CreateClassEnumerator(
+                CLSID_AudioRendererCategory, &monikers, 0) == S_OK) {
+            for (IMoniker *moniker = 0; monikers->Next(1, &moniker, 0) == S_OK; moniker->Release()) {
+                OLECHAR *string = 0;
+                if (moniker->GetDisplayName(m_bindContext, 0, &string) == S_OK) {
+                    QString deviceId = QString::fromWCharArray(string);
+                    oleMalloc->Free(string);
+
+                    moniker->AddRef();
+                    m_devices.insert(deviceId, moniker);
+
+                    if (m_defaultEndpoint.isEmpty()
+                            || deviceId.endsWith(QLatin1String("Default DirectSound Device"))) {
+                        m_defaultEndpoint = deviceId;
+                    }
+                }
+            }
+            monikers->Release();
+        }
+        oleMalloc->Release();
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowaudioendpointcontrol.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowaudioendpointcontrol.h
new file mode 100644
index 0000000..2faac13
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowaudioendpointcontrol.h
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWAUDIOENDPOINTCONTROL_H
+#define DIRECTSHOWAUDIOENDPOINTCONTROL_H
+
+#include <QtMultimedia/qmediacontrol.h>
+
+#include <dshow.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowPlayerService;
+
+class DirectShowAudioEndpointControl : public QMediaControl
+{
+    Q_OBJECT
+public:
+    DirectShowAudioEndpointControl(DirectShowPlayerService *service, QObject *parent = 0);
+    ~DirectShowAudioEndpointControl();
+
+    QList<QString> availableEndpoints() const;
+
+    QString endpointDescription(const QString &name) const;
+
+    QString defaultEndpoint() const;
+    QString activeEndpoint() const;
+
+    void setActiveEndpoint(const QString& name);
+
+private:
+    void updateEndpoints();
+
+    DirectShowPlayerService *m_service;
+    IBindCtx *m_bindContext;
+    ICreateDevEnum *m_deviceEnumerator;
+
+    QMap<QString, IMoniker *> m_devices;
+    QString m_defaultEndpoint;
+    QString m_activeEndpoint;
+};
+
+#define QAudioEndpointSelector_iid "com.nokia.Qt.QAudioEndpointSelector/1.0"
+
+class Duck
+{
+    uint quack;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
+
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshoweventloop.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshoweventloop.cpp
new file mode 100644
index 0000000..07541c2
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshoweventloop.cpp
@@ -0,0 +1,161 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <directshoweventloop.h>
+
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qcoreevent.h>
+
+
+QT_BEGIN_NAMESPACE
+
+
+class DirectShowPostedEvent
+{
+public:
+    DirectShowPostedEvent(QObject *receiver, QEvent *event)
+        : receiver(receiver)
+        , event(event)
+        , next(0)
+    {
+    }
+
+    ~DirectShowPostedEvent()
+    {
+        delete event;
+    }
+
+    QObject *receiver;
+    QEvent *event;
+    DirectShowPostedEvent *next;
+};
+
+DirectShowEventLoop::DirectShowEventLoop(QObject *parent)
+    : QWinEventNotifier(parent)
+    , m_postsHead(0)
+    , m_postsTail(0)
+    , m_eventHandle(::CreateEvent(0, 0, 0, 0))
+    , m_waitHandle(::CreateEvent(0, 0, 0, 0))
+{
+    setHandle(m_eventHandle);
+    setEnabled(true);
+}
+
+DirectShowEventLoop::~DirectShowEventLoop()
+{
+    setEnabled(false);
+
+    ::CloseHandle(m_eventHandle);
+    ::CloseHandle(m_waitHandle);
+
+    for (DirectShowPostedEvent *post = m_postsHead; post; post = m_postsHead) {
+        m_postsHead = m_postsHead->next;
+
+        delete post;
+    }
+}
+
+void DirectShowEventLoop::wait(QMutex *mutex)
+{
+    ::ResetEvent(m_waitHandle);
+
+    mutex->unlock();
+
+    HANDLE handles[] = { m_eventHandle, m_waitHandle };
+    while (::WaitForMultipleObjects(2, handles, false, INFINITE) == WAIT_OBJECT_0)
+        processEvents();
+  
+    mutex->lock();
+}
+
+void DirectShowEventLoop::wake()
+{
+    ::SetEvent(m_waitHandle);
+}
+
+void DirectShowEventLoop::postEvent(QObject *receiver, QEvent *event)
+{
+    QMutexLocker locker(&m_mutex);
+
+    DirectShowPostedEvent *post = new DirectShowPostedEvent(receiver, event);
+
+    if (m_postsTail)
+        m_postsTail->next = post;
+    else
+        m_postsHead = post;
+
+    m_postsTail = post;
+
+    ::SetEvent(m_eventHandle);
+}
+
+bool DirectShowEventLoop::event(QEvent *event)
+{
+    if (event->type() == QEvent::WinEventAct) {
+        processEvents();
+
+        return true;
+    } else {
+        return QWinEventNotifier::event(event);
+    }
+}
+
+void DirectShowEventLoop::processEvents()
+{
+    QMutexLocker locker(&m_mutex);
+
+    while(m_postsHead) {
+        ::ResetEvent(m_eventHandle);
+
+        DirectShowPostedEvent *post = m_postsHead;
+        m_postsHead = m_postsHead->next;
+
+        if (!m_postsHead)
+            m_postsTail = 0;
+
+        locker.unlock();
+        QCoreApplication::sendEvent(post->receiver, post->event);
+        delete post;
+        locker.relock();
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshoweventloop.h b/src/plugins/mediaservices/directshow/mediaplayer/directshoweventloop.h
new file mode 100644
index 0000000..f46e65a
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshoweventloop.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWEVENTLOOP_H
+#define DIRECTSHOWEVENTLOOP_H
+
+#include <QtCore/qmutex.h>
+#include <QtCore/private/qwineventnotifier_p.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowPostedEvent;
+
+class DirectShowEventLoop : public QWinEventNotifier
+{
+    Q_OBJECT
+public:
+    DirectShowEventLoop(QObject *parent = 0);
+    ~DirectShowEventLoop();
+
+    void wait(QMutex *mutex);
+    void wake();
+
+    void postEvent(QObject *object, QEvent *event);
+
+    bool event(QEvent *event);
+
+private:
+    void processEvents();
+
+    DirectShowPostedEvent *m_postsHead;
+    DirectShowPostedEvent *m_postsTail;
+    HANDLE m_eventHandle;
+    HANDLE m_waitHandle;
+    QMutex m_mutex;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowglobal.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowglobal.h
new file mode 100644
index 0000000..e43e2a7
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowglobal.h
@@ -0,0 +1,147 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWGLOBAL_H
+#define DIRECTSHOWGLOBAL_H
+
+#include <QtCore/qglobal.h>
+
+#include <dshow.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+template <typename T> T *com_cast(IUnknown *unknown, const IID &iid)
+{
+    T *iface = 0;
+    return unknown && unknown->QueryInterface(iid, reinterpret_cast<void **>(&iface)) == S_OK
+        ? iface
+        : 0;
+}
+
+template <typename T> T *com_new(const IID &clsid, const IID &iid)
+{
+    T *object = 0;
+    return CoCreateInstance(
+            clsid,
+            NULL,
+            CLSCTX_INPROC_SERVER,
+            iid,
+            reinterpret_cast<void **>(&object)) == S_OK
+        ? object
+        : 0;
+}
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#ifndef __IFilterGraph2_INTERFACE_DEFINED__
+#define __IFilterGraph2_INTERFACE_DEFINED__
+#define INTERFACE IFilterGraph2
+DECLARE_INTERFACE_(IFilterGraph2 ,IGraphBuilder)
+{
+    STDMETHOD(AddSourceFilterForMoniker)(THIS_ IMoniker *, IBindCtx *, LPCWSTR,IBaseFilter **) PURE;
+    STDMETHOD(ReconnectEx)(THIS_ IPin *, const AM_MEDIA_TYPE *) PURE;
+    STDMETHOD(RenderEx)(IPin *, DWORD, DWORD *) PURE;
+};
+#undef INTERFACE  
+#endif
+
+#ifndef __IAMFilterMiscFlags_INTERFACE_DEFINED__
+#define __IAMFilterMiscFlags_INTERFACE_DEFINED__
+#define INTERFACE IAMFilterMiscFlags
+DECLARE_INTERFACE_(IAMFilterMiscFlags ,IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ REFIID,PVOID*) PURE;
+	STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+	STDMETHOD_(ULONG,Release)(THIS) PURE;
+    STDMETHOD_(ULONG,GetMiscFlags)(THIS) PURE;
+};
+#undef INTERFACE  
+#endif
+
+#ifndef __IFileSourceFilter_INTERFACE_DEFINED__
+#define __IFileSourceFilter_INTERFACE_DEFINED__
+#define INTERFACE IFileSourceFilter
+DECLARE_INTERFACE_(IFileSourceFilter ,IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ REFIID,PVOID*) PURE;
+	STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+	STDMETHOD_(ULONG,Release)(THIS) PURE;
+    STDMETHOD(Load)(THIS_ LPCOLESTR, const AM_MEDIA_TYPE *) PURE;
+    STDMETHOD(GetCurFile)(THIS_ LPOLESTR *ppszFileName, AM_MEDIA_TYPE *) PURE;
+};
+#undef INTERFACE  
+#endif
+
+#ifndef __IAMOpenProgress_INTERFACE_DEFINED__
+#define __IAMOpenProgress_INTERFACE_DEFINED__
+#define INTERFACE IAMOpenProgress
+DECLARE_INTERFACE_(IAMOpenProgress ,IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ REFIID,PVOID*) PURE;
+	STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+	STDMETHOD_(ULONG,Release)(THIS) PURE;
+    STDMETHOD(QueryProgress)(THIS_ LONGLONG *, LONGLONG *) PURE;
+    STDMETHOD(AbortOperation)(THIS) PURE;
+};
+#undef INTERFACE  
+#endif
+
+#ifndef __IFilterChain_INTERFACE_DEFINED__
+#define __IFilterChain_INTERFACE_DEFINED__
+#define INTERFACE IFilterChain
+DECLARE_INTERFACE_(IFilterChain ,IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ REFIID,PVOID*) PURE;
+	STDMETHOD_(ULONG,AddRef)(THIS) PURE;
+	STDMETHOD_(ULONG,Release)(THIS) PURE;
+    STDMETHOD(StartChain)(IBaseFilter *, IBaseFilter *) PURE;
+    STDMETHOD(PauseChain)(IBaseFilter *, IBaseFilter *) PURE;
+    STDMETHOD(StopChain)(IBaseFilter *, IBaseFilter *) PURE;
+    STDMETHOD(RemoveChain)(IBaseFilter *, IBaseFilter *) PURE;
+};
+#undef INTERFACE  
+#endif
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowioreader.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowioreader.cpp
new file mode 100644
index 0000000..7369099
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowioreader.cpp
@@ -0,0 +1,501 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowioreader.h"
+
+#include "directshoweventloop.h"
+#include "directshowglobal.h"
+#include "directshowiosource.h"
+
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qiodevice.h>
+#include <QtCore/qthread.h>
+
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowSampleRequest
+{
+public:
+    DirectShowSampleRequest(
+            IMediaSample *sample, DWORD_PTR userData, LONGLONG position, LONG length, BYTE *buffer)
+        : next(0)
+        , sample(sample)
+        , userData(userData)
+        , position(position)
+        , length(length)
+        , buffer(buffer)
+        , result(S_FALSE)
+    {
+    }
+
+    DirectShowSampleRequest *remove() { DirectShowSampleRequest *n = next; delete this; return n; }
+
+    DirectShowSampleRequest *next;
+    IMediaSample *sample;
+    DWORD_PTR userData;
+    LONGLONG position;
+    LONG length;
+    BYTE *buffer;
+    HRESULT result;
+};
+
+DirectShowIOReader::DirectShowIOReader(
+        QIODevice *device, DirectShowIOSource *source, DirectShowEventLoop *loop)
+    : m_source(source)
+    , m_device(device)
+    , m_loop(loop)
+    , m_pendingHead(0)
+    , m_pendingTail(0)
+    , m_readyHead(0)
+    , m_readyTail(0)
+    , m_synchronousPosition(0)
+    , m_synchronousLength(0)
+    , m_synchronousBytesRead(0)
+    , m_synchronousBuffer(0)
+    , m_synchronousResult(S_OK)
+    , m_totalLength(0)
+    , m_availableLength(0)
+    , m_flushing(false)
+{
+    moveToThread(device->thread());
+
+    connect(device, SIGNAL(readyRead()), this, SLOT(readyRead()));
+}
+
+DirectShowIOReader::~DirectShowIOReader()
+{
+    flushRequests();
+}
+
+HRESULT DirectShowIOReader::QueryInterface(REFIID riid, void **ppvObject)
+{
+    return m_source->QueryInterface(riid, ppvObject);
+}
+
+ULONG DirectShowIOReader::AddRef()
+{
+    return m_source->AddRef();
+}
+
+ULONG DirectShowIOReader::Release()
+{
+    return m_source->Release();
+}
+
+// IAsyncReader
+HRESULT DirectShowIOReader::RequestAllocator(
+        IMemAllocator *pPreferred, ALLOCATOR_PROPERTIES *pProps, IMemAllocator **ppActual)
+{
+    if (!ppActual || !pProps) {
+        return E_POINTER;
+    } else {
+        ALLOCATOR_PROPERTIES actualProperties;
+
+        if (pProps->cbAlign == 0)
+            pProps->cbAlign = 1;
+
+        if (pPreferred && pPreferred->SetProperties(pProps, &actualProperties) == S_OK) {
+            pPreferred->AddRef();
+
+            *ppActual = pPreferred;
+
+            m_source->setAllocator(*ppActual);
+
+            return S_OK;
+        } else {
+            *ppActual = com_new<IMemAllocator>(CLSID_MemoryAllocator, IID_IMemAllocator);
+
+            if (*ppActual) {
+                if ((*ppActual)->SetProperties(pProps, &actualProperties) != S_OK) {
+                    (*ppActual)->Release();
+                } else {
+                    m_source->setAllocator(*ppActual);
+
+                    return S_OK;
+                }
+            }
+        }
+        ppActual = 0;
+
+        return E_FAIL;
+    }
+}
+
+HRESULT DirectShowIOReader::Request(IMediaSample *pSample, DWORD_PTR dwUser)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (!pSample) {
+        return E_POINTER;
+    } else if (m_flushing) {
+        return VFW_E_WRONG_STATE;
+    } else {
+        REFERENCE_TIME startTime = 0;
+        REFERENCE_TIME endTime = 0;
+        BYTE *buffer;
+
+        if (pSample->GetTime(&startTime, &endTime) != S_OK
+                || pSample->GetPointer(&buffer) != S_OK) {
+            return VFW_E_SAMPLE_TIME_NOT_SET;
+        } else {
+            LONGLONG position = startTime / 10000000;
+            LONG length = (endTime - startTime) / 10000000;
+
+            DirectShowSampleRequest *request = new DirectShowSampleRequest(
+                    pSample, dwUser, position, length, buffer);
+
+            if (m_pendingTail) {
+                m_pendingTail->next = request;
+            } else {
+                m_pendingHead = request;
+
+                m_loop->postEvent(this, new QEvent(QEvent::User));
+            }
+            m_pendingTail = request;
+
+            return S_OK;
+        }
+    }
+}
+
+HRESULT DirectShowIOReader::WaitForNext(
+        DWORD dwTimeout, IMediaSample **ppSample, DWORD_PTR *pdwUser)
+{
+    if (!ppSample || !pdwUser)
+        return E_POINTER;
+
+    QMutexLocker locker(&m_mutex);
+
+    do {
+        if (m_readyHead) {
+            DirectShowSampleRequest *request = m_readyHead;
+
+            *ppSample = request->sample;
+            *pdwUser = request->userData;
+
+            HRESULT hr = request->result;
+
+            m_readyHead = request->next;
+
+            if (!m_readyHead)
+                m_readyTail = 0;
+
+            delete request;
+
+            return hr;
+        } else if (m_flushing) {
+            *ppSample = 0;
+            *pdwUser = 0;
+
+            return VFW_E_WRONG_STATE;
+        }
+    } while (m_wait.wait(&m_mutex, dwTimeout));
+
+    *ppSample = 0;
+    *pdwUser = 0;
+
+    return VFW_E_TIMEOUT;
+}
+
+HRESULT DirectShowIOReader::SyncReadAligned(IMediaSample *pSample)
+{
+    if (!pSample) {
+        return E_POINTER;
+    } else {
+        REFERENCE_TIME startTime = 0;
+        REFERENCE_TIME endTime = 0;
+        BYTE *buffer;
+
+        if (pSample->GetTime(&startTime, &endTime) != S_OK
+                || pSample->GetPointer(&buffer) != S_OK) {
+            return VFW_E_SAMPLE_TIME_NOT_SET;
+        } else {
+            LONGLONG position = startTime / 10000000;
+            LONG length = (endTime - startTime) / 10000000;
+
+            QMutexLocker locker(&m_mutex);
+
+            if (thread() == QThread::currentThread()) {
+                qint64 bytesRead = 0;
+
+                HRESULT hr = blockingRead(position, length, buffer, &bytesRead);
+
+                if (SUCCEEDED(hr))
+                    pSample->SetActualDataLength(bytesRead);
+   
+                return hr;
+            } else {
+                m_synchronousPosition = position;
+                m_synchronousLength = length;
+                m_synchronousBuffer = buffer;
+
+                m_loop->postEvent(this, new QEvent(QEvent::User));
+
+                m_wait.wait(&m_mutex);
+
+                m_synchronousBuffer = 0;
+
+                if (SUCCEEDED(m_synchronousResult))
+                    pSample->SetActualDataLength(m_synchronousBytesRead);
+
+                return m_synchronousResult;
+            }
+        }
+    }
+}
+
+HRESULT DirectShowIOReader::SyncRead(LONGLONG llPosition, LONG lLength, BYTE *pBuffer)
+{
+    if (!pBuffer) {
+        return E_POINTER;
+    } else {
+        if (thread() == QThread::currentThread()) {
+            qint64 bytesRead;
+
+            return blockingRead(llPosition, lLength, pBuffer, &bytesRead);
+        } else {
+            QMutexLocker locker(&m_mutex);
+
+            m_synchronousPosition = llPosition;
+            m_synchronousLength = lLength;
+            m_synchronousBuffer = pBuffer;
+
+            m_loop->postEvent(this, new QEvent(QEvent::User));
+
+            m_wait.wait(&m_mutex);
+
+            m_synchronousBuffer = 0;
+
+            return m_synchronousResult;
+        }
+    }
+}
+
+HRESULT DirectShowIOReader::Length(LONGLONG *pTotal, LONGLONG *pAvailable)
+{
+    if (!pTotal || !pAvailable) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        *pTotal = m_totalLength;
+        *pAvailable = m_availableLength;
+
+        return S_OK;
+    }
+}
+
+
+HRESULT DirectShowIOReader::BeginFlush()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_flushing)
+        return S_FALSE;
+
+    m_flushing = true;
+
+    flushRequests();
+
+    m_wait.wakeAll();
+
+    return S_OK;
+}
+
+HRESULT DirectShowIOReader::EndFlush()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (!m_flushing)
+        return S_FALSE;
+
+    m_flushing = false;
+
+    return S_OK;
+}
+
+void DirectShowIOReader::customEvent(QEvent *event)
+{
+    if (event->type() == QEvent::User) {
+        readyRead();
+    } else {
+        QObject::customEvent(event);
+    }
+}
+
+void DirectShowIOReader::readyRead()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_availableLength = m_device->bytesAvailable() + m_device->pos();
+    m_totalLength = m_device->size();
+
+    if (m_synchronousBuffer) {
+        if (nonBlockingRead(
+                m_synchronousPosition,
+                m_synchronousLength,
+                m_synchronousBuffer,
+                &m_synchronousBytesRead,
+                &m_synchronousResult)) {
+            m_wait.wakeAll();
+        }
+    } else {
+        qint64 bytesRead = 0;
+
+        while (m_pendingHead && nonBlockingRead(
+                m_pendingHead->position,
+                m_pendingHead->length,
+                m_pendingHead->buffer,
+                &bytesRead,
+            &m_pendingHead->result)) {
+            m_pendingHead->sample->SetActualDataLength(bytesRead);
+
+            if (m_readyTail)
+                m_readyTail->next = m_pendingHead;
+            m_readyTail = m_pendingHead;
+
+            m_pendingHead = m_pendingHead->next;
+
+            m_readyTail->next = 0;
+
+            if (!m_pendingHead)
+                m_pendingTail = 0;
+
+            if (!m_readyHead)
+                m_readyHead = m_readyTail;
+
+            m_wait.wakeAll();
+        }
+    }
+}
+
+HRESULT DirectShowIOReader::blockingRead(
+        LONGLONG position, LONG length, BYTE *buffer, qint64 *bytesRead)
+{
+    *bytesRead = 0;
+
+    if (qint64(position) > m_device->size())
+        return S_FALSE;
+
+    const qint64 maxSize = qMin<qint64>(m_device->size(), position + length);
+
+    while (m_device->bytesAvailable() + m_device->pos() < maxSize) {
+        if (!m_device->waitForReadyRead(-1))
+            return S_FALSE;
+    }
+
+    if (m_device->pos() != position && !m_device->seek(position))
+        return S_FALSE;
+
+    const qint64 maxBytes = qMin<qint64>(length, m_device->bytesAvailable());
+
+    *bytesRead = m_device->read(reinterpret_cast<char *>(buffer), maxBytes);
+
+    if (*bytesRead != length) {
+        qMemSet(buffer + *bytesRead, 0, length - *bytesRead);
+
+        return S_FALSE;
+    } else {
+        return S_OK;
+    }
+}
+
+bool DirectShowIOReader::nonBlockingRead(
+        LONGLONG position, LONG length, BYTE *buffer, qint64 *bytesRead, HRESULT *result)
+{
+    const qint64 maxSize = qMin<qint64>(m_device->size(), position + length);
+
+    if (position > m_device->size()) {
+        *bytesRead = 0;
+        *result = S_FALSE;
+
+        return true;
+    } else if (m_device->bytesAvailable() + m_device->pos() >= maxSize) {
+        if (m_device->pos() != position && !m_device->seek(position)) {
+            *bytesRead = 0;
+            *result = S_FALSE;
+
+            return true;
+        } else {
+            const qint64 maxBytes = qMin<qint64>(length, m_device->bytesAvailable());
+
+            *bytesRead = m_device->read(reinterpret_cast<char *>(buffer), maxBytes);
+
+            if (*bytesRead != length) {
+                qMemSet(buffer + *bytesRead, 0, length - *bytesRead);
+
+                *result = S_FALSE;
+            } else {
+                *result = S_OK;
+            }
+
+            return true;
+        }
+    } else {
+        return false;
+    }
+}
+
+void DirectShowIOReader::flushRequests()
+{
+    while (m_pendingHead) {
+        m_pendingHead->result = VFW_E_WRONG_STATE;
+
+        if (m_readyTail)
+            m_readyTail->next = m_pendingHead;
+
+        m_readyTail = m_pendingHead;
+
+        m_pendingHead = m_pendingHead->next;
+
+        m_readyTail->next = 0;
+
+        if (!m_pendingHead)
+            m_pendingTail = 0;
+
+        if (!m_readyHead)
+            m_readyHead = m_readyTail;
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowioreader.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowioreader.h
new file mode 100644
index 0000000..8cbc2f1
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowioreader.h
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWIOREADER_H
+#define DIRECTSHOWIOREADER_H
+
+#include <QtCore/qmutex.h>
+#include <QtCore/qobject.h>
+#include <QtCore/qwaitcondition.h>
+
+#include <dshow.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QIODevice;
+
+class DirectShowEventLoop;
+class DirectShowIOSource;
+class DirectShowSampleRequest;
+
+class DirectShowIOReader : public QObject, public IAsyncReader
+{
+    Q_OBJECT
+public:
+    DirectShowIOReader(QIODevice *device, DirectShowIOSource *source, DirectShowEventLoop *loop);
+    ~DirectShowIOReader();
+
+    // IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+
+    // IAsyncReader
+    HRESULT STDMETHODCALLTYPE RequestAllocator(
+            IMemAllocator *pPreferred, ALLOCATOR_PROPERTIES *pProps, IMemAllocator **ppActual);
+
+    HRESULT STDMETHODCALLTYPE Request(IMediaSample *pSample, DWORD_PTR dwUser);
+
+    HRESULT STDMETHODCALLTYPE WaitForNext(
+            DWORD dwTimeout, IMediaSample **ppSample, DWORD_PTR *pdwUser);
+
+    HRESULT STDMETHODCALLTYPE SyncReadAligned(IMediaSample *pSample);
+
+    HRESULT STDMETHODCALLTYPE SyncRead(LONGLONG llPosition, LONG lLength, BYTE *pBuffer);
+
+    HRESULT STDMETHODCALLTYPE Length(LONGLONG *pTotal, LONGLONG *pAvailable);
+
+    HRESULT STDMETHODCALLTYPE BeginFlush();
+    HRESULT STDMETHODCALLTYPE EndFlush();
+
+protected:
+    void customEvent(QEvent *event);
+
+private Q_SLOTS:
+    void readyRead();
+
+private:
+    HRESULT blockingRead(LONGLONG position, LONG length, BYTE *buffer, qint64 *bytesRead);
+    bool nonBlockingRead(
+            LONGLONG position, LONG length, BYTE *buffer, qint64 *bytesRead, HRESULT *result);
+    void flushRequests();
+
+    DirectShowIOSource *m_source;
+    QIODevice *m_device;
+    DirectShowEventLoop *m_loop;
+    DirectShowSampleRequest *m_pendingHead;
+    DirectShowSampleRequest *m_pendingTail;
+    DirectShowSampleRequest *m_readyHead;
+    DirectShowSampleRequest *m_readyTail;
+    LONGLONG m_synchronousPosition;
+    LONG m_synchronousLength;
+    qint64 m_synchronousBytesRead;
+    BYTE *m_synchronousBuffer;
+    HRESULT m_synchronousResult;
+    LONGLONG m_totalLength;
+    LONGLONG m_availableLength;
+    bool m_flushing;
+    QMutex m_mutex;
+    QWaitCondition m_wait;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowiosource.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowiosource.cpp
new file mode 100644
index 0000000..7b66d56
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowiosource.cpp
@@ -0,0 +1,639 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowiosource.h"
+
+#include "directshowglobal.h"
+#include "directshowmediatype.h"
+#include "directshowpinenum.h"
+
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qurl.h>
+
+QT_BEGIN_NAMESPACE
+
+static const GUID directshow_subtypes[] =
+{
+    MEDIASUBTYPE_Avi,
+    MEDIASUBTYPE_WAVE,
+    MEDIASUBTYPE_NULL
+};
+
+DirectShowIOSource::DirectShowIOSource(DirectShowEventLoop *loop)
+    : m_ref(1)
+    , m_state(State_Stopped)
+    , m_reader(0)
+    , m_loop(loop)
+    , m_graph(0)
+    , m_clock(0)
+    , m_allocator(0)
+    , m_peerPin(0)
+    , m_pinId(QLatin1String("Data"))
+{
+    QVector<AM_MEDIA_TYPE> mediaTypes;
+
+    AM_MEDIA_TYPE type =
+    {
+        MEDIATYPE_Stream,  // majortype
+        MEDIASUBTYPE_NULL, // subtype
+        TRUE,              // bFixedSizeSamples
+        FALSE,             // bTemporalCompression
+        1,                 // lSampleSize
+        GUID_NULL,         // formattype
+        0,                 // pUnk
+        0,                 // cbFormat
+        0,                 // pbFormat
+    };
+
+    static const int count = sizeof(directshow_subtypes) / sizeof(GUID);
+
+    for (int i = 0; i < count; ++i) {
+        type.subtype = directshow_subtypes[i];
+        mediaTypes.append(type);
+    }
+
+    setMediaTypes(mediaTypes);
+}
+
+DirectShowIOSource::~DirectShowIOSource()
+{
+    Q_ASSERT(m_ref == 0);
+
+    delete m_reader;
+}
+
+void DirectShowIOSource::setDevice(QIODevice *device)
+{
+    Q_ASSERT(!m_reader);
+
+    m_reader = new DirectShowIOReader(device, this, m_loop);
+}
+
+void DirectShowIOSource::setAllocator(IMemAllocator *allocator)
+{
+    if (m_allocator)
+        m_allocator->Release();
+
+    m_allocator = allocator;
+
+    if (m_allocator)
+        m_allocator->AddRef();
+}
+
+// IUnknown
+HRESULT DirectShowIOSource::QueryInterface(REFIID riid, void **ppvObject)
+{
+    // 2dd74950-a890-11d1-abe8-00a0c905f375
+    static const GUID iid_IAmFilterMiscFlags = {
+        0x2dd74950, 0xa890, 0x11d1, {0xab, 0xe8, 0x00, 0xa0, 0xc9, 0x05, 0xf3, 0x75}};
+
+    if (!ppvObject) {
+        return E_POINTER;
+    } else if (riid == IID_IUnknown
+            || riid == IID_IPersist
+            || riid == IID_IMediaFilter
+            || riid == IID_IBaseFilter) {
+        *ppvObject = static_cast<IBaseFilter *>(this);
+    } else if (riid == iid_IAmFilterMiscFlags) {
+        *ppvObject = static_cast<IAMFilterMiscFlags *>(this);
+    } else if (riid == IID_IPin) {
+        *ppvObject = static_cast<IPin *>(this);
+    } else if (riid == IID_IAsyncReader) {
+        *ppvObject = static_cast<IAsyncReader *>(m_reader);
+    } else {
+        *ppvObject = 0;
+
+        return E_NOINTERFACE;
+    }
+
+    AddRef();
+
+    return S_OK;
+}
+
+ULONG DirectShowIOSource::AddRef()
+{
+    return InterlockedIncrement(&m_ref);
+}
+
+ULONG DirectShowIOSource::Release()
+{
+    ULONG ref = InterlockedDecrement(&m_ref);
+
+    if (ref == 0) {
+        delete this;
+    }
+
+    return ref;
+}
+
+// IPersist
+HRESULT DirectShowIOSource::GetClassID(CLSID *pClassID)
+{
+    *pClassID = CLSID_NULL;
+
+    return S_OK;
+}
+
+// IMediaFilter
+HRESULT DirectShowIOSource::Run(REFERENCE_TIME tStart)
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_state = State_Running;
+
+    return S_OK;
+}
+
+HRESULT DirectShowIOSource::Pause()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_state = State_Paused;
+
+    return S_OK;
+}
+
+HRESULT DirectShowIOSource::Stop()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_state = State_Stopped;
+
+    return S_OK;
+}
+
+HRESULT DirectShowIOSource::GetState(DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
+{
+    Q_UNUSED(dwMilliSecsTimeout);
+
+    if (!pState) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        *pState = m_state;
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowIOSource::SetSyncSource(IReferenceClock *pClock)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_clock)
+        m_clock->Release();
+
+    m_clock = pClock;
+
+    if (m_clock)
+        m_clock->AddRef();
+
+    return S_OK;
+}
+
+HRESULT DirectShowIOSource::GetSyncSource(IReferenceClock **ppClock)
+{
+    if (!ppClock) {
+        return E_POINTER;
+    } else {
+        if (!m_clock) {
+            *ppClock = 0;
+
+            return S_FALSE;
+        } else {
+            m_clock->AddRef();
+
+            *ppClock = m_clock;
+
+            return S_OK;
+        }
+    }
+}
+
+// IBaseFilter
+HRESULT DirectShowIOSource::EnumPins(IEnumPins **ppEnum)
+{
+    if (!ppEnum) {
+        return E_POINTER;
+    } else {
+        *ppEnum = new DirectShowPinEnum(QList<IPin *>() << this);
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowIOSource::FindPin(LPCWSTR Id, IPin **ppPin)
+{
+    if (!ppPin || !Id) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+        if (QString::fromWCharArray(Id) == m_pinId) {
+            AddRef();
+
+            *ppPin = this;
+
+            return S_OK;
+        } else {
+            *ppPin = 0;
+
+            return VFW_E_NOT_FOUND;
+        }
+    }
+}
+
+HRESULT DirectShowIOSource::JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName)
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_graph = pGraph;
+    m_filterName = QString::fromWCharArray(pName);
+
+    return S_OK;
+}
+
+HRESULT DirectShowIOSource::QueryFilterInfo(FILTER_INFO *pInfo)
+{
+    if (!pInfo) {
+        return E_POINTER;
+    } else {
+        QString name = m_filterName;
+
+        if (name.length() >= MAX_FILTER_NAME)
+            name.truncate(MAX_FILTER_NAME - 1);
+
+        int length = name.toWCharArray(pInfo->achName);
+        pInfo->achName[length] = '\0';
+
+        if (m_graph)
+            m_graph->AddRef();
+
+        pInfo->pGraph = m_graph;
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowIOSource::QueryVendorInfo(LPWSTR *pVendorInfo)
+{
+    Q_UNUSED(pVendorInfo);
+
+    return E_NOTIMPL;
+}
+
+// IAMFilterMiscFlags
+ULONG DirectShowIOSource::GetMiscFlags()
+{
+    return AM_FILTER_MISC_FLAGS_IS_SOURCE;
+}
+
+// IPin
+HRESULT DirectShowIOSource::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
+{
+    QMutexLocker locker(&m_mutex);
+    if (!pReceivePin) {
+        return E_POINTER;
+    } else if (m_state != State_Stopped) {
+        return VFW_E_NOT_STOPPED;
+    } else if (m_peerPin) {
+        return VFW_E_ALREADY_CONNECTED;
+    } else { 
+        HRESULT hr = VFW_E_TYPE_NOT_ACCEPTED;
+
+        m_peerPin = pReceivePin;
+        m_peerPin->AddRef();
+
+        if (!pmt) {
+            IEnumMediaTypes *mediaTypes = 0;
+            if (pReceivePin->EnumMediaTypes(&mediaTypes) == S_OK) {
+                for (AM_MEDIA_TYPE *type = 0;
+                        mediaTypes->Next(1, &type, 0) == S_OK;
+                        DirectShowMediaType::deleteType(type)) {
+                    switch (tryConnect(pReceivePin, type)) {
+                        case S_OK:
+                            DirectShowMediaType::freeData(type);
+                            mediaTypes->Release();
+                            return S_OK;
+                        case VFW_E_NO_TRANSPORT:
+                            hr = VFW_E_NO_TRANSPORT;
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                mediaTypes->Release();
+            }
+            AM_MEDIA_TYPE type =
+            {
+                MEDIATYPE_Stream,  // majortype
+                MEDIASUBTYPE_NULL, // subtype
+                TRUE,              // bFixedSizeSamples
+                FALSE,             // bTemporalCompression
+                1,                 // lSampleSize
+                GUID_NULL,         // formattype
+                0,                 // pUnk
+                0,                 // cbFormat
+                0,                 // pbFormat
+            };
+
+            static const int count = sizeof(directshow_subtypes) / sizeof(GUID);
+
+            for (int i = 0; i < count; ++i) {
+                type.subtype = directshow_subtypes[i];
+
+                switch (tryConnect(pReceivePin, &type)) {
+                case S_OK:
+                    return S_OK;
+                case VFW_E_NO_TRANSPORT:
+                    hr = VFW_E_NO_TRANSPORT;
+                    break;
+                default:
+                    break;
+                }
+            }
+        } else if (pmt->majortype == MEDIATYPE_Stream &&  (hr = tryConnect(pReceivePin, pmt))) {
+            return S_OK;
+        }
+
+        m_peerPin->Release();
+        m_peerPin = 0;
+
+        m_mediaType.clear();
+
+        return hr;
+    }
+}
+
+HRESULT DirectShowIOSource::tryConnect(IPin *pin, const AM_MEDIA_TYPE *type)
+{
+    m_mediaType = *type;
+
+    HRESULT hr = pin->ReceiveConnection(this, type);
+
+    if (!SUCCEEDED(hr)) {
+        if (m_allocator) {
+            m_allocator->Release();
+            m_allocator = 0;
+        }
+    } else if (!m_allocator) {
+        hr = VFW_E_NO_TRANSPORT;
+
+        if (IMemInputPin *memPin = com_cast<IMemInputPin>(pin, IID_IMemInputPin)) {
+            if ((m_allocator = com_new<IMemAllocator>(CLSID_MemoryAllocator, IID_IMemAllocator))) {
+                ALLOCATOR_PROPERTIES properties;
+                if (memPin->GetAllocatorRequirements(&properties) == S_OK
+                        || m_allocator->GetProperties(&properties) == S_OK) {
+                    if (properties.cbAlign == 0)
+                        properties.cbAlign = 1;
+              
+                    ALLOCATOR_PROPERTIES actualProperties;
+                    if (SUCCEEDED(hr = m_allocator->SetProperties(&properties, &actualProperties)))
+                        hr = memPin->NotifyAllocator(m_allocator, TRUE);
+                }
+                if (!SUCCEEDED(hr)) {
+                    m_allocator->Release();
+                    m_allocator = 0;
+                }
+            }
+            memPin->Release();
+        }        
+        if (!SUCCEEDED(hr))
+            pin->Disconnect();
+    }
+    return hr;
+}
+
+HRESULT DirectShowIOSource::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
+{
+    Q_UNUSED(pConnector);
+    Q_UNUSED(pmt);
+    // Output pin.
+    return E_NOTIMPL;
+}
+
+HRESULT DirectShowIOSource::Disconnect()
+{
+    if (!m_peerPin) {
+        return S_FALSE;
+    } else if (m_state != State_Stopped) {
+        return VFW_E_NOT_STOPPED;
+    } else {
+        HRESULT hr = m_peerPin->Disconnect();
+
+        if (!SUCCEEDED(hr))
+            return hr;
+
+        if (m_allocator) {
+            m_allocator->Release();
+            m_allocator = 0;
+        }
+
+        m_peerPin->Release();
+        m_peerPin = 0;
+
+        m_mediaType.clear();
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowIOSource::ConnectedTo(IPin **ppPin)
+{
+    if (!ppPin) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        if (!m_peerPin) {
+            *ppPin = 0;
+
+            return VFW_E_NOT_CONNECTED;
+        } else {
+            m_peerPin->AddRef();
+
+            *ppPin = m_peerPin;
+
+            return S_OK;
+        }
+    }
+}
+
+HRESULT DirectShowIOSource::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
+{
+    if (!pmt) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        if (!m_peerPin) {
+            pmt = 0;
+
+            return VFW_E_NOT_CONNECTED;
+        } else {
+            DirectShowMediaType::copy(pmt, m_mediaType);
+
+            return S_OK;
+        }
+    }
+}
+
+HRESULT DirectShowIOSource::QueryPinInfo(PIN_INFO *pInfo)
+{
+    if (!pInfo) {
+        return E_POINTER;
+    } else {
+        AddRef();
+
+        pInfo->pFilter = this;
+        pInfo->dir = PINDIR_OUTPUT;
+
+        const int bytes = qMin(MAX_FILTER_NAME, (m_pinId.length() + 1) * 2);
+
+        qMemCopy(pInfo->achName, m_pinId.utf16(), bytes);
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowIOSource::QueryId(LPWSTR *Id)
+{
+    if (!Id) {
+        return E_POINTER;
+    } else {
+        const int bytes = (m_pinId.length() + 1) * 2;
+
+        *Id = static_cast<LPWSTR>(::CoTaskMemAlloc(bytes));
+
+        qMemCopy(*Id, m_pinId.utf16(), bytes);
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowIOSource::QueryAccept(const AM_MEDIA_TYPE *pmt)
+{
+    if (!pmt) {
+        return E_POINTER;
+    } else if (pmt->majortype == MEDIATYPE_Stream) {
+        return S_OK;
+    } else {
+        return S_FALSE;
+    }
+}
+
+HRESULT DirectShowIOSource::EnumMediaTypes(IEnumMediaTypes **ppEnum)
+{
+    if (!ppEnum) {
+        return E_POINTER;
+    } else {
+        *ppEnum = createMediaTypeEnum();
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowIOSource::QueryInternalConnections(IPin **apPin, ULONG *nPin)
+{
+    Q_UNUSED(apPin);
+    Q_UNUSED(nPin);
+
+    return E_NOTIMPL;
+}
+
+HRESULT DirectShowIOSource::EndOfStream()
+{
+    return S_OK;
+}
+
+HRESULT DirectShowIOSource::BeginFlush()
+{
+    return m_reader->BeginFlush();
+}
+
+HRESULT DirectShowIOSource::EndFlush()
+{
+    return m_reader->EndFlush();
+}
+
+HRESULT DirectShowIOSource::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
+{
+    Q_UNUSED(tStart);
+    Q_UNUSED(tStop);
+    Q_UNUSED(dRate);
+
+    return S_OK;
+}
+
+HRESULT DirectShowIOSource::QueryDirection(PIN_DIRECTION *pPinDir)
+{
+    if (!pPinDir) {
+        return E_POINTER;
+    } else {
+        *pPinDir = PINDIR_OUTPUT;
+
+        return S_OK;
+    }
+}
+
+QT_END_NAMESPACE
+
+DirectShowRcSource::DirectShowRcSource(DirectShowEventLoop *loop)
+    : DirectShowIOSource(loop)
+{
+}
+
+bool DirectShowRcSource::open(const QUrl &url)
+{
+    m_file.moveToThread(QCoreApplication::instance()->thread());
+
+    m_file.setFileName(QLatin1Char(':') + url.path());
+
+    if (m_file.open(QIODevice::ReadOnly)) {
+
+        setDevice(&m_file);
+
+        return true;
+    } else {
+        return false;
+    }
+}
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowiosource.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowiosource.h
new file mode 100644
index 0000000..1d917df
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowiosource.h
@@ -0,0 +1,157 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWIOSOURCE_H
+#define DIRECTSHOWIOSOURCE_H
+
+#include "directshowglobal.h"
+#include "directshowioreader.h"
+#include "directshowmediatype.h"
+#include "directshowmediatypelist.h"
+
+#include <QtCore/qfile.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowIOSource
+    : public DirectShowMediaTypeList
+    , public IBaseFilter
+    , public IAMFilterMiscFlags
+    , public IPin
+{
+public:
+    DirectShowIOSource(DirectShowEventLoop *loop);
+    ~DirectShowIOSource();
+
+    void setDevice(QIODevice *device);
+    void setAllocator(IMemAllocator *allocator);
+    
+    // IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+
+    // IPersist
+    HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID);
+
+    // IMediaFilter
+    HRESULT STDMETHODCALLTYPE Run(REFERENCE_TIME tStart);
+    HRESULT STDMETHODCALLTYPE Pause();
+    HRESULT STDMETHODCALLTYPE Stop();
+
+    HRESULT STDMETHODCALLTYPE GetState(DWORD dwMilliSecsTimeout, FILTER_STATE *pState);
+
+    HRESULT STDMETHODCALLTYPE SetSyncSource(IReferenceClock *pClock);
+    HRESULT STDMETHODCALLTYPE GetSyncSource(IReferenceClock **ppClock);
+
+    // IBaseFilter
+    HRESULT STDMETHODCALLTYPE EnumPins(IEnumPins **ppEnum);
+    HRESULT STDMETHODCALLTYPE FindPin(LPCWSTR Id, IPin **ppPin);
+
+    HRESULT STDMETHODCALLTYPE JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName);
+
+    HRESULT STDMETHODCALLTYPE QueryFilterInfo(FILTER_INFO *pInfo);
+    HRESULT STDMETHODCALLTYPE QueryVendorInfo(LPWSTR *pVendorInfo);
+
+    // IAMFilterMiscFlags
+    ULONG STDMETHODCALLTYPE GetMiscFlags();
+
+    // IPin
+    HRESULT STDMETHODCALLTYPE Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt);
+    HRESULT STDMETHODCALLTYPE ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt);
+    HRESULT STDMETHODCALLTYPE Disconnect();
+    HRESULT STDMETHODCALLTYPE ConnectedTo(IPin **ppPin);
+
+    HRESULT STDMETHODCALLTYPE ConnectionMediaType(AM_MEDIA_TYPE *pmt);
+
+    HRESULT STDMETHODCALLTYPE QueryPinInfo(PIN_INFO *pInfo);
+    HRESULT STDMETHODCALLTYPE QueryId(LPWSTR *Id);
+
+    HRESULT STDMETHODCALLTYPE QueryAccept(const AM_MEDIA_TYPE *pmt);
+
+    HRESULT STDMETHODCALLTYPE EnumMediaTypes(IEnumMediaTypes **ppEnum);
+
+    HRESULT STDMETHODCALLTYPE QueryInternalConnections(IPin **apPin, ULONG *nPin);
+
+    HRESULT STDMETHODCALLTYPE EndOfStream();
+
+    HRESULT STDMETHODCALLTYPE BeginFlush();
+    HRESULT STDMETHODCALLTYPE EndFlush();
+
+    HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
+
+    HRESULT STDMETHODCALLTYPE QueryDirection(PIN_DIRECTION *pPinDir);
+
+private:
+    HRESULT tryConnect(IPin *pin, const AM_MEDIA_TYPE *type);
+
+    volatile LONG m_ref;
+    FILTER_STATE m_state;
+    DirectShowIOReader *m_reader;
+    DirectShowEventLoop *m_loop;
+    IFilterGraph *m_graph;
+    IReferenceClock *m_clock;
+    IMemAllocator *m_allocator;
+    IPin *m_peerPin;
+    DirectShowMediaType m_mediaType;
+    QString m_filterName;
+    const QString m_pinId;
+    QMutex m_mutex;
+};
+
+class DirectShowRcSource : public DirectShowIOSource
+{
+public:
+    DirectShowRcSource(DirectShowEventLoop *loop);
+
+    bool open(const QUrl &url);
+
+private:
+    QFile m_file;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatype.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatype.cpp
new file mode 100644
index 0000000..f8f519d
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatype.cpp
@@ -0,0 +1,205 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowmediatype.h"
+
+
+QT_BEGIN_NAMESPACE
+
+namespace
+{
+    struct TypeLookup
+    {
+        QVideoFrame::PixelFormat pixelFormat;
+        GUID mediaType;
+    };
+
+    static const TypeLookup qt_typeLookup[] =
+    {
+        { QVideoFrame::Format_RGB32,   /*MEDIASUBTYPE_RGB32*/  {0xe436eb7e, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
+        { QVideoFrame::Format_BGR24,   /*MEDIASUBTYPE_RGB24*/  {0xe436eb7d, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
+        { QVideoFrame::Format_RGB565,  /*MEDIASUBTYPE_RGB565*/ {0xe436eb7b, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
+        { QVideoFrame::Format_RGB555,  /*MEDIASUBTYPE_RGB555*/ {0xe436eb7c, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70}} },
+        { QVideoFrame::Format_AYUV444, /*MEDIASUBTYPE_AYUV*/   {0x56555941, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_YUYV,    /*MEDIASUBTYPE_YUY2*/   {0x32595559, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_UYVY,    /*MEDIASUBTYPE_UYVY*/   {0x59565955, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_IMC1,    /*MEDIASUBTYPE_IMC1*/   {0x31434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_IMC2,    /*MEDIASUBTYPE_IMC2*/   {0x32434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_IMC3,    /*MEDIASUBTYPE_IMC3*/   {0x33434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_IMC4,    /*MEDIASUBTYPE_IMC4*/   {0x34434D49, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_YV12,    /*MEDIASUBTYPE_YV12*/   {0x32315659, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_NV12,    /*MEDIASUBTYPE_NV12*/   {0x3231564E, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} },
+        { QVideoFrame::Format_YUV420P, /*MEDIASUBTYPE_IYUV*/   {0x56555949, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}} }
+    };
+}
+
+void DirectShowMediaType::copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE &source)
+{
+    *target = source;
+
+    if (source.cbFormat > 0) {
+        target->pbFormat = reinterpret_cast<PBYTE>(CoTaskMemAlloc(source.cbFormat));
+        memcpy(target->pbFormat, source.pbFormat, source.cbFormat);
+    }
+    if (target->pUnk)
+        target->pUnk->AddRef();
+}
+
+void DirectShowMediaType::deleteType(AM_MEDIA_TYPE *type)
+{
+    freeData(type);
+
+    CoTaskMemFree(type);
+}
+
+void DirectShowMediaType::freeData(AM_MEDIA_TYPE *type)
+{
+    if (type->cbFormat > 0)
+        CoTaskMemFree(type->pbFormat);
+
+    if (type->pUnk)
+        type->pUnk->Release();
+}
+
+
+GUID DirectShowMediaType::convertPixelFormat(QVideoFrame::PixelFormat format)
+{
+    // MEDIASUBTYPE_None;
+    static const GUID none = {
+        0xe436eb8e, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70} };
+
+    const int count = sizeof(qt_typeLookup) / sizeof(TypeLookup);
+
+    for (int i = 0; i < count; ++i)
+        if (qt_typeLookup[i].pixelFormat == format)
+            return qt_typeLookup[i].mediaType;
+    return none;
+}
+
+QVideoSurfaceFormat DirectShowMediaType::formatFromType(const AM_MEDIA_TYPE &type)
+{
+    const int count = sizeof(qt_typeLookup) / sizeof(TypeLookup);
+
+    for (int i = 0; i < count; ++i) {
+        if (IsEqualGUID(qt_typeLookup[i].mediaType, type.subtype) && type.cbFormat > 0) {
+            if (IsEqualGUID(type.formattype, FORMAT_VideoInfo)) {
+                VIDEOINFOHEADER *header = reinterpret_cast<VIDEOINFOHEADER *>(type.pbFormat);
+
+                QVideoSurfaceFormat format(
+                        QSize(header->bmiHeader.biWidth, qAbs(header->bmiHeader.biHeight)),
+                        qt_typeLookup[i].pixelFormat);
+
+                if (header->AvgTimePerFrame > 0)
+                    format.setFrameRate(10000 /header->AvgTimePerFrame);
+
+                switch (qt_typeLookup[i].pixelFormat) {
+                    case QVideoFrame::Format_RGB32:
+                    case QVideoFrame::Format_BGR24:
+                    case QVideoFrame::Format_RGB565:
+                    case QVideoFrame::Format_RGB555:
+                        if (header->bmiHeader.biHeight >= 0)
+                            format.setScanLineDirection(QVideoSurfaceFormat::BottomToTop);
+                        break;
+                    default:
+                        break;
+                }
+
+                return format;
+            } else if (IsEqualGUID(type.formattype, FORMAT_VideoInfo2)) {
+                VIDEOINFOHEADER2 *header = reinterpret_cast<VIDEOINFOHEADER2 *>(type.pbFormat);
+
+                QVideoSurfaceFormat format(
+                        QSize(header->bmiHeader.biWidth, qAbs(header->bmiHeader.biHeight)),
+                        qt_typeLookup[i].pixelFormat);
+
+                if (header->AvgTimePerFrame > 0)
+                    format.setFrameRate(10000 / header->AvgTimePerFrame);
+
+                switch (qt_typeLookup[i].pixelFormat) {
+                    case QVideoFrame::Format_RGB32:
+                    case QVideoFrame::Format_BGR24:
+                    case QVideoFrame::Format_RGB565:
+                    case QVideoFrame::Format_RGB555:
+                        if (header->bmiHeader.biHeight >= 0)
+                            format.setScanLineDirection(QVideoSurfaceFormat::BottomToTop);
+                        break;
+                    default:
+                        break;
+                }
+
+                return format;
+            }
+        }
+    }
+    return QVideoSurfaceFormat();
+}
+
+int DirectShowMediaType::bytesPerLine(const QVideoSurfaceFormat &format)
+{
+    switch (format.pixelFormat()) {
+    // 32 bpp packed formats.
+    case QVideoFrame::Format_RGB32:
+    case QVideoFrame::Format_AYUV444:
+        return format.frameWidth() * 4;
+    // 24 bpp packed formats.
+    case QVideoFrame::Format_RGB24:
+        return format.frameWidth() * 3 + 3 - format.frameWidth() % 4;
+    // 16 bpp packed formats.
+    case QVideoFrame::Format_RGB565:
+    case QVideoFrame::Format_RGB555:
+    case QVideoFrame::Format_YUYV:
+    case QVideoFrame::Format_UYVY:
+        return format.frameWidth() * 2 + 3 - format.frameWidth() % 4;
+    // Planar formats.
+    case QVideoFrame::Format_IMC1:
+    case QVideoFrame::Format_IMC2:
+    case QVideoFrame::Format_IMC3:
+    case QVideoFrame::Format_IMC4:
+    case QVideoFrame::Format_YV12:
+    case QVideoFrame::Format_NV12:
+    case QVideoFrame::Format_YUV420P:
+        return format.frameWidth() + 3 - format.frameWidth() % 4;
+    default:
+        return 0;
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatype.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatype.h
new file mode 100644
index 0000000..3cc7307
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatype.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWMEDIATYPE_H
+#define DIRECTSHOWMEDIATYPE_H
+
+#include <QtMultimedia/qvideosurfaceformat.h>
+
+#include <dshow.h>
+#include <dvdmedia.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+
+class DirectShowMediaType : public AM_MEDIA_TYPE
+{
+public:
+    DirectShowMediaType() { memset(this, 0, sizeof(DirectShowMediaType)); }
+    DirectShowMediaType(const AM_MEDIA_TYPE &type) { copy(this, type); }
+    DirectShowMediaType(const DirectShowMediaType &other) { copy(this, other); }
+    DirectShowMediaType &operator =(const AM_MEDIA_TYPE &type) {
+        freeData(this); copy(this, type); return *this; }
+    DirectShowMediaType &operator =(const DirectShowMediaType &other) {
+        freeData(this); copy(this, other); return *this; }
+    ~DirectShowMediaType() { freeData(this); }
+
+    void clear() { freeData(this); memset(this, 0, sizeof(DirectShowMediaType)); }
+
+    static void copy(AM_MEDIA_TYPE *target, const AM_MEDIA_TYPE &source);
+    static void freeData(AM_MEDIA_TYPE *type);
+    static void deleteType(AM_MEDIA_TYPE *type);
+
+    static GUID convertPixelFormat(QVideoFrame::PixelFormat format);
+    static QVideoSurfaceFormat formatFromType(const AM_MEDIA_TYPE &type);
+
+    static int bytesPerLine(const QVideoSurfaceFormat &format);
+};
+
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatypelist.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatypelist.cpp
new file mode 100644
index 0000000..f67794a
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatypelist.cpp
@@ -0,0 +1,229 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowmediatypelist.h"
+
+#include "directshowmediatype.h"
+#include "videosurfacefilter.h"
+
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowMediaTypeEnum : public IEnumMediaTypes
+{
+public:
+    DirectShowMediaTypeEnum(DirectShowMediaTypeList *list, int token, int index = 0);
+    ~DirectShowMediaTypeEnum();
+
+    // IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+
+    // IEnumMediaTypes
+    HRESULT STDMETHODCALLTYPE Next(
+            ULONG cMediaTypes, AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched);
+    HRESULT STDMETHODCALLTYPE Skip(ULONG cMediaTypes);
+    HRESULT STDMETHODCALLTYPE Reset();
+
+    HRESULT STDMETHODCALLTYPE Clone(IEnumMediaTypes **ppEnum);
+
+private:
+    LONG m_ref;
+    DirectShowMediaTypeList *m_list;
+    int m_mediaTypeToken;
+    int m_index;
+};
+
+
+DirectShowMediaTypeEnum::DirectShowMediaTypeEnum(
+        DirectShowMediaTypeList *list, int token, int index)
+    : m_ref(1)
+    , m_list(list)
+    , m_mediaTypeToken(token)
+    , m_index(index)
+{
+    m_list->AddRef();
+}
+
+DirectShowMediaTypeEnum::~DirectShowMediaTypeEnum()
+{
+    m_list->Release();
+}
+
+HRESULT DirectShowMediaTypeEnum::QueryInterface(REFIID riid, void **ppvObject)
+{
+    if (!ppvObject) {
+        return E_POINTER;
+    } else if (riid == IID_IUnknown
+            || riid == IID_IEnumMediaTypes) {
+        *ppvObject = static_cast<IEnumMediaTypes *>(this);
+    } else {
+        *ppvObject = 0;
+
+        return E_NOINTERFACE;
+    }
+
+    AddRef();
+
+    return S_OK;
+}
+
+ULONG DirectShowMediaTypeEnum::AddRef()
+{
+    return InterlockedIncrement(&m_ref);
+}
+
+ULONG DirectShowMediaTypeEnum::Release()
+{
+    ULONG ref = InterlockedDecrement(&m_ref);
+
+    if (ref == 0) {
+        delete this;
+    }
+
+    return ref;
+}
+
+HRESULT DirectShowMediaTypeEnum::Next(
+        ULONG cMediaTypes, AM_MEDIA_TYPE **ppMediaTypes, ULONG *pcFetched)
+{
+    return m_list->nextMediaType(m_mediaTypeToken, &m_index, cMediaTypes, ppMediaTypes, pcFetched);
+}
+
+HRESULT DirectShowMediaTypeEnum::Skip(ULONG cMediaTypes)
+{
+    return m_list->skipMediaType(m_mediaTypeToken, &m_index, cMediaTypes);
+}
+
+HRESULT DirectShowMediaTypeEnum::Reset()
+{
+    m_mediaTypeToken = m_list->currentMediaTypeToken();
+    m_index = 0;
+
+    return S_OK;
+}
+
+HRESULT DirectShowMediaTypeEnum::Clone(IEnumMediaTypes **ppEnum)
+{
+    return m_list->cloneMediaType(m_mediaTypeToken, m_index, ppEnum);
+}
+
+
+DirectShowMediaTypeList::DirectShowMediaTypeList()
+    : m_mediaTypeToken(0)
+{
+}
+
+IEnumMediaTypes *DirectShowMediaTypeList::createMediaTypeEnum()
+{
+    return new DirectShowMediaTypeEnum(this, m_mediaTypeToken, 0);
+}
+
+
+void DirectShowMediaTypeList::setMediaTypes(const QVector<AM_MEDIA_TYPE> &types)
+{
+    ++m_mediaTypeToken;
+
+    m_mediaTypes = types;
+}
+
+
+int DirectShowMediaTypeList::currentMediaTypeToken()
+{
+    return m_mediaTypeToken;
+}
+
+HRESULT DirectShowMediaTypeList::nextMediaType(
+        int token, int *index, ULONG count, AM_MEDIA_TYPE **types, ULONG *fetchedCount)
+{
+    if (!types || (count != 1 && !fetchedCount)) {
+        return E_POINTER;
+    } else if (m_mediaTypeToken != token) {
+        return VFW_E_ENUM_OUT_OF_SYNC;
+    } else {
+        int boundedCount = qBound<int>(0, count, m_mediaTypes.count() - *index);
+
+        for (int i = 0; i < boundedCount; ++i, ++(*index)) {
+            types[i] = reinterpret_cast<AM_MEDIA_TYPE *>(CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE)));
+
+            if (types[i]) {
+                DirectShowMediaType::copy(types[i], m_mediaTypes.at(*index));
+            } else {
+                for (--i; i >= 0; --i)
+                    CoTaskMemFree(types[i]);
+
+                if (fetchedCount)
+                    *fetchedCount = 0;
+
+                return E_OUTOFMEMORY;
+            }
+        }
+        if (fetchedCount)
+            *fetchedCount = boundedCount;
+
+        return boundedCount == count ? S_OK : S_FALSE;
+    }
+}
+
+HRESULT DirectShowMediaTypeList::skipMediaType(int token, int *index, ULONG count)
+{
+    if (m_mediaTypeToken != token) {
+        return VFW_E_ENUM_OUT_OF_SYNC;
+    } else {
+        *index = qMin<int>(*index + count, m_mediaTypes.size());
+
+        return *index < m_mediaTypes.size() ? S_OK : S_FALSE;
+    }
+}
+
+HRESULT DirectShowMediaTypeList::cloneMediaType(int token, int index, IEnumMediaTypes **enumeration)
+{
+    if (m_mediaTypeToken != token) {
+        return VFW_E_ENUM_OUT_OF_SYNC;
+    } else {
+        *enumeration = new DirectShowMediaTypeEnum(this, token, index);
+
+        return S_OK;
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatypelist.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatypelist.h
new file mode 100644
index 0000000..b49f24c
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowmediatypelist.h
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWMEDIATYPELIST_H
+#define DIRECTSHOWMEDIATYPELIST_H
+
+#include <QtCore/qvector.h>
+
+#include <dshow.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowMediaTypeList : public IUnknown
+{
+public:
+    DirectShowMediaTypeList();
+
+    IEnumMediaTypes *createMediaTypeEnum();
+
+    void setMediaTypes(const QVector<AM_MEDIA_TYPE> &types);
+
+    virtual int currentMediaTypeToken();
+    virtual HRESULT nextMediaType(
+            int token, int *index, ULONG count, AM_MEDIA_TYPE **types, ULONG *fetchedCount);
+    virtual HRESULT skipMediaType(int token, int *index, ULONG count);
+    virtual HRESULT cloneMediaType(int token, int index, IEnumMediaTypes **enumeration);
+
+private:
+    int m_mediaTypeToken;
+    QVector<AM_MEDIA_TYPE> m_mediaTypes;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowmetadatacontrol.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowmetadatacontrol.cpp
new file mode 100644
index 0000000..89821c4
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowmetadatacontrol.cpp
@@ -0,0 +1,370 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <dshow.h>
+#include <initguid.h>
+#include <qnetwork.h>
+
+#include "directshowmetadatacontrol.h"
+
+#include "directshowplayerservice.h"
+
+#include <QtCore/qcoreapplication.h>
+
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_WMSDK
+namespace
+{
+    struct QWMMetaDataKeyLookup
+    {
+        QtMultimedia::MetaData key;
+        const wchar_t *token;
+    };
+}
+
+static const QWMMetaDataKeyLookup qt_wmMetaDataKeys[] =
+{
+    { QtMultimedia::Title, L"Title" },
+    { QtMultimedia::SubTitle, L"WM/SubTitle" },
+    { QtMultimedia::Author, L"Author" },
+    { QtMultimedia::Comment, L"Comment" },
+    { QtMultimedia::Description, L"Description" },
+    { QtMultimedia::Category, L"WM/Category" },
+    { QtMultimedia::Genre, L"WM/Genre" },
+    //{ QtMultimedia::Date, 0 },
+    { QtMultimedia::Year, L"WM/Year" },
+    { QtMultimedia::UserRating, L"UserRating" },
+    //{ QtMultimedia::MetaDatawords, 0 },
+    { QtMultimedia::Language, L"Language" },
+    { QtMultimedia::Publisher, L"WM/Publisher" },
+    { QtMultimedia::Copyright, L"Copyright" },
+    { QtMultimedia::ParentalRating, L"ParentalRating" },
+    { QtMultimedia::RatingOrganisation, L"RatingOrganisation" },
+
+    // Media
+    { QtMultimedia::Size, L"FileSize" },
+    { QtMultimedia::MediaType, L"MediaType" },
+    { QtMultimedia::Duration, L"Duration" },
+
+    // Audio
+    { QtMultimedia::AudioBitRate, L"AudioBitRate" },
+    { QtMultimedia::AudioCodec, L"AudioCodec" },
+    { QtMultimedia::ChannelCount, L"ChannelCount" },
+    { QtMultimedia::SampleRate, L"Frequency" },
+
+    // Music
+    { QtMultimedia::AlbumTitle, L"WM/AlbumTitle" },
+    { QtMultimedia::AlbumArtist, L"WM/AlbumArtist" },
+    { QtMultimedia::ContributingArtist, L"Author" },
+    { QtMultimedia::Composer, L"WM/Composer" },
+    { QtMultimedia::Conductor, L"WM/Conductor" },
+    { QtMultimedia::Lyrics, L"WM/Lyrics" },
+    { QtMultimedia::Mood, L"WM/Mood" },
+    { QtMultimedia::TrackNumber, L"WM/TrackNumber" },
+    //{ QtMultimedia::TrackCount, 0 },
+    //{ QtMultimedia::CoverArtUriSmall, 0 },
+    //{ QtMultimedia::CoverArtUriLarge, 0 },
+
+    // Image/Video
+    //{ QtMultimedia::Resolution, 0 },
+    //{ QtMultimedia::PixelAspectRatio, 0 },
+
+    // Video
+    //{ QtMultimedia::FrameRate, 0 },
+    { QtMultimedia::VideoBitRate, L"VideoBitRate" },
+    { QtMultimedia::VideoCodec, L"VideoCodec" },
+
+    //{ QtMultimedia::PosterUri, 0 },
+
+    // Movie
+    { QtMultimedia::ChapterNumber, L"ChapterNumber" },
+    { QtMultimedia::Director, L"WM/Director" },
+    { QtMultimedia::LeadPerformer, L"LeadPerformer" },
+    { QtMultimedia::Writer, L"WM/Writer" },
+
+    // Photos
+    { QtMultimedia::CameraManufacturer, L"CameraManufacturer" },
+    { QtMultimedia::CameraModel, L"CameraModel" },
+    { QtMultimedia::Event, L"Event" },
+    { QtMultimedia::Subject, L"Subject" }
+};
+
+static QVariant getValue(IWMHeaderInfo *header, const wchar_t *key)
+{
+    WORD streamNumber = 0;
+    WMT_ATTR_DATATYPE type = WMT_TYPE_DWORD;
+    WORD size = 0;
+
+    if (header->GetAttributeByName(&streamNumber, key, &type, 0, &size) == S_OK) {
+        switch (type) {
+        case WMT_TYPE_DWORD:
+            if (size == sizeof(DWORD)) {
+                DWORD word;
+                if (header->GetAttributeByName(
+                        &streamNumber,
+                        key,
+                        &type,
+                        reinterpret_cast<BYTE *>(&word),
+                        &size) == S_OK) {
+                    return int(word);
+                }
+            }
+            break;
+        case WMT_TYPE_STRING:
+            {
+                QString string;
+                string.resize(size / 2 - 1);
+
+                if (header->GetAttributeByName(
+                        &streamNumber,
+                        key,
+                        &type,
+                        reinterpret_cast<BYTE *>(const_cast<ushort *>(string.utf16())),
+                        &size) == S_OK) {
+                    return string;
+                }
+            }
+            break;
+        case WMT_TYPE_BINARY:
+            {
+                QByteArray bytes;
+                bytes.resize(size);
+                if (header->GetAttributeByName(
+                        &streamNumber,
+                        key,
+                        &type,
+                        reinterpret_cast<BYTE *>(bytes.data()),
+                        &size) == S_OK) {
+                    return bytes;
+                }
+            }
+            break;
+        case WMT_TYPE_BOOL:
+            if (size == sizeof(DWORD)) {
+                DWORD word;
+                if (header->GetAttributeByName(
+                        &streamNumber,
+                        key,
+                        &type,
+                        reinterpret_cast<BYTE *>(&word),
+                        &size) == S_OK) {
+                    return bool(word);
+                }
+            }
+            break;
+        case WMT_TYPE_QWORD:
+            if (size == sizeof(QWORD)) {
+                QWORD word;
+                if (header->GetAttributeByName(
+                        &streamNumber,
+                        key,
+                        &type,
+                        reinterpret_cast<BYTE *>(&word),
+                        &size) == S_OK) {
+                    return qint64(word);
+                }
+            }
+            break;
+        case WMT_TYPE_WORD:
+            if (size == sizeof(WORD)){
+                WORD word;
+                if (header->GetAttributeByName(
+                        &streamNumber,
+                        key, 
+                        &type,
+                        reinterpret_cast<BYTE *>(&word),
+                        &size) == S_OK) {
+                    return short(word);
+                }
+            }
+            break;
+        case WMT_TYPE_GUID:
+            if (size == 16) {
+            }
+            break;
+        default:
+            break;
+        }
+    }
+    return QVariant();
+}
+#endif
+
+DirectShowMetaDataControl::DirectShowMetaDataControl(QObject *parent)
+    : QMetaDataControl(parent)
+    , m_content(0)
+#ifndef QT_NO_WMSDK
+    , m_headerInfo(0)
+#endif
+{
+}
+
+DirectShowMetaDataControl::~DirectShowMetaDataControl()
+{
+}
+
+bool DirectShowMetaDataControl::isWritable() const
+{
+    return false;
+}
+
+bool DirectShowMetaDataControl::isMetaDataAvailable() const
+{
+#ifndef QT_NO_WMSDK
+    return m_content || m_headerInfo;
+#else
+    return m_content;
+#endif
+}
+
+QVariant DirectShowMetaDataControl::metaData(QtMultimedia::MetaData key) const
+{
+    QVariant value;
+
+#ifndef QT_NO_WMSDK
+    if (m_headerInfo) {
+        static const int  count = sizeof(qt_wmMetaDataKeys) / sizeof(QWMMetaDataKeyLookup);
+        for (int i = 0; i < count; ++i) {
+            if (qt_wmMetaDataKeys[i].key == key) {
+                value = getValue(m_headerInfo, qt_wmMetaDataKeys[i].token);
+                break;
+            }
+        }
+    }  else if (m_content) {
+#else
+    if (m_content) {
+#endif
+        BSTR string = 0;
+
+        switch (key) {
+        case QtMultimedia::Author:
+            m_content->get_AuthorName(&string);
+            break;
+        case QtMultimedia::Title:
+            m_content->get_Title(&string);
+            break;
+        case QtMultimedia::ParentalRating:
+            m_content->get_Rating(&string);
+            break;
+        case QtMultimedia::Description:
+            m_content->get_Description(&string);
+            break;
+        case QtMultimedia::Copyright:
+            m_content->get_Copyright(&string);
+            break;
+        default:
+            break;
+        }
+
+        if (string) {
+            value = QString::fromUtf16(reinterpret_cast<ushort *>(string), ::SysStringLen(string));
+
+            ::SysFreeString(string);
+        }
+    }
+    return value;
+}
+
+void DirectShowMetaDataControl::setMetaData(QtMultimedia::MetaData, const QVariant &)
+{
+}
+
+QList<QtMultimedia::MetaData> DirectShowMetaDataControl::availableMetaData() const
+{
+    return QList<QtMultimedia::MetaData>();
+}
+
+QVariant DirectShowMetaDataControl::extendedMetaData(const QString &) const
+{
+    return QVariant();
+}
+
+void DirectShowMetaDataControl::setExtendedMetaData(const QString &, const QVariant &)
+{
+}
+
+QStringList DirectShowMetaDataControl::availableExtendedMetaData() const
+{
+    return QStringList();
+}
+
+void DirectShowMetaDataControl::updateGraph(IFilterGraph2 *graph, IBaseFilter *source)
+{
+    if (m_content)
+        m_content->Release();
+
+    if (!graph || graph->QueryInterface(
+            IID_IAMMediaContent, reinterpret_cast<void **>(&m_content)) != S_OK) {
+        m_content = 0;
+    }
+
+#ifdef QT_NO_WMSDK
+    Q_UNUSED(source);
+#else
+    if (m_headerInfo)
+        m_headerInfo->Release();
+
+    m_headerInfo = com_cast<IWMHeaderInfo>(source, IID_IWMHeaderInfo);
+#endif
+    // DirectShowMediaPlayerService holds a lock at this point so defer emitting signals to a later
+    // time.
+    QCoreApplication::postEvent(this, new QEvent(QEvent::Type(MetaDataChanged)));
+}
+
+void DirectShowMetaDataControl::customEvent(QEvent *event)
+{
+    if (event->type() == QEvent::Type(MetaDataChanged)) {
+        event->accept();
+
+        emit metaDataChanged();
+#ifndef QT_NO_WMSDK
+        emit metaDataAvailableChanged(m_content || m_headerInfo);
+#else
+        emit metaDataAvailableChanged(m_content);
+#endif
+    } else {
+        QMetaDataControl::customEvent(event);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowmetadatacontrol.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowmetadatacontrol.h
new file mode 100644
index 0000000..9a81ba8
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowmetadatacontrol.h
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWMETADATACONTROL_H
+#define DIRECTSHOWMETADATACONTROL_H
+
+#include "directshowglobal.h"
+
+#include <QtMultimedia/qmetadatacontrol.h>
+
+#include <qnetwork.h>
+
+#ifndef QT_NO_WMSDK
+#include <wmsdk.h>
+#endif
+
+#include <QtCore/qcoreevent.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowPlayerService;
+
+
+class DirectShowMetaDataControl : public QMetaDataControl
+{
+    Q_OBJECT
+public:
+    DirectShowMetaDataControl(QObject *parent = 0);
+    ~DirectShowMetaDataControl();
+
+    bool isWritable() const;
+    bool isMetaDataAvailable() const;
+
+    QVariant metaData(QtMultimedia::MetaData key) const;
+    void setMetaData(QtMultimedia::MetaData key, const QVariant &value);
+    QList<QtMultimedia::MetaData> availableMetaData() const;
+
+    QVariant extendedMetaData(const QString &key) const;
+    void setExtendedMetaData(const QString &key, const QVariant &value);
+    QStringList availableExtendedMetaData() const;
+
+    void updateGraph(IFilterGraph2 *graph, IBaseFilter *source);
+
+protected:
+    void customEvent(QEvent *event);
+
+private:
+    enum Event
+    {
+        MetaDataChanged = QEvent::User
+    };
+
+    IAMMediaContent *m_content;
+#ifndef QT_NO_WMSDK
+    IWMHeaderInfo *m_headerInfo;
+#endif
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowpinenum.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowpinenum.cpp
new file mode 100644
index 0000000..19f65da
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowpinenum.cpp
@@ -0,0 +1,140 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowpinenum.h"
+
+#include <QtMultimedia>
+
+
+QT_BEGIN_NAMESPACE
+
+DirectShowPinEnum::DirectShowPinEnum(const QList<IPin *> &pins)
+    : m_ref(1)
+    , m_pins(pins)
+    , m_index(0)
+{
+    foreach (IPin *pin, m_pins)
+        pin->AddRef();
+}
+
+DirectShowPinEnum::~DirectShowPinEnum()
+{
+    foreach (IPin *pin, m_pins)
+        pin->Release();
+}
+
+HRESULT DirectShowPinEnum::QueryInterface(REFIID riid, void **ppvObject)
+{
+    if (riid == IID_IUnknown
+            || riid == IID_IEnumPins) {
+        AddRef();
+
+        *ppvObject = static_cast<IEnumPins *>(this);
+
+        return S_OK;
+    } else {
+        *ppvObject = 0;
+
+        return E_NOINTERFACE;
+    }
+}
+
+ULONG DirectShowPinEnum::AddRef()
+{
+    return InterlockedIncrement(&m_ref);
+}
+
+ULONG DirectShowPinEnum::Release()
+{
+    ULONG ref = InterlockedDecrement(&m_ref);
+
+    if (ref == 0) {
+        delete this;
+    }
+
+    return ref;
+}
+
+HRESULT DirectShowPinEnum::Next(ULONG cPins, IPin **ppPins, ULONG *pcFetched)
+{
+    if (ppPins && (pcFetched || cPins == 1)) {
+        ULONG count = qBound<ULONG>(0, cPins, m_pins.count() - m_index);
+
+        for (ULONG i = 0; i < count; ++i, ++m_index) {
+            ppPins[i] = m_pins.at(m_index);
+            ppPins[i]->AddRef();
+        }
+
+        if (pcFetched)
+            *pcFetched = count;
+
+        return count == cPins ? S_OK : S_FALSE;
+    } else {
+        return E_POINTER;
+    }
+}
+
+HRESULT DirectShowPinEnum::Skip(ULONG cPins)
+{
+    m_index = qMin(int(m_index + cPins), m_pins.count());
+
+    return m_index < m_pins.count() ? S_OK : S_FALSE;
+}
+
+HRESULT DirectShowPinEnum::Reset()
+{
+    m_index = 0;
+
+    return S_OK;
+}
+
+HRESULT DirectShowPinEnum::Clone(IEnumPins **ppEnum)
+{
+    if (ppEnum) {
+        *ppEnum = new DirectShowPinEnum(m_pins);
+
+        return S_OK;
+    } else {
+        return E_POINTER;
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowpinenum.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowpinenum.h
new file mode 100644
index 0000000..40d99ea
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowpinenum.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWPINENUM_H
+#define DIRECTSHOWPINENUM_H
+
+#include <QtCore/qlist.h>
+
+#include <dshow.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowPinEnum : public IEnumPins
+{
+public:
+    DirectShowPinEnum(const QList<IPin *> &pins);
+    ~DirectShowPinEnum();
+
+    // IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+
+    // IEnumPins
+    HRESULT STDMETHODCALLTYPE Next(ULONG cPins, IPin **ppPins, ULONG *pcFetched);
+    HRESULT STDMETHODCALLTYPE Skip(ULONG cPins);
+    HRESULT STDMETHODCALLTYPE Reset();
+    HRESULT STDMETHODCALLTYPE Clone(IEnumPins **ppEnum);
+
+private:
+    LONG m_ref;
+    QList<IPin *> m_pins;
+    int m_index;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowplayercontrol.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowplayercontrol.cpp
new file mode 100644
index 0000000..67d07e1
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowplayercontrol.cpp
@@ -0,0 +1,395 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowplayercontrol.h"
+
+#include "directshowplayerservice.h"
+
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qmath.h>
+
+
+QT_BEGIN_NAMESPACE
+
+static int volumeToDecibels(int volume)
+{
+    if (volume == 0) {
+        return -10000;
+    } else if (volume == 100) {
+        return 0;
+#ifdef QT_USE_MATH_H_FLOATS
+    } else if (sizeof(qreal) == sizeof(float)) {
+        return qRound(::log10f(float(volume) / 100) * 5000);
+#endif
+    } else {
+        return qRound(::log10(qreal(volume) / 100) * 5000);
+    }
+}
+
+static int decibelsToVolume(int dB)
+{
+    if (dB == -10000) {
+        return 0;
+    } else if (dB == 0) {
+        return 100;
+    } else {
+        return qRound(100 * qPow(10, qreal(dB) / 5000));
+    }
+}
+
+DirectShowPlayerControl::DirectShowPlayerControl(DirectShowPlayerService *service, QObject *parent)
+    : QMediaPlayerControl(parent)
+    , m_service(service)
+    , m_audio(0)
+    , m_updateProperties(0)
+    , m_state(QMediaPlayer::StoppedState)
+    , m_status(QMediaPlayer::UnknownMediaStatus)
+    , m_error(QMediaPlayer::NoError)
+    , m_streamTypes(0)
+    , m_muteVolume(-1)
+    , m_position(0)
+    , m_duration(0)
+    , m_playbackRate(1.0)
+    , m_seekable(false)
+{
+}
+
+DirectShowPlayerControl::~DirectShowPlayerControl()
+{
+    if (m_audio)
+        m_audio->Release();
+}
+
+QMediaPlayer::State DirectShowPlayerControl::state() const
+{
+    return m_state;
+}
+
+QMediaPlayer::MediaStatus DirectShowPlayerControl::mediaStatus() const
+{
+    return m_status;
+}
+
+qint64 DirectShowPlayerControl::duration() const
+{
+    return m_duration;
+}
+
+qint64 DirectShowPlayerControl::position() const
+{
+    return const_cast<qint64 &>(m_position) = m_service->position();
+}
+
+void DirectShowPlayerControl::setPosition(qint64 position)
+{
+    m_service->seek(position);
+}
+
+int DirectShowPlayerControl::volume() const
+{
+    if (m_muteVolume >= 0) {
+        return m_muteVolume;
+    } else if (m_audio) {
+        long dB = 0;
+
+        m_audio->get_Volume(&dB);
+
+        return decibelsToVolume(dB);
+    } else {
+        return 0;
+    }
+}
+
+void DirectShowPlayerControl::setVolume(int volume)
+{
+    int boundedVolume = qBound(0, volume, 100);
+
+    if (m_muteVolume >= 0) {
+        m_muteVolume = boundedVolume;
+
+        emit volumeChanged(m_muteVolume);
+    } else if (m_audio) {
+        m_audio->put_Volume(volumeToDecibels(volume));
+
+        emit volumeChanged(boundedVolume);
+    }
+}
+
+bool DirectShowPlayerControl::isMuted() const
+{
+    return m_muteVolume >= 0;
+}
+
+void DirectShowPlayerControl::setMuted(bool muted)
+{
+    if (muted && m_muteVolume < 0) {
+        if (m_audio) {
+            long dB = 0;
+
+            m_audio->get_Volume(&dB);
+
+            m_muteVolume = decibelsToVolume(dB);
+
+            m_audio->put_Volume(-10000);
+        } else {
+            m_muteVolume = 0;
+        }
+
+        emit mutedChanged(muted);
+    } else if (!muted && m_muteVolume >= 0) {
+        if (m_audio) {
+            m_audio->put_Volume(volumeToDecibels(m_muteVolume));
+        }
+        m_muteVolume = -1;
+
+        emit mutedChanged(muted);
+    }
+}
+
+int DirectShowPlayerControl::bufferStatus() const
+{
+    return m_service->bufferStatus();
+}
+
+bool DirectShowPlayerControl::isAudioAvailable() const
+{
+    return m_streamTypes & DirectShowPlayerService::AudioStream;
+}
+
+bool DirectShowPlayerControl::isVideoAvailable() const
+{
+    return m_streamTypes & DirectShowPlayerService::VideoStream;
+}
+
+bool DirectShowPlayerControl::isSeekable() const
+{
+    return m_seekable;
+}
+
+QMediaTimeRange DirectShowPlayerControl::availablePlaybackRanges() const
+{
+    return m_service->availablePlaybackRanges();
+}
+
+qreal DirectShowPlayerControl::playbackRate() const
+{
+    return m_playbackRate;
+}
+
+void DirectShowPlayerControl::setPlaybackRate(qreal rate)
+{
+    if (m_playbackRate != rate) {
+        m_service->setRate(rate);
+
+        emit playbackRateChanged(m_playbackRate = rate);
+    }
+}
+
+QMediaContent DirectShowPlayerControl::media() const
+{
+    return m_media;
+}
+
+const QIODevice *DirectShowPlayerControl::mediaStream() const
+{
+    return m_stream;
+}
+
+void DirectShowPlayerControl::setMedia(const QMediaContent &media, QIODevice *stream)
+{
+    m_media = media;
+    m_stream = stream;
+
+    m_updateProperties &= PlaybackRateProperty;
+
+    m_service->load(media, stream);
+
+    emitPropertyChanges();
+}
+
+void DirectShowPlayerControl::play()
+{
+    m_service->play();
+    emit stateChanged(m_state = QMediaPlayer::PlayingState);
+}
+
+void DirectShowPlayerControl::pause()
+{
+    m_service->pause();
+    emit stateChanged(m_state = QMediaPlayer::PausedState);
+}
+
+void DirectShowPlayerControl::stop()
+{
+    m_service->stop();
+    emit stateChanged(m_state = QMediaPlayer::StoppedState);
+}
+
+void DirectShowPlayerControl::customEvent(QEvent *event)
+{
+    if (event->type() == QEvent::Type(PropertiesChanged)) {
+        emitPropertyChanges();
+
+        event->accept();
+    } else {
+        QMediaPlayerControl::customEvent(event);
+    }
+}
+
+void DirectShowPlayerControl::emitPropertyChanges()
+{
+    int properties = m_updateProperties;
+    m_updateProperties = 0;
+
+    if ((properties & ErrorProperty) && m_error != QMediaPlayer::NoError)
+        emit error(m_error, m_errorString);
+
+    if (properties & PlaybackRateProperty)
+        emit playbackRateChanged(m_playbackRate);
+
+    if (properties & StreamTypesProperty) {
+        emit audioAvailableChanged(m_streamTypes & DirectShowPlayerService::AudioStream);
+        emit videoAvailableChanged(m_streamTypes & DirectShowPlayerService::VideoStream);
+    }
+
+    if (properties & PositionProperty)
+        emit positionChanged(m_position);
+
+    if (properties & DurationProperty)
+        emit durationChanged(m_duration);
+
+    if (properties & SeekableProperty)
+        emit seekableChanged(m_seekable);
+
+    if (properties & StatusProperty)
+        emit mediaStatusChanged(m_status);
+
+    if (properties & StateProperty)
+        emit stateChanged(m_state);
+}
+
+void DirectShowPlayerControl::scheduleUpdate(int properties)
+{
+    if (m_updateProperties == 0)
+        QCoreApplication::postEvent(this, new QEvent(QEvent::Type(PropertiesChanged)));
+
+    m_updateProperties |= properties;
+}
+
+void DirectShowPlayerControl::updateState(QMediaPlayer::State state)
+{
+    if (m_state != state) {
+        m_state = state;
+
+        scheduleUpdate(StateProperty);
+    }
+}
+
+void DirectShowPlayerControl::updateStatus(QMediaPlayer::MediaStatus status)
+{
+    if (m_status != status) {
+        m_status = status;
+
+        scheduleUpdate(StatusProperty);
+    }
+}
+
+void DirectShowPlayerControl::updateMediaInfo(qint64 duration, int streamTypes, bool seekable)
+{
+    int properties = 0;
+
+    if (m_duration != duration) {
+        m_duration = duration;
+
+        properties |= DurationProperty;
+    }
+    if (m_streamTypes != streamTypes) {
+        m_streamTypes = streamTypes;
+
+        properties |= StreamTypesProperty;
+    }
+
+    if (m_seekable != seekable) {
+        m_seekable = seekable;
+
+        properties |= SeekableProperty;
+    }
+
+    if (properties != 0)
+        scheduleUpdate(properties);
+}
+
+void DirectShowPlayerControl::updatePlaybackRate(qreal rate)
+{
+    if (m_playbackRate != rate) {
+        m_playbackRate = rate;
+
+        scheduleUpdate(PlaybackRateProperty);
+    }
+}
+
+void DirectShowPlayerControl::updateAudioOutput(IBaseFilter *filter)
+{
+    if (m_audio)
+        m_audio->Release();
+
+    m_audio = com_cast<IBasicAudio>(filter, IID_IBasicAudio);
+}
+
+void DirectShowPlayerControl::updateError(QMediaPlayer::Error error, const QString &errorString)
+{
+    m_error = error;
+    m_errorString = errorString;
+
+    if (m_error != QMediaPlayer::NoError)
+        scheduleUpdate(ErrorProperty);
+}
+
+void DirectShowPlayerControl::updatePosition(qint64 position)
+{
+    if (m_position != position) {
+        m_position = position;
+
+        scheduleUpdate(PositionProperty);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowplayercontrol.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowplayercontrol.h
new file mode 100644
index 0000000..dd25d30
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowplayercontrol.h
@@ -0,0 +1,153 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWPLAYERCONTROL_H
+#define DIRECTSHOWPLAYERCONTROL_H
+
+#include <QtMultimedia/qmediacontent.h>
+#include <QtMultimedia/qmediaplayercontrol.h>
+
+#include <QtCore/qcoreevent.h>
+
+#include "directshowplayerservice.h"
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowPlayerControl : public QMediaPlayerControl
+{
+    Q_OBJECT
+public:
+    DirectShowPlayerControl(DirectShowPlayerService *service, QObject *parent = 0);
+    ~DirectShowPlayerControl();
+
+    QMediaPlayer::State state() const;
+
+    QMediaPlayer::MediaStatus mediaStatus() const;
+
+    qint64 duration() const;
+
+    qint64 position() const;
+    void setPosition(qint64 position);
+
+    int volume() const;
+    void setVolume(int volume);
+
+    bool isMuted() const;
+    void setMuted(bool muted);
+
+    int bufferStatus() const;
+
+    bool isAudioAvailable() const;
+    bool isVideoAvailable() const;
+
+    bool isSeekable() const;
+    
+    QMediaTimeRange availablePlaybackRanges() const;
+
+    qreal playbackRate() const;
+    void setPlaybackRate(qreal rate);
+
+    QMediaContent media() const;
+    const QIODevice *mediaStream() const;
+    void setMedia(const QMediaContent &media, QIODevice *stream);
+
+    void play();
+    void pause();
+    void stop();
+
+    void updateState(QMediaPlayer::State state);
+    void updateStatus(QMediaPlayer::MediaStatus status);
+    void updateMediaInfo(qint64 duration, int streamTypes, bool seekable);
+    void updatePlaybackRate(qreal rate);
+    void updateAudioOutput(IBaseFilter *filter);
+    void updateError(QMediaPlayer::Error error, const QString &errorString);
+    void updatePosition(qint64 position);
+
+protected:
+    void customEvent(QEvent *event);
+
+private:
+    enum Properties
+    {
+        StateProperty        = 0x01,
+        StatusProperty       = 0x02,
+        StreamTypesProperty  = 0x04,
+        DurationProperty     = 0x08,
+        PlaybackRateProperty = 0x10,
+        SeekableProperty     = 0x20,
+        ErrorProperty        = 0x40,
+        PositionProperty     = 0x80
+    };
+
+    enum Event
+    {
+        PropertiesChanged = QEvent::User
+    };
+
+    void scheduleUpdate(int properties);
+    void emitPropertyChanges();
+
+    DirectShowPlayerService *m_service;
+    IBasicAudio *m_audio;
+    QIODevice *m_stream;
+    int m_updateProperties;
+    QMediaPlayer::State m_state;
+    QMediaPlayer::MediaStatus m_status;
+    QMediaPlayer::Error m_error;
+    int m_streamTypes;
+    int m_muteVolume;
+    qint64 m_position;
+    qint64 m_duration;
+    qreal m_playbackRate;
+    bool m_seekable;
+    QMediaContent m_media;
+    QString m_errorString;
+    
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowplayerservice.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowplayerservice.cpp
new file mode 100644
index 0000000..a5f143f
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowplayerservice.cpp
@@ -0,0 +1,1410 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowplayerservice.h"
+
+#include "directshowaudioendpointcontrol.h"
+#include "directshowiosource.h"
+#include "directshowmetadatacontrol.h"
+#include "directshowplayercontrol.h"
+#include "directshowvideooutputcontrol.h"
+#include "directshowvideorenderercontrol.h"
+#include "vmr9videowindowcontrol.h"
+
+#include <QtMultimedia/qmediacontent.h>
+
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qdatetime.h>
+#include <QtCore/qthread.h>
+#include <QtCore/qvarlengtharray.h>
+
+Q_GLOBAL_STATIC(DirectShowEventLoop, qt_directShowEventLoop)
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowPlayerServiceThread : public QThread
+{
+public:
+    DirectShowPlayerServiceThread(DirectShowPlayerService *service)
+        : m_service(service)
+    {
+    }
+
+protected:
+    void run() { m_service->run(); }
+
+private:
+    DirectShowPlayerService *m_service;
+};
+
+DirectShowPlayerService::DirectShowPlayerService(QObject *parent)
+    : QMediaService(parent)
+    , m_playerControl(0)
+    , m_metaDataControl(0)
+    , m_videoOutputControl(0)
+    , m_videoRendererControl(0)
+    , m_videoWindowControl(0)
+    , m_audioEndpointControl(0)
+    , m_taskThread(0)
+    , m_loop(qt_directShowEventLoop())
+    , m_pendingTasks(0)
+    , m_executingTask(0)
+    , m_executedTasks(0)
+    , m_taskHandle(::CreateEvent(0, 0, 0, 0))
+    , m_eventHandle(0)
+    , m_graphStatus(NoMedia)
+    , m_stream(0)
+    , m_graph(0)
+    , m_source(0)
+    , m_audioOutput(0)
+    , m_videoOutput(0)
+    , m_rate(1.0)
+    , m_position(0)
+    , m_duration(0)
+    , m_buffering(false)
+    , m_seekable(false)
+    , m_atEnd(false)
+{
+    m_playerControl = new DirectShowPlayerControl(this);
+    m_metaDataControl = new DirectShowMetaDataControl(this);
+    m_videoOutputControl = new DirectShowVideoOutputControl; 
+    m_audioEndpointControl = new DirectShowAudioEndpointControl(this);
+    m_videoRendererControl = new DirectShowVideoRendererControl(m_loop);
+    m_videoWindowControl = new Vmr9VideoWindowControl;
+
+    m_taskThread = new DirectShowPlayerServiceThread(this);
+    m_taskThread->start();
+
+    connect(m_videoOutputControl, SIGNAL(outputChanged()), this, SLOT(videoOutputChanged()));
+    connect(m_videoRendererControl, SIGNAL(filterChanged()), this, SLOT(videoOutputChanged()));
+}
+
+DirectShowPlayerService::~DirectShowPlayerService()
+{
+    {
+        QMutexLocker locker(&m_mutex);
+
+        releaseGraph();
+
+        m_pendingTasks = Shutdown;
+        ::SetEvent(m_taskHandle);
+    }
+
+    m_taskThread->wait();
+    delete m_taskThread;
+
+    if (m_audioOutput) {
+        m_audioOutput->Release();
+        m_audioOutput = 0;
+    }
+
+    if (m_videoOutput) {
+        m_videoOutput->Release();
+        m_videoOutput = 0;
+    }
+
+    delete m_playerControl;
+    delete m_audioEndpointControl;
+    delete m_metaDataControl;
+    delete m_videoOutputControl;
+    delete m_videoRendererControl;
+    delete m_videoWindowControl;
+
+    ::CloseHandle(m_taskHandle);
+}
+
+QMediaControl *DirectShowPlayerService::control(const char *name) const
+{
+    if (qstrcmp(name, QMediaPlayerControl_iid) == 0)
+        return m_playerControl;
+    else if (qstrcmp(name, QAudioEndpointSelector_iid) == 0)
+        return m_audioEndpointControl;
+    else if (qstrcmp(name, QMetaDataControl_iid) == 0)
+        return m_metaDataControl;
+    else if (qstrcmp(name, QVideoOutputControl_iid) == 0)
+        return m_videoOutputControl;
+    else if (qstrcmp(name, QVideoRendererControl_iid) == 0)
+        return m_videoRendererControl;
+    else if (qstrcmp(name, QVideoWindowControl_iid) == 0)
+        return m_videoWindowControl;
+    else
+        return 0;
+}
+
+void DirectShowPlayerService::load(const QMediaContent &media, QIODevice *stream)
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_pendingTasks = 0;
+
+    if (m_graph)
+        releaseGraph();
+
+    m_resources = media.resources();
+    m_stream = stream;
+    m_error = QMediaPlayer::NoError;
+    m_errorString = QString();
+    m_position = 0;
+    m_duration = 0;
+    m_streamTypes = 0;
+    m_executedTasks = 0;
+    m_buffering = false;
+    m_seekable = false;
+    m_atEnd = false;
+    m_metaDataControl->updateGraph(0, 0);
+
+    QCoreApplication::postEvent(this, new QEvent(QEvent::Type(VideoOutputChange)));
+
+    if (m_resources.isEmpty() && !stream) {
+        m_pendingTasks = 0;
+        m_graphStatus = NoMedia;
+
+        m_url.clear();
+    } else if (stream && (!stream->isReadable() || stream->isSequential())) {
+        m_pendingTasks = 0;
+        m_graphStatus = InvalidMedia;
+        m_error = QMediaPlayer::ResourceError;
+    } else {
+        // {36b73882-c2c8-11cf-8b46-00805f6cef60}
+        static const GUID iid_IFilterGraph2 = {
+            0x36b73882, 0xc2c8, 0x11cf, {0x8b, 0x46, 0x00, 0x80, 0x5f, 0x6c, 0xef, 0x60} };
+        m_graphStatus = Loading;
+
+        m_graph = com_new<IFilterGraph2>(CLSID_FilterGraph, iid_IFilterGraph2);
+
+        if (stream)
+            m_pendingTasks = SetStreamSource;
+        else
+            m_pendingTasks = SetUrlSource;
+
+        ::SetEvent(m_taskHandle);
+    }
+
+    m_playerControl->updateError(m_error, m_errorString);
+    m_playerControl->updateMediaInfo(m_duration, m_streamTypes, m_seekable);
+    m_playerControl->updateState(QMediaPlayer::StoppedState);
+    m_playerControl->updatePosition(m_position);
+    updateStatus();
+}
+
+void DirectShowPlayerService::doSetUrlSource(QMutexLocker *locker)
+{
+    IBaseFilter *source = 0;
+
+    QMediaResource resource = m_resources.takeFirst();
+    QUrl url = resource.url();
+
+    HRESULT hr = E_FAIL;
+
+    if (url.scheme() == QLatin1String("http") || url.scheme() == QLatin1String("https")) {
+        static const GUID clsid_WMAsfReader = {
+            0x187463a0, 0x5bb7, 0x11d3, {0xac, 0xbe, 0x00, 0x80, 0xc7, 0x5e, 0x24, 0x6e} };
+
+        // {56a868a6-0ad4-11ce-b03a-0020af0ba770}
+        static const GUID iid_IFileSourceFilter = {
+            0x56a868a6, 0x0ad4, 0x11ce, {0xb0, 0x3a, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70} };
+
+        if (IFileSourceFilter *fileSource = com_new<IFileSourceFilter>(
+                clsid_WMAsfReader, iid_IFileSourceFilter)) {
+            locker->unlock();
+            hr = fileSource->Load(reinterpret_cast<const OLECHAR *>(url.toString().utf16()), 0);
+            locker->relock();
+
+            if (SUCCEEDED(hr)) {
+                source = com_cast<IBaseFilter>(fileSource, IID_IBaseFilter);
+
+                if (!SUCCEEDED(hr = m_graph->AddFilter(source, L"Source")) && source) {
+                    source->Release();
+                    source = 0;
+                }
+            }
+
+            fileSource->Release();
+        }
+    } else if (url.scheme() == QLatin1String("qrc")) {
+        DirectShowRcSource *rcSource = new DirectShowRcSource(m_loop);
+
+        if (rcSource->open(url) && SUCCEEDED(hr = m_graph->AddFilter(rcSource, L"Source")))
+            source = rcSource;
+        else
+            rcSource->Release();
+    }
+
+    if (!SUCCEEDED(hr)) {
+        locker->unlock();
+        hr = m_graph->AddSourceFilter(
+                reinterpret_cast<const OLECHAR *>(url.toString().utf16()), L"Source", &source);
+        locker->relock();
+    }
+
+    if (SUCCEEDED(hr)) {
+        m_executedTasks |= SetSource;
+        m_pendingTasks |= Render;
+
+        if (m_audioOutput)
+            m_pendingTasks |= SetAudioOutput;
+        if (m_videoOutput)
+            m_pendingTasks |= SetVideoOutput;
+
+        if (m_rate != 1.0 && m_rate != 0.0)
+            m_pendingTasks |= SetRate;
+
+        m_source = source;
+    } else if (!m_resources.isEmpty()) {
+        m_pendingTasks |= SetUrlSource;
+    } else {
+        m_pendingTasks = 0;
+        m_graphStatus = InvalidMedia;
+
+        switch (hr) {
+        case VFW_E_UNKNOWN_FILE_TYPE:
+            m_error = QMediaPlayer::FormatError;
+            m_errorString = QString();
+            break;
+        case E_OUTOFMEMORY:
+        case VFW_E_CANNOT_LOAD_SOURCE_FILTER:
+        case VFW_E_NOT_FOUND:
+            m_error = QMediaPlayer::ResourceError;
+            m_errorString = QString();
+        default:
+            m_error = QMediaPlayer::ResourceError;
+            m_errorString = QString();
+            qWarning("DirectShowPlayerService::doSetUrlSource: Unresolved error code %x", uint(hr));
+            break;
+        }
+
+        QCoreApplication::postEvent(this, new QEvent(QEvent::Type(Error)));
+    }
+}
+
+void DirectShowPlayerService::doSetStreamSource(QMutexLocker *locker)
+{
+    DirectShowIOSource *source = new DirectShowIOSource(m_loop);
+    source->setDevice(m_stream);
+
+    if (SUCCEEDED(m_graph->AddFilter(source, L"Source"))) {
+        m_executedTasks |= SetSource;
+        m_pendingTasks |= Render;
+
+        if (m_audioOutput)
+            m_pendingTasks |= SetAudioOutput;
+        if (m_videoOutput)
+            m_pendingTasks |= SetVideoOutput;
+
+        if (m_rate != 1.0 && m_rate != 0.0)
+            m_pendingTasks |= SetRate;
+
+        m_source = source;
+    } else {
+        source->Release();
+
+        m_pendingTasks = 0;
+        m_graphStatus = InvalidMedia;
+
+        m_error = QMediaPlayer::ResourceError;
+        m_errorString = QString();
+
+        QCoreApplication::postEvent(this, new QEvent(QEvent::Type(Error)));
+    }
+}
+
+void DirectShowPlayerService::doRender(QMutexLocker *locker)
+{
+    if (m_executedTasks & Pause)
+        m_pendingTasks |= Pause;
+    else if (m_executedTasks & Play && m_rate != 0.0)
+        m_pendingTasks |= Play;
+
+    if (IMediaControl *control = com_cast<IMediaControl>(m_graph, IID_IMediaControl)) {
+        control->Stop();
+        control->Release();
+    }
+
+    if (m_pendingTasks & SetAudioOutput) {
+        m_graph->AddFilter(m_audioOutput, L"AudioOutput");
+
+        m_pendingTasks ^= SetAudioOutput;
+        m_executedTasks |= SetAudioOutput;
+    }
+    if (m_pendingTasks & SetVideoOutput) {
+        m_graph->AddFilter(m_videoOutput, L"VideoOutput");
+
+        m_pendingTasks ^= SetVideoOutput;
+        m_executedTasks |= SetVideoOutput;
+    }
+
+    IFilterGraph2 *graph = m_graph;
+    graph->AddRef();
+
+    QVarLengthArray<IBaseFilter *, 16> filters;
+    m_source->AddRef();
+    filters.append(m_source);
+
+    bool rendered = false;
+
+    HRESULT renderHr = S_OK;
+
+    while (!filters.isEmpty()) {
+        IEnumPins *pins = 0;
+        IBaseFilter *filter = filters[filters.size() - 1];
+        filters.removeLast();
+
+        if (!(m_pendingTasks & ReleaseFilters) && SUCCEEDED(filter->EnumPins(&pins))) {
+            int outputs = 0;
+            for (IPin *pin = 0; pins->Next(1, &pin, 0) == S_OK; pin->Release()) {
+                PIN_DIRECTION direction;
+                if (pin->QueryDirection(&direction) == S_OK && direction == PINDIR_OUTPUT) {
+                    ++outputs;
+
+                    IPin *peer = 0;
+                    if (pin->ConnectedTo(&peer) == S_OK) {
+                        PIN_INFO peerInfo;
+                        if (SUCCEEDED(peer->QueryPinInfo(&peerInfo)))
+                            filters.append(peerInfo.pFilter);
+                        peer->Release();
+                    } else {
+                        locker->unlock();
+                        HRESULT hr;
+                        if (SUCCEEDED(hr = graph->RenderEx(
+                                pin, /*AM_RENDEREX_RENDERTOEXISTINGRENDERERS*/ 1, 0))) {
+                            rendered = true;
+                        } else if (renderHr == S_OK || renderHr == VFW_E_NO_DECOMPRESSOR){
+                            renderHr = hr;
+                        }
+                        locker->relock();
+                    }
+                }
+            }
+
+            pins->Release();
+
+            if (outputs == 0)
+                rendered = true;
+        }
+        filter->Release();
+    }
+
+    if (m_audioOutput && !isConnected(m_audioOutput, PINDIR_INPUT)) {
+        graph->RemoveFilter(m_audioOutput);
+
+        m_executedTasks &= ~SetAudioOutput;
+    }
+
+    if (m_videoOutput && !isConnected(m_videoOutput, PINDIR_INPUT)) {
+        graph->RemoveFilter(m_videoOutput);
+
+        m_executedTasks &= ~SetVideoOutput;
+    }
+
+    graph->Release();
+
+    if (!(m_pendingTasks & ReleaseFilters)) {
+        if (rendered) {
+            if (!(m_executedTasks & FinalizeLoad))
+                m_pendingTasks |= FinalizeLoad;
+        } else {
+            m_pendingTasks = 0;
+
+            m_graphStatus = InvalidMedia;
+
+            if (!m_audioOutput && !m_videoOutput) {
+                m_error = QMediaPlayer::ResourceError;
+                m_errorString = QString();
+            } else {
+                switch (renderHr) {
+                case VFW_E_UNSUPPORTED_AUDIO:
+                case VFW_E_UNSUPPORTED_VIDEO:
+                case VFW_E_UNSUPPORTED_STREAM:
+                    m_error = QMediaPlayer::FormatError;
+                    m_errorString = QString();
+                default:
+                    m_error = QMediaPlayer::ResourceError;
+                    m_errorString = QString();
+                    qWarning("DirectShowPlayerService::doRender: Unresolved error code %x",
+                             uint(renderHr));
+                }
+            }
+
+            QCoreApplication::postEvent(this, new QEvent(QEvent::Type(Error)));
+        }
+
+        QCoreApplication::postEvent(this, new QEvent(QEvent::Type(VideoOutputChange)));
+
+        m_executedTasks |= Render;
+    }
+}
+
+void DirectShowPlayerService::doFinalizeLoad(QMutexLocker *locker)
+{
+    if (m_graphStatus != Loaded) {
+        if (IMediaEvent *event = com_cast<IMediaEvent>(m_graph, IID_IMediaEvent)) {
+            event->GetEventHandle(reinterpret_cast<OAEVENT *>(&m_eventHandle));
+            event->Release();
+        }
+        if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+            LONGLONG duration = 0;
+            seeking->GetDuration(&duration);
+            m_duration = duration / 10;
+
+            DWORD capabilities = 0;
+            seeking->GetCapabilities(&capabilities);
+            m_seekable = capabilities & AM_SEEKING_CanSeekAbsolute;
+
+            seeking->Release();
+        }
+    }
+
+    if ((m_executedTasks & SetOutputs) == SetOutputs) {
+        m_streamTypes = AudioStream | VideoStream;
+    } else {
+        m_streamTypes = findStreamTypes(m_source);
+    }
+
+    m_executedTasks |= FinalizeLoad;
+
+    m_graphStatus = Loaded;
+
+    QCoreApplication::postEvent(this, new QEvent(QEvent::Type(FinalizedLoad)));
+}
+
+void DirectShowPlayerService::releaseGraph()
+{
+    if (m_graph) {
+        if (m_executingTask != 0) {
+            // {8E1C39A1-DE53-11cf-AA63-0080C744528D}
+            static const GUID iid_IAMOpenProgress = {
+                0x8E1C39A1, 0xDE53, 0x11cf, {0xAA, 0x63, 0x00, 0x80, 0xC7, 0x44, 0x52, 0x8D} };
+
+            if (IAMOpenProgress *progress = com_cast<IAMOpenProgress>(
+                    m_graph, iid_IAMOpenProgress)) {
+                progress->AbortOperation();
+                progress->Release();
+            }
+            m_graph->Abort();
+        }
+        
+        m_pendingTasks = ReleaseGraph;
+
+        ::SetEvent(m_taskHandle);
+
+        m_loop->wait(&m_mutex);
+    }
+}
+
+void DirectShowPlayerService::doReleaseGraph(QMutexLocker *locker)
+{
+    Q_UNUSED(locker);
+
+    if (IMediaControl *control = com_cast<IMediaControl>(m_graph, IID_IMediaControl)) {
+        control->Stop();
+        control->Release();
+    }
+
+    if (m_source) {
+        m_source->Release();
+        m_source = 0;
+    }
+
+    m_eventHandle = 0;
+
+    m_graph->Release();
+    m_graph = 0;
+
+    m_loop->wake();
+}
+
+int DirectShowPlayerService::findStreamTypes(IBaseFilter *source) const
+{
+    QVarLengthArray<IBaseFilter *, 16> filters;
+    source->AddRef();
+    filters.append(source);
+
+    int streamTypes = 0;
+
+    while (!filters.isEmpty()) {
+        IEnumPins *pins = 0;
+        IBaseFilter *filter = filters[filters.size() - 1];
+        filters.removeLast();
+
+        if (SUCCEEDED(filter->EnumPins(&pins))) {
+            for (IPin *pin = 0; pins->Next(1, &pin, 0) == S_OK; pin->Release()) {
+                PIN_DIRECTION direction;
+                if (pin->QueryDirection(&direction) == S_OK && direction == PINDIR_OUTPUT) {
+                    AM_MEDIA_TYPE connectionType;
+                    if (SUCCEEDED(pin->ConnectionMediaType(&connectionType))) {
+                        IPin *peer = 0;
+
+                        if (connectionType.majortype == MEDIATYPE_Audio) {
+                            streamTypes |= AudioStream;
+                        } else if (connectionType.majortype == MEDIATYPE_Video) {
+                            streamTypes |= VideoStream;
+                        } else if (SUCCEEDED(pin->ConnectedTo(&peer))) {
+                            PIN_INFO peerInfo;
+                            if (SUCCEEDED(peer->QueryPinInfo(&peerInfo)))
+                                filters.append(peerInfo.pFilter);
+                            peer->Release();
+                        }
+                    } else {
+                        streamTypes |= findStreamType(pin);
+                    }
+                }
+            }
+        }
+        filter->Release();
+    }
+    return streamTypes;
+}
+
+int DirectShowPlayerService::findStreamType(IPin *pin) const
+{
+    IEnumMediaTypes *types;
+
+    if (SUCCEEDED(pin->EnumMediaTypes(&types))) {
+        bool video = false;
+        bool audio = false;
+        bool other = false;
+
+        for (AM_MEDIA_TYPE *type = 0;
+                types->Next(1, &type, 0) == S_OK;
+                DirectShowMediaType::deleteType(type)) {
+            if (type->majortype == MEDIATYPE_Audio)
+                audio = true;
+            else if (type->majortype == MEDIATYPE_Video)
+                video = true;
+            else
+                other = true;
+        }
+        types->Release();
+
+        if (other)
+            return 0;
+        else if (audio && !video)
+            return AudioStream;
+        else if (!audio && video)
+            return VideoStream;
+        else
+            return 0;
+    } else {
+        return 0;
+    }
+}
+
+void DirectShowPlayerService::play()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_rate != 0.0) {
+        m_pendingTasks &= ~Pause;
+        m_pendingTasks |= Play;
+    } else {
+        m_pendingTasks |= Pause;
+        m_executedTasks |= Play;
+    }
+
+    if (m_executedTasks & Render) {
+        if (m_executedTasks & Stop) {
+            m_atEnd = false;
+            m_position = 0;
+            m_pendingTasks |= Seek;
+            m_executedTasks ^= Stop;
+        }
+
+        ::SetEvent(m_taskHandle);
+    }
+}
+
+void DirectShowPlayerService::doPlay(QMutexLocker *locker)
+{
+    if (IMediaControl *control = com_cast<IMediaControl>(m_graph, IID_IMediaControl)) {
+        locker->unlock();
+        HRESULT hr = control->Run();
+        locker->relock();
+
+        control->Release();
+
+        if (SUCCEEDED(hr)) {
+            m_executedTasks |= Play;
+            m_executedTasks &= ~Pause;
+
+            QCoreApplication::postEvent(this, new QEvent(QEvent::Type(StatusChange)));
+        } else {
+            m_error = QMediaPlayer::ResourceError;
+            m_errorString = QString();
+            qWarning("DirectShowPlayerService::doPlay: Unresolved error code %x", uint(hr));
+
+            QCoreApplication::postEvent(this, new QEvent(QEvent::Type(Error)));
+        }
+    }
+}
+
+void DirectShowPlayerService::pause()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_pendingTasks &= ~Play;
+    m_pendingTasks |= Pause;
+
+    if (m_executedTasks & Render) {
+        if (m_executedTasks & Stop) {
+            m_atEnd = false;
+            m_position = 0;
+            m_pendingTasks |= Seek;
+            m_executedTasks ^= Stop;
+        }
+
+        ::SetEvent(m_taskHandle);
+    }
+}
+
+void DirectShowPlayerService::doPause(QMutexLocker *locker)
+{
+    if (IMediaControl *control = com_cast<IMediaControl>(m_graph, IID_IMediaControl)) {
+        locker->unlock();
+        HRESULT hr = control->Pause();
+        locker->relock();
+
+        control->Release();
+
+        if (SUCCEEDED(hr)) {
+            if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+                LONGLONG position = 0;
+
+                seeking->GetCurrentPosition(&position);
+                seeking->Release();
+
+                m_position = position / 10;
+            } else {
+                m_position = 0;
+            }
+
+            m_executedTasks |= Pause;
+
+            if (m_rate != 0.0)
+                m_executedTasks &= ~Play;
+
+            QCoreApplication::postEvent(this, new QEvent(QEvent::Type(StatusChange)));
+        } else {
+            m_error = QMediaPlayer::ResourceError;
+            m_errorString = QString();
+            qWarning("DirectShowPlayerService::doPause: Unresolved error code %x", uint(hr));
+
+            QCoreApplication::postEvent(this, new QEvent(QEvent::Type(Error)));
+        }
+    }
+}
+
+void DirectShowPlayerService::stop()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_pendingTasks &= ~(Play | Pause | Seek);
+
+    if ((m_executingTask | m_executedTasks) & (Play | Pause | Seek)) {
+        m_pendingTasks |= Stop;
+
+        ::SetEvent(m_taskHandle);
+
+        m_loop->wait(&m_mutex);
+    }
+
+}
+
+void DirectShowPlayerService::doStop(QMutexLocker *locker)
+{
+    if (m_executedTasks & (Play | Pause)) {
+        if (IMediaControl *control = com_cast<IMediaControl>(m_graph, IID_IMediaControl)) {
+            control->Stop();
+            control->Release();
+        }
+
+        if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+            LONGLONG position = 0;
+
+            seeking->GetCurrentPosition(&position);
+            seeking->Release();
+
+            m_position = position / 10;
+        } else {
+            m_position = 0;
+        }
+
+        m_executedTasks &= ~(Play | Pause);
+        
+        QCoreApplication::postEvent(this, new QEvent(QEvent::Type(StatusChange)));
+    }
+
+    m_executedTasks |= Stop;
+
+    m_loop->wake();
+}
+
+void DirectShowPlayerService::setRate(qreal rate)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_rate == rate)
+        return;
+
+    if (rate == 0.0) {
+        if (m_pendingTasks & Play) {
+            m_executedTasks |= Play;
+            m_pendingTasks &= ~(Play | SetRate);
+
+            if (!((m_executingTask | m_executedTasks) & Pause))
+                m_pendingTasks |= Pause;
+        } else if ((m_executingTask | m_executedTasks) & Play) {
+            m_pendingTasks |= Pause;
+        }
+    } else {
+        m_pendingTasks |= SetRate;
+
+        if (m_rate == 0.0 && (m_executedTasks & Play) && !(m_executingTask & Play))
+            m_pendingTasks |= Play;
+    }
+
+    m_rate = rate;
+
+    if (m_executedTasks & FinalizeLoad)
+        ::SetEvent(m_taskHandle);
+}
+
+void DirectShowPlayerService::doSetRate(QMutexLocker *locker)
+{
+    if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+        // Cache current values as we can't query IMediaSeeking during a seek due to the
+        // possibility of a deadlock when flushing the VideoSurfaceFilter.
+        LONGLONG currentPosition = 0;
+        seeking->GetCurrentPosition(&currentPosition);
+        m_position = currentPosition / 10;
+
+        LONGLONG minimum = 0;
+        LONGLONG maximum = 0;
+        m_playbackRange = SUCCEEDED(seeking->GetAvailable(&minimum, &maximum))
+                ? QMediaTimeRange(minimum / 10, maximum / 10)
+                : QMediaTimeRange();
+
+        locker->unlock();
+        HRESULT hr = seeking->SetRate(m_rate);
+        locker->relock();
+
+        if (!SUCCEEDED(hr)) {
+            double rate = 0.0;
+            m_rate = seeking->GetRate(&rate)
+                    ? rate
+                    : 1.0;
+        }
+
+        seeking->Release();
+    } else if (m_rate != 1.0) {
+        m_rate = 1.0;
+    }
+
+    QCoreApplication::postEvent(this, new QEvent(QEvent::Type(RateChange)));
+}
+
+qint64 DirectShowPlayerService::position() const
+{
+    QMutexLocker locker(const_cast<QMutex *>(&m_mutex));
+
+    if (m_graphStatus == Loaded) {
+        if (m_executingTask == Seek || m_executingTask == SetRate) {
+            return m_position;
+        } else if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+            LONGLONG position = 0;
+
+            seeking->GetCurrentPosition(&position);
+            seeking->Release();
+
+            const_cast<qint64 &>(m_position) = position / 10;
+
+            return m_position;
+        }
+    }
+    return 0;
+}
+
+QMediaTimeRange DirectShowPlayerService::availablePlaybackRanges() const
+{
+    QMutexLocker locker(const_cast<QMutex *>(&m_mutex));
+
+    if (m_graphStatus == Loaded) {
+        if (m_executingTask == Seek || m_executingTask == SetRate) {
+            return m_playbackRange;
+        } else if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+            LONGLONG minimum = 0;
+            LONGLONG maximum = 0;
+
+            HRESULT hr = seeking->GetAvailable(&minimum, &maximum);
+            seeking->Release();
+
+            if (SUCCEEDED(hr))
+                return QMediaTimeRange(minimum, maximum);
+        }
+    }
+    return QMediaTimeRange();
+}
+
+void DirectShowPlayerService::seek(qint64 position)
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_position = position;
+
+    m_pendingTasks |= Seek;
+
+    if (m_executedTasks & FinalizeLoad)
+        ::SetEvent(m_taskHandle);
+}
+
+void DirectShowPlayerService::doSeek(QMutexLocker *locker)
+{
+    if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+        LONGLONG seekPosition = LONGLONG(m_position) * 10;
+
+        // Cache current values as we can't query IMediaSeeking during a seek due to the
+        // possibility of a deadlock when flushing the VideoSurfaceFilter.
+        LONGLONG currentPosition = 0;
+        seeking->GetCurrentPosition(&currentPosition);
+        m_position = currentPosition / 10;
+
+        LONGLONG minimum = 0;
+        LONGLONG maximum = 0;
+        m_playbackRange = SUCCEEDED(seeking->GetAvailable(&minimum, &maximum))
+                ? QMediaTimeRange(minimum / 10, maximum / 10)
+                : QMediaTimeRange();
+
+        locker->unlock();
+        seeking->SetPositions(
+                &seekPosition, AM_SEEKING_AbsolutePositioning, 0, AM_SEEKING_NoPositioning);
+        locker->relock();
+
+        seeking->GetCurrentPosition(&currentPosition);
+        m_position = currentPosition / 10;
+
+        seeking->Release();
+    } else {
+        m_position = 0;
+    }
+
+    QCoreApplication::postEvent(this, new QEvent(QEvent::Type(PositionChange)));
+}
+
+int DirectShowPlayerService::bufferStatus() const
+{
+#ifndef QT_NO_WMSDK
+    QMutexLocker locker(const_cast<QMutex *>(&m_mutex));
+
+    if (IWMReaderAdvanced2 *reader = com_cast<IWMReaderAdvanced2>(
+            m_source, IID_IWMReaderAdvanced2)) {
+        DWORD percentage = 0;
+
+        reader->GetBufferProgress(&percentage, 0);
+        reader->Release();
+
+        return percentage;
+    } else {
+        return 0;
+    }
+#else
+    return 0;
+#endif
+}
+
+void DirectShowPlayerService::setAudioOutput(IBaseFilter *filter)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_graph) {
+        if (m_audioOutput) {
+            if (m_executedTasks & SetAudioOutput) {
+                m_pendingTasks |= ReleaseAudioOutput;
+
+                ::SetEvent(m_taskHandle);
+
+                m_loop->wait(&m_mutex);
+            }
+            m_audioOutput->Release();
+        } 
+
+        m_audioOutput = filter;
+
+        if (m_audioOutput) {
+            m_audioOutput->AddRef();
+
+            m_pendingTasks |= SetAudioOutput;
+
+            if (m_executedTasks & SetSource) {
+                m_pendingTasks |= Render;
+
+                ::SetEvent(m_taskHandle);
+            }
+        } else {
+            m_pendingTasks &= ~ SetAudioOutput;
+        }
+    } else {
+        if (m_audioOutput)
+            m_audioOutput->Release();
+
+        m_audioOutput = filter;
+
+        if (m_audioOutput)
+            m_audioOutput->AddRef();
+    }
+
+    m_playerControl->updateAudioOutput(m_audioOutput);
+}
+
+void DirectShowPlayerService::doReleaseAudioOutput(QMutexLocker *locker)
+{
+    m_pendingTasks |= m_executedTasks & (Play | Pause);
+
+    if (IMediaControl *control = com_cast<IMediaControl>(m_graph, IID_IMediaControl)) {
+        control->Stop();
+        control->Release();
+    }
+
+    IBaseFilter *decoder = getConnected(m_audioOutput, PINDIR_INPUT);
+    if (!decoder) {
+        decoder = m_audioOutput;
+        decoder->AddRef();
+    }
+
+    // {DCFBDCF6-0DC2-45f5-9AB2-7C330EA09C29}
+    static const GUID iid_IFilterChain = {
+        0xDCFBDCF6, 0x0DC2, 0x45f5, {0x9A, 0xB2, 0x7C, 0x33, 0x0E, 0xA0, 0x9C, 0x29} };
+
+    if (IFilterChain *chain = com_cast<IFilterChain>(m_graph, iid_IFilterChain)) {
+        chain->RemoveChain(decoder, m_audioOutput);
+        chain->Release();
+    } else {
+        m_graph->RemoveFilter(m_audioOutput);
+    }
+
+    decoder->Release();
+
+    m_executedTasks &= ~SetAudioOutput;
+
+    m_loop->wake();
+}
+
+void DirectShowPlayerService::setVideoOutput(IBaseFilter *filter)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_graph) {
+        if (m_videoOutput) {
+            if (m_executedTasks & SetVideoOutput) {
+                m_pendingTasks |= ReleaseVideoOutput;
+
+                ::SetEvent(m_taskHandle);
+
+                m_loop->wait(&m_mutex);
+            }
+            m_videoOutput->Release();
+        }
+
+        m_videoOutput = filter;
+
+        if (m_videoOutput) {
+            m_videoOutput->AddRef();
+
+            m_pendingTasks |= SetVideoOutput;
+
+            if (m_executedTasks & SetSource) {
+                m_pendingTasks |= Render;
+
+                ::SetEvent(m_taskHandle);
+            }
+        }
+    } else {
+        if (m_videoOutput)
+            m_videoOutput->Release();
+
+        m_videoOutput = filter;
+
+        if (m_videoOutput)
+            m_videoOutput->AddRef();
+    }
+}
+
+void DirectShowPlayerService::doReleaseVideoOutput(QMutexLocker *locker)
+{
+    m_pendingTasks |= m_executedTasks & (Play | Pause);
+
+    if (IMediaControl *control = com_cast<IMediaControl>(m_graph, IID_IMediaControl)) {
+        control->Stop();
+        control->Release();
+    }
+
+    IBaseFilter *intermediate = 0;
+    if (!SUCCEEDED(m_graph->FindFilterByName(L"Color Space Converter", &intermediate))) {
+        intermediate = m_videoOutput;
+        intermediate->AddRef();
+    }
+
+    IBaseFilter *decoder = getConnected(intermediate, PINDIR_INPUT);
+    if (!decoder) {
+        decoder = intermediate;
+        decoder->AddRef();
+    }
+
+    // {DCFBDCF6-0DC2-45f5-9AB2-7C330EA09C29}
+    static const GUID iid_IFilterChain = {
+        0xDCFBDCF6, 0x0DC2, 0x45f5, {0x9A, 0xB2, 0x7C, 0x33, 0x0E, 0xA0, 0x9C, 0x29} };
+
+    if (IFilterChain *chain = com_cast<IFilterChain>(m_graph, iid_IFilterChain)) {
+        chain->RemoveChain(decoder, m_videoOutput);
+        chain->Release();
+    } else {
+        m_graph->RemoveFilter(m_videoOutput);
+    }
+
+    intermediate->Release();
+    decoder->Release();
+
+    m_executedTasks &= ~SetVideoOutput;
+
+    m_loop->wake();
+}
+
+void DirectShowPlayerService::customEvent(QEvent *event)
+{
+    if (event->type() == QEvent::Type(FinalizedLoad)) {
+        QMutexLocker locker(&m_mutex);
+
+        m_playerControl->updateMediaInfo(m_duration, m_streamTypes, m_seekable);
+        m_metaDataControl->updateGraph(m_graph, m_source);
+
+        updateStatus();
+    } else if (event->type() == QEvent::Type(Error)) {
+        QMutexLocker locker(&m_mutex);
+
+        if (m_error != QMediaPlayer::NoError) {
+            m_playerControl->updateError(m_error, m_errorString);
+            m_playerControl->updateMediaInfo(m_duration, m_streamTypes, m_seekable);
+            m_playerControl->updateState(QMediaPlayer::StoppedState);
+            updateStatus();
+        }
+    } else if (event->type() == QEvent::Type(RateChange)) {
+        QMutexLocker locker(&m_mutex);
+
+        m_playerControl->updatePlaybackRate(m_rate);
+    } else if (event->type() == QEvent::Type(StatusChange)) {
+        QMutexLocker locker(&m_mutex);
+
+        updateStatus();
+        m_playerControl->updatePosition(m_position);
+    } else if (event->type() == QEvent::Type(DurationChange)) {
+        QMutexLocker locker(&m_mutex);
+
+        m_playerControl->updateMediaInfo(m_duration, m_streamTypes, m_seekable);
+    } else if (event->type() == QEvent::Type(EndOfMedia)) {
+        QMutexLocker locker(&m_mutex);
+
+        if (m_atEnd) {
+            m_playerControl->updateState(QMediaPlayer::StoppedState);
+            m_playerControl->updateStatus(QMediaPlayer::EndOfMedia);
+            m_playerControl->updatePosition(m_position);
+        }
+    } else if (event->type() == QEvent::Type(PositionChange)) {
+        QMutexLocker locker(&m_mutex);
+
+        m_playerControl->updatePosition(m_position);
+    } else if (event->type() == QEvent::Type(VideoOutputChange)) {
+        if (m_videoWindowControl)
+            m_videoWindowControl->updateNativeSize();
+    } else {
+        QMediaService::customEvent(event);
+    }
+}
+
+void DirectShowPlayerService::videoOutputChanged()
+{
+    IBaseFilter *videoOutput = 0;
+
+    switch (m_videoOutputControl->output()) {
+    case QVideoOutputControl::RendererOutput:
+        videoOutput = m_videoRendererControl->filter();
+        break;
+    case QVideoOutputControl::WindowOutput:
+        videoOutput = m_videoWindowControl->filter();
+        break;
+    default:
+        break;
+    }
+
+    setVideoOutput(videoOutput);
+}
+
+void DirectShowPlayerService::graphEvent(QMutexLocker *locker)
+{
+    if (IMediaEvent *event = com_cast<IMediaEvent>(m_graph, IID_IMediaEvent)) {
+        long eventCode;
+        LONG_PTR param1;
+        LONG_PTR param2;
+
+        while (event->GetEvent(&eventCode, &param1, &param2, 0) == S_OK) {
+            switch (eventCode) {
+            case EC_BUFFERING_DATA:
+                m_buffering = param1;
+
+                QCoreApplication::postEvent(this, new QEvent(QEvent::Type(StatusChange)));
+                break;
+            case EC_COMPLETE:
+                m_executedTasks &= ~(Play | Pause);
+                m_executedTasks |= Stop;
+
+                m_buffering = false;
+                m_atEnd = true;
+
+                if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+                    LONGLONG position = 0;
+
+                    seeking->GetCurrentPosition(&position);
+                    seeking->Release();
+
+                    m_position = position / 10;
+                }
+
+                QCoreApplication::postEvent(this, new QEvent(QEvent::Type(EndOfMedia)));
+                break;
+            case EC_LENGTH_CHANGED:
+                if (IMediaSeeking *seeking = com_cast<IMediaSeeking>(m_graph, IID_IMediaSeeking)) {
+                    LONGLONG duration = 0;
+                    seeking->GetDuration(&duration);
+                    m_duration = duration / 10;
+
+                    DWORD capabilities = 0;
+                    seeking->GetCapabilities(&capabilities);
+                    m_seekable = capabilities & AM_SEEKING_CanSeekAbsolute;
+
+                    seeking->Release();
+
+                    QCoreApplication::postEvent(this, new QEvent(QEvent::Type(DurationChange)));
+                }
+                break;
+            default:
+                break;
+            }
+
+            event->FreeEventParams(eventCode, param1, param2);
+        }
+        event->Release();
+    }
+}
+
+void DirectShowPlayerService::updateStatus()
+{
+    switch (m_graphStatus) {
+    case NoMedia:
+        m_playerControl->updateStatus(QMediaPlayer::NoMedia);
+        break;
+    case Loading:
+        m_playerControl->updateStatus(QMediaPlayer::LoadingMedia);
+        break;
+    case Loaded:
+        if ((m_pendingTasks | m_executingTask | m_executedTasks) & (Play | Pause)) {
+            if (m_buffering)
+                m_playerControl->updateStatus(QMediaPlayer::BufferingMedia);
+            else
+                m_playerControl->updateStatus(QMediaPlayer::BufferedMedia);
+        } else {
+            m_playerControl->updateStatus(QMediaPlayer::LoadedMedia);
+        }
+        break;
+    case InvalidMedia:
+        m_playerControl->updateStatus(QMediaPlayer::InvalidMedia);
+        break;
+    default:
+        m_playerControl->updateStatus(QMediaPlayer::UnknownMediaStatus);
+    }
+}
+
+bool DirectShowPlayerService::isConnected(IBaseFilter *filter, PIN_DIRECTION direction) const
+{
+    bool connected = false;
+
+    IEnumPins *pins = 0;
+
+    if (SUCCEEDED(filter->EnumPins(&pins))) {
+        for (IPin *pin = 0; pins->Next(1, &pin, 0) == S_OK; pin->Release()) {
+            PIN_DIRECTION dir;
+            if (SUCCEEDED(pin->QueryDirection(&dir)) && dir == direction) {
+                IPin *peer = 0;
+                if (SUCCEEDED(pin->ConnectedTo(&peer))) {
+                    connected = true;
+
+                    peer->Release();
+                }
+            }
+        }
+        pins->Release();
+    }
+    return connected;
+}
+
+IBaseFilter *DirectShowPlayerService::getConnected(
+        IBaseFilter *filter, PIN_DIRECTION direction) const
+{
+    IBaseFilter *connected = 0;
+
+    IEnumPins *pins = 0;
+
+    if (SUCCEEDED(filter->EnumPins(&pins))) {
+        for (IPin *pin = 0; pins->Next(1, &pin, 0) == S_OK; pin->Release()) {
+            PIN_DIRECTION dir;
+            if (SUCCEEDED(pin->QueryDirection(&dir)) && dir == direction) {
+                IPin *peer = 0;
+                if (SUCCEEDED(pin->ConnectedTo(&peer))) {
+                    PIN_INFO info;
+
+                    if (SUCCEEDED(peer->QueryPinInfo(&info))) {
+                        if (connected) {
+                            qWarning("DirectShowPlayerService::getConnected: "
+                                "Multiple connected filters");
+                            connected->Release();
+                        }
+                        connected = info.pFilter;
+                    }
+                    peer->Release();
+                }
+            }
+        }
+        pins->Release();
+    }
+    return connected;
+}
+
+void DirectShowPlayerService::run()
+{
+    QMutexLocker locker(&m_mutex);
+
+    for (;;) {
+        ::ResetEvent(m_taskHandle);
+
+        while (m_pendingTasks == 0) {
+            DWORD result = 0;
+
+            locker.unlock();
+            if (m_eventHandle) {
+                HANDLE handles[] = { m_taskHandle, m_eventHandle };
+
+                result = ::WaitForMultipleObjects(2, handles, false, INFINITE);
+            } else {
+                result = ::WaitForSingleObject(m_taskHandle, INFINITE);
+            }
+            locker.relock();
+
+            if (result == WAIT_OBJECT_0 + 1) {
+                graphEvent(&locker);
+            }
+        }
+
+        if (m_pendingTasks & ReleaseGraph) {
+            m_pendingTasks ^= ReleaseGraph;
+            m_executingTask = ReleaseGraph;
+
+            doReleaseGraph(&locker);
+        } else if (m_pendingTasks & Shutdown) {
+            return;
+        } else if (m_pendingTasks & ReleaseAudioOutput) {
+            m_pendingTasks ^= ReleaseAudioOutput;
+            m_executingTask = ReleaseAudioOutput;
+
+            doReleaseAudioOutput(&locker);
+        } else if (m_pendingTasks & ReleaseVideoOutput) {
+            m_pendingTasks ^= ReleaseVideoOutput;
+            m_executingTask = ReleaseVideoOutput;
+
+            doReleaseVideoOutput(&locker);
+        } else if (m_pendingTasks & SetUrlSource) {
+            m_pendingTasks ^= SetUrlSource;
+            m_executingTask = SetUrlSource;
+
+            doSetUrlSource(&locker);
+        } else if (m_pendingTasks & SetStreamSource) {
+            m_pendingTasks ^= SetStreamSource;
+            m_executingTask = SetStreamSource;
+
+            doSetStreamSource(&locker);
+        } else if (m_pendingTasks & Render) {
+            m_pendingTasks ^= Render;
+            m_executingTask = Render;
+
+            doRender(&locker);
+        } else if (!(m_executedTasks & Render)) {
+            m_pendingTasks &= ~(FinalizeLoad | SetRate | Stop | Pause | Seek | Play);
+        } else if (m_pendingTasks & FinalizeLoad) {
+            m_pendingTasks ^= FinalizeLoad;
+            m_executingTask = FinalizeLoad;
+
+            doFinalizeLoad(&locker);
+        } else if (m_pendingTasks & Stop) {
+            m_pendingTasks ^= Stop;
+            m_executingTask = Stop;
+
+            doStop(&locker);
+        } else if (m_pendingTasks & Pause) {
+            m_pendingTasks ^= Pause;
+            m_executingTask = Pause;
+
+            doPause(&locker);
+        } else if (m_pendingTasks & SetRate) {
+            m_pendingTasks ^= SetRate;
+            m_executingTask = SetRate;
+
+            doSetRate(&locker);
+        } else if (m_pendingTasks & Seek) {
+            m_pendingTasks ^= Seek;
+            m_executingTask = Seek;
+
+            doSeek(&locker);
+        } else if (m_pendingTasks & Play) {
+            m_pendingTasks ^= Play;
+            m_executingTask = Play;
+
+            doPlay(&locker);
+        }
+        m_executingTask = 0;
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowplayerservice.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowplayerservice.h
new file mode 100644
index 0000000..d3ef809
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowplayerservice.h
@@ -0,0 +1,220 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWPLAYERSERVICE_H
+#define DIRECTSHOWPLAYERSERVICE_H
+
+#include <QtMultimedia/qmediaplayer.h>
+#include <QtMultimedia/qmediaresource.h>
+#include <QtMultimedia/qmediaservice.h>
+#include <QtMultimedia/qmediatimerange.h>
+
+#include "directshoweventloop.h"
+#include "directshowglobal.h"
+
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qurl.h>
+#include <QtCore/qwaitcondition.h>
+
+#include <QtCore/private/qwineventnotifier_p.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowAudioEndpointControl;
+class DirectShowMetaDataControl;
+class DirectShowPlayerControl;
+class DirectShowVideoOutputControl;
+class DirectShowVideoRendererControl;
+class Vmr9VideoWindowControl;
+
+class DirectShowPlayerService : public QMediaService
+{
+    Q_OBJECT
+public:
+    enum StreamType
+    {
+        AudioStream = 0x01,
+        VideoStream = 0x02
+    };
+
+    DirectShowPlayerService(QObject *parent = 0);
+    ~DirectShowPlayerService();
+
+    QMediaControl* control(const char *name) const;
+
+    void load(const QMediaContent &media, QIODevice *stream);
+    void play();
+    void pause();
+    void stop();
+
+    qint64 position() const;
+    QMediaTimeRange availablePlaybackRanges() const;
+
+    void seek(qint64 position);
+    void setRate(qreal rate);
+
+    int bufferStatus() const;
+
+    void setAudioOutput(IBaseFilter *filter);
+    void setVideoOutput(IBaseFilter *filter);
+
+protected:
+    void customEvent(QEvent *event);
+
+private Q_SLOTS:
+    void videoOutputChanged();
+
+private:
+    void releaseGraph();
+    void updateStatus();
+
+    int findStreamTypes(IBaseFilter *source) const;
+    int findStreamType(IPin *pin) const;
+
+    bool isConnected(IBaseFilter *filter, PIN_DIRECTION direction) const;
+    IBaseFilter *getConnected(IBaseFilter *filter, PIN_DIRECTION direction) const;
+
+    void run();
+
+    void doSetUrlSource(QMutexLocker *locker);
+    void doSetStreamSource(QMutexLocker *locker);
+    void doRender(QMutexLocker *locker);
+    void doFinalizeLoad(QMutexLocker *locker);
+    void doSetRate(QMutexLocker *locker);
+    void doSeek(QMutexLocker *locker);
+    void doPlay(QMutexLocker *locker);
+    void doPause(QMutexLocker *locker);
+    void doStop(QMutexLocker *locker);
+    void doReleaseAudioOutput(QMutexLocker *locker);
+    void doReleaseVideoOutput(QMutexLocker *locker);
+    void doReleaseGraph(QMutexLocker *locker);
+
+    void graphEvent(QMutexLocker *locker);
+
+    enum Task
+    {
+        Shutdown           = 0x0001,
+        SetUrlSource       = 0x0002,
+        SetStreamSource    = 0x0004,
+        SetSource          = SetUrlSource | SetStreamSource,
+        SetAudioOutput     = 0x0008,
+        SetVideoOutput     = 0x0010,
+        SetOutputs         = SetAudioOutput | SetVideoOutput,
+        Render             = 0x0020,
+        FinalizeLoad       = 0x0040,
+        SetRate            = 0x0080,
+        Seek               = 0x0100,
+        Play               = 0x0200,
+        Pause              = 0x0400,
+        Stop               = 0x0800,
+        ReleaseGraph       = 0x1000,
+        ReleaseAudioOutput = 0x2000,
+        ReleaseVideoOutput = 0x4000,
+        ReleaseFilters     = ReleaseGraph | ReleaseAudioOutput | ReleaseVideoOutput
+    };
+
+    enum Event
+    {
+        FinalizedLoad = QEvent::User,
+        Error,
+        RateChange,
+        Started,
+        Paused,
+        DurationChange,
+        StatusChange,
+        EndOfMedia,
+        PositionChange,
+        VideoOutputChange
+    };
+
+    enum GraphStatus
+    {
+        NoMedia,
+        Loading,
+        Loaded,
+        InvalidMedia
+    };
+
+    DirectShowPlayerControl *m_playerControl;
+    DirectShowMetaDataControl *m_metaDataControl;
+    DirectShowVideoOutputControl *m_videoOutputControl;
+    DirectShowVideoRendererControl *m_videoRendererControl;
+    Vmr9VideoWindowControl *m_videoWindowControl;
+    DirectShowAudioEndpointControl *m_audioEndpointControl;
+
+    QThread *m_taskThread;
+    DirectShowEventLoop *m_loop;
+    int m_pendingTasks;
+    int m_executingTask;
+    int m_executedTasks;
+    HANDLE m_taskHandle;
+    HANDLE m_eventHandle;
+    GraphStatus m_graphStatus;
+    QMediaPlayer::Error m_error;
+    QIODevice *m_stream;
+    IFilterGraph2 *m_graph;
+    IBaseFilter *m_source;
+    IBaseFilter *m_audioOutput;
+    IBaseFilter *m_videoOutput;
+    int m_streamTypes;
+    qreal m_rate;
+    qint64 m_position;
+    qint64 m_duration;
+    bool m_buffering;
+    bool m_seekable;
+    bool m_atEnd;
+    QMediaTimeRange m_playbackRange;
+    QUrl m_url;
+    QMediaResourceList m_resources;
+    QString m_errorString;
+    QMutex m_mutex;
+
+    friend class DirectShowPlayerServiceThread;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowsamplescheduler.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowsamplescheduler.cpp
new file mode 100644
index 0000000..733080e
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowsamplescheduler.cpp
@@ -0,0 +1,414 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowsamplescheduler.h"
+
+#include <QtCore/qcoreevent.h>
+
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowTimedSample
+{
+public:
+    DirectShowTimedSample(IMediaSample *sample)
+        : m_next(0)
+        , m_sample(sample)
+        , m_cookie(0)
+        , m_lastSample(false)
+    {
+        m_sample->AddRef();
+    }
+
+    ~DirectShowTimedSample()
+    {
+        m_sample->Release();
+    }
+
+    IMediaSample *sample() const { return m_sample; }
+
+    DirectShowTimedSample *nextSample() const { return m_next; }
+    void setNextSample(DirectShowTimedSample *sample) { Q_ASSERT(!m_next); m_next = sample; }
+
+    DirectShowTimedSample *remove() {
+        DirectShowTimedSample *next = m_next; delete this; return next; }
+
+    bool schedule(IReferenceClock *clock, REFERENCE_TIME startTime, HANDLE handle);
+    void unschedule(IReferenceClock *clock);
+
+    bool isReady(IReferenceClock *clock) const;
+
+    bool isLast() const { return m_lastSample; }
+    void setLast() { m_lastSample = true; }
+
+private:
+    DirectShowTimedSample *m_next;
+    IMediaSample *m_sample;
+    DWORD_PTR m_cookie;
+    bool m_lastSample;
+};
+
+bool DirectShowTimedSample::schedule(
+        IReferenceClock *clock, REFERENCE_TIME startTime, HANDLE handle)
+{
+    REFERENCE_TIME sampleStartTime;
+    REFERENCE_TIME sampleEndTime;
+    if (m_sample->GetTime(&sampleStartTime, &sampleEndTime) == S_OK) {
+        if (clock->AdviseTime(
+                startTime, sampleStartTime, reinterpret_cast<HEVENT>(handle), &m_cookie) == S_OK) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void DirectShowTimedSample::unschedule(IReferenceClock *clock)
+{
+    clock->Unadvise(m_cookie);
+}
+
+bool DirectShowTimedSample::isReady(IReferenceClock *clock) const
+{
+    REFERENCE_TIME sampleStartTime;
+    REFERENCE_TIME sampleEndTime;
+    REFERENCE_TIME currentTime;
+    if (m_sample->GetTime(&sampleStartTime, &sampleEndTime) == S_OK) {
+        if (clock->GetTime(&currentTime) == S_OK)
+            return currentTime >= sampleStartTime;
+    }
+    return true;
+}
+
+DirectShowSampleScheduler::DirectShowSampleScheduler(IUnknown *pin, QObject *parent)
+    : QWinEventNotifier(parent)
+    , m_pin(pin)
+    , m_clock(0)
+    , m_allocator(0)
+    , m_head(0)
+    , m_tail(0)
+    , m_maximumSamples(2)
+    , m_state(Stopped)
+    , m_startTime(0)
+    , m_timeoutEvent(::CreateEvent(0, 0, 0, 0))
+{
+    m_semaphore.release(m_maximumSamples);
+
+    setHandle(m_timeoutEvent);
+    setEnabled(true);
+}
+
+DirectShowSampleScheduler::~DirectShowSampleScheduler()
+{
+    setEnabled(false);
+
+    ::CloseHandle(m_timeoutEvent);
+
+    Q_ASSERT(!m_clock);
+    Q_ASSERT(!m_allocator);
+}
+
+HRESULT DirectShowSampleScheduler::QueryInterface(REFIID riid, void **ppvObject)
+{
+    return m_pin->QueryInterface(riid, ppvObject);
+}
+
+ULONG DirectShowSampleScheduler::AddRef()
+{
+    return m_pin->AddRef();
+}
+
+ULONG DirectShowSampleScheduler::Release()
+{
+    return m_pin->Release();
+}
+
+// IMemInputPin
+HRESULT DirectShowSampleScheduler::GetAllocator(IMemAllocator **ppAllocator)
+{
+    if (!ppAllocator) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        if (!m_allocator) {
+            return VFW_E_NO_ALLOCATOR;
+        } else {
+            *ppAllocator = m_allocator;
+
+            return S_OK;
+        }
+    }
+}
+
+HRESULT DirectShowSampleScheduler::NotifyAllocator(IMemAllocator *pAllocator, BOOL bReadOnly)
+{
+    Q_UNUSED(bReadOnly);
+
+    HRESULT hr;
+    ALLOCATOR_PROPERTIES properties;
+
+    if (!pAllocator) {
+        if (m_allocator)
+            m_allocator->Release();
+
+        m_allocator = 0;
+
+        return S_OK;
+    } else if ((hr = pAllocator->GetProperties(&properties)) != S_OK) {
+        return hr;
+    } else {
+        if (properties.cBuffers == 1) {
+            ALLOCATOR_PROPERTIES actual;
+
+            properties.cBuffers = 2;
+            if ((hr = pAllocator->SetProperties(&properties, &actual)) != S_OK)
+                return hr;
+        }
+
+        QMutexLocker locker(&m_mutex);
+
+        if (m_allocator)
+            m_allocator->Release();
+
+        m_allocator = pAllocator;
+        m_allocator->AddRef();
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowSampleScheduler::GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps)
+{
+    if (!pProps)
+        return E_POINTER;
+
+    pProps->cBuffers = 2;
+
+    return S_OK;
+}
+
+HRESULT DirectShowSampleScheduler::Receive(IMediaSample *pSample)
+{
+    if (!pSample)
+        return E_POINTER;
+
+    m_semaphore.acquire(1);
+
+    QMutexLocker locker(&m_mutex);
+
+    if (m_state & Flushing) {
+        m_semaphore.release(1);
+
+        return S_FALSE;
+    } else if (m_state == Stopped) {
+        m_semaphore.release();
+
+        return VFW_E_WRONG_STATE;
+    } else {
+        DirectShowTimedSample *timedSample = new DirectShowTimedSample(pSample);
+
+        if (m_tail)
+            m_tail->setNextSample(timedSample);
+        else
+            m_head = timedSample;
+
+        m_tail = timedSample;
+
+        if (m_state == Running) {
+            if (!timedSample->schedule(m_clock, m_startTime, m_timeoutEvent)) {
+                // Timing information is unavailable, so schedule frames immediately.
+                QMetaObject::invokeMethod(this, "timerActivated", Qt::QueuedConnection);
+            }
+        } else if (m_tail == m_head) {
+            // If this is the first frame make is available.
+            QMetaObject::invokeMethod(this, "timerActivated", Qt::QueuedConnection);
+        }
+
+        return S_OK;
+    }
+}
+
+HRESULT DirectShowSampleScheduler::ReceiveMultiple(
+        IMediaSample **pSamples, long nSamples, long *nSamplesProcessed)
+{
+    if (!pSamples || !nSamplesProcessed)
+        return E_POINTER;
+
+    for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; ++(*nSamplesProcessed)) {
+        HRESULT hr = Receive(pSamples[*nSamplesProcessed]);
+
+        if (hr != S_OK)
+            return hr;
+    }
+    return S_OK;
+}
+
+HRESULT DirectShowSampleScheduler::ReceiveCanBlock()
+{
+    return S_OK;
+}
+
+void DirectShowSampleScheduler::run(REFERENCE_TIME startTime)
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_state = (m_state & Flushing) | Running;
+    m_startTime = startTime;
+
+    for (DirectShowTimedSample *sample = m_head; sample; sample = sample->nextSample()) {
+        sample->schedule(m_clock, m_startTime, m_timeoutEvent);
+    }
+}
+
+void DirectShowSampleScheduler::pause()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_state = (m_state & Flushing) | Paused;
+
+    for (DirectShowTimedSample *sample = m_head; sample; sample = sample->nextSample())
+        sample->unschedule(m_clock);
+}
+
+void DirectShowSampleScheduler::stop()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_state = m_state & Flushing;
+
+    for (DirectShowTimedSample *sample = m_head; sample; sample = sample->remove()) {
+        sample->unschedule(m_clock);
+        
+        m_semaphore.release(1);
+    }
+
+    m_head = 0;
+    m_tail = 0;
+}
+
+void DirectShowSampleScheduler::setFlushing(bool flushing)
+{
+    QMutexLocker locker(&m_mutex);
+
+    const bool isFlushing = m_state & Flushing;
+
+    if (isFlushing != flushing) {
+        if (flushing) {
+            m_state |= Flushing;
+
+            for (DirectShowTimedSample *sample = m_head; sample; sample = sample->remove()) {
+                sample->unschedule(m_clock);
+
+                m_semaphore.release(1);
+            }
+            m_head = 0;
+            m_tail = 0;
+        } else {
+            m_state &= ~Flushing;
+        }
+    }
+}
+
+void DirectShowSampleScheduler::setClock(IReferenceClock *clock)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_clock)
+        m_clock->Release();
+
+    m_clock = clock;
+
+    if (m_clock)
+        m_clock->AddRef();
+}
+
+IMediaSample *DirectShowSampleScheduler::takeSample(bool *eos)
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_head && m_head->isReady(m_clock)) {
+        IMediaSample *sample = m_head->sample();
+        sample->AddRef();
+
+        if (m_state == Running) {
+            *eos =  m_head->isLast();
+
+            m_head = m_head->remove();
+
+            if (!m_head)
+                m_tail = 0;
+
+            m_semaphore.release(1);
+        }
+
+        return sample;
+    } else {
+        return 0;
+    }
+}
+
+bool DirectShowSampleScheduler::scheduleEndOfStream()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_tail) {
+        m_tail->setLast();
+
+        return true;
+    } else {
+        return false;
+    }
+}
+
+bool DirectShowSampleScheduler::event(QEvent *event)
+{
+    if (event->type() == QEvent::WinEventAct) {
+        QObject::event(event);
+
+        emit sampleReady();
+
+        return true;
+    } else {
+        return QWinEventNotifier::event(event);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowsamplescheduler.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowsamplescheduler.h
new file mode 100644
index 0000000..007fa99
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowsamplescheduler.h
@@ -0,0 +1,127 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWSAMPLESCHEDULER_H
+#define DIRECTSHOWSAMPLESCHEDULER_H
+
+#include <QtCore/qmutex.h>
+#include <QtCore/qobject.h>
+#include <QtCore/qsemaphore.h>
+
+#include <QtCore/private/qwineventnotifier_p.h>
+
+#include <dshow.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowTimedSample;
+
+class DirectShowSampleScheduler : public QWinEventNotifier, public IMemInputPin
+{
+    Q_OBJECT
+public:
+
+    enum State
+    {
+        Stopped  = 0x00,
+        Running  = 0x01,
+        Paused   = 0x02,
+        RunMask  = 0x03,
+        Flushing = 0x04
+    };
+
+    DirectShowSampleScheduler(IUnknown *pin, QObject *parent = 0);
+    ~DirectShowSampleScheduler();
+
+    // IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+
+    // IMemInputPin
+    HRESULT STDMETHODCALLTYPE GetAllocator(IMemAllocator **ppAllocator);
+    HRESULT STDMETHODCALLTYPE NotifyAllocator(IMemAllocator *pAllocator, BOOL bReadOnly);
+    HRESULT STDMETHODCALLTYPE GetAllocatorRequirements(ALLOCATOR_PROPERTIES *pProps);
+
+    HRESULT STDMETHODCALLTYPE Receive(IMediaSample *pSample);
+    HRESULT STDMETHODCALLTYPE ReceiveMultiple(IMediaSample **pSamples, long nSamples, long *nSamplesProcessed);
+    HRESULT STDMETHODCALLTYPE ReceiveCanBlock();
+
+    void run(REFERENCE_TIME startTime);
+    void pause();
+    void stop();
+    void setFlushing(bool flushing);
+
+    IReferenceClock *clock() const { return m_clock; }
+    void setClock(IReferenceClock *clock);
+
+    bool schedule(IMediaSample *sample);
+    bool scheduleEndOfStream();
+
+    IMediaSample *takeSample(bool *eos);
+
+    bool event(QEvent *event);
+
+Q_SIGNALS:
+    void sampleReady();
+
+private:
+    IUnknown *m_pin;
+    IReferenceClock *m_clock;
+    IMemAllocator *m_allocator;
+    DirectShowTimedSample *m_head;
+    DirectShowTimedSample *m_tail;
+    int m_maximumSamples;
+    int m_state;
+    REFERENCE_TIME m_startTime;
+    HANDLE m_timeoutEvent;
+    QSemaphore m_semaphore;
+    QMutex m_mutex;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowvideooutputcontrol.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowvideooutputcontrol.cpp
new file mode 100644
index 0000000..ee2bea8
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowvideooutputcontrol.cpp
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowvideooutputcontrol.h"
+
+
+QT_BEGIN_NAMESPACE
+
+DirectShowVideoOutputControl::DirectShowVideoOutputControl(QObject *parent)
+    : QVideoOutputControl(parent)
+    , m_output(NoOutput)
+{
+
+}
+
+DirectShowVideoOutputControl::~DirectShowVideoOutputControl()
+{
+}
+
+QList<QVideoOutputControl::Output> DirectShowVideoOutputControl::availableOutputs() const
+{
+    return QList<Output>()
+            << RendererOutput
+            << WindowOutput;
+}
+
+
+QVideoOutputControl::Output DirectShowVideoOutputControl::output() const
+{
+    return m_output;
+}
+
+void DirectShowVideoOutputControl::setOutput(Output output)
+{
+    if (output != m_output) {
+        switch (output) {
+        case NoOutput:
+        case RendererOutput:
+        case WindowOutput:
+            m_output = output;
+            emit outputChanged();
+            break;
+        default:
+            break;
+        }
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowvideooutputcontrol.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowvideooutputcontrol.h
new file mode 100644
index 0000000..acb2937
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowvideooutputcontrol.h
@@ -0,0 +1,75 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWVIDEOUTPUTCONTROL_H
+#define DIRECTSHOWVIDEOOUPUTCONTROL_H
+
+#include <QtMultimedia/qvideooutputcontrol.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowVideoOutputControl : public QVideoOutputControl
+{
+    Q_OBJECT
+public:
+    DirectShowVideoOutputControl(QObject *parent = 0);
+    ~DirectShowVideoOutputControl();
+
+    QList<Output> availableOutputs() const;
+
+    Output output() const;
+    void setOutput(Output output);
+
+Q_SIGNALS:
+    void outputChanged();
+
+private:
+    Output m_output;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowvideorenderercontrol.cpp b/src/plugins/mediaservices/directshow/mediaplayer/directshowvideorenderercontrol.cpp
new file mode 100644
index 0000000..f27cb10
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowvideorenderercontrol.cpp
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "directshowvideorenderercontrol.h"
+
+#include "videosurfacefilter.h"
+
+
+QT_BEGIN_NAMESPACE
+
+
+DirectShowVideoRendererControl::DirectShowVideoRendererControl(DirectShowEventLoop *loop, QObject *parent)
+    : QVideoRendererControl(parent)
+    , m_loop(loop)
+    , m_surface(0)
+    , m_filter(0)
+{
+}
+
+DirectShowVideoRendererControl::~DirectShowVideoRendererControl()
+{
+    delete m_filter;
+}
+
+QAbstractVideoSurface *DirectShowVideoRendererControl::surface() const
+{
+    return m_surface;
+}
+
+void DirectShowVideoRendererControl::setSurface(QAbstractVideoSurface *surface)
+{
+    if (surface != m_surface) {
+        m_surface = surface;
+
+        VideoSurfaceFilter *existingFilter = m_filter;
+
+        if (surface) {
+            m_filter = new VideoSurfaceFilter(surface, m_loop);
+        } else {
+            m_filter = 0;
+        }
+
+        emit filterChanged();
+
+        delete existingFilter;
+    }
+}
+
+IBaseFilter *DirectShowVideoRendererControl::filter()
+{
+    return m_filter;
+}
+
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/directshowvideorenderercontrol.h b/src/plugins/mediaservices/directshow/mediaplayer/directshowvideorenderercontrol.h
new file mode 100644
index 0000000..6b4f4a2
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/directshowvideorenderercontrol.h
@@ -0,0 +1,82 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef DIRECTSHOWVIDEORENDERERCONTROL_H
+#define DIRECTSHOWVIDEORENDERERCONTROL_H
+
+#include <QtMultimedia/qvideorenderercontrol.h>
+
+#include <dshow.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class DirectShowEventLoop;
+class VideoSurfaceFilter;
+
+class DirectShowVideoRendererControl : public QVideoRendererControl
+{
+    Q_OBJECT
+public:
+    DirectShowVideoRendererControl(DirectShowEventLoop *loop, QObject *parent = 0);
+    ~DirectShowVideoRendererControl();
+
+    QAbstractVideoSurface *surface() const;
+    void setSurface(QAbstractVideoSurface *surface);
+
+    IBaseFilter *filter();
+
+Q_SIGNALS:
+    void filterChanged();
+
+private:
+    DirectShowEventLoop *m_loop;
+    QAbstractVideoSurface *m_surface;
+    VideoSurfaceFilter *m_filter;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/mediaplayer.pri b/src/plugins/mediaservices/directshow/mediaplayer/mediaplayer.pri
new file mode 100644
index 0000000..99a1191
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/mediaplayer.pri
@@ -0,0 +1,45 @@
+INCLUDEPATH += $$PWD
+
+DEFINES += QMEDIA_DIRECTSHOW_PLAYER
+
+!contains(QT_CONFIG, wmsdk): DEFINES += QT_NO_WMSDK
+
+HEADERS += \
+        $$PWD/directshowaudioendpointcontrol.h \
+        $$PWD/directshoweventloop.h \
+        $$PWD/directshowglobal.h \
+        $$PWD/directshowioreader.h \
+        $$PWD/directshowiosource.h \
+        $$PWD/directshowmediatype.h \
+        $$PWD/directshowmediatypelist.h \
+        $$PWD/directshowmetadatacontrol.h \
+        $$PWD/directshowpinenum.h \
+        $$PWD/directshowplayercontrol.h \
+        $$PWD/directshowplayerservice.h \
+        $$PWD/directshowsamplescheduler.h \
+        $$PWD/directshowvideooutputcontrol.h \
+        $$PWD/directshowvideorenderercontrol.h \
+        $$PWD/mediasamplevideobuffer.h \
+        $$PWD/videosurfacefilter.h \
+        $$PWD/vmr9videowindowcontrol.h
+
+SOURCES += \
+        $$PWD/directshowaudioendpointcontrol.cpp \
+        $$PWD/directshoweventloop.cpp \
+        $$PWD/directshowioreader.cpp \
+        $$PWD/directshowiosource.cpp \
+        $$PWD/directshowmediatype.cpp \
+        $$PWD/directshowmediatypelist.cpp \
+        $$PWD/directshowmetadatacontrol.cpp \
+        $$PWD/directshowpinenum.cpp \
+        $$PWD/directshowplayercontrol.cpp \
+        $$PWD/directshowplayerservice.cpp \
+        $$PWD/directshowsamplescheduler.cpp \
+        $$PWD/directshowvideooutputcontrol.cpp \
+        $$PWD/directshowvideorenderercontrol.cpp \
+        $$PWD/mediasamplevideobuffer.cpp \
+        $$PWD/videosurfacefilter.cpp \
+        $$PWD/vmr9videowindowcontrol.cpp
+
+LIBS += -lstrmiids -ldmoguids -luuid -lmsdmo -lole32 -loleaut32
+
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/mediasamplevideobuffer.cpp b/src/plugins/mediaservices/directshow/mediaplayer/mediasamplevideobuffer.cpp
new file mode 100644
index 0000000..7eff226
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/mediasamplevideobuffer.cpp
@@ -0,0 +1,91 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mediasamplevideobuffer.h"
+
+
+QT_BEGIN_NAMESPACE
+
+MediaSampleVideoBuffer::MediaSampleVideoBuffer(IMediaSample *sample, int bytesPerLine)
+    : QAbstractVideoBuffer(NoHandle)
+    , m_sample(sample)
+    , m_bytesPerLine(m_bytesPerLine)
+    , m_mapMode(NotMapped)
+{
+    m_sample->AddRef();
+}
+
+MediaSampleVideoBuffer::~MediaSampleVideoBuffer()
+{
+    m_sample->Release();
+}
+
+uchar *MediaSampleVideoBuffer::map(MapMode mode, int *numBytes, int *bytesPerLine)
+{
+    if (m_mapMode == NotMapped && mode != NotMapped) {
+        if (numBytes)
+            *numBytes = m_sample->GetActualDataLength();
+
+        if (bytesPerLine)
+            *bytesPerLine = m_bytesPerLine;
+
+        BYTE *bytes = 0;
+
+        if (m_sample->GetPointer(&bytes) == S_OK) {
+            m_mapMode = mode;
+
+            return reinterpret_cast<uchar *>(bytes);
+        }
+    }
+    return 0;
+}
+
+void MediaSampleVideoBuffer::unmap()
+{
+    m_mapMode = NotMapped;
+}
+
+QAbstractVideoBuffer::MapMode MediaSampleVideoBuffer::mapMode() const
+{
+    return m_mapMode;
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/mediasamplevideobuffer.h b/src/plugins/mediaservices/directshow/mediaplayer/mediasamplevideobuffer.h
new file mode 100644
index 0000000..06dc31c
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/mediasamplevideobuffer.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MEDIASAMPLEVIDEOBUFFER_H
+#define MEDIASAMPLEVIDEOBUFFER_H
+
+#include <QtMultimedia/qabstractvideobuffer.h>
+
+#include <dshow.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class MediaSampleVideoBuffer : public QAbstractVideoBuffer
+{
+public:
+    MediaSampleVideoBuffer(IMediaSample *sample, int bytesPerLine);
+    ~MediaSampleVideoBuffer();
+
+    IMediaSample *sample() { return m_sample; }
+
+    uchar *map(MapMode mode, int *numBytes, int *bytesPerLine);
+    void unmap();
+
+    MapMode mapMode() const;
+
+private:
+    IMediaSample *m_sample;
+    int m_bytesPerLine;
+    MapMode m_mapMode;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/videosurfacefilter.cpp b/src/plugins/mediaservices/directshow/mediaplayer/videosurfacefilter.cpp
new file mode 100644
index 0000000..a471c68
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/videosurfacefilter.cpp
@@ -0,0 +1,633 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "videosurfacefilter.h"
+
+#include "directshoweventloop.h"
+#include "directshowglobal.h"
+#include "directshowpinenum.h"
+#include "mediasamplevideobuffer.h"
+
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qthread.h>
+#include <QtMultimedia/qabstractvideosurface.h>
+
+#include <initguid.h>
+
+
+QT_BEGIN_NAMESPACE
+
+// { e23cad72-153d-406c-bf3f-4c4b523d96f2 }
+DEFINE_GUID(CLSID_VideoSurfaceFilter,
+0xe23cad72, 0x153d, 0x406c, 0xbf, 0x3f, 0x4c, 0x4b, 0x52, 0x3d, 0x96, 0xf2);
+
+VideoSurfaceFilter::VideoSurfaceFilter(
+        QAbstractVideoSurface *surface, DirectShowEventLoop *loop, QObject *parent)
+    : QObject(parent)
+    , m_ref(1)
+    , m_state(State_Stopped)
+    , m_surface(surface)
+    , m_loop(loop)
+    , m_graph(0)
+    , m_peerPin(0)
+    , m_bytesPerLine(0)
+    , m_startResult(S_OK)
+    , m_pinId(QString::fromLatin1("reference"))
+    , m_sampleScheduler(static_cast<IPin *>(this))
+{
+    connect(surface, SIGNAL(supportedFormatsChanged()), this, SLOT(supportedFormatsChanged()));
+    connect(&m_sampleScheduler, SIGNAL(sampleReady()), this, SLOT(sampleReady()));
+}
+
+VideoSurfaceFilter::~VideoSurfaceFilter()
+{
+    Q_ASSERT(m_ref == 1);
+}
+
+HRESULT VideoSurfaceFilter::QueryInterface(REFIID riid, void **ppvObject)
+{    
+    // 2dd74950-a890-11d1-abe8-00a0c905f375
+    static const GUID iid_IAmFilterMiscFlags = {
+        0x2dd74950, 0xa890, 0x11d1, {0xab, 0xe8, 0x00, 0xa0, 0xc9, 0x05, 0xf3, 0x75} };
+
+    if (!ppvObject) {
+        return E_POINTER;
+    } else if (riid == IID_IUnknown
+            || riid == IID_IPersist
+            || riid == IID_IMediaFilter
+            || riid == IID_IBaseFilter) {
+        *ppvObject = static_cast<IBaseFilter *>(this);
+    } else if (riid == iid_IAmFilterMiscFlags) {
+        *ppvObject = static_cast<IAMFilterMiscFlags *>(this);
+    } else if (riid == IID_IPin) {
+        *ppvObject = static_cast<IPin *>(this);
+    } else if (riid == IID_IMemInputPin) {
+        *ppvObject = static_cast<IMemInputPin *>(&m_sampleScheduler);
+    } else {
+        *ppvObject = 0;
+
+        return E_NOINTERFACE;
+    }
+
+    AddRef();
+
+    return S_OK;
+}
+
+ULONG VideoSurfaceFilter::AddRef()
+{
+    return InterlockedIncrement(&m_ref);
+}
+
+ULONG VideoSurfaceFilter::Release()
+{
+    ULONG ref = InterlockedDecrement(&m_ref);
+
+    Q_ASSERT(ref != 0);
+
+    return ref;
+}
+
+HRESULT VideoSurfaceFilter::GetClassID(CLSID *pClassID)
+{
+    *pClassID = CLSID_VideoSurfaceFilter;
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::Run(REFERENCE_TIME tStart)
+{
+    m_state = State_Running;
+
+    m_sampleScheduler.run(tStart);
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::Pause()
+{
+    m_state = State_Paused;
+
+    m_sampleScheduler.pause();
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::Stop()
+{
+    m_state = State_Stopped;
+
+    m_sampleScheduler.stop();
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::GetState(DWORD dwMilliSecsTimeout, FILTER_STATE *pState)
+{
+    if (!pState)
+        return E_POINTER;
+
+    *pState = m_state;
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::SetSyncSource(IReferenceClock *pClock)
+{
+
+    m_sampleScheduler.setClock(pClock);
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::GetSyncSource(IReferenceClock **ppClock)
+{
+    if (!ppClock) {
+        return E_POINTER;
+    } else {
+        *ppClock = m_sampleScheduler.clock();
+
+        if (*ppClock) {
+            (*ppClock)->AddRef();
+
+            return S_OK;
+        } else {
+            return S_FALSE;
+        }
+    }
+}
+
+HRESULT VideoSurfaceFilter::EnumPins(IEnumPins **ppEnum)
+{
+    if (ppEnum) {
+        *ppEnum = new DirectShowPinEnum(QList<IPin *>() << this);
+
+        return S_OK;
+    } else {
+        return E_POINTER;
+    }
+}
+
+HRESULT VideoSurfaceFilter::FindPin(LPCWSTR pId, IPin **ppPin)
+{
+    if (!ppPin || !pId) {
+        return E_POINTER;
+    } else if (QString::fromWCharArray(pId) == m_pinId) {
+        AddRef();
+
+        *ppPin = this;
+
+        return S_OK;
+    } else {
+        return VFW_E_NOT_FOUND;
+    }
+}
+
+HRESULT VideoSurfaceFilter::JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName)
+{
+    m_graph = pGraph;
+    m_name = QString::fromWCharArray(pName);
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::QueryFilterInfo(FILTER_INFO *pInfo)
+{
+    if (pInfo) {
+        QString name = m_name;
+
+        if (name.length() >= MAX_FILTER_NAME)
+            name.truncate(MAX_FILTER_NAME - 1);
+
+        int length = name.toWCharArray(pInfo->achName);
+        pInfo->achName[length] = '\0';
+
+        if (m_graph)
+            m_graph->AddRef();
+
+        pInfo->pGraph = m_graph;
+
+        return S_OK;
+    } else {
+        return E_POINTER;
+    }
+}
+
+HRESULT VideoSurfaceFilter::QueryVendorInfo(LPWSTR *pVendorInfo)
+{
+    Q_UNUSED(pVendorInfo);
+
+    return E_NOTIMPL;
+}
+
+ULONG VideoSurfaceFilter::GetMiscFlags()
+{
+    return AM_FILTER_MISC_FLAGS_IS_RENDERER;
+}
+
+
+HRESULT VideoSurfaceFilter::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
+{
+    // This is an input pin, you shouldn't be calling Connect on it.
+    return E_POINTER;
+}
+
+HRESULT VideoSurfaceFilter::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
+{
+    if (!pConnector) {
+        return E_POINTER;
+    } else if (!pmt) {
+        return E_POINTER;
+    } else {
+        HRESULT hr;
+        QMutexLocker locker(&m_mutex);
+
+        if (m_peerPin) {
+            hr = VFW_E_ALREADY_CONNECTED;
+        } else if (pmt->majortype != MEDIATYPE_Video) {
+            hr = VFW_E_TYPE_NOT_ACCEPTED;
+        } else {
+            m_surfaceFormat = DirectShowMediaType::formatFromType(*pmt);
+            m_bytesPerLine = DirectShowMediaType::bytesPerLine(m_surfaceFormat);
+
+            if (thread() == QThread::currentThread()) {
+                hr = start();
+            } else {
+                m_loop->postEvent(this, new QEvent(QEvent::Type(StartSurface)));
+
+                m_wait.wait(&m_mutex);
+
+                hr = m_startResult;
+            }
+        }
+        if (hr == S_OK) {
+           m_peerPin = pConnector;
+           m_peerPin->AddRef();
+
+           DirectShowMediaType::copy(&m_mediaType, *pmt);
+        }
+        return hr;
+    }
+}
+
+HRESULT VideoSurfaceFilter::start()
+{
+    if (!m_surface->start(m_surfaceFormat)) {
+        return VFW_E_TYPE_NOT_ACCEPTED;
+    } else {
+        return S_OK;
+    }
+}
+
+HRESULT VideoSurfaceFilter::Disconnect()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (!m_peerPin)
+        return S_FALSE;
+
+    if (thread() == QThread::currentThread()) {
+        stop();
+    } else {
+        m_loop->postEvent(this, new QEvent(QEvent::Type(StopSurface)));
+
+        m_wait.wait(&m_mutex);
+    }
+
+    m_mediaType.clear();
+
+    m_sampleScheduler.NotifyAllocator(0, FALSE);
+
+    m_peerPin->Release();
+    m_peerPin = 0;
+
+    return S_OK;
+}
+
+void VideoSurfaceFilter::stop()
+{
+    m_surface->stop();
+}
+
+HRESULT VideoSurfaceFilter::ConnectedTo(IPin **ppPin)
+{
+    if (!ppPin) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        if (!m_peerPin) {
+            return VFW_E_NOT_CONNECTED;
+        } else {
+            m_peerPin->AddRef();
+
+            *ppPin = m_peerPin;
+
+            return S_OK;
+        }
+    }
+}
+
+HRESULT VideoSurfaceFilter::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
+{
+    if (!pmt) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        if (!m_peerPin) {
+            return VFW_E_NOT_CONNECTED;
+        } else {
+            DirectShowMediaType::copy(pmt, m_mediaType);
+
+            return S_OK;
+        }
+    }
+}
+
+HRESULT VideoSurfaceFilter::QueryPinInfo(PIN_INFO *pInfo)
+{
+    if (!pInfo) {
+        return E_POINTER;
+    } else {
+        AddRef();
+
+        pInfo->pFilter = this;
+        pInfo->dir = PINDIR_INPUT;
+
+        const int bytes = qMin(MAX_FILTER_NAME, (m_pinId.length() + 1) * 2);
+
+        qMemCopy(pInfo->achName, m_pinId.utf16(), bytes);
+
+        return S_OK;
+    }
+}
+
+HRESULT VideoSurfaceFilter::QueryId(LPWSTR *Id)
+{
+    if (!Id) {
+        return E_POINTER;
+    } else {
+        const int bytes = (m_pinId.length() + 1) * 2;
+
+        *Id = static_cast<LPWSTR>(::CoTaskMemAlloc(bytes));
+
+        qMemCopy(*Id, m_pinId.utf16(), bytes);
+
+        return S_OK;
+    }
+}
+
+HRESULT VideoSurfaceFilter::QueryAccept(const AM_MEDIA_TYPE *pmt)
+{
+    return !m_surface->isFormatSupported(DirectShowMediaType::formatFromType(*pmt))
+            ? S_OK
+            : S_FALSE;
+}
+
+HRESULT VideoSurfaceFilter::EnumMediaTypes(IEnumMediaTypes **ppEnum)
+{
+    if (!ppEnum) {
+        return E_POINTER;
+    } else {
+        QMutexLocker locker(&m_mutex);
+
+        *ppEnum = createMediaTypeEnum();
+
+        return S_OK;
+    }
+}
+
+HRESULT VideoSurfaceFilter::QueryInternalConnections(IPin **apPin, ULONG *nPin)
+{
+    Q_UNUSED(apPin);
+    Q_UNUSED(nPin);
+
+    return E_NOTIMPL;
+}
+
+HRESULT VideoSurfaceFilter::EndOfStream()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (!m_sampleScheduler.scheduleEndOfStream()) {
+        if (IMediaEventSink *sink = com_cast<IMediaEventSink>(m_graph, IID_IMediaEventSink)) {
+            sink->Notify(
+                    EC_COMPLETE,
+                    S_OK,
+                    reinterpret_cast<LONG_PTR>(static_cast<IBaseFilter *>(this)));
+            sink->Release();
+        }
+    }
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::BeginFlush()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_sampleScheduler.setFlushing(true);
+
+    if (thread() == QThread::currentThread()) {
+        flush();
+    } else {
+        m_loop->postEvent(this, new QEvent(QEvent::Type(FlushSurface)));
+
+        m_wait.wait(&m_mutex);
+    }
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::EndFlush()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_sampleScheduler.setFlushing(false);
+
+    return S_OK;
+}
+
+void VideoSurfaceFilter::flush()
+{
+    m_surface->present(QVideoFrame());
+
+    m_wait.wakeAll();
+}
+
+HRESULT VideoSurfaceFilter::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
+{
+    Q_UNUSED(tStart);
+    Q_UNUSED(tStop);
+    Q_UNUSED(dRate);
+
+    return S_OK;
+}
+
+HRESULT VideoSurfaceFilter::QueryDirection(PIN_DIRECTION *pPinDir)
+{
+    if (!pPinDir) {
+        return E_POINTER;
+    } else {
+        *pPinDir = PINDIR_INPUT;
+
+        return S_OK;
+    }
+}
+
+int VideoSurfaceFilter::currentMediaTypeToken()
+{
+    QMutexLocker locker(&m_mutex);
+
+    return DirectShowMediaTypeList::currentMediaTypeToken();
+}
+
+HRESULT VideoSurfaceFilter::nextMediaType(
+        int token, int *index, ULONG count, AM_MEDIA_TYPE **types, ULONG *fetchedCount)
+{
+    QMutexLocker locker(&m_mutex);
+
+    return DirectShowMediaTypeList::nextMediaType(token, index, count, types, fetchedCount);
+
+}
+
+HRESULT VideoSurfaceFilter::skipMediaType(int token, int *index, ULONG count)
+{
+    QMutexLocker locker(&m_mutex);
+
+    return DirectShowMediaTypeList::skipMediaType(token, index, count);
+}
+
+HRESULT VideoSurfaceFilter::cloneMediaType(int token, int index, IEnumMediaTypes **enumeration)
+{
+    QMutexLocker locker(&m_mutex);
+
+    return DirectShowMediaTypeList::cloneMediaType(token, index, enumeration);
+}
+
+void VideoSurfaceFilter::customEvent(QEvent *event)
+{
+    if (event->type() == StartSurface) {
+        QMutexLocker locker(&m_mutex);
+
+        m_startResult = start();
+
+        m_wait.wakeAll();
+    } else if (event->type() == StopSurface) {
+        QMutexLocker locker(&m_mutex);
+
+        stop();
+
+        m_wait.wakeAll();
+    } else if (event->type() == FlushSurface) {
+        QMutexLocker locker(&m_mutex);
+
+        flush();
+
+        m_wait.wakeAll();
+    } else {
+       QObject::customEvent(event);
+    }
+}
+
+void VideoSurfaceFilter::supportedFormatsChanged()
+{
+    QMutexLocker locker(&m_mutex);
+
+    // MEDIASUBTYPE_None;
+    static const GUID none = {
+        0xe436eb8e, 0x524f, 0x11ce, {0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70} };
+
+    QList<QVideoFrame::PixelFormat> formats = m_surface->supportedPixelFormats();
+
+    QVector<AM_MEDIA_TYPE> mediaTypes;
+    mediaTypes.reserve(formats.count());
+
+    AM_MEDIA_TYPE type;
+    type.majortype = MEDIATYPE_Video;
+    type.bFixedSizeSamples = TRUE;
+    type.bTemporalCompression = FALSE;
+    type.lSampleSize = 0;
+    type.formattype = GUID_NULL;
+    type.pUnk = 0;
+    type.cbFormat = 0;
+    type.pbFormat = 0;
+
+    foreach (QVideoFrame::PixelFormat format, formats) {
+        type.subtype = DirectShowMediaType::convertPixelFormat(format);
+
+        if (type.subtype != none)
+            mediaTypes.append(type);
+    }
+
+    setMediaTypes(mediaTypes);
+}
+
+void VideoSurfaceFilter::sampleReady()
+{
+    bool eos = false;
+
+    IMediaSample *sample = m_sampleScheduler.takeSample(&eos);
+
+    if (sample) {
+        m_surface->present(QVideoFrame(
+                new MediaSampleVideoBuffer(sample, m_bytesPerLine),
+                m_surfaceFormat.frameSize(),
+                m_surfaceFormat.pixelFormat()));
+
+        sample->Release();
+
+        if (eos) {
+            if (IMediaEventSink *sink = com_cast<IMediaEventSink>(m_graph, IID_IMediaEventSink)) {
+                sink->Notify(
+                        EC_COMPLETE,
+                        S_OK,
+                        reinterpret_cast<LONG_PTR>(static_cast<IBaseFilter *>(this)));
+                sink->Release();
+            }
+        }
+    }
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/videosurfacefilter.h b/src/plugins/mediaservices/directshow/mediaplayer/videosurfacefilter.h
new file mode 100644
index 0000000..0607fd3
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/videosurfacefilter.h
@@ -0,0 +1,180 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+#ifndef VIDEOSURFACEFILTER_H
+#define VIDEOSURFACEFILTER_H
+
+#include "directshowglobal.h"
+#include "directshowmediatypelist.h"
+#include "directshowsamplescheduler.h"
+#include "directshowmediatype.h"
+
+#include <QtCore/qbasictimer.h>
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qsemaphore.h>
+#include <QtCore/qstring.h>
+#include <QtCore/qwaitcondition.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+
+class QAbstractVideoSurface;
+
+class DirectShowEventLoop;
+
+class VideoSurfaceFilter
+    : public QObject
+    , public DirectShowMediaTypeList
+    , public IBaseFilter
+    , public IAMFilterMiscFlags
+    , public IPin
+{
+    Q_OBJECT
+public:
+    VideoSurfaceFilter(
+            QAbstractVideoSurface *surface, DirectShowEventLoop *loop, QObject *parent = 0);
+    ~VideoSurfaceFilter();
+
+    // IUnknown
+    HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppvObject);
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+
+    // IPersist
+    HRESULT STDMETHODCALLTYPE GetClassID(CLSID *pClassID);
+
+    // IMediaFilter
+    HRESULT STDMETHODCALLTYPE Run(REFERENCE_TIME tStart);
+    HRESULT STDMETHODCALLTYPE Pause();
+    HRESULT STDMETHODCALLTYPE Stop();
+
+    HRESULT STDMETHODCALLTYPE GetState(DWORD dwMilliSecsTimeout, FILTER_STATE *pState);
+
+    HRESULT STDMETHODCALLTYPE SetSyncSource(IReferenceClock *pClock);
+    HRESULT STDMETHODCALLTYPE GetSyncSource(IReferenceClock **ppClock);
+
+    // IBaseFilter
+    HRESULT STDMETHODCALLTYPE EnumPins(IEnumPins **ppEnum);
+    HRESULT STDMETHODCALLTYPE FindPin(LPCWSTR Id, IPin **ppPin);
+
+    HRESULT STDMETHODCALLTYPE JoinFilterGraph(IFilterGraph *pGraph, LPCWSTR pName);
+
+    HRESULT STDMETHODCALLTYPE QueryFilterInfo(FILTER_INFO *pInfo);
+    HRESULT STDMETHODCALLTYPE QueryVendorInfo(LPWSTR *pVendorInfo);
+
+    // IAMFilterMiscFlags
+    ULONG STDMETHODCALLTYPE GetMiscFlags();
+
+    // IPin
+    HRESULT STDMETHODCALLTYPE Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt);
+    HRESULT STDMETHODCALLTYPE ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt);
+    HRESULT STDMETHODCALLTYPE Disconnect();
+    HRESULT STDMETHODCALLTYPE ConnectedTo(IPin **ppPin);
+
+    HRESULT STDMETHODCALLTYPE ConnectionMediaType(AM_MEDIA_TYPE *pmt);
+
+    HRESULT STDMETHODCALLTYPE QueryPinInfo(PIN_INFO *pInfo);
+    HRESULT STDMETHODCALLTYPE QueryId(LPWSTR *Id);
+
+    HRESULT STDMETHODCALLTYPE QueryAccept(const AM_MEDIA_TYPE *pmt);
+
+    HRESULT STDMETHODCALLTYPE EnumMediaTypes(IEnumMediaTypes **ppEnum);
+
+    HRESULT STDMETHODCALLTYPE QueryInternalConnections(IPin **apPin, ULONG *nPin);
+
+    HRESULT STDMETHODCALLTYPE EndOfStream();
+
+    HRESULT STDMETHODCALLTYPE BeginFlush();
+    HRESULT STDMETHODCALLTYPE EndFlush();
+
+    HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
+
+    HRESULT STDMETHODCALLTYPE QueryDirection(PIN_DIRECTION *pPinDir);
+
+    int currentMediaTypeToken();
+    HRESULT nextMediaType(
+            int token, int *index, ULONG count, AM_MEDIA_TYPE **types, ULONG *fetchedCount);
+    HRESULT skipMediaType(int token, int *index, ULONG count);
+    HRESULT cloneMediaType(int token, int index, IEnumMediaTypes **enumeration);
+
+protected:
+    void customEvent(QEvent *event);
+
+private Q_SLOTS:
+    void supportedFormatsChanged();
+    void sampleReady();
+
+private:
+    HRESULT start();
+    void stop();
+    void flush();
+
+    enum
+    {
+        StartSurface = QEvent::User,
+        StopSurface,
+        FlushSurface
+    };
+
+    LONG m_ref;
+    FILTER_STATE m_state;
+    QAbstractVideoSurface *m_surface;
+    DirectShowEventLoop *m_loop;
+    IFilterGraph *m_graph;
+    IPin *m_peerPin;
+    int m_bytesPerLine;
+    HRESULT m_startResult;
+    QString m_name;
+    QString m_pinId;
+    DirectShowMediaType m_mediaType;
+    QVideoSurfaceFormat m_surfaceFormat;
+    QMutex m_mutex;
+    QWaitCondition m_wait;
+    DirectShowSampleScheduler m_sampleScheduler;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/vmr9videowindowcontrol.cpp b/src/plugins/mediaservices/directshow/mediaplayer/vmr9videowindowcontrol.cpp
new file mode 100644
index 0000000..1c6df2c
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/vmr9videowindowcontrol.cpp
@@ -0,0 +1,317 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "vmr9videowindowcontrol.h"
+
+#include "directshowglobal.h"
+
+
+QT_BEGIN_NAMESPACE
+
+Vmr9VideoWindowControl::Vmr9VideoWindowControl(QObject *parent)
+    : QVideoWindowControl(parent)
+    , m_filter(com_new<IBaseFilter>(CLSID_VideoMixingRenderer9, IID_IBaseFilter))
+    , m_windowId(0)
+    , m_dirtyValues(0)
+    , m_aspectRatioMode(Qt::KeepAspectRatio)
+    , m_brightness(0)
+    , m_contrast(0)
+    , m_hue(0)
+    , m_saturation(0)
+    , m_fullScreen(false)
+{
+    if (IVMRFilterConfig9 *config = com_cast<IVMRFilterConfig9>(m_filter, IID_IVMRFilterConfig9)) {
+        config->SetRenderingMode(VMR9Mode_Windowless);
+        config->SetNumberOfStreams(1);
+        config->SetRenderingPrefs(RenderPrefs9_DoNotRenderBorder);
+        config->Release();
+    }
+}
+
+Vmr9VideoWindowControl::~Vmr9VideoWindowControl()
+{
+    if (m_filter)
+        m_filter->Release();
+}
+
+
+WId Vmr9VideoWindowControl::winId() const
+{
+    return m_windowId;
+
+}
+
+void Vmr9VideoWindowControl::setWinId(WId id)
+{
+    m_windowId = id;
+
+    if (IVMRWindowlessControl9 *control = com_cast<IVMRWindowlessControl9>(
+            m_filter, IID_IVMRWindowlessControl9)) {
+        control->SetVideoClippingWindow(m_windowId);
+        control->Release();
+    }
+}
+
+QRect Vmr9VideoWindowControl::displayRect() const
+{
+    return m_displayRect;
+}
+
+void Vmr9VideoWindowControl::setDisplayRect(const QRect &rect)
+{
+    m_displayRect = rect;
+
+    if (IVMRWindowlessControl9 *control = com_cast<IVMRWindowlessControl9>(
+            m_filter, IID_IVMRWindowlessControl9)) {
+        RECT sourceRect = { 0, 0, 0, 0 };
+        RECT displayRect = { rect.left(), rect.top(), rect.right(), rect.bottom() };
+
+        control->GetNativeVideoSize(&sourceRect.right, &sourceRect.bottom, 0, 0);
+
+        if (m_aspectRatioMode == Qt::KeepAspectRatioByExpanding) {
+            QSize clippedSize = rect.size();
+            clippedSize.scale(sourceRect.right, sourceRect.bottom, Qt::KeepAspectRatio);
+
+            sourceRect.left = (sourceRect.right - clippedSize.width()) / 2;
+            sourceRect.top = (sourceRect.bottom - clippedSize.height()) / 2;
+            sourceRect.right = sourceRect.left + clippedSize.width();
+            sourceRect.bottom = sourceRect.top + clippedSize.height();
+        }
+
+        control->SetVideoPosition(&sourceRect, &displayRect);
+        control->Release();
+    }
+}
+
+bool Vmr9VideoWindowControl::isFullScreen() const
+{
+    return m_fullScreen;
+}
+
+void Vmr9VideoWindowControl::setFullScreen(bool fullScreen)
+{
+    emit fullScreenChanged(m_fullScreen = fullScreen);
+}
+
+void Vmr9VideoWindowControl::repaint()
+{
+    if (QWidget *widget = QWidget::find(m_windowId)) {
+        HDC dc = widget->getDC();
+        if (IVMRWindowlessControl9 *control = com_cast<IVMRWindowlessControl9>(
+                m_filter, IID_IVMRWindowlessControl9)) {
+            control->RepaintVideo(m_windowId, dc);
+            control->Release();
+        }
+        widget->releaseDC(dc);
+    }
+}
+
+QSize Vmr9VideoWindowControl::nativeSize() const
+{
+    QSize size;
+
+    if (IVMRWindowlessControl9 *control = com_cast<IVMRWindowlessControl9>(
+            m_filter, IID_IVMRWindowlessControl9)) {
+        LONG width;
+        LONG height;
+
+        if (control->GetNativeVideoSize(&width, &height, 0, 0) == S_OK)
+            size = QSize(width, height);
+        control->Release();
+    }
+    return size;
+}
+
+Qt::AspectRatioMode Vmr9VideoWindowControl::aspectRatioMode() const
+{
+    return m_aspectRatioMode;
+}
+
+void Vmr9VideoWindowControl::setAspectRatioMode(Qt::AspectRatioMode mode)
+{
+    m_aspectRatioMode = mode;
+
+    if (IVMRWindowlessControl9 *control = com_cast<IVMRWindowlessControl9>(
+            m_filter, IID_IVMRWindowlessControl9)) {
+        switch (mode) {
+        case Qt::IgnoreAspectRatio:
+            control->SetAspectRatioMode(VMR9ARMode_None);
+            break;
+        case Qt::KeepAspectRatio:
+            control->SetAspectRatioMode(VMR9ARMode_LetterBox);
+            break;
+        case Qt::KeepAspectRatioByExpanding:
+            control->SetAspectRatioMode(VMR9ARMode_LetterBox);
+            break;
+        default:
+            break;
+        }
+        control->Release();
+
+        setDisplayRect(m_displayRect);
+    }
+}
+
+int Vmr9VideoWindowControl::brightness() const
+{
+    return m_brightness;
+}
+
+void Vmr9VideoWindowControl::setBrightness(int brightness)
+{
+    m_brightness = brightness;
+
+    m_dirtyValues |= ProcAmpControl9_Brightness;
+
+    setProcAmpValues();
+
+    emit brightnessChanged(brightness);
+}
+
+int Vmr9VideoWindowControl::contrast() const
+{
+    return m_contrast;
+}
+
+void Vmr9VideoWindowControl::setContrast(int contrast)
+{
+    m_contrast = contrast;
+
+    m_dirtyValues |= ProcAmpControl9_Contrast;
+
+    setProcAmpValues();
+
+    emit contrastChanged(contrast);
+}
+
+int Vmr9VideoWindowControl::hue() const
+{
+    return m_hue;
+}
+
+void Vmr9VideoWindowControl::setHue(int hue)
+{
+    m_hue = hue;
+
+    m_dirtyValues |= ProcAmpControl9_Hue;
+
+    setProcAmpValues();
+
+    emit hueChanged(hue);
+}
+
+int Vmr9VideoWindowControl::saturation() const
+{
+    return m_saturation;
+}
+
+void Vmr9VideoWindowControl::setSaturation(int saturation)
+{
+    m_saturation = saturation;
+
+    m_dirtyValues |= ProcAmpControl9_Saturation;
+
+    setProcAmpValues();
+
+    emit saturationChanged(saturation);
+}
+
+void Vmr9VideoWindowControl::updateNativeSize()
+{
+    setDisplayRect(m_displayRect);
+
+    emit nativeSizeChanged();
+}
+
+void Vmr9VideoWindowControl::setProcAmpValues()
+{
+    if (IVMRMixerControl9 *control = com_cast<IVMRMixerControl9>(m_filter, IID_IVMRMixerControl9)) {
+        VMR9ProcAmpControl procAmp;
+        procAmp.dwSize = sizeof(VMR9ProcAmpControl);
+        procAmp.dwFlags = m_dirtyValues;
+
+        if (m_dirtyValues & ProcAmpControl9_Brightness) {
+            procAmp.Brightness = scaleProcAmpValue(
+                    control, ProcAmpControl9_Brightness, m_brightness);
+        }
+        if (m_dirtyValues & ProcAmpControl9_Contrast) {
+            procAmp.Contrast = scaleProcAmpValue(
+                    control, ProcAmpControl9_Contrast, m_contrast);
+        }
+        if (m_dirtyValues & ProcAmpControl9_Hue) {
+            procAmp.Hue = scaleProcAmpValue(
+                    control, ProcAmpControl9_Hue, m_hue);
+        }
+        if (m_dirtyValues & ProcAmpControl9_Saturation) {
+            procAmp.Saturation = scaleProcAmpValue(
+                    control, ProcAmpControl9_Saturation, m_saturation);
+        }
+
+        if (SUCCEEDED(control->SetProcAmpControl(0, &procAmp))) {
+            m_dirtyValues = 0;
+        }
+
+        control->Release();
+    }
+}
+
+float Vmr9VideoWindowControl::scaleProcAmpValue(
+        IVMRMixerControl9 *control, VMR9ProcAmpControlFlags property, int value) const
+{
+    float scaledValue = 0.0;
+
+    VMR9ProcAmpControlRange range;
+    range.dwSize = sizeof(VMR9ProcAmpControlRange);
+    range.dwProperty = property;
+
+    if (SUCCEEDED(control->GetProcAmpControlRange(0, &range))) {
+        scaledValue = range.DefaultValue;
+        if (value > 0)
+            scaledValue += float(value) * (range.MaxValue - range.DefaultValue) / 100;
+        else if (value < 0)
+            scaledValue -= float(value) * (range.MinValue - range.DefaultValue) / 100;
+    }
+
+    return scaledValue;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/directshow/mediaplayer/vmr9videowindowcontrol.h b/src/plugins/mediaservices/directshow/mediaplayer/vmr9videowindowcontrol.h
new file mode 100644
index 0000000..beac433
--- /dev/null
+++ b/src/plugins/mediaservices/directshow/mediaplayer/vmr9videowindowcontrol.h
@@ -0,0 +1,116 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef VMR9VIDEOWINDOWCONTROL_H
+#define VMR9VIDEOWINDOWCONTROL_H
+
+#include <QtMultimedia/qvideowindowcontrol.h>
+
+#include <dshow.h>
+#include <d3d9.h>
+#include <vmr9.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class Vmr9VideoWindowControl : public QVideoWindowControl
+{
+    Q_OBJECT
+public:
+    Vmr9VideoWindowControl(QObject *parent = 0);
+    ~Vmr9VideoWindowControl();
+
+    IBaseFilter *filter() const { return m_filter; }
+
+    WId winId() const;
+    void setWinId(WId id);
+
+    QRect displayRect() const;
+    void setDisplayRect(const QRect &rect);
+
+    bool isFullScreen() const;
+    void setFullScreen(bool fullScreen);
+
+    void repaint();
+
+    QSize nativeSize() const;
+
+    Qt::AspectRatioMode aspectRatioMode() const;
+    void setAspectRatioMode(Qt::AspectRatioMode mode);
+
+    int brightness() const;
+    void setBrightness(int brightness);
+
+    int contrast() const;
+    void setContrast(int contrast);
+
+    int hue() const;
+    void setHue(int hue);
+
+    int saturation() const;
+    void setSaturation(int saturation);
+
+    void updateNativeSize();
+
+private:
+    void setProcAmpValues();
+    float scaleProcAmpValue(
+            IVMRMixerControl9 *control, VMR9ProcAmpControlFlags property, int value) const;
+
+    IBaseFilter *m_filter;
+    WId m_windowId;
+    DWORD m_dirtyValues;
+    Qt::AspectRatioMode m_aspectRatioMode;
+    QRect m_displayRect;
+    int m_brightness;
+    int m_contrast;
+    int m_hue;
+    int m_saturation;
+    bool m_fullScreen;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/gstreamer.pro b/src/plugins/mediaservices/gstreamer/gstreamer.pro
new file mode 100644
index 0000000..d1bfe44
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/gstreamer.pro
@@ -0,0 +1,50 @@
+TARGET = gstengine
+include(../../qpluginbase.pri)
+
+QT += multimedia
+
+unix:contains(QT_CONFIG, alsa) {
+    DEFINES += HAVE_ALSA
+    LIBS += -lasound
+}
+
+QMAKE_CXXFLAGS += $$QT_CFLAGS_GSTREAMER
+LIBS += -lXv $$QT_LIBS_GSTREAMER -lgstinterfaces-0.10 -lgstvideo-0.10 -lgstbase-0.10 -lgstaudio-0.10
+
+# Input
+HEADERS += \
+    qgstreamermessage.h \
+    qgstreamerbushelper.h \
+    qgstreamervideooutputcontrol.h \
+    qgstreamervideorendererinterface.h \
+    qgstreamervideowidget.h \
+    qgstreamerserviceplugin.h \
+    qgstreamervideoinputdevicecontrol.h \
+    qgstreamervideooverlay.h \
+    qgstreamervideorenderer.h \
+    qgstvideobuffer.h \
+    qvideosurfacegstsink.h \
+    qx11videosurface.h \
+    qgstxvimagebuffer.h
+
+
+SOURCES += \
+    qgstreamermessage.cpp \
+    qgstreamerbushelper.cpp \
+    qgstreamervideooutputcontrol.cpp \
+    qgstreamervideorendererinterface.cpp \
+    qgstreamervideowidget.cpp \
+    qgstreamerserviceplugin.cpp \
+    qgstreamervideoinputdevicecontrol.cpp \
+    qgstreamervideooverlay.cpp \
+    qgstreamervideorenderer.cpp \
+    qgstvideobuffer.cpp \
+    qvideosurfacegstsink.cpp \
+    qx11videosurface.cpp \
+    qgstxvimagebuffer.cpp
+
+include(mediaplayer/mediaplayer.pri)
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/mediaservices
+target.path = $$[QT_INSTALL_PLUGINS]/mediaservices
+INSTALLS += target
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/mediaplayer.pri b/src/plugins/mediaservices/gstreamer/mediaplayer/mediaplayer.pri
new file mode 100644
index 0000000..19ff034
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/mediaplayer.pri
@@ -0,0 +1,17 @@
+INCLUDEPATH += $$PWD
+
+DEFINES += QMEDIA_GSTREAMER_PLAYER
+
+HEADERS += \
+    $$PWD/qgstreamerplayercontrol.h \
+    $$PWD/qgstreamerplayerservice.h \
+    $$PWD/qgstreamerplayersession.h \
+    $$PWD/qgstreamermetadataprovider.h
+
+SOURCES += \
+    $$PWD/qgstreamerplayercontrol.cpp \
+    $$PWD/qgstreamerplayerservice.cpp \
+    $$PWD/qgstreamerplayersession.cpp \
+    $$PWD/qgstreamermetadataprovider.cpp
+
+
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamermetadataprovider.cpp b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamermetadataprovider.cpp
new file mode 100644
index 0000000..eff6ea4
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamermetadataprovider.cpp
@@ -0,0 +1,209 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamermetadataprovider.h"
+#include "qgstreamerplayersession.h"
+#include <QtCore/qdebug.h>
+
+#include <gst/gstversion.h>
+
+QT_BEGIN_NAMESPACE
+
+struct QGstreamerMetaDataKeyLookup
+{
+    QtMultimedia::MetaData key;
+    const char *token;
+};
+
+static const QGstreamerMetaDataKeyLookup qt_gstreamerMetaDataKeys[] =
+{
+    { QtMultimedia::Title, GST_TAG_TITLE },
+    //{ QtMultimedia::SubTitle, 0 },
+    //{ QtMultimedia::Author, 0 },
+    { QtMultimedia::Comment, GST_TAG_COMMENT },
+    { QtMultimedia::Description, GST_TAG_DESCRIPTION },
+    //{ QtMultimedia::Category, 0 },
+    { QtMultimedia::Genre, GST_TAG_GENRE },
+    { QtMultimedia::Year, "year" },
+    //{ QtMultimedia::UserRating, 0 },
+
+    { QtMultimedia::Language, GST_TAG_LANGUAGE_CODE },
+
+    { QtMultimedia::Publisher, GST_TAG_ORGANIZATION },
+    { QtMultimedia::Copyright, GST_TAG_COPYRIGHT },
+    //{ QtMultimedia::ParentalRating, 0 },
+    //{ QtMultimedia::RatingOrganisation, 0 },
+
+    // Media
+    //{ QtMultimedia::Size, 0 },
+    //{ QtMultimedia::MediaType, 0 },
+    { QtMultimedia::Duration, GST_TAG_DURATION },
+
+    // Audio
+    { QtMultimedia::AudioBitRate, GST_TAG_BITRATE },
+    { QtMultimedia::AudioCodec, GST_TAG_AUDIO_CODEC },
+    //{ QtMultimedia::ChannelCount, 0 },
+    //{ QtMultimedia::Frequency, 0 },
+
+    // Music
+    { QtMultimedia::AlbumTitle, GST_TAG_ALBUM },
+    { QtMultimedia::AlbumArtist,  GST_TAG_ARTIST},
+    { QtMultimedia::ContributingArtist, GST_TAG_PERFORMER },
+#if (GST_VERSION_MAJOR >= 0) && (GST_VERSION_MINOR >= 10) && (GST_VERSION_MICRO >= 19)
+    { QtMultimedia::Composer, GST_TAG_COMPOSER },
+#endif
+    //{ QtMultimedia::Conductor, 0 },
+    //{ QtMultimedia::Lyrics, 0 },
+    //{ QtMultimedia::Mood, 0 },
+    { QtMultimedia::TrackNumber, GST_TAG_TRACK_NUMBER },
+
+    //{ QtMultimedia::CoverArtUrlSmall, 0 },
+    //{ QtMultimedia::CoverArtUrlLarge, 0 },
+
+    // Image/Video
+    //{ QtMultimedia::Resolution, 0 },
+    //{ QtMultimedia::PixelAspectRatio, 0 },
+
+    // Video
+    //{ QtMultimedia::VideoFrameRate, 0 },
+    //{ QtMultimedia::VideoBitRate, 0 },
+    { QtMultimedia::VideoCodec, GST_TAG_VIDEO_CODEC },
+
+    //{ QtMultimedia::PosterUrl, 0 },
+
+    // Movie
+    //{ QtMultimedia::ChapterNumber, 0 },
+    //{ QtMultimedia::Director, 0 },
+    { QtMultimedia::LeadPerformer, GST_TAG_PERFORMER },
+    //{ QtMultimedia::Writer, 0 },
+
+    // Photos
+    //{ QtMultimedia::CameraManufacturer, 0 },
+    //{ QtMultimedia::CameraModel, 0 },
+    //{ QtMultimedia::Event, 0 },
+    //{ QtMultimedia::Subject, 0 }
+};
+
+QGstreamerMetaDataProvider::QGstreamerMetaDataProvider(QGstreamerPlayerSession *session, QObject *parent)
+    :QMetaDataControl(parent), m_session(session)
+{
+    connect(m_session, SIGNAL(tagsChanged()), SLOT(updateTags()));
+}
+
+QGstreamerMetaDataProvider::~QGstreamerMetaDataProvider()
+{
+}
+
+bool QGstreamerMetaDataProvider::isMetaDataAvailable() const
+{
+    return !m_session->tags().isEmpty();
+}
+
+bool QGstreamerMetaDataProvider::isWritable() const
+{
+    return false;
+}
+
+QVariant QGstreamerMetaDataProvider::metaData(QtMultimedia::MetaData key) const
+{
+    static const int count = sizeof(qt_gstreamerMetaDataKeys) / sizeof(QGstreamerMetaDataKeyLookup);
+
+    for (int i = 0; i < count; ++i) {
+        if (qt_gstreamerMetaDataKeys[i].key == key) {
+            return m_session->tags().value(QByteArray(qt_gstreamerMetaDataKeys[i].token));
+        }
+    }
+    return QVariant();
+}
+
+void QGstreamerMetaDataProvider::setMetaData(QtMultimedia::MetaData key, QVariant const &value)
+{
+    Q_UNUSED(key);
+    Q_UNUSED(value);
+}
+
+QList<QtMultimedia::MetaData> QGstreamerMetaDataProvider::availableMetaData() const
+{
+    static QMap<QByteArray, QtMultimedia::MetaData> keysMap;
+    if (keysMap.isEmpty()) {
+        const int count = sizeof(qt_gstreamerMetaDataKeys) / sizeof(QGstreamerMetaDataKeyLookup);
+        for (int i = 0; i < count; ++i) {
+            keysMap[QByteArray(qt_gstreamerMetaDataKeys[i].token)] = qt_gstreamerMetaDataKeys[i].key;
+        }
+    }
+
+    QList<QtMultimedia::MetaData> res;
+    foreach (const QByteArray &key, m_session->tags().keys()) {
+        QtMultimedia::MetaData tag = keysMap.value(key, QtMultimedia::MetaData(-1));
+        if (tag != -1)
+            res.append(tag);
+    }
+
+    return res;
+}
+
+QVariant QGstreamerMetaDataProvider::extendedMetaData(const QString &key) const
+{
+    return m_session->tags().value(key.toLatin1());
+}
+
+void QGstreamerMetaDataProvider::setExtendedMetaData(const QString &key, QVariant const &value)
+{
+    Q_UNUSED(key);
+    Q_UNUSED(value);
+}
+
+QStringList QGstreamerMetaDataProvider::availableExtendedMetaData() const
+{
+    QStringList res;
+    foreach (const QByteArray &key, m_session->tags().keys())
+        res.append(QString(key));
+
+    return res;
+}
+
+void QGstreamerMetaDataProvider::updateTags()
+{
+    emit metaDataChanged();
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamermetadataprovider.h b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamermetadataprovider.h
new file mode 100644
index 0000000..267c2d7
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamermetadataprovider.h
@@ -0,0 +1,83 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERMETADATAPROVIDER_H
+#define QGSTREAMERMETADATAPROVIDER_H
+
+#include <QtMultimedia/qmetadatacontrol.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerPlayerSession;
+
+class QGstreamerMetaDataProvider : public QMetaDataControl
+{
+    Q_OBJECT
+public:
+    QGstreamerMetaDataProvider( QGstreamerPlayerSession *session, QObject *parent );
+    virtual ~QGstreamerMetaDataProvider();
+
+    bool isMetaDataAvailable() const;
+    bool isWritable() const;
+
+    QVariant metaData(QtMultimedia::MetaData key) const;
+    void setMetaData(QtMultimedia::MetaData key, const QVariant &value);
+    QList<QtMultimedia::MetaData> availableMetaData() const;
+
+    QVariant extendedMetaData(const QString &key) const ;
+    void setExtendedMetaData(const QString &key, const QVariant &value);
+    QStringList availableExtendedMetaData() const;
+
+private slots:
+    void updateTags();
+
+private:
+    QGstreamerPlayerSession *m_session;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGSTREAMERMETADATAPROVIDER_H
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayercontrol.cpp b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayercontrol.cpp
new file mode 100644
index 0000000..e646693
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayercontrol.cpp
@@ -0,0 +1,451 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamerplayercontrol.h"
+#include "qgstreamerplayersession.h"
+
+#include <qmediaplaylistnavigator.h>
+
+#include <QtCore/qdir.h>
+#include <QtCore/qsocketnotifier.h>
+#include <QtCore/qurl.h>
+#include <QtCore/qdebug.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+QT_BEGIN_NAMESPACE
+
+QGstreamerPlayerControl::QGstreamerPlayerControl(QGstreamerPlayerSession *session, QObject *parent)
+    : QMediaPlayerControl(parent)
+    , m_session(session)
+    , m_state(QMediaPlayer::StoppedState)
+    , m_mediaStatus(QMediaPlayer::NoMedia)
+    , m_bufferProgress(-1)
+    , m_stream(0)
+    , m_fifoNotifier(0)
+    , m_fifoCanWrite(false)
+    , m_bufferSize(0)
+    , m_bufferOffset(0)
+{
+    m_fifoFd[0] = -1;
+    m_fifoFd[1] = -1;
+
+    connect(m_session, SIGNAL(positionChanged(qint64)),
+            this, SIGNAL(positionChanged(qint64)));
+    connect(m_session, SIGNAL(durationChanged(qint64)),
+            this, SIGNAL(durationChanged(qint64)));
+    connect(m_session, SIGNAL(mutedStateChanged(bool)),
+            this, SIGNAL(mutedChanged(bool)));
+    connect(m_session, SIGNAL(volumeChanged(int)),
+            this, SIGNAL(volumeChanged(int)));
+    connect(m_session, SIGNAL(stateChanged(QMediaPlayer::State)),
+            this, SLOT(updateState(QMediaPlayer::State)));
+    connect(m_session,SIGNAL(bufferingProgressChanged(int)),
+            this, SLOT(setBufferProgress(int)));
+    connect(m_session, SIGNAL(playbackFinished()),
+            this, SLOT(processEOS()));
+    connect(m_session, SIGNAL(audioAvailableChanged(bool)),
+            this, SIGNAL(audioAvailableChanged(bool)));
+    connect(m_session, SIGNAL(videoAvailableChanged(bool)),
+            this, SIGNAL(videoAvailableChanged(bool)));
+    connect(m_session, SIGNAL(seekableChanged(bool)),
+            this, SIGNAL(seekableChanged(bool)));
+    connect(m_session, SIGNAL(error(int,QString)),
+            this, SIGNAL(error(int,QString)));
+}
+
+QGstreamerPlayerControl::~QGstreamerPlayerControl()
+{
+    if (m_fifoFd[0] >= 0) {
+        ::close(m_fifoFd[0]);
+        ::close(m_fifoFd[1]);
+        m_fifoFd[0] = -1;
+        m_fifoFd[1] = -1;
+    }
+}
+
+qint64 QGstreamerPlayerControl::position() const
+{
+    return m_session->position();
+}
+
+qint64 QGstreamerPlayerControl::duration() const
+{
+    return m_session->duration();
+}
+
+QMediaPlayer::State QGstreamerPlayerControl::state() const
+{
+    return m_state;
+}
+
+QMediaPlayer::MediaStatus QGstreamerPlayerControl::mediaStatus() const
+{
+    return m_mediaStatus;
+}
+
+int QGstreamerPlayerControl::bufferStatus() const
+{
+    if (m_bufferProgress == -1) {
+        return m_session->state() == QMediaPlayer::StoppedState ? 0 : 100;
+    } else
+        return m_bufferProgress;
+}
+
+int QGstreamerPlayerControl::volume() const
+{
+    return m_session->volume();
+}
+
+bool QGstreamerPlayerControl::isMuted() const
+{
+    return m_session->isMuted();
+}
+
+bool QGstreamerPlayerControl::isSeekable() const
+{
+    return m_session->isSeekable();
+}
+
+QMediaTimeRange QGstreamerPlayerControl::availablePlaybackRanges() const
+{
+    QMediaTimeRange ranges;
+
+     if (m_session->isSeekable())
+         ranges.addInterval(0, m_session->duration());
+
+     return ranges;
+}
+
+qreal QGstreamerPlayerControl::playbackRate() const
+{
+    return m_session->playbackRate();
+}
+
+void QGstreamerPlayerControl::setPlaybackRate(qreal rate)
+{
+    m_session->setPlaybackRate(rate);
+}
+
+void QGstreamerPlayerControl::setPosition(qint64 pos)
+{
+    m_session->seek(pos);
+}
+
+void QGstreamerPlayerControl::play()
+{
+    if (m_session->play()) {
+        if (m_state != QMediaPlayer::PlayingState)
+            emit stateChanged(m_state = QMediaPlayer::PlayingState);
+    }
+}
+
+void QGstreamerPlayerControl::pause()
+{
+    if (m_session->pause()) {
+        if (m_state != QMediaPlayer::PausedState)
+            emit stateChanged(m_state = QMediaPlayer::PausedState);
+    }
+}
+
+void QGstreamerPlayerControl::stop()
+{
+    if (m_state != QMediaPlayer::StoppedState) {
+        m_session->pause();
+        if (!m_session->seek(0)) {
+            m_bufferProgress = -1;
+            m_session->stop();
+            m_session->pause();
+        }
+        emit positionChanged(0);
+        if (m_state != QMediaPlayer::StoppedState)
+            emit stateChanged(m_state = QMediaPlayer::StoppedState);
+    }
+}
+
+void QGstreamerPlayerControl::setVolume(int volume)
+{
+    m_session->setVolume(volume);
+}
+
+void QGstreamerPlayerControl::setMuted(bool muted)
+{
+    m_session->setMuted(muted);
+}
+
+QMediaContent QGstreamerPlayerControl::media() const
+{
+    return m_currentResource;
+}
+
+const QIODevice *QGstreamerPlayerControl::mediaStream() const
+{
+    return m_stream;
+}
+
+void QGstreamerPlayerControl::setMedia(const QMediaContent &content, QIODevice *stream)
+{
+    QMediaPlayer::State oldState = m_state;
+    m_state = QMediaPlayer::StoppedState;    
+    m_session->stop();
+
+    if (m_bufferProgress != -1) {
+        m_bufferProgress = -1;
+        emit bufferStatusChanged(0);
+    }
+
+    if (m_stream) {
+        closeFifo();
+
+        disconnect(m_stream, SIGNAL(readyRead()), this, SLOT(writeFifo()));
+        m_stream = 0;
+    }
+
+    m_currentResource = content;
+    m_stream = stream;
+
+    QUrl url;
+
+    if (m_stream) {
+        if (m_stream->isReadable() && openFifo()) {
+            url = QUrl(QString(QLatin1String("fd://%1")).arg(m_fifoFd[0]));
+        }
+    } else if (!content.isNull()) {
+        url = content.canonicalUrl();
+    }
+
+    m_session->load(url);
+
+    if (m_fifoFd[1] >= 0) {
+        m_fifoCanWrite = true;
+
+        writeFifo();
+    }
+
+    if (!url.isEmpty()) {
+        if (m_mediaStatus != QMediaPlayer::LoadingMedia)
+            emit mediaStatusChanged(m_mediaStatus = QMediaPlayer::LoadingMedia);
+        m_session->pause();
+    } else {
+        if (m_mediaStatus != QMediaPlayer::NoMedia)
+            emit mediaStatusChanged(m_mediaStatus = QMediaPlayer::NoMedia);
+        setBufferProgress(0);
+    }
+
+    emit mediaChanged(m_currentResource);
+    if (m_state != oldState)
+        emit stateChanged(m_state);
+}
+
+void QGstreamerPlayerControl::setVideoOutput(QObject *output)
+{
+    m_session->setVideoRenderer(output);
+}
+
+bool QGstreamerPlayerControl::isAudioAvailable() const
+{
+    return m_session->isAudioAvailable();
+}
+
+bool QGstreamerPlayerControl::isVideoAvailable() const
+{
+    return m_session->isVideoAvailable();
+}
+
+void QGstreamerPlayerControl::updateState(QMediaPlayer::State state)
+{
+    QMediaPlayer::MediaStatus oldStatus = m_mediaStatus;
+
+    switch (state) {
+    case QMediaPlayer::StoppedState:
+        if (m_state != QMediaPlayer::StoppedState)
+            emit stateChanged(m_state = QMediaPlayer::StoppedState);
+        break;
+
+    case QMediaPlayer::PlayingState:
+    case QMediaPlayer::PausedState:
+        if (m_state == QMediaPlayer::StoppedState)
+            m_mediaStatus = QMediaPlayer::LoadedMedia;
+        else {            
+            if (m_bufferProgress == -1)
+                m_mediaStatus = QMediaPlayer::BufferedMedia;
+        }
+        break;
+    }
+
+    if (m_mediaStatus != oldStatus)
+        emit mediaStatusChanged(m_mediaStatus);
+}
+
+void QGstreamerPlayerControl::processEOS()
+{
+    m_mediaStatus = QMediaPlayer::EndOfMedia;
+    m_state = QMediaPlayer::StoppedState;
+
+    emit stateChanged(m_state);
+    emit mediaStatusChanged(m_mediaStatus);
+}
+
+void QGstreamerPlayerControl::setBufferProgress(int progress)
+{
+    if (m_bufferProgress == progress || m_mediaStatus == QMediaPlayer::NoMedia)
+        return;
+
+    QMediaPlayer::MediaStatus oldStatus = m_mediaStatus;
+
+    m_bufferProgress = progress;
+
+    if (m_state == QMediaPlayer::StoppedState) {
+        m_mediaStatus = QMediaPlayer::LoadedMedia;
+    } else {
+        if (m_bufferProgress < 100) {
+            m_mediaStatus = QMediaPlayer::StalledMedia;
+            m_session->pause();
+        } else {
+            m_mediaStatus = QMediaPlayer::BufferedMedia;
+            if (m_state == QMediaPlayer::PlayingState)
+                m_session->play();
+        }
+    }
+
+    if (m_mediaStatus != oldStatus)
+        emit mediaStatusChanged(m_mediaStatus);
+
+    emit bufferStatusChanged(m_bufferProgress);
+}
+
+void QGstreamerPlayerControl::writeFifo()
+{
+    if (m_fifoCanWrite) {
+        qint64 bytesToRead = qMin<qint64>(
+                m_stream->bytesAvailable(), PIPE_BUF - m_bufferSize);
+
+        if (bytesToRead > 0) {
+            int bytesRead = m_stream->read(&m_buffer[m_bufferOffset + m_bufferSize], bytesToRead);
+
+            if (bytesRead > 0)
+                m_bufferSize += bytesRead;
+        }
+
+        if (m_bufferSize > 0) {
+            int bytesWritten = ::write(m_fifoFd[1], &m_buffer[m_bufferOffset], size_t(m_bufferSize));
+
+            if (bytesWritten > 0) {
+                m_bufferOffset += bytesWritten;
+                m_bufferSize -= bytesWritten;
+
+                if (m_bufferSize == 0)
+                    m_bufferOffset = 0;
+            } else if (errno == EAGAIN) {
+                m_fifoCanWrite = false;
+            } else {
+                closeFifo();
+            }
+        }
+    }
+
+    m_fifoNotifier->setEnabled(m_stream->bytesAvailable() > 0);
+}
+
+void QGstreamerPlayerControl::fifoReadyWrite(int socket)
+{
+    if (socket == m_fifoFd[1]) {
+        m_fifoCanWrite = true;
+
+        writeFifo();
+    }
+}
+
+bool QGstreamerPlayerControl::openFifo()
+{
+    Q_ASSERT(m_fifoFd[0] < 0);
+    Q_ASSERT(m_fifoFd[1] < 0);
+
+    if (::pipe(m_fifoFd) == 0) {
+        int flags = ::fcntl(m_fifoFd[1], F_GETFD);
+
+        if (::fcntl(m_fifoFd[1], F_SETFD, flags | O_NONBLOCK) >= 0) {
+            m_fifoNotifier = new QSocketNotifier(m_fifoFd[1], QSocketNotifier::Write);
+
+            connect(m_fifoNotifier, SIGNAL(activated(int)), this, SLOT(fifoReadyWrite(int)));
+
+            return true;
+        } else {
+            qWarning("Failed to make pipe non blocking %d", errno);
+
+            ::close(m_fifoFd[0]);
+            ::close(m_fifoFd[1]);
+
+            m_fifoFd[0] = -1;
+            m_fifoFd[1] = -1;
+
+            return false;
+        }
+    } else {
+        qWarning("Failed to create pipe %d", errno);
+
+        return false;
+    }
+}
+
+void QGstreamerPlayerControl::closeFifo()
+{
+    if (m_fifoFd[0] >= 0) {
+        delete m_fifoNotifier;
+        m_fifoNotifier = 0;
+
+        ::close(m_fifoFd[0]);
+        ::close(m_fifoFd[1]);
+        m_fifoFd[0] = -1;
+        m_fifoFd[1] = -1;
+
+        m_fifoCanWrite = false;
+
+        m_bufferSize = 0;
+        m_bufferOffset = 0;
+    }
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayercontrol.h b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayercontrol.h
new file mode 100644
index 0000000..0c53945
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayercontrol.h
@@ -0,0 +1,136 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERPLAYERCONTROL_H
+#define QGSTREAMERPLAYERCONTROL_H
+
+#include <QtCore/qobject.h>
+
+#include <QtMultimedia/qmediaplayercontrol.h>
+#include <QtMultimedia/qmediaplayer.h>
+
+#include <limits.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QMediaPlaylist;
+class QGstreamerPlayerSession;
+class QGstreamerPlayerService;
+class QMediaPlaylistNavigator;
+class QSocketNotifier;
+
+class QGstreamerPlayerControl : public QMediaPlayerControl
+{
+    Q_OBJECT
+
+public:
+    QGstreamerPlayerControl(QGstreamerPlayerSession *session, QObject *parent = 0);
+    ~QGstreamerPlayerControl();
+
+    QMediaPlayer::State state() const;
+    QMediaPlayer::MediaStatus mediaStatus() const;
+
+    qint64 position() const;
+    qint64 duration() const;
+
+    int bufferStatus() const;
+
+    int volume() const;
+    bool isMuted() const;
+
+    bool isAudioAvailable() const;
+    bool isVideoAvailable() const;
+    void setVideoOutput(QObject *output);
+
+    bool isSeekable() const;
+    QMediaTimeRange availablePlaybackRanges() const;
+
+    qreal playbackRate() const;
+    void setPlaybackRate(qreal rate);
+
+    QMediaContent media() const;
+    const QIODevice *mediaStream() const;
+    void setMedia(const QMediaContent&, QIODevice *);
+
+public Q_SLOTS:
+    void setPosition(qint64 pos);
+
+    void play();
+    void pause();
+    void stop();
+
+    void setVolume(int volume);
+    void setMuted(bool muted);
+
+private Q_SLOTS:
+    void writeFifo();
+    void fifoReadyWrite(int socket);
+
+    void updateState(QMediaPlayer::State);
+    void processEOS();
+    void setBufferProgress(int progress);
+
+private:
+    bool openFifo();
+    void closeFifo();
+
+    QGstreamerPlayerSession *m_session;
+    QMediaPlayer::State m_state;
+    QMediaPlayer::MediaStatus m_mediaStatus;
+    int m_bufferProgress;
+    QMediaContent m_currentResource;
+    QIODevice *m_stream;
+    QSocketNotifier *m_fifoNotifier;
+    int m_fifoFd[2];
+    bool m_fifoCanWrite;
+    int m_bufferSize;
+    int m_bufferOffset;
+    char m_buffer[PIPE_BUF];
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayerservice.cpp b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayerservice.cpp
new file mode 100644
index 0000000..d5d7bd0
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayerservice.cpp
@@ -0,0 +1,137 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qdebug.h>
+#include <QtGui/qwidget.h>
+
+#include "qgstreamerplayerservice.h"
+#include "qgstreamerplayercontrol.h"
+#include "qgstreamerplayersession.h"
+#include "qgstreamermetadataprovider.h"
+#include "qgstreamervideooutputcontrol.h"
+
+#include "qgstreamervideooverlay.h"
+#include "qgstreamervideorenderer.h"
+
+#include "qgstreamervideowidget.h"
+//#include "qgstreamerstreamscontrol.h"
+
+#include <qmediaplaylistnavigator.h>
+#include <qmediaplaylist.h>
+
+
+QT_BEGIN_NAMESPACE
+
+
+QGstreamerPlayerService::QGstreamerPlayerService(QObject *parent):
+     QMediaService(parent)
+{
+    m_session = new QGstreamerPlayerSession(this);
+    m_control = new QGstreamerPlayerControl(m_session, this);
+    m_metaData = new QGstreamerMetaDataProvider(m_session, this);
+    m_videoOutput = new QGstreamerVideoOutputControl(this);
+//    m_streamsControl = new QGstreamerStreamsControl(m_session,this);
+
+    connect(m_videoOutput, SIGNAL(outputChanged(QVideoOutputControl::Output)),
+            this, SLOT(videoOutputChanged(QVideoOutputControl::Output)));
+    m_videoRenderer = new QGstreamerVideoRenderer(this);
+    m_videoWindow = new QGstreamerVideoOverlay(this);
+    m_videoWidget = new QGstreamerVideoWidgetControl(this);
+
+    m_videoOutput->setAvailableOutputs(QList<QVideoOutputControl::Output>()
+            << QVideoOutputControl::RendererOutput
+            << QVideoOutputControl::WindowOutput
+            << QVideoOutputControl::WidgetOutput);
+}
+
+QGstreamerPlayerService::~QGstreamerPlayerService()
+{
+}
+
+QMediaControl *QGstreamerPlayerService::control(const char *name) const
+{
+    if (qstrcmp(name,QMediaPlayerControl_iid) == 0)
+        return m_control;
+
+    if (qstrcmp(name,QMetaDataControl_iid) == 0)
+        return m_metaData;
+
+//    if (qstrcmp(name,QMediaStreamsControl_iid) == 0)
+//        return m_streamsControl;
+
+    if (qstrcmp(name, QVideoOutputControl_iid) == 0)
+        return m_videoOutput;
+
+    if (qstrcmp(name, QVideoWidgetControl_iid) == 0)
+        return m_videoWidget;
+
+    if (qstrcmp(name, QVideoRendererControl_iid) == 0)
+        return m_videoRenderer;
+
+    if (qstrcmp(name, QVideoWindowControl_iid) == 0)
+        return m_videoWindow;
+
+    return 0;
+}
+
+void QGstreamerPlayerService::videoOutputChanged(QVideoOutputControl::Output output)
+{
+    switch (output) {
+    case QVideoOutputControl::NoOutput:
+        m_control->setVideoOutput(0);
+        break;
+    case QVideoOutputControl::RendererOutput:
+        m_control->setVideoOutput(m_videoRenderer);
+        break;
+    case QVideoOutputControl::WindowOutput:
+        m_control->setVideoOutput(m_videoWindow);
+        break;
+    case QVideoOutputControl::WidgetOutput:
+        m_control->setVideoOutput(m_videoWidget);
+        break;
+    default:
+        qWarning("Invalid video output selection");
+        break;
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayerservice.h b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayerservice.h
new file mode 100644
index 0000000..f60c72e
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayerservice.h
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERPLAYERSERVICE_H
+#define QGSTREAMERPLAYERSERVICE_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qiodevice.h>
+
+#include <QtMultimedia/qmediaservice.h>
+
+#include "qgstreamervideooutputcontrol.h"
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QMediaMetaData;
+class QMediaPlayerControl;
+class QMediaPlaylist;
+class QMediaPlaylistNavigator;
+class QGstreamerMetaData;
+class QGstreamerPlayerControl;
+class QGstreamerPlayerSession;
+class QGstreamerMetaDataProvider;
+class QGstreamerStreamsControl;
+class QGstreamerVideoRenderer;
+class QGstreamerVideoOverlay;
+class QGstreamerVideoWidgetControl;
+
+
+class QGstreamerPlayerService : public QMediaService
+{
+    Q_OBJECT
+public:
+    QGstreamerPlayerService(QObject *parent = 0);
+    ~QGstreamerPlayerService();
+
+    //void setVideoOutput(QObject *output);
+
+    QMediaControl *control(const char *name) const;
+
+private slots:
+    void videoOutputChanged(QVideoOutputControl::Output output);
+
+private:
+    QGstreamerPlayerControl *m_control;
+    QGstreamerPlayerSession *m_session;
+    QGstreamerMetaDataProvider *m_metaData;
+    QGstreamerVideoOutputControl *m_videoOutput;
+    QGstreamerStreamsControl *m_streamsControl;
+
+    QGstreamerVideoRenderer *m_videoRenderer;
+    QGstreamerVideoOverlay *m_videoWindow;
+    QGstreamerVideoWidgetControl *m_videoWidget;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayersession.cpp b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayersession.cpp
new file mode 100644
index 0000000..56cdb04
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayersession.cpp
@@ -0,0 +1,913 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamerplayersession.h"
+#include "qgstreamerbushelper.h"
+
+#include "qgstreamervideorendererinterface.h"
+
+#include <gst/gstvalue.h>
+
+#include <QtCore/qdatetime.h>
+#include <QtCore/qdebug.h>
+
+//#define USE_PLAYBIN2
+
+//#define DEBUG_VO_BIN_DUMP
+//#define DEBUG_PLAYBIN_STATES
+
+
+QT_BEGIN_NAMESPACE
+
+QGstreamerPlayerSession::QGstreamerPlayerSession(QObject *parent)
+    :QObject(parent),
+     m_state(QMediaPlayer::StoppedState),
+     m_busHelper(0),
+     m_playbin(0),
+     m_videoSink(0),
+     m_pendingVideoSink(0),
+     m_nullVideoSink(0),
+     m_bus(0),
+     m_renderer(0),
+     m_volume(100),
+     m_playbackRate(1.0),
+     m_muted(false),
+     m_audioAvailable(false),
+     m_videoAvailable(false),
+     m_seekable(false),
+     m_lastPosition(0),
+     m_duration(-1)
+{
+    static bool initialized = false;
+    if (!initialized) {
+        initialized = true;
+        gst_init(NULL, NULL);
+    }
+
+#ifdef USE_PLAYBIN2
+    m_playbin = gst_element_factory_make("playbin2", NULL);
+#else
+    m_playbin = gst_element_factory_make("playbin", NULL);
+#endif
+
+    m_videoOutputBin = gst_bin_new("video-output-bin");
+    gst_object_ref(GST_OBJECT(m_videoOutputBin));
+
+    m_videoIdentity = gst_element_factory_make("identity", "identity-vo");
+    m_colorSpace = gst_element_factory_make("ffmpegcolorspace", "ffmpegcolorspace-vo");
+    m_videoScale = gst_element_factory_make("videoscale","videoscale-vo");
+    m_nullVideoSink = gst_element_factory_make("fakesink", NULL);
+    gst_object_ref(GST_OBJECT(m_nullVideoSink));
+    gst_bin_add_many(GST_BIN(m_videoOutputBin), m_videoIdentity, m_colorSpace, m_videoScale, m_nullVideoSink, NULL);
+    gst_element_link_many(m_videoIdentity, m_colorSpace, m_videoScale, m_nullVideoSink, NULL);
+
+    m_videoSink = m_nullVideoSink;
+
+    // add ghostpads
+    GstPad *pad = gst_element_get_static_pad(m_videoIdentity,"sink");
+    gst_element_add_pad(GST_ELEMENT(m_videoOutputBin), gst_ghost_pad_new("videosink", pad));
+    gst_object_unref(GST_OBJECT(pad));
+
+
+    if (m_playbin != 0) {
+        // Sort out messages
+        m_bus = gst_element_get_bus(m_playbin);
+        m_busHelper = new QGstreamerBusHelper(m_bus, this);
+        connect(m_busHelper, SIGNAL(message(QGstreamerMessage)), SLOT(busMessage(QGstreamerMessage)));
+        m_busHelper->installSyncEventFilter(this);
+
+        g_object_set(G_OBJECT(m_playbin), "video-sink", m_videoOutputBin, NULL);
+
+        // Initial volume
+        double volume = 1.0;
+        g_object_get(G_OBJECT(m_playbin), "volume", &volume, NULL);
+        m_volume = int(volume*100);
+    }
+}
+
+QGstreamerPlayerSession::~QGstreamerPlayerSession()
+{
+    if (m_playbin) {
+        stop();
+
+        delete m_busHelper;
+        gst_object_unref(GST_OBJECT(m_bus));
+        gst_object_unref(GST_OBJECT(m_playbin));
+        gst_object_unref(GST_OBJECT(m_nullVideoSink));
+        gst_object_unref(GST_OBJECT(m_videoOutputBin));
+    }
+}
+
+void QGstreamerPlayerSession::load(const QUrl &url)
+{
+    m_url = url;
+
+    if (m_playbin) {
+        m_tags.clear();
+        emit tagsChanged();
+
+        g_object_set(G_OBJECT(m_playbin), "uri", m_url.toEncoded().constData(), NULL);
+
+//        if (!m_streamTypes.isEmpty()) {
+//            m_streamProperties.clear();
+//            m_streamTypes.clear();
+//
+//            emit streamsChanged();
+//        }
+    }
+}
+
+qint64 QGstreamerPlayerSession::duration() const
+{
+    return m_duration;
+}
+
+qint64 QGstreamerPlayerSession::position() const
+{
+    GstFormat   format = GST_FORMAT_TIME;
+    gint64      position = 0;
+
+    if ( m_playbin && gst_element_query_position(m_playbin, &format, &position))
+        return position / 1000000;
+    else
+        return 0;
+}
+
+qreal QGstreamerPlayerSession::playbackRate() const
+{
+    return m_playbackRate;
+}
+
+void QGstreamerPlayerSession::setPlaybackRate(qreal rate)
+{
+    if (!qFuzzyCompare(m_playbackRate, rate)) {
+        m_playbackRate = rate;
+        if (m_playbin) {
+            gst_element_seek(m_playbin, rate, GST_FORMAT_TIME,
+                             GstSeekFlags(GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SEGMENT),
+                             GST_SEEK_TYPE_NONE,0,
+                             GST_SEEK_TYPE_NONE,0 );
+        }
+    }
+}
+
+
+//int QGstreamerPlayerSession::activeStream(QMediaStreamsControl::StreamType streamType) const
+//{
+//    int streamNumber = -1;
+//    if (m_playbin) {
+//        switch (streamType) {
+//        case QMediaStreamsControl::AudioStream:
+//            g_object_set(G_OBJECT(m_playbin), "current-audio", streamNumber, NULL);
+//            break;
+//        case QMediaStreamsControl::VideoStream:
+//            g_object_set(G_OBJECT(m_playbin), "current-video", streamNumber, NULL);
+//            break;
+//        case QMediaStreamsControl::SubPictureStream:
+//            g_object_set(G_OBJECT(m_playbin), "current-text", streamNumber, NULL);
+//            break;
+//        default:
+//            break;
+//        }
+//    }
+//
+//#ifdef USE_PLAYBIN2
+//    streamNumber += m_playbin2StreamOffset.value(streamType,0);
+//#endif
+//
+//    return streamNumber;
+//}
+
+//void QGstreamerPlayerSession::setActiveStream(QMediaStreamsControl::StreamType streamType, int streamNumber)
+//{
+//#ifdef USE_PLAYBIN2
+//    streamNumber -= m_playbin2StreamOffset.value(streamType,0);
+//#endif
+//
+//    if (m_playbin) {
+//        switch (streamType) {
+//        case QMediaStreamsControl::AudioStream:
+//            g_object_get(G_OBJECT(m_playbin), "current-audio", &streamNumber, NULL);
+//            break;
+//        case QMediaStreamsControl::VideoStream:
+//            g_object_get(G_OBJECT(m_playbin), "current-video", &streamNumber, NULL);
+//            break;
+//        case QMediaStreamsControl::SubPictureStream:
+//            g_object_get(G_OBJECT(m_playbin), "current-text", &streamNumber, NULL);
+//            break;
+//        default:
+//            break;
+//        }
+//    }
+//}
+
+
+bool QGstreamerPlayerSession::isBuffering() const
+{
+    return false;
+}
+
+int QGstreamerPlayerSession::bufferingProgress() const
+{
+    return 0;
+}
+
+int QGstreamerPlayerSession::volume() const
+{
+    return m_volume;
+}
+
+bool QGstreamerPlayerSession::isMuted() const
+{
+    return m_muted;
+}
+
+bool QGstreamerPlayerSession::isAudioAvailable() const
+{
+    return m_audioAvailable;
+}
+
+static void block_pad_cb(GstPad *pad, gboolean blocked, gpointer user_data)
+{
+    Q_UNUSED(pad);
+    //qDebug() << "block_pad_cb" << blocked;
+
+    if (blocked && user_data) {
+        QGstreamerPlayerSession *session = reinterpret_cast<QGstreamerPlayerSession*>(user_data);
+        QMetaObject::invokeMethod(session, "finishVideoOutputChange", Qt::QueuedConnection);
+    }
+}
+
+#ifdef DEBUG_VO_BIN_DUMP
+    static int dumpNum = 0;
+#endif
+
+void QGstreamerPlayerSession::setVideoRenderer(QObject *videoOutput)
+{
+    QGstreamerVideoRendererInterface* renderer = qobject_cast<QGstreamerVideoRendererInterface*>(videoOutput);
+
+    if (m_renderer == renderer)
+        return;
+
+#ifdef DEBUG_VO_BIN_DUMP
+    dumpNum++;
+
+    _gst_debug_bin_to_dot_file(GST_BIN(m_videoOutputBin),
+                                  GstDebugGraphDetails(GST_DEBUG_GRAPH_SHOW_ALL /* GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE | GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS | GST_DEBUG_GRAPH_SHOW_STATES*/),
+                                  QString("video_output_change_%1_set").arg(dumpNum).toAscii().constData());
+#endif
+
+    m_renderer = renderer;
+
+    GstElement *videoSink = m_renderer ? m_renderer->videoSink() : m_nullVideoSink;
+
+    if (m_state == QMediaPlayer::StoppedState) {
+        m_pendingVideoSink = 0;
+        gst_element_unlink(m_videoScale, m_videoSink);
+
+        gst_bin_remove(GST_BIN(m_videoOutputBin), m_videoSink);
+
+        m_videoSink = videoSink;
+
+        gst_bin_add(GST_BIN(m_videoOutputBin), m_videoSink);
+        gst_element_link(m_videoScale, m_videoSink);
+
+    } else {
+        if (m_pendingVideoSink) {
+            m_pendingVideoSink = videoSink;
+            return;
+        }
+
+        m_pendingVideoSink = videoSink;
+
+        //block pads, async to avoid locking in paused state
+        GstPad *srcPad = gst_element_get_static_pad(m_videoIdentity, "src");
+        gst_pad_set_blocked_async(srcPad, true, &block_pad_cb, this);
+        gst_object_unref(GST_OBJECT(srcPad));
+    }
+}
+
+void QGstreamerPlayerSession::finishVideoOutputChange()
+{
+    if (!m_pendingVideoSink)
+        return;
+
+    GstPad *srcPad = gst_element_get_static_pad(m_videoIdentity, "src");
+
+    if (!gst_pad_is_blocked(srcPad)) {
+        //pad is not blocked, it's possible to swap outputs only in the null state
+        GstState identityElementState = GST_STATE_NULL;
+        gst_element_get_state(m_videoIdentity, &identityElementState, NULL, GST_CLOCK_TIME_NONE);
+        if (identityElementState != GST_STATE_NULL) {
+            gst_object_unref(GST_OBJECT(srcPad));
+            return; //can't change vo yet, received async call from the previous change
+        }
+
+    }
+
+    if (m_pendingVideoSink == m_videoSink) {
+        //video output was change back to the current one,
+        //no need to torment the pipeline, just unblock the pad
+        if (gst_pad_is_blocked(srcPad))
+            gst_pad_set_blocked_async(srcPad, false, &block_pad_cb, 0);
+
+        m_pendingVideoSink = 0;
+        gst_object_unref(GST_OBJECT(srcPad));
+        return;
+    }  
+
+    gst_element_set_state(m_colorSpace, GST_STATE_NULL);
+    gst_element_set_state(m_videoScale, GST_STATE_NULL);
+    gst_element_set_state(m_videoSink, GST_STATE_NULL);
+
+    gst_element_unlink(m_videoScale, m_videoSink);
+
+    gst_bin_remove(GST_BIN(m_videoOutputBin), m_videoSink);
+
+    m_videoSink = m_pendingVideoSink;
+    m_pendingVideoSink = 0;
+
+    gst_bin_add(GST_BIN(m_videoOutputBin), m_videoSink);
+    if (!gst_element_link(m_videoScale, m_videoSink))
+        qWarning() << "Linking video output element failed";
+
+    GstState state;
+
+    switch (m_state) {
+    case QMediaPlayer::StoppedState:
+        state = GST_STATE_NULL;
+        break;
+    case QMediaPlayer::PausedState:
+        state = GST_STATE_PAUSED;
+        break;
+    case QMediaPlayer::PlayingState:
+        state = GST_STATE_PLAYING;
+        break;
+    }
+
+    gst_element_set_state(m_colorSpace, state);
+    gst_element_set_state(m_videoScale, state);
+    gst_element_set_state(m_videoSink, state);
+
+    //don't have to wait here, it will unblock eventually
+    if (gst_pad_is_blocked(srcPad))
+        gst_pad_set_blocked_async(srcPad, false, &block_pad_cb, 0);
+    gst_object_unref(GST_OBJECT(srcPad));
+
+#ifdef DEBUG_VO_BIN_DUMP
+    dumpNum++;
+
+    _gst_debug_bin_to_dot_file(GST_BIN(m_videoOutputBin),
+                                  GstDebugGraphDetails(/*GST_DEBUG_GRAPH_SHOW_ALL */ GST_DEBUG_GRAPH_SHOW_MEDIA_TYPE | GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS | GST_DEBUG_GRAPH_SHOW_STATES),
+                                  QString("video_output_change_%1_finish").arg(dumpNum).toAscii().constData());
+#endif
+
+}
+
+bool QGstreamerPlayerSession::isVideoAvailable() const
+{
+    return m_videoAvailable;
+}
+
+bool QGstreamerPlayerSession::isSeekable() const
+{
+    return m_seekable;
+}
+
+bool QGstreamerPlayerSession::play()
+{
+    if (m_playbin) {
+        if (gst_element_set_state(m_playbin, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
+            qWarning() << "GStreamer; Unable to play -" << m_url.toString();
+            m_state = QMediaPlayer::StoppedState;            
+
+            emit stateChanged(m_state);
+            emit error(int(QMediaPlayer::ResourceError), tr("Unable to play %1").arg(m_url.path()));
+        } else
+            return true;
+    }
+
+    return false;
+}
+
+bool QGstreamerPlayerSession::pause()
+{
+    if (m_playbin) {
+        if (gst_element_set_state(m_playbin, GST_STATE_PAUSED) == GST_STATE_CHANGE_FAILURE) {
+            qWarning() << "GStreamer; Unable to play -" << m_url.toString();
+            m_state = QMediaPlayer::StoppedState;
+
+            emit stateChanged(m_state);
+            emit error(int(QMediaPlayer::ResourceError), tr("Unable to play %1").arg(m_url.path()));
+        } else
+            return true;
+    }
+
+    return false;
+}
+
+void QGstreamerPlayerSession::stop()
+{
+    if (m_playbin) {
+        gst_element_set_state(m_playbin, GST_STATE_NULL);
+
+        QMediaPlayer::State oldState = QMediaPlayer::StoppedState;
+        m_state = QMediaPlayer::StoppedState;
+
+        finishVideoOutputChange();
+
+        //we have to do it here, since gstreamer will not emit bus messages any more
+        if (oldState != m_state)
+            emit stateChanged(m_state);
+    }
+}
+
+bool QGstreamerPlayerSession::seek(qint64 ms)
+{
+    //seek locks when the video output sink is changing and pad is blocked
+    if (m_playbin && !m_pendingVideoSink && m_state != QMediaPlayer::StoppedState) {
+        gint64  position = qMax(ms,qint64(0)) * 1000000;
+        return gst_element_seek_simple(m_playbin, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH, position);
+    }
+
+    return false;
+}
+
+void QGstreamerPlayerSession::setVolume(int volume)
+{
+    if (m_volume != volume) {
+        m_volume = volume;
+
+        if (m_playbin) {
+#ifndef USE_PLAYBIN2
+            if(!m_muted)
+#endif
+                g_object_set(G_OBJECT(m_playbin), "volume", m_volume/100.0, NULL);
+        }
+
+        emit volumeChanged(m_volume);
+    }
+
+}
+
+void QGstreamerPlayerSession::setMuted(bool muted)
+{
+    if (m_muted != muted) {
+        m_muted = muted;
+
+#ifdef USE_PLAYBIN2
+        g_object_set(G_OBJECT(m_playbin), "mute", m_muted, NULL);
+#else
+        g_object_set(G_OBJECT(m_playbin), "volume", (m_muted ? 0 : m_volume/100.0), NULL);
+#endif
+        emit mutedStateChanged(m_muted);
+    }
+}
+
+static void addTagToMap(const GstTagList *list,
+                        const gchar *tag,
+                        gpointer user_data)
+{
+    QMap<QByteArray, QVariant> *map = reinterpret_cast<QMap<QByteArray, QVariant>* >(user_data);
+
+    GValue val;
+    val.g_type = 0;
+    gst_tag_list_copy_value(&val,list,tag);
+
+    switch( G_VALUE_TYPE(&val) ) {
+        case G_TYPE_STRING:
+        {
+            const gchar *str_value = g_value_get_string(&val);
+            map->insert(QByteArray(tag), QString::fromUtf8(str_value));
+            break;
+        }
+        case G_TYPE_INT:
+            map->insert(QByteArray(tag), g_value_get_int(&val));
+            break;
+        case G_TYPE_UINT:
+            map->insert(QByteArray(tag), g_value_get_uint(&val));
+            break;
+        case G_TYPE_LONG:
+            map->insert(QByteArray(tag), qint64(g_value_get_long(&val)));
+            break;
+        case G_TYPE_BOOLEAN:
+            map->insert(QByteArray(tag), g_value_get_boolean(&val));
+            break;
+        case G_TYPE_CHAR:
+            map->insert(QByteArray(tag), g_value_get_char(&val));
+            break;
+        case G_TYPE_DOUBLE:
+            map->insert(QByteArray(tag), g_value_get_double(&val));
+            break;
+        default:
+            // GST_TYPE_DATE is a function, not a constant, so pull it out of the switch
+            if (G_VALUE_TYPE(&val) == GST_TYPE_DATE) {
+                const GDate *date = gst_value_get_date(&val);
+                if (g_date_valid(date)) {
+                    int year = g_date_get_year(date);
+                    int month = g_date_get_month(date);
+                    int day = g_date_get_day(date);
+                    map->insert(QByteArray(tag), QDate(year,month,day));
+                    if (!map->contains("year"))
+                        map->insert("year", year);
+                }
+            } else if (G_VALUE_TYPE(&val) == GST_TYPE_FRACTION) {
+                int nom = gst_value_get_fraction_numerator(&val);
+                int denom = gst_value_get_fraction_denominator(&val);
+
+                if (denom > 0) {
+                    map->insert(QByteArray(tag), double(nom)/denom);
+                }
+            }
+            break;
+    }
+
+    g_value_unset(&val);
+}
+
+void QGstreamerPlayerSession::setSeekable(bool seekable)
+{
+    if (seekable != m_seekable) {
+        m_seekable = seekable;
+        emit seekableChanged(m_seekable);
+    }
+}
+
+bool QGstreamerPlayerSession::processSyncMessage(const QGstreamerMessage &message)
+{
+    GstMessage* gm = message.rawMessage();
+
+    if (gm &&
+        GST_MESSAGE_TYPE(gm) == GST_MESSAGE_ELEMENT &&
+        gst_structure_has_name(gm->structure, "prepare-xwindow-id"))
+    {
+        if (m_renderer)
+            m_renderer->precessNewStream();
+        return true;
+    }
+
+    return false;
+}
+
+void QGstreamerPlayerSession::busMessage(const QGstreamerMessage &message)
+{
+    GstMessage* gm = message.rawMessage();
+
+    if (gm == 0) {
+        // Null message, query current position
+        quint32 newPos = position();
+
+        if (newPos/1000 != m_lastPosition) {
+            m_lastPosition = newPos/1000;
+            emit positionChanged(newPos);
+        }
+
+    } else {
+        //tag message comes from elements inside playbin, not from playbin itself
+        if (GST_MESSAGE_TYPE(gm) == GST_MESSAGE_TAG) {
+            //qDebug() << "tag message";
+            GstTagList *tag_list;
+            gst_message_parse_tag(gm, &tag_list);
+            gst_tag_list_foreach(tag_list, addTagToMap, &m_tags);
+
+            //qDebug() << m_tags;
+
+            emit tagsChanged();
+        }
+
+        if (GST_MESSAGE_SRC(gm) == GST_OBJECT_CAST(m_playbin)) {
+            switch (GST_MESSAGE_TYPE(gm))  {
+            case GST_MESSAGE_STATE_CHANGED:
+                {
+                    GstState    oldState;
+                    GstState    newState;
+                    GstState    pending;
+
+                    gst_message_parse_state_changed(gm, &oldState, &newState, &pending);
+
+#ifdef DEBUG_PLAYBIN_STATES
+                    QStringList states;
+                    states << "GST_STATE_VOID_PENDING" <<  "GST_STATE_NULL" << "GST_STATE_READY" << "GST_STATE_PAUSED" << "GST_STATE_PLAYING";
+
+                    qDebug() << QString("state changed: old: %1  new: %2  pending: %3") \
+                            .arg(states[oldState]) \
+                            .arg(states[newState]) \
+                            .arg(states[pending]);
+#endif
+
+                    switch (newState) {
+                    case GST_STATE_VOID_PENDING:
+                    case GST_STATE_NULL:
+                        setSeekable(false);
+                        if (m_state != QMediaPlayer::StoppedState)
+                            emit stateChanged(m_state = QMediaPlayer::StoppedState);
+                        break;
+                    case GST_STATE_READY:
+                        setSeekable(false);
+                        if (m_state != QMediaPlayer::StoppedState)
+                            emit stateChanged(m_state = QMediaPlayer::StoppedState);
+                        break;
+                    case GST_STATE_PAUSED:
+                        if (m_state != QMediaPlayer::PausedState)
+                            emit stateChanged(m_state = QMediaPlayer::PausedState);
+
+                        //check for seekable
+                        if (oldState == GST_STATE_READY) {
+                            /*
+                                //gst_element_seek_simple doesn't work reliably here, have to find a better solution
+
+                                GstFormat   format = GST_FORMAT_TIME;
+                                gint64      position = 0;
+                                bool seekable = false;
+                                if (gst_element_query_position(m_playbin, &format, &position)) {
+                                    seekable = gst_element_seek_simple(m_playbin, format, GST_SEEK_FLAG_NONE, position);
+                                }
+
+                                setSeekable(seekable);
+                                */
+
+                            setSeekable(true);
+
+                            if (!qFuzzyCompare(m_playbackRate, qreal(1.0)))
+                                setPlaybackRate(m_playbackRate);
+
+                            if (m_renderer)
+                                m_renderer->precessNewStream();
+
+                        }
+
+
+                        break;
+                    case GST_STATE_PLAYING:
+                        if (oldState == GST_STATE_PAUSED)
+                            getStreamsInfo();
+
+                        if (m_state != QMediaPlayer::PlayingState)
+                            emit stateChanged(m_state = QMediaPlayer::PlayingState);
+
+                        break;
+                    }
+                }
+                break;
+
+            case GST_MESSAGE_EOS:
+                emit playbackFinished();
+                break;
+
+            case GST_MESSAGE_TAG:
+            case GST_MESSAGE_STREAM_STATUS:
+            case GST_MESSAGE_UNKNOWN:
+                break;
+            case GST_MESSAGE_ERROR:
+                {
+                    GError *err;
+                    gchar *debug;
+                    gst_message_parse_error (gm, &err, &debug);
+                    emit error(int(QMediaPlayer::ResourceError), QString::fromUtf8(err->message));
+                    qWarning() << "Error:" << QString::fromUtf8(err->message);
+                    g_error_free (err);
+                    g_free (debug);
+                }
+                break;
+            case GST_MESSAGE_WARNING:
+            case GST_MESSAGE_INFO:
+                break;
+            case GST_MESSAGE_BUFFERING:
+                {
+                    int progress = 0;
+                    gst_message_parse_buffering(gm, &progress);
+                    emit bufferingProgressChanged(progress);
+                }
+                break;
+            case GST_MESSAGE_STATE_DIRTY:
+            case GST_MESSAGE_STEP_DONE:
+            case GST_MESSAGE_CLOCK_PROVIDE:
+            case GST_MESSAGE_CLOCK_LOST:
+            case GST_MESSAGE_NEW_CLOCK:
+            case GST_MESSAGE_STRUCTURE_CHANGE:
+            case GST_MESSAGE_APPLICATION:
+            case GST_MESSAGE_ELEMENT:
+                break;
+            case GST_MESSAGE_SEGMENT_START:
+                {
+                    const GstStructure *structure = gst_message_get_structure(gm);
+                    qint64 position = g_value_get_int64(gst_structure_get_value(structure, "position"));
+                    position /= 1000000;
+                    m_lastPosition = position;
+                    emit positionChanged(position);
+                }
+                break;
+            case GST_MESSAGE_SEGMENT_DONE:
+                break;
+            case GST_MESSAGE_DURATION:
+                {
+                    GstFormat   format = GST_FORMAT_TIME;
+                    gint64      duration = 0;
+
+                    if (gst_element_query_duration(m_playbin, &format, &duration)) {
+                        int newDuration = duration / 1000000;
+                        if (m_duration != newDuration) {
+                            m_duration = newDuration;
+                            emit durationChanged(m_duration);
+                        }
+                    }
+                }
+                break;
+            case GST_MESSAGE_LATENCY:
+#if (GST_VERSION_MAJOR >= 0) &&  (GST_VERSION_MINOR >= 10) && (GST_VERSION_MICRO >= 13)
+            case GST_MESSAGE_ASYNC_START:
+            case GST_MESSAGE_ASYNC_DONE:
+#if GST_VERSION_MICRO >= 23
+            case GST_MESSAGE_REQUEST_STATE:
+#endif
+#endif
+            case GST_MESSAGE_ANY:
+                break;
+            }
+        }
+    }
+}
+
+void QGstreamerPlayerSession::getStreamsInfo()
+{
+    GstFormat   format = GST_FORMAT_TIME;
+    gint64      duration = 0;
+
+    if (gst_element_query_duration(m_playbin, &format, &duration)) {
+        int newDuration = duration / 1000000;
+        if (m_duration != newDuration) {
+            m_duration = newDuration;
+            emit durationChanged(m_duration);
+        }
+    }
+
+    //check if video is available:
+    bool haveAudio = false;
+    bool haveVideo = false;
+//    m_streamProperties.clear();
+//    m_streamTypes.clear();
+
+#ifdef USE_PLAYBIN2
+    gint audioStreamsCount = 0;
+    gint videoStreamsCount = 0;
+    gint textStreamsCount = 0;
+
+    g_object_get(G_OBJECT(m_playbin), "n-audio", &audioStreamsCount, NULL);
+    g_object_get(G_OBJECT(m_playbin), "n-video", &videoStreamsCount, NULL);
+    g_object_get(G_OBJECT(m_playbin), "n-text", &textStreamsCount, NULL);
+
+    haveAudio = audioStreamsCount > 0;
+    haveVideo = videoStreamsCount > 0;
+
+    /*m_playbin2StreamOffset[QMediaStreamsControl::AudioStream] = 0;
+    m_playbin2StreamOffset[QMediaStreamsControl::VideoStream] = audioStreamsCount;
+    m_playbin2StreamOffset[QMediaStreamsControl::SubPictureStream] = audioStreamsCount+videoStreamsCount;
+
+    for (int i=0; i<audioStreamsCount; i++)
+        m_streamTypes.append(QMediaStreamsControl::AudioStream);
+
+    for (int i=0; i<videoStreamsCount; i++)
+        m_streamTypes.append(QMediaStreamsControl::VideoStream);
+
+    for (int i=0; i<textStreamsCount; i++)
+        m_streamTypes.append(QMediaStreamsControl::SubPictureStream);
+
+    for (int i=0; i<m_streamTypes.count(); i++) {
+        QMediaStreamsControl::StreamType streamType = m_streamTypes[i];
+        QMap<QtMultimedia::MetaData, QVariant> streamProperties;
+
+        int streamIndex = i - m_playbin2StreamOffset[streamType];
+
+        GstTagList *tags = 0;
+        switch (streamType) {
+        case QMediaStreamsControl::AudioStream:
+            g_signal_emit_by_name(G_OBJECT(m_playbin), "get-audio-tags", streamIndex, &tags);
+            break;
+        case QMediaStreamsControl::VideoStream:
+            g_signal_emit_by_name(G_OBJECT(m_playbin), "get-video-tags", streamIndex, &tags);
+            break;
+        case QMediaStreamsControl::SubPictureStream:
+            g_signal_emit_by_name(G_OBJECT(m_playbin), "get-text-tags", streamIndex, &tags);
+            break;
+        default:
+            break;
+        }
+
+        if (tags && gst_is_tag_list(tags)) {
+            gchar *languageCode = 0;
+            if (gst_tag_list_get_string(tags, GST_TAG_LANGUAGE_CODE, &languageCode))
+                streamProperties[QtMultimedia::Language] = QString::fromUtf8(languageCode);
+
+            //qDebug() << "language for setream" << i << QString::fromUtf8(languageCode);
+            g_free (languageCode);
+        }
+
+        m_streamProperties.append(streamProperties);
+        
+    }
+    */
+
+#else
+    enum {
+        GST_STREAM_TYPE_UNKNOWN,
+        GST_STREAM_TYPE_AUDIO,
+        GST_STREAM_TYPE_VIDEO,
+        GST_STREAM_TYPE_TEXT,
+        GST_STREAM_TYPE_SUBPICTURE,
+        GST_STREAM_TYPE_ELEMENT
+    };
+
+    GList*      streamInfo;
+    g_object_get(G_OBJECT(m_playbin), "stream-info", &streamInfo, NULL);
+
+    for (; streamInfo != 0; streamInfo = g_list_next(streamInfo)) {
+        gint        type;
+        gchar *languageCode = 0;
+
+        GObject*    obj = G_OBJECT(streamInfo->data);
+
+        g_object_get(obj, "type", &type, NULL);
+        g_object_get(obj, "language-code", &languageCode, NULL);
+
+        if (type == GST_STREAM_TYPE_VIDEO)
+            haveVideo = true;
+        else if (type == GST_STREAM_TYPE_AUDIO)
+            haveAudio = true;
+
+//        QMediaStreamsControl::StreamType streamType = QMediaStreamsControl::UnknownStream;
+//
+//        switch (type) {
+//        case GST_STREAM_TYPE_VIDEO:
+//            streamType = QMediaStreamsControl::VideoStream;
+//            break;
+//        case GST_STREAM_TYPE_AUDIO:
+//            streamType = QMediaStreamsControl::AudioStream;
+//            break;
+//        case GST_STREAM_TYPE_SUBPICTURE:
+//            streamType = QMediaStreamsControl::SubPictureStream;
+//            break;
+//        default:
+//            streamType = QMediaStreamsControl::UnknownStream;
+//            break;
+//        }
+//
+//        QMap<QtMultimedia::MetaData, QVariant> streamProperties;
+//        streamProperties[QtMultimedia::Language] = QString::fromUtf8(languageCode);
+//
+//        m_streamProperties.append(streamProperties);
+//        m_streamTypes.append(streamType);
+    }
+#endif
+
+    if (haveAudio != m_audioAvailable) {
+        m_audioAvailable = haveAudio;
+        emit audioAvailableChanged(m_audioAvailable);
+    }
+    if (haveVideo != m_videoAvailable) {
+        m_videoAvailable = haveVideo;
+        emit videoAvailableChanged(m_videoAvailable);
+    }
+
+    emit streamsChanged();
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayersession.h b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayersession.h
new file mode 100644
index 0000000..867a0e0
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/mediaplayer/qgstreamerplayersession.h
@@ -0,0 +1,176 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERPLAYERSESSION_H
+#define QGSTREAMERPLAYERSESSION_H
+
+#include <QObject>
+#include <QUrl>
+#include "qgstreamerplayercontrol.h"
+#include "qgstreamerbushelper.h"
+#include <QtMultimedia/qmediaplayer.h>
+//#include <qmediastreamscontrol.h>
+
+#include <gst/gst.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerBusHelper;
+class QGstreamerMessage;
+class QGstreamerVideoRendererInterface;
+
+class QGstreamerPlayerSession : public QObject, public QGstreamerSyncEventFilter
+{
+Q_OBJECT
+
+public:
+    QGstreamerPlayerSession(QObject *parent);
+    virtual ~QGstreamerPlayerSession();
+
+    QUrl url() const;
+
+    QMediaPlayer::State state() const { return m_state; }
+
+    qint64 duration() const;
+    qint64 position() const;
+
+    bool isBuffering() const;
+
+    int bufferingProgress() const;
+
+    int volume() const;
+    bool isMuted() const;
+
+    void setVideoRenderer(QObject *renderer);
+    bool isAudioAvailable() const;
+    bool isVideoAvailable() const;
+
+    bool isSeekable() const;
+
+    qreal playbackRate() const;
+    void setPlaybackRate(qreal rate);
+
+    QMap<QByteArray ,QVariant> tags() const { return m_tags; }
+    QMap<QtMultimedia::MetaData,QVariant> streamProperties(int streamNumber) const { return m_streamProperties[streamNumber]; }
+//    int streamCount() const { return m_streamProperties.count(); }
+//    QMediaStreamsControl::StreamType streamType(int streamNumber) { return m_streamTypes.value(streamNumber, QMediaStreamsControl::UnknownStream); }
+//
+//    int activeStream(QMediaStreamsControl::StreamType streamType) const;
+//    void setActiveStream(QMediaStreamsControl::StreamType streamType, int streamNumber);
+
+    bool processSyncMessage(const QGstreamerMessage &message);    
+
+public slots:
+    void load(const QUrl &url);
+
+    bool play();
+    bool pause();
+    void stop();
+
+    bool seek(qint64 pos);
+
+    void setVolume(int volume);
+    void setMuted(bool muted);
+
+signals:
+    void durationChanged(qint64 duration);
+    void positionChanged(qint64 position);
+    void stateChanged(QMediaPlayer::State state);
+    void volumeChanged(int volume);
+    void mutedStateChanged(bool muted);
+    void audioAvailableChanged(bool audioAvailable);
+    void videoAvailableChanged(bool videoAvailable);
+    void bufferingChanged(bool buffering);
+    void bufferingProgressChanged(int percentFilled);
+    void playbackFinished();
+    void tagsChanged();
+    void streamsChanged();
+    void seekableChanged(bool);
+    void error(int error, const QString &errorString);
+
+private slots:
+    void busMessage(const QGstreamerMessage &message);
+    void getStreamsInfo();
+    void setSeekable(bool);
+    void finishVideoOutputChange();
+
+private:
+    QUrl m_url;
+    QMediaPlayer::State m_state;
+    QGstreamerBusHelper* m_busHelper;
+    GstElement* m_playbin;
+
+    GstElement* m_videoOutputBin;
+    GstElement* m_videoIdentity;
+    GstElement* m_colorSpace;
+    GstElement* m_videoScale;
+    GstElement* m_videoSink;
+    GstElement* m_pendingVideoSink;
+    GstElement* m_nullVideoSink;
+
+    GstBus* m_bus;
+    QGstreamerVideoRendererInterface *m_renderer;
+
+    QMap<QByteArray, QVariant> m_tags;
+    QList< QMap<QtMultimedia::MetaData,QVariant> > m_streamProperties;
+//    QList<QMediaStreamsControl::StreamType> m_streamTypes;
+//    QMap<QMediaStreamsControl::StreamType, int> m_playbin2StreamOffset;
+
+
+    int m_volume;
+    qreal m_playbackRate;
+    bool m_muted;
+    bool m_audioAvailable;
+    bool m_videoAvailable;
+    bool m_seekable;
+
+    qint64 m_lastPosition;
+    qint64 m_duration;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGSTREAMERPLAYERSESSION_H
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamerbushelper.cpp b/src/plugins/mediaservices/gstreamer/qgstreamerbushelper.cpp
new file mode 100644
index 0000000..5049fa1
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamerbushelper.cpp
@@ -0,0 +1,206 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QMap>
+#include <QTimer>
+#include <QMutex>
+
+#include "qgstreamerbushelper.h"
+
+QT_BEGIN_NAMESPACE
+
+#ifndef QT_NO_GLIB
+class QGstreamerBusHelperPrivate : public QObject
+{
+    Q_OBJECT
+
+public:
+    void addWatch(GstBus* bus, QGstreamerBusHelper* helper)
+    {
+        setParent(helper);
+        m_tag = gst_bus_add_watch_full(bus, 0, busCallback, this, NULL);
+        m_helper = helper;
+        filter = 0;
+    }
+
+    void removeWatch(QGstreamerBusHelper* helper)
+    {
+        Q_UNUSED(helper);
+        g_source_remove(m_tag);
+    }
+
+    static QGstreamerBusHelperPrivate* instance()
+    {
+        return new QGstreamerBusHelperPrivate;
+    }
+
+private:
+    void processMessage(GstBus* bus, GstMessage* message)
+    {
+        Q_UNUSED(bus);
+        emit m_helper->message(message);
+    }
+
+    static gboolean busCallback(GstBus *bus, GstMessage *message, gpointer data)
+    {
+        reinterpret_cast<QGstreamerBusHelperPrivate*>(data)->processMessage(bus, message);
+        return TRUE;
+    }
+
+    guint       m_tag;
+    QGstreamerBusHelper*  m_helper;
+
+public:
+    GstBus* bus;
+    QGstreamerSyncEventFilter *filter;
+    QMutex filterMutex;
+};
+
+#else
+
+class QGstreamerBusHelperPrivate : public QObject
+{
+    Q_OBJECT
+    typedef QMap<QGstreamerBusHelper*, GstBus*>   HelperMap;
+
+public:
+    void addWatch(GstBus* bus, QGstreamerBusHelper* helper)
+    {
+        m_helperMap.insert(helper, bus);
+
+        if (m_helperMap.size() == 1)
+            m_intervalTimer->start();
+    }
+
+    void removeWatch(QGstreamerBusHelper* helper)
+    {
+        m_helperMap.remove(helper);
+
+        if (m_helperMap.size() == 0)
+            m_intervalTimer->stop();
+    }
+
+    static QGstreamerBusHelperPrivate* instance()
+    {
+        static QGstreamerBusHelperPrivate self;
+
+        return &self;
+    }
+
+private slots:
+    void interval()
+    {
+        for (HelperMap::iterator it = m_helperMap.begin(); it != m_helperMap.end(); ++it) {
+            GstMessage* message;
+
+            while ((message = gst_bus_poll(it.value(), GST_MESSAGE_ANY, 0)) != 0) {
+                emit it.key()->message(message);
+                gst_message_unref(message);
+            }
+
+            emit it.key()->message(QGstreamerMessage());
+        }
+    }
+
+private:
+    QGstreamerBusHelperPrivate()
+    {
+        m_intervalTimer = new QTimer(this);
+        m_intervalTimer->setInterval(250);
+
+        connect(m_intervalTimer, SIGNAL(timeout()), SLOT(interval()));
+    }
+
+    HelperMap   m_helperMap;
+    QTimer*     m_intervalTimer;
+
+public:
+    GstBus* bus;
+    QGstreamerSyncEventFilter *filter;
+    QMutex filterMutex;
+};
+#endif
+
+
+static GstBusSyncReply syncGstBusFilter(GstBus* bus, GstMessage* message, QGstreamerBusHelperPrivate *d)
+{
+    Q_UNUSED(bus);
+    QMutexLocker lock(&d->filterMutex);
+
+    bool res = false;
+
+    if (d->filter)
+        res = d->filter->processSyncMessage(QGstreamerMessage(message));
+
+    return res ? GST_BUS_DROP : GST_BUS_PASS;
+}
+
+
+/*!
+    \class QGstreamerBusHelper
+    \internal
+*/
+
+QGstreamerBusHelper::QGstreamerBusHelper(GstBus* bus, QObject* parent):
+    QObject(parent),
+    d(QGstreamerBusHelperPrivate::instance())
+{
+    d->bus = bus;
+    d->addWatch(bus, this);
+
+    gst_bus_set_sync_handler(bus, (GstBusSyncHandler)syncGstBusFilter, d);
+}
+
+QGstreamerBusHelper::~QGstreamerBusHelper()
+{
+    d->removeWatch(this);
+    gst_bus_set_sync_handler(d->bus,0,0);
+}
+
+void QGstreamerBusHelper::installSyncEventFilter(QGstreamerSyncEventFilter *filter)
+{
+    QMutexLocker lock(&d->filterMutex);
+    d->filter = filter;
+}
+
+QT_END_NAMESPACE
+
+#include "qgstreamerbushelper.moc"
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamerbushelper.h b/src/plugins/mediaservices/gstreamer/qgstreamerbushelper.h
new file mode 100644
index 0000000..8600015
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamerbushelper.h
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERBUSHELPER_H
+#define QGSTREAMERBUSHELPER_H
+
+#include <QObject>
+
+#include <qgstreamermessage.h>
+#include <gst/gst.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerSyncEventFilter {
+public:
+    //returns true if message was processed and should be dropped, false otherwise
+    virtual bool processSyncMessage(const QGstreamerMessage &message) = 0;
+};
+
+class QGstreamerBusHelperPrivate;
+
+class QGstreamerBusHelper : public QObject
+{
+    Q_OBJECT
+    friend class QGstreamerBusHelperPrivate;
+
+public:
+    QGstreamerBusHelper(GstBus* bus, QObject* parent = 0);
+    ~QGstreamerBusHelper();
+
+    void installSyncEventFilter(QGstreamerSyncEventFilter *filter);
+
+signals:
+    void message(QGstreamerMessage const& message);
+
+
+private:
+    QGstreamerBusHelperPrivate*   d;
+};
+
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamermessage.cpp b/src/plugins/mediaservices/gstreamer/qgstreamermessage.cpp
new file mode 100644
index 0000000..d52aa75
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamermessage.cpp
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <gst/gst.h>
+
+#include "qgstreamermessage.h"
+
+
+QT_BEGIN_NAMESPACE
+
+static int wuchi = qRegisterMetaType<QGstreamerMessage>();
+
+
+/*!
+    \class QGstreamerMessage
+    \internal
+*/
+
+QGstreamerMessage::QGstreamerMessage():
+    m_message(0)
+{
+}
+
+QGstreamerMessage::QGstreamerMessage(GstMessage* message):
+    m_message(message)
+{
+    gst_message_ref(m_message);
+}
+
+QGstreamerMessage::QGstreamerMessage(QGstreamerMessage const& m):
+    m_message(m.m_message)
+{
+    gst_message_ref(m_message);
+}
+
+
+QGstreamerMessage::~QGstreamerMessage()
+{
+    if (m_message != 0)
+        gst_message_unref(m_message);
+}
+
+GstMessage* QGstreamerMessage::rawMessage() const
+{
+    return m_message;
+}
+
+QGstreamerMessage& QGstreamerMessage::operator=(QGstreamerMessage const& rhs)
+{
+    if (m_message != 0)
+        gst_message_unref(m_message);
+
+    if ((m_message = rhs.m_message) != 0)
+        gst_message_ref(m_message);
+
+    return *this;
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamermessage.h b/src/plugins/mediaservices/gstreamer/qgstreamermessage.h
new file mode 100644
index 0000000..4680903
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamermessage.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERMESSAGE_H
+#define QGSTREAMERMESSAGE_H
+
+#include <QMetaType>
+
+#include <gst/gst.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerMessage
+{
+public:
+    QGstreamerMessage();
+    QGstreamerMessage(GstMessage* message);
+    QGstreamerMessage(QGstreamerMessage const& m);
+    ~QGstreamerMessage();
+
+    GstMessage* rawMessage() const;
+
+    QGstreamerMessage& operator=(QGstreamerMessage const& rhs);
+
+private:
+    GstMessage* m_message;
+};
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(QGstreamerMessage);
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamerserviceplugin.cpp b/src/plugins/mediaservices/gstreamer/qgstreamerserviceplugin.cpp
new file mode 100644
index 0000000..98068ac
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamerserviceplugin.cpp
@@ -0,0 +1,192 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qstring.h>
+#include <QtCore/qdebug.h>
+#include <QtGui/QIcon>
+#include <QtCore/QDir>
+
+#include "qgstreamerserviceplugin.h"
+
+#ifdef QMEDIA_GSTREAMER_PLAYER
+#include "qgstreamerplayerservice.h"
+#endif
+#ifdef QMEDIA_GSTREAMER_CAPTURE
+#include "qgstreamercaptureservice.h"
+#endif
+#include <QtMultimedia/qmediaserviceprovider.h>
+
+#ifdef QMEDIA_GSTREAMER_CAPTURE
+#include <linux/types.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <linux/videodev2.h>
+#endif
+
+
+QT_BEGIN_NAMESPACE
+
+
+QStringList QGstreamerServicePlugin::keys() const
+{
+    return QStringList()
+#ifdef QMEDIA_GSTREAMER_PLAYER
+            << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER)
+#endif
+#ifdef QMEDIA_GSTREAMER_CAPTURE
+            << QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE)
+            << QLatin1String(Q_MEDIASERVICE_CAMERA)
+#endif
+            ;
+}
+
+QMediaService* QGstreamerServicePlugin::create(const QString &key)
+{
+#ifdef QMEDIA_GSTREAMER_PLAYER
+    if (key == QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER))
+        return new QGstreamerPlayerService;
+#endif
+#ifdef QMEDIA_GSTREAMER_CAPTURE
+    if (key == QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE))
+        return new QGstreamerCaptureService(key);
+
+    if (key == QLatin1String(Q_MEDIASERVICE_CAMERA))
+        return new QGstreamerCaptureService(key);
+#endif
+
+    qWarning() << "GStreamer service plugin: unsupported service -" << key;
+    return 0;
+}
+
+void QGstreamerServicePlugin::release(QMediaService *service)
+{
+    delete service;
+}
+
+QList<QByteArray> QGstreamerServicePlugin::devices(const QByteArray &service) const
+{
+#ifdef QMEDIA_GSTREAMER_CAPTURE
+    if (service == Q_MEDIASERVICE_CAMERA) {
+        if (m_cameraDevices.isEmpty())
+            updateDevices();
+
+        return m_cameraDevices;
+    }
+#endif
+
+    return QList<QByteArray>();
+}
+
+QString QGstreamerServicePlugin::deviceDescription(const QByteArray &service, const QByteArray &device)
+{
+#ifdef QMEDIA_GSTREAMER_CAPTURE
+    if (service == Q_MEDIASERVICE_CAMERA) {
+        if (m_cameraDevices.isEmpty())
+            updateDevices();
+
+        for (int i=0; i<m_cameraDevices.count(); i++)
+            if (m_cameraDevices[i] == device)
+                return m_cameraDescriptions[i];
+    }
+#endif
+
+    return QString();
+}
+
+void QGstreamerServicePlugin::updateDevices() const
+{
+#ifdef QMEDIA_GSTREAMER_CAPTURE
+    m_cameraDevices.clear();
+    m_cameraDescriptions.clear();
+
+    QDir devDir("/dev");
+    devDir.setFilter(QDir::System);
+
+    QFileInfoList entries = devDir.entryInfoList(QStringList() << "video*");
+
+    foreach( const QFileInfo &entryInfo, entries ) {
+//        qDebug() << "Try" << entryInfo.filePath();
+
+        int fd = ::open(entryInfo.filePath().toLatin1().constData(), O_RDWR );
+        if (fd == -1)
+            continue;
+
+        bool isCamera = false;
+
+        v4l2_input input;
+        memset(&input, 0, sizeof(input));
+        for (; ::ioctl(fd, VIDIOC_ENUMINPUT, &input) >= 0; ++input.index) {
+            if(input.type == V4L2_INPUT_TYPE_CAMERA || input.type == 0) {
+                isCamera = ::ioctl(fd, VIDIOC_S_INPUT, input.index) != 0;
+                break;
+            }
+        }
+
+        if (isCamera) {
+            // find out its driver "name"
+            QString name;
+            struct v4l2_capability vcap;
+            memset(&vcap, 0, sizeof(struct v4l2_capability));
+
+            if (ioctl(fd, VIDIOC_QUERYCAP, &vcap) != 0)
+                name = entryInfo.fileName();
+            else
+                name = QString((const char*)vcap.card);
+//            qDebug() << "found camera: " << name;
+
+            m_cameraDevices.append(entryInfo.filePath().toLocal8Bit());
+            m_cameraDescriptions.append(name);
+        }
+        ::close(fd);
+    }
+#endif
+}
+
+Q_EXPORT_PLUGIN2(gstengine, QGstreamerServicePlugin);
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamerserviceplugin.h b/src/plugins/mediaservices/gstreamer/qgstreamerserviceplugin.h
new file mode 100644
index 0000000..d6d6899
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamerserviceplugin.h
@@ -0,0 +1,76 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QGSTREAMERSERVICEPLUGIN_H
+#define QGSTREAMERSERVICEPLUGIN_H
+
+#include <QtMultimedia/qmediaserviceproviderplugin.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerServicePlugin : public QMediaServiceProviderPlugin, public QMediaServiceSupportedDevicesInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
+public:
+    QStringList keys() const;
+    QMediaService* create(QString const& key);
+    void release(QMediaService *service);
+
+    QList<QByteArray> devices(const QByteArray &service) const;
+    QString deviceDescription(const QByteArray &service, const QByteArray &device);
+
+private:
+    void updateDevices() const;
+
+    mutable QList<QByteArray> m_cameraDevices;
+    mutable QStringList m_cameraDescriptions;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGSTREAMERSERVICEPLUGIN_H
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideoinputdevicecontrol.cpp b/src/plugins/mediaservices/gstreamer/qgstreamervideoinputdevicecontrol.cpp
new file mode 100644
index 0000000..4ecf10b
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideoinputdevicecontrol.cpp
@@ -0,0 +1,165 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamervideoinputdevicecontrol.h"
+
+#include <QtGui/QIcon>
+#include <QtCore/QDir>
+#include <QtCore/QDebug>
+
+#include <linux/types.h>
+#include <sys/time.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/mman.h>
+#include <linux/videodev2.h>
+
+
+QT_BEGIN_NAMESPACE
+
+QGstreamerVideoInputDeviceControl::QGstreamerVideoInputDeviceControl(QObject *parent)
+    :QVideoDeviceControl(parent), m_selectedDevice(0)
+{
+    update();
+}
+
+QGstreamerVideoInputDeviceControl::~QGstreamerVideoInputDeviceControl()
+{
+}
+
+int QGstreamerVideoInputDeviceControl::deviceCount() const
+{
+    return m_names.size();
+}
+
+QString QGstreamerVideoInputDeviceControl::deviceName(int index) const
+{
+    return m_names[index];
+}
+
+QString QGstreamerVideoInputDeviceControl::deviceDescription(int index) const
+{
+    return m_descriptions[index];
+}
+
+QIcon QGstreamerVideoInputDeviceControl::deviceIcon(int index) const
+{
+    Q_UNUSED(index);
+    return QIcon();
+}
+
+int QGstreamerVideoInputDeviceControl::defaultDevice() const
+{
+    return 0;
+}
+
+int QGstreamerVideoInputDeviceControl::selectedDevice() const
+{
+    return m_selectedDevice;
+}
+
+
+void QGstreamerVideoInputDeviceControl::setSelectedDevice(int index)
+{
+    if (index != m_selectedDevice) {
+        m_selectedDevice = index;
+        emit selectedDeviceChanged(index);
+        emit selectedDeviceChanged(deviceName(index));
+    }
+}
+
+
+void QGstreamerVideoInputDeviceControl::update()
+{
+    m_names.clear();
+    m_descriptions.clear();
+
+#ifdef QMEDIA_GSTREAMER_CAPTURE
+    QDir devDir("/dev");
+    devDir.setFilter(QDir::System);
+
+    QFileInfoList entries = devDir.entryInfoList(QStringList() << "video*");
+
+    foreach( const QFileInfo &entryInfo, entries ) {
+//        qDebug() << "Try" << entryInfo.filePath();
+
+        int fd = ::open(entryInfo.filePath().toLatin1().constData(), O_RDWR );
+        if (fd == -1)
+            continue;
+
+        bool isCamera = false;
+
+        v4l2_input input;
+        memset(&input, 0, sizeof(input));
+        for (; ::ioctl(fd, VIDIOC_ENUMINPUT, &input) >= 0; ++input.index) {
+            if(input.type == V4L2_INPUT_TYPE_CAMERA || input.type == 0) {
+                isCamera = ::ioctl(fd, VIDIOC_S_INPUT, input.index) != 0;
+                break;
+            }
+        }
+
+        if (isCamera) {
+            // find out its driver "name"
+            QString name;
+            struct v4l2_capability vcap;
+            memset(&vcap, 0, sizeof(struct v4l2_capability));
+
+            if (ioctl(fd, VIDIOC_QUERYCAP, &vcap) != 0)
+                name = entryInfo.fileName();
+            else
+                name = QString((const char*)vcap.card);
+//            qDebug() << "found camera: " << name;
+
+            m_names.append(entryInfo.filePath());
+            m_descriptions.append(name);
+        }
+        ::close(fd);
+    }
+#endif
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideoinputdevicecontrol.h b/src/plugins/mediaservices/gstreamer/qgstreamervideoinputdevicecontrol.h
new file mode 100644
index 0000000..6762bab
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideoinputdevicecontrol.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERVIDEOINPUTDEVICECONTROL_H
+#define QGSTREAMERVIDEOINPUTDEVICECONTROL_H
+
+#include <QtMultimedia/qvideodevicecontrol.h>
+#include <QtCore/qstringlist.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+
+class QGstreamerVideoInputDeviceControl : public QVideoDeviceControl
+{
+Q_OBJECT
+public:
+    QGstreamerVideoInputDeviceControl(QObject *parent);
+    ~QGstreamerVideoInputDeviceControl();
+
+    int deviceCount() const;
+
+    QString deviceName(int index) const;
+    QString deviceDescription(int index) const;
+    QIcon deviceIcon(int index) const;
+
+    int defaultDevice() const;
+    int selectedDevice() const;
+
+public Q_SLOTS:
+    void setSelectedDevice(int index);
+
+private:
+    void update();
+
+    int m_selectedDevice;
+    QStringList m_names;
+    QStringList m_descriptions;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGSTREAMERAUDIOINPUTDEVICECONTROL_H
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideooutputcontrol.cpp b/src/plugins/mediaservices/gstreamer/qgstreamervideooutputcontrol.cpp
new file mode 100644
index 0000000..f406bff
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideooutputcontrol.cpp
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamervideooutputcontrol.h"
+
+QT_BEGIN_NAMESPACE
+
+QGstreamerVideoOutputControl::QGstreamerVideoOutputControl(QObject *parent)
+    : QVideoOutputControl(parent)
+    , m_output(NoOutput)
+{
+}
+
+QList<QVideoOutputControl::Output> QGstreamerVideoOutputControl::availableOutputs() const
+{
+    return m_outputs;
+}
+
+void QGstreamerVideoOutputControl::setAvailableOutputs(const QList<Output> &outputs)
+{
+    emit availableOutputsChanged(m_outputs = outputs);
+}
+
+QVideoOutputControl::Output QGstreamerVideoOutputControl::output() const
+{
+    return m_output;
+}
+
+void QGstreamerVideoOutputControl::setOutput(Output output)
+{
+    if (!m_outputs.contains(output))
+        output = NoOutput;
+
+    if (m_output != output)
+        emit outputChanged(m_output = output);
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideooutputcontrol.h b/src/plugins/mediaservices/gstreamer/qgstreamervideooutputcontrol.h
new file mode 100644
index 0000000..7685239
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideooutputcontrol.h
@@ -0,0 +1,86 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERVIDEOOUTPUTCONTROL_H
+#define QGSTREAMERVIDEOOUTPUTCONTROL_H
+
+#include <QtMultimedia/qvideooutputcontrol.h>
+
+#include <gst/gst.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerVideoRendererInterface
+{
+public:
+    virtual ~QGstreamerVideoRendererInterface();
+    virtual GstElement *videoSink() = 0;
+    virtual void precessNewStream() {}
+};
+
+class QGstreamerVideoOutputControl : public QVideoOutputControl
+{
+    Q_OBJECT
+public:
+    QGstreamerVideoOutputControl(QObject *parent = 0);
+
+    QList<Output> availableOutputs() const;
+    void setAvailableOutputs(const QList<Output> &outputs);
+
+    Output output() const;
+    void setOutput(Output output);
+
+Q_SIGNALS:
+    void outputChanged(QVideoOutputControl::Output output);
+
+private:
+    QList<Output> m_outputs;
+    Output m_output;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideooverlay.cpp b/src/plugins/mediaservices/gstreamer/qgstreamervideooverlay.cpp
new file mode 100644
index 0000000..f381f7f
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideooverlay.cpp
@@ -0,0 +1,230 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamervideooverlay.h"
+#include "qvideosurfacegstsink.h"
+
+#include <QtMultimedia/qvideosurfaceformat.h>
+
+#include "qx11videosurface.h"
+
+QT_BEGIN_NAMESPACE
+
+QGstreamerVideoOverlay::QGstreamerVideoOverlay(QObject *parent)
+    : QVideoWindowControl(parent)
+    , m_surface(new QX11VideoSurface)
+    , m_videoSink(reinterpret_cast<GstElement*>(QVideoSurfaceGstSink::createSink(m_surface)))
+    , m_aspectRatioMode(Qt::KeepAspectRatio)
+    , m_fullScreen(false)
+{
+    if (m_videoSink) {
+        gst_object_ref(GST_OBJECT(m_videoSink)); //Take ownership
+        gst_object_sink(GST_OBJECT(m_videoSink));
+    }
+
+    connect(m_surface, SIGNAL(surfaceFormatChanged(QVideoSurfaceFormat)),
+            this, SLOT(surfaceFormatChanged()));
+}
+
+QGstreamerVideoOverlay::~QGstreamerVideoOverlay()
+{
+    if (m_videoSink)
+        gst_object_unref(GST_OBJECT(m_videoSink));
+
+    delete m_surface;
+}
+
+WId QGstreamerVideoOverlay::winId() const
+{
+    return m_surface->winId();
+}
+
+void QGstreamerVideoOverlay::setWinId(WId id)
+{
+    m_surface->setWinId(id);
+}
+
+QRect QGstreamerVideoOverlay::displayRect() const
+{
+    return m_displayRect;
+}
+
+void QGstreamerVideoOverlay::setDisplayRect(const QRect &rect)
+{
+    m_displayRect = rect;
+
+    setScaledDisplayRect();
+}
+
+Qt::AspectRatioMode QGstreamerVideoOverlay::aspectRatioMode() const
+{
+    return m_aspectRatioMode;
+}
+
+void QGstreamerVideoOverlay::setAspectRatioMode(Qt::AspectRatioMode mode)
+{
+    m_aspectRatioMode = mode;
+
+    setScaledDisplayRect();
+}
+
+void QGstreamerVideoOverlay::repaint()
+{
+}
+
+int QGstreamerVideoOverlay::brightness() const
+{
+    return m_surface->brightness();
+}
+
+void QGstreamerVideoOverlay::setBrightness(int brightness)
+{
+    m_surface->setBrightness(brightness);
+
+    emit brightnessChanged(m_surface->brightness());
+}
+
+int QGstreamerVideoOverlay::contrast() const
+{
+    return m_surface->contrast();
+}
+
+void QGstreamerVideoOverlay::setContrast(int contrast)
+{
+    m_surface->setContrast(contrast);
+
+    emit contrastChanged(m_surface->contrast());
+}
+
+int QGstreamerVideoOverlay::hue() const
+{
+    return m_surface->hue();
+}
+
+void QGstreamerVideoOverlay::setHue(int hue)
+{
+    m_surface->setHue(hue);
+
+    emit hueChanged(m_surface->hue());
+}
+
+int QGstreamerVideoOverlay::saturation() const
+{
+    return m_surface->saturation();
+}
+
+void QGstreamerVideoOverlay::setSaturation(int saturation)
+{
+    m_surface->setSaturation(saturation);
+
+    emit saturationChanged(m_surface->saturation());
+}
+
+bool QGstreamerVideoOverlay::isFullScreen() const
+{
+    return m_fullScreen;
+}
+
+void QGstreamerVideoOverlay::setFullScreen(bool fullScreen)
+{
+    emit fullScreenChanged(m_fullScreen = fullScreen);
+}
+
+QSize QGstreamerVideoOverlay::nativeSize() const
+{
+    return m_surface->surfaceFormat().sizeHint();
+}
+
+QAbstractVideoSurface *QGstreamerVideoOverlay::surface() const
+{
+    return m_surface;
+}
+
+GstElement *QGstreamerVideoOverlay::videoSink()
+{
+    return m_videoSink;
+}
+
+void QGstreamerVideoOverlay::surfaceFormatChanged()
+{
+    setScaledDisplayRect();
+
+    emit nativeSizeChanged();
+}
+
+void QGstreamerVideoOverlay::setScaledDisplayRect()
+{
+    QRect formatViewport = m_surface->surfaceFormat().viewport();
+
+    switch (m_aspectRatioMode) {
+    case Qt::KeepAspectRatio:
+        {
+            QSize size = m_surface->surfaceFormat().sizeHint();
+            size.scale(m_displayRect.size(), Qt::KeepAspectRatio);
+
+            QRect rect(QPoint(0, 0), size);
+            rect.moveCenter(m_displayRect.center());
+
+            m_surface->setDisplayRect(rect);
+            m_surface->setViewport(formatViewport);
+        }
+        break;
+    case Qt::IgnoreAspectRatio:
+        m_surface->setDisplayRect(m_displayRect);
+        m_surface->setViewport(formatViewport);
+        break;
+    case Qt::KeepAspectRatioByExpanding:
+        {
+            QSize size = m_displayRect.size();
+            size.scale(m_surface->surfaceFormat().sizeHint(), Qt::KeepAspectRatio);
+
+            QRect viewport(QPoint(0, 0), size);
+            viewport.moveCenter(formatViewport.center());
+
+            m_surface->setDisplayRect(m_displayRect);
+            m_surface->setViewport(viewport);
+        }
+        break;
+    };
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideooverlay.h b/src/plugins/mediaservices/gstreamer/qgstreamervideooverlay.h
new file mode 100644
index 0000000..1188074
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideooverlay.h
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERVIDEOOVERLAY_H
+#define QGSTREAMERVIDEOOVERLAY_H
+
+#include <QtMultimedia/qvideowindowcontrol.h>
+
+#include "qgstreamervideorendererinterface.h"
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QAbstractVideoSurface;
+class QX11VideoSurface;
+
+class QGstreamerVideoOverlay : public QVideoWindowControl, public QGstreamerVideoRendererInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QGstreamerVideoRendererInterface)
+public:
+    QGstreamerVideoOverlay(QObject *parent = 0);
+    ~QGstreamerVideoOverlay();
+
+    WId winId() const;
+    void setWinId(WId id);
+
+    QRect displayRect() const;
+    void setDisplayRect(const QRect &rect);
+
+    bool isFullScreen() const;
+    void setFullScreen(bool fullScreen);
+
+    QSize nativeSize() const;
+
+    Qt::AspectRatioMode aspectRatioMode() const;
+    void setAspectRatioMode(Qt::AspectRatioMode mode);
+
+    void repaint();
+
+    int brightness() const;
+    void setBrightness(int brightness);
+
+    int contrast() const;
+    void setContrast(int contrast);
+
+    int hue() const;
+    void setHue(int hue);
+
+    int saturation() const;
+    void setSaturation(int saturation);
+
+    QAbstractVideoSurface *surface() const;
+
+    GstElement *videoSink();
+
+private slots:
+    void surfaceFormatChanged();
+
+private:
+    void setScaledDisplayRect();
+
+    QX11VideoSurface *m_surface;
+    GstElement *m_videoSink;
+    Qt::AspectRatioMode m_aspectRatioMode;
+    QRect m_displayRect;
+    bool m_fullScreen;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideorenderer.cpp b/src/plugins/mediaservices/gstreamer/qgstreamervideorenderer.cpp
new file mode 100644
index 0000000..1f03990
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideorenderer.cpp
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamervideorenderer.h"
+#include "qvideosurfacegstsink.h"
+
+#include <QEvent>
+#include <QApplication>
+
+#include <gst/gst.h>
+
+
+QT_BEGIN_NAMESPACE
+
+QGstreamerVideoRenderer::QGstreamerVideoRenderer(QObject *parent)
+    :QVideoRendererControl(parent),m_videoSink(0)
+{
+}
+
+QGstreamerVideoRenderer::~QGstreamerVideoRenderer()
+{
+    if (m_videoSink)
+        gst_object_unref(GST_OBJECT(m_videoSink));
+}
+
+GstElement *QGstreamerVideoRenderer::videoSink()
+{
+    if (!m_videoSink) {
+        m_videoSink = reinterpret_cast<GstElement*>(QVideoSurfaceGstSink::createSink(m_surface));
+        gst_object_ref(GST_OBJECT(m_videoSink)); //Take ownership
+        gst_object_sink(GST_OBJECT(m_videoSink));
+    }
+
+    return m_videoSink;
+}
+
+
+QAbstractVideoSurface *QGstreamerVideoRenderer::surface() const
+{
+    return m_surface;
+}
+
+void QGstreamerVideoRenderer::setSurface(QAbstractVideoSurface *surface)
+{
+    m_surface = surface;
+}
+
+QT_END_NAMESPACE
+
+
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideorenderer.h b/src/plugins/mediaservices/gstreamer/qgstreamervideorenderer.h
new file mode 100644
index 0000000..ba3f806
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideorenderer.h
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERVIDEORENDERER_H
+#define QGSTREAMERVIDEORENDERER_H
+
+#include <QtMultimedia/qvideorenderercontrol.h>
+#include "qvideosurfacegstsink.h"
+
+#include "qgstreamervideorendererinterface.h"
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerVideoRenderer : public QVideoRendererControl, public QGstreamerVideoRendererInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QGstreamerVideoRendererInterface)
+public:
+    QGstreamerVideoRenderer(QObject *parent = 0);
+    virtual ~QGstreamerVideoRenderer();
+    
+    QAbstractVideoSurface *surface() const;
+    void setSurface(QAbstractVideoSurface *surface);
+
+    GstElement *videoSink();
+    void precessNewStream() {}
+
+private:    
+    GstElement *m_videoSink;
+    QAbstractVideoSurface *m_surface;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGSTREAMERVIDEORENDRER_H
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideorendererinterface.cpp b/src/plugins/mediaservices/gstreamer/qgstreamervideorendererinterface.cpp
new file mode 100644
index 0000000..886a064
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideorendererinterface.cpp
@@ -0,0 +1,52 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamervideorendererinterface.h"
+
+
+QT_BEGIN_NAMESPACE
+
+QGstreamerVideoRendererInterface::~QGstreamerVideoRendererInterface()
+{
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideorendererinterface.h b/src/plugins/mediaservices/gstreamer/qgstreamervideorendererinterface.h
new file mode 100644
index 0000000..c63a757
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideorendererinterface.h
@@ -0,0 +1,69 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERVIDEOOUTPUTCONTROL_H
+#define QGSTREAMERVIDEOOUTPUTCONTROL_H
+
+#include <gst/gst.h>
+
+#include <QtCore/qobject.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerVideoRendererInterface
+{
+public:
+    virtual ~QGstreamerVideoRendererInterface();
+    virtual GstElement *videoSink() = 0;
+    virtual void precessNewStream() {}
+};
+
+#define QGstreamerVideoRendererInterface_iid "com.nokia.Qt.QGstreamerVideoRendererInterface/1.0"
+Q_DECLARE_INTERFACE(QGstreamerVideoRendererInterface, QGstreamerVideoRendererInterface_iid)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideowidget.cpp b/src/plugins/mediaservices/gstreamer/qgstreamervideowidget.cpp
new file mode 100644
index 0000000..763f7f1
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideowidget.cpp
@@ -0,0 +1,340 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstreamervideowidget.h"
+
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qdebug.h>
+#include <QtGui/qapplication.h>
+#include <QtGui/qpainter.h>
+
+#include <X11/Xlib.h>
+#include <gst/gst.h>
+#include <gst/interfaces/xoverlay.h>
+#include <gst/interfaces/propertyprobe.h>
+
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerVideoWidget : public QWidget
+{
+public:
+    QGstreamerVideoWidget(QWidget *parent = 0)
+        :QWidget(parent)
+    {
+        setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
+        QPalette palette;
+        palette.setColor(QPalette::Background, Qt::black);
+        setPalette(palette);
+    }
+
+    virtual ~QGstreamerVideoWidget() {}
+
+    QSize sizeHint() const
+    {
+        return m_nativeSize;
+    }
+
+    void setNativeSize( const QSize &size)
+    {
+        if (size != m_nativeSize) {
+            m_nativeSize = size;
+            if (size.isEmpty())
+                setMinimumSize(0,0);
+            else
+                setMinimumSize(160,120);
+
+            updateGeometry();
+        }
+    }
+
+protected:
+    void paintEvent(QPaintEvent *)
+    {
+        QPainter painter(this);
+        painter.fillRect(rect(), palette().background());
+    }
+
+    QSize m_nativeSize;
+};
+
+QGstreamerVideoWidgetControl::QGstreamerVideoWidgetControl(QObject *parent)
+    : QVideoWidgetControl(parent)
+    , m_videoSink(0)
+    , m_widget(0)
+    , m_fullScreen(false)
+{    
+}
+
+QGstreamerVideoWidgetControl::~QGstreamerVideoWidgetControl()
+{
+    if (m_videoSink)
+        gst_object_unref(GST_OBJECT(m_videoSink));
+
+    delete m_widget;
+}
+
+void QGstreamerVideoWidgetControl::createVideoWidget()
+{
+    if (m_widget)
+        return;
+
+    m_widget = new QGstreamerVideoWidget;
+
+    m_widget->installEventFilter(this);
+    m_windowId = m_widget->winId();
+
+    m_videoSink = gst_element_factory_make ("xvimagesink", NULL);
+    if (m_videoSink) {
+        // Check if the xv sink is usable
+        if (gst_element_set_state(m_videoSink, GST_STATE_READY) != GST_STATE_CHANGE_SUCCESS) {
+            gst_object_unref(GST_OBJECT(m_videoSink));
+            m_videoSink = 0;
+        } else {
+            gst_element_set_state(m_videoSink, GST_STATE_NULL);
+
+            g_object_set(G_OBJECT(m_videoSink), "force-aspect-ratio", 1, (const char*)NULL);
+        }
+    }
+
+    if (!m_videoSink)
+        m_videoSink = gst_element_factory_make ("ximagesink", NULL);
+
+    gst_object_ref (GST_OBJECT (m_videoSink)); //Take ownership
+    gst_object_sink (GST_OBJECT (m_videoSink));
+}
+
+GstElement *QGstreamerVideoWidgetControl::videoSink()
+{
+    createVideoWidget();
+    return m_videoSink;
+}
+
+bool QGstreamerVideoWidgetControl::eventFilter(QObject *object, QEvent *e)
+{
+    if (m_widget && object == m_widget) {
+        if (e->type() == QEvent::ParentChange || e->type() == QEvent::Show) {
+            WId newWId = m_widget->winId();
+            if (newWId != m_windowId) {
+                m_windowId = newWId;
+                // Even if we have created a winId at this point, other X applications
+                // need to be aware of it.
+                QApplication::syncX();
+                setOverlay();
+            }
+        }
+
+        if (e->type() == QEvent::Show) {
+            // Setting these values ensures smooth resizing since it
+            // will prevent the system from clearing the background
+            m_widget->setAttribute(Qt::WA_NoSystemBackground, true);
+            m_widget->setAttribute(Qt::WA_PaintOnScreen, true);
+        } else if (e->type() == QEvent::Resize) {
+            // This is a workaround for missing background repaints
+            // when reducing window size
+            windowExposed();
+        }
+    }
+
+    return false;
+}
+
+void QGstreamerVideoWidgetControl::precessNewStream()
+{
+    setOverlay();
+    QMetaObject::invokeMethod(this, "updateNativeVideoSize", Qt::QueuedConnection);
+}
+
+void QGstreamerVideoWidgetControl::setOverlay()
+{
+    if (m_videoSink && GST_IS_X_OVERLAY(m_videoSink)) {
+        gst_x_overlay_set_xwindow_id(GST_X_OVERLAY(m_videoSink), m_windowId);
+    }
+}
+
+void QGstreamerVideoWidgetControl::updateNativeVideoSize()
+{
+    if (m_videoSink) {
+        //find video native size to update video widget size hint
+        GstPad *pad = gst_element_get_static_pad(m_videoSink,"sink");
+        GstCaps *caps = gst_pad_get_negotiated_caps(pad);
+
+        if (caps) {
+            GstStructure *str;
+            gint width, height;
+
+            if ((str = gst_caps_get_structure (caps, 0))) {
+                if (gst_structure_get_int (str, "width", &width) && gst_structure_get_int (str, "height", &height)) {
+                    gint aspectNum = 0;
+                    gint aspectDenum = 0;
+                    if (gst_structure_get_fraction(str, "pixel-aspect-ratio", &aspectNum, &aspectDenum)) {
+                        if (aspectDenum > 0)
+                            width = width*aspectNum/aspectDenum;
+                    }
+                    m_widget->setNativeSize(QSize(width, height));
+                }
+            }
+            gst_caps_unref(caps);
+        }
+    } else {
+        if (m_widget)
+            m_widget->setNativeSize(QSize());
+    }
+}
+
+
+void QGstreamerVideoWidgetControl::windowExposed()
+{
+    if (m_videoSink && GST_IS_X_OVERLAY(m_videoSink))
+        gst_x_overlay_expose(GST_X_OVERLAY(m_videoSink));
+}
+
+QWidget *QGstreamerVideoWidgetControl::videoWidget()
+{
+    createVideoWidget();
+    return m_widget;
+}
+
+Qt::AspectRatioMode QGstreamerVideoWidgetControl::aspectRatioMode() const
+{
+    return m_aspectRatioMode;
+}
+
+void QGstreamerVideoWidgetControl::setAspectRatioMode(Qt::AspectRatioMode mode)
+{
+    if (m_videoSink) {
+        g_object_set(G_OBJECT(m_videoSink),
+                     "force-aspect-ratio",
+                     (mode == Qt::KeepAspectRatio),
+                     (const char*)NULL);
+    }
+
+    m_aspectRatioMode = mode;
+}
+
+bool QGstreamerVideoWidgetControl::isFullScreen() const
+{
+    return m_fullScreen;
+}
+
+void QGstreamerVideoWidgetControl::setFullScreen(bool fullScreen)
+{
+    emit fullScreenChanged(m_fullScreen =  fullScreen);
+}
+
+int QGstreamerVideoWidgetControl::brightness() const
+{
+    int brightness = 0;
+
+    if (m_videoSink && g_object_class_find_property(G_OBJECT_GET_CLASS(m_videoSink), "brightness"))
+        g_object_get(G_OBJECT(m_videoSink), "brightness", &brightness, NULL);
+
+    return brightness / 10;
+}
+
+void QGstreamerVideoWidgetControl::setBrightness(int brightness)
+{
+    if (m_videoSink && g_object_class_find_property(G_OBJECT_GET_CLASS(m_videoSink), "brightness")) {
+        g_object_set(G_OBJECT(m_videoSink), "brightness", brightness * 10, NULL);
+
+        emit brightnessChanged(brightness);
+    }
+}
+
+int QGstreamerVideoWidgetControl::contrast() const
+{
+    int contrast = 0;
+
+    if (m_videoSink && g_object_class_find_property(G_OBJECT_GET_CLASS(m_videoSink), "contrast"))
+        g_object_get(G_OBJECT(m_videoSink), "contrast", &contrast, NULL);
+
+    return contrast / 10;
+}
+
+void QGstreamerVideoWidgetControl::setContrast(int contrast)
+{
+    if (m_videoSink && g_object_class_find_property(G_OBJECT_GET_CLASS(m_videoSink), "contrast")) {
+        g_object_set(G_OBJECT(m_videoSink), "contrast", contrast * 10, NULL);
+
+        emit contrastChanged(contrast);
+    }
+}
+
+int QGstreamerVideoWidgetControl::hue() const
+{
+    int hue = 0;
+
+    if (m_videoSink && g_object_class_find_property(G_OBJECT_GET_CLASS(m_videoSink), "hue"))
+        g_object_get(G_OBJECT(m_videoSink), "hue", &hue, NULL);
+
+    return hue / 10;
+}
+
+void QGstreamerVideoWidgetControl::setHue(int hue)
+{
+    if (m_videoSink && g_object_class_find_property(G_OBJECT_GET_CLASS(m_videoSink), "hue")) {
+        g_object_set(G_OBJECT(m_videoSink), "hue", hue * 10, NULL);
+
+        emit hueChanged(hue);
+    }
+}
+
+int QGstreamerVideoWidgetControl::saturation() const
+{
+    int saturation = 0;
+
+    if (m_videoSink && g_object_class_find_property(G_OBJECT_GET_CLASS(m_videoSink), "saturation"))
+        g_object_get(G_OBJECT(m_videoSink), "saturation", &saturation, NULL);
+
+    return saturation / 10;
+}
+
+void QGstreamerVideoWidgetControl::setSaturation(int saturation)
+{
+    if (m_videoSink && g_object_class_find_property(G_OBJECT_GET_CLASS(m_videoSink), "saturation")) {
+        g_object_set(G_OBJECT(m_videoSink), "saturation", saturation * 10, NULL);
+
+        emit saturationChanged(saturation);
+    }
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/qgstreamervideowidget.h b/src/plugins/mediaservices/gstreamer/qgstreamervideowidget.h
new file mode 100644
index 0000000..28b48af
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstreamervideowidget.h
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTREAMERVIDEOWIDGET_H
+#define QGSTREAMERVIDEOWIDGET_H
+
+#include <QtMultimedia/qvideowidgetcontrol.h>
+
+#include "qgstreamervideorendererinterface.h"
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstreamerVideoWidget;
+
+class QGstreamerVideoWidgetControl
+        : public QVideoWidgetControl
+        , public QGstreamerVideoRendererInterface
+{
+    Q_OBJECT
+    Q_INTERFACES(QGstreamerVideoRendererInterface)
+public:
+    QGstreamerVideoWidgetControl(QObject *parent = 0);
+    virtual ~QGstreamerVideoWidgetControl();
+
+    GstElement *videoSink();
+    void precessNewStream();
+
+    QWidget *videoWidget();
+
+    Qt::AspectRatioMode aspectRatioMode() const;
+    void setAspectRatioMode(Qt::AspectRatioMode mode);
+
+    bool isFullScreen() const;
+    void setFullScreen(bool fullScreen);
+
+    int brightness() const;
+    void setBrightness(int brightness);
+
+    int contrast() const;
+    void setContrast(int contrast);
+
+    int hue() const;
+    void setHue(int hue);
+
+    int saturation() const;
+    void setSaturation(int saturation);
+
+    void setOverlay();
+
+    bool eventFilter(QObject *object, QEvent *event);
+
+public slots:
+    void updateNativeVideoSize();
+
+private:
+    void createVideoWidget();
+    void windowExposed();
+
+    GstElement *m_videoSink;
+    QGstreamerVideoWidget *m_widget;
+    WId m_windowId;
+    Qt::AspectRatioMode m_aspectRatioMode;
+    bool m_fullScreen;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGSTREAMERVIDEOWIDGET_H
diff --git a/src/plugins/mediaservices/gstreamer/qgstvideobuffer.cpp b/src/plugins/mediaservices/gstreamer/qgstvideobuffer.cpp
new file mode 100644
index 0000000..76289bf
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstvideobuffer.cpp
@@ -0,0 +1,101 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgstvideobuffer.h"
+
+
+QT_BEGIN_NAMESPACE
+
+QGstVideoBuffer::QGstVideoBuffer(GstBuffer *buffer, int bytesPerLine)
+    : QAbstractVideoBuffer(NoHandle)
+    , m_buffer(buffer)
+    , m_bytesPerLine(bytesPerLine)
+    , m_mode(NotMapped)
+{
+    gst_buffer_ref(m_buffer);
+}
+
+QGstVideoBuffer::QGstVideoBuffer(GstBuffer *buffer, int bytesPerLine,
+                QGstVideoBuffer::HandleType handleType,
+                const QVariant &handle)
+    : QAbstractVideoBuffer(handleType)
+    , m_buffer(buffer)
+    , m_bytesPerLine(bytesPerLine)
+    , m_mode(NotMapped)
+    , m_handle(handle)
+{
+    gst_buffer_ref(m_buffer);
+}
+
+QGstVideoBuffer::~QGstVideoBuffer()
+{
+    gst_buffer_unref(m_buffer);
+}
+
+
+QAbstractVideoBuffer::MapMode QGstVideoBuffer::mapMode() const
+{
+    return m_mode;
+}
+
+uchar *QGstVideoBuffer::map(MapMode mode, int *numBytes, int *bytesPerLine)
+{
+    if (mode != NotMapped && m_mode == NotMapped) {
+        if (numBytes)
+            *numBytes = m_buffer->size;
+
+        if (bytesPerLine)
+            *bytesPerLine = m_bytesPerLine;
+
+        m_mode = mode;
+
+        return m_buffer->data;
+    } else {
+        return 0;
+    }
+}
+void QGstVideoBuffer::unmap()
+{
+    m_mode = NotMapped;
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/qgstvideobuffer.h b/src/plugins/mediaservices/gstreamer/qgstvideobuffer.h
new file mode 100644
index 0000000..5133e2e
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstvideobuffer.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTVIDEOBUFFER_H
+#define QGSTVIDEOBUFFER_H
+
+#include <QtMultimedia/QAbstractVideoBuffer>
+#include <QtCore/qvariant.h>
+
+#include <gst/gst.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstVideoBuffer : public QAbstractVideoBuffer
+{
+public:
+    QGstVideoBuffer(GstBuffer *buffer, int bytesPerLine);
+    QGstVideoBuffer(GstBuffer *buffer, int bytesPerLine,
+                    HandleType handleType, const QVariant &handle);
+    ~QGstVideoBuffer();
+
+    MapMode mapMode() const;
+
+    uchar *map(MapMode mode, int *numBytes, int *bytesPerLine);
+    void unmap();
+
+    QVariant handle() const { return m_handle; }
+private:
+    GstBuffer *m_buffer;
+    int m_bytesPerLine;
+    MapMode m_mode;
+    QVariant m_handle;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/qgstxvimagebuffer.cpp b/src/plugins/mediaservices/gstreamer/qgstxvimagebuffer.cpp
new file mode 100644
index 0000000..b2e633d
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstxvimagebuffer.cpp
@@ -0,0 +1,282 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qdebug.h>
+#include <QtCore/qthread.h>
+#include <QtCore/qvariant.h>
+#include <QtGui/qx11info_x11.h>
+
+#include "qgstxvimagebuffer.h"
+#include "qvideosurfacegstsink.h"
+
+
+QT_BEGIN_NAMESPACE
+
+GstBufferClass *QGstXvImageBuffer::parent_class = NULL;
+
+GType QGstXvImageBuffer::get_type(void)
+{
+    static GType buffer_type = 0;
+
+    if (buffer_type == 0) {
+        static const GTypeInfo buffer_info = {
+            sizeof (GstBufferClass),
+            NULL,
+            NULL,
+            QGstXvImageBuffer::class_init,
+            NULL,
+            NULL,
+            sizeof(QGstXvImageBuffer),
+            0,
+            (GInstanceInitFunc)QGstXvImageBuffer::buffer_init,
+            NULL
+        };
+        buffer_type = g_type_register_static(GST_TYPE_BUFFER,
+                                             "QGstXvImageBuffer", &buffer_info, GTypeFlags(0));
+    }
+    return buffer_type;
+}
+
+void QGstXvImageBuffer::class_init(gpointer g_class, gpointer class_data)
+{
+    Q_UNUSED(class_data);
+    GST_MINI_OBJECT_CLASS(g_class)->finalize =
+            (GstMiniObjectFinalizeFunction)buffer_finalize;
+    parent_class = (GstBufferClass*)g_type_class_peek_parent(g_class);
+}
+
+void QGstXvImageBuffer::buffer_init(QGstXvImageBuffer *xvImage, gpointer g_class)
+{
+    Q_UNUSED(g_class);
+    xvImage->pool = 0;
+    xvImage->shmInfo.shmaddr = ((char *) -1);
+    xvImage->shmInfo.shmid = -1;
+    xvImage->markedForDeletion = false;
+}
+
+void QGstXvImageBuffer::buffer_finalize(QGstXvImageBuffer * xvImage)
+{
+    if (xvImage->pool) {
+        if (xvImage->markedForDeletion)
+            xvImage->pool->destroyBuffer(xvImage);
+        else
+            xvImage->pool->recycleBuffer(xvImage);
+    }
+}
+
+
+QGstXvImageBufferPool::QGstXvImageBufferPool(QObject *parent)
+    :QObject(parent)
+{
+}
+
+QGstXvImageBufferPool::~QGstXvImageBufferPool()
+{
+}
+
+bool QGstXvImageBufferPool::isFormatSupported(const QVideoSurfaceFormat &surfaceFormat)
+{
+    bool ok = true;
+    surfaceFormat.property("portId").toULongLong(&ok);
+    if (!ok)
+        return false;
+
+    int xvFormatId = surfaceFormat.property("xvFormatId").toInt(&ok);
+    if (!ok || xvFormatId < 0)
+        return false;
+
+    int dataSize = surfaceFormat.property("dataSize").toInt(&ok);
+    if (!ok || dataSize<=0)
+        return false;
+
+    return true;
+}
+
+QGstXvImageBuffer *QGstXvImageBufferPool::takeBuffer(const QVideoSurfaceFormat &format, GstCaps *caps)
+{
+    m_poolMutex.lock();
+
+    m_caps = caps;
+    if (format != m_format) {
+        doClear();
+        m_format = format;
+    }
+
+
+    if (m_pool.isEmpty()) {
+        //qDebug() << "QGstXvImageBufferPool::takeBuffer: no buffer available, allocate the new one";
+        if (QThread::currentThread() == thread()) {
+            m_poolMutex.unlock();
+            queuedAlloc();
+            m_poolMutex.lock();
+        } else {
+            QMetaObject::invokeMethod(this, "queuedAlloc", Qt::QueuedConnection);
+            m_allocWaitCondition.wait(&m_poolMutex, 300);
+        }
+    }
+    QGstXvImageBuffer *res = 0;
+
+    if (!m_pool.isEmpty()) {
+        res = m_pool.takeLast();
+    }
+
+    m_poolMutex.unlock();
+
+    return res;
+}
+
+void QGstXvImageBufferPool::queuedAlloc()
+{
+    QMutexLocker lock(&m_poolMutex);
+
+    Q_ASSERT(QThread::currentThread() == thread());
+
+    QGstXvImageBuffer *xvBuffer = (QGstXvImageBuffer *)gst_mini_object_new(QGstXvImageBuffer::get_type());
+
+    quint64 portId = m_format.property("portId").toULongLong();
+    int xvFormatId = m_format.property("xvFormatId").toInt();
+
+    xvBuffer->xvImage = XvShmCreateImage(
+            QX11Info::display(),
+            portId,
+            xvFormatId,
+            0,
+            m_format.frameWidth(),
+            m_format.frameHeight(),
+            &xvBuffer->shmInfo
+            );
+
+    if (!xvBuffer->xvImage) {
+//        qDebug() << "QGstXvImageBufferPool: XvShmCreateImage failed";
+        m_allocWaitCondition.wakeOne();
+        return;
+    }
+
+    xvBuffer->shmInfo.shmid = shmget(IPC_PRIVATE, xvBuffer->xvImage->data_size, IPC_CREAT | 0777);
+    xvBuffer->shmInfo.shmaddr = xvBuffer->xvImage->data = (char*)shmat(xvBuffer->shmInfo.shmid, 0, 0);
+    xvBuffer->shmInfo.readOnly = False;
+
+    if (!XShmAttach(QX11Info::display(), &xvBuffer->shmInfo)) {
+//        qDebug() << "QGstXvImageBufferPool: XShmAttach failed";
+        m_allocWaitCondition.wakeOne();
+        return;
+    }
+
+    shmctl (xvBuffer->shmInfo.shmid, IPC_RMID, NULL);
+
+    xvBuffer->pool = this;
+    GST_MINI_OBJECT_CAST(xvBuffer)->flags = 0;
+    gst_buffer_set_caps(GST_BUFFER_CAST(xvBuffer), m_caps);
+    GST_BUFFER_DATA(xvBuffer) = (uchar*)xvBuffer->xvImage->data;
+    GST_BUFFER_SIZE(xvBuffer) = xvBuffer->xvImage->data_size;
+
+    m_allBuffers.append(xvBuffer);
+    m_pool.append(xvBuffer);
+
+    m_allocWaitCondition.wakeOne();
+}
+
+
+void QGstXvImageBufferPool::clear()
+{
+    QMutexLocker lock(&m_poolMutex);
+    doClear();
+}
+
+void QGstXvImageBufferPool::doClear()
+{
+    foreach (QGstXvImageBuffer *xvBuffer, m_allBuffers) {
+        xvBuffer->markedForDeletion = true;
+    }
+    m_allBuffers.clear();
+
+    foreach (QGstXvImageBuffer *xvBuffer, m_pool) {
+        gst_buffer_unref(GST_BUFFER(xvBuffer));
+    }
+    m_pool.clear();
+
+    m_format = QVideoSurfaceFormat();
+}
+
+void QGstXvImageBufferPool::queuedDestroy()
+{
+    QMutexLocker lock(&m_destroyMutex);
+
+    foreach(XvShmImage xvImage, m_imagesToDestroy) {
+        if (xvImage.shmInfo.shmaddr != ((void *) -1)) {
+            XShmDetach(QX11Info::display(), &xvImage.shmInfo);
+            XSync(QX11Info::display(), false);
+
+            shmdt(xvImage.shmInfo.shmaddr);
+        }
+
+        if (xvImage.xvImage)
+            XFree(xvImage.xvImage);
+    }
+
+    m_imagesToDestroy.clear();
+
+    XSync(QX11Info::display(), false);
+}
+
+void QGstXvImageBufferPool::recycleBuffer(QGstXvImageBuffer *xvBuffer)
+{
+    QMutexLocker lock(&m_poolMutex);
+    gst_buffer_ref(GST_BUFFER_CAST(xvBuffer));
+    m_pool.append(xvBuffer);
+}
+
+void QGstXvImageBufferPool::destroyBuffer(QGstXvImageBuffer *xvBuffer)
+{
+    XvShmImage imageToDestroy;
+    imageToDestroy.xvImage = xvBuffer->xvImage;
+    imageToDestroy.shmInfo = xvBuffer->shmInfo;
+
+    m_destroyMutex.lock();
+    m_imagesToDestroy.append(imageToDestroy);
+    m_destroyMutex.unlock();
+
+    if (m_imagesToDestroy.size() == 1)
+        QMetaObject::invokeMethod(this, "queuedDestroy", Qt::QueuedConnection);
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/gstreamer/qgstxvimagebuffer.h b/src/plugins/mediaservices/gstreamer/qgstxvimagebuffer.h
new file mode 100644
index 0000000..30f77d1
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qgstxvimagebuffer.h
@@ -0,0 +1,131 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGSTXVIMAGEBUFFER_H
+#define QGSTXVIMAGEBUFFER_H
+
+#include <QtMultimedia/qabstractvideobuffer.h>
+#include <QtMultimedia/qvideosurfaceformat.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qwaitcondition.h>
+#include <QtCore/qqueue.h>
+
+#include <X11/Xlib.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <X11/extensions/XShm.h>
+#include <X11/Xlib.h>
+#include <X11/extensions/Xv.h>
+#include <X11/extensions/Xvlib.h>
+
+#include <gst/gst.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QGstXvImageBufferPool;
+
+struct QGstXvImageBuffer {
+    GstBuffer buffer;
+    QGstXvImageBufferPool *pool;
+    XvImage *xvImage;
+    XShmSegmentInfo shmInfo;
+    bool markedForDeletion;
+
+    static GType get_type(void);
+    static void class_init(gpointer g_class, gpointer class_data);
+    static void buffer_init(QGstXvImageBuffer *xvimage, gpointer g_class);
+    static void buffer_finalize(QGstXvImageBuffer * xvimage);
+    static GstBufferClass *parent_class;
+};
+
+const QAbstractVideoBuffer::HandleType XvHandleType = QAbstractVideoBuffer::HandleType(4);
+
+
+
+class QGstXvImageBufferPool : public QObject {
+Q_OBJECT
+friend class QGstXvImageBuffer;
+public:
+    QGstXvImageBufferPool(QObject *parent = 0);
+    virtual ~QGstXvImageBufferPool();
+
+    bool isFormatSupported(const QVideoSurfaceFormat &format);
+
+    QGstXvImageBuffer *takeBuffer(const QVideoSurfaceFormat &format, GstCaps *caps);
+    void clear();
+
+private slots:
+    void queuedAlloc();
+    void queuedDestroy();
+
+    void doClear();
+
+    void recycleBuffer(QGstXvImageBuffer *);
+    void destroyBuffer(QGstXvImageBuffer *);
+
+private:
+    struct XvShmImage {
+        XvImage *xvImage;
+        XShmSegmentInfo shmInfo;
+    };
+
+    QMutex m_poolMutex;
+    QMutex m_allocMutex;
+    QWaitCondition m_allocWaitCondition;
+    QMutex m_destroyMutex;
+    QVideoSurfaceFormat m_format;
+    GstCaps *m_caps;
+    QList<QGstXvImageBuffer*> m_pool;
+    QList<QGstXvImageBuffer*> m_allBuffers;
+    QList<XvShmImage> m_imagesToDestroy;
+};
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(::XvImage*)
+
+QT_END_HEADER
+
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/qvideosurfacegstsink.cpp b/src/plugins/mediaservices/gstreamer/qvideosurfacegstsink.cpp
new file mode 100644
index 0000000..76d87ce
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qvideosurfacegstsink.cpp
@@ -0,0 +1,699 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtMultimedia/QAbstractVideoSurface>
+#include <QtMultimedia/QVideoFrame>
+#include <QtCore/qdebug.h>
+#include <QMap>
+#include <QThread>
+#include <QtGui/qx11info_x11.h>
+
+#include "qvideosurfacegstsink.h"
+
+#include "qgstvideobuffer.h"
+#include "qgstxvimagebuffer.h"
+
+
+
+Q_DECLARE_METATYPE(QVideoSurfaceFormat)
+
+QT_BEGIN_NAMESPACE
+
+QVideoSurfaceGstDelegate::QVideoSurfaceGstDelegate(QAbstractVideoSurface *surface)
+    : m_surface(surface)
+    , m_renderReturn(GST_FLOW_ERROR)
+    , m_bytesPerLine(0)
+{
+    m_supportedPixelFormats = m_surface->supportedPixelFormats();
+
+    connect(m_surface, SIGNAL(supportedFormatsChanged()), this, SLOT(supportedFormatsChanged()));
+}
+
+QList<QVideoFrame::PixelFormat> QVideoSurfaceGstDelegate::supportedPixelFormats(QAbstractVideoBuffer::HandleType handleType) const
+{
+    QMutexLocker locker(const_cast<QMutex *>(&m_mutex));
+
+    if (handleType == QAbstractVideoBuffer::NoHandle)
+        return m_supportedPixelFormats;
+    else
+        return m_surface->supportedPixelFormats(handleType);
+}
+
+QVideoSurfaceFormat QVideoSurfaceGstDelegate::surfaceFormat() const
+{
+    QMutexLocker locker(const_cast<QMutex *>(&m_mutex));
+    return m_format;
+}
+
+bool QVideoSurfaceGstDelegate::start(const QVideoSurfaceFormat &format, int bytesPerLine)
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_format = format;
+    m_bytesPerLine = bytesPerLine;
+
+    if (QThread::currentThread() == thread()) {
+        m_started = !m_surface.isNull() ? m_surface->start(m_format) : false;
+    } else {
+        QMetaObject::invokeMethod(this, "queuedStart", Qt::QueuedConnection);
+
+        m_setupCondition.wait(&m_mutex);
+    }
+
+    m_format = m_surface->surfaceFormat();
+
+    return m_started;
+}
+
+void QVideoSurfaceGstDelegate::stop()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (QThread::currentThread() == thread()) {
+        if (!m_surface.isNull())
+            m_surface->stop();
+    } else {
+        QMetaObject::invokeMethod(this, "queuedStop", Qt::QueuedConnection);
+
+        m_setupCondition.wait(&m_mutex);
+    }
+
+    m_started = false;
+}
+
+bool QVideoSurfaceGstDelegate::isActive()
+{
+    QMutexLocker locker(&m_mutex);
+    return m_surface->isActive();
+}
+
+GstFlowReturn QVideoSurfaceGstDelegate::render(GstBuffer *buffer)
+{
+    QMutexLocker locker(&m_mutex);
+
+    QGstVideoBuffer *videoBuffer = 0;
+
+    if (G_TYPE_CHECK_INSTANCE_TYPE(buffer, QGstXvImageBuffer::get_type())) {
+        QGstXvImageBuffer *xvBuffer = reinterpret_cast<QGstXvImageBuffer *>(buffer);
+        QVariant handle = QVariant::fromValue(xvBuffer->xvImage);
+        videoBuffer = new QGstVideoBuffer(buffer, m_bytesPerLine, XvHandleType, handle);
+    } else
+        videoBuffer = new QGstVideoBuffer(buffer, m_bytesPerLine);
+
+    m_frame = QVideoFrame(
+            videoBuffer,
+            m_format.frameSize(),
+            m_format.pixelFormat());
+
+    qint64 startTime = GST_BUFFER_TIMESTAMP(buffer);
+
+    if (startTime >= 0) {
+        m_frame.setStartTime(startTime/G_GINT64_CONSTANT (1000000));
+
+        qint64 duration = GST_BUFFER_DURATION(buffer);
+
+        if (duration >= 0)
+            m_frame.setEndTime((startTime + duration)/G_GINT64_CONSTANT (1000000));
+    }
+
+    QMetaObject::invokeMethod(this, "queuedRender", Qt::QueuedConnection);
+
+    if (!m_renderCondition.wait(&m_mutex, 300)) {
+        m_frame = QVideoFrame();
+
+        return GST_FLOW_OK;
+    } else {
+        return m_renderReturn;
+    }
+}
+
+void QVideoSurfaceGstDelegate::queuedStart()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_started = m_surface->start(m_format);
+
+    m_setupCondition.wakeAll();
+}
+
+void QVideoSurfaceGstDelegate::queuedStop()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_surface->stop();
+
+    m_setupCondition.wakeAll();
+}
+
+void QVideoSurfaceGstDelegate::queuedRender()
+{
+    QMutexLocker locker(&m_mutex);
+
+    if (m_surface.isNull()) {
+        m_renderReturn = GST_FLOW_ERROR;
+    } else if (m_surface->present(m_frame)) {
+        m_renderReturn = GST_FLOW_OK;
+    } else {
+        switch (m_surface->error()) {
+        case QAbstractVideoSurface::NoError:
+            m_renderReturn = GST_FLOW_OK;
+            break;
+        case QAbstractVideoSurface::StoppedError:
+            m_renderReturn = GST_FLOW_NOT_NEGOTIATED;
+            break;
+        default:
+            m_renderReturn = GST_FLOW_ERROR;
+            break;
+        }
+    }
+
+    m_renderCondition.wakeAll();
+}
+
+void QVideoSurfaceGstDelegate::supportedFormatsChanged()
+{
+    QMutexLocker locker(&m_mutex);
+
+    m_supportedPixelFormats = m_surface->supportedPixelFormats();
+}
+
+struct YuvFormat
+{
+    QVideoFrame::PixelFormat pixelFormat;
+    guint32 fourcc;
+    int bitsPerPixel;
+};
+
+static const YuvFormat qt_yuvColorLookup[] =
+{
+    { QVideoFrame::Format_YUV420P, GST_MAKE_FOURCC('I','4','2','0'), 8 },
+    { QVideoFrame::Format_YV12,    GST_MAKE_FOURCC('Y','V','1','2'), 8 },
+    { QVideoFrame::Format_UYVY,    GST_MAKE_FOURCC('U','Y','V','Y'), 16 },
+    { QVideoFrame::Format_YUYV,    GST_MAKE_FOURCC('Y','U','Y','2'), 16 },
+    { QVideoFrame::Format_NV12,    GST_MAKE_FOURCC('N','V','1','2'), 8 },
+    { QVideoFrame::Format_NV21,    GST_MAKE_FOURCC('N','V','2','1'), 8 },
+    { QVideoFrame::Format_AYUV444, GST_MAKE_FOURCC('A','Y','U','V'), 32 }
+};
+
+static int indexOfYuvColor(QVideoFrame::PixelFormat format)
+{
+    const int count = sizeof(qt_yuvColorLookup) / sizeof(YuvFormat);
+
+    for (int i = 0; i < count; ++i)
+        if (qt_yuvColorLookup[i].pixelFormat == format)
+            return i;
+
+    return -1;
+}
+
+static int indexOfYuvColor(guint32 fourcc)
+{
+    const int count = sizeof(qt_yuvColorLookup) / sizeof(YuvFormat);
+
+    for (int i = 0; i < count; ++i)
+        if (qt_yuvColorLookup[i].fourcc == fourcc)
+            return i;
+
+    return -1;
+}
+
+struct RgbFormat
+{
+    QVideoFrame::PixelFormat pixelFormat;
+    int bitsPerPixel;
+    int depth;
+    int endianness;
+    int red;
+    int green;
+    int blue;
+    int alpha;
+};
+
+static const RgbFormat qt_rgbColorLookup[] =
+{
+    { QVideoFrame::Format_RGB32 , 32, 24, 4321, 0x0000FF00, 0x00FF0000, 0xFF000000, 0x00000000 },
+    { QVideoFrame::Format_RGB32 , 32, 24, 1234, 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 },
+    { QVideoFrame::Format_BGR32 , 32, 24, 4321, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x00000000 },
+    { QVideoFrame::Format_BGR32 , 32, 24, 1234, 0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000 },
+    { QVideoFrame::Format_ARGB32, 32, 24, 4321, 0x0000FF00, 0x00FF0000, 0xFF000000, 0x000000FF },
+    { QVideoFrame::Format_ARGB32, 32, 24, 1234, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xFF000000 },
+    { QVideoFrame::Format_RGB24 , 24, 24, 4321, 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00000000 },
+    { QVideoFrame::Format_BGR24 , 24, 24, 4321, 0x000000FF, 0x0000FF00, 0x00FF0000, 0x00000000 },
+    { QVideoFrame::Format_RGB565, 16, 16, 1234, 0x0000F800, 0x000007E0, 0x0000001F, 0x00000000 }
+};
+
+static int indexOfRgbColor(
+        int bits, int depth, int endianness, int red, int green, int blue, int alpha)
+{
+    const int count = sizeof(qt_rgbColorLookup) / sizeof(RgbFormat);
+
+    for (int i = 0; i < count; ++i) {
+        if (qt_rgbColorLookup[i].bitsPerPixel == bits
+            && qt_rgbColorLookup[i].depth == depth
+            && qt_rgbColorLookup[i].endianness == endianness
+            && qt_rgbColorLookup[i].red == red
+            && qt_rgbColorLookup[i].green == green
+            && qt_rgbColorLookup[i].blue == blue
+            && qt_rgbColorLookup[i].alpha == alpha) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+static GstVideoSinkClass *sink_parent_class;
+
+#define VO_SINK(s) QVideoSurfaceGstSink *sink(reinterpret_cast<QVideoSurfaceGstSink *>(s))
+
+QVideoSurfaceGstSink *QVideoSurfaceGstSink::createSink(QAbstractVideoSurface *surface)
+{
+    QVideoSurfaceGstSink *sink = reinterpret_cast<QVideoSurfaceGstSink *>(
+            g_object_new(QVideoSurfaceGstSink::get_type(), 0));
+
+    sink->delegate = new QVideoSurfaceGstDelegate(surface);
+
+    return sink;
+}
+
+GType QVideoSurfaceGstSink::get_type()
+{
+    static GType type = 0;
+
+    if (type == 0) {
+        static const GTypeInfo info =
+        {
+            sizeof(QVideoSurfaceGstSinkClass),                    // class_size
+            base_init,                                         // base_init
+            NULL,                                              // base_finalize
+            class_init,                                        // class_init
+            NULL,                                              // class_finalize
+            NULL,                                              // class_data
+            sizeof(QVideoSurfaceGstSink),                         // instance_size
+            0,                                                 // n_preallocs
+            instance_init,                                     // instance_init
+            0                                                  // value_table
+        };
+
+        type = g_type_register_static(
+                GST_TYPE_VIDEO_SINK, "QVideoSurfaceGstSink", &info, GTypeFlags(0));
+    }
+
+    return type;
+}
+
+void QVideoSurfaceGstSink::class_init(gpointer g_class, gpointer class_data)
+{
+    Q_UNUSED(class_data);
+
+    sink_parent_class = reinterpret_cast<GstVideoSinkClass *>(g_type_class_peek_parent(g_class));
+
+    GstBaseSinkClass *base_sink_class = reinterpret_cast<GstBaseSinkClass *>(g_class);
+    base_sink_class->get_caps = QVideoSurfaceGstSink::get_caps;
+    base_sink_class->set_caps = QVideoSurfaceGstSink::set_caps;
+    base_sink_class->buffer_alloc = QVideoSurfaceGstSink::buffer_alloc;
+    base_sink_class->start = QVideoSurfaceGstSink::start;
+    base_sink_class->stop = QVideoSurfaceGstSink::stop;
+    // base_sink_class->unlock = QVideoSurfaceGstSink::unlock; // Not implemented.
+    // base_sink_class->event = QVideoSurfaceGstSink::event; // Not implemented.
+    base_sink_class->preroll = QVideoSurfaceGstSink::preroll;
+    base_sink_class->render = QVideoSurfaceGstSink::render;
+
+    GstElementClass *element_class = reinterpret_cast<GstElementClass *>(g_class);
+    element_class->change_state = QVideoSurfaceGstSink::change_state;
+
+    GObjectClass *object_class = reinterpret_cast<GObjectClass *>(g_class);
+    object_class->finalize = QVideoSurfaceGstSink::finalize;
+}
+
+void QVideoSurfaceGstSink::base_init(gpointer g_class)
+{
+    static GstStaticPadTemplate sink_pad_template = GST_STATIC_PAD_TEMPLATE(
+            "sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_STATIC_CAPS(
+                    "video/x-raw-rgb, "
+                    "framerate = (fraction) [ 0, MAX ], "
+                    "width = (int) [ 1, MAX ], "
+                    "height = (int) [ 1, MAX ]; "
+                    "video/x-raw-yuv, "
+                    "framerate = (fraction) [ 0, MAX ], "
+                    "width = (int) [ 1, MAX ], "
+                    "height = (int) [ 1, MAX ]"));
+
+    gst_element_class_add_pad_template(
+            GST_ELEMENT_CLASS(g_class), gst_static_pad_template_get(&sink_pad_template));
+}
+
+void QVideoSurfaceGstSink::instance_init(GTypeInstance *instance, gpointer g_class)
+{
+    VO_SINK(instance);
+
+    Q_UNUSED(g_class);
+
+    sink->delegate = 0;
+    sink->pool = new QGstXvImageBufferPool();
+    sink->lastRequestedCaps = 0;
+    sink->lastBufferCaps = 0;
+    sink->lastSurfaceFormat = new QVideoSurfaceFormat;
+}
+
+void QVideoSurfaceGstSink::finalize(GObject *object)
+{
+    VO_SINK(object);
+    delete sink->pool;
+    sink->pool = 0;
+    delete sink->lastSurfaceFormat;
+    sink->lastSurfaceFormat = 0;
+
+    if (sink->lastBufferCaps)
+        gst_caps_unref(sink->lastBufferCaps);
+    sink->lastBufferCaps = 0;
+
+    if (sink->lastRequestedCaps)
+        gst_caps_unref(sink->lastRequestedCaps);
+    sink->lastRequestedCaps = 0;
+}
+
+GstStateChangeReturn QVideoSurfaceGstSink::change_state(
+        GstElement *element, GstStateChange transition)
+{
+    Q_UNUSED(element);
+
+    return GST_ELEMENT_CLASS(sink_parent_class)->change_state(
+            element, transition);
+}
+
+GstCaps *QVideoSurfaceGstSink::get_caps(GstBaseSink *base)
+{
+    VO_SINK(base);
+
+    GstCaps *caps = gst_caps_new_empty();
+
+    foreach (QVideoFrame::PixelFormat format, sink->delegate->supportedPixelFormats()) {
+        int index = indexOfYuvColor(format);
+
+        if (index != -1) {
+            gst_caps_append_structure(caps, gst_structure_new(
+                    "video/x-raw-yuv",
+                    "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, INT_MAX, 1,
+                    "width"    , GST_TYPE_INT_RANGE, 1, INT_MAX,
+                    "height"   , GST_TYPE_INT_RANGE, 1, INT_MAX,
+                    "format"   , GST_TYPE_FOURCC, qt_yuvColorLookup[index].fourcc,
+                    NULL));
+            continue;
+        }
+
+        const int count = sizeof(qt_rgbColorLookup) / sizeof(RgbFormat);
+
+        for (int i = 0; i < count; ++i) {
+            if (qt_rgbColorLookup[i].pixelFormat == format) {
+                GstStructure *structure = gst_structure_new(
+                        "video/x-raw-rgb",
+                        "framerate" , GST_TYPE_FRACTION_RANGE, 0, 1, INT_MAX, 1,
+                        "width"     , GST_TYPE_INT_RANGE, 1, INT_MAX,
+                        "height"    , GST_TYPE_INT_RANGE, 1, INT_MAX,
+                        "bpp"       , G_TYPE_INT, qt_rgbColorLookup[i].bitsPerPixel,
+                        "depth"     , G_TYPE_INT, qt_rgbColorLookup[i].depth,
+                        "endianness", G_TYPE_INT, qt_rgbColorLookup[i].endianness,
+                        "red_mask"  , G_TYPE_INT, qt_rgbColorLookup[i].red,
+                        "green_mask", G_TYPE_INT, qt_rgbColorLookup[i].green,
+                        "blue_mask" , G_TYPE_INT, qt_rgbColorLookup[i].blue,
+                        NULL);
+
+                if (qt_rgbColorLookup[i].alpha != 0) {
+                    gst_structure_set(
+                            structure, "alpha_mask", G_TYPE_INT, qt_rgbColorLookup[i].alpha, NULL);
+                }
+                gst_caps_append_structure(caps, structure);
+            }
+        }
+    }
+
+    return caps;
+}
+
+gboolean QVideoSurfaceGstSink::set_caps(GstBaseSink *base, GstCaps *caps)
+{
+    VO_SINK(base);
+
+    //qDebug() << "set_caps";
+    //qDebug() << gst_caps_to_string(caps);
+
+    if (!caps) {
+        sink->delegate->stop();
+
+        return TRUE;
+    } else {
+        int bytesPerLine = 0;
+        QVideoSurfaceFormat format = formatForCaps(caps, &bytesPerLine);
+
+        if (sink->delegate->isActive()) {
+            QVideoSurfaceFormat surfaceFormst = sink->delegate->surfaceFormat();
+
+            if (format.pixelFormat() == surfaceFormst.pixelFormat() &&
+                format.frameSize() == surfaceFormst.frameSize())
+                return TRUE;
+            else
+                sink->delegate->stop();
+        }
+
+        if (sink->lastRequestedCaps)
+            gst_caps_unref(sink->lastRequestedCaps);
+        sink->lastRequestedCaps = 0;
+
+        //qDebug() << "Staring video surface:";
+        //qDebug() << format;
+        //qDebug() << bytesPerLine;
+
+        if (sink->delegate->start(format, bytesPerLine))
+            return TRUE;
+
+    }
+
+    return FALSE;
+}
+
+QVideoSurfaceFormat QVideoSurfaceGstSink::formatForCaps(GstCaps *caps, int *bytesPerLine)
+{
+    const GstStructure *structure = gst_caps_get_structure(caps, 0);
+
+    QVideoFrame::PixelFormat pixelFormat = QVideoFrame::Format_Invalid;
+    int bitsPerPixel = 0;
+
+    QSize size;
+    gst_structure_get_int(structure, "width", &size.rwidth());
+    gst_structure_get_int(structure, "height", &size.rheight());
+
+    if (qstrcmp(gst_structure_get_name(structure), "video/x-raw-yuv") == 0) {
+        guint32 fourcc = 0;
+        gst_structure_get_fourcc(structure, "format", &fourcc);
+
+        int index = indexOfYuvColor(fourcc);
+        if (index != -1) {
+            pixelFormat = qt_yuvColorLookup[index].pixelFormat;
+            bitsPerPixel = qt_yuvColorLookup[index].bitsPerPixel;
+        }
+    } else if (qstrcmp(gst_structure_get_name(structure), "video/x-raw-rgb") == 0) {
+        int depth = 0;
+        int endianness = 0;
+        int red = 0;
+        int green = 0;
+        int blue = 0;
+        int alpha = 0;
+
+        gst_structure_get_int(structure, "bpp", &bitsPerPixel);
+        gst_structure_get_int(structure, "depth", &depth);
+        gst_structure_get_int(structure, "endianness", &endianness);
+        gst_structure_get_int(structure, "red_mask", &red);
+        gst_structure_get_int(structure, "green_mask", &green);
+        gst_structure_get_int(structure, "blue_mask", &blue);
+        gst_structure_get_int(structure, "alpha_mask", &alpha);
+
+        int index = indexOfRgbColor(bitsPerPixel, depth, endianness, red, green, blue, alpha);
+
+        if (index != -1)
+            pixelFormat = qt_rgbColorLookup[index].pixelFormat;
+    }
+
+    if (pixelFormat != QVideoFrame::Format_Invalid) {
+        QVideoSurfaceFormat format(size, pixelFormat);
+
+        QPair<int, int> rate;
+        gst_structure_get_fraction(structure, "framerate", &rate.first, &rate.second);
+
+        if (rate.second)
+            format.setFrameRate(qreal(rate.first)/rate.second);
+
+        gint aspectNum = 0;
+        gint aspectDenum = 0;
+        if (gst_structure_get_fraction(
+                structure, "pixel-aspect-ratio", &aspectNum, &aspectDenum)) {
+            if (aspectDenum > 0)
+                format.setPixelAspectRatio(aspectNum, aspectDenum);
+        }
+
+        if (bytesPerLine)
+            *bytesPerLine = ((size.width() * bitsPerPixel / 8) + 3) & ~3;
+
+        return format;
+    }
+
+    return QVideoSurfaceFormat();
+}
+
+
+GstFlowReturn QVideoSurfaceGstSink::buffer_alloc(
+        GstBaseSink *base, guint64 offset, guint size, GstCaps *caps, GstBuffer **buffer)
+{
+    VO_SINK(base);
+
+    Q_UNUSED(offset);
+    Q_UNUSED(size);
+
+    *buffer = 0;
+
+    if (sink->lastRequestedCaps && gst_caps_is_equal(sink->lastRequestedCaps, caps)) {
+        //qDebug() << "reusing last caps";
+        *buffer = GST_BUFFER(sink->pool->takeBuffer(*sink->lastSurfaceFormat, sink->lastBufferCaps));
+        return GST_FLOW_OK;
+    }
+
+    if (sink->delegate->supportedPixelFormats(XvHandleType).isEmpty()) {
+        //qDebug() << "sink doesn't support Xv buffers, skip buffers allocation";
+        return GST_FLOW_OK;
+    }
+
+    GstCaps *intersection = gst_caps_intersect(get_caps(GST_BASE_SINK(sink)), caps);
+
+    if (gst_caps_is_empty (intersection)) {
+        gst_caps_unref(intersection);
+        return GST_FLOW_NOT_NEGOTIATED;
+    }
+
+    if (sink->delegate->isActive()) {
+        //if format was changed, restart the surface
+        QVideoSurfaceFormat format = formatForCaps(intersection);
+        QVideoSurfaceFormat surfaceFormat = sink->delegate->surfaceFormat();
+
+        if (format.pixelFormat() != surfaceFormat.pixelFormat() ||
+            format.frameSize() != surfaceFormat.frameSize()) {
+            //qDebug() << "new format requested, restart video surface";
+            sink->delegate->stop();
+        }
+    }
+
+    if (!sink->delegate->isActive()) {
+        int bytesPerLine = 0;
+        QVideoSurfaceFormat format = formatForCaps(intersection, &bytesPerLine);
+
+        if (!sink->delegate->start(format, bytesPerLine)) {
+            qDebug() << "failed to start video surface";
+            return GST_FLOW_NOT_NEGOTIATED;
+        }
+    }
+
+    QVideoSurfaceFormat surfaceFormat = sink->delegate->surfaceFormat();
+
+    if (!sink->pool->isFormatSupported(surfaceFormat)) {
+        //qDebug() << "sink doesn't provide Xv buffer details, skip buffers allocation";
+        return GST_FLOW_OK;
+    }
+
+    if (sink->lastRequestedCaps)
+        gst_caps_unref(sink->lastRequestedCaps);
+    sink->lastRequestedCaps = caps;
+    gst_caps_ref(sink->lastRequestedCaps);
+
+    if (sink->lastBufferCaps)
+        gst_caps_unref(sink->lastBufferCaps);
+    sink->lastBufferCaps = intersection;
+    gst_caps_ref(sink->lastBufferCaps);
+
+    *sink->lastSurfaceFormat = surfaceFormat;
+
+    *buffer =  GST_BUFFER(sink->pool->takeBuffer(surfaceFormat, intersection));
+
+    return GST_FLOW_OK;
+}
+
+gboolean QVideoSurfaceGstSink::start(GstBaseSink *base)
+{
+    Q_UNUSED(base);
+
+    return TRUE;
+}
+
+gboolean QVideoSurfaceGstSink::stop(GstBaseSink *base)
+{
+    Q_UNUSED(base);
+
+    return TRUE;
+}
+
+gboolean QVideoSurfaceGstSink::unlock(GstBaseSink *base)
+{
+    Q_UNUSED(base);
+
+    return TRUE;
+}
+
+gboolean QVideoSurfaceGstSink::event(GstBaseSink *base, GstEvent *event)
+{
+    Q_UNUSED(base);
+    Q_UNUSED(event);
+
+    return TRUE;
+}
+
+GstFlowReturn QVideoSurfaceGstSink::preroll(GstBaseSink *base, GstBuffer *buffer)
+{
+    VO_SINK(base);
+
+    return sink->delegate->render(buffer);
+}
+
+GstFlowReturn QVideoSurfaceGstSink::render(GstBaseSink *base, GstBuffer *buffer)
+{
+    VO_SINK(base);
+    return sink->delegate->render(buffer);
+}
+
+QT_END_NAMESPACE
+
+
diff --git a/src/plugins/mediaservices/gstreamer/qvideosurfacegstsink.h b/src/plugins/mediaservices/gstreamer/qvideosurfacegstsink.h
new file mode 100644
index 0000000..f59a43c
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qvideosurfacegstsink.h
@@ -0,0 +1,157 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef VIDEOSURFACEGSTSINK_H
+#define VIDEOSURFACEGSTSINK_H
+
+#include <gst/video/gstvideosink.h>
+
+#include <QtCore/qlist.h>
+#include <QtCore/qmutex.h>
+#include <QtCore/qpointer.h>
+#include <QtCore/qwaitcondition.h>
+#include <QtMultimedia/qvideosurfaceformat.h>
+#include <QtMultimedia/qvideoframe.h>
+#include <QtMultimedia/qabstractvideobuffer.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QAbstractVideoSurface;
+
+class QGstXvImageBuffer;
+class QGstXvImageBufferPool;
+
+
+class QVideoSurfaceGstDelegate : public QObject
+{
+    Q_OBJECT
+public:
+    QVideoSurfaceGstDelegate(QAbstractVideoSurface *surface);
+
+    QList<QVideoFrame::PixelFormat> supportedPixelFormats(
+        QAbstractVideoBuffer::HandleType handleType = QAbstractVideoBuffer::NoHandle) const;
+
+    QVideoSurfaceFormat surfaceFormat() const;
+
+
+    bool start(const QVideoSurfaceFormat &format, int bytesPerLine);
+    void stop();
+
+    bool isActive();
+
+    GstFlowReturn render(GstBuffer *buffer);
+
+private slots:
+    void queuedStart();
+    void queuedStop();
+    void queuedRender();
+
+    void supportedFormatsChanged();
+
+private:
+    QPointer<QAbstractVideoSurface> m_surface;
+    QList<QVideoFrame::PixelFormat> m_supportedPixelFormats;
+    QMutex m_mutex;
+    QWaitCondition m_setupCondition;
+    QWaitCondition m_renderCondition;
+    QVideoSurfaceFormat m_format;
+    QVideoFrame m_frame;
+    GstFlowReturn m_renderReturn;
+    int m_bytesPerLine;
+    bool m_started;
+};
+
+class QVideoSurfaceGstSink
+{
+public:
+    GstVideoSink parent;
+
+    static QVideoSurfaceGstSink *createSink(QAbstractVideoSurface *surface);
+    static QVideoSurfaceFormat formatForCaps(GstCaps *caps, int *bytesPerLine = 0);
+
+private:
+    static GType get_type();
+    static void class_init(gpointer g_class, gpointer class_data);
+    static void base_init(gpointer g_class);
+    static void instance_init(GTypeInstance *instance, gpointer g_class);
+
+    static void finalize(GObject *object);
+
+    static GstStateChangeReturn change_state(GstElement *element, GstStateChange transition);
+
+    static GstCaps *get_caps(GstBaseSink *sink);
+    static gboolean set_caps(GstBaseSink *sink, GstCaps *caps);
+
+    static GstFlowReturn buffer_alloc(
+            GstBaseSink *sink, guint64 offset, guint size, GstCaps *caps, GstBuffer **buffer);
+
+    static gboolean start(GstBaseSink *sink);
+    static gboolean stop(GstBaseSink *sink);
+
+    static gboolean unlock(GstBaseSink *sink);
+
+    static gboolean event(GstBaseSink *sink, GstEvent *event);
+    static GstFlowReturn preroll(GstBaseSink *sink, GstBuffer *buffer);
+    static GstFlowReturn render(GstBaseSink *sink, GstBuffer *buffer);
+
+private:
+    QVideoSurfaceGstDelegate *delegate;
+    QGstXvImageBufferPool *pool;
+    GstCaps *lastRequestedCaps;
+    GstCaps *lastBufferCaps;
+    QVideoSurfaceFormat *lastSurfaceFormat;
+};
+
+
+class QVideoSurfaceGstSinkClass
+{
+public:
+    GstVideoSinkClass parent_class;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/gstreamer/qx11videosurface.cpp b/src/plugins/mediaservices/gstreamer/qx11videosurface.cpp
new file mode 100644
index 0000000..70b8527
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qx11videosurface.cpp
@@ -0,0 +1,523 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qdebug.h>
+#include <QtGui/qx11info_x11.h>
+#include <QtMultimedia/qvideosurfaceformat.h>
+
+#include "qx11videosurface.h"
+
+Q_DECLARE_METATYPE(::XvImage*);
+
+QT_BEGIN_NAMESPACE
+
+static QAbstractVideoBuffer::HandleType XvHandleType = QAbstractVideoBuffer::HandleType(4);
+
+struct XvFormatRgb
+{
+    QVideoFrame::PixelFormat pixelFormat;
+    int bits_per_pixel;
+    int format;
+    int num_planes;
+
+    int depth;
+    unsigned int red_mask;
+    unsigned int green_mask;
+    unsigned int blue_mask;
+
+};
+
+bool operator ==(const XvImageFormatValues &format, const XvFormatRgb &rgb)
+{
+    return format.type == XvRGB
+            && format.bits_per_pixel == rgb.bits_per_pixel
+            && format.format         == rgb.format
+            && format.num_planes     == rgb.num_planes
+            && format.depth          == rgb.depth
+            && format.red_mask       == rgb.red_mask
+            && format.blue_mask      == rgb.blue_mask;
+}
+
+static const XvFormatRgb qt_xvRgbLookup[] =
+{
+    { QVideoFrame::Format_ARGB32, 32, XvPacked, 1, 32, 0x00FF0000, 0x0000FF00, 0x000000FF },
+    { QVideoFrame::Format_RGB32 , 32, XvPacked, 1, 24, 0x00FF0000, 0x0000FF00, 0x000000FF },
+    { QVideoFrame::Format_RGB24 , 24, XvPacked, 1, 24, 0x00FF0000, 0x0000FF00, 0x000000FF },
+    { QVideoFrame::Format_RGB565, 16, XvPacked, 1, 16, 0x0000F800, 0x000007E0, 0x0000001F },
+    { QVideoFrame::Format_BGRA32, 32, XvPacked, 1, 32, 0xFF000000, 0x00FF0000, 0x0000FF00 },
+    { QVideoFrame::Format_BGR32 , 32, XvPacked, 1, 24, 0x00FF0000, 0x0000FF00, 0x000000FF },
+    { QVideoFrame::Format_BGR24 , 24, XvPacked, 1, 24, 0x00FF0000, 0x0000FF00, 0x000000FF },
+    { QVideoFrame::Format_BGR565, 16, XvPacked, 1, 16, 0x0000F800, 0x000007E0, 0x0000001F }
+};
+
+struct XvFormatYuv
+{
+    QVideoFrame::PixelFormat pixelFormat;
+    int bits_per_pixel;
+    int format;
+    int num_planes;
+
+    unsigned int y_sample_bits;
+    unsigned int u_sample_bits;
+    unsigned int v_sample_bits;
+    unsigned int horz_y_period;
+    unsigned int horz_u_period;
+    unsigned int horz_v_period;
+    unsigned int vert_y_period;
+    unsigned int vert_u_period;
+    unsigned int vert_v_period;
+    char component_order[32];
+};
+
+bool operator ==(const XvImageFormatValues &format, const XvFormatYuv &yuv)
+{
+    return format.type == XvYUV
+            && format.bits_per_pixel == yuv.bits_per_pixel
+            && format.format         == yuv.format
+            && format.num_planes     == yuv.num_planes
+            && format.y_sample_bits  == yuv.y_sample_bits
+            && format.u_sample_bits  == yuv.u_sample_bits
+            && format.v_sample_bits  == yuv.v_sample_bits
+            && format.horz_y_period  == yuv.horz_y_period
+            && format.horz_u_period  == yuv.horz_u_period
+            && format.horz_v_period  == yuv.horz_v_period
+            && format.horz_y_period  == yuv.vert_y_period
+            && format.vert_u_period  == yuv.vert_u_period
+            && format.vert_v_period  == yuv.vert_v_period
+            && qstrncmp(format.component_order, yuv.component_order, 32) == 0;
+}
+
+static const XvFormatYuv qt_xvYuvLookup[] =
+{
+    { QVideoFrame::Format_YUV444 , 24, XvPacked, 1, 8, 8, 8, 1, 1, 1, 1, 1, 1, "YUV"  },
+    { QVideoFrame::Format_YUV420P, 12, XvPlanar, 3, 8, 8, 8, 1, 2, 2, 1, 2, 2, "YUV"  },
+    { QVideoFrame::Format_YV12   , 12, XvPlanar, 3, 8, 8, 8, 1, 2, 2, 1, 2, 2, "YVU"  },
+    { QVideoFrame::Format_UYVY   , 16, XvPacked, 1, 8, 8, 8, 1, 2, 2, 1, 1, 1, "UYVY" },
+    { QVideoFrame::Format_YUYV   , 16, XvPacked, 1, 8, 8, 8, 1, 2, 2, 1, 1, 1, "YUY2" },
+    { QVideoFrame::Format_YUYV   , 16, XvPacked, 1, 8, 8, 8, 1, 2, 2, 1, 1, 1, "YUYV" },
+    { QVideoFrame::Format_NV12   , 12, XvPlanar, 2, 8, 8, 8, 1, 2, 2, 1, 2, 2, "YUV"  },
+    { QVideoFrame::Format_NV12   , 12, XvPlanar, 2, 8, 8, 8, 1, 2, 2, 1, 2, 2, "YVU"  },
+    { QVideoFrame::Format_Y8     , 8 , XvPlanar, 1, 8, 0, 0, 1, 0, 0, 1, 0, 0, "Y"    }
+};
+
+QX11VideoSurface::QX11VideoSurface(QObject *parent)
+    : QAbstractVideoSurface(parent)
+    , m_winId(0)
+    , m_portId(0)
+    , m_gc(0)
+    , m_image(0)
+{
+}
+
+QX11VideoSurface::~QX11VideoSurface()
+{
+    if (m_gc)
+        XFreeGC(QX11Info::display(), m_gc);
+
+    if (m_portId != 0)
+        XvUngrabPort(QX11Info::display(), m_portId, 0);
+}
+
+WId QX11VideoSurface::winId() const
+{
+    return m_winId;
+}
+
+void QX11VideoSurface::setWinId(WId id)
+{
+    if (id == m_winId)
+        return;
+
+    if (m_image)
+        XFree(m_image);
+
+    if (m_gc) {
+        XFreeGC(QX11Info::display(), m_gc);
+        m_gc = 0;
+    }
+
+    if (m_portId != 0)
+        XvUngrabPort(QX11Info::display(), m_portId, 0);
+
+    m_supportedPixelFormats.clear();
+    m_formatIds.clear();
+
+    m_winId = id;
+
+    if (m_winId && findPort()) {
+        querySupportedFormats();
+
+        m_gc = XCreateGC(QX11Info::display(), m_winId, 0, 0);
+
+        if (m_image) {
+            m_image = 0;
+
+            if (!start(surfaceFormat()))
+                QAbstractVideoSurface::stop();
+        }
+    } else if (m_image) {
+        m_image = 0;
+
+        QAbstractVideoSurface::stop();
+    }
+
+    emit supportedFormatsChanged();
+}
+
+QRect QX11VideoSurface::displayRect() const
+{
+    return m_displayRect;
+}
+
+void QX11VideoSurface::setDisplayRect(const QRect &rect)
+{
+    m_displayRect = rect;
+}
+
+QRect QX11VideoSurface::viewport() const
+{
+    return m_viewport;
+}
+
+void QX11VideoSurface::setViewport(const QRect &rect)
+{
+    m_viewport = rect;
+}
+
+int QX11VideoSurface::brightness() const
+{
+    return getAttribute("XV_BRIGHTNESS", m_brightnessRange.first, m_brightnessRange.second);
+}
+
+void QX11VideoSurface::setBrightness(int brightness)
+{
+    setAttribute("XV_BRIGHTNESS", brightness, m_brightnessRange.first, m_brightnessRange.second);
+}
+
+int QX11VideoSurface::contrast() const
+{
+    return getAttribute("XV_CONTRAST", m_contrastRange.first, m_contrastRange.second);
+}
+
+void QX11VideoSurface::setContrast(int contrast)
+{
+    setAttribute("XV_CONTRAST", contrast, m_contrastRange.first, m_contrastRange.second);
+}
+
+int QX11VideoSurface::hue() const
+{
+    return getAttribute("XV_HUE", m_hueRange.first, m_hueRange.second);
+}
+
+void QX11VideoSurface::setHue(int hue)
+{
+    setAttribute("XV_HUE", hue, m_hueRange.first, m_hueRange.second);
+}
+
+int QX11VideoSurface::saturation() const
+{
+    return getAttribute("XV_SATURATION", m_saturationRange.first, m_saturationRange.second);
+}
+
+void QX11VideoSurface::setSaturation(int saturation)
+{
+    setAttribute("XV_SATURATION", saturation, m_saturationRange.first, m_saturationRange.second);
+}
+
+int QX11VideoSurface::getAttribute(const char *attribute, int minimum, int maximum) const
+{
+    if (m_portId != 0) {
+        Display *display = QX11Info::display();
+
+        Atom atom = XInternAtom(display, attribute, True);
+
+        int value = 0;
+
+        XvGetPortAttribute(display, m_portId, atom, &value);
+
+        return redistribute(value, minimum, maximum, -100, 100);
+    } else {
+        return 0;
+    }
+}
+
+void QX11VideoSurface::setAttribute(const char *attribute, int value, int minimum, int maximum)
+{
+    if (m_portId != 0) {
+        Display *display = QX11Info::display();
+
+        Atom atom = XInternAtom(display, attribute, True);
+
+        XvSetPortAttribute(
+                display, m_portId, atom, redistribute(value, -100, 100, minimum, maximum));
+    }
+}
+
+int QX11VideoSurface::redistribute(
+        int value, int fromLower, int fromUpper, int toLower, int toUpper)
+{
+    return fromUpper != fromLower
+            ? ((value - fromLower) * (toUpper - toLower) / (fromUpper - fromLower)) + toLower
+            : 0;
+}
+
+QList<QVideoFrame::PixelFormat> QX11VideoSurface::supportedPixelFormats(
+        QAbstractVideoBuffer::HandleType handleType) const
+{
+    return handleType == QAbstractVideoBuffer::NoHandle || handleType ==  XvHandleType
+            ? m_supportedPixelFormats
+            : QList<QVideoFrame::PixelFormat>();
+}
+
+bool QX11VideoSurface::start(const QVideoSurfaceFormat &format)
+{
+    if (m_image)
+        XFree(m_image);
+
+    int xvFormatId = 0;
+    for (int i = 0; i < m_supportedPixelFormats.count(); ++i) {
+        if (m_supportedPixelFormats.at(i) == format.pixelFormat()) {
+            xvFormatId = m_formatIds.at(i);
+            break;
+        }
+    }
+
+    if (xvFormatId == 0) {
+        setError(UnsupportedFormatError);
+    } else {
+        XvImage *image = XvCreateImage(
+                QX11Info::display(),
+                m_portId,
+                xvFormatId,
+                0,
+                format.frameWidth(),
+                format.frameHeight());
+
+        if (!image) {
+            setError(ResourceError);
+        } else {
+            m_viewport = format.viewport();
+            m_image = image;
+
+            QVideoSurfaceFormat newFormat = format;
+            newFormat.setProperty("portId", QVariant(quint64(m_portId)));
+            newFormat.setProperty("xvFormatId", xvFormatId);
+            newFormat.setProperty("dataSize", image->data_size);
+
+            return QAbstractVideoSurface::start(newFormat);
+        }
+    }
+
+    if (m_image) {
+        m_image = 0;
+
+        QAbstractVideoSurface::stop();
+    }
+
+    return false;
+}
+
+void QX11VideoSurface::stop()
+{
+    if (m_image) {
+        XFree(m_image);
+        m_image = 0;
+
+        QAbstractVideoSurface::stop();
+    }
+}
+
+bool QX11VideoSurface::present(const QVideoFrame &frame)
+{
+    if (!m_image) {
+        setError(StoppedError);
+        return false;
+    } else if (m_image->width != frame.width() || m_image->height != frame.height()) {
+        setError(IncorrectFormatError);
+        return false;
+    } else {
+        QVideoFrame frameCopy(frame);
+
+        if (!frameCopy.map(QAbstractVideoBuffer::ReadOnly)) {
+            setError(IncorrectFormatError);
+            return false;
+        } else {
+            bool presented = false;
+
+            if (frame.handleType() != XvHandleType &&
+                m_image->data_size > frame.mappedBytes()) {
+                qWarning("Insufficient frame buffer size");
+                setError(IncorrectFormatError);
+            } else if (frame.handleType() != XvHandleType &&
+                       m_image->num_planes > 0 &&
+                       m_image->pitches[0] != frame.bytesPerLine()) {
+                qWarning("Incompatible frame pitches");
+                setError(IncorrectFormatError);
+            } else {
+                if (frame.handleType() != XvHandleType) {
+                    m_image->data = reinterpret_cast<char *>(frameCopy.bits());
+
+                    //qDebug() << "copy frame";
+                    XvPutImage(
+                            QX11Info::display(),
+                            m_portId,
+                            m_winId,
+                            m_gc,
+                            m_image,
+                            m_viewport.x(),
+                            m_viewport.y(),
+                            m_viewport.width(),
+                            m_viewport.height(),
+                            m_displayRect.x(),
+                            m_displayRect.y(),
+                            m_displayRect.width(),
+                            m_displayRect.height());
+
+                    m_image->data = 0;
+                } else {
+                    XvImage *img = frame.handle().value<XvImage*>();
+
+                    //qDebug() << "render directly";
+                    if (img)
+                        XvShmPutImage(
+                           QX11Info::display(),
+                           m_portId,
+                           m_winId,
+                           m_gc,
+                           img,
+                           m_viewport.x(),
+                           m_viewport.y(),
+                           m_viewport.width(),
+                           m_viewport.height(),
+                           m_displayRect.x(),
+                           m_displayRect.y(),
+                           m_displayRect.width(),
+                           m_displayRect.height(),
+                           false);
+                }
+
+                presented = true;
+            }
+
+            frameCopy.unmap();
+
+            return presented;
+        }
+    }
+}
+
+bool QX11VideoSurface::findPort()
+{
+    unsigned int count = 0;
+    XvAdaptorInfo *adaptors = 0;
+    bool portFound = false;
+
+    if (XvQueryAdaptors(QX11Info::display(), m_winId, &count, &adaptors) == Success) {
+        for (unsigned int i = 0; i < count && !portFound; ++i) {
+            if (adaptors[i].type & XvImageMask) {
+                m_portId = adaptors[i].base_id;
+
+                for (unsigned int j = 0; j < adaptors[i].num_ports && !portFound; ++j, ++m_portId)
+                    portFound = XvGrabPort(QX11Info::display(), m_portId, 0) == Success;
+            }
+        }
+        XvFreeAdaptorInfo(adaptors);
+    }
+
+    return portFound;
+}
+
+void QX11VideoSurface::querySupportedFormats()
+{
+    int count = 0;
+    if (XvImageFormatValues *imageFormats = XvListImageFormats(
+            QX11Info::display(), m_portId, &count)) {
+        const int rgbCount = sizeof(qt_xvRgbLookup) / sizeof(XvFormatRgb);
+        const int yuvCount = sizeof(qt_xvYuvLookup) / sizeof(XvFormatYuv);
+
+        for (int i = 0; i < count; ++i) {
+            switch (imageFormats[i].type) {
+            case XvRGB:
+                for (int j = 0; j < rgbCount; ++j) {
+                    if (imageFormats[i] == qt_xvRgbLookup[j]) {
+                        m_supportedPixelFormats.append(qt_xvRgbLookup[j].pixelFormat);
+                        m_formatIds.append(imageFormats[i].id);
+                        break;
+                    }
+                }
+                break;
+            case XvYUV:
+                for (int j = 0; j < yuvCount; ++j) {
+                    if (imageFormats[i] == qt_xvYuvLookup[j]) {
+                        m_supportedPixelFormats.append(qt_xvYuvLookup[j].pixelFormat);
+                        m_formatIds.append(imageFormats[i].id);
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+        XFree(imageFormats);
+    }
+
+    m_brightnessRange = qMakePair(0, 0);
+    m_contrastRange = qMakePair(0, 0);
+    m_hueRange = qMakePair(0, 0);
+    m_saturationRange = qMakePair(0, 0);
+
+    if (XvAttribute *attributes = XvQueryPortAttributes(QX11Info::display(), m_portId, &count)) {
+        for (int i = 0; i < count; ++i) {
+            if (qstrcmp(attributes[i].name, "XV_BRIGHTNESS") == 0)
+                m_brightnessRange = qMakePair(attributes[i].min_value, attributes[i].max_value);
+            else if (qstrcmp(attributes[i].name, "XV_CONTRAST") == 0)
+                m_contrastRange = qMakePair(attributes[i].min_value, attributes[i].max_value);
+            else if (qstrcmp(attributes[i].name, "XV_HUE") == 0)
+                m_hueRange = qMakePair(attributes[i].min_value, attributes[i].max_value);
+            else if (qstrcmp(attributes[i].name, "XV_SATURATION") == 0)
+                m_saturationRange = qMakePair(attributes[i].min_value, attributes[i].max_value);
+        }
+
+        XFree(attributes);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/gstreamer/qx11videosurface.h b/src/plugins/mediaservices/gstreamer/qx11videosurface.h
new file mode 100644
index 0000000..10f79a6
--- /dev/null
+++ b/src/plugins/mediaservices/gstreamer/qx11videosurface.h
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QX11VIDEOSURFACE_H
+#define QX11VIDEOSURFACE_H
+
+#include <QtGui/qwidget.h>
+#include <QtMultimedia/qabstractvideosurface.h>
+
+#include <X11/Xlib.h>
+#include <X11/extensions/Xv.h>
+#include <X11/extensions/Xvlib.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QX11VideoSurface : public QAbstractVideoSurface
+{
+    Q_OBJECT
+public:
+    QX11VideoSurface(QObject *parent = 0);
+    ~QX11VideoSurface();
+
+    WId winId() const;
+    void setWinId(WId id);
+
+    QRect displayRect() const;
+    void setDisplayRect(const QRect &rect);
+
+    QRect viewport() const;
+    void setViewport(const QRect &rect);
+
+    int brightness() const;
+    void setBrightness(int brightness);
+
+    int contrast() const;
+    void setContrast(int contrast);
+
+    int hue() const;
+    void setHue(int hue);
+
+    int saturation() const;
+    void setSaturation(int saturation);
+
+    QList<QVideoFrame::PixelFormat> supportedPixelFormats(
+            QAbstractVideoBuffer::HandleType handleType = QAbstractVideoBuffer::NoHandle) const;
+
+    bool start(const QVideoSurfaceFormat &format);
+    void stop();
+
+    bool present(const QVideoFrame &frame);
+
+private:   
+    WId m_winId;
+    XvPortID m_portId;
+    GC m_gc;
+    XvImage *m_image;
+    QList<QVideoFrame::PixelFormat> m_supportedPixelFormats;
+    QVector<int> m_formatIds;
+    QRect m_viewport;
+    QRect m_displayRect;
+    QPair<int, int> m_brightnessRange;
+    QPair<int, int> m_contrastRange;
+    QPair<int, int> m_hueRange;
+    QPair<int, int> m_saturationRange;
+
+    bool findPort();
+    void querySupportedFormats();
+
+    int getAttribute(const char *attribute, int minimum, int maximum) const;
+    void setAttribute(const char *attribute, int value, int minimum, int maximum);
+
+    static int redistribute(int value, int fromLower, int fromUpper, int toLower, int toUpper);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/mediaservices.pro b/src/plugins/mediaservices/mediaservices.pro
new file mode 100644
index 0000000..19d678b
--- /dev/null
+++ b/src/plugins/mediaservices/mediaservices.pro
@@ -0,0 +1,11 @@
+TEMPLATE = subdirs
+
+contains(QT_CONFIG, mediaservice) {
+    win32:!wince*: SUBDIRS += directshow
+
+    mac: SUBDIRS += qt7
+
+    unix:!mac:!symbian:contains(QT_CONFIG, xvideo):contains(QT_CONFIG, gstreamer) {
+        SUBDIRS += gstreamer
+    }
+}
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/mediaplayer.pri b/src/plugins/mediaservices/qt7/mediaplayer/mediaplayer.pri
new file mode 100644
index 0000000..577209e
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/mediaplayer.pri
@@ -0,0 +1,18 @@
+INCLUDEPATH += $$PWD
+
+DEFINES += QMEDIA_QT7_PLAYER
+
+HEADERS += \
+    $$PWD/qt7playercontrol.h \
+    $$PWD/qt7playermetadata.h \
+    $$PWD/qt7playerservice.h \
+    $$PWD/qt7playersession.h
+
+OBJECTIVE_SOURCES += \
+    $$PWD/qt7playercontrol.mm \
+    $$PWD/qt7playermetadata.mm \
+    $$PWD/qt7playerservice.mm \
+    $$PWD/qt7playersession.mm
+
+
+
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/qt7playercontrol.h b/src/plugins/mediaservices/qt7/mediaplayer/qt7playercontrol.h
new file mode 100644
index 0000000..907d13d
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/qt7playercontrol.h
@@ -0,0 +1,128 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7PLAYERCONTROL_H
+#define QT7PLAYERCONTROL_H
+
+#include <QtCore/qobject.h>
+#include <QtGui/qmacdefines_mac.h>
+
+#include <QtMultimedia/qmediaplayercontrol.h>
+#include <QtMultimedia/qmediaplayer.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QT7PlayerSession;
+class QT7PlayerService;
+class QMediaPlaylist;
+class QMediaPlaylistNavigator;
+
+class QT7PlayerControl : public QMediaPlayerControl
+{
+Q_OBJECT
+public:
+    QT7PlayerControl(QObject *parent = 0);
+    ~QT7PlayerControl();
+
+    void setSession(QT7PlayerSession *session);
+
+    QMediaPlayer::State state() const;
+    QMediaPlayer::MediaStatus mediaStatus() const;
+
+    QMediaContent media() const;
+    const QIODevice *mediaStream() const;
+    void setMedia(const QMediaContent &content, QIODevice *stream);
+
+    qint64 position() const;
+    qint64 duration() const;
+
+    int bufferStatus() const;
+
+    int volume() const;
+    bool isMuted() const;
+
+    bool isAudioAvailable() const;
+    bool isVideoAvailable() const;
+
+    bool isSeekable() const;
+
+    QMediaTimeRange availablePlaybackRanges() const;
+
+    qreal playbackRate() const;
+    void setPlaybackRate(qreal rate);
+
+public Q_SLOTS:
+    void setPosition(qint64 pos);
+
+    void play();
+    void pause();
+    void stop();
+
+    void setVolume(int volume);
+    void setMuted(bool muted);
+
+Q_SIGNALS:
+    void mediaChanged(const QMediaContent& content);
+    void durationChanged(qint64 duration);
+    void positionChanged(qint64 position);
+    void stateChanged(QMediaPlayer::State newState);
+    void mediaStatusChanged(QMediaPlayer::MediaStatus status);
+    void volumeChanged(int volume);
+    void mutedChanged(bool muted);
+    void videoAvailableChanged(bool videoAvailable);
+    void bufferStatusChanged(int percentFilled);
+    void seekableChanged(bool);
+    void seekRangeChanged(const QPair<qint64,qint64>&);
+    void playbackRateChanged(qreal rate);
+    void error(int error, const QString &errorString);
+
+private:
+    QT7PlayerSession *m_session;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/qt7playercontrol.mm b/src/plugins/mediaservices/qt7/mediaplayer/qt7playercontrol.mm
new file mode 100644
index 0000000..0f4ac41
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/qt7playercontrol.mm
@@ -0,0 +1,193 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qt7playercontrol.h"
+#include "qt7playersession.h"
+
+#include <QtMultimedia/qmediaplaylistnavigator.h>
+
+#include <QtCore/qurl.h>
+#include <QtCore/qdebug.h>
+
+
+QT_BEGIN_NAMESPACE
+
+QT7PlayerControl::QT7PlayerControl(QObject *parent)
+   : QMediaPlayerControl(parent)
+{    
+}
+
+QT7PlayerControl::~QT7PlayerControl()
+{
+}
+
+void QT7PlayerControl::setSession(QT7PlayerSession *session)
+{
+    m_session = session;
+
+    connect(m_session, SIGNAL(positionChanged(qint64)), this, SIGNAL(positionChanged(qint64)));
+    connect(m_session, SIGNAL(durationChanged(qint64)), this, SIGNAL(durationChanged(qint64)));
+    connect(m_session, SIGNAL(stateChanged(QMediaPlayer::State)),
+            this, SIGNAL(stateChanged(QMediaPlayer::State)));
+    connect(m_session, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)),
+            this, SIGNAL(mediaStatusChanged(QMediaPlayer::MediaStatus)));
+    connect(m_session, SIGNAL(volumeChanged(int)), this, SIGNAL(volumeChanged(int)));
+    connect(m_session, SIGNAL(mutedChanged(bool)), this, SIGNAL(mutedChanged(bool)));
+    connect(m_session, SIGNAL(audioAvailableChanged(bool)), this, SIGNAL(audioAvailableChanged(bool)));
+    connect(m_session, SIGNAL(videoAvailableChanged(bool)), this, SIGNAL(videoAvailableChanged(bool)));
+    connect(m_session, SIGNAL(error(int,QString)), this, SIGNAL(error(int,QString)));
+}
+
+qint64 QT7PlayerControl::position() const
+{
+    return m_session->position();
+}
+
+qint64 QT7PlayerControl::duration() const
+{
+    return m_session->duration();
+}
+
+QMediaPlayer::State QT7PlayerControl::state() const
+{
+    return m_session->state();
+}
+
+QMediaPlayer::MediaStatus QT7PlayerControl::mediaStatus() const
+{
+    return m_session->mediaStatus();
+}
+
+int QT7PlayerControl::bufferStatus() const
+{
+    return m_session->bufferStatus();
+}
+
+int QT7PlayerControl::volume() const
+{
+    return m_session->volume();
+}
+
+bool QT7PlayerControl::isMuted() const
+{
+    return m_session->isMuted();
+}
+
+bool QT7PlayerControl::isSeekable() const
+{
+    return m_session->isSeekable();
+}
+
+QMediaTimeRange QT7PlayerControl::availablePlaybackRanges() const
+{
+    return isSeekable() ? QMediaTimeRange(0, duration()) : QMediaTimeRange();
+}
+
+qreal QT7PlayerControl::playbackRate() const
+{
+    return m_session->playbackRate();
+}
+
+void QT7PlayerControl::setPlaybackRate(qreal rate)
+{
+    m_session->setPlaybackRate(rate);
+}
+
+void QT7PlayerControl::setPosition(qint64 pos)
+{
+    m_session->setPosition(pos);
+}
+
+void QT7PlayerControl::play()
+{
+    m_session->play();
+}
+
+void QT7PlayerControl::pause()
+{
+    m_session->pause();
+}
+
+void QT7PlayerControl::stop()
+{
+    m_session->stop();
+}
+
+void QT7PlayerControl::setVolume(int volume)
+{
+    m_session->setVolume(volume);
+}
+
+void QT7PlayerControl::setMuted(bool muted)
+{
+    m_session->setMuted(muted);
+}
+
+QMediaContent QT7PlayerControl::media() const
+{
+    return m_session->media();
+}
+
+const QIODevice *QT7PlayerControl::mediaStream() const
+{
+    return m_session->mediaStream();
+}
+
+void QT7PlayerControl::setMedia(const QMediaContent &content, QIODevice *stream)
+{
+    m_session->setMedia(content, stream);
+
+    emit mediaChanged(content);
+}
+
+bool QT7PlayerControl::isAudioAvailable() const
+{
+    return m_session->isAudioAvailable();
+}
+
+bool QT7PlayerControl::isVideoAvailable() const
+{
+    return m_session->isVideoAvailable();
+}
+
+#include "moc_qt7playercontrol.cpp"
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/qt7playermetadata.h b/src/plugins/mediaservices/qt7/mediaplayer/qt7playermetadata.h
new file mode 100644
index 0000000..f16807a
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/qt7playermetadata.h
@@ -0,0 +1,84 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7PLAYERMETADATACONTROL_H
+#define QT7PLAYERMETADATACONTROL_H
+
+#include <QtMultimedia/qmetadatacontrol.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QT7PlayerSession;
+
+class QT7PlayerMetaDataControl : public QMetaDataControl
+{
+    Q_OBJECT
+public:
+    QT7PlayerMetaDataControl(QT7PlayerSession *session, QObject *parent);
+    virtual ~QT7PlayerMetaDataControl();
+
+    bool isMetaDataAvailable() const;
+    bool isWritable() const;
+
+    QVariant metaData(QtMultimedia::MetaData key) const;
+    void setMetaData(QtMultimedia::MetaData key, const QVariant &value);
+    QList<QtMultimedia::MetaData> availableMetaData() const;
+
+    QVariant extendedMetaData(const QString &key) const ;
+    void setExtendedMetaData(const QString &key, const QVariant &value);
+    QStringList availableExtendedMetaData() const;
+
+private slots:
+    void updateTags();
+
+private:
+    QT7PlayerSession *m_session;
+    QMap<QtMultimedia::MetaData, QVariant> m_tags;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/qt7playermetadata.mm b/src/plugins/mediaservices/qt7/mediaplayer/qt7playermetadata.mm
new file mode 100644
index 0000000..59d01a2
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/qt7playermetadata.mm
@@ -0,0 +1,274 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qt7backend.h"
+#include "qt7playermetadata.h"
+#include "qt7playersession.h"
+#include <QtCore/qvarlengtharray.h>
+
+#import <QTKit/QTMovie.h>
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+    #include <QuickTime/QuickTime.h>
+    #undef check // avoid name clash;
+#endif
+
+QT_BEGIN_NAMESPACE
+
+QT7PlayerMetaDataControl::QT7PlayerMetaDataControl(QT7PlayerSession *session, QObject *parent)
+    :QMetaDataControl(parent), m_session(session)
+{
+}
+
+QT7PlayerMetaDataControl::~QT7PlayerMetaDataControl()
+{
+}
+
+bool QT7PlayerMetaDataControl::isMetaDataAvailable() const
+{
+    return !m_tags.isEmpty();
+}
+
+bool QT7PlayerMetaDataControl::isWritable() const
+{
+    return false;
+}
+
+QVariant QT7PlayerMetaDataControl::metaData(QtMultimedia::MetaData key) const
+{
+    return m_tags.value(key);
+}
+
+void QT7PlayerMetaDataControl::setMetaData(QtMultimedia::MetaData key, QVariant const &value)
+{
+    Q_UNUSED(key);
+    Q_UNUSED(value);
+}
+
+QList<QtMultimedia::MetaData> QT7PlayerMetaDataControl::availableMetaData() const
+{
+    return m_tags.keys();
+}
+
+QVariant QT7PlayerMetaDataControl::extendedMetaData(const QString &key) const
+{
+    Q_UNUSED(key);
+    return QVariant();
+}
+
+void QT7PlayerMetaDataControl::setExtendedMetaData(const QString &key, QVariant const &value)
+{
+    Q_UNUSED(key);
+    Q_UNUSED(value);
+}
+
+QStringList QT7PlayerMetaDataControl::availableExtendedMetaData() const
+{
+    return QStringList();
+}
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+
+static QString stripCopyRightSymbol(const QString &key)
+{
+    return key.right(key.length()-1);
+}
+
+static QString convertQuickTimeKeyToUserKey(const QString &key)
+{
+    if (key == QLatin1String("com.apple.quicktime.displayname"))
+        return QLatin1String("nam");
+    else if (key == QLatin1String("com.apple.quicktime.album"))
+        return QLatin1String("alb");
+    else if (key == QLatin1String("com.apple.quicktime.artist"))
+        return QLatin1String("ART");
+    else
+        return QLatin1String("???");
+}
+
+static OSStatus readMetaValue(QTMetaDataRef metaDataRef, QTMetaDataItem item, QTPropertyClass propClass,
+                              QTPropertyID id, QTPropertyValuePtr *value, ByteCount *size)
+{
+    QTPropertyValueType type;
+    ByteCount propSize;
+    UInt32 propFlags;
+    OSStatus err = QTMetaDataGetItemPropertyInfo(metaDataRef, item, propClass, id, &type, &propSize, &propFlags);
+
+    if (err == noErr) {
+        *value = malloc(propSize);
+        if (*value != 0) {
+            err = QTMetaDataGetItemProperty(metaDataRef, item, propClass, id, propSize, *value, size);
+
+            if (err == noErr && (type == 'code' || type == 'itsk' || type == 'itlk')) {
+                // convert from native endian to big endian
+                OSTypePtr pType = (OSTypePtr)*value;
+                *pType = EndianU32_NtoB(*pType);
+            }
+        }
+        else
+            return -1;
+    }
+
+    return err;
+}
+
+static UInt32 getMetaType(QTMetaDataRef metaDataRef, QTMetaDataItem item)
+{
+    QTPropertyValuePtr value = 0;
+    ByteCount ignore = 0;
+    OSStatus err = readMetaValue(
+            metaDataRef, item, kPropertyClass_MetaDataItem, kQTMetaDataItemPropertyID_DataType, &value, &ignore);
+
+    if (err == noErr) {
+        UInt32 type = *((UInt32 *) value);
+        if (value)
+            free(value);
+        return type;
+    }
+
+    return 0;
+}
+
+static QString cFStringToQString(CFStringRef str)
+{
+    if(!str)
+        return QString();
+    CFIndex length = CFStringGetLength(str);
+    const UniChar *chars = CFStringGetCharactersPtr(str);
+    if (chars)
+        return QString(reinterpret_cast<const QChar *>(chars), length);
+
+    QVarLengthArray<UniChar> buffer(length);
+    CFStringGetCharacters(str, CFRangeMake(0, length), buffer.data());
+    return QString(reinterpret_cast<const QChar *>(buffer.constData()), length);
+}
+
+
+static QString getMetaValue(QTMetaDataRef metaDataRef, QTMetaDataItem item, SInt32 id)
+{
+    QTPropertyValuePtr value = 0;
+    ByteCount size = 0;
+    OSStatus err = readMetaValue(metaDataRef, item, kPropertyClass_MetaDataItem, id, &value, &size);
+    QString string;
+
+    if (err == noErr) {
+        UInt32 dataType = getMetaType(metaDataRef, item);
+        switch (dataType){
+        case kQTMetaDataTypeUTF8:
+        case kQTMetaDataTypeMacEncodedText:
+            string = cFStringToQString(CFStringCreateWithBytes(0, (UInt8*)value, size, kCFStringEncodingUTF8, false));
+            break;
+        case kQTMetaDataTypeUTF16BE:
+            string = cFStringToQString(CFStringCreateWithBytes(0, (UInt8*)value, size, kCFStringEncodingUTF16BE, false));
+            break;
+        default:
+            break;
+        }
+
+        if (value)
+            free(value);
+    }
+
+    return string;
+}
+
+
+static void readFormattedData(QTMetaDataRef metaDataRef, OSType format, QMultiMap<QString, QString> &result)
+{
+    QTMetaDataItem item = kQTMetaDataItemUninitialized;
+    OSStatus err = QTMetaDataGetNextItem(metaDataRef, format, item, kQTMetaDataKeyFormatWildcard, 0, 0, &item);
+    while (err == noErr){
+        QString key = getMetaValue(metaDataRef, item, kQTMetaDataItemPropertyID_Key);
+        if (format == kQTMetaDataStorageFormatQuickTime)
+            key = convertQuickTimeKeyToUserKey(key);
+        else
+            key = stripCopyRightSymbol(key);
+
+        if (!result.contains(key)){
+            QString val = getMetaValue(metaDataRef, item, kQTMetaDataItemPropertyID_Value);
+            result.insert(key, val);
+        }
+        err = QTMetaDataGetNextItem(metaDataRef, format, item, kQTMetaDataKeyFormatWildcard, 0, 0, &item);
+    }
+}
+#endif
+
+
+void QT7PlayerMetaDataControl::updateTags()
+{
+    bool wasEmpty = m_tags.isEmpty();
+    m_tags.clear();
+
+    QTMovie *movie = (QTMovie*)m_session->movie();
+
+    if (movie) {
+        QMultiMap<QString, QString> metaMap;
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+        QTMetaDataRef metaDataRef;
+        OSStatus err = QTCopyMovieMetaData([movie quickTimeMovie], &metaDataRef);
+        if (err == noErr) {
+            readFormattedData(metaDataRef, kQTMetaDataStorageFormatUserData, metaMap);
+            readFormattedData(metaDataRef, kQTMetaDataStorageFormatQuickTime, metaMap);
+            readFormattedData(metaDataRef, kQTMetaDataStorageFormatiTunes, metaMap);
+        }
+#else
+        AutoReleasePool pool;
+        NSString *name = [movie attributeForKey:@"QTMovieDisplayNameAttribute"];
+        metaMap.insert(QLatin1String("nam"), QString::fromUtf8([name UTF8String]));
+#endif // QUICKTIME_C_API_AVAILABLE
+
+        m_tags.insert(QtMultimedia::AlbumArtist, metaMap.value(QLatin1String("ART")));
+        m_tags.insert(QtMultimedia::AlbumTitle, metaMap.value(QLatin1String("alb")));
+        m_tags.insert(QtMultimedia::Title, metaMap.value(QLatin1String("nam")));
+        m_tags.insert(QtMultimedia::Date, metaMap.value(QLatin1String("day")));
+        m_tags.insert(QtMultimedia::Genre, metaMap.value(QLatin1String("gnre")));
+        m_tags.insert(QtMultimedia::TrackNumber, metaMap.value(QLatin1String("trk")));
+        m_tags.insert(QtMultimedia::Description, metaMap.value(QLatin1String("des")));
+    }
+
+    if (!wasEmpty || !m_tags.isEmpty())
+        emit metaDataChanged();
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qt7playermetadata.cpp"
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/qt7playerservice.h b/src/plugins/mediaservices/qt7/mediaplayer/qt7playerservice.h
new file mode 100644
index 0000000..d4b30b8
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/qt7playerservice.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7PLAYERSERVICE_H
+#define QT7PLAYERSERVICE_H
+
+#include <QtCore/qobject.h>
+#include <QtMultimedia/qmediaservice.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QMediaMetaData;
+class QMediaPlayerControl;
+class QMediaPlaylist;
+class QMediaPlaylistNavigator;
+class QT7PlayerControl;
+class QT7PlayerMetaDataControl;
+class QT7VideoOutputControl;
+class QT7VideoWindowControl;
+class QT7VideoWidgetControl;
+class QT7VideoRendererControl;
+class QT7VideoOutput;
+class QT7PlayerSession;
+
+class QT7PlayerService : public QMediaService
+{
+Q_OBJECT
+public:
+    QT7PlayerService(QObject *parent = 0);
+    ~QT7PlayerService();
+
+    QMediaControl *control(const char *name) const;
+
+private slots:
+    void updateVideoOutput();
+
+private:
+    QT7PlayerSession *m_session;
+    QT7PlayerControl *m_control;    
+    QT7VideoOutputControl *m_videoOutputControl;
+    QT7VideoWindowControl *m_videoWidnowControl;
+    QT7VideoWidgetControl *m_videoWidgetControl;
+    QT7VideoRendererControl *m_videoRendererControl;
+    QT7PlayerMetaDataControl *m_playerMetaDataControl;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/qt7playerservice.mm b/src/plugins/mediaservices/qt7/mediaplayer/qt7playerservice.mm
new file mode 100644
index 0000000..205e862
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/qt7playerservice.mm
@@ -0,0 +1,152 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qvariant.h>
+#include <QtCore/qdebug.h>
+#include <QtGui/qwidget.h>
+
+#include "qt7backend.h"
+#include "qt7playerservice.h"
+#include "qt7playercontrol.h"
+#include "qt7playersession.h"
+#include "qt7videooutputcontrol.h"
+#include "qt7movieviewoutput.h"
+#include "qt7movieviewrenderer.h"
+#include "qt7movierenderer.h"
+#include "qt7movievideowidget.h"
+#include "qt7playermetadata.h"
+
+#include <QtMultimedia/qmediaplaylistnavigator.h>
+#include <QtMultimedia/qmediaplaylist.h>
+
+QT_BEGIN_NAMESPACE
+
+QT7PlayerService::QT7PlayerService(QObject *parent):
+    QMediaService(parent)
+{
+    m_session = new QT7PlayerSession(this);
+
+    m_control = new QT7PlayerControl(this);
+    m_control->setSession(m_session);
+
+    m_playerMetaDataControl = new QT7PlayerMetaDataControl(m_session, this);
+    connect(m_control, SIGNAL(mediaChanged(QMediaContent)), m_playerMetaDataControl, SLOT(updateTags()));
+
+    m_videoOutputControl = new QT7VideoOutputControl(this);
+
+    m_videoWidnowControl = 0;
+    m_videoWidgetControl = 0;
+    m_videoRendererControl = 0;
+
+#if defined(QT_MAC_USE_COCOA)
+    m_videoWidnowControl = new QT7MovieViewOutput(this);
+    m_videoOutputControl->enableOutput(QVideoOutputControl::WindowOutput);
+//    qDebug() << "Using cocoa";
+#endif
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+    m_videoRendererControl = new QT7MovieRenderer(this);
+    m_videoOutputControl->enableOutput(QVideoOutputControl::RendererOutput);
+
+    m_videoWidgetControl = new QT7MovieVideoWidget(this);
+    m_videoOutputControl->enableOutput(QVideoOutputControl::WidgetOutput);
+//    qDebug() << "QuickTime C API is available";
+#else
+    m_videoRendererControl = new QT7MovieViewRenderer(this);
+    m_videoOutputControl->enableOutput(QVideoOutputControl::RendererOutput);
+//    qDebug() << "QuickTime C API is not available";
+#endif
+
+
+    connect(m_videoOutputControl, SIGNAL(videoOutputChanged(QVideoOutputControl::Output)),
+            this, SLOT(updateVideoOutput()));
+}
+
+QT7PlayerService::~QT7PlayerService()
+{
+    m_session->setVideoOutput(0);
+}
+
+QMediaControl *QT7PlayerService::control(const char *name) const
+{
+    if (qstrcmp(name, QMediaPlayerControl_iid) == 0)
+        return m_control;
+
+    if (qstrcmp(name, QVideoOutputControl_iid) == 0)
+        return m_videoOutputControl;
+
+    if (qstrcmp(name, QVideoWindowControl_iid) == 0)
+        return m_videoWidnowControl;
+
+    if (qstrcmp(name, QVideoRendererControl_iid) == 0)
+        return m_videoRendererControl;
+
+    if (qstrcmp(name, QVideoWidgetControl_iid) == 0)
+        return m_videoWidgetControl;
+
+    if (qstrcmp(name, QMetaDataControl_iid) == 0)
+        return m_playerMetaDataControl;
+
+    return 0;
+}
+
+void QT7PlayerService::updateVideoOutput()
+{
+//    qDebug() << "QT7PlayerService::updateVideoOutput" << m_videoOutputControl->output();
+
+    switch (m_videoOutputControl->output()) {
+    case QVideoOutputControl::WindowOutput:
+        m_session->setVideoOutput(m_videoWidnowControl);
+        break;
+    case QVideoOutputControl::RendererOutput:
+        m_session->setVideoOutput(m_videoRendererControl);
+        break;
+    case QVideoOutputControl::WidgetOutput:
+        m_session->setVideoOutput(m_videoWidgetControl);
+        break;
+    default:
+        m_session->setVideoOutput(0);
+    }
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qt7playerservice.cpp"
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/qt7playersession.h b/src/plugins/mediaservices/qt7/mediaplayer/qt7playersession.h
new file mode 100644
index 0000000..0ba3041
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/qt7playersession.h
@@ -0,0 +1,151 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7PLAYERSESSION_H
+#define QT7PLAYERSESSION_H
+
+#include <QtCore/qobject.h>
+#include <QtGui/qmacdefines_mac.h>
+
+#include <QtMultimedia/qmediaplayercontrol.h>
+#include <QtMultimedia/qmediaplayer.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QT7PlayerControl;
+class QMediaPlaylist;
+class QMediaPlaylistNavigator;
+class QT7VideoOutput;
+class QT7PlayerSession;
+class QT7PlayerService;
+
+class QT7PlayerSession : public QObject
+{
+Q_OBJECT
+public:
+    QT7PlayerSession(QObject *parent = 0);
+    ~QT7PlayerSession();
+
+    void *movie() const;
+
+    void setControl(QT7PlayerControl *control);
+    void setVideoOutput(QT7VideoOutput *output);
+
+    QMediaPlayer::State state() const;
+    QMediaPlayer::MediaStatus mediaStatus() const;
+
+    QMediaContent media() const;
+    const QIODevice *mediaStream() const;
+    void setMedia(const QMediaContent &content, QIODevice *stream);
+
+    qint64 position() const;
+    qint64 duration() const;
+
+    int bufferStatus() const;
+
+    int volume() const;
+    bool isMuted() const;
+
+    bool isAudioAvailable() const;
+    bool isVideoAvailable() const;
+
+    bool isSeekable() const;
+
+    qreal playbackRate() const;
+
+public slots:
+    void setPlaybackRate(qreal rate);
+
+    void setPosition(qint64 pos);
+
+    void play();
+    void pause();
+    void stop();
+
+    void setVolume(int volume);
+    void setMuted(bool muted);
+
+    void processEOS();
+    void processLoadStateChange();
+    void processVolumeChange();
+    void processNaturalSizeChange();
+
+signals:
+    void positionChanged(qint64 position);
+    void durationChanged(qint64 duration);
+    void stateChanged(QMediaPlayer::State newState);
+    void mediaStatusChanged(QMediaPlayer::MediaStatus status);
+    void volumeChanged(int volume);
+    void mutedChanged(bool muted);
+    void audioAvailableChanged(bool audioAvailable);
+    void videoAvailableChanged(bool videoAvailable);
+    void error(int error, const QString &errorString);
+
+private:
+    void *m_QTMovie;
+    void *m_movieObserver;
+
+    QMediaPlayer::State m_state;
+    QMediaPlayer::MediaStatus m_mediaStatus;
+    QIODevice *m_mediaStream;
+    QMediaContent m_resources;
+
+    QT7VideoOutput *m_videoOutput;
+
+    mutable qint64 m_currentTime;
+
+    bool m_muted;
+    int m_volume;
+    qreal m_rate;
+
+    qint64 m_duration;
+    bool m_videoAvailable;
+    bool m_audioAvailable;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/mediaplayer/qt7playersession.mm b/src/plugins/mediaservices/qt7/mediaplayer/qt7playersession.mm
new file mode 100644
index 0000000..65c9f7d
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/mediaplayer/qt7playersession.mm
@@ -0,0 +1,553 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#import <QTKit/QTDataReference.h>
+#import <QTKit/QTMovie.h>
+
+#include "qt7backend.h"
+
+#include "qt7playersession.h"
+#include "qt7playercontrol.h"
+#include "qt7videooutputcontrol.h"
+
+#include <QtNetwork/qnetworkcookie.h>
+#include <QtMultimedia/qmediaplaylistnavigator.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <Foundation/Foundation.h>
+
+#include <QtCore/qdatetime.h>
+#include <QtCore/qurl.h>
+#include <QtCore/qdebug.h>
+
+@interface QTMovieObserver : NSObject
+{
+@private
+    QT7PlayerSession *m_session;
+    QTMovie *m_movie;
+}
+
+- (QTMovieObserver *) initWithPlayerSession:(QT7PlayerSession*)session;
+- (void) setMovie:(QTMovie *)movie;
+- (void) processEOS:(NSNotification *)notification;
+- (void) processLoadStateChange:(NSNotification *)notification;
+- (void) processVolumeChange:(NSNotification *)notification;
+- (void) processNaturalSizeChange :(NSNotification *)notification;
+@end
+
+@implementation QTMovieObserver
+
+- (QTMovieObserver *) initWithPlayerSession:(QT7PlayerSession*)session
+{
+    if (!(self = [super init]))
+        return nil;
+
+    self->m_session = session;
+    return self;
+}
+
+- (void) setMovie:(QTMovie *)movie
+{
+    if (m_movie == movie)
+        return;
+
+    if (m_movie) {
+        [[NSNotificationCenter defaultCenter] removeObserver:self];
+        [m_movie release];
+    }
+
+    m_movie = movie;
+
+    if (movie) {
+        [[NSNotificationCenter defaultCenter] addObserver:self 
+                                                 selector:@selector(processEOS:) 
+                                                     name:QTMovieDidEndNotification
+                                                   object:m_movie];
+
+        [[NSNotificationCenter defaultCenter] addObserver:self
+                                                 selector:@selector(processLoadStateChange:)
+                                                     name:QTMovieLoadStateDidChangeNotification 
+                                                   object:m_movie];
+
+        [[NSNotificationCenter defaultCenter] addObserver:self 
+                                                 selector:@selector(processVolumeChange:) 
+                                                     name:QTMovieVolumeDidChangeNotification 
+                                                   object:m_movie];
+
+        [[NSNotificationCenter defaultCenter] addObserver:self 
+                                                 selector:@selector(processNaturalSizeChange:)
+                                                     name: 
+#if defined(MAC_OS_X_VERSION_10_6) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_6)
+                                                          QTMovieNaturalSizeDidChangeNotification
+#else
+                                                          QTMovieEditedNotification
+#endif
+                                                   object:m_movie];
+        [movie retain];
+    }
+}
+
+- (void) processEOS:(NSNotification *)notification
+{
+    Q_UNUSED(notification);
+    QMetaObject::invokeMethod(m_session, "processEOS", Qt::AutoConnection);
+}
+
+- (void) processLoadStateChange:(NSNotification *)notification
+{
+    Q_UNUSED(notification);
+    QMetaObject::invokeMethod(m_session, "processLoadStateChange", Qt::AutoConnection);
+}
+
+- (void) processVolumeChange:(NSNotification *)notification
+{
+    Q_UNUSED(notification);
+    QMetaObject::invokeMethod(m_session, "processVolumeChange", Qt::AutoConnection);
+}
+
+- (void) processNaturalSizeChange :(NSNotification *)notification
+{
+    Q_UNUSED(notification);
+    QMetaObject::invokeMethod(m_session, "processNaturalSizeChange", Qt::AutoConnection);
+}
+
+@end
+
+QT_BEGIN_NAMESPACE
+
+static CFStringRef qString2CFStringRef(const QString &string)
+{
+    return CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar *>(string.unicode()),
+                                        string.length());
+}
+
+QT7PlayerSession::QT7PlayerSession(QObject *parent)
+   : QObject(parent)
+   , m_QTMovie(0)
+   , m_state(QMediaPlayer::StoppedState)
+   , m_mediaStatus(QMediaPlayer::NoMedia)
+   , m_mediaStream(0)
+   , m_videoOutput(0)
+   , m_muted(false)
+   , m_volume(100)
+   , m_rate(1.0)
+   , m_duration(0)
+   , m_videoAvailable(false)
+   , m_audioAvailable(false)
+{
+    m_movieObserver = [[QTMovieObserver alloc] initWithPlayerSession:this];
+}
+
+QT7PlayerSession::~QT7PlayerSession()
+{
+    [(QTMovieObserver*)m_movieObserver setMovie:nil];
+    [(QTMovieObserver*)m_movieObserver release];
+    [(QTMovie*)m_QTMovie release];
+}
+
+void *QT7PlayerSession::movie() const
+{
+    return m_QTMovie;
+}
+
+void QT7PlayerSession::setVideoOutput(QT7VideoOutput *output)
+{
+    if (m_videoOutput == output)
+        return;
+
+    if (m_videoOutput)
+        m_videoOutput->setMovie(0);
+
+    m_videoOutput = output;
+
+    if (m_videoOutput && m_state != QMediaPlayer::StoppedState)
+        m_videoOutput->setMovie(m_QTMovie);
+}
+
+
+qint64 QT7PlayerSession::position() const
+{
+    if (!m_QTMovie || m_state == QMediaPlayer::PausedState)
+        return m_currentTime;
+
+    AutoReleasePool pool;
+
+    QTTime qtTime = [(QTMovie*)m_QTMovie currentTime];
+    quint64 t = static_cast<quint64>(float(qtTime.timeValue) / float(qtTime.timeScale) * 1000.0f);
+    m_currentTime = t;
+
+    return m_currentTime;
+}
+
+qint64 QT7PlayerSession::duration() const
+{
+    if (!m_QTMovie)
+        return 0;
+
+    AutoReleasePool pool;
+
+    QTTime qtTime = [(QTMovie*)m_QTMovie duration];
+
+    return static_cast<quint64>(float(qtTime.timeValue) / float(qtTime.timeScale) * 1000.0f);
+}
+
+QMediaPlayer::State QT7PlayerSession::state() const
+{
+    return m_state;
+}
+
+QMediaPlayer::MediaStatus QT7PlayerSession::mediaStatus() const
+{
+    return m_mediaStatus;
+}
+
+int QT7PlayerSession::bufferStatus() const
+{
+    return 100;
+}
+
+int QT7PlayerSession::volume() const
+{
+    return m_volume;
+}
+
+bool QT7PlayerSession::isMuted() const
+{
+    return m_muted;
+}
+
+bool QT7PlayerSession::isSeekable() const
+{
+    return true;
+}
+
+qreal QT7PlayerSession::playbackRate() const
+{
+    return m_rate;
+}
+
+void QT7PlayerSession::setPlaybackRate(qreal rate)
+{
+    if (qFuzzyCompare(m_rate, rate))
+        return;
+
+    m_rate = rate;
+
+    if (m_QTMovie && m_state == QMediaPlayer::PlayingState) {        
+        float preferredRate = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMoviePreferredRateAttribute"] floatValue];
+        [(QTMovie*)m_QTMovie setRate:preferredRate*m_rate];
+    }
+}
+
+void QT7PlayerSession::setPosition(qint64 pos)
+{
+    if ( !isSeekable() || pos == position())
+        return;
+
+    AutoReleasePool pool;
+
+    pos = qMin(pos, duration());
+
+    QTTime newQTTime = [(QTMovie*)m_QTMovie currentTime];
+    newQTTime.timeValue = (pos / 1000.0f) * newQTTime.timeScale;
+    [(QTMovie*)m_QTMovie setCurrentTime:newQTTime];
+}
+
+void QT7PlayerSession::play()
+{
+    if (m_videoOutput)
+        m_videoOutput->setMovie(m_QTMovie);
+
+    float preferredRate = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMoviePreferredRateAttribute"] floatValue];
+    [(QTMovie*)m_QTMovie setRate:preferredRate*m_rate];
+
+    if (m_state != QMediaPlayer::PlayingState)
+        emit stateChanged(m_state = QMediaPlayer::PlayingState);
+}
+
+void QT7PlayerSession::pause()
+{
+    if (m_videoOutput)
+        m_videoOutput->setMovie(m_QTMovie);
+
+    m_state = QMediaPlayer::PausedState;
+
+    [(QTMovie*)m_QTMovie setRate:0];
+
+    emit stateChanged(m_state);
+}
+
+void QT7PlayerSession::stop()
+{
+    m_state = QMediaPlayer::StoppedState;
+
+    [(QTMovie*)m_QTMovie setRate:0];
+    setPosition(0);
+
+    if (m_videoOutput)
+        m_videoOutput->setMovie(0);
+
+    if (m_state == QMediaPlayer::StoppedState)
+        emit stateChanged(m_state);
+}
+
+void QT7PlayerSession::setVolume(int volume)
+{
+    if (m_QTMovie) {
+        m_volume = volume;
+        [(QTMovie*)m_QTMovie setVolume:(volume/100.0f)];
+    }
+}
+
+void QT7PlayerSession::setMuted(bool muted)
+{
+    if (m_muted != muted) {
+        m_muted = muted;
+
+        if (m_QTMovie)
+            [(QTMovie*)m_QTMovie setMuted:m_muted];
+
+        emit mutedChanged(muted);
+    }
+}
+
+QMediaContent QT7PlayerSession::media() const
+{
+    return m_resources;
+}
+
+const QIODevice *QT7PlayerSession::mediaStream() const
+{
+    return m_mediaStream;
+}
+
+void QT7PlayerSession::setMedia(const QMediaContent &content, QIODevice *stream)
+{
+    AutoReleasePool pool;
+
+    if (m_QTMovie) {
+        [(QTMovieObserver*)m_movieObserver setMovie:nil];
+
+        if (m_videoOutput)
+            m_videoOutput->setMovie(0);
+
+        [(QTMovie*)m_QTMovie release];
+        m_QTMovie = 0;
+    }
+
+    m_resources = content;
+    m_mediaStream = stream;
+    m_mediaStatus = QMediaPlayer::NoMedia;
+
+    QNetworkRequest request;
+
+    if (!content.isNull())
+        request = content.canonicalResource().request();
+    else
+        return;
+
+    QVariant cookies = request.header(QNetworkRequest::CookieHeader);
+    if (cookies.isValid()) {
+        NSHTTPCookieStorage *store = [NSHTTPCookieStorage sharedHTTPCookieStorage];
+        QList<QNetworkCookie> cookieList = cookies.value<QList<QNetworkCookie> >();
+
+        foreach (const QNetworkCookie &requestCookie, cookieList) {
+            NSMutableDictionary *p = [NSMutableDictionary dictionaryWithObjectsAndKeys:
+                               (NSString*)qString2CFStringRef(requestCookie.name()), NSHTTPCookieName,
+                               (NSString*)qString2CFStringRef(requestCookie.value()), NSHTTPCookieValue,
+                               (NSString*)qString2CFStringRef(requestCookie.domain()), NSHTTPCookieDomain,
+                               (NSString*)qString2CFStringRef(requestCookie.path()), NSHTTPCookiePath,
+                               nil
+                               ];
+            if (requestCookie.isSessionCookie())
+                [p setObject:[NSString stringWithUTF8String:"TRUE"] forKey:NSHTTPCookieDiscard];
+            else
+                [p setObject:[NSDate dateWithTimeIntervalSince1970:requestCookie.expirationDate().toTime_t()] forKey:NSHTTPCookieExpires];
+
+            [store setCookie:[NSHTTPCookie cookieWithProperties:p]];
+        }
+    }
+
+    NSError *err = 0;
+    NSString *urlString = (NSString *)qString2CFStringRef(request.url().toString());
+
+    NSDictionary *attr = [NSDictionary dictionaryWithObjectsAndKeys:
+                            [NSURL URLWithString:urlString], QTMovieURLAttribute,
+                            [NSNumber numberWithBool:YES], QTMovieOpenAsyncOKAttribute,
+                            [NSNumber numberWithBool:YES], QTMovieIsActiveAttribute,
+                            [NSNumber numberWithBool:YES], QTMovieResolveDataRefsAttribute,
+                            [NSNumber numberWithBool:YES], QTMovieDontInteractWithUserAttribute,
+                            nil];
+
+    m_QTMovie = [[QTMovie movieWithAttributes:attr error:&err] retain];
+
+    if (err) {
+        [(QTMovie*)m_QTMovie release];
+        m_QTMovie = 0;
+        QString description = QString::fromUtf8([[err localizedDescription] UTF8String]);
+
+        emit error(QMediaPlayer::FormatError, description );
+    } else {
+        [(QTMovieObserver*)m_movieObserver setMovie:(QTMovie*)m_QTMovie];
+
+        if (m_videoOutput && m_state != QMediaPlayer::StoppedState)
+            m_videoOutput->setMovie(m_QTMovie);
+
+        processLoadStateChange();
+
+        [(QTMovie*)m_QTMovie setMuted:m_muted];
+        setVolume(m_volume);
+    }
+}
+
+bool QT7PlayerSession::isAudioAvailable() const
+{
+    if (!m_QTMovie)
+        return false;
+
+    AutoReleasePool pool;
+    return [[(QTMovie*)m_QTMovie attributeForKey:@"QTMovieHasAudioAttribute"] boolValue] == YES;
+}
+
+bool QT7PlayerSession::isVideoAvailable() const
+{
+    if (!m_QTMovie)
+        return false;
+
+    AutoReleasePool pool;
+    return [[(QTMovie*)m_QTMovie attributeForKey:@"QTMovieHasVideoAttribute"] boolValue] == YES;
+}
+
+void QT7PlayerSession::processEOS()
+{    
+    m_mediaStatus = QMediaPlayer::EndOfMedia;
+    if (m_videoOutput)
+        m_videoOutput->setMovie(0);
+    emit stateChanged(m_state = QMediaPlayer::StoppedState);
+    emit mediaStatusChanged(m_mediaStatus);
+}
+
+void QT7PlayerSession::processLoadStateChange()
+{
+    if (!m_QTMovie)
+        return;
+
+    signed long state = [[(QTMovie*)m_QTMovie attributeForKey:QTMovieLoadStateAttribute]
+                         longValue];
+//    qDebug() << "Moview load state changed:" << state;
+
+#ifndef QUICKTIME_C_API_AVAILABLE
+    enum {
+      kMovieLoadStateError          = -1L,
+      kMovieLoadStateLoading        = 1000,
+      kMovieLoadStateLoaded         = 2000,
+      kMovieLoadStatePlayable       = 10000,
+      kMovieLoadStatePlaythroughOK  = 20000,
+      kMovieLoadStateComplete       = 100000
+    };
+#endif
+
+    QMediaPlayer::MediaStatus newStatus = QMediaPlayer::NoMedia;
+    bool isPlaying = (m_state != QMediaPlayer::StoppedState);
+
+    if (state >= kMovieLoadStateComplete) {
+        newStatus = isPlaying ? QMediaPlayer::BufferedMedia : QMediaPlayer::LoadedMedia;
+    } else if (state >= kMovieLoadStatePlayable)
+        newStatus = isPlaying ? QMediaPlayer::BufferingMedia : QMediaPlayer::LoadingMedia;
+    else if (state >= kMovieLoadStateLoading)
+        newStatus = isPlaying ? QMediaPlayer::StalledMedia : QMediaPlayer::LoadingMedia;
+
+    if (state == kMovieLoadStateError) {
+        newStatus = QMediaPlayer::InvalidMedia;
+        if (m_videoOutput)
+            m_videoOutput->setMovie(0);
+
+        emit error(QMediaPlayer::FormatError, tr("Failed to load media"));
+        emit stateChanged(m_state = QMediaPlayer::StoppedState);
+    }
+
+    if (state >= kMovieLoadStatePlayable &&
+        m_state == QMediaPlayer::PlayingState &&
+        [(QTMovie*)m_QTMovie rate] == 0) {
+            QMetaObject::invokeMethod(this, "play", Qt::QueuedConnection);
+    }
+
+    if (state >= kMovieLoadStateLoaded) {
+        qint64 currentDuration = duration();
+        if (m_duration != currentDuration)
+            emit durationChanged(m_duration = currentDuration);
+
+        if (m_audioAvailable != isAudioAvailable())
+            emit audioAvailableChanged(m_audioAvailable = !m_audioAvailable);
+
+        if (m_videoAvailable != isVideoAvailable())
+            emit videoAvailableChanged(m_videoAvailable = !m_videoAvailable);
+    }
+
+    if (newStatus != m_mediaStatus)
+        emit mediaStatusChanged(m_mediaStatus = newStatus);
+}
+
+void QT7PlayerSession::processVolumeChange()
+{
+    if (!m_QTMovie)
+        return;
+
+    int newVolume = qRound(100.0f*[((QTMovie*)m_QTMovie) volume]);
+
+    if (newVolume != m_volume) {
+        emit volumeChanged(m_volume = newVolume);
+    }
+}
+
+void QT7PlayerSession::processNaturalSizeChange()
+{
+    if (m_videoOutput) {
+        NSSize size = [[(QTMovie*)m_QTMovie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
+//        qDebug() << "Native size changed:" << QSize(size.width, size.height);
+        m_videoOutput->updateNaturalSize(QSize(size.width, size.height));
+    }
+}
+
+#include "moc_qt7playersession.cpp"
+
+QT_END_NAMESPACE
+
diff --git a/src/plugins/mediaservices/qt7/qcvdisplaylink.h b/src/plugins/mediaservices/qt7/qcvdisplaylink.h
new file mode 100644
index 0000000..5cd8f73
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qcvdisplaylink.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QCVDISPLAYLINK_H
+#define QCVDISPLAYLINK_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qmutex.h>
+
+#include <CoreVideo/CVDisplayLink.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QCvDisplayLink : public QObject
+{
+Q_OBJECT
+public:
+    QCvDisplayLink(QObject *parent = 0);
+    virtual ~QCvDisplayLink();
+
+    bool isValid();
+    bool isActive() const;
+
+public slots:
+    void start();
+    void stop();
+
+signals:
+    void tick(const CVTimeStamp &ts);
+
+public:
+    void displayLinkEvent(const CVTimeStamp *);
+
+protected:
+    virtual bool event(QEvent *);
+    
+private:
+    CVDisplayLinkRef m_displayLink;
+    QMutex m_displayLinkMutex;
+    bool m_pendingDisplayLinkEvent;
+    bool m_isActive;
+    CVTimeStamp m_frameTimeStamp;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
+
diff --git a/src/plugins/mediaservices/qt7/qcvdisplaylink.mm b/src/plugins/mediaservices/qt7/qcvdisplaylink.mm
new file mode 100644
index 0000000..00b4dc5
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qcvdisplaylink.mm
@@ -0,0 +1,158 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qcvdisplaylink.h"
+
+#include <QtCore/qcoreapplication.h>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+static CVReturn CVDisplayLinkCallback(CVDisplayLinkRef displayLink,
+                                 const CVTimeStamp *inNow,
+                                 const CVTimeStamp *inOutputTime,
+                                 CVOptionFlags flagsIn,
+                                 CVOptionFlags *flagsOut,
+                                 void *displayLinkContext)
+{
+    Q_UNUSED(displayLink);
+    Q_UNUSED(inNow);
+    Q_UNUSED(flagsIn);
+    Q_UNUSED(flagsOut);
+
+    QCvDisplayLink *link = (QCvDisplayLink *)displayLinkContext;
+
+    link->displayLinkEvent(inOutputTime);
+    return kCVReturnSuccess;
+}
+
+
+QCvDisplayLink::QCvDisplayLink(QObject *parent)
+    :QObject(parent),
+    m_pendingDisplayLinkEvent(false),
+    m_isActive(false)
+{
+    // create display link for the main display
+    CVDisplayLinkCreateWithCGDisplay(kCGDirectMainDisplay, &m_displayLink);
+    if (m_displayLink) {
+        // set the current display of a display link.
+        CVDisplayLinkSetCurrentCGDisplay(m_displayLink, kCGDirectMainDisplay);
+
+        // set the renderer output callback function
+        CVDisplayLinkSetOutputCallback(m_displayLink, &CVDisplayLinkCallback, this);
+    }
+}
+
+QCvDisplayLink::~QCvDisplayLink()
+{
+    if (m_displayLink) {
+        CVDisplayLinkStop(m_displayLink);
+        CVDisplayLinkRelease(m_displayLink);
+        m_displayLink = NULL;
+    }
+}
+
+bool QCvDisplayLink::isValid()
+{
+    return m_displayLink != 0;
+}
+
+bool QCvDisplayLink::isActive() const
+{
+    return m_isActive;
+}
+
+void QCvDisplayLink::start()
+{
+     if (m_displayLink && !m_isActive) {
+        CVDisplayLinkStart(m_displayLink);
+        m_isActive = true;
+     }
+}
+
+void QCvDisplayLink::stop()
+{
+    if (m_displayLink && m_isActive) {
+        CVDisplayLinkStop(m_displayLink);
+        m_isActive = false;
+    }
+}
+
+void QCvDisplayLink::displayLinkEvent(const CVTimeStamp *ts)
+{
+    // This function is called from a
+    // thread != gui thread. So we post the event.
+    // But we need to make sure that we don't post faster
+    // than the event loop can eat:
+    m_displayLinkMutex.lock();
+    bool pending = m_pendingDisplayLinkEvent;
+    m_pendingDisplayLinkEvent = true;
+    m_frameTimeStamp = *ts;
+    m_displayLinkMutex.unlock();
+
+    if (!pending)
+        qApp->postEvent(this, new QEvent(QEvent::User), Qt::HighEventPriority);
+}
+
+bool QCvDisplayLink::event(QEvent *event)
+{
+    switch (event->type()){
+        case QEvent::User:  {
+                m_displayLinkMutex.lock();
+                m_pendingDisplayLinkEvent = false;
+                CVTimeStamp ts = m_frameTimeStamp;
+                m_displayLinkMutex.unlock();
+
+                emit tick(ts);
+
+                return false;
+            }
+            break;
+        default:
+            break;
+    }
+    return QObject::event(event);
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qcvdisplaylink.cpp"
+
diff --git a/src/plugins/mediaservices/qt7/qt7.pro b/src/plugins/mediaservices/qt7/qt7.pro
new file mode 100644
index 0000000..8791d73
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7.pro
@@ -0,0 +1,47 @@
+TARGET = qt7
+include(../../qpluginbase.pri)
+
+QT += opengl multimedia
+
+LIBS += -framework AppKit -framework AudioUnit \
+        -framework AudioToolbox -framework CoreAudio \
+        -framework QuartzCore -framework QTKit
+
+# The Quicktime framework is only awailable for 32-bit builds, so we
+# need to check for this before linking against it.
+# QMAKE_MAC_XARCH is not awailable on Tiger, but at the same time,
+# we never build for 64-bit architechtures on Tiger either:
+contains(QMAKE_MAC_XARCH, no) {
+    LIBS += -framework QuickTime
+} else {
+    LIBS += -Xarch_i386 -framework QuickTime -Xarch_ppc -framework QuickTime
+}
+
+HEADERS += \
+    qt7backend.h \
+    qt7videooutputcontrol.h \
+    qt7movieviewoutput.h \
+    qt7movievideowidget.h \
+    qt7movieviewrenderer.h \
+    qt7serviceplugin.h \
+    qt7movierenderer.h \
+    qt7ciimagevideobuffer.h \
+    qcvdisplaylink.h
+
+OBJECTIVE_SOURCES += \
+    qt7backend.mm \
+    qt7serviceplugin.mm \
+    qt7movieviewoutput.mm \
+    qt7movievideowidget.mm \
+    qt7movieviewrenderer.mm \
+    qt7movierenderer.mm \
+    qt7videooutputcontrol.mm \
+    qt7ciimagevideobuffer.mm \
+    qcvdisplaylink.mm
+
+include(mediaplayer/mediaplayer.pri)
+
+QTDIR_build:DESTDIR = $$QT_BUILD_TREE/plugins/mediaservices
+target.path = $$[QT_INSTALL_PLUGINS]/mediaservices
+INSTALLS += target
+
diff --git a/src/plugins/mediaservices/qt7/qt7backend.h b/src/plugins/mediaservices/qt7/qt7backend.h
new file mode 100644
index 0000000..5668965
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7backend.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7BACKEND_H
+#define QT7BACKEND_H
+
+#include <QtCore/qstring.h>
+
+#ifndef Q_WS_MAC64
+#define QUICKTIME_C_API_AVAILABLE
+#endif
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class AutoReleasePool
+{
+private:
+    void *pool;
+public:
+    AutoReleasePool();
+    ~AutoReleasePool();
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/qt7backend.mm b/src/plugins/mediaservices/qt7/qt7backend.mm
new file mode 100644
index 0000000..478589b
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7backend.mm
@@ -0,0 +1,60 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qt7backend.h"
+
+#import <Foundation/NSAutoreleasePool.h>
+#include <CoreFoundation/CFBase.h>
+
+
+QT_BEGIN_NAMESPACE
+
+AutoReleasePool::AutoReleasePool()
+{
+    pool = (void*)[[NSAutoreleasePool alloc] init];
+}
+
+AutoReleasePool::~AutoReleasePool()
+{
+    [(NSAutoreleasePool*)pool release];
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/qt7/qt7ciimagevideobuffer.h b/src/plugins/mediaservices/qt7/qt7ciimagevideobuffer.h
new file mode 100644
index 0000000..669724f
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7ciimagevideobuffer.h
@@ -0,0 +1,90 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7CIIMAGEVIDEOBUFFER_H
+#define QT7CIIMAGEVIDEOBUFFER_H
+
+#include "qt7backend.h"
+#import <QTKit/QTKit.h>
+
+#include <QtCore/qvariant.h>
+#include <QtMultimedia/qabstractvideobuffer.h>
+
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API. It exists purely as an
+// implementation detail. This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QT7CIImageVideoBuffer : public QAbstractVideoBuffer
+{
+public:
+    QT7CIImageVideoBuffer(CIImage *image);
+
+    virtual ~QT7CIImageVideoBuffer();
+
+    MapMode mapMode() const;
+    uchar *map(MapMode mode, int *numBytes, int *bytesPerLine);
+    void unmap();
+    QVariant handle() const;
+
+private:
+    CIImage *m_image;
+    NSBitmapImageRep *m_buffer;
+    MapMode m_mode;
+};
+
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/qt7ciimagevideobuffer.mm b/src/plugins/mediaservices/qt7/qt7ciimagevideobuffer.mm
new file mode 100644
index 0000000..3778b58
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7ciimagevideobuffer.mm
@@ -0,0 +1,104 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qt7ciimagevideobuffer.h"
+
+QT7CIImageVideoBuffer::QT7CIImageVideoBuffer(CIImage *image)
+    : QAbstractVideoBuffer(CoreImageHandle)
+    , m_image(image)
+    , m_buffer(0)
+    , m_mode(NotMapped)
+{
+    [m_image retain];
+}
+
+QT7CIImageVideoBuffer::~QT7CIImageVideoBuffer()
+{
+    [m_image release];
+    [m_buffer release];
+}
+
+QAbstractVideoBuffer::MapMode QT7CIImageVideoBuffer::mapMode() const
+{
+    return m_mode;
+}
+
+uchar *QT7CIImageVideoBuffer::map(QAbstractVideoBuffer::MapMode mode, int *numBytes, int *bytesPerLine)
+{
+    if (mode == NotMapped || m_mode != NotMapped || !m_image)
+        return 0;
+
+    if (!m_buffer) {
+        //swap R and B channels
+        CIFilter *colorSwapFilter = [CIFilter filterWithName: @"CIColorMatrix"  keysAndValues:
+                                     @"inputImage", m_image,
+                                     @"inputRVector", [CIVector vectorWithX: 0  Y: 0  Z: 1  W: 0],
+                                     @"inputGVector", [CIVector vectorWithX: 0  Y: 1  Z: 0  W: 0],
+                                     @"inputBVector", [CIVector vectorWithX: 1  Y: 0  Z: 0  W: 0],
+                                     @"inputAVector", [CIVector vectorWithX: 0  Y: 0  Z: 0  W: 1],
+                                     @"inputBiasVector", [CIVector vectorWithX: 0  Y: 0  Z: 0  W: 0],
+                                     nil];
+        CIImage *img = [colorSwapFilter valueForKey: @"outputImage"];
+
+        m_buffer = [[NSBitmapImageRep alloc] initWithCIImage:img];
+    }
+
+    if (numBytes)
+        *numBytes = [m_buffer bytesPerPlane];
+
+    if (bytesPerLine)
+        *bytesPerLine = [m_buffer bytesPerRow];
+
+    m_mode = mode;
+
+    return [m_buffer bitmapData];
+}
+
+void QT7CIImageVideoBuffer::unmap()
+{
+    m_mode = NotMapped;
+}
+
+QVariant QT7CIImageVideoBuffer::handle() const
+{
+    return QVariant::fromValue<void*>(m_image);
+}
+
diff --git a/src/plugins/mediaservices/qt7/qt7movierenderer.h b/src/plugins/mediaservices/qt7/qt7movierenderer.h
new file mode 100644
index 0000000..c2dd177
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7movierenderer.h
@@ -0,0 +1,112 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7MOVIERENDERER_H
+#define QT7MOVIERENDERER_H
+
+#include "qt7backend.h"
+
+#include <QtCore/qobject.h>
+#include <QtCore/qmutex.h>
+
+#include <qvideorenderercontrol.h>
+#include <qmediaplayer.h>
+
+#include <QtGui/qmacdefines_mac.h>
+#include "qt7videooutputcontrol.h"
+
+#include <CoreVideo/CVOpenGLTexture.h>
+#include <QuickTime/QuickTime.h>
+
+
+QT_BEGIN_HEADER
+
+class QGLContext;
+
+QT_BEGIN_NAMESPACE
+
+class QCvDisplayLink;
+class QT7PlayerSession;
+class QT7PlayerService;
+
+class QT7MovieRenderer : public QT7VideoRendererControl
+{
+Q_OBJECT
+public:
+    QT7MovieRenderer(QObject *parent = 0);
+    virtual ~QT7MovieRenderer();
+
+    void setMovie(void *movie);
+    void updateNaturalSize(const QSize &newSize);
+
+    QAbstractVideoSurface *surface() const;
+    void setSurface(QAbstractVideoSurface *surface);
+
+    QSize nativeSize() const;
+
+private slots:
+    void updateVideoFrame(const CVTimeStamp &ts);
+    
+private:
+    void setupVideoOutput();
+    bool createPixelBufferVisualContext();
+    bool createGLVisualContext();
+
+    void *m_movie;
+
+    QMutex m_mutex;
+
+    QCvDisplayLink *m_displayLink;
+#ifdef QUICKTIME_C_API_AVAILABLE
+    QTVisualContextRef	m_visualContext;
+    bool m_usingGLContext;
+    const QGLContext *m_currentGLContext;
+    QSize m_pixelBufferContextGeometry;
+#endif
+    QAbstractVideoSurface *m_surface;
+    QSize m_nativeSize;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/qt7movierenderer.mm b/src/plugins/mediaservices/qt7/qt7movierenderer.mm
new file mode 100644
index 0000000..95f5d4c
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7movierenderer.mm
@@ -0,0 +1,465 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#import <QTKit/QTKit.h>
+
+#include "qt7backend.h"
+
+#include "qt7playercontrol.h"
+#include "qt7movierenderer.h"
+#include "qt7playersession.h"
+#include "qt7ciimagevideobuffer.h"
+#include "qcvdisplaylink.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qcoreapplication.h>
+
+#include <QGLWidget>
+
+#include <QtMultimedia/qabstractvideobuffer.h>
+#include <QtMultimedia/qabstractvideosurface.h>
+#include <QtMultimedia/qvideosurfaceformat.h>
+
+QT_BEGIN_NAMESPACE
+
+//#define USE_MAIN_MONITOR_COLOR_SPACE 1
+
+class CVGLTextureVideoBuffer : public QAbstractVideoBuffer
+{
+public:
+    CVGLTextureVideoBuffer(CVOpenGLTextureRef buffer)
+        : QAbstractVideoBuffer(GLTextureHandle)
+        , m_buffer(buffer)
+        , m_mode(NotMapped)
+    {        
+        CVOpenGLTextureRetain(m_buffer);
+    }
+
+    virtual ~CVGLTextureVideoBuffer()
+    {
+        CVOpenGLTextureRelease(m_buffer);
+    }
+
+    QVariant handle() const
+    {
+        GLuint id = CVOpenGLTextureGetName(m_buffer);
+        return QVariant(int(id));
+    }
+
+    MapMode mapMode() const { return m_mode; }
+
+    uchar *map(MapMode mode, int *numBytes, int *bytesPerLine)
+    {
+        if (numBytes)
+            *numBytes = 0;
+
+        if (bytesPerLine)
+            *bytesPerLine = 0;
+
+        m_mode = mode;
+        return 0;
+    }
+
+    void unmap() { m_mode = NotMapped; }
+
+private:
+    CVOpenGLTextureRef m_buffer;
+    MapMode m_mode;
+};
+
+
+class CVPixelBufferVideoBuffer : public QAbstractVideoBuffer
+{
+public:
+    CVPixelBufferVideoBuffer(CVPixelBufferRef buffer)
+        : QAbstractVideoBuffer(NoHandle)
+        , m_buffer(buffer)
+        , m_mode(NotMapped)
+    {
+        CVPixelBufferRetain(m_buffer);
+    }
+
+    virtual ~CVPixelBufferVideoBuffer()
+    {
+        CVPixelBufferRelease(m_buffer);
+    }
+
+    MapMode mapMode() const { return m_mode; }
+
+    uchar *map(MapMode mode, int *numBytes, int *bytesPerLine)
+    {
+        if (mode != NotMapped && m_mode == NotMapped) {
+            CVPixelBufferLockBaseAddress(m_buffer, 0);
+
+            if (numBytes)
+                *numBytes = CVPixelBufferGetDataSize(m_buffer);
+
+            if (bytesPerLine)
+                *bytesPerLine = CVPixelBufferGetBytesPerRow(m_buffer);
+
+            m_mode = mode;
+
+            return (uchar*)CVPixelBufferGetBaseAddress(m_buffer);
+        } else {
+            return 0;
+        }
+    }
+
+    void unmap()
+    {
+        if (m_mode != NotMapped) {
+            m_mode = NotMapped;
+            CVPixelBufferUnlockBaseAddress(m_buffer, 0);
+        }
+    }
+
+private:
+    CVPixelBufferRef m_buffer;
+    MapMode m_mode;
+};
+
+
+
+QT7MovieRenderer::QT7MovieRenderer(QObject *parent)
+   :QT7VideoRendererControl(parent),
+    m_movie(0),
+#ifdef QUICKTIME_C_API_AVAILABLE
+    m_visualContext(0),
+    m_usingGLContext(false),
+    m_currentGLContext(0),
+#endif
+    m_surface(0)
+{
+//    qDebug() << "QT7MovieRenderer";
+
+    m_displayLink = new QCvDisplayLink(this);
+    connect(m_displayLink, SIGNAL(tick(CVTimeStamp)), SLOT(updateVideoFrame(CVTimeStamp)));
+}
+
+
+bool QT7MovieRenderer::createGLVisualContext()
+{
+#ifdef QUICKTIME_C_API_AVAILABLE
+    AutoReleasePool pool;
+    CGLContextObj cglContext = CGLGetCurrentContext();
+    NSOpenGLPixelFormat *nsglPixelFormat = [NSOpenGLView defaultPixelFormat];
+    CGLPixelFormatObj cglPixelFormat = static_cast<CGLPixelFormatObj>([nsglPixelFormat CGLPixelFormatObj]);
+
+    OSStatus err = QTOpenGLTextureContextCreate(kCFAllocatorDefault, cglContext,
+                                                cglPixelFormat, NULL, &m_visualContext);
+    if (err != noErr)
+        qWarning() << "Could not create visual context (OpenGL)";
+
+    return (err == noErr);
+#endif // QUICKTIME_C_API_AVAILABLE
+
+    return false;
+}
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+static bool DictionarySetValue(CFMutableDictionaryRef dict, CFStringRef key, SInt32 value)
+{
+    CFNumberRef  number    = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &value);
+
+    if (number) {
+        CFDictionarySetValue( dict, key, number );
+        CFRelease( number );
+        return true;
+    }
+    return false;
+}
+#endif // QUICKTIME_C_API_AVAILABLE
+
+bool QT7MovieRenderer::createPixelBufferVisualContext()
+{
+#ifdef QUICKTIME_C_API_AVAILABLE
+    if (m_visualContext) {
+        QTVisualContextRelease(m_visualContext);
+        m_visualContext = 0;
+    }
+
+    m_pixelBufferContextGeometry = m_nativeSize;
+
+    CFMutableDictionaryRef  pixelBufferOptions = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                                                           &kCFTypeDictionaryKeyCallBacks,
+                                                                           &kCFTypeDictionaryValueCallBacks);
+    //DictionarySetValue(pixelBufferOptions, kCVPixelBufferPixelFormatTypeKey, k32ARGBPixelFormat );
+    DictionarySetValue(pixelBufferOptions, kCVPixelBufferPixelFormatTypeKey, k32BGRAPixelFormat );
+    DictionarySetValue(pixelBufferOptions, kCVPixelBufferWidthKey, m_nativeSize.width() );
+    DictionarySetValue(pixelBufferOptions, kCVPixelBufferHeightKey, m_nativeSize.height() );
+    DictionarySetValue(pixelBufferOptions, kCVPixelBufferBytesPerRowAlignmentKey, 16);
+    //CFDictionarySetValue(pixelBufferOptions, kCVPixelBufferOpenGLCompatibilityKey, kCFBooleanTrue);
+
+    CFMutableDictionaryRef  visualContextOptions = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                                                             &kCFTypeDictionaryKeyCallBacks,
+                                                                             &kCFTypeDictionaryValueCallBacks);
+    CFDictionarySetValue(visualContextOptions, kQTVisualContextPixelBufferAttributesKey, pixelBufferOptions);
+
+    CGColorSpaceRef colorSpace = NULL;
+
+#if USE_MAIN_MONITOR_COLOR_SPACE
+    CMProfileRef sysprof = NULL;
+
+    // Get the Systems Profile for the main display
+    if (CMGetSystemProfile(&sysprof) == noErr) {
+        // Create a colorspace with the systems profile
+        colorSpace = CGColorSpaceCreateWithPlatformColorSpace(sysprof);        
+        CMCloseProfile(sysprof);
+    }
+#endif
+
+    if (!colorSpace)
+        colorSpace = CGColorSpaceCreateDeviceRGB();
+
+    CFDictionarySetValue(visualContextOptions, kQTVisualContextOutputColorSpaceKey, colorSpace);
+
+    OSStatus err = QTPixelBufferContextCreate(kCFAllocatorDefault,
+                                               visualContextOptions,
+                                               &m_visualContext);
+    CFRelease(pixelBufferOptions);
+    CFRelease(visualContextOptions);
+
+    if (err != noErr) {
+        qWarning() << "Could not create visual context (PixelBuffer)";
+        return false;
+    }
+
+    return true;
+#endif // QUICKTIME_C_API_AVAILABLE
+
+    return false;
+}
+
+
+QT7MovieRenderer::~QT7MovieRenderer()
+{
+    m_displayLink->stop();
+}
+
+void QT7MovieRenderer::setupVideoOutput()
+{
+    AutoReleasePool pool;
+
+//    qDebug() << "QT7MovieRenderer::setupVideoOutput" << m_movie;
+
+    if (m_movie == 0 || m_surface == 0) {
+        m_displayLink->stop();
+        return;
+    }
+
+    NSSize size = [[(QTMovie*)m_movie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
+    m_nativeSize = QSize(size.width, size.height);
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+    bool usedGLContext = m_usingGLContext;
+
+    if (!m_nativeSize.isEmpty()) {
+
+        bool glSupported = !m_surface->supportedPixelFormats(QAbstractVideoBuffer::GLTextureHandle).isEmpty();
+
+        //Try rendering using opengl textures first:
+        if (glSupported) {
+            QVideoSurfaceFormat format(m_nativeSize, QVideoFrame::Format_RGB32, QAbstractVideoBuffer::GLTextureHandle);
+
+            if (m_surface->isActive())
+                m_surface->stop();
+
+//            qDebug() << "Starting the surface with format" << format;
+            if (!m_surface->start(format)) {
+//                qDebug() << "failed to start video surface" << m_surface->error();
+                glSupported = false;
+            } else {
+                m_usingGLContext = true;
+            }
+
+        }
+
+        if (!glSupported) {
+            m_usingGLContext = false;
+            QVideoSurfaceFormat format(m_nativeSize, QVideoFrame::Format_RGB32);
+
+            if (m_surface->isActive() && m_surface->surfaceFormat() != format) {
+//                qDebug() << "Surface format was changed, stop the surface.";
+                m_surface->stop();
+            }
+
+            if (!m_surface->isActive()) {
+//                qDebug() << "Starting the surface with format" << format;
+                m_surface->start(format);
+//                if (!m_surface->start(format))
+//                    qDebug() << "failed to start video surface" << m_surface->error();
+            }
+        }
+    }
+
+
+    if (m_visualContext) {
+        //check if the visual context still can be reused
+        if (usedGLContext != m_usingGLContext ||
+            (m_usingGLContext && (m_currentGLContext != QGLContext::currentContext())) ||
+            (!m_usingGLContext && (m_pixelBufferContextGeometry != m_nativeSize))) {
+            QTVisualContextRelease(m_visualContext);
+            m_pixelBufferContextGeometry = QSize();
+            m_visualContext = 0;
+        }
+    }
+
+    if (!m_nativeSize.isEmpty()) {
+        if (!m_visualContext) {
+            if (m_usingGLContext) {
+//                qDebug() << "Building OpenGL visual context" << m_nativeSize;
+                m_currentGLContext = QGLContext::currentContext();
+                if (!createGLVisualContext()) {
+                    qWarning() << "QT7MovieRenderer: failed to create visual context";
+                    return;
+                }
+            } else {
+//                qDebug() << "Building Pixel Buffer visual context" << m_nativeSize;
+                if (!createPixelBufferVisualContext()) {
+                    qWarning() << "QT7MovieRenderer: failed to create visual context";
+                    return;
+                }
+            }
+        }
+
+        // targets a Movie to render into a visual context
+        SetMovieVisualContext([(QTMovie*)m_movie quickTimeMovie], m_visualContext);
+
+        m_displayLink->start();
+    }
+#endif
+
+}
+
+void QT7MovieRenderer::setMovie(void *movie)
+{
+//    qDebug() << "QT7MovieRenderer::setMovie" << movie;
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+    QMutexLocker locker(&m_mutex);
+
+    if (m_movie != movie) {
+        if (m_movie) {
+            //ensure the old movie doesn't hold the visual context, otherwise it can't be reused
+            SetMovieVisualContext([(QTMovie*)m_movie quickTimeMovie], nil);
+            [(QTMovie*)m_movie release];
+        }
+
+        m_movie = movie;
+        [(QTMovie*)m_movie retain];
+
+        setupVideoOutput();
+    }
+#endif
+}
+
+void QT7MovieRenderer::updateNaturalSize(const QSize &newSize)
+{
+    if (m_nativeSize != newSize) {
+        m_nativeSize = newSize;
+        setupVideoOutput();
+    }
+}
+
+QAbstractVideoSurface *QT7MovieRenderer::surface() const
+{
+    return m_surface;
+}
+
+void QT7MovieRenderer::setSurface(QAbstractVideoSurface *surface)
+{
+//    qDebug() << "Set video surface" << surface;
+
+    if (surface == m_surface)
+        return;
+
+    QMutexLocker locker(&m_mutex);
+
+    if (m_surface && m_surface->isActive())
+        m_surface->stop();
+
+    m_surface = surface;
+    setupVideoOutput();
+}
+
+
+QSize QT7MovieRenderer::nativeSize() const
+{
+    return m_nativeSize;
+}
+
+void QT7MovieRenderer::updateVideoFrame(const CVTimeStamp &ts)
+{
+#ifdef QUICKTIME_C_API_AVAILABLE
+
+    QMutexLocker locker(&m_mutex);
+
+    if (m_surface && m_surface->isActive() &&
+        m_visualContext && QTVisualContextIsNewImageAvailable(m_visualContext, &ts)) {
+
+        CVImageBufferRef imageBuffer = NULL;
+
+        OSStatus status = QTVisualContextCopyImageForTime(m_visualContext, NULL, &ts, &imageBuffer);
+
+        if (status == noErr && imageBuffer) {
+            QAbstractVideoBuffer *buffer = 0;
+
+            if (m_usingGLContext) {
+                buffer = new QT7CIImageVideoBuffer([CIImage imageWithCVImageBuffer:imageBuffer]);
+                CVOpenGLTextureRelease((CVOpenGLTextureRef)imageBuffer);
+            } else {
+                buffer = new CVPixelBufferVideoBuffer((CVPixelBufferRef)imageBuffer);
+                //buffer = new QT7CIImageVideoBuffer( [CIImage imageWithCVImageBuffer:imageBuffer] );
+                CVPixelBufferRelease((CVPixelBufferRef)imageBuffer);
+            }
+
+            QVideoFrame frame(buffer, m_nativeSize, QVideoFrame::Format_RGB32);
+            m_surface->present(frame);
+            QTVisualContextTask(m_visualContext);
+        }
+    }
+#else
+    Q_UNUSED(ts);
+#endif
+}
+
+#include "moc_qt7movierenderer.cpp"
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/qt7/qt7movievideowidget.h b/src/plugins/mediaservices/qt7/qt7movievideowidget.h
new file mode 100644
index 0000000..831a18d
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7movievideowidget.h
@@ -0,0 +1,131 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7MOVIEVIDEOWIDGET_H
+#define QT7MOVIEVIDEOWIDGET_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qmutex.h>
+
+#include <qvideowindowcontrol.h>
+#include <qmediaplayer.h>
+
+#include <QtGui/qmacdefines_mac.h>
+#include "qt7videooutputcontrol.h"
+
+#include <CoreVideo/CVOpenGLTexture.h>
+#include <QuickTime/QuickTime.h>
+
+
+QT_BEGIN_HEADER
+
+
+QT_BEGIN_NAMESPACE
+
+class GLVideoWidget;
+class QCvDisplayLink;
+class QT7PlayerSession;
+class QT7PlayerService;
+
+class QT7MovieVideoWidget : public QT7VideoWidgetControl
+{
+Q_OBJECT
+public:
+    QT7MovieVideoWidget(QObject *parent = 0);
+    virtual ~QT7MovieVideoWidget();
+
+    void setMovie(void *movie);
+    void updateNaturalSize(const QSize &newSize);
+
+    QWidget *videoWidget();
+
+    bool isFullScreen() const;
+    void setFullScreen(bool fullScreen);
+
+    QSize nativeSize() const;
+
+    Qt::AspectRatioMode aspectRatioMode() const;
+    void setAspectRatioMode(Qt::AspectRatioMode mode);
+
+    int brightness() const;
+    void setBrightness(int brightness);
+
+    int contrast() const;
+    void setContrast(int contrast);
+
+    int hue() const;
+    void setHue(int hue);
+
+    int saturation() const;
+    void setSaturation(int saturation);
+
+private slots:
+    void updateVideoFrame(const CVTimeStamp &ts);
+    
+private:
+    void setupVideoOutput();
+    bool createVisualContext();
+
+    void updateColors();
+
+    void *m_movie;
+    GLVideoWidget *m_videoWidget;
+
+    QCvDisplayLink *m_displayLink;
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+    QTVisualContextRef	m_visualContext;
+#endif
+
+    bool m_fullscreen;
+    QSize m_nativeSize;
+    Qt::AspectRatioMode m_aspectRatioMode;
+    int m_brightness;
+    int m_contrast;
+    int m_hue;
+    int m_saturation;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/qt7movievideowidget.mm b/src/plugins/mediaservices/qt7/qt7movievideowidget.mm
new file mode 100644
index 0000000..648d6b4
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7movievideowidget.mm
@@ -0,0 +1,425 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#import <QTKit/QTKit.h>
+
+#include "qt7backend.h"
+
+#include "qt7playercontrol.h"
+#include "qt7movievideowidget.h"
+#include "qt7playersession.h"
+#include "qcvdisplaylink.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qcoreapplication.h>
+
+#include <QGLWidget>
+
+#import <QuartzCore/QuartzCore.h>
+
+#include "math.h"
+
+QT_BEGIN_NAMESPACE
+
+class GLVideoWidget : public QGLWidget
+{
+public:
+
+    GLVideoWidget(QWidget *parent, const QGLFormat &format)
+        : QGLWidget(format, parent),
+          m_texRef(0),
+          m_nativeSize(640,480),
+          m_aspectRatioMode(Qt::KeepAspectRatio)
+    {
+        setAutoFillBackground(false);        
+    }
+
+    void initializeGL()
+    {
+        QColor bgColor = palette().color(QPalette::Background);
+        glClearColor(bgColor.redF(), bgColor.greenF(), bgColor.blueF(), bgColor.alphaF());
+    }
+
+    void resizeGL(int w, int h)
+    {
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        glViewport(0, 0, GLsizei(w), GLsizei(h));
+        gluOrtho2D(0, GLsizei(w), 0, GLsizei(h));
+        updateGL();
+    }
+
+    void paintGL()
+    {
+        glClear(GL_COLOR_BUFFER_BIT);
+        if (!m_texRef)
+            return;
+
+        glPushMatrix();
+            glDisable(GL_CULL_FACE);
+            GLenum target = CVOpenGLTextureGetTarget(m_texRef);
+            glEnable(target);
+
+            glBindTexture(target, CVOpenGLTextureGetName(m_texRef));
+            glTexParameterf(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+            glTexParameterf(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+            GLfloat lowerLeft[2], lowerRight[2], upperRight[2], upperLeft[2];
+            CVOpenGLTextureGetCleanTexCoords(m_texRef, lowerLeft, lowerRight, upperRight, upperLeft);
+
+            glBegin(GL_QUADS);
+                QRect rect = displayRect();
+                glTexCoord2f(lowerLeft[0], lowerLeft[1]);
+                glVertex2i(rect.topLeft().x(), rect.topLeft().y());
+                glTexCoord2f(lowerRight[0], lowerRight[1]);
+                glVertex2i(rect.topRight().x() + 1, rect.topRight().y());
+                glTexCoord2f(upperRight[0], upperRight[1]);
+                glVertex2i(rect.bottomRight().x() + 1, rect.bottomRight().y() + 1);
+                glTexCoord2f(upperLeft[0], upperLeft[1]);
+                glVertex2i(rect.bottomLeft().x(), rect.bottomLeft().y() + 1);
+            glEnd();
+        glPopMatrix();
+    }
+
+    void setCVTexture(CVOpenGLTextureRef texRef)
+    {
+        if (m_texRef)
+            CVOpenGLTextureRelease(m_texRef);
+
+        m_texRef = texRef;
+
+        if (m_texRef)
+            CVOpenGLTextureRetain(m_texRef);
+
+        if (isVisible()) {
+            makeCurrent();
+            paintGL();
+            swapBuffers();
+        }
+    }
+
+    QSize sizeHint() const
+    {
+        return m_nativeSize;
+    }
+
+    void setNativeSize(const QSize &size)
+    {
+        m_nativeSize = size;        
+    }
+
+    void setAspectRatioMode(Qt::AspectRatioMode mode)
+    {
+        if (m_aspectRatioMode != mode) {
+            m_aspectRatioMode = mode;
+            update();
+        }
+    }
+
+private:
+    QRect displayRect() const
+    {
+        QRect displayRect = rect();
+
+        if (m_aspectRatioMode == Qt::KeepAspectRatio) {
+            QSize size = m_nativeSize;
+            size.scale(displayRect.size(), Qt::KeepAspectRatio);
+
+            displayRect = QRect(QPoint(0, 0), size);
+            displayRect.moveCenter(rect().center());
+        }
+        return displayRect;
+    }
+
+    CVOpenGLTextureRef m_texRef;
+    QSize m_nativeSize;
+    Qt::AspectRatioMode m_aspectRatioMode;
+};
+
+QT7MovieVideoWidget::QT7MovieVideoWidget(QObject *parent)
+   :QT7VideoWidgetControl(parent),
+    m_movie(0),    
+    m_videoWidget(0),    
+    m_fullscreen(false),
+    m_aspectRatioMode(Qt::KeepAspectRatio),
+    m_brightness(0),
+    m_contrast(0),
+    m_hue(0),
+    m_saturation(0)
+{
+//    qDebug() << "QT7MovieVideoWidget";
+
+    QGLFormat format = QGLFormat::defaultFormat();
+    format.setSwapInterval(1); // Vertical sync (avoid tearing)
+    m_videoWidget = new GLVideoWidget(0, format);
+
+    m_displayLink = new QCvDisplayLink(this);
+
+    connect(m_displayLink, SIGNAL(tick(CVTimeStamp)), SLOT(updateVideoFrame(CVTimeStamp)));
+
+    if (!createVisualContext()) {
+        qWarning() << "QT7MovieVideoWidget: failed to create visual context";
+    }
+}
+
+bool QT7MovieVideoWidget::createVisualContext()
+{
+#ifdef QUICKTIME_C_API_AVAILABLE
+    m_videoWidget->makeCurrent();
+
+    AutoReleasePool pool;
+    CGLContextObj cglContext = CGLGetCurrentContext();
+    NSOpenGLPixelFormat *nsglPixelFormat = [NSOpenGLView defaultPixelFormat];
+    CGLPixelFormatObj cglPixelFormat = static_cast<CGLPixelFormatObj>([nsglPixelFormat CGLPixelFormatObj]);
+
+    CFTypeRef keys[] = { kQTVisualContextOutputColorSpaceKey };
+    CGColorSpaceRef colorSpace = NULL;
+    CMProfileRef sysprof = NULL;
+
+    // Get the Systems Profile for the main display
+    if (CMGetSystemProfile(&sysprof) == noErr) {
+        // Create a colorspace with the systems profile
+        colorSpace = CGColorSpaceCreateWithPlatformColorSpace(sysprof);        
+        CMCloseProfile(sysprof);
+    }
+
+    if (!colorSpace)
+        colorSpace = CGColorSpaceCreateDeviceRGB();
+
+    CFDictionaryRef textureContextAttributes = CFDictionaryCreate(kCFAllocatorDefault,
+                                                                  (const void **)keys,
+                                                                  (const void **)&colorSpace, 1,
+                                                                  &kCFTypeDictionaryKeyCallBacks,
+                                                                  &kCFTypeDictionaryValueCallBacks);
+
+    OSStatus err = QTOpenGLTextureContextCreate(kCFAllocatorDefault,
+                                                cglContext,
+                                                cglPixelFormat,
+                                                textureContextAttributes,
+                                                &m_visualContext);
+    if (err != noErr)
+        qWarning() << "Could not create visual context (OpenGL)";
+
+
+    return (err == noErr);
+#endif // QUICKTIME_C_API_AVAILABLE
+
+    return false;
+}
+
+QT7MovieVideoWidget::~QT7MovieVideoWidget()
+{
+    m_displayLink->stop();
+    [(QTMovie*)m_movie release];
+    delete m_videoWidget;
+}
+
+QWidget *QT7MovieVideoWidget::videoWidget()
+{
+    return m_videoWidget;
+}
+
+void QT7MovieVideoWidget::setupVideoOutput()
+{
+    AutoReleasePool pool;
+
+//    qDebug() << "QT7MovieVideoWidget::setupVideoOutput" << m_movie;
+
+    if (m_movie == 0) {
+        m_displayLink->stop();
+        return;
+    }
+
+    NSSize size = [[(QTMovie*)m_movie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
+    m_nativeSize = QSize(size.width, size.height);
+    m_videoWidget->setNativeSize(m_nativeSize);
+
+#ifdef QUICKTIME_C_API_AVAILABLE
+    // targets a Movie to render into a visual context
+    SetMovieVisualContext([(QTMovie*)m_movie quickTimeMovie], m_visualContext);
+#endif
+
+    m_displayLink->start();
+}
+
+void QT7MovieVideoWidget::setMovie(void *movie)
+{
+    if (m_movie == movie)
+        return;
+
+    if (m_movie) {
+#ifdef QUICKTIME_C_API_AVAILABLE
+        SetMovieVisualContext([(QTMovie*)m_movie quickTimeMovie], nil);
+#endif
+        [(QTMovie*)m_movie release];
+    }
+
+    m_movie = movie;
+    [(QTMovie*)m_movie retain];
+
+    setupVideoOutput();
+}
+
+void QT7MovieVideoWidget::updateNaturalSize(const QSize &newSize)
+{
+    if (m_nativeSize != newSize) {
+        m_nativeSize = newSize;
+        setupVideoOutput();
+    }
+}
+
+bool QT7MovieVideoWidget::isFullScreen() const
+{
+    return m_fullscreen;
+}
+
+void QT7MovieVideoWidget::setFullScreen(bool fullScreen)
+{
+    m_fullscreen = fullScreen;    
+}
+
+QSize QT7MovieVideoWidget::nativeSize() const
+{
+    return m_nativeSize;
+}
+
+Qt::AspectRatioMode QT7MovieVideoWidget::aspectRatioMode() const
+{
+    return m_aspectRatioMode;
+}
+
+void QT7MovieVideoWidget::setAspectRatioMode(Qt::AspectRatioMode mode)
+{
+    m_aspectRatioMode = mode;
+    m_videoWidget->setAspectRatioMode(mode);    
+}
+
+int QT7MovieVideoWidget::brightness() const
+{
+    return m_brightness;
+}
+
+void QT7MovieVideoWidget::setBrightness(int brightness)
+{
+    m_brightness = brightness;
+    updateColors();
+}
+
+int QT7MovieVideoWidget::contrast() const
+{
+    return m_contrast;
+}
+
+void QT7MovieVideoWidget::setContrast(int contrast)
+{
+    m_contrast = contrast;
+    updateColors();
+}
+
+int QT7MovieVideoWidget::hue() const
+{
+    return m_hue;
+}
+
+void QT7MovieVideoWidget::setHue(int hue)
+{
+    m_hue = hue;
+    updateColors();
+}
+
+int QT7MovieVideoWidget::saturation() const
+{
+    return m_saturation;
+}
+
+void QT7MovieVideoWidget::setSaturation(int saturation)
+{
+    m_saturation = saturation;
+    updateColors();
+}
+
+void QT7MovieVideoWidget::updateColors()
+{
+#ifdef QUICKTIME_C_API_AVAILABLE
+    if (m_movie) {
+        QTMovie *movie = (QTMovie*)m_movie;
+
+        Float32 value;
+        value = m_brightness/100.0;
+        SetMovieVisualBrightness([movie quickTimeMovie], value, 0);
+        value = pow(2, m_contrast/50.0);
+        SetMovieVisualContrast([movie quickTimeMovie], value, 0);
+        value = m_hue/100.0;
+        SetMovieVisualHue([movie quickTimeMovie], value, 0);
+        value = 1.0+m_saturation/100.0;
+        SetMovieVisualSaturation([movie quickTimeMovie], value, 0);
+    }
+#endif
+}
+
+void QT7MovieVideoWidget::updateVideoFrame(const CVTimeStamp &ts)
+{
+#ifdef QUICKTIME_C_API_AVAILABLE
+    AutoReleasePool pool;    
+    // check for new frame
+    if (m_visualContext && QTVisualContextIsNewImageAvailable(m_visualContext, &ts)) {
+        CVOpenGLTextureRef currentFrame = NULL;
+
+        // get a "frame" (image buffer) from the Visual Context, indexed by the provided time
+        OSStatus status = QTVisualContextCopyImageForTime(m_visualContext, NULL, &ts, &currentFrame);
+
+        // the above call may produce a null frame so check for this first
+        // if we have a frame, then draw it
+        if (status == noErr && currentFrame) {
+            //qDebug() << "render video frame";
+            m_videoWidget->setCVTexture(currentFrame);
+            CVOpenGLTextureRelease(currentFrame);
+        }
+        QTVisualContextTask(m_visualContext);
+    }
+#else
+    Q_UNUSED(ts);
+#endif
+}
+
+#include "moc_qt7movievideowidget.cpp"
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/qt7/qt7movieviewoutput.h b/src/plugins/mediaservices/qt7/qt7movieviewoutput.h
new file mode 100644
index 0000000..0fee41c
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7movieviewoutput.h
@@ -0,0 +1,119 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7MOVIEVIEWOUTPUT_H
+#define QT7MOVIEVIEWOUTPUT_H
+
+#include <QtCore/qobject.h>
+
+#include <QtMultimedia/qvideowindowcontrol.h>
+#include <QtMultimedia/qmediaplayer.h>
+
+#include <QtGui/qmacdefines_mac.h>
+#include "qt7videooutputcontrol.h"
+
+
+QT_BEGIN_HEADER
+QT_BEGIN_NAMESPACE
+
+class QT7PlayerSession;
+class QT7PlayerService;
+
+class QT7MovieViewOutput : public QT7VideoWindowControl
+{
+public:
+    QT7MovieViewOutput(QObject *parent = 0);
+    ~QT7MovieViewOutput();
+
+    void setMovie(void *movie);
+    void updateNaturalSize(const QSize &newSize);
+
+    WId winId() const;
+    void setWinId(WId id);
+
+    QRect displayRect() const;
+    void setDisplayRect(const QRect &rect);
+
+    bool isFullScreen() const;
+    void setFullScreen(bool fullScreen);
+
+    void repaint();
+
+    QSize nativeSize() const;
+
+    Qt::AspectRatioMode aspectRatioMode() const;
+    void setAspectRatioMode(Qt::AspectRatioMode mode);
+
+    int brightness() const;
+    void setBrightness(int brightness);
+
+    int contrast() const;
+    void setContrast(int contrast);
+
+    int hue() const;
+    void setHue(int hue);
+
+    int saturation() const;
+    void setSaturation(int saturation);
+    
+private:
+    void setupVideoOutput();
+
+    void *m_movie;
+    void *m_movieView;
+    bool m_layouted;
+
+    WId m_winId;
+    QRect m_displayRect;
+    bool m_fullscreen;
+    QSize m_nativeSize;
+    Qt::AspectRatioMode m_aspectRatioMode;
+    int m_brightness;
+    int m_contrast;
+    int m_hue;
+    int m_saturation;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/qt7movieviewoutput.mm b/src/plugins/mediaservices/qt7/qt7movieviewoutput.mm
new file mode 100644
index 0000000..20f1a02
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7movieviewoutput.mm
@@ -0,0 +1,332 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#import <QTKit/QTKit.h>
+
+#include "qt7backend.h"
+
+#include "qt7playercontrol.h"
+#include "qt7movieviewoutput.h"
+#include "qt7playersession.h"
+#include <QtCore/qdebug.h>
+
+
+#define VIDEO_TRANSPARENT(m) -(void)m:(NSEvent *)e{[[self superview] m:e];}
+
+@interface TransparentQTMovieView : QTMovieView
+{
+@private
+    QRect *m_drawRect;
+    qreal m_brightness, m_contrast, m_saturation, m_hue;
+}
+
+- (TransparentQTMovieView *) init;
+- (void) setDrawRect:(QRect &)rect;
+- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img;
+- (void) setContrast:(qreal) contrast;
+@end
+
+@implementation TransparentQTMovieView
+
+- (TransparentQTMovieView *) init
+{
+    self = [super initWithFrame:NSZeroRect];
+    if (self) {
+        [self setControllerVisible:NO];
+        [self setContrast:1.0];
+        [self setDelegate:self];
+    }
+    return self;
+}
+
+- (void) dealloc
+{
+    [super dealloc];
+}
+
+- (void) setContrast:(qreal) contrast
+{
+    m_hue = 0.0;
+    m_brightness = 0.0;
+    m_contrast = contrast;
+    m_saturation = 1.0;
+}
+
+
+- (void) setDrawRect:(QRect &)rect
+{
+    *m_drawRect = rect;
+
+    NSRect nsrect;
+    nsrect.origin.x = m_drawRect->x();
+    nsrect.origin.y = m_drawRect->y();
+    nsrect.size.width = m_drawRect->width();
+    nsrect.size.height = m_drawRect->height();
+    [self setFrame:nsrect];
+}
+
+- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img
+{
+    // This method is called from QTMovieView just
+    // before the image will be drawn.
+    Q_UNUSED(view);
+
+    if ( !qFuzzyCompare(m_brightness, 0.0) ||
+         !qFuzzyCompare(m_contrast, 1.0) ||
+         !qFuzzyCompare(m_saturation, 1.0)){
+        CIFilter *colorFilter = [CIFilter filterWithName:@"CIColorControls"];
+        [colorFilter setValue:[NSNumber numberWithFloat:m_brightness] forKey:@"inputBrightness"];
+        [colorFilter setValue:[NSNumber numberWithFloat:(m_contrast < 1) ? m_contrast : 1 + ((m_contrast-1)*3)] forKey:@"inputContrast"];
+        [colorFilter setValue:[NSNumber numberWithFloat:m_saturation] forKey:@"inputSaturation"];
+        [colorFilter setValue:img forKey:@"inputImage"];
+        img = [colorFilter valueForKey:@"outputImage"];
+    }
+
+    /*if (m_hue){
+        CIFilter *colorFilter = [CIFilter filterWithName:@"CIHueAdjust"];
+        [colorFilter setValue:[NSNumber numberWithFloat:(m_hue * 3.14)] forKey:@"inputAngle"];
+        [colorFilter setValue:img forKey:@"inputImage"];
+        img = [colorFilter valueForKey:@"outputImage"];
+    }*/
+
+    return img;
+}
+
+
+VIDEO_TRANSPARENT(mouseDown);
+VIDEO_TRANSPARENT(mouseDragged);
+VIDEO_TRANSPARENT(mouseUp);
+VIDEO_TRANSPARENT(mouseMoved);
+VIDEO_TRANSPARENT(mouseEntered);
+VIDEO_TRANSPARENT(mouseExited);
+VIDEO_TRANSPARENT(rightMouseDown);
+VIDEO_TRANSPARENT(rightMouseDragged);
+VIDEO_TRANSPARENT(rightMouseUp);
+VIDEO_TRANSPARENT(otherMouseDown);
+VIDEO_TRANSPARENT(otherMouseDragged);
+VIDEO_TRANSPARENT(otherMouseUp);
+VIDEO_TRANSPARENT(keyDown);
+VIDEO_TRANSPARENT(keyUp);
+VIDEO_TRANSPARENT(scrollWheel)
+
+@end
+
+
+QT7MovieViewOutput::QT7MovieViewOutput(QObject *parent)
+   :QT7VideoWindowControl(parent),
+    m_movie(0),
+    m_movieView(0),
+    m_layouted(false),
+    m_winId(0),
+    m_fullscreen(false),
+    m_aspectRatioMode(Qt::KeepAspectRatio),
+    m_brightness(0),
+    m_contrast(0),
+    m_hue(0),
+    m_saturation(0)
+{    
+}
+
+QT7MovieViewOutput::~QT7MovieViewOutput()
+{
+    [(QTMovieView*)m_movieView release];
+    [(QTMovie*)m_movie release];
+}
+
+void QT7MovieViewOutput::setupVideoOutput()
+{
+    AutoReleasePool pool;
+
+    //qDebug() << "QT7MovieViewOutput::setupVideoOutput" << m_movie << m_winId;
+    if (m_movie == 0 || m_winId <= 0)
+        return;
+
+    NSSize size = [[(QTMovie*)m_movie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
+    m_nativeSize = QSize(size.width, size.height);
+
+    if (!m_movieView)
+        m_movieView = [[TransparentQTMovieView alloc] init];
+
+    [(QTMovieView*)m_movieView setControllerVisible:NO];
+    [(QTMovieView*)m_movieView setMovie:(QTMovie*)m_movie];
+
+    [(NSView *)m_winId addSubview:(QTMovieView*)m_movieView];
+    m_layouted = true;
+
+    setDisplayRect(m_displayRect);
+}
+
+void QT7MovieViewOutput::setMovie(void *movie)
+{
+    if (m_movie != movie) {
+        if (m_movie) {
+            if (m_movieView)
+                [(QTMovieView*)m_movieView setMovie:nil];
+
+            [(QTMovie*)m_movie release];
+        }
+
+        m_movie = movie;
+
+        if (m_movie)
+            [(QTMovie*)m_movie retain];
+
+        setupVideoOutput();
+    }
+}
+
+void QT7MovieViewOutput::updateNaturalSize(const QSize &newSize)
+{
+    if (m_nativeSize != newSize) {
+        m_nativeSize = newSize;
+        emit nativeSizeChanged();
+    }
+}
+
+WId QT7MovieViewOutput::winId() const
+{
+    return m_winId;
+}
+
+void QT7MovieViewOutput::setWinId(WId id)
+{
+    if (m_winId != id) {
+        if (m_movieView && m_layouted) {
+            [(QTMovieView*)m_movieView removeFromSuperview];
+            m_layouted = false;
+        }
+
+        m_winId = id;
+        setupVideoOutput();
+    }
+}
+
+QRect QT7MovieViewOutput::displayRect() const
+{
+    return m_displayRect;
+}
+
+void QT7MovieViewOutput::setDisplayRect(const QRect &rect)
+{
+    m_displayRect = rect;
+
+    if (m_movieView) {
+        AutoReleasePool pool;
+        [(QTMovieView*)m_movieView setPreservesAspectRatio:(m_aspectRatioMode == Qt::KeepAspectRatio ? YES : NO)];
+        [(QTMovieView*)m_movieView setFrame:NSMakeRect(m_displayRect.x(),
+                                                       m_displayRect.y(),
+                                                       m_displayRect.width(),
+                                                       m_displayRect.height())];
+     }
+
+}
+
+bool QT7MovieViewOutput::isFullScreen() const
+{
+    return m_fullscreen;
+}
+
+void QT7MovieViewOutput::setFullScreen(bool fullScreen)
+{
+    m_fullscreen = fullScreen;
+    setDisplayRect(m_displayRect);
+}
+
+void QT7MovieViewOutput::repaint()
+{
+}
+
+QSize QT7MovieViewOutput::nativeSize() const
+{
+    return m_nativeSize;
+}
+
+Qt::AspectRatioMode QT7MovieViewOutput::aspectRatioMode() const
+{
+    return m_aspectRatioMode;
+}
+
+void QT7MovieViewOutput::setAspectRatioMode(Qt::AspectRatioMode mode)
+{
+    m_aspectRatioMode = mode;
+    setDisplayRect(m_displayRect);
+}
+
+int QT7MovieViewOutput::brightness() const
+{
+    return m_brightness;
+}
+
+void QT7MovieViewOutput::setBrightness(int brightness)
+{
+    m_brightness = brightness;
+}
+
+int QT7MovieViewOutput::contrast() const
+{
+    return m_contrast;
+}
+
+void QT7MovieViewOutput::setContrast(int contrast)
+{
+    m_contrast = contrast;
+    [(TransparentQTMovieView*)m_movieView setContrast:(contrast/100.0+1.0)];
+}
+
+int QT7MovieViewOutput::hue() const
+{
+    return m_hue;
+}
+
+void QT7MovieViewOutput::setHue(int hue)
+{
+    m_hue = hue;
+}
+
+int QT7MovieViewOutput::saturation() const
+{
+    return m_saturation;
+}
+
+void QT7MovieViewOutput::setSaturation(int saturation)
+{
+    m_saturation = saturation;
+}
diff --git a/src/plugins/mediaservices/qt7/qt7movieviewrenderer.h b/src/plugins/mediaservices/qt7/qt7movieviewrenderer.h
new file mode 100644
index 0000000..0b515ae
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7movieviewrenderer.h
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7MOVIEVIEWRENDERER_H
+#define QT7MOVIEVIEWRENDERER_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qmutex.h>
+
+#include <QtMultimedia/qvideowindowcontrol.h>
+#include <QtMultimedia/qmediaplayer.h>
+
+#include <QtGui/qmacdefines_mac.h>
+#include "qt7videooutputcontrol.h"
+#include <QtMultimedia/qvideoframe.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+
+class QVideoFrame;
+class QT7PlayerSession;
+class QT7PlayerService;
+
+class QT7MovieViewRenderer : public QT7VideoRendererControl
+{
+public:
+    QT7MovieViewRenderer(QObject *parent = 0);
+    ~QT7MovieViewRenderer();
+
+    void setMovie(void *movie);
+    void updateNaturalSize(const QSize &newSize);
+
+    QAbstractVideoSurface *surface() const;
+    void setSurface(QAbstractVideoSurface *surface);
+
+    void renderFrame(const QVideoFrame &);
+
+protected:
+    bool event(QEvent *event);
+
+private:
+    void setupVideoOutput();
+
+    void *m_movie;
+    void *m_movieView;
+    QSize m_nativeSize;
+    QAbstractVideoSurface *m_surface;
+    QVideoFrame m_currentFrame;
+    bool m_pendingRenderEvent;
+    QMutex m_mutex;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/qt7movieviewrenderer.mm b/src/plugins/mediaservices/qt7/qt7movieviewrenderer.mm
new file mode 100644
index 0000000..33a6970
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7movieviewrenderer.mm
@@ -0,0 +1,363 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#import <QTKit/QTKit.h>
+
+#include "qt7backend.h"
+
+#include "qt7playercontrol.h"
+#include "qt7movieviewrenderer.h"
+#include "qt7playersession.h"
+#include "qt7ciimagevideobuffer.h"
+#include <QtCore/qdebug.h>
+#include <QtCore/qcoreevent.h>
+#include <QtCore/qcoreapplication.h>
+
+#include <QtMultimedia/qabstractvideobuffer.h>
+#include <QtMultimedia/qabstractvideosurface.h>
+#include <QtMultimedia/qvideosurfaceformat.h>
+
+
+QT_BEGIN_NAMESPACE
+
+class NSBitmapVideoBuffer : public QAbstractVideoBuffer
+{
+public:
+    NSBitmapVideoBuffer(NSBitmapImageRep *buffer)
+        : QAbstractVideoBuffer(NoHandle)
+        , m_buffer(buffer)
+        , m_mode(NotMapped)
+    {
+        [m_buffer retain];
+    }
+
+    virtual ~NSBitmapVideoBuffer()
+    {
+        [m_buffer release];
+    }
+
+    MapMode mapMode() const { return m_mode; }
+
+    uchar *map(MapMode mode, int *numBytes, int *bytesPerLine)
+    {
+        if (mode != NotMapped && m_mode == NotMapped) {
+            if (numBytes)
+                *numBytes = [m_buffer bytesPerPlane];
+
+            if (bytesPerLine)
+                *bytesPerLine = [m_buffer bytesPerRow];
+
+            m_mode = mode;
+
+            return [m_buffer bitmapData];
+        } else {
+            return 0;
+        }
+    }
+
+    void unmap() { m_mode = NotMapped; }
+
+private:
+    NSBitmapImageRep *m_buffer;
+    MapMode m_mode;
+};
+
+QT_END_NAMESPACE
+
+#define VIDEO_TRANSPARENT(m) -(void)m:(NSEvent *)e{[[self superview] m:e];}
+
+@interface HiddenQTMovieView : QTMovieView
+{
+@private
+    QWidget *m_window;
+    QT7MovieViewRenderer *m_renderer;
+}
+
+- (HiddenQTMovieView *) initWithRenderer:(QT7MovieViewRenderer *)renderer;
+- (void) setRenderer:(QT7MovieViewRenderer *)renderer;
+- (void) setDrawRect:(const QRect &)rect;
+- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img;
+@end
+
+@implementation HiddenQTMovieView
+
+- (HiddenQTMovieView *) initWithRenderer:(QT7MovieViewRenderer *)renderer
+{
+    self = [super initWithFrame:NSZeroRect];
+    if (self) {
+        [self setControllerVisible:NO];
+        [self setDelegate:self];
+
+        self->m_renderer = renderer;
+
+        self->m_window = new QWidget;
+        self->m_window->setWindowOpacity(0.0);
+        self->m_window->show();
+        self->m_window->hide();
+
+        [(NSView *)(self->m_window->winId()) addSubview:self];
+        [self setDrawRect:QRect(0,0,1,1)];
+    }
+    return self;
+}
+
+- (void) dealloc
+{
+    [super dealloc];
+}
+
+- (void) setRenderer:(QT7MovieViewRenderer *)renderer
+{
+    m_renderer = renderer;
+}
+
+- (void) setDrawRect:(const QRect &)rect
+{
+    NSRect nsrect;
+    nsrect.origin.x = rect.x();
+    nsrect.origin.y = rect.y();
+    nsrect.size.width = rect.width();
+    nsrect.size.height = rect.height();
+    [self setFrame:nsrect];
+}
+
+- (CIImage *) view:(QTMovieView *)view willDisplayImage:(CIImage *)img
+{
+    // This method is called from QTMovieView just
+    // before the image will be drawn.
+    Q_UNUSED(view);
+    if (m_renderer) {
+        CGRect bounds = [img extent];
+        int w = bounds.size.width;
+        int h = bounds.size.height;
+
+        QVideoFrame frame;
+
+        QAbstractVideoSurface *surface = m_renderer->surface();
+        if (!surface || !surface->isActive())
+            return img;
+
+        if (surface->surfaceFormat().handleType() == QAbstractVideoBuffer::CoreImageHandle) {
+            //surface supports rendering of opengl based CIImage
+            frame = QVideoFrame(new QT7CIImageVideoBuffer(img), QSize(w,h), QVideoFrame::Format_RGB32 );
+        } else {
+            //Swap R and B colors
+            CIFilter *colorSwapFilter = [CIFilter filterWithName: @"CIColorMatrix"  keysAndValues:
+                                         @"inputImage", img,
+                                         @"inputRVector", [CIVector vectorWithX: 0  Y: 0  Z: 1  W: 0],
+                                         @"inputGVector", [CIVector vectorWithX: 0  Y: 1  Z: 0  W: 0],
+                                         @"inputBVector", [CIVector vectorWithX: 1  Y: 0  Z: 0  W: 0],
+                                         @"inputAVector", [CIVector vectorWithX: 0  Y: 0  Z: 0  W: 1],
+                                         @"inputBiasVector", [CIVector vectorWithX: 0  Y: 0  Z: 0  W: 0],
+                                         nil];
+            CIImage *img = [colorSwapFilter valueForKey: @"outputImage"];
+            NSBitmapImageRep *bitmap =[[NSBitmapImageRep alloc] initWithCIImage:img];
+            //requesting the bitmap data is slow,
+            //but it's better to do it here to avoid blocking the main thread for a long.
+            [bitmap bitmapData];
+            frame = QVideoFrame(new NSBitmapVideoBuffer(bitmap), QSize(w,h), QVideoFrame::Format_RGB32 );
+            [bitmap release];
+        }
+
+        if (m_renderer)
+            m_renderer->renderFrame(frame);
+    }
+
+    return img;
+}
+
+// Override this method so that the movie doesn't stop if
+// the window becomes invisible
+- (void)viewWillMoveToWindow:(NSWindow *)newWindow
+{
+    Q_UNUSED(newWindow);
+}
+
+
+VIDEO_TRANSPARENT(mouseDown);
+VIDEO_TRANSPARENT(mouseDragged);
+VIDEO_TRANSPARENT(mouseUp);
+VIDEO_TRANSPARENT(mouseMoved);
+VIDEO_TRANSPARENT(mouseEntered);
+VIDEO_TRANSPARENT(mouseExited);
+VIDEO_TRANSPARENT(rightMouseDown);
+VIDEO_TRANSPARENT(rightMouseDragged);
+VIDEO_TRANSPARENT(rightMouseUp);
+VIDEO_TRANSPARENT(otherMouseDown);
+VIDEO_TRANSPARENT(otherMouseDragged);
+VIDEO_TRANSPARENT(otherMouseUp);
+VIDEO_TRANSPARENT(keyDown);
+VIDEO_TRANSPARENT(keyUp);
+VIDEO_TRANSPARENT(scrollWheel)
+
+@end
+
+QT_BEGIN_NAMESPACE
+
+QT7MovieViewRenderer::QT7MovieViewRenderer(QObject *parent)
+   :QT7VideoRendererControl(parent),
+    m_movie(0),
+    m_movieView(0),
+    m_surface(0),
+    m_pendingRenderEvent(false)
+{    
+}
+
+QT7MovieViewRenderer::~QT7MovieViewRenderer()
+{
+    [(HiddenQTMovieView*)m_movieView setRenderer:0];
+
+    QMutexLocker locker(&m_mutex);
+    m_currentFrame = QVideoFrame();
+    [(HiddenQTMovieView*)m_movieView release];
+}
+
+void QT7MovieViewRenderer::setupVideoOutput()
+{
+    AutoReleasePool pool;
+
+//    qDebug() << "QT7MovieViewRenderer::setupVideoOutput" << m_movie << m_surface;
+
+    HiddenQTMovieView *movieView = (HiddenQTMovieView*)m_movieView;
+
+    if (movieView && !m_movie) {
+        [movieView setMovie:nil];
+    }
+
+    if (m_movie) {
+        NSSize size = [[(QTMovie*)m_movie attributeForKey:@"QTMovieNaturalSizeAttribute"] sizeValue];
+
+        m_nativeSize = QSize(size.width, size.height);
+
+        if (!movieView) {
+            movieView = [[HiddenQTMovieView alloc] initWithRenderer:this];
+            m_movieView = movieView;
+            [movieView setControllerVisible:NO];
+        }
+
+        [movieView setMovie:(QTMovie*)m_movie];
+        [movieView setDrawRect:QRect(QPoint(0,0), m_nativeSize)];
+    }
+
+    if (m_surface && !m_nativeSize.isEmpty()) {
+        bool coreImageFrameSupported = !m_surface->supportedPixelFormats(QAbstractVideoBuffer::CoreImageHandle).isEmpty() &&
+                                       !m_surface->supportedPixelFormats(QAbstractVideoBuffer::GLTextureHandle).isEmpty();
+
+        QVideoSurfaceFormat format(m_nativeSize, QVideoFrame::Format_RGB32,
+                                   coreImageFrameSupported ? QAbstractVideoBuffer::CoreImageHandle : QAbstractVideoBuffer::NoHandle);
+
+        if (m_surface->isActive() && m_surface->surfaceFormat() != format) {
+//            qDebug() << "Surface format was changed, stop the surface.";
+            m_surface->stop();
+        }
+
+        if (!m_surface->isActive()) {
+            //qDebug() << "Starting the surface with format" << format;
+            if (!m_surface->start(format)) {
+                qWarning() << "Failed to start video surface" << m_surface->error();
+                qWarning() << "Surface format:" << format;
+            }
+        }
+    }
+}
+
+void QT7MovieViewRenderer::setMovie(void *movie)
+{
+    if (movie == m_movie)
+        return;
+
+    QMutexLocker locker(&m_mutex);
+    m_movie = movie;
+    setupVideoOutput();
+}
+
+void QT7MovieViewRenderer::updateNaturalSize(const QSize &newSize)
+{
+    if (m_nativeSize != newSize) {
+        m_nativeSize = newSize;
+        setupVideoOutput();
+    }
+}
+
+QAbstractVideoSurface *QT7MovieViewRenderer::surface() const
+{
+    return m_surface;
+}
+
+void QT7MovieViewRenderer::setSurface(QAbstractVideoSurface *surface)
+{
+    if (surface == m_surface)
+        return;
+
+    QMutexLocker locker(&m_mutex);
+
+    if (m_surface && m_surface->isActive())
+        m_surface->stop();
+
+    m_surface = surface;
+    setupVideoOutput();
+}
+
+void QT7MovieViewRenderer::renderFrame(const QVideoFrame &frame)
+{
+
+    QMutexLocker locker(&m_mutex);
+    m_currentFrame = frame;
+
+    if (!m_pendingRenderEvent)
+        qApp->postEvent(this, new QEvent(QEvent::User), Qt::HighEventPriority);
+
+    m_pendingRenderEvent = true;
+}
+
+bool QT7MovieViewRenderer::event(QEvent *event)
+{
+    if (event->type() == QEvent::User) {
+        QMutexLocker locker(&m_mutex);
+        m_pendingRenderEvent = false;
+        if (m_surface->isActive())
+            m_surface->present(m_currentFrame);
+    }
+
+    return QT7VideoRendererControl::event(event);
+}
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/qt7/qt7serviceplugin.h b/src/plugins/mediaservices/qt7/qt7serviceplugin.h
new file mode 100644
index 0000000..c5afda1
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7serviceplugin.h
@@ -0,0 +1,64 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QT7SERVICEPLUGIN_H
+#define QT7SERVICEPLUGIN_H
+
+#include <QtMultimedia/qmediaserviceproviderplugin.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QT7ServicePlugin : public QMediaServiceProviderPlugin
+{
+public:
+    QStringList keys() const;
+    QMediaService* create(QString const& key);
+    void release(QMediaService *service);
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QGSTREAMERSERVICEPLUGIN_H
diff --git a/src/plugins/mediaservices/qt7/qt7serviceplugin.mm b/src/plugins/mediaservices/qt7/qt7serviceplugin.mm
new file mode 100644
index 0000000..c59a453
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7serviceplugin.mm
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtCore/qstring.h>
+#include <QtCore/qdebug.h>
+
+#include "qt7serviceplugin.h"
+#include "qt7playerservice.h"
+
+#include <QtMultimedia/qmediaserviceprovider.h>
+
+QT_BEGIN_NAMESPACE
+
+QStringList QT7ServicePlugin::keys() const
+{
+    return QStringList()
+#ifdef QMEDIA_QT7_PLAYER
+    << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER);
+#endif
+}
+
+QMediaService* QT7ServicePlugin::create(QString const& key)
+{
+#ifdef QMEDIA_QT7_PLAYER
+    if (key == QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER))
+        return new QT7PlayerService;
+#endif
+
+    qWarning() << "Attempt to create unknown service with key" << key;
+    return 0;
+}
+
+void QT7ServicePlugin::release(QMediaService *service)
+{
+    delete service;
+}
+
+Q_EXPORT_PLUGIN2(qt7_serviceplugin, QT7ServicePlugin);
+
+QT_END_NAMESPACE
diff --git a/src/plugins/mediaservices/qt7/qt7videooutputcontrol.h b/src/plugins/mediaservices/qt7/qt7videooutputcontrol.h
new file mode 100644
index 0000000..3c74cb8
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7videooutputcontrol.h
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QT7VIDEOOUTPUTCONTROL_H
+#define QT7VIDEOOUTPUTCONTROL_H
+
+#include <QtCore/qobject.h>
+#include <QtCore/qsize.h>
+
+#include <QtMultimedia/qvideooutputcontrol.h>
+#include <QtMultimedia/qvideowindowcontrol.h>
+#include <QtMultimedia/qvideowidgetcontrol.h>
+#include <QtMultimedia/qvideorenderercontrol.h>
+#include <QtMultimedia/qmediaplayer.h>
+
+#include <QtGui/qmacdefines_mac.h>
+
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+class QMediaPlaylist;
+class QMediaPlaylistNavigator;
+class QT7PlayerSession;
+class QT7PlayerService;
+
+
+class QT7VideoOutput {
+public:
+    virtual ~QT7VideoOutput() {}
+    virtual void setMovie(void *movie) = 0;
+    virtual void updateNaturalSize(const QSize &newSize) = 0;
+};
+
+class QT7VideoWindowControl : public QVideoWindowControl, public QT7VideoOutput
+{
+public:
+    virtual ~QT7VideoWindowControl() {}
+
+protected:
+    QT7VideoWindowControl(QObject *parent)
+        :QVideoWindowControl(parent)
+    {}
+};
+
+class QT7VideoRendererControl : public QVideoRendererControl, public QT7VideoOutput
+{
+public:
+    virtual ~QT7VideoRendererControl() {}
+
+protected:
+    QT7VideoRendererControl(QObject *parent)
+        :QVideoRendererControl(parent)
+    {}
+};
+
+class QT7VideoWidgetControl : public QVideoWidgetControl, public QT7VideoOutput
+{
+public:
+    virtual ~QT7VideoWidgetControl() {}
+
+protected:
+    QT7VideoWidgetControl(QObject *parent)
+        :QVideoWidgetControl(parent)
+    {}
+};
+
+class QT7VideoOutputControl : public QVideoOutputControl
+{
+Q_OBJECT
+public:
+    QT7VideoOutputControl(QObject *parent = 0);
+    ~QT7VideoOutputControl();
+
+    void setSession(QT7PlayerSession *session);
+
+    QList<Output> availableOutputs() const;
+    void enableOutput(Output);
+
+    Output output() const;
+    void setOutput(Output output);
+
+signals:
+    void videoOutputChanged(QVideoOutputControl::Output);
+    
+private:
+    QT7PlayerSession *m_session;
+    Output m_output;
+    QList<Output> m_outputs;
+};
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif
diff --git a/src/plugins/mediaservices/qt7/qt7videooutputcontrol.mm b/src/plugins/mediaservices/qt7/qt7videooutputcontrol.mm
new file mode 100644
index 0000000..a468431
--- /dev/null
+++ b/src/plugins/mediaservices/qt7/qt7videooutputcontrol.mm
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qt7playercontrol.h"
+#include "qt7videooutputcontrol.h"
+#include "qt7playersession.h"
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+QT7VideoOutputControl::QT7VideoOutputControl(QObject *parent)
+   :QVideoOutputControl(parent), 
+    m_session(0),
+    m_output(QVideoOutputControl::NoOutput)
+{    
+}
+
+QT7VideoOutputControl::~QT7VideoOutputControl()
+{
+}
+
+void QT7VideoOutputControl::setSession(QT7PlayerSession *session)
+{
+    m_session = session;
+}
+
+QList<QVideoOutputControl::Output> QT7VideoOutputControl::availableOutputs() const
+{
+    return m_outputs;
+}
+
+void QT7VideoOutputControl::enableOutput(QVideoOutputControl::Output output)
+{
+    if (!m_outputs.contains(output))
+        m_outputs.append(output);
+}
+
+QVideoOutputControl::Output QT7VideoOutputControl::output() const
+{
+    return m_output;
+}
+
+void QT7VideoOutputControl::setOutput(Output output)
+{
+    if (m_output != output) {
+        m_output = output;
+        emit videoOutputChanged(m_output);
+    }
+
+}
+
+QT_END_NAMESPACE
+
+#include "moc_qt7videooutputcontrol.cpp"
+
diff --git a/src/plugins/phonon/ds9/ds9.pro b/src/plugins/phonon/ds9/ds9.pro
index 786338a..f40c561 100644
--- a/src/plugins/phonon/ds9/ds9.pro
+++ b/src/plugins/phonon/ds9/ds9.pro
@@ -53,7 +53,6 @@ SOURCES += \
            $$PHONON_DS9_DIR/qaudiocdreader.cpp \
            $$PHONON_DS9_DIR/qmeminputpin.cpp
 
-
 target.path = $$[QT_INSTALL_PLUGINS]/phonon_backend
 INSTALLS += target
 
diff --git a/src/plugins/phonon/gstreamer/gstreamer.pro b/src/plugins/phonon/gstreamer/gstreamer.pro
index ae597fa..1013205 100644
--- a/src/plugins/phonon/gstreamer/gstreamer.pro
+++ b/src/plugins/phonon/gstreamer/gstreamer.pro
@@ -15,6 +15,7 @@ PHONON_GSTREAMER_DIR = $$QT_SOURCE_TREE/src/3rdparty/phonon/gstreamer
 
 HEADERS += $$PHONON_GSTREAMER_DIR/common.h \
  $$PHONON_GSTREAMER_DIR/audiooutput.h \
+ $$PHONON_GSTREAMER_DIR/audiodataoutput.h \
  $$PHONON_GSTREAMER_DIR/artssink.h \
  $$PHONON_GSTREAMER_DIR/abstractrenderer.h \
  $$PHONON_GSTREAMER_DIR/backend.h \
@@ -35,26 +36,27 @@ HEADERS += $$PHONON_GSTREAMER_DIR/common.h \
  $$PHONON_GSTREAMER_DIR/audioeffect.h \
  $$PHONON_GSTREAMER_DIR/volumefadereffect.h
 
-SOURCES += $$PHONON_GSTREAMER_DIR/audiooutput.cpp \
- $$PHONON_GSTREAMER_DIR/abstractrenderer.cpp \
+SOURCES += $$PHONON_GSTREAMER_DIR/abstractrenderer.cpp \
  $$PHONON_GSTREAMER_DIR/artssink.cpp \
+ $$PHONON_GSTREAMER_DIR/audioeffect.cpp \
+ $$PHONON_GSTREAMER_DIR/audiooutput.cpp \
+ $$PHONON_GSTREAMER_DIR/audiodataoutput.cpp \
  $$PHONON_GSTREAMER_DIR/backend.cpp \
  $$PHONON_GSTREAMER_DIR/devicemanager.cpp \
  $$PHONON_GSTREAMER_DIR/effect.cpp \
  $$PHONON_GSTREAMER_DIR/effectmanager.cpp \
+ $$PHONON_GSTREAMER_DIR/glrenderer.cpp \
  $$PHONON_GSTREAMER_DIR/gsthelper.cpp \
- $$PHONON_GSTREAMER_DIR/mediaobject.cpp \
  $$PHONON_GSTREAMER_DIR/medianode.cpp \
  $$PHONON_GSTREAMER_DIR/medianodeevent.cpp \
- $$PHONON_GSTREAMER_DIR/widgetrenderer.cpp \
- $$PHONON_GSTREAMER_DIR/videowidget.cpp \
- $$PHONON_GSTREAMER_DIR/glrenderer.cpp \
- $$PHONON_GSTREAMER_DIR/qwidgetvideosink.cpp \
+ $$PHONON_GSTREAMER_DIR/mediaobject.cpp \
+ $$PHONON_GSTREAMER_DIR/message.cpp \
  $$PHONON_GSTREAMER_DIR/phononsrc.cpp \
+ $$PHONON_GSTREAMER_DIR/qwidgetvideosink.cpp \
  $$PHONON_GSTREAMER_DIR/streamreader.cpp \
- $$PHONON_GSTREAMER_DIR/message.cpp \
- $$PHONON_GSTREAMER_DIR/audioeffect.cpp \
- $$PHONON_GSTREAMER_DIR/volumefadereffect.cpp
+ $$PHONON_GSTREAMER_DIR/videowidget.cpp \
+ $$PHONON_GSTREAMER_DIR/volumefadereffect.cpp \
+ $$PHONON_GSTREAMER_DIR/widgetrenderer.cpp
 
 !embedded {
     HEADERS += $$PHONON_GSTREAMER_DIR/x11renderer.h
diff --git a/src/plugins/phonon/mmf/mmf.pro b/src/plugins/phonon/mmf/mmf.pro
index da41f18..85415b2 100644
--- a/src/plugins/phonon/mmf/mmf.pro
+++ b/src/plugins/phonon/mmf/mmf.pro
@@ -77,23 +77,25 @@ SOURCES +=                                           \
 
 # Test for whether the build environment supports video rendering to graphics
 # surfaces.
-exists($${EPOCROOT}epoc32/include/platform/videoplayer2.h) {
-    HEADERS +=                                       \
-           $$PHONON_MMF_DIR/videooutput_surface.h    \
-           $$PHONON_MMF_DIR/videoplayer_surface.h
-    SOURCES +=                                       \
-           $$PHONON_MMF_DIR/videooutput_surface.cpp  \
-           $$PHONON_MMF_DIR/videoplayer_surface.cpp
-    DEFINES += PHONON_MMF_VIDEO_SURFACES
-} else {
-    HEADERS +=                                       \
-           $$PHONON_MMF_DIR/ancestormovemonitor.h    \
-           $$PHONON_MMF_DIR/videooutput_dsa.h        \
-           $$PHONON_MMF_DIR/videoplayer_dsa.h
-    SOURCES +=                                       \
-           $$PHONON_MMF_DIR/ancestormovemonitor.cpp  \
-           $$PHONON_MMF_DIR/videooutput_dsa.cpp      \
-           $$PHONON_MMF_DIR/videoplayer_dsa.cpp      \
+symbian {
+    exists($${EPOCROOT}epoc32/include/platform/videoplayer2.h) {
+        HEADERS +=                                       \
+               $$PHONON_MMF_DIR/videooutput_surface.h    \
+               $$PHONON_MMF_DIR/videoplayer_surface.h
+        SOURCES +=                                       \
+               $$PHONON_MMF_DIR/videooutput_surface.cpp  \
+               $$PHONON_MMF_DIR/videoplayer_surface.cpp
+        DEFINES += PHONON_MMF_VIDEO_SURFACES
+    } else {
+        HEADERS +=                                       \
+               $$PHONON_MMF_DIR/ancestormovemonitor.h    \
+               $$PHONON_MMF_DIR/videooutput_dsa.h        \
+               $$PHONON_MMF_DIR/videoplayer_dsa.h
+        SOURCES +=                                       \
+               $$PHONON_MMF_DIR/ancestormovemonitor.cpp  \
+               $$PHONON_MMF_DIR/videooutput_dsa.cpp      \
+               $$PHONON_MMF_DIR/videoplayer_dsa.cpp      \
+    }
 }
 
 LIBS += -lcone
diff --git a/src/plugins/plugins.pro b/src/plugins/plugins.pro
index 004b816..42fbf9e 100644
--- a/src/plugins/plugins.pro
+++ b/src/plugins/plugins.pro
@@ -1,6 +1,6 @@
 TEMPLATE = subdirs
 
-SUBDIRS	*= accessible imageformats sqldrivers iconengines script
+SUBDIRS	*= imageformats sqldrivers iconengines script bearer
 unix:!symbian {
         contains(QT_CONFIG,iconv)|contains(QT_CONFIG,gnu-libiconv):SUBDIRS *= codecs
 } else {
@@ -9,6 +9,9 @@ unix:!symbian {
 !embedded:SUBDIRS *= graphicssystems
 embedded:SUBDIRS *=  gfxdrivers decorations mousedrivers kbddrivers
 !win32:!embedded:!mac:!symbian:SUBDIRS *= inputmethods
+!symbian:SUBDIRS += accessible
 symbian:SUBDIRS += s60
 contains(QT_CONFIG, phonon): SUBDIRS *= phonon
-contains(QT_CONFIG, multimedia): SUBDIRS *= audio
+contains(QT_CONFIG, multimedia): SUBDIRS *= audio mediaservices
+
+
diff --git a/src/plugins/qpluginbase.pri b/src/plugins/qpluginbase.pri
index f6a8f87..8b119b5 100644
--- a/src/plugins/qpluginbase.pri
+++ b/src/plugins/qpluginbase.pri
@@ -1,6 +1,6 @@
 TEMPLATE = lib
 isEmpty(QT_MAJOR_VERSION) {
-   VERSION=4.6.3
+   VERSION=4.7.0
 } else {
    VERSION=$${QT_MAJOR_VERSION}.$${QT_MINOR_VERSION}.$${QT_PATCH_VERSION}
 }
diff --git a/src/plugins/s60/3_2/3_2.pro b/src/plugins/s60/3_2/3_2.pro
index 9424c7c..0524866 100644
--- a/src/plugins/s60/3_2/3_2.pro
+++ b/src/plugins/s60/3_2/3_2.pro
@@ -10,7 +10,12 @@ contains(S60_VERSION, 3.1) {
     SOURCES += ../src/qlocale_3_2.cpp \
         ../src/qdesktopservices_3_2.cpp \
         ../src/qcoreapplication_3_2.cpp
-    LIBS += -lDirectoryLocalizer -lefsrv
+    contains(CONFIG, is_using_gnupoc) {
+        LIBS += -ldirectorylocalizer
+    } else {
+        LIBS += -lDirectoryLocalizer
+    }
+    LIBS += -lefsrv
     INCLUDEPATH += $$APP_LAYER_SYSTEMINCLUDE
 }
 
diff --git a/src/plugins/s60/5_0/5_0.pro b/src/plugins/s60/5_0/5_0.pro
index c787ab3..00aea1b 100644
--- a/src/plugins/s60/5_0/5_0.pro
+++ b/src/plugins/s60/5_0/5_0.pro
@@ -10,7 +10,12 @@ contains(S60_VERSION, 3.1) {
     SOURCES += ../src/qlocale_3_2.cpp \
         ../src/qdesktopservices_3_2.cpp \
         ../src/qcoreapplication_3_2.cpp
-    LIBS += -lDirectoryLocalizer -lefsrv
+    contains(CONFIG, is_using_gnupoc) {
+        LIBS += -ldirectorylocalizer
+    } else {
+        LIBS += -lDirectoryLocalizer
+    }
+    LIBS += -lefsrv
     INCLUDEPATH += $$APP_LAYER_SYSTEMINCLUDE
 }
 
diff --git a/src/plugins/s60/s60pluginbase.pri b/src/plugins/s60/s60pluginbase.pri
index c1aa4ef..1a6f4a2 100644
--- a/src/plugins/s60/s60pluginbase.pri
+++ b/src/plugins/s60/s60pluginbase.pri
@@ -4,6 +4,8 @@ include(../qpluginbase.pri)
 
 CONFIG  -= plugin
 
+QTDIR_build:DESTDIR	 = $$QT_BUILD_TREE/plugins/s60
+
 MMP_RULES += NOEXPORTLIBRARY
 
 defBlock = \
diff --git a/src/plugins/sqldrivers/psql/psql.pro b/src/plugins/sqldrivers/psql/psql.pro
index 29fbada..0a38ee4 100644
--- a/src/plugins/sqldrivers/psql/psql.pro
+++ b/src/plugins/sqldrivers/psql/psql.pro
@@ -4,18 +4,15 @@ HEADERS		= ../../../sql/drivers/psql/qsql_psql.h
 SOURCES		= main.cpp \
 		  ../../../sql/drivers/psql/qsql_psql.cpp
 
-unix: {
+unix|win32-g++: {
     !isEmpty(QT_LFLAGS_PSQL) {
-        LIBS *= $$QT_LFLAGS_PSQL
+        !contains(QT_CONFIG, system-zlib): QT_LFLAGS_PSQL -= -lz
+        !static:LIBS *= $$QT_LFLAGS_PSQL
         QMAKE_CXXFLAGS *= $$QT_CFLAGS_PSQL
     }
     !contains(LIBS, .*pq.*):LIBS *= -lpq
 }
 
-win32:!contains(LIBS, .*pq.* ) {
-    !win32-g++:LIBS    *= -llibpq       
-    win32-g++:LIBS *= -lpq	
-    LIBS    *= -lws2_32 -ladvapi32
-}
+win32:!win32-g++:!contains(LIBS, .*pq.* ) LIBS *= -llibpq -lws2_32 -ladvapi32
 
 include(../qsqldriverbase.pri)