Revision control

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qwasmmediadevices_p.h"
#include "private/qcameradevice_p.h"
#include "private/qplatformmediaintegration_p.h"
#include "qwasmwebaudiosource_p.h"
#include "qwasmwebaudiosink_p.h"
#include "qwasmaudiodevice_p.h"
+ #include <QtMultimedia/private/qmultimedia_ranges_p.h>
- #include <QMap>
#include <QDebug>
#include <emscripten.h>
+ #include <algorithm>
+ #include <string_view>
+ #include <utility>
+
QT_BEGIN_NAMESPACE
+ namespace ranges = QtMultimediaPrivate::ranges;
+
Q_LOGGING_CATEGORY(qWasmMediaDevices, "qt.multimedia.wasm.mediadevices")
+ namespace {
+
+ // Chrome and Edge add synthetic entries to enumerateDevices() that alias a real
+ // device: "default" tracks the system default, "communications" the device picked
+ // for voice calls. Both carry the aliased device's groupId. Firefox and Safari
+ // have no such entries and simply enumerate the default device first.
+ constexpr std::string_view s_defaultDeviceId = "default";
+ constexpr std::string_view s_communicationsDeviceId = "communications";
+
+ bool isAliasDeviceId(std::string_view deviceId)
+ {
+ return deviceId == s_defaultDeviceId || deviceId == s_communicationsDeviceId;
+ }
+
+ std::string stringProperty(const emscripten::val &mediaDevice, const char *property)
+ {
+ const emscripten::val value = mediaDevice[property];
+ if (value.isUndefined() || value.isNull())
+ return std::string();
+ return value.as<std::string>();
+ }
+
+ // enumerateDevices() reports empty ids until permission is granted, and we
+ // substitute a synthetic per-kind id for those. Default lookup must match.
+ std::string effectiveDeviceId(const std::string &deviceId, const std::string &deviceKind)
+ {
+ return deviceId.empty() ? "System " + deviceKind : deviceId;
+ }
+
+ template <typename DeviceList>
+ bool containsDeviceId(const DeviceList &devices, const QByteArray &deviceId)
+ {
+ return ranges::any_of(devices, [&deviceId](const auto &device) {
+ return device.id() == deviceId;
+ });
+ }
+
+ } // namespace
+
static QWasmMediaDevices *s_mediaDevicesInstance = nullptr;
static bool s_constructingInstance = false;
bool isFirefox() {
return !emscripten::val::global("InstallTrigger").isUndefined();
}
// Firefox only as it limits enumerateDevices to inputs only when no permissions are given
extern "C" {
EMSCRIPTEN_KEEPALIVE void qtMediaDevicesOnAudioOutputSelected()
{
if (QWasmMediaDevices *instance = QWasmMediaDevices::instance())
instance->getMediaDevices();
}
} // extern "C"
EM_JS(void, setupAudioOutputSelector, (), {
const overlay = document.createElement('div');
overlay.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;background:rgba(0,0,0,0.5);z-index:9999;display:flex;align-items:center;justify-content:center;';
const dialog = document.createElement('div');
dialog.style.cssText = 'background:white;padding:24px;border-radius:8px;text-align:center;font-family:sans-serif;min-width:240px;';
const message = document.createElement('p');
message.textContent = 'Select an audio output device to continue.';
message.style.cssText = 'margin:0 0 16px 0;font-size:14px;';
const button = document.createElement('button');
button.textContent = 'Select Audio Output';
button.style.cssText = 'padding:8px 16px;font-size:14px;cursor:pointer;';
button.addEventListener('click', async () => {
document.body.removeChild(overlay);
try {
const deviceInfo = await navigator.mediaDevices.selectAudioOutput();
console.log("Selected device: ", deviceInfo.label);
Module._qtMediaDevicesOnAudioOutputSelected();
} catch (err) {
console.error(err);
}
}, { once: true });
dialog.appendChild(message);
dialog.appendChild(button);
overlay.appendChild(dialog);
document.body.appendChild(overlay);
});
QWasmCameraDevices::QWasmCameraDevices(QPlatformMediaIntegration *integration)
: QPlatformVideoDevices(integration)
{
}
QList<QCameraDevice> QWasmCameraDevices::findVideoInputs() const
{
return QWasmMediaDevices::instance() ? QWasmMediaDevices::instance()->videoInputs() : QList<QCameraDevice>();
}
void QWasmCameraDevices::connectNotify(const QMetaMethod &)
{
Q_ASSERT(QThread::isMainThread());
QWasmMediaDevices::instance();
}
QWasmAudioDevices::QWasmAudioDevices() = default;
QPlatformAudioSource *QWasmAudioDevices::createAudioSource(const QAudioDevice &deviceInfo,
const QAudioFormat &fmt,
QObject *parent)
{
return new QWasmAudioSource(deviceInfo, fmt, parent);
}
QPlatformAudioSink *QWasmAudioDevices::createAudioSink(const QAudioDevice &deviceInfo,
const QAudioFormat &fmt,
QObject *parent)
{
return new QWasmAudioSink(deviceInfo, fmt, parent);
}
QList<QAudioDevice> QWasmAudioDevices::findAudioInputs() const
{
return QWasmMediaDevices::instance() ? QWasmMediaDevices::instance()->audioInputs() : QList<QAudioDevice>();
}
QList<QAudioDevice> QWasmAudioDevices::findAudioOutputs() const
{
return QWasmMediaDevices::instance() ? QWasmMediaDevices::instance()->audioOutputs() : QList<QAudioDevice>();
}
void QWasmAudioDevices::connectNotify(const QMetaMethod &)
{
Q_ASSERT(QThread::isMainThread());
QWasmMediaDevices::instance();
}
QWasmMediaDevices::QWasmMediaDevices()
{
}
QWasmMediaDevices *QWasmMediaDevices::instance()
{
if (s_mediaDevicesInstance)
return s_mediaDevicesInstance;
if (s_constructingInstance)
return nullptr;
s_constructingInstance = true;
s_mediaDevicesInstance = new QWasmMediaDevices();
s_constructingInstance = false;
s_mediaDevicesInstance->initDevices();
return s_mediaDevicesInstance;
}
void QWasmMediaDevices::initDevices()
{
if (m_initDone)
return;
m_initDone = true;
// Seed a synchronous fallback output device immediately: enumerateDevices() below
// is asynchronous, so without this, any consumer that needs a device synchronously
// right after construction (e.g. QSoundEffect) sees an empty list and fails.
insertFallbackAudioOutput();
if (isFirefox())
setupAudioOutputSelector();
else
getMediaDevices(); // asynchronous
}
QList<QCameraDevice> QWasmMediaDevices::videoInputs() const
{
- return m_cameraDevices.values();
+ return m_cameraDevices;
}
QList<QAudioDevice> QWasmMediaDevices::audioInputs() const
{
- return m_audioInputs.values();
+ return m_audioInputs;
}
QList<QAudioDevice> QWasmMediaDevices::audioOutputs() const
{
- return m_audioOutputs.values();
+ return m_audioOutputs;
+ }
+
+ // Works out which enumerated device should carry the isDefault flag. When the
+ // browser publishes a synthetic "default" entry it is resolved back to the real
+ // device through its groupId, so the returned id is one that also ends up in our
+ // device lists. Otherwise the first enumerated device of that kind wins.
+ QByteArray QWasmMediaDevices::findDefaultDeviceId(emscripten::val devices,
+ std::string_view deviceKind) const
+ {
+ const QString kindName = QString::fromUtf8(deviceKind.data(), qsizetype(deviceKind.size()));
+ std::string defaultGroupId;
+ QList<std::pair<QByteArray, std::string>> candidates;
+
+ const int deviceCount = devices["length"].as<int>();
+ for (int i = 0; i < deviceCount; ++i) {
+ const emscripten::val mediaDevice = devices[i];
+ const std::string kind = stringProperty(mediaDevice, "kind");
+ if (kind != deviceKind)
+ continue;
+
+ const std::string deviceId = stringProperty(mediaDevice, "deviceId");
+ if (deviceId == s_defaultDeviceId) {
+ defaultGroupId = stringProperty(mediaDevice, "groupId");
+ continue;
+ }
+ if (isAliasDeviceId(deviceId))
+ continue;
+
+ candidates.append({ QByteArray::fromStdString(effectiveDeviceId(deviceId, kind)),
+ stringProperty(mediaDevice, "groupId") });
+ }
+
+ if (candidates.isEmpty()) {
+ qCDebug(qWasmMediaDevices) << "no" << kindName << "devices enumerated, no default";
+ return {};
+ }
+
+ if (!defaultGroupId.empty()) {
+ const auto it = ranges::find_if(candidates, [&defaultGroupId](const auto &candidate) {
+ return candidate.second == defaultGroupId;
+ });
+ if (it != candidates.cend()) {
+ qCDebug(qWasmMediaDevices)
+ << "default" << kindName << "resolved from the browser's default entry:"
+ << it->first << "via groupId" << QString::fromStdString(defaultGroupId);
+ return it->first;
+ }
+ qCDebug(qWasmMediaDevices)
+ << "the browser's default" << kindName << "entry has groupId"
+ << QString::fromStdString(defaultGroupId)
+ << "which matches no enumerated device, falling back to the first";
+ }
+ qCDebug(qWasmMediaDevices) << "default" << kindName
+ << "falls back to the first enumerated device:"
+ << candidates.constFirst().first;
+ return candidates.constFirst().first;
+ }
+
+ void QWasmMediaDevices::applyDefaultDevice(QList<QAudioDevice> &audioDevices,
+ const QByteArray &defaultDeviceId)
+ {
+ for (QAudioDevice &audioDevice : audioDevices) {
+ QAudioDevicePrivate *devicePrivate = QAudioDevicePrivate::handle(audioDevice);
+ if (!devicePrivate)
+ continue;
+ const bool isDefault = audioDevice.id() == defaultDeviceId;
+ if (devicePrivate->isDefault == isDefault)
+ continue;
+ qCDebug(qWasmMediaDevices) << "default" << audioDevice.mode()
+ << (isDefault ? "set to" : "cleared from")
+ << audioDevice.id() << audioDevice.description();
+ devicePrivate->isDefault = isDefault;
+ }
+ }
+
+ void QWasmMediaDevices::applyDefaultDevice(QList<QCameraDevice> &cameraDevices,
+ const QByteArray &defaultDeviceId)
+ {
+ for (QCameraDevice &cameraDevice : cameraDevices) {
+ auto *devicePrivate =
+ const_cast<QCameraDevicePrivate *>(QCameraDevicePrivate::handle(cameraDevice));
+ if (!devicePrivate)
+ continue;
+ const bool isDefault = cameraDevice.id() == defaultDeviceId;
+ if (devicePrivate->isDefault == isDefault)
+ continue;
+ qCDebug(qWasmMediaDevices) << "default camera"
+ << (isDefault ? "set to" : "cleared from")
+ << cameraDevice.id() << cameraDevice.description();
+ devicePrivate->isDefault = isDefault;
+ }
}
void QWasmMediaDevices::parseDevices(emscripten::val devices)
{
if (devices.isNull() || devices.isUndefined()) {
qWarning() << "Something went wrong enumerating devices";
return;
}
- QList<std::string> cameraDevicesToRemove = m_cameraDevices.keys();
- QList<std::string> audioOutputsToRemove;
- QList<std::string> audioInputsToRemove;
+ QList<QByteArray> cameraDevicesToRemove;
+ cameraDevicesToRemove.reserve(m_cameraDevices.count());
+ for (const QCameraDevice &cameraDevice : m_cameraDevices)
+ cameraDevicesToRemove.append(cameraDevice.id());
- audioOutputsToRemove = m_audioOutputs.keys();
- audioInputsToRemove = m_audioInputs.keys();
+ QList<QByteArray> audioOutputsToRemove;
+ audioOutputsToRemove.reserve(m_audioOutputs.count());
+ for (const QAudioDevice &audioDevice : m_audioOutputs)
+ audioOutputsToRemove.append(audioDevice.id());
+
+ QList<QByteArray> audioInputsToRemove;
+ audioInputsToRemove.reserve(m_audioInputs.count());
+ for (const QAudioDevice &audioDevice : m_audioInputs)
+ audioInputsToRemove.append(audioDevice.id());
m_audioInputsAdded = false;
m_audioOutputsAdded = false;
m_videoInputsAdded = false;
+ const QByteArray defaultCameraId = findDefaultDeviceId(devices, "videoinput");
+ const QByteArray defaultAudioInputId = findDefaultDeviceId(devices, "audioinput");
+ const QByteArray defaultAudioOutputId = findDefaultDeviceId(devices, "audiooutput");
+
bool m_videoInputsRemoved = false;
bool m_audioInputsRemoved = false;
bool m_audioOutputsRemoved = false;
for (int i = 0; i < devices["length"].as<int>(); i++) {
emscripten::val mediaDevice = devices[i];
const std::string deviceKind = mediaDevice["kind"].as<std::string>();
std::string label = mediaDevice["label"].as<std::string>();
std::string deviceId = mediaDevice["deviceId"].as<std::string>();
+ if (deviceKind.empty())
+ continue;
+
qCDebug(qWasmMediaDevices) << QString::fromStdString(deviceKind)
<< QString::fromStdString(deviceId)
- << QString::fromStdString(label);
+ << QString::fromStdString(label) << "groupId"
+ << QString::fromStdString(stringProperty(mediaDevice, "groupId"));
+
+ // the real device this aliases is enumerated separately
+ if (isAliasDeviceId(deviceId))
+ continue;
if (deviceId.empty()) { // no permissions we'll use System;
label = "System " + deviceKind;
deviceId = label;
}
- if (deviceKind.empty())
- continue;
- bool isDefault = false;
- if (deviceKind == std::string("videoinput")) {
- if (!m_cameraDevices.contains(deviceId)) {
+ const QByteArray qtDeviceId = QByteArray::fromStdString(deviceId);
+
+ if (deviceKind == std::string_view("videoinput")) {
+ if (!containsDeviceId(m_cameraDevices, qtDeviceId)) {
QCameraDevicePrivate *camera = new QCameraDevicePrivate; // QSharedData
- camera->id = QString::fromStdString(deviceId).toUtf8();
+ camera->id = qtDeviceId;
camera->description = QString::fromUtf8(label.c_str());
- // no camera defaults, first in wins!
- camera->isDefault = !m_videoInputsAdded;
- m_cameraDevices.insert(deviceId, camera->create());
+ camera->isDefault = false; // assigned by applyDefaultDevice() below
+ m_cameraDevices.append(camera->create());
m_videoInputsAdded = true;
}
- cameraDevicesToRemove.removeOne(deviceId);
- } else if (deviceKind == std::string("audioinput")) {
- if (!m_audioInputs.contains(deviceId)) {
- isDefault = !m_audioInputsAdded;
- m_audioInputs.insert(
- deviceId,
+ cameraDevicesToRemove.removeOne(qtDeviceId);
+ } else if (deviceKind == std::string_view("audioinput")) {
+ if (!containsDeviceId(m_audioInputs, qtDeviceId)) {
+ m_audioInputs.append(
QAudioDevicePrivate::createQAudioDevice(std::make_unique<QWasmAudioDevice>(
- deviceId.c_str(), label.c_str(), isDefault, QAudioDevice::Input)));
+ deviceId.c_str(), label.c_str(), false, QAudioDevice::Input)));
m_audioInputsAdded = true;
}
- audioInputsToRemove.removeOne(deviceId);
- } else if (deviceKind == std::string("audiooutput")) {
- if (!m_audioOutputs.contains(deviceId)) {
- isDefault = !m_audioOutputsAdded;
- m_audioOutputs.insert(
- deviceId,
+ audioInputsToRemove.removeOne(qtDeviceId);
+ } else if (deviceKind == std::string_view("audiooutput")) {
+ if (!containsDeviceId(m_audioOutputs, qtDeviceId)) {
+ m_audioOutputs.append(
QAudioDevicePrivate::createQAudioDevice(std::make_unique<QWasmAudioDevice>(
- deviceId.c_str(), label.c_str(), isDefault, QAudioDevice::Output)));
+ deviceId.c_str(), label.c_str(), false, QAudioDevice::Output)));
m_audioOutputsAdded = true;
}
- audioOutputsToRemove.removeOne(deviceId);
+ audioOutputsToRemove.removeOne(qtDeviceId);
}
// if permissions are given label will hold the actual
// camera name, such as "Live! Cam Sync 1080p (041e:409d)"
}
// any left here were removed
- int j = 0;
- for (; j < cameraDevicesToRemove.count(); j++) {
- m_cameraDevices.remove(cameraDevicesToRemove.at(j));
+ for (const QByteArray &cameraId : cameraDevicesToRemove) {
+ m_cameraDevices.removeIf([&](const QCameraDevice &cameraDevice) {
+ return cameraDevice.id() == cameraId;
+ });
}
m_videoInputsRemoved = !cameraDevicesToRemove.isEmpty();
- for (j = 0; j < audioInputsToRemove.count(); j++) {
- m_audioInputs.remove(audioInputsToRemove.at(j));
+ for (const QByteArray &audioDeviceId : audioInputsToRemove) {
+ m_audioInputs.removeIf([&audioDeviceId](const QAudioDevice &audioDevice) {
+ return audioDevice.id() == audioDeviceId;
+ });
}
m_audioInputsRemoved = !audioInputsToRemove.isEmpty();
- for (j = 0; j < audioOutputsToRemove.count(); j++) {
- m_audioOutputs.remove(audioOutputsToRemove.at(j));
+ for (const QByteArray &audioDeviceId : audioOutputsToRemove) {
+ m_audioOutputs.removeIf([&audioDeviceId](const QAudioDevice &audioDevice) {
+ return audioDevice.id() == audioDeviceId;
+ });
}
m_audioOutputsRemoved = !audioOutputsToRemove.isEmpty();
- if (m_videoInputsAdded || m_videoInputsRemoved) {
- auto videoDevices = static_cast<QWasmCameraDevices*>(QPlatformMediaIntegration::instance()->videoDevices());
- QMetaObject::invokeMethod(videoDevices, &QWasmCameraDevices::onVideoInputsChanged,
- Qt::QueuedConnection);
- }
- if (m_audioInputsAdded || m_audioInputsRemoved) {
- auto audioDevices = static_cast<QWasmAudioDevices*>(QPlatformMediaIntegration::instance()->audioDevices());
- QMetaObject::invokeMethod(audioDevices, &QWasmAudioDevices::onAudioInputsChanged,
- Qt::QueuedConnection);
- }
if (!m_audioOutputsAdded) {
// Firefox and Safari require mic or camera permissions
// (or selectAudioOutput for Firefox)
// to enumerate output devices, so we just fake one.
// The device actually does not require perms to play.
insertFallbackAudioOutput();
}
+
+ // re-evaluated on every enumeration: the default can move when devices are
+ // plugged in or removed, or when the user changes the system default
+ applyDefaultDevice(m_cameraDevices, defaultCameraId);
+ applyDefaultDevice(m_audioInputs, defaultAudioInputId);
+ applyDefaultDevice(m_audioOutputs, defaultAudioOutputId);
+
+ if (m_videoInputsAdded || m_videoInputsRemoved) {
+ auto videoDevices = static_cast<QWasmCameraDevices*>(QPlatformMediaIntegration::instance()->videoDevices());
+ QMetaObject::invokeMethod(videoDevices, &QWasmCameraDevices::onVideoInputsChanged,
+ Qt::QueuedConnection);
+ }
+ if (m_audioInputsAdded || m_audioInputsRemoved) {
+ auto audioDevices = static_cast<QWasmAudioDevices*>(QPlatformMediaIntegration::instance()->audioDevices());
+ QMetaObject::invokeMethod(audioDevices, &QWasmAudioDevices::onAudioInputsChanged,
+ Qt::QueuedConnection);
+ }
if (m_audioOutputsAdded || m_audioOutputsRemoved) {
auto audioDevices = static_cast<QWasmAudioDevices*>(QPlatformMediaIntegration::instance()->audioDevices());
QMetaObject::invokeMethod(audioDevices, &QWasmAudioDevices::onAudioOutputsChanged,
Qt::QueuedConnection);
}
}
void QWasmMediaDevices::insertFallbackAudioOutput()
{
- m_audioOutputs.insert(
- "",
- QAudioDevicePrivate::createQAudioDevice(std::make_unique<QWasmAudioDevice>(
- "", "System output", true, QAudioDevice::Output)));
+ const bool hasFallback = std::any_of(m_audioOutputs.cbegin(), m_audioOutputs.cend(),
+ [](const QAudioDevice &audioDevice) {
+ return audioDevice.id().isEmpty();
+ });
+ if (!hasFallback) {
+ m_audioOutputs.append(
+ QAudioDevicePrivate::createQAudioDevice(std::make_unique<QWasmAudioDevice>(
+ "", "System output", true, QAudioDevice::Output)));
+ }
m_audioOutputsAdded = true;
}
void QWasmMediaDevices::getMediaDevices()
{
emscripten::val navigator = emscripten::val::global("navigator");
m_jsMediaDevicesInterface = navigator["mediaDevices"];
if (m_jsMediaDevicesInterface.isNull() || m_jsMediaDevicesInterface.isUndefined()) {
qWarning() << "No media devices found";
return;
}
if (qstdweb::haveAsyncify()) {
#ifdef QT_HAVE_EMSCRIPTEN_ASYNCIFY
auto asyncEnumerate = [](void *arg){
QWasmMediaDevices *mediaDevices = static_cast<QWasmMediaDevices *>(arg);
mediaDevices->devicesList = mediaDevices->m_jsMediaDevicesInterface.call<emscripten::val>("enumerateDevices").await();
if (mediaDevices->devicesList.isNull() || mediaDevices->devicesList.isUndefined()) {
qWarning() << "devices list error";
return;
}
mediaDevices->parseDevices(mediaDevices->devicesList);
};
asyncEnumerate(this);
m_deviceChangedCallback = std::make_unique<qstdweb::EventCallback>(
m_jsMediaDevicesInterface, "devicechange",
[this, asyncEnumerate](emscripten::val) {
asyncEnumerate(this);
});
#endif
} else {
qstdweb::PromiseCallbacks enumerateDevicesCallback{
.thenFunc =
[&](emscripten::val devices) {
parseDevices(devices);
},
.catchFunc =
[this](emscripten::val error) {
qWarning() << "mediadevices enumerateDevices fail"
<< QString::fromStdString(error["name"].as<std::string>())
<< QString::fromStdString(error["message"].as<std::string>());
m_initDone = false;
},
.finallyFunc = {}
};
qstdweb::Promise::make(m_jsMediaDevicesInterface,
QStringLiteral("enumerateDevices"),
std::move(enumerateDevicesCallback));
// setup devicechange monitor
m_deviceChangedCallback = std::make_unique<qstdweb::EventCallback>(
m_jsMediaDevicesInterface, "devicechange",
[this, enumerateDevicesCallback](emscripten::val) {
qstdweb::Promise::make(m_jsMediaDevicesInterface,
QStringLiteral("enumerateDevices"),
std::move(enumerateDevicesCallback));
});
}
}
QT_END_NAMESPACE