init

Telegram/lib_webrtc/webrtc/details/webrtc_environment_openal.cpp

@@ -0,0 +1,158 @@
+// This file is part of Desktop App Toolkit,
+// a set of libraries for developing nice desktop applications.
+//
+// For license and copyright information please follow this link:
+// https://github.com/desktop-app/legal/blob/master/LEGAL
+//
+#include "webrtc/details/webrtc_environment_openal.h"
+
+#include "webrtc/webrtc_environment.h"
+
+#include <al.h>
+#include <alc.h>
+
+namespace Webrtc::details {
+namespace {
+
+template <typename Callback>
+void EnumerateDevices(DeviceType type, Callback &&callback) {
+	const auto specifier = (type == DeviceType::Playback)
+		? ALC_ALL_DEVICES_SPECIFIER
+		: ALC_CAPTURE_DEVICE_SPECIFIER;
+	auto devices = alcGetString(nullptr, specifier);
+	Assert(devices != nullptr);
+	while (*devices != 0) {
+		callback(devices);
+		while (*devices != 0) {
+			++devices;
+		}
+		++devices;
+	}
+}
+
+[[nodiscard]] DeviceInfo DeviceFromOpenAL(
+	DeviceType type,
+	const char *device) {
+	if (!device) {
+		return {};
+	}
+	const auto guid = QString::fromUtf8(device);
+	const auto prefix = u"OpenAL Soft on "_q;
+	return {
+		.id = guid,
+		.name = (guid.startsWith(prefix) ? guid.mid(prefix.size()) : guid),
+		.type = type,
+	};
+}
+
+} // namespace
+
+EnvironmentOpenAL::EnvironmentOpenAL(not_null<EnvironmentDelegate*> delegate)
+: _delegate(delegate) {
+}
+
+EnvironmentOpenAL::~EnvironmentOpenAL() {
+}
+
+QString EnvironmentOpenAL::defaultId(DeviceType type) {
+	return DefaultId(type);
+}
+
+QString EnvironmentOpenAL::DefaultId(DeviceType type) {
+	Expects(type == DeviceType::Playback || type == DeviceType::Capture);
+
+	[[maybe_unused]] const auto reenumerate = alcGetString(
+		nullptr,
+		(type == DeviceType::Capture)
+			? ALC_CAPTURE_DEVICE_SPECIFIER
+			: ALC_ALL_DEVICES_SPECIFIER);
+
+	return QString::fromUtf8(
+		alcGetString(nullptr, (type == DeviceType::Capture)
+			? ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER
+			: ALC_DEFAULT_ALL_DEVICES_SPECIFIER));
+}
+
+DeviceResolvedId EnvironmentOpenAL::DefaultResolvedId(DeviceType type) {
+	return { DefaultId(type), type, true };
+}
+
+DeviceResolvedId EnvironmentOpenAL::ResolveId(
+		DeviceType type,
+		const QString &savedId) {
+	if (savedId.isEmpty() || savedId == kDefaultDeviceId) {
+		return DefaultResolvedId(type);
+	}
+	auto found = false;
+	EnumerateDevices(type, [&](const char *device) {
+		const auto info = DeviceFromOpenAL(type, device);
+		if (info.id == savedId) {
+			found = true;
+		}
+	});
+	return found
+		? DeviceResolvedId{ savedId, type }
+		: DefaultResolvedId(type);
+}
+
+DeviceInfo EnvironmentOpenAL::device(DeviceType type, const QString &id) {
+	Expects(type == DeviceType::Playback || type == DeviceType::Capture);
+
+	auto result = DeviceInfo();
+	EnumerateDevices(type, [&](const char *device) {
+		auto info = DeviceFromOpenAL(type, device);
+		if (info.id == id) {
+			result = std::move(info);
+		}
+	});
+	return result;
+}
+
+std::vector<DeviceInfo> EnvironmentOpenAL::devices(DeviceType type) {
+	Expects(type == DeviceType::Playback || type == DeviceType::Capture);
+
+	auto result = std::vector<DeviceInfo>();
+	EnumerateDevices(type, [&](const char *device) {
+		if (auto info = DeviceFromOpenAL(type, device)) {
+			result.push_back(std::move(info));
+		}
+	});
+	return result;
+}
+
+bool EnvironmentOpenAL::refreshFullListOnChange(DeviceType type) {
+	Expects(type == DeviceType::Playback || type == DeviceType::Capture);
+
+	return true;
+}
+
+bool EnvironmentOpenAL::desktopCaptureAllowed() const {
+	Unexpected("EnvironmentOpenAL::desktopCaptureAllowed.");
+}
+
+auto EnvironmentOpenAL::uniqueDesktopCaptureSource() const
+-> std::optional<QString> {
+	Unexpected("EnvironmentOpenAL::uniqueDesktopCaptureSource.");
+}
+
+void EnvironmentOpenAL::defaultIdRequested(DeviceType type) {
+	_delegate->devicesForceRefresh(type);
+}
+
+void EnvironmentOpenAL::devicesRequested(DeviceType type) {
+	_delegate->devicesForceRefresh(type);
+}
+
+DeviceResolvedId EnvironmentOpenAL::threadSafeResolveId(
+		const DeviceResolvedId &lastResolvedId,
+		const QString &savedId) {
+	const auto result = ResolveId(lastResolvedId.type, savedId);
+	if (result != lastResolvedId) {
+		crl::on_main(this, [=, type = lastResolvedId.type] {
+			_delegate->devicesForceRefresh(type);
+		});
+	}
+	return result;
+}
+
+} // namespace Webrtc::details

