File indexing completed on 2024-04-28 16:01:47

 /*  This file is part of the KDE project
     Copyright (C) 2006-2008 Matthias Kretz <kretz@kde.org>
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) version 3, or any
     later version accepted by the membership of KDE e.V. (or its
     successor approved by the membership of KDE e.V.), Nokia Corporation
     (or its successors, if any) and the KDE Free Qt Foundation, which shall
     act as a proxy defined in Section 6 of version 3 of the license.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.
 
     You should have received a copy of the GNU Lesser General Public
     License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
 */
 
 #include "globalconfig.h"
 #include "globalconfig_p.h"
 
 #include "factory_p.h"
 #include "phonondefs_p.h"
 #include "platformplugin.h"
 #include "backendinterface.h"
 #include "qsettingsgroup_p.h"
 #include "phononnamespace_p.h"
 #include "phononnamespace.h"
 #include "pulsesupport.h"
 
 #include <QList>
 #include <QVariant>
 
 namespace Phonon
 {
 
 GlobalConfigPrivate::GlobalConfigPrivate() : config(QLatin1String("kde.org"), QLatin1String("libphonon"))
 {
 }
 
 GlobalConfig::GlobalConfig()
     : k_ptr(new GlobalConfigPrivate)
 {
 }
 
 GlobalConfig::~GlobalConfig()
 {
     delete k_ptr;
 }
 
 enum WhatToFilter {
     FilterAdvancedDevices = 1,
     FilterHardwareDevices = 2,
     FilterUnavailableDevices = 4
 };
 
 static void filter(ObjectDescriptionType type, BackendInterface *backendIface, QList<int> *list, int whatToFilter)
 {
     QMutableListIterator<int> it(*list);
     while (it.hasNext()) {
         QHash<QByteArray, QVariant> properties;
         if (backendIface)
             properties = backendIface->objectDescriptionProperties(type, it.next());
         else
             properties = PulseSupport::getInstance()->objectDescriptionProperties(type, it.next());
         QVariant var;
         if (whatToFilter & FilterAdvancedDevices) {
             var = properties.value("isAdvanced");
             if (var.isValid() && var.toBool()) {
                 it.remove();
                 continue;
             }
         }
         if (whatToFilter & FilterHardwareDevices) {
             var = properties.value("isHardwareDevice");
             if (var.isValid() && var.toBool()) {
                 it.remove();
                 continue;
             }
         }
         if (whatToFilter & FilterUnavailableDevices) {
             var = properties.value("available");
             if (var.isValid() && !var.toBool()) {
                 it.remove();
                 continue;
             }
         }
     }
 }
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
 static QList<int> sortDevicesByCategoryPriority(const GlobalConfig *config, const QSettingsGroup *backendConfig, ObjectDescriptionType type, Category category, QList<int> &defaultList)
 {
     Q_ASSERT(config); Q_UNUSED(config);
     Q_ASSERT(backendConfig);
     Q_ASSERT(type == AudioOutputDeviceType);
 
     if (defaultList.size() <= 1) {
         // nothing to sort
         return defaultList;
     } else {
         // make entries unique
         QSet<int> seen;
         QMutableListIterator<int> it(defaultList);
         while (it.hasNext()) {
             if (seen.contains(it.next())) {
                 it.remove();
             } else {
                 seen.insert(it.value());
             }
         }
     }
 
     QList<int> deviceList;
     PulseSupport *pulse = PulseSupport::getInstance();
     if (pulse->isUsed()) {
         deviceList = pulse->objectIndexesByCategory(type, category);
     } else {
         QString categoryKey = QLatin1String("Category_") + QString::number(static_cast<int>(category));
         if (!backendConfig->hasKey(categoryKey)) {
             // no list in config for the given category
             categoryKey = QLatin1String("Category_") + QString::number(static_cast<int>(NoCategory));
             if (!backendConfig->hasKey(categoryKey)) {
                 // no list in config for NoCategory
                 return defaultList;
             }
         }
 
         //Now the list from d->config
         deviceList = backendConfig->value(categoryKey, QList<int>());
     }
 
     //if there are devices in d->config that the backend doesn't report, remove them from the list
     QMutableListIterator<int> i(deviceList);
     while (i.hasNext()) {
         if (0 == defaultList.removeAll(i.next())) {
             i.remove();
         }
     }
 
     //if the backend reports more devices that are not in d->config append them to the list
     deviceList += defaultList;
 
     return deviceList;
 }
 
 static QList<int> sortDevicesByCategoryPriority(const GlobalConfig *config, const QSettingsGroup *backendConfig, ObjectDescriptionType type, CaptureCategory category, QList<int> &defaultList)
 {
     Q_ASSERT(config); Q_UNUSED(config);
     Q_ASSERT(backendConfig);
     Q_ASSERT(type == AudioCaptureDeviceType || type == VideoCaptureDeviceType);
 
     if (defaultList.size() <= 1) {
         // nothing to sort
         return defaultList;
     } else {
         // make entries unique
         QSet<int> seen;
         QMutableListIterator<int> it(defaultList);
         while (it.hasNext()) {
             if (seen.contains(it.next())) {
                 it.remove();
             } else {
                 seen.insert(it.value());
             }
         }
     }
 
     QList<int> deviceList;
     PulseSupport *pulse = PulseSupport::getInstance();
     if (pulse->isUsed()) {
         deviceList = pulse->objectIndexesByCategory(type, category);
     } else {
         QString categoryKey = QLatin1String("Category_") + QString::number(static_cast<int>(category));
         if (!backendConfig->hasKey(categoryKey)) {
             // no list in config for the given category
             categoryKey = QLatin1String("Category_") + QString::number(static_cast<int>(NoCategory));
             if (!backendConfig->hasKey(categoryKey)) {
                 // no list in config for NoCategory
                 return defaultList;
             }
         }
 
         //Now the list from d->config
         deviceList = backendConfig->value(categoryKey, QList<int>());
     }
 
     //if there are devices in d->config that the backend doesn't report, remove them from the list
     QMutableListIterator<int> i(deviceList);
     while (i.hasNext()) {
         if (0 == defaultList.removeAll(i.next())) {
             i.remove();
         }
     }
 
     //if the backend reports more devices that are not in d->config append them to the list
     deviceList += defaultList;
 
     return deviceList;
 }
 
 bool GlobalConfig::hideAdvancedDevices() const
 {
     P_D(const GlobalConfig);
     //The devices need to be stored independently for every backend
     const QSettingsGroup generalGroup(&d->config, QLatin1String("General"));
     return generalGroup.value(QLatin1String("HideAdvancedDevices"), true);
 }
 
 void GlobalConfig::setHideAdvancedDevices(bool hide)
 {
     P_D(GlobalConfig);
     QSettingsGroup generalGroup(&d->config, QLatin1String("General"));
     generalGroup.setValue(QLatin1String("HideAdvancedDevices"), hide);
 }
 #endif // QT_NO_PHONON_SETTINGSGROUP
 
 static bool isHiddenAudioOutputDevice(const GlobalConfig *config, int i)
 {
     Q_ASSERT(config);
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     if (!config->hideAdvancedDevices())
         return false;
 #endif // QT_NO_PHONON_SETTINGSGROUP
 
     AudioOutputDevice ad = AudioOutputDevice::fromIndex(i);
     const QVariant var = ad.property("isAdvanced");
     return (var.isValid() && var.toBool());
 }
 
 #ifndef PHONON_NO_AUDIOCAPTURE
 static bool isHiddenAudioCaptureDevice(const GlobalConfig *config, int i)
 {
     Q_ASSERT(config);
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     if (!config->hideAdvancedDevices())
         return false;
 #endif // QT_NO_PHONON_SETTINGSGROUP
 
     AudioCaptureDevice ad = AudioCaptureDevice::fromIndex(i);
     const QVariant var = ad.property("isAdvanced");
     return (var.isValid() && var.toBool());
 }
 #endif
 
 #ifndef PHONON_NO_VIDEOCAPTURE
 static bool isHiddenVideoCaptureDevice(const GlobalConfig *config, int i)
 {
     Q_ASSERT(config);
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     if (!config->hideAdvancedDevices())
         return false;
 #endif // QT_NO_PHONON_SETTINGSGROUP
 
     VideoCaptureDevice vd = VideoCaptureDevice::fromIndex(i);
     const QVariant var = vd.property("isAdvanced");
     return (var.isValid() && var.toBool());
 }
 #endif
 
 static QList<int> reindexList(const GlobalConfig *config, ObjectDescriptionType type, Category category, QList<int>newOrder)
 {
     Q_ASSERT(config);
     Q_ASSERT(type == AudioOutputDeviceType);
     Q_UNUSED(type);
 
     /*QString sb;
     sb = QString("(Size %1)").arg(currentList.size());
     foreach (int i, currentList)
     sb += QString("%1, ").arg(i);
     fprintf(stderr, "=== Reindex Current: %s\n", sb.toUtf8().constData());
     sb = QString("(Size %1)").arg(newOrder.size());
     foreach (int i, newOrder)
     sb += QString("%1, ").arg(i);
     fprintf(stderr, "=== Reindex Before : %s\n", sb.toUtf8().constData());*/
 
     int override = GlobalConfig::ShowUnavailableDevices | GlobalConfig::ShowAdvancedDevices;
     QList<int> currentList = config->audioOutputDeviceListFor(category, override);
 
 
     QList<int> newList;
 
     foreach (int i, newOrder) {
         int found = currentList.indexOf(i);
         if (found < 0) {
             // It's not in the list, so something is odd (e.g. client error). Ignore it.
             continue;
         }
 
         // Iterate through the list from this point onward. If there are hidden devices
         // immediately following, take them too.
         newList.append(currentList.takeAt(found));
 
         while (found < currentList.size()) {
             bool hidden = isHiddenAudioOutputDevice(config, currentList.at(found));
             if (!hidden)
                 break;
 
             newList.append(currentList.takeAt(found));
         }
     }
 
     // If there are any devices left in.. just tack them on the end.
     if (currentList.size() > 0)
         newList += currentList;
 
     /*sb = QString("(Size %1)").arg(newList.size());
     foreach (int i, newList)
     sb += QString("%1, ").arg(i);
     fprintf(stderr, "=== Reindex After  : %s\n", sb.toUtf8().constData());*/
     return newList;
 }
 
 static QList<int> reindexList(const GlobalConfig *config, ObjectDescriptionType type, CaptureCategory category, QList<int>newOrder)
 {
     Q_ASSERT(config);
     Q_ASSERT(type == AudioCaptureDeviceType || type == VideoCaptureDeviceType);
 
     QList<int> currentList;
     int override = GlobalConfig::ShowUnavailableDevices | GlobalConfig::ShowAdvancedDevices;
 
     switch (type) {
 #ifndef PHONON_NO_AUDIOCAPTURE
     case AudioCaptureDeviceType:
         currentList = config->audioCaptureDeviceListFor(category, override);
         break;
 #endif
 
 #ifndef PHONON_NO_VIDEOCAPTURE
     case VideoCaptureDeviceType:
         currentList = config->videoCaptureDeviceListFor(category, override);
         break;
 #endif
 
     default: ;
     }
 
     QList<int> newList;
 
     foreach (int i, newOrder) {
         int found = currentList.indexOf(i);
         if (found < 0) {
             // It's not in the list, so something is odd (e.g. client error). Ignore it.
             continue;
         }
 
         // Iterate through the list from this point onward. If there are hidden devices
         // immediately following, take them too.
         newList.append(currentList.takeAt(found));
 
         while (found < currentList.size()) {
             bool hidden = true;
 
             switch (type) {
 #ifndef PHONON_NO_AUDIOCAPTURE
             case AudioCaptureDeviceType:
                 hidden = isHiddenAudioCaptureDevice(config, currentList.at(found));
                 break;
 #endif
 
 #ifndef PHONON_NO_VIDEOCAPTURE
             case VideoCaptureDeviceType:
                 hidden = isHiddenVideoCaptureDevice(config, currentList.at(found));
                 break;
 #endif
 
             default: ;
             }
 
             if (!hidden)
                 break;
 
             newList.append(currentList.takeAt(found));
         }
     }
 
     // If there are any devices left in.. just tack them on the end.
     if (currentList.size() > 0)
         newList += currentList;
 
     return newList;
 }
 
 void GlobalConfig::setAudioOutputDeviceListFor(Category category, QList<int> order)
 {
     PulseSupport *pulse = PulseSupport::getInstance();
     if (pulse->isUsed()) {
         pulse->setOutputDevicePriorityForCategory(category, order);
         return;
     }
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     P_D(GlobalConfig);
     QSettingsGroup backendConfig(&d->config, QLatin1String("AudioOutputDevice")); // + Factory::identifier());
 
     order = reindexList(this, AudioOutputDeviceType, category, order);
 
     const QList<int> noCategoryOrder = audioOutputDeviceListFor(NoCategory, ShowUnavailableDevices|ShowAdvancedDevices);
     if (category != NoCategory && order == noCategoryOrder) {
         backendConfig.removeEntry(QLatin1String("Category_") + QString::number(category));
     } else {
         backendConfig.setValue(QLatin1String("Category_") + QString::number(category), order);
     }
 #endif //QT_NO_PHONON_SETTINGSGROUP
 }
 
 QList<int> GlobalConfig::audioOutputDeviceListFor(Category category, int override) const
 {
     P_D(const GlobalConfig);
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     const bool hide = ((override & AdvancedDevicesFromSettings)
             ? hideAdvancedDevices()
             : static_cast<bool>(override & HideAdvancedDevices));
 #else
     const bool hide = !((override & AdvancedDevicesFromSettings) && static_cast<bool>(override & HideAdvancedDevices));
 #endif
 
     QList<int> defaultList;
 
     PulseSupport *pulse = PulseSupport::getInstance();
     if (pulse->isUsed()) {
         defaultList = pulse->objectDescriptionIndexes(AudioOutputDeviceType);
         if (hide || (override & HideUnavailableDevices)) {
             filter(AudioOutputDeviceType, nullptr, &defaultList,
                     (hide ? FilterAdvancedDevices : 0)
                     | ((override & HideUnavailableDevices) ? FilterUnavailableDevices : 0)
                     );
         }
     } else {
         BackendInterface *backendIface = qobject_cast<BackendInterface *>(Factory::backend());
 
 #ifndef QT_NO_PHONON_PLATFORMPLUGIN
         if (PlatformPlugin *platformPlugin = Factory::platformPlugin()) {
             // the platform plugin lists the audio devices for the platform
             // this list already is in default order (as defined by the platform plugin)
             defaultList = platformPlugin->objectDescriptionIndexes(AudioOutputDeviceType);
             if (hide) {
                 QMutableListIterator<int> it(defaultList);
                 while (it.hasNext()) {
                     AudioOutputDevice objDesc = AudioOutputDevice::fromIndex(it.next());
                     const QVariant var = objDesc.property("isAdvanced");
                     if (var.isValid() && var.toBool()) {
                         it.remove();
                     }
                 }
             }
         }
 #endif //QT_NO_PHONON_PLATFORMPLUGIN
 
         // lookup the available devices directly from the backend
         if (backendIface) {
             // this list already is in default order (as defined by the backend)
             QList<int> list = backendIface->objectDescriptionIndexes(AudioOutputDeviceType);
             if (hide || !defaultList.isEmpty() || (override & HideUnavailableDevices)) {
                 filter(AudioOutputDeviceType, backendIface, &list,
                         (hide ? FilterAdvancedDevices : 0)
                         // the platform plugin maybe already provided the hardware devices?
                         | (defaultList.isEmpty() ? 0 : FilterHardwareDevices)
                         | ((override & HideUnavailableDevices) ? FilterUnavailableDevices : 0)
                         );
             }
             defaultList += list;
         }
     }
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     const QSettingsGroup backendConfig(&d->config, QLatin1String("AudioOutputDevice")); // + Factory::identifier());
     return sortDevicesByCategoryPriority(this, &backendConfig, AudioOutputDeviceType, category, defaultList);
 #else //QT_NO_PHONON_SETTINGSGROUP
     return defaultList;
 #endif //QT_NO_PHONON_SETTINGSGROUP
 }
 
 
 int GlobalConfig::audioOutputDeviceFor(Category category, int override) const
 {
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     QList<int> ret = audioOutputDeviceListFor(category, override);
     if (!ret.isEmpty())
         return ret.first();
 #endif //QT_NO_PHONON_SETTINGSGROUP
     return -1;
 }
 
 QHash<QByteArray, QVariant> GlobalConfig::audioOutputDeviceProperties(int index) const
 {
     return deviceProperties(AudioOutputDeviceType, index);
 }
 
 
 #ifndef PHONON_NO_AUDIOCAPTURE
 void GlobalConfig::setAudioCaptureDeviceListFor(CaptureCategory category, QList<int> order)
 {
 
     PulseSupport *pulse = PulseSupport::getInstance();
     if (pulse->isUsed()) {
         pulse->setCaptureDevicePriorityForCategory(category, order);
         return;
     }
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     P_D(GlobalConfig);
     QSettingsGroup backendConfig(&d->config, QLatin1String("AudioCaptureDevice")); // + Factory::identifier());
 
     order = reindexList(this, AudioCaptureDeviceType, category, order);
 
     const QList<int> noCategoryOrder = audioCaptureDeviceListFor(NoCaptureCategory, ShowUnavailableDevices|ShowAdvancedDevices);
     if (category != NoCaptureCategory && order == noCategoryOrder) {
         backendConfig.removeEntry(QLatin1String("Category_") + QString::number(category));
     } else {
         backendConfig.setValue(QLatin1String("Category_") + QString::number(category), order);
     }
 #endif //QT_NO_PHONON_SETTINGSGROUP
 }
 
 QList<int> GlobalConfig::audioCaptureDeviceListFor(CaptureCategory category, int override) const
 {
     P_D(const GlobalConfig);
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     const bool hide = ((override & AdvancedDevicesFromSettings)
         ? hideAdvancedDevices()
         : static_cast<bool>(override & HideAdvancedDevices));
 #else
     const bool hide = !((override & AdvancedDevicesFromSettings) && static_cast<bool>(override & HideAdvancedDevices));
 #endif
 
     QList<int> defaultList;
 
     PulseSupport *pulse = PulseSupport::getInstance();
     if (pulse->isUsed()) {
         defaultList = pulse->objectDescriptionIndexes(AudioCaptureDeviceType);
         if (hide || (override & HideUnavailableDevices)) {
             filter(AudioCaptureDeviceType, nullptr, &defaultList,
                     (hide ? FilterAdvancedDevices : 0)
                     | ((override & HideUnavailableDevices) ? FilterUnavailableDevices : 0)
                     );
         }
     } else {
         BackendInterface *backendIface = qobject_cast<BackendInterface *>(Factory::backend());
 
 #ifndef QT_NO_PHONON_PLATFORMPLUGIN
         if (PlatformPlugin *platformPlugin = Factory::platformPlugin()) {
             // the platform plugin lists the audio devices for the platform
             // this list already is in default order (as defined by the platform plugin)
             defaultList += platformPlugin->objectDescriptionIndexes(AudioCaptureDeviceType);
             if (hide) {
                 QMutableListIterator<int> it(defaultList);
                 while (it.hasNext()) {
                     AudioCaptureDevice objDesc = AudioCaptureDevice::fromIndex(it.next());
                     const QVariant var = objDesc.property("isAdvanced");
                     if (var.isValid() && var.toBool()) {
                         it.remove();
                     }
                 }
             }
         }
 #endif //QT_NO_PHONON_PLATFORMPLUGIN
 
         // lookup the available devices directly from the backend
         if (backendIface) {
             // this list already is in default order (as defined by the backend)
             QList<int> list = backendIface->objectDescriptionIndexes(AudioCaptureDeviceType);
             if (hide || !defaultList.isEmpty() || (override & HideUnavailableDevices)) {
                 filter(AudioCaptureDeviceType, backendIface, &list,
                         (hide ? FilterAdvancedDevices : 0)
                         // the platform plugin maybe already provided the hardware devices?
                         | (defaultList.isEmpty() ? 0 : FilterHardwareDevices)
                         | ((override & HideUnavailableDevices) ? FilterUnavailableDevices : 0)
                         );
             }
             defaultList += list;
         }
     }
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     const QSettingsGroup backendConfig(&d->config, QLatin1String("AudioCaptureDevice")); // + Factory::identifier());
     return sortDevicesByCategoryPriority(this, &backendConfig, AudioCaptureDeviceType, category, defaultList);
 #else //QT_NO_PHONON_SETTINGSGROUP
 #ifndef QT_NO_PHONON_PLATFORMPLUGIN
     return defaultList;
 #else //QT_NO_PHONON_PLATFORMPLUGIN
     return QList<int>();
 #endif //QT_NO_PHONON_PLATFORMPLUGIN
 #endif //QT_NO_PHONON_SETTINGSGROUP
 }
 
 int GlobalConfig::audioCaptureDeviceFor(CaptureCategory category, int override) const
 {
     QList<int> ret = audioCaptureDeviceListFor(category, override);
     if (ret.isEmpty())
         return -1;
     return ret.first();
 }
 
 QHash<QByteArray, QVariant> GlobalConfig::audioCaptureDeviceProperties(int index) const
 {
     return deviceProperties(AudioCaptureDeviceType, index);
 }
 
 void GlobalConfig::setAudioCaptureDeviceListFor(Category category, QList<int> order)
 {
     CaptureCategory cat = categoryToCaptureCategory(category);
     setAudioCaptureDeviceListFor(cat, order);
 }
 
 QList<int> GlobalConfig::audioCaptureDeviceListFor(Category category, int override) const
 {
     CaptureCategory cat = categoryToCaptureCategory(category);
     return audioCaptureDeviceListFor(cat, override);
 }
 
 int GlobalConfig::audioCaptureDeviceFor(Category category, int override) const
 {
     CaptureCategory cat = categoryToCaptureCategory(category);
     return audioCaptureDeviceFor(cat, override);
 }
 
 #endif //PHONON_NO_AUDIOCAPTURE
 
 
 #ifndef PHONON_NO_VIDEOCAPTURE
 void GlobalConfig::setVideoCaptureDeviceListFor(CaptureCategory category, QList<int> order)
 {
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     P_D(GlobalConfig);
     QSettingsGroup backendConfig(&d->config, QLatin1String("VideoCaptureDevice")); // + Factory::identifier());
 
     order = reindexList(this, VideoCaptureDeviceType, category, order);
 
     const QList<int> noCategoryOrder = videoCaptureDeviceListFor(NoCaptureCategory, ShowUnavailableDevices|ShowAdvancedDevices);
     if (category != NoCaptureCategory && order == noCategoryOrder) {
         backendConfig.removeEntry(QLatin1String("Category_") + QString::number(category));
     } else {
         backendConfig.setValue(QLatin1String("Category_") + QString::number(category), order);
     }
 #endif //QT_NO_PHONON_SETTINGSGROUP
 }
 
 QList<int> GlobalConfig::videoCaptureDeviceListFor(CaptureCategory category, int override) const
 {
     P_D(const GlobalConfig);
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     const bool hide = ((override & AdvancedDevicesFromSettings)
         ? hideAdvancedDevices()
         : static_cast<bool>(override & HideAdvancedDevices));
 #else
     const bool hide = !((override & AdvancedDevicesFromSettings) && static_cast<bool>(override & HideAdvancedDevices));
 #endif
 
     //First we lookup the available devices directly from the backend
     BackendInterface *backendIface = qobject_cast<BackendInterface *>(Factory::backend());
     if (!backendIface) {
         return QList<int>();
     }
 
     // this list already is in default order (as defined by the backend)
     QList<int> defaultList = backendIface->objectDescriptionIndexes(VideoCaptureDeviceType);
 
 #ifndef QT_NO_PHONON_PLATFORMPLUGIN
     if (PlatformPlugin *platformPlugin = Factory::platformPlugin()) {
         // the platform plugin lists the video devices for the platform
         // this list already is in default order (as defined by the platform plugin)
         defaultList += platformPlugin->objectDescriptionIndexes(VideoCaptureDeviceType);
         if (hide) {
             QMutableListIterator<int> it(defaultList);
             while (it.hasNext()) {
                 VideoCaptureDevice objDesc = VideoCaptureDevice::fromIndex(it.next());
                 const QVariant var = objDesc.property("isAdvanced");
                 if (var.isValid() && var.toBool()) {
                     it.remove();
                 }
             }
         }
     }
 #endif //QT_NO_PHONON_PLATFORMPLUGIN
 
 #ifndef QT_NO_PHONON_SETTINGSGROUP
     if (hideAdvancedDevices() || (override & HideUnavailableDevices)) {
         filter(VideoCaptureDeviceType, backendIface, &defaultList,
             (hideAdvancedDevices() ? FilterAdvancedDevices : 0) |
             ((override & HideUnavailableDevices) ? FilterUnavailableDevices : 0)
             );
     }
 
     //The devices need to be stored independently for every backend
     const QSettingsGroup backendConfig(&d->config, QLatin1String("VideoCaptureDevice")); // + Factory::identifier());
     return sortDevicesByCategoryPriority(this, &backendConfig, VideoCaptureDeviceType, category, defaultList);
 #else // QT_NO_PHONON_SETTINGSGROUP
     return defaultList;
 #endif // QT_NO_PHONON_SETTINGSGROUP
 }
 
 int GlobalConfig::videoCaptureDeviceFor(CaptureCategory category, int override) const
 {
     QList<int> ret = videoCaptureDeviceListFor(category, override);
     if (ret.isEmpty())
         return -1;
     return ret.first();
 }
 
 QHash<QByteArray, QVariant> GlobalConfig::videoCaptureDeviceProperties(int index) const
 {
     return deviceProperties(VideoCaptureDeviceType, index);
 }
 
 void GlobalConfig::setVideoCaptureDeviceListFor(Category category, QList<int> order)
 {
     CaptureCategory cat = categoryToCaptureCategory(category);
     setVideoCaptureDeviceListFor(cat, order);
 }
 
 QList<int> GlobalConfig::videoCaptureDeviceListFor(Category category, int override) const
 {
     CaptureCategory cat = categoryToCaptureCategory(category);
     return videoCaptureDeviceListFor(cat, override);
 }
 
 int GlobalConfig::videoCaptureDeviceFor(Category category, int override) const
 {
     CaptureCategory cat = categoryToCaptureCategory(category);
     return videoCaptureDeviceFor(cat, override);
 }
 
 #endif // PHONON_NO_VIDEOCAPTURE
 
 QHash<QByteArray, QVariant> GlobalConfig::deviceProperties(ObjectDescriptionType deviceType, int index) const
 {
     QList<int> indices;
     QHash<QByteArray, QVariant> props;
 
     // Try a pulseaudio device
     PulseSupport *pulse = PulseSupport::getInstance();
     if (pulse->isUsed()) {
         // Check the index before passing it to PulseSupport
         indices = pulse->objectDescriptionIndexes(deviceType);
         if (indices.contains(index))
             props = pulse->objectDescriptionProperties(deviceType, index);
     }
     if (!props.isEmpty())
         return props;
 
     #ifndef QT_NO_PHONON_PLATFORMPLUGIN
     // Try a device from the platform
     if (PlatformPlugin *platformPlugin = Factory::platformPlugin())
         props = platformPlugin->objectDescriptionProperties(deviceType, index);
     if (!props.isEmpty())
         return props;
     #endif //QT_NO_PHONON_PLATFORMPLUGIN
 
     // Try a device from the backend
     BackendInterface *backendIface = qobject_cast<BackendInterface *>(Factory::backend());
     if (backendIface)
         props = backendIface->objectDescriptionProperties(deviceType, index);
     if (!props.isEmpty())
         return props;
 
     return props;
 }
 
 
 } // namespace Phonon