| /* This file is part of the KDE project |
| Copyright (C) 2009 Colin Guthrie <cguthrie@mandriva.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 <QtCore/QAbstractEventDispatcher> |
| #include <QtCore/QEventLoop> |
| #include <QtCore/QDebug> |
| #include <QtCore/QStringList> |
| |
| #ifdef HAVE_PULSEAUDIO |
| #include <glib.h> |
| #include <pulse/pulseaudio.h> |
| #include <pulse/xmalloc.h> |
| #include <pulse/glib-mainloop.h> |
| #ifdef HAVE_PULSEAUDIO_DEVICE_MANAGER |
| # include <pulse/ext-device-manager.h> |
| #endif |
| #endif // HAVE_PULSEAUDIO |
| |
| #include "pulsesupport.h" |
| |
| QT_BEGIN_NAMESPACE |
| |
| namespace Phonon |
| { |
| |
| static PulseSupport* s_instance = NULL; |
| |
| #ifdef HAVE_PULSEAUDIO |
| /*** |
| * Prints a conditional debug message based on the current debug level |
| * If obj is provided, classname and objectname will be printed as well |
| * |
| * see debugLevel() |
| */ |
| |
| static int debugLevel() { |
| static int level = -1; |
| if (level < 1) { |
| level = 0; |
| QByteArray pulseenv = qgetenv("PHONON_PULSEAUDIO_DEBUG"); |
| int l = pulseenv.toInt(); |
| if (l > 0) |
| level = (l > 2 ? 2 : l); |
| } |
| return level; |
| } |
| |
| static void logMessage(const QString &message, int priority = 2, QObject *obj=0); |
| static void logMessage(const QString &message, int priority, QObject *obj) |
| { |
| if (debugLevel() > 0) { |
| QString output; |
| if (obj) { |
| // Strip away namespace from className |
| QByteArray className(obj->metaObject()->className()); |
| int nameLength = className.length() - className.lastIndexOf(':') - 1; |
| className = className.right(nameLength); |
| output.sprintf("%s %s (%s %p)", message.toLatin1().constData(), |
| obj->objectName().toLatin1().constData(), |
| className.constData(), obj); |
| } |
| else { |
| output = message; |
| } |
| if (priority <= debugLevel()) { |
| qDebug() << QString::fromLatin1("PulseSupport(%1): %2").arg(priority).arg(output); |
| } |
| } |
| } |
| |
| |
| class AudioDevice |
| { |
| public: |
| inline |
| AudioDevice(QString name, QString desc, QString icon, uint32_t index) |
| : pulseName(name), pulseIndex(index) |
| { |
| properties["name"] = desc; |
| properties["description"] = QLatin1String(""); // We don't have descriptions (well we do, but we use them as the name!) |
| properties["icon"] = icon; |
| properties["available"] = (index != PA_INVALID_INDEX); |
| properties["isAdvanced"] = false; // Nothing is advanced! |
| } |
| |
| // Needed for QMap |
| inline AudioDevice() {} |
| |
| QString pulseName; |
| uint32_t pulseIndex; |
| QHash<QByteArray, QVariant> properties; |
| }; |
| bool operator!=(const AudioDevice &a, const AudioDevice &b) |
| { |
| return !(a.pulseName == b.pulseName && a.properties == b.properties); |
| } |
| |
| class PulseUserData |
| { |
| public: |
| inline |
| PulseUserData() |
| { |
| } |
| |
| QMap<QString, AudioDevice> newOutputDevices; |
| QMap<Phonon::Category, QMap<int, int> > newOutputDevicePriorities; // prio, device |
| |
| QMap<QString, AudioDevice> newCaptureDevices; |
| QMap<Phonon::Category, QMap<int, int> > newCaptureDevicePriorities; // prio, device |
| }; |
| |
| static QMap<QString, Phonon::Category> s_roleCategoryMap; |
| |
| static bool s_pulseActive = false; |
| |
| static pa_glib_mainloop *s_mainloop = NULL; |
| static pa_context *s_context = NULL; |
| |
| |
| |
| static int s_deviceIndexCounter = 0; |
| |
| static QMap<QString, int> s_outputDeviceIndexes; |
| static QMap<int, AudioDevice> s_outputDevices; |
| static QMap<Phonon::Category, QMap<int, int> > s_outputDevicePriorities; // prio, device |
| static QMap<QString, uint32_t> s_outputStreamIndexMap; |
| |
| static QMap<QString, int> s_captureDeviceIndexes; |
| static QMap<int, AudioDevice> s_captureDevices; |
| static QMap<Phonon::Category, QMap<int, int> > s_captureDevicePriorities; // prio, device |
| static QMap<QString, uint32_t> s_captureStreamIndexMap; |
| |
| static void createGenericDevices() |
| { |
| // OK so we don't have the device manager extension, but we can show a single device and fake it. |
| int index; |
| s_outputDeviceIndexes.clear(); |
| s_outputDevices.clear(); |
| s_outputDevicePriorities.clear(); |
| index = s_deviceIndexCounter++; |
| s_outputDeviceIndexes.insert(QLatin1String("sink:default"), index); |
| s_outputDevices.insert(index, AudioDevice(QLatin1String("sink:default"), QObject::tr("PulseAudio Sound Server"), QLatin1String("audio-backend-pulseaudio"), 0)); |
| for (int i = Phonon::NoCategory; i <= Phonon::LastCategory; ++i) { |
| Phonon::Category cat = static_cast<Phonon::Category>(i); |
| s_outputDevicePriorities[cat].insert(0, index); |
| } |
| |
| s_captureDeviceIndexes.clear(); |
| s_captureDevices.clear(); |
| s_captureDevicePriorities.clear(); |
| index = s_deviceIndexCounter++; |
| s_captureDeviceIndexes.insert(QLatin1String("source:default"), index); |
| s_captureDevices.insert(index, AudioDevice(QLatin1String("source:default"), QObject::tr("PulseAudio Sound Server"), QLatin1String("audio-backend-pulseaudio"), 0)); |
| for (int i = Phonon::NoCategory; i <= Phonon::LastCategory; ++i) { |
| Phonon::Category cat = static_cast<Phonon::Category>(i); |
| s_captureDevicePriorities[cat].insert(0, index); |
| } |
| } |
| |
| #ifdef HAVE_PULSEAUDIO_DEVICE_MANAGER |
| static void ext_device_manager_read_cb(pa_context *c, const pa_ext_device_manager_info *info, int eol, void *userdata) { |
| Q_ASSERT(c); |
| Q_ASSERT(userdata); |
| |
| PulseUserData *u = reinterpret_cast<PulseUserData*>(userdata); |
| |
| if (eol < 0) { |
| logMessage(QString("Failed to initialize device manager extension: %1").arg(pa_strerror(pa_context_errno(c)))); |
| logMessage("Falling back to single device mode"); |
| createGenericDevices(); |
| delete u; |
| |
| // If this is our probe phase, exit now |
| if (s_context != c) |
| pa_context_disconnect(c); |
| |
| return; |
| } |
| |
| if (eol) { |
| // We're done reading the data, so order it by priority and copy it into the |
| // static variables where it can then be accessed by those classes that need it. |
| |
| QMap<QString, AudioDevice>::iterator newdev_it; |
| |
| // Check for new output devices or things changing about known output devices. |
| bool output_changed = false; |
| for (newdev_it = u->newOutputDevices.begin(); newdev_it != u->newOutputDevices.end(); ++newdev_it) { |
| QString name = newdev_it.key(); |
| |
| // The name + index map is always written when a new device is added. |
| Q_ASSERT(s_outputDeviceIndexes.contains(name)); |
| |
| int index = s_outputDeviceIndexes[name]; |
| if (!s_outputDevices.contains(index)) { |
| // This is a totally new device |
| output_changed = true; |
| logMessage(QString("Brand New Output Device Found.")); |
| s_outputDevices.insert(index, *newdev_it); |
| } else if (s_outputDevices[index] != *newdev_it) { |
| // We have this device already, but is it different? |
| output_changed = true; |
| logMessage(QString("Change to Existing Output Device (may be Added/Removed or something else)")); |
| s_outputDevices.remove(index); |
| s_outputDevices.insert(index, *newdev_it); |
| } |
| } |
| // Go through the output devices we know about and see if any are no longer mentioned in the list. |
| QMutableMapIterator<QString, int> output_existing_it(s_outputDeviceIndexes); |
| while (output_existing_it.hasNext()) { |
| output_existing_it.next(); |
| if (!u->newOutputDevices.contains(output_existing_it.key())) { |
| output_changed = true; |
| logMessage(QString("Output Device Completely Removed")); |
| s_outputDevices.remove(output_existing_it.value()); |
| output_existing_it.remove(); |
| } |
| } |
| |
| // Check for new capture devices or things changing about known capture devices. |
| bool capture_changed = false; |
| for (newdev_it = u->newCaptureDevices.begin(); newdev_it != u->newCaptureDevices.end(); ++newdev_it) { |
| QString name = newdev_it.key(); |
| |
| // The name + index map is always written when a new device is added. |
| Q_ASSERT(s_captureDeviceIndexes.contains(name)); |
| |
| int index = s_captureDeviceIndexes[name]; |
| if (!s_captureDevices.contains(index)) { |
| // This is a totally new device |
| capture_changed = true; |
| logMessage(QString("Brand New Capture Device Found.")); |
| s_captureDevices.insert(index, *newdev_it); |
| } else if (s_captureDevices[index] != *newdev_it) { |
| // We have this device already, but is it different? |
| capture_changed = true; |
| logMessage(QString("Change to Existing Capture Device (may be Added/Removed or something else)")); |
| s_captureDevices.remove(index); |
| s_captureDevices.insert(index, *newdev_it); |
| } |
| } |
| // Go through the capture devices we know about and see if any are no longer mentioned in the list. |
| QMutableMapIterator<QString, int> capture_existing_it(s_captureDeviceIndexes); |
| while (capture_existing_it.hasNext()) { |
| capture_existing_it.next(); |
| if (!u->newCaptureDevices.contains(capture_existing_it.key())) { |
| capture_changed = true; |
| logMessage(QString("Capture Device Completely Removed")); |
| s_captureDevices.remove(capture_existing_it.value()); |
| capture_existing_it.remove(); |
| } |
| } |
| |
| // Just copy accross the new priority lists as we know they are valid |
| if (s_outputDevicePriorities != u->newOutputDevicePriorities) { |
| output_changed = true; |
| s_outputDevicePriorities = u->newOutputDevicePriorities; |
| } |
| if (s_captureDevicePriorities != u->newCaptureDevicePriorities) { |
| capture_changed = true; |
| s_captureDevicePriorities = u->newCaptureDevicePriorities; |
| } |
| |
| if (s_instance) { |
| // This wont be emitted durring the connection probe phase |
| // which is intensional |
| if (output_changed) |
| s_instance->emitObjectDescriptionChanged(AudioOutputDeviceType); |
| if (capture_changed) |
| s_instance->emitObjectDescriptionChanged(AudioCaptureDeviceType); |
| } |
| |
| // We can free the user data as we will not be called again. |
| delete u; |
| |
| // Some debug |
| logMessage(QString("Output Device Priority List:")); |
| for (int i = Phonon::NoCategory; i <= Phonon::LastCategory; ++i) { |
| Phonon::Category cat = static_cast<Phonon::Category>(i); |
| if (s_outputDevicePriorities.contains(cat)) { |
| logMessage(QString(" Phonon Category %1").arg(cat)); |
| int count = 0; |
| foreach (int j, s_outputDevicePriorities[cat]) { |
| QHash<QByteArray, QVariant> &props = s_outputDevices[j].properties; |
| logMessage(QString(" %1. %2 (Available: %3)").arg(++count).arg(props["name"].toString()).arg(props["available"].toBool())); |
| } |
| } |
| } |
| logMessage(QString("Capture Device Priority List:")); |
| for (int i = Phonon::NoCategory; i <= Phonon::LastCategory; ++i) { |
| Phonon::Category cat = static_cast<Phonon::Category>(i); |
| if (s_captureDevicePriorities.contains(cat)) { |
| logMessage(QString(" Phonon Category %1").arg(cat)); |
| int count = 0; |
| foreach (int j, s_captureDevicePriorities[cat]) { |
| QHash<QByteArray, QVariant> &props = s_captureDevices[j].properties; |
| logMessage(QString(" %1. %2 (Available: %3)").arg(++count).arg(props["name"].toString()).arg(props["available"].toBool())); |
| } |
| } |
| } |
| |
| // If this is our probe phase, exit now as we're finished reading |
| // our device info and can exit and reconnect |
| if (s_context != c) |
| pa_context_disconnect(c); |
| } |
| |
| if (!info) |
| return; |
| |
| Q_ASSERT(info->name); |
| Q_ASSERT(info->description); |
| Q_ASSERT(info->icon); |
| |
| // QString wrapper |
| QString name(info->name); |
| int index; |
| QMap<Phonon::Category, QMap<int, int> > *new_prio_map_cats; // prio, device |
| QMap<QString, AudioDevice> *new_devices; |
| |
| if (name.startsWith("sink:")) { |
| new_devices = &u->newOutputDevices; |
| new_prio_map_cats = &u->newOutputDevicePriorities; |
| |
| if (s_outputDeviceIndexes.contains(name)) |
| index = s_outputDeviceIndexes[name]; |
| else |
| index = s_outputDeviceIndexes[name] = s_deviceIndexCounter++; |
| } else if (name.startsWith("source:")) { |
| new_devices = &u->newCaptureDevices; |
| new_prio_map_cats = &u->newCaptureDevicePriorities; |
| |
| if (s_captureDeviceIndexes.contains(name)) |
| index = s_captureDeviceIndexes[name]; |
| else |
| index = s_captureDeviceIndexes[name] = s_deviceIndexCounter++; |
| } else { |
| // This indicates a bug in pulseaudio. |
| return; |
| } |
| |
| // Add the new device itself. |
| new_devices->insert(name, AudioDevice(name, info->description, info->icon, info->index)); |
| |
| // For each role in the priority, map it to a phonon category and store the order. |
| for (uint32_t i = 0; i < info->n_role_priorities; ++i) { |
| pa_ext_device_manager_role_priority_info* role_prio = &info->role_priorities[i]; |
| Q_ASSERT(role_prio->role); |
| |
| if (s_roleCategoryMap.contains(role_prio->role)) { |
| Phonon::Category cat = s_roleCategoryMap[role_prio->role]; |
| |
| (*new_prio_map_cats)[cat].insert(role_prio->priority, index); |
| } |
| } |
| } |
| |
| static void ext_device_manager_subscribe_cb(pa_context *c, void *) { |
| Q_ASSERT(c); |
| |
| pa_operation *o; |
| PulseUserData *u = new PulseUserData; |
| if (!(o = pa_ext_device_manager_read(c, ext_device_manager_read_cb, u))) { |
| logMessage(QString("pa_ext_device_manager_read() failed.")); |
| delete u; |
| return; |
| } |
| pa_operation_unref(o); |
| } |
| #endif |
| |
| void sink_input_cb(pa_context *c, const pa_sink_input_info *i, int eol, void *userdata) { |
| Q_UNUSED(userdata); |
| Q_ASSERT(c); |
| |
| if (eol < 0) { |
| if (pa_context_errno(c) == PA_ERR_NOENTITY) |
| return; |
| |
| logMessage(QLatin1String("Sink input callback failure")); |
| return; |
| } |
| |
| if (eol > 0) |
| return; |
| |
| Q_ASSERT(i); |
| |
| // loop through (*i) and extract phonon->streamindex... |
| const char *t; |
| if ((t = pa_proplist_gets(i->proplist, "phonon.streamid"))) { |
| logMessage(QString::fromLatin1("Found PulseAudio stream index %1 for Phonon Output Stream %2").arg(i->index).arg(QLatin1String(t))); |
| s_outputStreamIndexMap[QLatin1String(t)] = i->index; |
| |
| // Find the sink's phonon index and notify whoever cares... |
| if (PA_INVALID_INDEX != i->sink) { |
| bool found = false; |
| int device; |
| QMap<int, AudioDevice>::iterator it; |
| for (it = s_outputDevices.begin(); it != s_outputDevices.end(); ++it) { |
| if ((*it).pulseIndex == i->sink) { |
| found = true; |
| device = it.key(); |
| break; |
| } |
| } |
| if (found) { |
| // OK so we just emit our signal |
| logMessage(QLatin1String("Letting the rest of phonon know about this")); |
| s_instance->emitUsingDevice(QLatin1String(t), device); |
| } |
| } |
| } |
| } |
| |
| void source_output_cb(pa_context *c, const pa_source_output_info *i, int eol, void *userdata) { |
| Q_UNUSED(userdata); |
| Q_ASSERT(c); |
| |
| if (eol < 0) { |
| if (pa_context_errno(c) == PA_ERR_NOENTITY) |
| return; |
| |
| logMessage(QLatin1String("Source output callback failure")); |
| return; |
| } |
| |
| if (eol > 0) |
| return; |
| |
| Q_ASSERT(i); |
| |
| // loop through (*i) and extract phonon->streamindex... |
| const char *t; |
| if ((t = pa_proplist_gets(i->proplist, "phonon.streamid"))) { |
| logMessage(QString::fromLatin1("Found PulseAudio stream index %1 for Phonon Capture Stream %2").arg(i->index).arg(QLatin1String(t))); |
| s_captureStreamIndexMap[QLatin1String(t)] = i->index; |
| |
| // Find the source's phonon index and notify whoever cares... |
| if (PA_INVALID_INDEX != i->source) { |
| bool found = false; |
| int device; |
| QMap<int, AudioDevice>::iterator it; |
| for (it = s_captureDevices.begin(); it != s_captureDevices.end(); ++it) { |
| if ((*it).pulseIndex == i->source) { |
| found = true; |
| device = it.key(); |
| break; |
| } |
| } |
| if (found) { |
| // OK so we just emit our signal |
| logMessage(QLatin1String("Letting the rest of phonon know about this")); |
| s_instance->emitUsingDevice(QLatin1String(t), device); |
| } |
| } |
| } |
| } |
| |
| static void subscribe_cb(pa_context *c, pa_subscription_event_type_t t, uint32_t index, void *userdata) { |
| Q_UNUSED(userdata); |
| |
| switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) { |
| case PA_SUBSCRIPTION_EVENT_SINK_INPUT: |
| if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { |
| QString phononid = s_outputStreamIndexMap.key(index); |
| if (!phononid.isEmpty()) { |
| if (s_outputStreamIndexMap.contains(phononid)) { |
| logMessage(QString::fromLatin1("Phonon Output Stream %1 is gone at the PA end. Marking it as invalid in our cache as we may reuse it.").arg(phononid)); |
| s_outputStreamIndexMap[phononid] = PA_INVALID_INDEX; |
| } else { |
| logMessage(QString::fromLatin1("Removing Phonon Output Stream %1 (it's gone!)").arg(phononid)); |
| s_outputStreamIndexMap.remove(phononid); |
| } |
| } |
| } else { |
| pa_operation *o; |
| if (!(o = pa_context_get_sink_input_info(c, index, sink_input_cb, NULL))) { |
| logMessage(QLatin1String("pa_context_get_sink_input_info() failed")); |
| return; |
| } |
| pa_operation_unref(o); |
| } |
| break; |
| |
| case PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT: |
| if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_REMOVE) { |
| QString phononid = s_captureStreamIndexMap.key(index); |
| if (!phononid.isEmpty()) { |
| if (s_captureStreamIndexMap.contains(phononid)) { |
| logMessage(QString::fromLatin1("Phonon Capture Stream %1 is gone at the PA end. Marking it as invalid in our cache as we may reuse it.").arg(phononid)); |
| s_captureStreamIndexMap[phononid] = PA_INVALID_INDEX; |
| } else { |
| logMessage(QString::fromLatin1("Removing Phonon Capture Stream %1 (it's gone!)").arg(phononid)); |
| s_captureStreamIndexMap.remove(phononid); |
| } |
| } |
| } else { |
| pa_operation *o; |
| if (!(o = pa_context_get_source_output_info(c, index, source_output_cb, NULL))) { |
| logMessage(QLatin1String("pa_context_get_sink_input_info() failed")); |
| return; |
| } |
| pa_operation_unref(o); |
| } |
| break; |
| } |
| } |
| |
| |
| static QString statename(pa_context_state_t state) |
| { |
| switch (state) |
| { |
| case PA_CONTEXT_UNCONNECTED: return QLatin1String("Unconnected"); |
| case PA_CONTEXT_CONNECTING: return QLatin1String("Connecting"); |
| case PA_CONTEXT_AUTHORIZING: return QLatin1String("Authorizing"); |
| case PA_CONTEXT_SETTING_NAME: return QLatin1String("Setting Name"); |
| case PA_CONTEXT_READY: return QLatin1String("Ready"); |
| case PA_CONTEXT_FAILED: return QLatin1String("Failed"); |
| case PA_CONTEXT_TERMINATED: return QLatin1String("Terminated"); |
| } |
| |
| return QString::fromLatin1("Unknown state: %0").arg(state); |
| } |
| |
| static void context_state_callback(pa_context *c, void *) |
| { |
| Q_ASSERT(c); |
| |
| logMessage(QString::fromLatin1("context_state_callback %1").arg(statename(pa_context_get_state(c)))); |
| pa_context_state_t state = pa_context_get_state(c); |
| if (state == PA_CONTEXT_READY) { |
| // We've connected to PA, so it is active |
| s_pulseActive = true; |
| |
| // Attempt to load things up |
| pa_operation *o; |
| |
| // 1. Register for the stream changes (except during probe) |
| if (s_context == c) { |
| pa_context_set_subscribe_callback(c, subscribe_cb, NULL); |
| |
| if (!(o = pa_context_subscribe(c, (pa_subscription_mask_t) |
| (PA_SUBSCRIPTION_MASK_SINK_INPUT| |
| PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT), NULL, NULL))) { |
| logMessage(QLatin1String("pa_context_subscribe() failed")); |
| return; |
| } |
| pa_operation_unref(o); |
| } |
| |
| #ifdef HAVE_PULSEAUDIO_DEVICE_MANAGER |
| // 2a. Attempt to initialise Device Manager info (except during probe) |
| if (s_context == c) { |
| pa_ext_device_manager_set_subscribe_cb(c, ext_device_manager_subscribe_cb, NULL); |
| if (!(o = pa_ext_device_manager_subscribe(c, 1, NULL, NULL))) { |
| logMessage(QString("pa_ext_device_manager_subscribe() failed")); |
| return; |
| } |
| pa_operation_unref(o); |
| } |
| |
| // 3. Attempt to read info from Device Manager |
| PulseUserData *u = new PulseUserData; |
| if (!(o = pa_ext_device_manager_read(c, ext_device_manager_read_cb, u))) { |
| logMessage(QString("pa_ext_device_manager_read() failed. Attempting to continue without device manager support")); |
| createGenericDevices(); |
| delete u; |
| |
| // If this is our probe phase, exit immediately |
| if (s_context != c) |
| pa_context_disconnect(c); |
| |
| return; |
| } |
| pa_operation_unref(o); |
| |
| #else |
| // If we know do not have Device Manager support, we just create our dummy devices now |
| createGenericDevices(); |
| |
| // If this is our probe phase, exit immediately |
| if (s_context != c) |
| pa_context_disconnect(c); |
| #endif |
| } else if (!PA_CONTEXT_IS_GOOD(state)) { |
| /// @todo Deal with reconnection... |
| //logMessage("Connection to PulseAudio lost"); |
| |
| // If this is our probe phase, exit our context immediately |
| if (s_context != c) |
| pa_context_disconnect(c); |
| } |
| } |
| #endif // HAVE_PULSEAUDIO |
| |
| |
| PulseSupport* PulseSupport::getInstance() |
| { |
| if (NULL == s_instance) { |
| s_instance = new PulseSupport(); |
| } |
| return s_instance; |
| } |
| |
| void PulseSupport::shutdown() |
| { |
| if (NULL != s_instance) { |
| delete s_instance; |
| s_instance = NULL; |
| } |
| } |
| |
| PulseSupport::PulseSupport() |
| : QObject(), mEnabled(false) |
| { |
| #ifdef HAVE_PULSEAUDIO |
| // Initialise our map (is there a better way to do this?) |
| s_roleCategoryMap[QLatin1String("none")] = Phonon::NoCategory; |
| s_roleCategoryMap[QLatin1String("video")] = Phonon::VideoCategory; |
| s_roleCategoryMap[QLatin1String("music")] = Phonon::MusicCategory; |
| s_roleCategoryMap[QLatin1String("game")] = Phonon::GameCategory; |
| s_roleCategoryMap[QLatin1String("event")] = Phonon::NotificationCategory; |
| s_roleCategoryMap[QLatin1String("phone")] = Phonon::CommunicationCategory; |
| //s_roleCategoryMap[QLatin1String("animation")]; // No Mapping |
| //s_roleCategoryMap[QLatin1String("production")]; // No Mapping |
| s_roleCategoryMap[QLatin1String("a11y")] = Phonon::AccessibilityCategory; |
| |
| // To allow for easy debugging, give an easy way to disable this pulseaudio check |
| QByteArray pulseenv = qgetenv("PHONON_PULSEAUDIO_DISABLE"); |
| if (pulseenv.toInt()) { |
| logMessage(QLatin1String("PulseAudio support disabled: PHONON_PULSEAUDIO_DISABLE is set")); |
| return; |
| } |
| |
| // We require a glib event loop |
| if (strcmp(QAbstractEventDispatcher::instance()->metaObject()->className(), |
| "QGuiEventDispatcherGlib") != 0) { |
| logMessage(QLatin1String("Disabling PulseAudio integration for lack of GLib event loop.")); |
| return; |
| } |
| |
| // First of all conenct to PA via simple/blocking means and if that succeeds, |
| // use a fully async integrated mainloop method to connect and get proper support. |
| pa_mainloop *p_test_mainloop; |
| if (!(p_test_mainloop = pa_mainloop_new())) { |
| logMessage(QLatin1String("PulseAudio support disabled: Unable to create mainloop")); |
| return; |
| } |
| |
| pa_context *p_test_context; |
| if (!(p_test_context = pa_context_new(pa_mainloop_get_api(p_test_mainloop), "libphonon-probe"))) { |
| logMessage(QLatin1String("PulseAudio support disabled: Unable to create context")); |
| pa_mainloop_free(p_test_mainloop); |
| return; |
| } |
| |
| logMessage(QLatin1String("Probing for PulseAudio...")); |
| // (cg) Convert to PA_CONTEXT_NOFLAGS when PulseAudio 0.9.19 is required |
| if (pa_context_connect(p_test_context, NULL, static_cast<pa_context_flags_t>(0), NULL) < 0) { |
| logMessage(QString::fromLatin1("PulseAudio support disabled: %1").arg(QString::fromLocal8Bit(pa_strerror(pa_context_errno(p_test_context))))); |
| pa_context_disconnect(p_test_context); |
| pa_context_unref(p_test_context); |
| pa_mainloop_free(p_test_mainloop); |
| return; |
| } |
| |
| pa_context_set_state_callback(p_test_context, &context_state_callback, NULL); |
| for (;;) { |
| pa_mainloop_iterate(p_test_mainloop, 1, NULL); |
| |
| if (!PA_CONTEXT_IS_GOOD(pa_context_get_state(p_test_context))) { |
| logMessage(QLatin1String("PulseAudio probe complete.")); |
| break; |
| } |
| } |
| pa_context_disconnect(p_test_context); |
| pa_context_unref(p_test_context); |
| pa_mainloop_free(p_test_mainloop); |
| |
| if (!s_pulseActive) { |
| logMessage(QLatin1String("PulseAudio support is not available.")); |
| return; |
| } |
| |
| // If we're still here, PA is available. |
| logMessage(QLatin1String("PulseAudio support enabled")); |
| |
| // Now we connect for real using a proper main loop that we can forget |
| // all about processing. |
| s_mainloop = pa_glib_mainloop_new(NULL); |
| Q_ASSERT(s_mainloop); |
| pa_mainloop_api *api = pa_glib_mainloop_get_api(s_mainloop); |
| |
| s_context = pa_context_new(api, "libphonon"); |
| // (cg) Convert to PA_CONTEXT_NOFLAGS when PulseAudio 0.9.19 is required |
| if (pa_context_connect(s_context, NULL, static_cast<pa_context_flags_t>(0), 0) >= 0) |
| pa_context_set_state_callback(s_context, &context_state_callback, NULL); |
| #endif |
| } |
| |
| PulseSupport::~PulseSupport() |
| { |
| #ifdef HAVE_PULSEAUDIO |
| if (s_context) { |
| pa_context_disconnect(s_context); |
| s_context = NULL; |
| } |
| |
| if (s_mainloop) { |
| pa_glib_mainloop_free(s_mainloop); |
| s_mainloop = NULL; |
| } |
| #endif |
| } |
| |
| bool PulseSupport::isActive() |
| { |
| #ifdef HAVE_PULSEAUDIO |
| return mEnabled && s_pulseActive; |
| #else |
| return false; |
| #endif |
| } |
| |
| void PulseSupport::enable(bool enabled) |
| { |
| mEnabled = enabled; |
| } |
| |
| QList<int> PulseSupport::objectDescriptionIndexes(ObjectDescriptionType type) const |
| { |
| QList<int> list; |
| |
| if (type != AudioOutputDeviceType && type != AudioCaptureDeviceType) |
| return list; |
| |
| #ifdef HAVE_PULSEAUDIO |
| if (s_pulseActive) { |
| switch (type) { |
| |
| case AudioOutputDeviceType: { |
| QMap<QString, int>::iterator it; |
| for (it = s_outputDeviceIndexes.begin(); it != s_outputDeviceIndexes.end(); ++it) { |
| list.append(*it); |
| } |
| break; |
| } |
| case AudioCaptureDeviceType: { |
| QMap<QString, int>::iterator it; |
| for (it = s_captureDeviceIndexes.begin(); it != s_captureDeviceIndexes.end(); ++it) { |
| list.append(*it); |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| } |
| #endif |
| |
| return list; |
| } |
| |
| QHash<QByteArray, QVariant> PulseSupport::objectDescriptionProperties(ObjectDescriptionType type, int index) const |
| { |
| QHash<QByteArray, QVariant> ret; |
| |
| if (type != AudioOutputDeviceType && type != AudioCaptureDeviceType) |
| return ret; |
| |
| #ifndef HAVE_PULSEAUDIO |
| Q_UNUSED(index); |
| #else |
| if (s_pulseActive) { |
| switch (type) { |
| |
| case AudioOutputDeviceType: |
| Q_ASSERT(s_outputDevices.contains(index)); |
| ret = s_outputDevices[index].properties; |
| break; |
| |
| case AudioCaptureDeviceType: |
| Q_ASSERT(s_captureDevices.contains(index)); |
| ret = s_captureDevices[index].properties; |
| break; |
| |
| default: |
| break; |
| } |
| } |
| #endif |
| |
| return ret; |
| } |
| |
| QList<int> PulseSupport::objectIndexesByCategory(ObjectDescriptionType type, Category category) const |
| { |
| QList<int> ret; |
| |
| if (type != AudioOutputDeviceType && type != AudioCaptureDeviceType) |
| return ret; |
| |
| #ifndef HAVE_PULSEAUDIO |
| Q_UNUSED(category); |
| #else |
| if (s_pulseActive) { |
| switch (type) { |
| |
| case AudioOutputDeviceType: |
| if (s_outputDevicePriorities.contains(category)) |
| ret = s_outputDevicePriorities[category].values(); |
| break; |
| |
| case AudioCaptureDeviceType: |
| if (s_captureDevicePriorities.contains(category)) |
| ret = s_captureDevicePriorities[category].values(); |
| break; |
| |
| default: |
| break; |
| } |
| } |
| #endif |
| |
| return ret; |
| } |
| |
| #ifdef HAVE_PULSEAUDIO |
| static void setDevicePriority(Category category, QStringList list) |
| { |
| QString role = s_roleCategoryMap.key(category); |
| if (role.isEmpty()) |
| return; |
| |
| logMessage(QString::fromLatin1("Reindexing %1: %2").arg(role).arg(list.join(QLatin1String(", ")))); |
| |
| char **devices; |
| devices = pa_xnew(char *, list.size()+1); |
| int i = 0; |
| foreach (QString str, list) { |
| devices[i++] = pa_xstrdup(str.toUtf8().constData()); |
| } |
| devices[list.size()] = NULL; |
| |
| #ifdef HAVE_PULSEAUDIO_DEVICE_MANAGER |
| pa_operation *o; |
| if (!(o = pa_ext_device_manager_reorder_devices_for_role(s_context, role.toUtf8().constData(), (const char**)devices, NULL, NULL))) |
| logMessage(QString("pa_ext_device_manager_reorder_devices_for_role() failed")); |
| else |
| pa_operation_unref(o); |
| #endif |
| |
| for (i = 0; i < list.size(); ++i) |
| pa_xfree(devices[i]); |
| pa_xfree(devices); |
| } |
| #endif |
| |
| void PulseSupport::setOutputDevicePriorityForCategory(Category category, QList<int> order) |
| { |
| #ifndef HAVE_PULSEAUDIO |
| Q_UNUSED(category); |
| Q_UNUSED(order); |
| #else |
| QStringList list; |
| QList<int>::iterator it; |
| |
| for (it = order.begin(); it != order.end(); ++it) { |
| if (s_outputDevices.contains(*it)) { |
| list << s_outputDeviceIndexes.key(*it); |
| } |
| } |
| setDevicePriority(category, list); |
| #endif |
| } |
| |
| void PulseSupport::setCaptureDevicePriorityForCategory(Category category, QList<int> order) |
| { |
| #ifndef HAVE_PULSEAUDIO |
| Q_UNUSED(category); |
| Q_UNUSED(order); |
| #else |
| QStringList list; |
| QList<int>::iterator it; |
| |
| for (it = order.begin(); it != order.end(); ++it) { |
| if (s_captureDevices.contains(*it)) { |
| list << s_captureDeviceIndexes.key(*it); |
| } |
| } |
| setDevicePriority(category, list); |
| #endif |
| } |
| |
| void PulseSupport::setStreamPropList(Category category, QString streamUuid) |
| { |
| #ifndef HAVE_PULSEAUDIO |
| Q_UNUSED(category); |
| Q_UNUSED(streamUuid); |
| #else |
| QString role = s_roleCategoryMap.key(category); |
| if (role.isEmpty()) |
| return; |
| |
| logMessage(QString::fromLatin1("Setting role to %1 for streamindex %2").arg(role).arg(streamUuid)); |
| setenv("PULSE_PROP_media.role", role.toLatin1().constData(), 1); |
| setenv("PULSE_PROP_phonon.streamid", streamUuid.toLatin1().constData(), 1); |
| #endif |
| } |
| |
| void PulseSupport::emitObjectDescriptionChanged(ObjectDescriptionType type) |
| { |
| emit objectDescriptionChanged(type); |
| } |
| |
| void PulseSupport::emitUsingDevice(QString streamUuid, int device) |
| { |
| emit usingDevice(streamUuid, device); |
| } |
| |
| bool PulseSupport::setOutputDevice(QString streamUuid, int device) { |
| #ifndef HAVE_PULSEAUDIO |
| Q_UNUSED(streamUuid); |
| Q_UNUSED(device); |
| return false; |
| #else |
| if (s_outputDevices.size() < 2) |
| return true; |
| |
| if (!s_outputDevices.contains(device)) { |
| logMessage(QString::fromLatin1("Attempting to set Output Device for invalid device id %1.").arg(device)); |
| return false; |
| } |
| const QVariant var = s_outputDevices[device].properties["name"]; |
| logMessage(QString::fromLatin1("Attempting to set Output Device to '%1' for Output Stream %2").arg(var.toString()).arg(streamUuid)); |
| |
| // Attempt to look up the pulse stream index. |
| if (s_outputStreamIndexMap.contains(streamUuid) && s_outputStreamIndexMap[streamUuid] != PA_INVALID_INDEX) { |
| logMessage(QLatin1String("... Found in map. Moving now")); |
| |
| uint32_t pulse_device_index = s_outputDevices[device].pulseIndex; |
| uint32_t pulse_stream_index = s_outputStreamIndexMap[streamUuid]; |
| |
| logMessage(QString::fromLatin1("Moving Pulse Sink Input %1 to '%2' (Pulse Sink %3)").arg(pulse_stream_index).arg(var.toString()).arg(pulse_device_index)); |
| |
| /// @todo Find a way to move the stream without saving it... We don't want to pollute the stream restore db. |
| pa_operation* o; |
| if (!(o = pa_context_move_sink_input_by_index(s_context, pulse_stream_index, pulse_device_index, NULL, NULL))) { |
| logMessage(QLatin1String("pa_context_move_sink_input_by_index() failed")); |
| return false; |
| } |
| pa_operation_unref(o); |
| } else { |
| logMessage(QLatin1String("... Not found in map. We will be notified of the device when the stream appears and we can process any moves needed then")); |
| } |
| return true; |
| #endif |
| } |
| |
| bool PulseSupport::setCaptureDevice(QString streamUuid, int device) { |
| #ifndef HAVE_PULSEAUDIO |
| Q_UNUSED(streamUuid); |
| Q_UNUSED(device); |
| return false; |
| #else |
| if (s_captureDevices.size() < 2) |
| return true; |
| |
| if (!s_captureDevices.contains(device)) { |
| logMessage(QString::fromLatin1("Attempting to set Capture Device for invalid device id %1.").arg(device)); |
| return false; |
| } |
| const QVariant var = s_captureDevices[device].properties["name"]; |
| logMessage(QString::fromLatin1("Attempting to set Capture Device to '%1' for Capture Stream %2").arg(var.toString()).arg(streamUuid)); |
| |
| // Attempt to look up the pulse stream index. |
| if (s_captureStreamIndexMap.contains(streamUuid) && s_captureStreamIndexMap[streamUuid] == PA_INVALID_INDEX) { |
| logMessage(QString::fromLatin1("... Found in map. Moving now")); |
| |
| uint32_t pulse_device_index = s_captureDevices[device].pulseIndex; |
| uint32_t pulse_stream_index = s_captureStreamIndexMap[streamUuid]; |
| |
| logMessage(QString::fromLatin1("Moving Pulse Source Output %1 to '%2' (Pulse Sink %3)").arg(pulse_stream_index).arg(var.toString()).arg(pulse_device_index)); |
| |
| /// @todo Find a way to move the stream without saving it... We don't want to pollute the stream restore db. |
| pa_operation* o; |
| if (!(o = pa_context_move_source_output_by_index(s_context, pulse_stream_index, pulse_device_index, NULL, NULL))) { |
| logMessage(QString::fromLatin1("pa_context_move_source_output_by_index() failed")); |
| return false; |
| } |
| pa_operation_unref(o); |
| } else { |
| logMessage(QString::fromLatin1("... Not found in map. We will be notified of the device when the stream appears and we can process any moves needed then")); |
| } |
| return true; |
| #endif |
| } |
| |
| void PulseSupport::clearStreamCache(QString streamUuid) { |
| #ifndef HAVE_PULSEAUDIO |
| Q_UNUSED(streamUuid); |
| return; |
| #else |
| logMessage(QString::fromLatin1("Clearing stream cache for stream %1").arg(streamUuid)); |
| s_outputStreamIndexMap.remove(streamUuid); |
| s_captureStreamIndexMap.remove(streamUuid); |
| #endif |
| } |
| |
| } // namespace Phonon |
| |
| QT_END_NAMESPACE |
| |
| #include "moc_pulsesupport.cpp" |
| |
| // vim: sw=4 ts=4 |