Telegram/lib_webrtc/webrtc/details/webrtc_environment_openal.h

@@ -0,0 +1,51 @@
+// This file is part of Desktop App Toolkit,
+// a set of libraries for developing nice desktop applications.
+//
+// For license and copyright information please follow this link:
+// https://github.com/desktop-app/legal/blob/master/LEGAL
+//
+#pragma once
+
+#include "base/weak_ptr.h"
+#include "webrtc/platform/webrtc_platform_environment.h"
+
+namespace Webrtc::details {
+
+class EnvironmentOpenAL final
+	: public Platform::Environment
+	, public base::has_weak_ptr {
+public:
+	using EnvironmentDelegate = Platform::EnvironmentDelegate;
+
+	explicit EnvironmentOpenAL(not_null<EnvironmentDelegate*> delegate);
+	~EnvironmentOpenAL();
+
+	QString defaultId(DeviceType type) override;
+	DeviceInfo device(DeviceType type, const QString &id) override;
+
+	std::vector<DeviceInfo> devices(DeviceType type) override;
+	bool refreshFullListOnChange(DeviceType type) override;
+
+	bool desktopCaptureAllowed() const override;
+	std::optional<QString> uniqueDesktopCaptureSource() const override;
+
+	void defaultIdRequested(DeviceType type) override;
+	void devicesRequested(DeviceType type) override;
+
+	DeviceResolvedId threadSafeResolveId(
+		const DeviceResolvedId &lastResolvedId,
+		const QString &savedId) override;
+
+	[[nodiscard]] static QString DefaultId(DeviceType type);
+
+private:
+	[[nodiscard]] static DeviceResolvedId DefaultResolvedId(DeviceType type);
+	[[nodiscard]] static DeviceResolvedId ResolveId(
+		DeviceType type,
+		const QString &savedId);
+
+	const not_null<EnvironmentDelegate*> _delegate;
+
+};
+
+} // namespace Webrtc::details

Telegram/lib_webrtc/webrtc/details/webrtc_environment_video_capture.cpp

