class QAudioEngineDeclarativeModule : public QQmlExtensionPlugin
{
Q_OBJECT
+ Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface/1.0")
+
public:
virtual void registerTypes(const char *uri)
{
#include "audioengine.moc"
-Q_EXPORT_PLUGIN2("QtAudioEngine", QT_PREPEND_NAMESPACE(QAudioEngineDeclarativeModule));
-
class QMultimediaDeclarativeModule : public QQmlExtensionPlugin
{
Q_OBJECT
+ Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface/1.0")
+
public:
virtual void registerTypes(const char *uri)
{
#include "multimedia.moc"
-Q_EXPORT_PLUGIN2(qmultimediadeclarativemodule, QT_PREPEND_NAMESPACE(QMultimediaDeclarativeModule));
-
****************************************************************************/
#include "qdeclarativevideooutput_p.h"
-#include <private/qsgvideonode_p.h>
#include "qsgvideonode_i420.h"
#include "qsgvideonode_rgb.h"
QT_BEGIN_NAMESPACE
Q_GLOBAL_STATIC_WITH_ARGS(QMediaPluginLoader, videoNodeFactoryLoader,
- (QSGVideoNodeFactory_iid, QLatin1String("video"), Qt::CaseInsensitive))
+ (QSGVideoNodeFactoryInterface_iid, QLatin1String("video"), Qt::CaseInsensitive))
class QSGVideoItemSurface : public QAbstractVideoSurface
{
{
QList<QVideoFrame::PixelFormat> formats;
- foreach (QSGVideoNodeFactory* factory, m_item->m_videoNodeFactories) {
+ foreach (QSGVideoNodeFactoryInterface* factory, m_item->m_videoNodeFactories) {
formats.append(factory->supportedPixelFormats(handleType));
}
this, SLOT(_q_updateNativeSize(QVideoSurfaceFormat)), Qt::QueuedConnection);
foreach (QObject *instance, videoNodeFactoryLoader()->instances(QSGVideoNodeFactoryPluginKey)) {
- QSGVideoNodeFactory* plugin = qobject_cast<QSGVideoNodeFactory*>(instance);
+ QSGVideoNodeFactoryInterface* plugin = qobject_cast<QSGVideoNodeFactoryInterface*>(instance);
if (plugin) {
m_videoNodeFactories.append(plugin);
}
}
if (videoNode == 0) {
- foreach (QSGVideoNodeFactory* factory, m_videoNodeFactories) {
+ foreach (QSGVideoNodeFactoryInterface* factory, m_videoNodeFactories) {
videoNode = factory->createNode(m_surface->surfaceFormat());
if (videoNode)
break;
QWeakPointer<QMediaService> m_service;
QWeakPointer<QVideoRendererControl> m_rendererControl;
- QList<QSGVideoNodeFactory*> m_videoNodeFactories;
+ QList<QSGVideoNodeFactoryInterface*> m_videoNodeFactories;
QSGVideoItemSurface *m_surface;
QVideoFrame m_frame;
FillMode m_fillMode;
return 0;
}
-QStringList QSGVideoNodeFactory_I420::keys() const
-{
- return QStringList() << QSGVideoNodeFactoryPluginKey;
-}
-
class QSGVideoMaterialShader_YUV420 : public QSGMaterialShader
{
QSGVideoMaterial_YUV420 *m_material;
};
-class QSGVideoNodeFactory_I420 : public QSGVideoNodeFactory {
+class QSGVideoNodeFactory_I420 : public QSGVideoNodeFactoryInterface {
public:
QList<QVideoFrame::PixelFormat> supportedPixelFormats(QAbstractVideoBuffer::HandleType handleType) const;
QSGVideoNode *createNode(const QVideoSurfaceFormat &format);
- QStringList keys() const;
};
return 0;
}
-QStringList QSGVideoNodeFactory_RGB::keys() const
-{
- return QStringList() << QSGVideoNodeFactoryPluginKey;
-}
-
class QSGVideoMaterialShader_RGB : public QSGMaterialShader
{
QVideoFrame m_frame;
};
-class QSGVideoNodeFactory_RGB : public QSGVideoNodeFactory {
+class QSGVideoNodeFactory_RGB : public QSGVideoNodeFactoryInterface {
public:
QList<QVideoFrame::PixelFormat> supportedPixelFormats(QAbstractVideoBuffer::HandleType handleType) const;
QSGVideoNode *createNode(const QVideoSurfaceFormat &format);
- QStringList keys() const;
};
PRIVATE_HEADERS += \
audio/qaudiobuffer_p.h \
audio/qaudiodevicefactory_p.h \
- audio/qaudiopluginloader_p.h \
audio/qwavedecoder_p.h \
audio/qsamplecache_p.h \
audio/qaudiodecoder_p.h
audio/qaudiosystemplugin.cpp \
audio/qaudiosystem.cpp \
audio/qaudiodevicefactory.cpp \
- audio/qaudiopluginloader.cpp \
audio/qsoundeffect.cpp \
audio/qwavedecoder_p.cpp \
audio/qsamplecache_p.cpp \
#include "qaudiosystem.h"
#include "qaudiosystemplugin.h"
-#include "qaudiopluginloader_p.h"
+#include "qmediapluginloader_p.h"
#include "qaudiodevicefactory_p.h"
#ifndef QT_NO_AUDIO_BACKEND
QT_BEGIN_NAMESPACE
#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
-Q_GLOBAL_STATIC_WITH_ARGS(QAudioPluginLoader, audioLoader,
- (QAudioSystemFactoryInterface_iid, QLatin1String("/audio"), Qt::CaseInsensitive))
+Q_GLOBAL_STATIC_WITH_ARGS(QMediaPluginLoader, audioLoader,
+ (QAudioSystemFactoryInterface_iid, QLatin1String("audio"), Qt::CaseInsensitive))
#endif
class QNullDeviceInfo : public QAbstractAudioDeviceInfo
#endif
#if !defined (QT_NO_LIBRARY) && !defined(QT_NO_SETTINGS)
- QAudioPluginLoader* l = audioLoader();
+ QMediaPluginLoader* l = audioLoader();
foreach (const QString& key, l->keys()) {
QAudioSystemFactoryInterface* plugin = qobject_cast<QAudioSystemFactoryInterface*>(l->instance(key));
if (plugin) {
foreach (QByteArray const& handle, plugin->availableDevices(mode))
devices << QAudioDeviceInfo(key, handle, mode);
}
-
- delete plugin;
}
#endif
+++ /dev/null
-/****************************************************************************
-**
-** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: http://www.qt-project.org/
-**
-** This file is part of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:LGPL$
-** GNU Lesser General Public License Usage
-** 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.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU General
-** Public License version 3.0 as published by the Free Software Foundation
-** and appearing in the file LICENSE.GPL included in the packaging of this
-** file. Please review the following information to ensure the GNU General
-** Public License version 3.0 requirements will be met:
-** http://www.gnu.org/copyleft/gpl.html.
-**
-** Other Usage
-** Alternatively, this file may be used in accordance with the terms and
-** conditions contained in a signed written agreement between you and Nokia.
-**
-**
-**
-**
-**
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include "qaudiosystemplugin.h"
-#include "qaudiopluginloader_p.h"
-
-#include <QtCore/qcoreapplication.h>
-#include <QtCore/qpluginloader.h>
-#include <QtCore/qfactoryinterface.h>
-#include <QtCore/qdir.h>
-#include <QtCore/qdebug.h>
-
-QT_BEGIN_NAMESPACE
-
-QAudioPluginLoader::QAudioPluginLoader(const char *iid, const QString &location, Qt::CaseSensitivity):
- m_iid(iid)
-{
- m_location = location + QLatin1Char('/');
- load();
-}
-
-QAudioPluginLoader::~QAudioPluginLoader()
-{
- for (int i = 0; i < m_plugins.count(); i++ ) {
- delete m_plugins.at(i);
- }
-}
-
-QStringList QAudioPluginLoader::pluginList() const
-{
-#if !defined QT_NO_DEBUG
- const bool showDebug = qgetenv("QT_DEBUG_PLUGINS").toInt() > 0;
-#endif
-
- QStringList paths = QCoreApplication::libraryPaths();
-#ifdef QTM_PLUGIN_PATH
- paths << QLatin1String(QTM_PLUGIN_PATH);
-#endif
-#if !defined QT_NO_DEBUG
- if (showDebug)
- qDebug() << "Plugin paths:" << paths;
-#endif
-
- //temp variable to avoid multiple identic path
- QSet<QString> processed;
-
- /* Discover a bunch o plugins */
- QStringList plugins;
-
- /* Enumerate our plugin paths */
- for (int i=0; i < paths.count(); i++) {
- if (processed.contains(paths.at(i)))
- continue;
- processed.insert(paths.at(i));
- QDir pluginsDir(paths.at(i)+m_location);
- if (!pluginsDir.exists())
- continue;
-
- QStringList files = pluginsDir.entryList(QDir::Files);
-#if !defined QT_NO_DEBUG
- if (showDebug)
- qDebug()<<"Looking for plugins in "<<pluginsDir.path()<<files;
-#endif
- for (int j=0; j < files.count(); j++) {
- const QString &file = files.at(j);
- plugins << pluginsDir.absoluteFilePath(file);
- }
- }
- return plugins;
-}
-
-QStringList QAudioPluginLoader::keys() const
-{
- QMutexLocker locker(const_cast<QMutex *>(&m_mutex));
-
- QStringList list;
- for (int i = 0; i < m_plugins.count(); i++) {
- QAudioSystemPlugin* p = qobject_cast<QAudioSystemPlugin*>(m_plugins.at(i)->instance());
- if (p) list << p->keys();
- }
-
- return list;
-}
-
-QObject* QAudioPluginLoader::instance(QString const &key)
-{
- QMutexLocker locker(&m_mutex);
-
- for (int i = 0; i < m_plugins.count(); i++) {
- QAudioSystemPlugin* p = qobject_cast<QAudioSystemPlugin*>(m_plugins.at(i)->instance());
- if (p && p->keys().contains(key))
- return m_plugins.at(i)->instance();
- }
- return 0;
-}
-
-QList<QObject*> QAudioPluginLoader::instances(QString const &key)
-{
- QMutexLocker locker(&m_mutex);
-
- QList<QObject*> list;
- for (int i = 0; i < m_plugins.count(); i++) {
- QAudioSystemPlugin* p = qobject_cast<QAudioSystemPlugin*>(m_plugins.at(i)->instance());
- if (p && p->keys().contains(key))
- list << m_plugins.at(i)->instance();
- }
- return list;
-}
-
-void QAudioPluginLoader::load()
-{
- if (!m_plugins.isEmpty())
- return;
-
-#if !defined QT_NO_DEBUG
- const bool showDebug = qgetenv("QT_DEBUG_PLUGINS").toInt() > 0;
-#endif
-
- QStringList plugins = pluginList();
- for (int i=0; i < plugins.count(); i++) {
- QPluginLoader* loader = new QPluginLoader(plugins.at(i));
- QObject *o = loader->instance();
- if (o != 0 && o->qt_metacast(m_iid) != 0) {
- m_plugins.append(loader);
- } else {
-#if !defined QT_NO_DEBUG
- if (showDebug)
- qWarning() << "QAudioPluginLoader: Failed to load plugin: "
- << plugins.at(i) << loader->errorString();
-#endif
- delete o;
- //we are not calling loader->unload here for it may cause problem on some device
- delete loader;
- }
- }
-}
-QT_END_NAMESPACE
-
#include <QtCore/qstring.h>
#include <QtCore/qplugin.h>
-#include <QtCore/qfactoryinterface.h>
#include <qtmultimediadefs.h>
#include <qtmedianamespace.h>
QT_MODULE(Multimedia)
-struct Q_MULTIMEDIA_EXPORT QAudioSystemFactoryInterface : public QFactoryInterface
+struct Q_MULTIMEDIA_EXPORT QAudioSystemFactoryInterface
{
virtual QList<QByteArray> availableDevices(QAudio::Mode) const = 0;
virtual QAbstractAudioInput* createInput(const QByteArray& device) = 0;
class Q_MULTIMEDIA_EXPORT QAudioSystemPlugin : public QObject, public QAudioSystemFactoryInterface
{
Q_OBJECT
- Q_INTERFACES(QAudioSystemFactoryInterface:QFactoryInterface)
+ Q_INTERFACES(QAudioSystemFactoryInterface)
public:
QAudioSystemPlugin(QObject *parent = 0);
~QAudioSystemPlugin();
- virtual QStringList keys() const = 0;
virtual QList<QByteArray> availableDevices(QAudio::Mode) const = 0;
virtual QAbstractAudioInput* createInput(const QByteArray& device) = 0;
virtual QAbstractAudioOutput* createOutput(const QByteArray& device) = 0;
#include <qvideosurfaceformat.h>
#include <QtCore/qobject.h>
#include <QtCore/qplugin.h>
-#include <QtCore/qfactoryinterface.h>
#include <gst/gst.h>
/*!
Abstract interface for video buffers allocation.
*/
-class QGstBufferPoolInterface : public QFactoryInterface
+class QGstBufferPoolInterface
{
public:
virtual ~QGstBufferPoolInterface() {}
class QGstBufferPoolPlugin : public QObject, public QGstBufferPoolInterface
{
Q_OBJECT
- Q_INTERFACES(QGstBufferPoolInterface:QFactoryInterface)
+ Q_INTERFACES(QGstBufferPoolInterface)
public:
explicit QGstBufferPoolPlugin(QObject *parent = 0);
virtual ~QGstBufferPoolPlugin() {}
This method is called from gstreamer video sink thread.
*/
virtual QAbstractVideoBuffer *prepareVideoBuffer(GstBuffer *buffer, int bytesPerLine) = 0;
-
- virtual QStringList keys() const = 0;
};
QT_END_NAMESPACE
TARGET = QtMultimedia
QPRO_PWD = $$PWD
-QT = core network gui
+QT = core-private network gui
CONFIG += module
MODULE_PRI += ../../modules/qt_multimedia.pri
#include <QtCore/qobject.h>
#include <QtCore/qplugin.h>
-#include <QtCore/qfactoryinterface.h>
#include <qtmultimediadefs.h>
virtual void close() = 0;
};
-struct Q_MULTIMEDIA_EXPORT QMediaPlaylistIOInterface : public QFactoryInterface
+struct Q_MULTIMEDIA_EXPORT QMediaPlaylistIOInterface
{
virtual bool canRead(QIODevice *device, const QByteArray &format = QByteArray() ) const = 0;
virtual bool canRead(const QUrl& location, const QByteArray &format = QByteArray()) const = 0;
class Q_MULTIMEDIA_EXPORT QMediaPlaylistIOPlugin : public QObject, public QMediaPlaylistIOInterface
{
Q_OBJECT
-Q_INTERFACES(QMediaPlaylistIOInterface:QFactoryInterface)
+Q_INTERFACES(QMediaPlaylistIOInterface)
public:
explicit QMediaPlaylistIOPlugin(QObject *parent = 0);
virtual ~QMediaPlaylistIOPlugin();
virtual bool canWrite(QIODevice *device, const QByteArray &format) const = 0;
- virtual QStringList keys() const = 0;
-
virtual QMediaPlaylistReader *createReader(QIODevice *device, const QByteArray &format = QByteArray()) = 0;
virtual QMediaPlaylistReader *createReader(const QUrl& location, const QByteArray &format = QByteArray()) = 0;
#include "qmediapluginloader_p.h"
#include <QtCore/qcoreapplication.h>
-#include <QtCore/qpluginloader.h>
-#include <QtCore/qdir.h>
#include <QtCore/qdebug.h>
+#include <QtCore/qjsonarray.h>
+#include <private/qfactoryloader_p.h>
#include "qmediaserviceproviderplugin.h"
-#if defined(Q_OS_MAC)
-# include <CoreFoundation/CoreFoundation.h>
-#endif
-
QT_BEGIN_NAMESPACE
-typedef QMap<QString,QObjectList> ObjectListMap;
-Q_GLOBAL_STATIC(ObjectListMap, staticMediaPlugins);
-
-
-QMediaPluginLoader::QMediaPluginLoader(const char *iid, const QString &location, Qt::CaseSensitivity):
+QMediaPluginLoader::QMediaPluginLoader(const char *iid, const QString &location, Qt::CaseSensitivity caseSensitivity):
m_iid(iid)
{
m_location = QString::fromLatin1("/%1").arg(location);
- load();
+ m_factoryLoader = new QFactoryLoader(m_iid, m_location, caseSensitivity);
+ loadMetadata();
}
-QStringList QMediaPluginLoader::keys() const
+QMediaPluginLoader::~QMediaPluginLoader()
{
- return m_instances.keys();
+ delete m_factoryLoader;
}
-QObject* QMediaPluginLoader::instance(QString const &key)
+QStringList QMediaPluginLoader::keys() const
{
- return m_instances.value(key).value(0);
+ return m_metadata.keys();
}
-QList<QObject*> QMediaPluginLoader::instances(QString const &key)
+QObject* QMediaPluginLoader::instance(QString const &key)
{
- return m_instances.value(key);
-}
+ if (!m_metadata.contains(key))
+ return 0;
-//to be used for testing purposes only
-void QMediaPluginLoader::setStaticPlugins(const QString &location, const QObjectList& objects)
-{
- staticMediaPlugins()->insert(QString::fromLatin1("/%1").arg(location), objects);
+ int idx = m_metadata.value(key).first().value(QStringLiteral("index")).toDouble();
+ if (idx < 0)
+ return 0;
+
+ return m_factoryLoader->instance(idx);
}
-QStringList QMediaPluginLoader::availablePlugins() const
+QList<QObject*> QMediaPluginLoader::instances(QString const &key)
{
- QStringList paths;
- QStringList plugins;
-
-#if defined(Q_OS_MAC)
- QString imageSuffix(qgetenv("DYLD_IMAGE_SUFFIX"));
-
- // Bundle plugin directory
- CFBundleRef mainBundle = CFBundleGetMainBundle();
- if (mainBundle != 0) {
- CFURLRef baseUrl = CFBundleCopyBundleURL(mainBundle);
- CFURLRef pluginUrlPart = CFBundleCopyBuiltInPlugInsURL(mainBundle);
- CFStringRef pluginPathPart = CFURLCopyFileSystemPath(pluginUrlPart, kCFURLPOSIXPathStyle);
- CFURLRef pluginUrl = CFURLCreateCopyAppendingPathComponent(0, baseUrl, pluginPathPart, true);
- CFStringRef pluginPath = CFURLCopyFileSystemPath(pluginUrl, kCFURLPOSIXPathStyle);
-
- CFIndex length = CFStringGetLength(pluginPath);
- UniChar buffer[length];
- CFStringGetCharacters(pluginPath, CFRangeMake(0, length), buffer);
-
- paths << QString(reinterpret_cast<const QChar *>(buffer), length);
-
- CFRelease(pluginPath);
- CFRelease(pluginUrl);
- CFRelease(pluginPathPart);
- CFRelease(pluginUrlPart);
- CFRelease(baseUrl);
- }
-#endif
-
- // Qt paths
- paths << QCoreApplication::libraryPaths();
-
- foreach (const QString &path, paths) {
- QDir typeDir(path + m_location);
- foreach (const QString &file, typeDir.entryList(QDir::Files, QDir::Name)) {
-#if defined(Q_OS_MAC)
- if (!imageSuffix.isEmpty()) { // Only add appropriate images
- if (file.lastIndexOf(imageSuffix, -6) == -1)
- continue;
- } else {
- int foundSuffix = file.lastIndexOf(QLatin1String("_debug.dylib"));
- if (foundSuffix == -1) {
- foundSuffix = file.lastIndexOf(QLatin1String("_profile.dylib"));
- }
- if (foundSuffix != -1) {
- /*
- If this is a "special" version of the plugin, prefer the release
- version, where available.
- Avoids warnings like:
-
- objc[23101]: Class TransparentQTMovieView is implemented in both
- libqqt7engine_debug.dylib and libqqt7engine.dylib. One of the two
- will be used. Which one is undefined.
-
- Note, this code relies on QDir::Name sorting!
- */
-
- QString preferred =
- typeDir.absoluteFilePath(file.left(foundSuffix) + QLatin1String(".dylib"));
-
- if (plugins.contains(preferred)) {
- continue;
- }
- }
- }
-#elif defined(Q_OS_UNIX)
- // Ignore separate debug files
- if (file.endsWith(QLatin1String(".debug")))
- continue;
-#elif defined(Q_OS_WIN)
- // Ignore non-dlls
- if (!file.endsWith(QLatin1String(".dll"), Qt::CaseInsensitive))
- continue;
-#endif
- plugins << typeDir.absoluteFilePath(file);
+ if (!m_metadata.contains(key))
+ return QList<QObject*>();
+
+ QList<QObject *> objects;
+ foreach (QJsonObject jsonobj, m_metadata.value(key)) {
+ int idx = jsonobj.value(QStringLiteral("index")).toDouble();
+ if (idx < 0)
+ continue;
+
+ QObject *object = m_factoryLoader->instance(idx);
+ if (!objects.contains(object)) {
+ objects.append(object);
}
}
- return plugins;
+ return objects;
}
-void QMediaPluginLoader::load()
+void QMediaPluginLoader::loadMetadata()
{
- if (!m_instances.isEmpty())
- return;
-
#if !defined QT_NO_DEBUG
const bool showDebug = qgetenv("QT_DEBUG_PLUGINS").toInt() > 0;
#endif
- if (staticMediaPlugins() && staticMediaPlugins()->contains(m_location)) {
- foreach(QObject *o, staticMediaPlugins()->value(m_location)) {
- if (o != 0 && o->qt_metacast(m_iid) != 0) {
- QFactoryInterface* p = qobject_cast<QFactoryInterface*>(o);
- if (p != 0) {
- foreach (QString const &key, p->keys())
- m_instances[key].append(o);
- }
- }
- }
- } else {
- QSet<QString> loadedPlugins;
-
- foreach (const QString &plugin, availablePlugins()) {
- QString fileName = QFileInfo(plugin).fileName();
- //don't try to load plugin with the same name if it's already loaded
- if (loadedPlugins.contains(fileName)) {
#if !defined QT_NO_DEBUG
- if (showDebug)
- qDebug() << "Skip loading plugin" << plugin;
+ if (showDebug)
+ qDebug() << "QMediaPluginLoader: loading metadata for iid " << m_iid << " at location " << m_location;
#endif
- continue;
- }
-
- QPluginLoader loader(plugin);
- QObject *o = loader.instance();
- if (o != 0 && o->qt_metacast(m_iid) != 0) {
- QFactoryInterface* p = qobject_cast<QFactoryInterface*>(o);
- if (p != 0) {
- foreach (const QString &key, p->keys())
- m_instances[key].append(o);
+ if (!m_metadata.isEmpty()) {
+#if !defined QT_NO_DEBUG
+ if (showDebug)
+ qDebug() << "QMediaPluginLoader: already loaded metadata, returning";
+#endif
+ return;
+ }
- loadedPlugins.insert(fileName);
+ QList<QJsonObject> meta = m_factoryLoader->metaData();
+ for (int i = 0; i < meta.size(); i++) {
+ QJsonObject jsonobj = meta.at(i).value(QStringLiteral("MetaData")).toObject();
+ jsonobj.insert(QStringLiteral("index"), i);
#if !defined QT_NO_DEBUG
- if (showDebug)
- qDebug() << "Loaded plugin" << plugin << "services:" << p->keys();
+ if (showDebug)
+ qDebug() << "QMediaPluginLoader: Inserted index " << i << " into metadata: " << jsonobj;
#endif
- }
- continue;
- } else {
+ QJsonArray arr = jsonobj.value(QStringLiteral("Keys")).toArray();
+ foreach (QJsonValue value, arr) {
+ QString key = value.toString();
+
+ if (!m_metadata.contains(key)) {
#if !defined QT_NO_DEBUG
if (showDebug)
- qWarning() << "QMediaPluginLoader: Failed to load plugin: " << plugin << loader.errorString();
+ qDebug() << "QMediaPluginLoader: Inserting new list for key: " << key;
#endif
+ m_metadata.insert(key, QList<QJsonObject>());
}
- loader.unload();
+ m_metadata[key].append(jsonobj);
}
}
}
#include <QtCore/qstring.h>
#include <QtCore/qstringlist.h>
#include <QtCore/qmap.h>
+#include <QtCore/qjsonobject.h>
QT_BEGIN_HEADER
QT_MODULE(Multimedia)
-
+class QFactoryLoader;
class QMediaServiceProviderPlugin;
class Q_MULTIMEDIA_EXPORT QMediaPluginLoader
QMediaPluginLoader(const char *iid,
const QString &suffix = QString(),
Qt::CaseSensitivity = Qt::CaseSensitive);
+ ~QMediaPluginLoader();
QStringList keys() const;
QObject* instance(QString const &key);
QList<QObject*> instances(QString const &key);
- static void setStaticPlugins(const QString &location, const QObjectList& objects);
-
private:
- void load();
- QStringList availablePlugins() const;
+ void loadMetadata();
QByteArray m_iid;
QString m_location;
- QMap<QString, QList<QObject *> > m_instances;
+ QMap<QString, QList<QJsonObject> > m_metadata;
+
+ QFactoryLoader *m_factoryLoader;
};
QT_END_NAMESPACE
#include <QtCore/qstringlist.h>
#include <QtCore/qplugin.h>
-#include <QtCore/qfactoryinterface.h>
#include <qtmedianamespace.h>
#include <qtmultimediadefs.h>
Q_DECLARE_OPERATORS_FOR_FLAGS(QMediaServiceProviderHint::Features)
-struct Q_MULTIMEDIA_EXPORT QMediaServiceProviderFactoryInterface : public QFactoryInterface
+struct Q_MULTIMEDIA_EXPORT QMediaServiceProviderFactoryInterface
{
- virtual QStringList keys() const = 0;
virtual QMediaService* create(QString const& key) = 0;
virtual void release(QMediaService *service) = 0;
};
class Q_MULTIMEDIA_EXPORT QMediaServiceProviderPlugin : public QObject, public QMediaServiceProviderFactoryInterface
{
Q_OBJECT
- Q_INTERFACES(QMediaServiceProviderFactoryInterface:QFactoryInterface)
+ Q_INTERFACES(QMediaServiceProviderFactoryInterface)
public:
- virtual QStringList keys() const = 0;
virtual QMediaService* create(const QString& key) = 0;
virtual void release(QMediaService *service) = 0;
};
#include <QtMultimedia/qvideoframe.h>
#include <QtMultimedia/qvideosurfaceformat.h>
#include <QtGui/qopenglfunctions.h>
-#include <QtCore/qfactoryinterface.h>
QT_BEGIN_HEADER
int m_orientation;
};
-class QSGVideoNodeFactory : public QFactoryInterface {
+class QSGVideoNodeFactoryInterface
+{
public:
virtual QList<QVideoFrame::PixelFormat> supportedPixelFormats(QAbstractVideoBuffer::HandleType handleType) const = 0;
virtual QSGVideoNode *createNode(const QVideoSurfaceFormat &format) = 0;
};
-#define QSGVideoNodeFactory_iid "com.nokia.Qt.QSGVideoNodeFactory"
-Q_DECLARE_INTERFACE(QSGVideoNodeFactory, QSGVideoNodeFactory_iid)
+#define QSGVideoNodeFactoryInterface_iid "com.nokia.Qt.QSGVideoNodeFactoryInterface"
+Q_DECLARE_INTERFACE(QSGVideoNodeFactoryInterface, QSGVideoNodeFactoryInterface_iid)
+
+class QSGVideoNodeFactoryPlugin : public QObject, public QSGVideoNodeFactoryInterface
+{
+ Q_OBJECT
+ Q_INTERFACES(QSGVideoNodeFactoryInterface)
+public:
+ virtual QList<QVideoFrame::PixelFormat> supportedPixelFormats(QAbstractVideoBuffer::HandleType handleType) const = 0;
+ virtual QSGVideoNode *createNode(const QVideoSurfaceFormat &format) = 0;
+};
QT_END_NAMESPACE
--- /dev/null
+{
+ "Keys": ["com.nokia.qt.audiosource"]
+}
target.path += $$[QT_INSTALL_PLUGINS]/$${PLUGIN_TYPE}
INSTALLS += target
+
+OTHER_FILES += \
+ audiocapture.json
#include "qmediaserviceproviderplugin.h"
-QStringList AudioCaptureServicePlugin::keys() const
-{
- return QStringList() << QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE);
-}
-
QMediaService* AudioCaptureServicePlugin::create(QString const& key)
{
if (key == QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE))
delete service;
}
-Q_EXPORT_PLUGIN2(qtmedia_audioengine, AudioCaptureServicePlugin);
-
{
Q_OBJECT
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaServiceProviderFactoryInterface/1.0" FILE "audiocapture.json")
+
public:
- QStringList keys() const;
QMediaService* create(QString const& key);
void release(QMediaService *service);
};
--- /dev/null
+{
+ "Keys": ["com.nokia.qt.camera", "com.nokia.qt.mediaplayer"]
+}
target.path += $$[QT_INSTALL_PLUGINS]/$${PLUGIN_TYPE}
INSTALLS += target
+
+OTHER_FILES += \
+ directshow.json
QT_USE_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
return new DirectShowPlayerService;
#endif
- qDebug() << "unsupported key:" << key;
return 0;
}
}
#endif
-Q_EXPORT_PLUGIN2(qtmedia_dsengine, DSServicePlugin);
-
Q_OBJECT
Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
Q_INTERFACES(QMediaServiceFeaturesInterface)
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaServiceProviderFactoryInterface/1.0", FILE "directshow.json")
+
public:
- QStringList keys() const;
QMediaService* create(QString const& key);
void release(QMediaService *service);
--- /dev/null
+{
+ "Keys": ["com.nokia.qt.mediaplayer", "com.nokia.qt.audiosource", "com.nokia.qt.camera", "com.nokia.qt.audiodecode"]
+}
LIBS += -lgstapp-0.10
}
+OTHER_FILES += gstreamer.json
+
#Camerabin2 based camera backend is untested and currently disabled
#contains(config_test_gstreamer_photography, yes) {
#include <linux/videodev2.h>
-QStringList QGstreamerServicePlugin::keys() const
-{
- return QStringList()
-#ifdef QMEDIA_GSTREAMER_PLAYER
- << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER)
-#endif
-#ifdef QMEDIA_GSTREAMER_AUDIO_DECODER
- << QLatin1String(Q_MEDIASERVICE_AUDIODECODER)
-#endif
-#ifdef QMEDIA_GSTREAMER_CAPTURE
- << QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE)
- << QLatin1String(Q_MEDIASERVICE_CAMERA)
-#elif defined(QMEDIA_GSTREAMER_CAMERABIN)
- << QLatin1String(Q_MEDIASERVICE_CAMERA)
-#endif
- ;
-
-}
-
QMediaService* QGstreamerServicePlugin::create(const QString &key)
{
static bool initialized = false;
return QStringList();
}
-Q_EXPORT_PLUGIN2(qtmedia_gstengine, QGstreamerServicePlugin);
#include <qmediaserviceproviderplugin.h>
#include <QtCore/qset.h>
+#include <QtCore/QObject>
QT_BEGIN_NAMESPACE
Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
Q_INTERFACES(QMediaServiceFeaturesInterface)
Q_INTERFACES(QMediaServiceSupportedFormatsInterface)
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaServiceProviderFactoryInterface/1.0" FILE "gstreamer.json")
public:
- QStringList keys() const;
QMediaService* create(QString const& key);
void release(QMediaService *service);
--- /dev/null
+{
+ "Keys": ["m3u"]
+}
HEADERS += qm3uhandler.h
-SOURCES += main.cpp \
- qm3uhandler.cpp
+SOURCES += qm3uhandler.cpp
target.path += $$[QT_INSTALL_PLUGINS]/$${PLUGIN_TYPE}
INSTALLS += target
+
+OTHER_FILES += \
+ m3u.json
return device->isOpen() && device->isWritable() && format == "m3u";
}
-QStringList QM3uPlaylistPlugin::keys() const
-{
- return QStringList() << QLatin1String("m3u");
-}
-
QMediaPlaylistReader *QM3uPlaylistPlugin::createReader(QIODevice *device, const QByteArray &format)
{
Q_UNUSED(format);
#define QM3UHANDLER_H
#include <private/qmediaplaylistioplugin_p.h>
-#include <QObject>
+#include <QtCore/QObject>
QT_USE_NAMESPACE
class QM3uPlaylistPlugin : public QMediaPlaylistIOPlugin
{
-Q_OBJECT
+ Q_OBJECT
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaPlaylistIOInterface" FILE "m3u.json")
+
public:
explicit QM3uPlaylistPlugin(QObject *parent = 0);
virtual ~QM3uPlaylistPlugin();
virtual bool canWrite(QIODevice *device, const QByteArray &format) const;
- virtual QStringList keys() const;
-
virtual QMediaPlaylistReader *createReader(QIODevice *device, const QByteArray &format = QByteArray());
virtual QMediaPlaylistReader *createReader(const QUrl& location, const QByteArray &format = QByteArray());
--- /dev/null
+{
+ "Keys": ["default"]
+}
target.path += $$[QT_INSTALL_PLUGINS]/$${PLUGIN_TYPE}
INSTALLS += target
+
+OTHER_FILES += \
+ pulseaudio.json
{
}
-QStringList QPulseAudioPlugin::keys() const
-{
- return QStringList() << "default";
-}
-
QList<QByteArray> QPulseAudioPlugin::availableDevices(QAudio::Mode mode) const
{
return m_pulseEngine->availableDevices(mode);
return deviceInfo;
}
-Q_EXPORT_PLUGIN2(qtmedia_pulse, QPulseAudioPlugin);
-
QT_END_NAMESPACE
{
Q_OBJECT
+ Q_PLUGIN_METADATA(IID "com.nokia.qt.QAudioSystemFactoryInterface" FILE "pulseaudio.json")
+
public:
QPulseAudioPlugin(QObject *parent = 0);
~QPulseAudioPlugin() {}
- QStringList keys() const;
QList<QByteArray> availableDevices(QAudio::Mode mode) const;
QAbstractAudioInput *createInput(const QByteArray &device);
QAbstractAudioOutput *createOutput(const QByteArray &device);
--- /dev/null
+{
+ "Keys": ["com.nokia.qt.mediaplayer"]
+}
target.path += $$[QT_INSTALL_PLUGINS]/$${PLUGIN_TYPE}
INSTALLS += target
+
+OTHER_FILES += \
+ qt7.json
, public QMediaServiceSupportedFormatsInterface
, public QMediaServiceFeaturesInterface
{
+ Q_OBJECT
Q_INTERFACES(QMediaServiceFeaturesInterface)
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaServiceProviderFactoryInterface/1.0" FILE "qt7.json")
+
public:
QT7ServicePlugin();
- QStringList keys() const;
QMediaService* create(QString const& key);
void release(QMediaService *service);
buildSupportedTypes();
}
-QStringList QT7ServicePlugin::keys() const
-{
- return QStringList()
-#ifdef QMEDIA_QT7_PLAYER
- << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER)
-#endif
- ;
-}
-
QMediaService* QT7ServicePlugin::create(QString const& key)
{
#ifdef QT_DEBUG_QT7
}
}
-Q_EXPORT_PLUGIN2(qtmedia_qt7engine, QT7ServicePlugin);
-
QT_END_NAMESPACE
content2 = QMediaContent(QUrl(QLatin1String("file:///2")));
content3 = QMediaContent(QUrl(QLatin1String("file:///3")));
- QMediaPluginLoader::setStaticPlugins(QLatin1String("playlistformats"), QObjectList() << new QM3uPlaylistPlugin(this));
}
void tst_QMediaPlaylist::cleanup()
void tst_QMediaPluginLoader::initTestCase()
{
loader = new QMediaPluginLoader(QMediaServiceProviderFactoryInterface_iid,
- QLatin1String("/mediaservice"),
+ QLatin1String("mediaservice"),
Qt::CaseInsensitive);
}
**
****************************************************************************/
-#include "qm3uhandler.h"
-#include <qstringlist.h>
+#ifndef MOCKSERVICE_H
+#define MOCKSERVICE_H
+#include <qmediaservice.h>
-Q_EXPORT_STATIC_PLUGIN(QM3uPlaylistPlugin)
-Q_EXPORT_PLUGIN2(qtmultimedia_m3u, QM3uPlaylistPlugin)
+class MockMediaService : public QMediaService
+{
+ Q_OBJECT
+public:
+ MockMediaService(const QString& name, QObject *parent = 0) : QMediaService(parent)
+ { setObjectName(name); }
+ ~MockMediaService() {}
+
+ QMediaControl* requestControl(const char *) {return 0;}
+ void releaseControl(QMediaControl *) {}
+};
+
+#endif // MOCKSERVICE_H
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qmediaserviceproviderplugin.h>
+#include <qmediaservice.h>
+#include "../mockservice.h"
+
+class MockServicePlugin1 : public QMediaServiceProviderPlugin,
+ public QMediaServiceSupportedFormatsInterface,
+ public QMediaServiceSupportedDevicesInterface
+{
+ Q_OBJECT
+ Q_INTERFACES(QMediaServiceSupportedFormatsInterface)
+ Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaServiceProviderFactoryInterface/1.0" FILE "mockserviceplugin1.json")
+public:
+ QStringList keys() const
+ {
+ return QStringList() <<
+ QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER);
+ }
+
+ QMediaService* create(QString const& key)
+ {
+ if (keys().contains(key))
+ return new MockMediaService("MockServicePlugin1");
+ else
+ return 0;
+ }
+
+ void release(QMediaService *service)
+ {
+ delete service;
+ }
+
+ QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
+ {
+ if (codecs.contains(QLatin1String("mpeg4")))
+ return QtMultimedia::NotSupported;
+
+ if (mimeType == "audio/ogg") {
+ return QtMultimedia::ProbablySupported;
+ }
+
+ return QtMultimedia::MaybeSupported;
+ }
+
+ QStringList supportedMimeTypes() const
+ {
+ return QStringList("audio/ogg");
+ }
+
+ QList<QByteArray> devices(const QByteArray &service) const
+ {
+ Q_UNUSED(service);
+ QList<QByteArray> res;
+ return res;
+ }
+
+ QString deviceDescription(const QByteArray &service, const QByteArray &device)
+ {
+ if (devices(service).contains(device))
+ return QString(device)+" description";
+ else
+ return QString();
+ }
+};
+
+#include "mockserviceplugin1.moc"
+
--- /dev/null
+{
+ "Keys": ["com.nokia.qt.mediaplayer"]
+}
--- /dev/null
+
+load(qt_module)
+
+TARGET = mockserviceplugin1
+QT += multimedia-private
+CONFIG += no_private_qt_headers_warning
+
+PLUGIN_TYPE=mediaservice
+DESTDIR = ../$${PLUGIN_TYPE}
+
+load(qt_plugin)
+
+HEADERS += ../mockservice.h
+SOURCES += mockserviceplugin1.cpp
+OTHER_FILES += mockserviceplugin1.json
+
+target.path += $$[QT_INSTALL_TESTS]/tst_qmediaserviceprovider/$${PLUGIN_TYPE}
+INSTALLS += target
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qmediaserviceproviderplugin.h>
+#include <qmediaservice.h>
+#include "../mockservice.h"
+
+class MockServicePlugin2 : public QMediaServiceProviderPlugin,
+ public QMediaServiceSupportedFormatsInterface,
+ public QMediaServiceFeaturesInterface
+{
+ Q_OBJECT
+ Q_INTERFACES(QMediaServiceSupportedFormatsInterface)
+ Q_INTERFACES(QMediaServiceFeaturesInterface)
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaServiceProviderFactoryInterface/1.0" FILE "mockserviceplugin2.json")
+public:
+ QStringList keys() const
+ {
+ return QStringList() << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER)
+ << QLatin1String(Q_MEDIASERVICE_RADIO);
+ }
+
+ QMediaService* create(QString const& key)
+ {
+ if (keys().contains(key))
+ return new MockMediaService("MockServicePlugin2");
+ else
+ return 0;
+ }
+
+ void release(QMediaService *service)
+ {
+ delete service;
+ }
+
+ QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
+ {
+ Q_UNUSED(codecs);
+
+ if (mimeType == "audio/wav")
+ return QtMultimedia::PreferredService;
+
+ return QtMultimedia::NotSupported;
+ }
+
+ QStringList supportedMimeTypes() const
+ {
+ return QStringList("audio/wav");
+ }
+
+ QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const
+ {
+ if (service == QByteArray(Q_MEDIASERVICE_MEDIAPLAYER))
+ return QMediaServiceProviderHint::LowLatencyPlayback;
+ else
+ return 0;
+ }
+};
+
+#include "mockserviceplugin2.moc"
+
--- /dev/null
+{
+ "Keys": ["com.nokia.qt.mediaplayer", "com.nokia.qt.radio"]
+}
--- /dev/null
+
+load(qt_module)
+
+TARGET = mockserviceplugin2
+QT += multimedia-private
+CONFIG += no_private_qt_headers_warning
+
+PLUGIN_TYPE=mediaservice
+DESTDIR = ../$${PLUGIN_TYPE}
+
+load(qt_plugin)
+
+HEADERS += ../mockservice.h
+SOURCES += mockserviceplugin2.cpp
+OTHER_FILES += mockserviceplugin2.json
+
+target.path += $$[QT_INSTALL_TESTS]/tst_qmediaserviceprovider/$${PLUGIN_TYPE}
+INSTALLS += target
**
****************************************************************************/
-#ifndef QAUDIOPLUGINLOADER_H
-#define QAUDIOPLUGINLOADER_H
+#include <qmediaserviceproviderplugin.h>
+#include <qmediaservice.h>
+#include "../mockservice.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 <qtmultimediadefs.h>
-#include <QObject>
-#include <QtCore/qstring.h>
-#include <QtCore/qmap.h>
-#include <QtCore/qmutex.h>
-#include <QtCore/qpluginloader.h>
-
-
-QT_BEGIN_HEADER
-
-QT_BEGIN_NAMESPACE
-
-QT_MODULE(Multimedia)
-
-
-class QAudioPluginLoader
+class MockServicePlugin3 : public QMediaServiceProviderPlugin,
+ public QMediaServiceSupportedDevicesInterface
{
+ Q_OBJECT
+ Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaServiceProviderFactoryInterface/1.0" FILE "mockserviceplugin3.json")
public:
- QAudioPluginLoader(const char *iid,
- const QString &suffix = QString(),
- Qt::CaseSensitivity = Qt::CaseSensitive);
-
- ~QAudioPluginLoader();
-
- QStringList keys() const;
- QObject* instance(QString const &key);
- QList<QObject*> instances(QString const &key);
-
-private:
- QStringList pluginList() const;
- void load();
-
- QMutex m_mutex;
-
- QByteArray m_iid;
- QString m_location;
- QList<QPluginLoader*> m_plugins;
+ QStringList keys() const
+ {
+ return QStringList() <<
+ QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER) <<
+ QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE);
+ }
+
+ QMediaService* create(QString const& key)
+ {
+ if (keys().contains(key))
+ return new MockMediaService("MockServicePlugin3");
+ else
+ return 0;
+ }
+
+ void release(QMediaService *service)
+ {
+ delete service;
+ }
+
+ QList<QByteArray> devices(const QByteArray &service) const
+ {
+ QList<QByteArray> res;
+ if (service == QByteArray(Q_MEDIASERVICE_AUDIOSOURCE))
+ res << "audiosource1" << "audiosource2";
+
+ return res;
+ }
+
+ QString deviceDescription(const QByteArray &service, const QByteArray &device)
+ {
+ if (devices(service).contains(device))
+ return QString(device)+" description";
+ else
+ return QString();
+ }
};
-QT_END_NAMESPACE
-
-QT_END_HEADER
-
+#include "mockserviceplugin3.moc"
-#endif // QAUDIOPLUGINLOADER_H
--- /dev/null
+{
+ "Keys": ["com.nokia.qt.mediaplayer", "com.nokia.qt.audiosource"]
+}
--- /dev/null
+
+load(qt_module)
+
+TARGET = mockserviceplugin3
+QT += multimedia-private
+CONFIG += no_private_qt_headers_warning
+
+PLUGIN_TYPE=mediaservice
+DESTDIR = ../$${PLUGIN_TYPE}
+
+load(qt_plugin)
+
+HEADERS += ../mockservice.h
+SOURCES += mockserviceplugin3.cpp
+OTHER_FILES += mockserviceplugin3.json
+
+target.path += $$[QT_INSTALL_TESTS]/tst_qmediaserviceprovider/$${PLUGIN_TYPE}
+INSTALLS += target
--- /dev/null
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qmediaserviceproviderplugin.h>
+#include <qmediaservice.h>
+#include "../mockservice.h"
+
+class MockServicePlugin4 : public QMediaServiceProviderPlugin,
+ public QMediaServiceSupportedFormatsInterface,
+ public QMediaServiceFeaturesInterface
+{
+ Q_OBJECT
+ Q_INTERFACES(QMediaServiceSupportedFormatsInterface)
+ Q_INTERFACES(QMediaServiceFeaturesInterface)
+ Q_PLUGIN_METADATA(IID "com.nokia.Qt.QMediaServiceProviderFactoryInterface/1.0" FILE "mockserviceplugin4.json")
+public:
+ QStringList keys() const
+ {
+ return QStringList() << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER);
+ }
+
+ QMediaService* create(QString const& key)
+ {
+ if (keys().contains(key))
+ return new MockMediaService("MockServicePlugin4");
+ else
+ return 0;
+ }
+
+ void release(QMediaService *service)
+ {
+ delete service;
+ }
+
+ QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
+ {
+ if (codecs.contains(QLatin1String("jpeg2000")))
+ return QtMultimedia::NotSupported;
+
+ if (supportedMimeTypes().contains(mimeType))
+ return QtMultimedia::ProbablySupported;
+
+ return QtMultimedia::MaybeSupported;
+ }
+
+ QStringList supportedMimeTypes() const
+ {
+ return QStringList() << "video/mp4" << "video/quicktime";
+ }
+
+ QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const
+ {
+ if (service == QByteArray(Q_MEDIASERVICE_MEDIAPLAYER))
+ return QMediaServiceProviderHint::StreamPlayback;
+ else
+ return 0;
+ }
+};
+
+#include "mockserviceplugin4.moc"
+
--- /dev/null
+{
+ "Keys": ["com.nokia.qt.mediaplayer"]
+}
--- /dev/null
+
+load(qt_module)
+
+TARGET = mockserviceplugin4
+QT += multimedia-private
+CONFIG += no_private_qt_headers_warning
+
+PLUGIN_TYPE=mediaservice
+DESTDIR = ../$${PLUGIN_TYPE}
+
+load(qt_plugin)
+
+HEADERS += ../mockservice.h
+SOURCES += mockserviceplugin4.cpp
+OTHER_FILES += mockserviceplugin4.json
+
+target.path += $$[QT_INSTALL_TESTS]/tst_qmediaserviceprovider/$${PLUGIN_TYPE}
+INSTALLS += target
-CONFIG += testcase
-TARGET = tst_qmediaserviceprovider
+TEMPLATE = subdirs
+CONFIG += ORDERED
-QT += multimedia-private testlib
-CONFIG += no_private_qt_headers_warning
+SUBDIRS += \
+ test \
+ mockserviceplugin1 \
+ mockserviceplugin2 \
+ mockserviceplugin3 \
+ mockserviceplugin4
-SOURCES += tst_qmediaserviceprovider.cpp
+# no special install rule for subdir
+INSTALLS =
--- /dev/null
+CONFIG += testcase
+TARGET = ../tst_qmediaserviceprovider
+
+QT += multimedia-private testlib
+CONFIG += no_private_qt_headers_warning
+
+SOURCES += ../tst_qmediaserviceprovider.cpp
+
+win32 {
+ CONFIG(debug, debug|release) {
+ TARGET = ../../debug/tst_qmediaserviceprovider
+ } else {
+ TARGET = ../../release/tst_qmediaserviceprovider
+ }
+}
+
#include <qaudiorecorder.h>
QT_USE_NAMESPACE
-class MockMediaService : public QMediaService
-{
- Q_OBJECT
-public:
- MockMediaService(const QString& name, QObject *parent = 0) : QMediaService(parent)
- { setObjectName(name); }
- ~MockMediaService() {}
-
- QMediaControl* requestControl(const char *) {return 0;}
- void releaseControl(QMediaControl *) {}
-};
-
-class MockServicePlugin1 : public QMediaServiceProviderPlugin,
- public QMediaServiceSupportedFormatsInterface,
- public QMediaServiceSupportedDevicesInterface
-{
- Q_OBJECT
- Q_INTERFACES(QMediaServiceSupportedFormatsInterface)
- Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
-public:
- QStringList keys() const
- {
- return QStringList() <<
- QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER);
- }
-
- QMediaService* create(QString const& key)
- {
- if (keys().contains(key))
- return new MockMediaService("MockServicePlugin1");
- else
- return 0;
- }
-
- void release(QMediaService *service)
- {
- delete service;
- }
-
- QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
- {
- if (codecs.contains(QLatin1String("mpeg4")))
- return QtMultimedia::NotSupported;
-
- if (mimeType == "audio/ogg") {
- return QtMultimedia::ProbablySupported;
- }
-
- return QtMultimedia::MaybeSupported;
- }
-
- QStringList supportedMimeTypes() const
- {
- return QStringList("audio/ogg");
- }
-
- QList<QByteArray> devices(const QByteArray &service) const
- {
- Q_UNUSED(service);
- QList<QByteArray> res;
- return res;
- }
-
- QString deviceDescription(const QByteArray &service, const QByteArray &device)
- {
- if (devices(service).contains(device))
- return QString(device)+" description";
- else
- return QString();
- }
-};
-
-class MockServicePlugin2 : public QMediaServiceProviderPlugin,
- public QMediaServiceSupportedFormatsInterface,
- public QMediaServiceFeaturesInterface
-{
- Q_OBJECT
- Q_INTERFACES(QMediaServiceSupportedFormatsInterface)
- Q_INTERFACES(QMediaServiceFeaturesInterface)
-public:
- QStringList keys() const
- {
- return QStringList() << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER)
- << QLatin1String(Q_MEDIASERVICE_RADIO);
- }
-
- QMediaService* create(QString const& key)
- {
- if (keys().contains(key))
- return new MockMediaService("MockServicePlugin2");
- else
- return 0;
- }
-
- void release(QMediaService *service)
- {
- delete service;
- }
-
- QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
- {
- Q_UNUSED(codecs);
-
- if (mimeType == "audio/wav")
- return QtMultimedia::PreferredService;
-
- return QtMultimedia::NotSupported;
- }
-
- QStringList supportedMimeTypes() const
- {
- return QStringList("audio/wav");
- }
-
- QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const
- {
- if (service == QByteArray(Q_MEDIASERVICE_MEDIAPLAYER))
- return QMediaServiceProviderHint::LowLatencyPlayback;
- else
- return 0;
- }
-};
-
-
-class MockServicePlugin3 : public QMediaServiceProviderPlugin,
- public QMediaServiceSupportedDevicesInterface
-{
- Q_OBJECT
- Q_INTERFACES(QMediaServiceSupportedDevicesInterface)
-public:
- QStringList keys() const
- {
- return QStringList() <<
- QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER) <<
- QLatin1String(Q_MEDIASERVICE_AUDIOSOURCE);
- }
-
- QMediaService* create(QString const& key)
- {
- if (keys().contains(key))
- return new MockMediaService("MockServicePlugin3");
- else
- return 0;
- }
-
- void release(QMediaService *service)
- {
- delete service;
- }
-
- QList<QByteArray> devices(const QByteArray &service) const
- {
- QList<QByteArray> res;
- if (service == QByteArray(Q_MEDIASERVICE_AUDIOSOURCE))
- res << "audiosource1" << "audiosource2";
-
- return res;
- }
-
- QString deviceDescription(const QByteArray &service, const QByteArray &device)
- {
- if (devices(service).contains(device))
- return QString(device)+" description";
- else
- return QString();
- }
-};
-
-class MockServicePlugin4 : public QMediaServiceProviderPlugin,
- public QMediaServiceSupportedFormatsInterface,
- public QMediaServiceFeaturesInterface
-{
- Q_OBJECT
- Q_INTERFACES(QMediaServiceSupportedFormatsInterface)
- Q_INTERFACES(QMediaServiceFeaturesInterface)
-public:
- QStringList keys() const
- {
- return QStringList() << QLatin1String(Q_MEDIASERVICE_MEDIAPLAYER);
- }
-
- QMediaService* create(QString const& key)
- {
- if (keys().contains(key))
- return new MockMediaService("MockServicePlugin4");
- else
- return 0;
- }
-
- void release(QMediaService *service)
- {
- delete service;
- }
-
- QtMultimedia::SupportEstimate hasSupport(const QString &mimeType, const QStringList& codecs) const
- {
- if (codecs.contains(QLatin1String("jpeg2000")))
- return QtMultimedia::NotSupported;
-
- if (supportedMimeTypes().contains(mimeType))
- return QtMultimedia::ProbablySupported;
-
- return QtMultimedia::MaybeSupported;
- }
-
- QStringList supportedMimeTypes() const
- {
- return QStringList() << "video/mp4" << "video/quicktime";
- }
-
- QMediaServiceProviderHint::Features supportedFeatures(const QByteArray &service) const
- {
- if (service == QByteArray(Q_MEDIASERVICE_MEDIAPLAYER))
- return QMediaServiceProviderHint::StreamPlayback;
- else
- return 0;
- }
-};
-
-
class MockMediaServiceProvider : public QMediaServiceProvider
{
void tst_QMediaServiceProvider::initTestCase()
{
- plugins << new MockServicePlugin1;
- plugins << new MockServicePlugin2;
- plugins << new MockServicePlugin3;
- plugins << new MockServicePlugin4;
-
- QMediaPluginLoader::setStaticPlugins(QLatin1String("mediaservice"), plugins);
+// QMediaPluginLoader::setStaticPlugins(QLatin1String("mediaservice"), plugins);
+ QCoreApplication::setLibraryPaths(QStringList() << QCoreApplication::applicationDirPath());
}
void tst_QMediaServiceProvider::testDefaultProviderAvailable()
projects / platform / upstream / qtmultimedia.git / commitdiff