summaryrefslogtreecommitdiffstats
path: root/dom/media/webrtc/MediaEngineWebRTC.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--dom/media/webrtc/MediaEngineWebRTC.cpp299
1 files changed, 299 insertions, 0 deletions
diff --git a/dom/media/webrtc/MediaEngineWebRTC.cpp b/dom/media/webrtc/MediaEngineWebRTC.cpp
new file mode 100644
index 0000000000..cf638497a9
--- /dev/null
+++ b/dom/media/webrtc/MediaEngineWebRTC.cpp
@@ -0,0 +1,299 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MediaEngineWebRTC.h"
+
+#include "CamerasChild.h"
+#include "MediaEngineRemoteVideoSource.h"
+#include "MediaEngineWebRTCAudio.h"
+#include "MediaManager.h"
+#include "mozilla/Logging.h"
+
+// Pipewire detection support
+#if defined(WEBRTC_USE_PIPEWIRE)
+# include "mozilla/StaticPrefs_media.h"
+# include "modules/desktop_capture/desktop_capturer.h"
+#endif
+
+#define FAKE_ONDEVICECHANGE_EVENT_PERIOD_IN_MS 500
+
+static mozilla::LazyLogModule sGetUserMediaLog("GetUserMedia");
+#undef LOG
+#define LOG(args) MOZ_LOG(sGetUserMediaLog, mozilla::LogLevel::Debug, args)
+
+namespace mozilla {
+
+using AudioDeviceSet = CubebDeviceEnumerator::AudioDeviceSet;
+using camera::CamerasChild;
+using camera::GetChildAndCall;
+using dom::MediaSourceEnum;
+
+CubebDeviceEnumerator* GetEnumerator() {
+ return CubebDeviceEnumerator::GetInstance();
+}
+
+MediaEngineWebRTC::MediaEngineWebRTC() {
+ AssertIsOnOwningThread();
+
+ GetChildAndCall(
+ &CamerasChild::ConnectDeviceListChangeListener<MediaEngineWebRTC>,
+ &mCameraListChangeListener, AbstractThread::MainThread(), this,
+ &MediaEngineWebRTC::DeviceListChanged);
+ mMicrophoneListChangeListener =
+ GetEnumerator()->OnAudioInputDeviceListChange().Connect(
+ AbstractThread::MainThread(), this,
+ &MediaEngineWebRTC::DeviceListChanged);
+ mSpeakerListChangeListener =
+ GetEnumerator()->OnAudioOutputDeviceListChange().Connect(
+ AbstractThread::MainThread(), this,
+ &MediaEngineWebRTC::DeviceListChanged);
+}
+
+void MediaEngineWebRTC::EnumerateVideoDevices(
+ MediaSourceEnum aMediaSource, nsTArray<RefPtr<MediaDevice>>* aDevices) {
+ AssertIsOnOwningThread();
+ // flag sources with cross-origin exploit potential
+ bool scaryKind = (aMediaSource == MediaSourceEnum::Screen ||
+ aMediaSource == MediaSourceEnum::Browser);
+#if defined(WEBRTC_USE_PIPEWIRE)
+ bool canRequestOsLevelPrompt =
+ mozilla::StaticPrefs::media_webrtc_capture_allow_pipewire() &&
+ webrtc::DesktopCapturer::IsRunningUnderWayland() &&
+ (aMediaSource == MediaSourceEnum::Application ||
+ aMediaSource == MediaSourceEnum::Screen ||
+ aMediaSource == MediaSourceEnum::Window);
+#else
+ bool canRequestOsLevelPrompt = false;
+#endif
+ /*
+ * We still enumerate every time, in case a new device was plugged in since
+ * the last call. TODO: Verify that WebRTC actually does deal with hotplugging
+ * new devices (with or without new engine creation) and accordingly adjust.
+ * Enumeration is not neccessary if GIPS reports the same set of devices
+ * for a given instance of the engine.
+ */
+ int num;
+#if defined(_ARM64_) && defined(XP_WIN)
+ // There are problems with using DirectShow on versions of Windows before
+ // 19H1 on arm64. This disables the camera on older versions of Windows.
+ if (aMediaSource == MediaSourceEnum::Camera) {
+ typedef ULONG (*RtlGetVersionFn)(LPOSVERSIONINFOEXW);
+ RtlGetVersionFn RtlGetVersion;
+ RtlGetVersion = (RtlGetVersionFn)GetProcAddress(GetModuleHandleA("ntdll"),
+ "RtlGetVersion");
+ if (RtlGetVersion) {
+ OSVERSIONINFOEXW info;
+ info.dwOSVersionInfoSize = sizeof(info);
+ RtlGetVersion(&info);
+ // 19H1 is 18346
+ if (info.dwBuildNumber < 18346) {
+ return;
+ }
+ }
+ }
+#endif
+ camera::CaptureEngine capEngine =
+ MediaEngineRemoteVideoSource::CaptureEngine(aMediaSource);
+ num = GetChildAndCall(&CamerasChild::NumberOfCaptureDevices, capEngine);
+
+ for (int i = 0; i < num; i++) {
+ char deviceName[MediaEngineSource::kMaxDeviceNameLength];
+ char uniqueId[MediaEngineSource::kMaxUniqueIdLength];
+ bool scarySource = false;
+
+ // paranoia
+ deviceName[0] = '\0';
+ uniqueId[0] = '\0';
+ int error;
+
+ error = GetChildAndCall(&CamerasChild::GetCaptureDevice, capEngine, i,
+ deviceName, sizeof(deviceName), uniqueId,
+ sizeof(uniqueId), &scarySource);
+ if (error) {
+ LOG(("camera:GetCaptureDevice: Failed %d", error));
+ continue;
+ }
+#ifdef DEBUG
+ LOG((" Capture Device Index %d, Name %s", i, deviceName));
+
+ webrtc::CaptureCapability cap;
+ int numCaps = GetChildAndCall(&CamerasChild::NumberOfCapabilities,
+ capEngine, uniqueId);
+ LOG(("Number of Capabilities %d", numCaps));
+ for (int j = 0; j < numCaps; j++) {
+ if (GetChildAndCall(&CamerasChild::GetCaptureCapability, capEngine,
+ uniqueId, j, &cap) != 0) {
+ break;
+ }
+ LOG(("type=%d width=%d height=%d maxFPS=%d",
+ static_cast<int>(cap.videoType), cap.width, cap.height, cap.maxFPS));
+ }
+#endif
+
+ NS_ConvertUTF8toUTF16 name(deviceName);
+ NS_ConvertUTF8toUTF16 uuid(uniqueId);
+ // The remote video backend doesn't implement group id. We return the
+ // device name and higher layers will correlate this with the name of
+ // audio devices.
+ aDevices->EmplaceBack(new MediaDevice(
+ this, aMediaSource, name, uuid, uuid,
+ MediaDevice::IsScary(scaryKind || scarySource),
+ canRequestOsLevelPrompt ? MediaDevice::OsPromptable::Yes
+ : MediaDevice::OsPromptable::No));
+ }
+}
+
+void MediaEngineWebRTC::EnumerateMicrophoneDevices(
+ nsTArray<RefPtr<MediaDevice>>* aDevices) {
+ AssertIsOnOwningThread();
+
+ RefPtr<const AudioDeviceSet> devices =
+ GetEnumerator()->EnumerateAudioInputDevices();
+
+ DebugOnly<bool> foundPreferredDevice = false;
+
+ for (const auto& deviceInfo : *devices) {
+#ifndef ANDROID
+ MOZ_ASSERT(deviceInfo->DeviceID());
+#endif
+ LOG(("Cubeb device: type 0x%x, state 0x%x, name %s, id %p",
+ deviceInfo->Type(), deviceInfo->State(),
+ NS_ConvertUTF16toUTF8(deviceInfo->Name()).get(),
+ deviceInfo->DeviceID()));
+
+ if (deviceInfo->State() == CUBEB_DEVICE_STATE_ENABLED) {
+ MOZ_ASSERT(deviceInfo->Type() == CUBEB_DEVICE_TYPE_INPUT);
+ // Lie and provide the name as UUID
+ RefPtr device = new MediaDevice(this, deviceInfo, deviceInfo->Name());
+ if (deviceInfo->Preferred()) {
+#ifdef DEBUG
+ if (!foundPreferredDevice) {
+ foundPreferredDevice = true;
+ } else {
+ // This is possible on windows, there is a default communication
+ // device, and a default device:
+ // See https://bugzilla.mozilla.org/show_bug.cgi?id=1542739
+# ifndef XP_WIN
+ MOZ_ASSERT(!foundPreferredDevice,
+ "Found more than one preferred audio input device"
+ "while enumerating");
+# endif
+ }
+#endif
+ aDevices->InsertElementAt(0, std::move(device));
+ } else {
+ aDevices->AppendElement(std::move(device));
+ }
+ }
+ }
+}
+
+void MediaEngineWebRTC::EnumerateSpeakerDevices(
+ nsTArray<RefPtr<MediaDevice>>* aDevices) {
+ AssertIsOnOwningThread();
+
+ RefPtr<const AudioDeviceSet> devices =
+ GetEnumerator()->EnumerateAudioOutputDevices();
+
+#ifndef XP_WIN
+ DebugOnly<bool> preferredDeviceFound = false;
+#endif
+ for (const auto& deviceInfo : *devices) {
+ LOG(("Cubeb device: type 0x%x, state 0x%x, name %s, id %p",
+ deviceInfo->Type(), deviceInfo->State(),
+ NS_ConvertUTF16toUTF8(deviceInfo->Name()).get(),
+ deviceInfo->DeviceID()));
+ if (deviceInfo->State() == CUBEB_DEVICE_STATE_ENABLED) {
+ MOZ_ASSERT(deviceInfo->Type() == CUBEB_DEVICE_TYPE_OUTPUT);
+ nsString uuid(deviceInfo->Name());
+ // If, for example, input and output are in the same device, uuid
+ // would be the same for both which ends up to create the same
+ // deviceIDs (in JS).
+ uuid.Append(u"_Speaker"_ns);
+ RefPtr device = new MediaDevice(this, deviceInfo, uuid);
+ if (deviceInfo->Preferred()) {
+ // In windows is possible to have more than one preferred device
+#if defined(DEBUG) && !defined(XP_WIN)
+ MOZ_ASSERT(!preferredDeviceFound, "More than one preferred device");
+ preferredDeviceFound = true;
+#endif
+ aDevices->InsertElementAt(0, std::move(device));
+ } else {
+ aDevices->AppendElement(std::move(device));
+ }
+ }
+ }
+}
+
+void MediaEngineWebRTC::EnumerateDevices(
+ MediaSourceEnum aMediaSource, MediaSinkEnum aMediaSink,
+ nsTArray<RefPtr<MediaDevice>>* aDevices) {
+ AssertIsOnOwningThread();
+ MOZ_ASSERT(aMediaSource != MediaSourceEnum::Other ||
+ aMediaSink != MediaSinkEnum::Other);
+ if (MediaEngineSource::IsVideo(aMediaSource)) {
+ switch (aMediaSource) {
+ case MediaSourceEnum::Window:
+ // Since the mediaSource constraint is deprecated, treat the Window
+ // value as a request for getDisplayMedia-equivalent sharing: Combine
+ // window and fullscreen into a single list of choices. The other values
+ // are still useful for testing.
+ EnumerateVideoDevices(MediaSourceEnum::Window, aDevices);
+ EnumerateVideoDevices(MediaSourceEnum::Browser, aDevices);
+ EnumerateVideoDevices(MediaSourceEnum::Screen, aDevices);
+ break;
+ case MediaSourceEnum::Screen:
+ case MediaSourceEnum::Browser:
+ case MediaSourceEnum::Camera:
+ EnumerateVideoDevices(aMediaSource, aDevices);
+ break;
+ default:
+ MOZ_CRASH("No valid video source");
+ break;
+ }
+ } else if (aMediaSource == MediaSourceEnum::AudioCapture) {
+ aDevices->EmplaceBack(new MediaDevice(
+ this, aMediaSource, u"AudioCapture"_ns,
+ MediaEngineWebRTCAudioCaptureSource::GetUUID(),
+ MediaEngineWebRTCAudioCaptureSource::GetGroupId(),
+ MediaDevice::IsScary::No, MediaDevice::OsPromptable::No));
+ } else if (aMediaSource == MediaSourceEnum::Microphone) {
+ EnumerateMicrophoneDevices(aDevices);
+ }
+
+ if (aMediaSink == MediaSinkEnum::Speaker) {
+ EnumerateSpeakerDevices(aDevices);
+ }
+}
+
+RefPtr<MediaEngineSource> MediaEngineWebRTC::CreateSource(
+ const MediaDevice* aMediaDevice) {
+ MOZ_ASSERT(aMediaDevice->mEngine == this);
+ if (MediaEngineSource::IsVideo(aMediaDevice->mMediaSource)) {
+ return new MediaEngineRemoteVideoSource(aMediaDevice);
+ }
+ switch (aMediaDevice->mMediaSource) {
+ case MediaSourceEnum::AudioCapture:
+ return new MediaEngineWebRTCAudioCaptureSource(aMediaDevice);
+ case MediaSourceEnum::Microphone:
+ return new MediaEngineWebRTCMicrophoneSource(aMediaDevice);
+ default:
+ MOZ_CRASH("Unsupported source type");
+ return nullptr;
+ }
+}
+
+void MediaEngineWebRTC::Shutdown() {
+ AssertIsOnOwningThread();
+ mCameraListChangeListener.DisconnectIfExists();
+ mMicrophoneListChangeListener.DisconnectIfExists();
+ mSpeakerListChangeListener.DisconnectIfExists();
+
+ LOG(("%s", __FUNCTION__));
+ mozilla::camera::Shutdown();
+}
+
+} // namespace mozilla