@@ -0,0 +1,133 @@
+// This file is part of Desktop App Toolkit,
+// a set of libraries for developing nice desktop applications.
+//
+// For license and copyright information please follow this link:
+// https://github.com/desktop-app/legal/blob/master/LEGAL
+//
+#include "webrtc/details/webrtc_environment_video_capture.h"
+
+#include "webrtc/webrtc_environment.h"
+
+#include <api/task_queue/default_task_queue_factory.h>
+#include <modules/video_capture/video_capture_factory.h>
+#include <modules/audio_device/include/audio_device_factory.h>
+
+#ifdef WEBRTC_LINUX // Breaks compilation on MSVC because of ERROR define.
+#include <modules/video_capture/video_capture_options.h>
+#endif // WEBRTC_LINUX
+
+namespace Webrtc::details {
+namespace {
+
+#ifdef WEBRTC_LINUX
+[[nodiscard]] webrtc::VideoCaptureOptions GetVideoCaptureOptions() {
+	auto result = webrtc::VideoCaptureOptions();
+	result.set_allow_v4l2(true);
+#ifdef WEBRTC_USE_PIPEWIRE
+	//result.set_allow_pipewire(true);
+	// This requires a call to result.Init(callback)
+	// and waiting for the callback to finish.
+#endif
+	return result;
+}
+#endif
+
+[[nodiscard]] std::vector<DeviceInfo> GetDevices() {
+#ifdef WEBRTC_LINUX
+	auto options = GetVideoCaptureOptions();
+	const auto info = std::unique_ptr<
+		webrtc::VideoCaptureModule::DeviceInfo
+	>(webrtc::VideoCaptureFactory::CreateDeviceInfo(&options));
+#else // WEBRTC_LINUX
+	const auto info = std::unique_ptr<
+		webrtc::VideoCaptureModule::DeviceInfo
+	>(webrtc::VideoCaptureFactory::CreateDeviceInfo());
+#endif
+
+	auto result = std::vector<DeviceInfo>();
+	if (!info) {
+		return result;
+	}
+	const auto count = info->NumberOfDevices();
+	for (auto i = uint32_t(); i != count; ++i) {
+		constexpr auto kLengthLimit = 256;
+		auto id = std::string(kLengthLimit, char(0));
+		auto name = std::string(kLengthLimit, char(0));
+		info->GetDeviceName(
+			i,
+			name.data(),
+			name.size(),
+			id.data(),
+			id.size());
+		const auto utfName = QString::fromUtf8(name.c_str());
+		const auto utfId = id[0] ? QString::fromUtf8(id.c_str()) : utfName;
+		result.push_back({
+			.id = utfId,
+			.name = utfName,
+			.type = DeviceType::Camera,
+		});
+	}
+	return result;
+}
+
+} // namespace
+
+EnvironmentVideoCapture::EnvironmentVideoCapture(
+	not_null<EnvironmentDelegate*> delegate)
+: _delegate(delegate) {
+}
+
+EnvironmentVideoCapture::~EnvironmentVideoCapture() {
+}
+
+QString EnvironmentVideoCapture::defaultId(DeviceType type) {
+	Expects(type == DeviceType::Camera);
+
+	return DefaultId();
+}
+
+DeviceInfo EnvironmentVideoCapture::device(
+		DeviceType type,
+		const QString &id) {
+	Expects(type == DeviceType::Camera);
+
+	const auto devices = GetDevices();
+	const auto i = ranges::find(devices, id, &DeviceInfo::id);
+	return (i != end(devices)) ? *i : DeviceInfo();
+}
+
+std::vector<DeviceInfo> EnvironmentVideoCapture::devices(DeviceType type) {
+	Expects(type == DeviceType::Camera);
+
+	return GetDevices();
+}
+
+bool EnvironmentVideoCapture::refreshFullListOnChange(DeviceType type) {
+	Expects(type == DeviceType::Camera);
+
+	return true;
+}
+
+bool EnvironmentVideoCapture::desktopCaptureAllowed() const {
+	Unexpected("EnvironmentVideoCapture::desktopCaptureAllowed.");
+}
+
+auto EnvironmentVideoCapture::uniqueDesktopCaptureSource() const
+-> std::optional<QString> {
+	Unexpected("EnvironmentVideoCapture::uniqueDesktopCaptureSource.");
+}
+
+void EnvironmentVideoCapture::defaultIdRequested(DeviceType type) {
+	_delegate->devicesForceRefresh(type);
+}
+
+void EnvironmentVideoCapture::devicesRequested(DeviceType type) {
+	_delegate->devicesForceRefresh(type);
+}
+
+QString EnvironmentVideoCapture::DefaultId() {
+	const auto devices = GetDevices();
+	return devices.empty() ? QString() : devices.front().id;
+}
+
+} // namespace Webrtc::details

Telegram/lib_webrtc/webrtc/details/webrtc_environment_video_capture.h

