From 8db3a552d6c609a526ddf44806206a041d565545 Mon Sep 17 00:00:00 2001 From: Scan Date: Wed, 28 Aug 2024 11:43:11 -0400 Subject: [PATCH] Re-implement Pipewire backend on 24-08-24 --- CMakeLists.txt | 1 + hooks/audio/audio.h | 5 +- hooks/audio/backends/wasapi/audio_client.cpp | 4 + hooks/audio/implementations/pipewire.cpp | 273 +++++++++++++++++++ hooks/audio/implementations/pipewire.h | 35 +++ launcher/options.cpp | 2 +- 6 files changed, 318 insertions(+), 2 deletions(-) create mode 100644 hooks/audio/implementations/pipewire.cpp create mode 100644 hooks/audio/implementations/pipewire.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 5b0dbe6..5bb9c1d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -473,6 +473,7 @@ set(SOURCE_FILES ${SOURCE_FILES} hooks/audio/implementations/asio.cpp hooks/audio/implementations/wave_out.cpp hooks/audio/implementations/none.cpp + hooks/audio/implementations/pipewire.cpp hooks/avshook.cpp hooks/cfgmgr32hook.cpp hooks/debughook.cpp diff --git a/hooks/audio/audio.h b/hooks/audio/audio.h index a86915d..aaf8e3d 100644 --- a/hooks/audio/audio.h +++ b/hooks/audio/audio.h @@ -13,7 +13,8 @@ namespace hooks::audio { enum class Backend { Asio, WaveOut, - None, + Pipewire, + None }; extern bool ENABLED; @@ -33,6 +34,8 @@ namespace hooks::audio { return Backend::Asio; } else if (_stricmp(value, "waveout") == 0) { return Backend::WaveOut; + } else if (_stricmp(value, "pipewire") == 0) { + return Backend::Pipewire; } else if (_stricmp(value, "none") == 0) { return Backend::None; } diff --git a/hooks/audio/backends/wasapi/audio_client.cpp b/hooks/audio/backends/wasapi/audio_client.cpp index dfa0204..6aa0d8d 100644 --- a/hooks/audio/backends/wasapi/audio_client.cpp +++ b/hooks/audio/backends/wasapi/audio_client.cpp @@ -9,6 +9,7 @@ #include "hooks/audio/backends/wasapi/util.h" #include "hooks/audio/implementations/asio.h" #include "hooks/audio/implementations/wave_out.h" +#include "hooks/audio/implementations/pipewire.h" #include "hooks/audio/implementations/none.h" //#include "util/co_task_mem_ptr.h" @@ -161,6 +162,9 @@ IAudioClient *wrap_audio_client(IAudioClient *audio_client) { case hooks::audio::Backend::WaveOut: backend = new WaveOutBackend(); break; + case hooks::audio::Backend::Pipewire: + backend = new PipewireBackend(); + break; case hooks::audio::Backend::None: backend = new NoneBackend(); break; diff --git a/hooks/audio/implementations/pipewire.cpp b/hooks/audio/implementations/pipewire.cpp new file mode 100644 index 0000000..ac76e29 --- /dev/null +++ b/hooks/audio/implementations/pipewire.cpp @@ -0,0 +1,273 @@ +#include +#include "pipewire.h" +#include "hooks/audio/audio.h" +#include "hooks/audio/backends/wasapi/audio_client.h" +#include "util/libutils.h" +#include "launcher/launcher.h" +#include "hooks/audio/util.h" +#include "hooks/audio/backends/wasapi/util.h" + + +/* +... ShareMode : AUDCLNT_SHAREMODE_EXCLUSIVE <- backend to reimplement, THIS is the audio engine, GAME is client https://learn.microsoft.com/en-us/windows/win32/coreaudio/audclnt-streamflags-xxx-constants +... StreamFlags : AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST <- first is the whole reason for relay_handle_ requirement, second flag not tested +... hnsBufferDuration : 10000 <- wasapi people inventing new time units, 1ms (since 1unit==100ns, 10000*0.0001ms) +... hnsPeriodicity : 10000 <- same as above (1ms) +... nChannels : 2 <- channel_count +... nSamplesPerSec : 44100 <- bitrate +... nAvgBytesPerSec : 176400 <- raw buffer size per second (bitrate * stride)(bytes) +... nBlockAlign : 4 <- stride (bytes) +... wBitsPerSample : 16 <- sample size (bits) +... wValidBitsPerSample : 16 <- same as above +... dwChannelMask : SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT <- position config + _INFO: Code pipeline + INIT: on_is_format_supported()?->on_initialize()->on_set_event_handle()-:(LOOPx1):->on_start() + LOOP: if relay_handle_: on_get_buffer_size()->on_get_buffer()->..->on_release_buffer() + DEINIT: on_stop() + + _REV: POSSIBLE ALTERNATIVES: + Check if the stream is driving. The stream needs to have the + * PW_STREAM_FLAG_DRIVER set. When the stream is driving, + * pw_stream_trigger_process() needs to be called when data is + * available (output) or needed (input). Since 0.3.34 + bool pw_stream_is_driving(struct pw_stream *stream); + * */ + +/* Imports/Exports (refer to bmsound-wine.dll.spec) */ +typedef void (*BmswConfigInit_t)(const char *); +typedef void (*BmswExperimentalForceProfile_t)(const char *); +typedef int(*BmswClientFormatIsSupported_t)(DWORD, DWORD, DWORD, void *); +typedef int(*BmswClientFormatPeriodFPC_t)(void *); +typedef REFERENCE_TIME(*BmswClientFormatPeriodWRT_t)(void *); +typedef void *(*BmswClientCreate_t)(const char *, void *, void *); +typedef int(*BmswClientStart_t)(void *); +typedef int(*BmswClientStop_t)(void *); +typedef int(*BmswClientDestroy_t)(void *); +typedef unsigned char *(*BmswClientGetBuffer_t)(void *, uint32_t); +typedef int(*BmswClientReleaseBuffer_t)(void *, uint32_t); +typedef void (*BmswClientUpdateCallback_t)(void *, void *, void *); +static BmswConfigInit_t BmswConfigInit; +[[maybe_unused]] static BmswExperimentalForceProfile_t BmswExperimentalForceProfile; +static BmswClientFormatIsSupported_t BmswClientFormatIsSupported; +static BmswClientFormatPeriodFPC_t BmswClientFormatPeriodFPC; +static BmswClientFormatPeriodWRT_t BmswClientFormatPeriodWRT; +static BmswClientCreate_t BmswClientCreate; +static BmswClientStart_t BmswClientStart; +static BmswClientStop_t BmswClientStop; +static BmswClientDestroy_t BmswClientDestroy; +static BmswClientGetBuffer_t BmswClientGetBuffer; +static BmswClientReleaseBuffer_t BmswClientReleaseBuffer; +[[maybe_unused]] static BmswClientUpdateCallback_t BmswClientUpdateCallback; +static HMODULE bmsw_ = nullptr; + +/* Audio init (unless specified otherwise, run once at start) */ +// Reports to game whether each requested audio format is available for device (first success return will be used) +HRESULT PipewireBackend::on_is_format_supported(AUDCLNT_SHAREMODE *ShareMode, const WAVEFORMATEX *pFormat, WAVEFORMATEX **ppClosestMatch) noexcept +{ + // Format reporting and filtering + log_info("audio::pipewire", "{}", __FUNCTION__); + log_misc("audio::pipewire", "Checking backend support for {} channels, {} Hz, {}-bit", + pFormat->nChannels, + pFormat->nSamplesPerSec, + pFormat->wBitsPerSample); + + // IIDX? will always request format that was last checked through this function + if (*ShareMode != AUDCLNT_SHAREMODE_EXCLUSIVE) return AUDCLNT_E_UNSUPPORTED_FORMAT; + + // Request format support from real backend (only accepts 44.1 kHz, stereo, 16-bits per channel for now) + return BmswClientFormatIsSupported(pFormat->nSamplesPerSec, pFormat->nChannels, pFormat->wBitsPerSample, nullptr) == 0 ? S_OK : AUDCLNT_E_UNSUPPORTED_FORMAT; +} +// Populate hnsPeriodicity, _INFO: runs before on_initialize, requires configured client stream data +HRESULT PipewireBackend::on_get_device_period(REFERENCE_TIME *default_device_period, REFERENCE_TIME *minimum_device_period) +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + *default_device_period = wrt_; + *minimum_device_period = wrt_; + + return S_OK; +} +// This expects to be run once on_is_format_supported() succeeds, initializes backend based on passed arguments (and updates them if needed) +HRESULT PipewireBackend::on_initialize(AUDCLNT_SHAREMODE *ShareMode, DWORD *StreamFlags, REFERENCE_TIME *hnsBufferDuration, REFERENCE_TIME *hnsPeriodicity, const WAVEFORMATEX *pFormat, LPCGUID AudioSessionGuid) noexcept +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + + // Initialize pipewire client (without starting the thread) + client_ = BmswClientCreate(GAME_INSTANCE->title(), nullptr, nullptr);//(void *)callback_notify,this + + if (!client_) + log_fatal("audio::pipewire", "Client could not be initialized"); + log_info("audio::pipewire", "Client initialized: '{}'", fmt::ptr(client_)); + + // Adjust WASAPI configuration visible to game (passed arguments are populated and should match that of last on_is_format_supported call) + *hnsBufferDuration = wrt_; + *hnsPeriodicity = wrt_; + + //_TODO: Init info + log_info("audio::asio", "Device Info:"); + log_info("audio::pipewire", "... hnsBufferDuration : {}", *hnsBufferDuration); + log_info("audio::pipewire", "... hnsPeriodicity : {}", *hnsPeriodicity); + + return S_OK; +} +// This takes ownership over shared event handle exclusive to AUDCLNT_STREAMFLAGS_EVENTCALLBACK _INFO: first loop iteration runs directly after this, before on_start() call +HRESULT PipewireBackend::on_set_event_handle(HANDLE *event_handle) +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + this->relay_handle_ = *event_handle; // take over WASAPI's owned handle pre-initialized by client + //BmswClientUpdateCallback(client_, (void *) 0, this->relay_handle_); + *event_handle = CreateEvent(nullptr, true, false, nullptr); // replace WASAPI's handle with always off handle + + return S_OK; + + ULONG ntbuf_size = sizeof(OBJECT_NAME_INFORMATION) + 1024; + char ntbuf[ntbuf_size]; + OBJECT_NAME_INFORMATION *ntinfo = (OBJECT_NAME_INFORMATION *) ntbuf; + NTSTATUS status = NtQueryObject(*event_handle, ObjectNameInformation, ntinfo, ntbuf_size, &ntbuf_size); + if (NT_SUCCESS(status)) + { + // possible to rename anonymous handle to access by name + } +} +HRESULT PipewireBackend::on_start() noexcept +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + BmswClientStart(client_); + return S_OK; +} +PipewireBackend::PipewireBackend() : relay_handle_(nullptr), format_(hooks::audio::FORMAT), client_(nullptr) +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + + // Initialize bmsound-wine.dll once + if (!bmsw_ && (bmsw_ = libutils::try_library(MODULE_PATH / "bmsound-wine.dll"))) + { + BmswConfigInit = (BmswConfigInit_t) GetProcAddress(bmsw_, "BmswConfigInit"); + BmswExperimentalForceProfile = (BmswExperimentalForceProfile_t) GetProcAddress(bmsw_, "BmswExperimentalForceProfile"); + BmswClientFormatIsSupported = (BmswClientFormatIsSupported_t) GetProcAddress(bmsw_, "BmswClientFormatIsSupported"); + BmswClientFormatPeriodWRT = (BmswClientFormatPeriodWRT_t) GetProcAddress(bmsw_, "BmswClientFormatPeriodWRT"); + BmswClientFormatPeriodFPC = (BmswClientFormatPeriodFPC_t) GetProcAddress(bmsw_, "BmswClientFormatPeriodFPC"); + BmswClientCreate = (BmswClientCreate_t) GetProcAddress(bmsw_, "BmswClientCreate"); + BmswClientStart = (BmswClientStart_t) GetProcAddress(bmsw_, "BmswClientStart"); + BmswClientStop = (BmswClientStop_t) GetProcAddress(bmsw_, "BmswClientStop"); + BmswClientDestroy = (BmswClientDestroy_t) GetProcAddress(bmsw_, "BmswClientDestroy"); + BmswClientGetBuffer = (BmswClientGetBuffer_t) GetProcAddress(bmsw_, "BmswClientGetBuffer"); + BmswClientReleaseBuffer = (BmswClientReleaseBuffer_t) GetProcAddress(bmsw_, "BmswClientReleaseBuffer"); + BmswClientUpdateCallback = (BmswClientUpdateCallback_t) GetProcAddress(bmsw_, "BmswClientUpdateCallback"); + + // Load config + BmswConfigInit("prop/linux.json"); + //BmswExperimentalForceProfile("notif_spice"); + } + if (bmsw_) + { + // Sync config + wrt_ = BmswClientFormatPeriodWRT(nullptr); //_INFO: wrt affects reported latency (1:100ns) + fpc_ = BmswClientFormatPeriodFPC(nullptr); + return; + } + log_fatal("audio::pipewire", "Library not found: '{}'", (MODULE_PATH / "bmsound-wine.dll").string()); +} + +/* Audio callback loop (reacts to state of relay_handle_, most likely separate thread */ +// _REV: Synchronizing client and backend with nanotime may be necessary (bmsound-pw endpoint dependant) +inline static void callback_notify(void *self) +{ + //log_info("audio::pipewire", "{}", __FUNCTION__); + auto *self_ = (PipewireBackend *) self; + //std::this_thread::sleep_for(std::chrono::nanoseconds(10 * 1000 * 1000 - 227)); + if (!SetEvent(self_->relay_handle_)) // has to be called for game-side audio loop to continue + { + DWORD last_error = GetLastError(); + + log_warning("audio::asio", "AsioBackend::buffer_switch: SetEvent failed: {} ({})", + last_error, + std::system_category().message(last_error)); + } +} +// Amount in frames of data we may handle at once (which should always end up being what gets send by client, unless overrun happens) +HRESULT PipewireBackend::on_get_buffer_size(uint32_t *buffer_frames) noexcept +{ + static int iterc = -1; + if (iterc == -1) + { + log_info("audio::pipewire", "{}, frames: {} (INITIAL HIT)", __FUNCTION__, fpc_); + iterc = 0; + } + + *buffer_frames = fpc_; + + return S_OK; +} +// Wants a raw stream buffer to be assigned into *ppData, this stream will have x amount of sound frames stored into it by a client and assumes exclusive access until next on_release_buffer +HRESULT PipewireBackend::on_get_buffer(uint32_t num_frames_requested, BYTE **ppData) +{ + static int iterc = -1; + if (iterc == -1) + { + log_info("audio::pipewire", "{}, frames: {} (INITIAL HIT)", __FUNCTION__, num_frames_requested); + } + iterc++; + if (iterc > 999999) + { + log_info("audio::pipewire", "on_get_buffer, frames: {} (HIT {})", num_frames_requested, iterc); + iterc = 0; + } + + *ppData = BmswClientGetBuffer(client_, num_frames_requested); + + return S_OK; +} +// This releases access to buffer from last on_get_buffer and implies x amount of frames being valid data to be streamed +HRESULT PipewireBackend::on_release_buffer(uint32_t num_frames_written, DWORD dwFlags) +{ + static int iterc = -1; + if (iterc == -1) + { + log_info("audio::pipewire", "{}, frames: {} (INITIAL HIT)", __FUNCTION__, num_frames_written); + iterc = 0; + } + + BmswClientReleaseBuffer(client_, num_frames_written); + callback_notify(this); + + return S_OK; +} + +/* Audio deinit (unless specified otherwise, run once at termination) */ +HRESULT PipewireBackend::on_stop() noexcept +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + BmswClientStop(client_); + return S_OK; +} +PipewireBackend::~PipewireBackend() +{ + log_info("audio::pipewire", "~PipewireBackend"); + if (client_) BmswClientDestroy(client_); +} + +/* Unsorted (unknown callers, should be considered as unimplemented/untested) *///_BUG: does this need implementation? +const WAVEFORMATEXTENSIBLE &PipewireBackend::format() const noexcept +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + return format_; +} +HRESULT PipewireBackend::on_get_stream_latency(REFERENCE_TIME *latency) noexcept +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + *latency = BmswClientFormatPeriodWRT(client_); + + return S_OK; +} +HRESULT PipewireBackend::on_get_current_padding(std::optional &padding_frames) noexcept +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + padding_frames = 0; + + return S_OK; +} +HRESULT PipewireBackend::on_get_mix_format(WAVEFORMATEX **pp_device_format) noexcept +{ + log_info("audio::pipewire", "{}", __FUNCTION__); + return E_NOTIMPL; +} diff --git a/hooks/audio/implementations/pipewire.h b/hooks/audio/implementations/pipewire.h new file mode 100644 index 0000000..f777dc1 --- /dev/null +++ b/hooks/audio/implementations/pipewire.h @@ -0,0 +1,35 @@ +#pragma once + +#include "backend.h" +#include + + +struct PipewireBackend final : AudioBackend +{ +public: + HANDLE relay_handle_; + + explicit PipewireBackend(); + ~PipewireBackend() final; + [[nodiscard]] const WAVEFORMATEXTENSIBLE &format() const noexcept override; + HRESULT on_initialize(AUDCLNT_SHAREMODE *ShareMode, DWORD *StreamFlags, REFERENCE_TIME *hnsBufferDuration, REFERENCE_TIME *hnsPeriodicity, const WAVEFORMATEX *pFormat, LPCGUID AudioSessionGuid) noexcept override; + HRESULT on_get_buffer_size(uint32_t *buffer_frames) noexcept override; + HRESULT on_get_stream_latency(REFERENCE_TIME *latency) noexcept override; + HRESULT on_get_current_padding(std::optional &padding_frames) noexcept override; + HRESULT on_is_format_supported(AUDCLNT_SHAREMODE *ShareMode, const WAVEFORMATEX *pFormat, WAVEFORMATEX **ppClosestMatch) noexcept override; + HRESULT on_get_mix_format(WAVEFORMATEX **pp_device_format) noexcept override; + HRESULT on_get_device_period(REFERENCE_TIME *default_device_period, REFERENCE_TIME *minimum_device_period) override; + HRESULT on_start() noexcept override; + HRESULT on_stop() noexcept override; + HRESULT on_set_event_handle(HANDLE *event_handle) override; + HRESULT on_get_buffer(uint32_t num_frames_requested, BYTE **ppData) override; + HRESULT on_release_buffer(uint32_t num_frames_written, DWORD dwFlags) override; + +private: + int fpc_; + REFERENCE_TIME wrt_; + const WAVEFORMATEXTENSIBLE &format_; + void *client_; + +}; + diff --git a/launcher/options.cpp b/launcher/options.cpp index 4fe96f0..c983575 100644 --- a/launcher/options.cpp +++ b/launcher/options.cpp @@ -1341,7 +1341,7 @@ static const std::vector OPTION_DEFINITIONS = { " Does nothing for games that do not output to exclusive WASAPI", .type = OptionType::Enum, .category = "Audio", - .elements = {{"asio", "ASIO"}, {"waveout", "waveOut"},{"none", "None"}}, + .elements = {{"asio", "ASIO"}, {"waveout", "waveOut"},{"pipewire", "Pipewire (Linux)"},{"none", "None"}}, }, { .title = "Spice Audio Hook ASIO Driver ID",