@@ -0,0 +1,40 @@
+// This file is part of Desktop App Toolkit,
+// a set of libraries for developing nice desktop applications.
+//
+// For license and copyright information please follow this link:
+// https://github.com/desktop-app/legal/blob/master/LEGAL
+//
+#pragma once
+
+#include "webrtc/platform/webrtc_platform_environment.h"
+
+namespace Webrtc::details {
+
+class EnvironmentVideoCapture final : public Platform::Environment {
+public:
+	using EnvironmentDelegate = Platform::EnvironmentDelegate;
+
+	explicit EnvironmentVideoCapture(
+		not_null<EnvironmentDelegate*> delegate);
+	~EnvironmentVideoCapture();
+
+	QString defaultId(DeviceType type) override;
+	DeviceInfo device(DeviceType type, const QString &id) override;
+
+	std::vector<DeviceInfo> devices(DeviceType type) override;
+	bool refreshFullListOnChange(DeviceType type) override;
+
+	bool desktopCaptureAllowed() const override;
+	std::optional<QString> uniqueDesktopCaptureSource() const override;
+
+	void defaultIdRequested(DeviceType type) override;
+	void devicesRequested(DeviceType type) override;
+
+	[[nodiscard]] static QString DefaultId();
+
+private:
+	const not_null<EnvironmentDelegate*> _delegate;
+
+};
+
+} // namespace Webrtc::details

Telegram/lib_webrtc/webrtc/details/webrtc_openal_adm.h

@@ -0,0 +1,209 @@
+// This file is part of Desktop App Toolkit,
+// a set of libraries for developing nice desktop applications.
+//
+// For license and copyright information please follow this link:
+// https://github.com/desktop-app/legal/blob/master/LEGAL
+//
+#pragma once
+
+#include "webrtc/webrtc_device_common.h"
+
+#include <modules/audio_device/include/audio_device.h>
+#include <modules/audio_device/audio_device_buffer.h>
+
+#include <crl/crl_time.h>
+#include <al.h>
+#include <alc.h>
+#include <atomic>
+
+#include <QtCore/QMutex>
+
+namespace rtc {
+class Thread;
+} // namespace rtc
+
+namespace Webrtc::details {
+
+struct DeviceResolvedIds {
+	QMutex mutex;
+	DeviceResolvedId playback{ .type = DeviceType::Playback };
+	DeviceResolvedId capture{ .type = DeviceType::Capture };
+};
+
+class AudioDeviceOpenAL : public webrtc::AudioDeviceModule {
+public:
+	explicit AudioDeviceOpenAL(webrtc::TaskQueueFactory *taskQueueFactory);
+	~AudioDeviceOpenAL();
+
+	[[nodiscard]] Fn<void(DeviceResolvedId)> setDeviceIdCallback();
+
+	int32_t ActiveAudioLayer(AudioLayer *audioLayer) const override;
+	int32_t RegisterAudioCallback(
+		webrtc::AudioTransport *audioCallback) override;
+
+	// Main initialization and termination
+	int32_t Init() override;
+	int32_t Terminate() override;
+	bool Initialized() const override;
+
+	// Device enumeration
+	int16_t PlayoutDevices() override;
+	int16_t RecordingDevices() override;
+	int32_t PlayoutDeviceName(uint16_t index,
+		char name[webrtc::kAdmMaxDeviceNameSize],
+		char guid[webrtc::kAdmMaxGuidSize]) override;
+	int32_t RecordingDeviceName(uint16_t index,
+		char name[webrtc::kAdmMaxDeviceNameSize],
+		char guid[webrtc::kAdmMaxGuidSize]) override;
+
+	// Device selection
+	int32_t SetPlayoutDevice(uint16_t index) override;
+	int32_t SetPlayoutDevice(WindowsDeviceType device) override;
+	int32_t SetRecordingDevice(uint16_t index) override;
+	int32_t SetRecordingDevice(WindowsDeviceType device) override;
+
+	// Audio transport initialization
+	int32_t PlayoutIsAvailable(bool *available) override;
+	int32_t InitPlayout() override;
+	bool PlayoutIsInitialized() const override;
+	int32_t RecordingIsAvailable(bool *available) override;
+	int32_t InitRecording() override;
+	bool RecordingIsInitialized() const override;
+
+	// Audio transport control
+	int32_t StartPlayout() override;
+	int32_t StopPlayout() override;
+	bool Playing() const override;
+	int32_t StartRecording() override;
+	int32_t StopRecording() override;
+	bool Recording() const override;
+
+	// Audio mixer initialization
+	int32_t InitSpeaker() override;
+	bool SpeakerIsInitialized() const override;
+	int32_t InitMicrophone() override;
+	bool MicrophoneIsInitialized() const override;
+
+	// Speaker volume controls
+	int32_t SpeakerVolumeIsAvailable(bool *available) override;
+	int32_t SetSpeakerVolume(uint32_t volume) override;
+	int32_t SpeakerVolume(uint32_t *volume) const override;
+	int32_t MaxSpeakerVolume(uint32_t *maxVolume) const override;
+	int32_t MinSpeakerVolume(uint32_t *minVolume) const override;
+
+	// Microphone volume controls
+	int32_t MicrophoneVolumeIsAvailable(bool *available) override;
+	int32_t SetMicrophoneVolume(uint32_t volume) override;
+	int32_t MicrophoneVolume(uint32_t *volume) const override;
+	int32_t MaxMicrophoneVolume(uint32_t *maxVolume) const override;
+	int32_t MinMicrophoneVolume(uint32_t *minVolume) const override;
+
+	// Microphone mute control
+	int32_t MicrophoneMuteIsAvailable(bool *available) override;
+	int32_t SetMicrophoneMute(bool enable) override;
+	int32_t MicrophoneMute(bool *enabled) const override;
+
+	// Speaker mute control
+	int32_t SpeakerMuteIsAvailable(bool *available) override;
+	int32_t SetSpeakerMute(bool enable) override;
+	int32_t SpeakerMute(bool *enabled) const override;
+
+	// Stereo support
+	int32_t StereoPlayoutIsAvailable(bool *available) const override;
+	int32_t SetStereoPlayout(bool enable) override;
+	int32_t StereoPlayout(bool *enabled) const override;
+	int32_t StereoRecordingIsAvailable(bool *available) const override;
+	int32_t SetStereoRecording(bool enable) override;
+	int32_t StereoRecording(bool *enabled) const override;
+
+	// Delay information and control
+	int32_t PlayoutDelay(uint16_t *delayMS) const override;
+
+	// Only supported on Android.
+	bool BuiltInAECIsAvailable() const override;
+	bool BuiltInAGCIsAvailable() const override;
+	bool BuiltInNSIsAvailable() const override;
+
+	// Enables the built-in audio effects. Only supported on Android.
+	int32_t EnableBuiltInAEC(bool enable) override;
+	int32_t EnableBuiltInAGC(bool enable) override;
+	int32_t EnableBuiltInNS(bool enable) override;
+
+private:
+	struct Data;
+	struct ExactQueuedTime {
+		crl::time now = 0;
+		crl::time queued = 0;
+	};
+
+	template <typename Callback>
+	std::invoke_result_t<Callback> sync(Callback &&callback);
+
+	void openRecordingDevice();
+	void openPlayoutDevice();
+	void closeRecordingDevice();
+
+	// NB! stopPlayingOnThread should be called before this,
+	// to clear the thread local context and event callback.
+	void closePlayoutDevice();
+
+	int restartPlayout();
+	int restartRecording();
+	void restartRecordingQueued();
+	void restartPlayoutQueued();
+
+	void ensureThreadStarted();
+	void startCaptureOnThread();
+	void stopCaptureOnThread();
+	void startPlayingOnThread();
+
+	// NB! closePlayoutDevice should be called after this, so that next time
+	// we start playing, we set the thread local context and event callback.
+	void stopPlayingOnThread();
+
+	void processData();
+	void processRecordingData();
+	void processPlayoutData();
+	bool processRecordedPart(bool firstInCycle);
+
+	void clearProcessedBuffers();
+	bool clearProcessedBuffer();
+	void unqueueAllBuffers();
+
+	void handleEvent(
+		ALenum eventType,
+		ALuint object,
+		ALuint param,
+		ALsizei length,
+		const ALchar *message);
+
+	[[nodiscard]] crl::time countExactQueuedMsForLatency(
+		crl::time now,
+		bool playing);
+	[[nodiscard]] crl::time queryRecordingLatencyMs();
+
+	rtc::Thread *_thread = nullptr;
+	webrtc::AudioDeviceBuffer _audioDeviceBuffer;
+	std::unique_ptr<Data> _data;
+
+	std::shared_ptr<DeviceResolvedIds> _deviceResolvedIds;
+
+	ALCdevice *_playoutDevice = nullptr;
+	ALCcontext *_playoutContext = nullptr;
+	crl::time _playoutLatency = 0;
+	int _playoutChannels = 2;
+	bool _playoutInitialized = false;
+	bool _playoutFailed = false;
+
+	ALCdevice *_recordingDevice = nullptr;
+	crl::time _recordingLatency = 0;
+	bool _recordingInitialized = false;
+	bool _recordingFailed = false;
+
+	bool _speakerInitialized = false;
+	bool _microphoneInitialized = false;
+	bool _initialized = false;
+
+};
+
+} // namespace Webrtc::details