summaryrefslogtreecommitdiffstats
path: root/src/audio_core/sink
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/audio_core/sink.h30
-rw-r--r--src/audio_core/sink/cubeb_sink.cpp651
-rw-r--r--src/audio_core/sink/cubeb_sink.h110
-rw-r--r--src/audio_core/sink/null_sink.h52
-rw-r--r--src/audio_core/sink/sdl2_sink.cpp556
-rw-r--r--src/audio_core/sink/sdl2_sink.h101
-rw-r--r--src/audio_core/sink/sink.h106
-rw-r--r--src/audio_core/sink/sink_details.cpp (renamed from src/audio_core/sink_details.cpp)27
-rw-r--r--src/audio_core/sink/sink_details.h43
-rw-r--r--src/audio_core/sink/sink_stream.h224
-rw-r--r--src/audio_core/sink_context.cpp47
-rw-r--r--src/audio_core/sink_context.h95
-rw-r--r--src/audio_core/sink_details.h23
-rw-r--r--src/audio_core/sink_stream.h35
14 files changed, 1857 insertions, 243 deletions
diff --git a/src/audio_core/sink.h b/src/audio_core/sink.h
deleted file mode 100644
index 3c03554fa..000000000
--- a/src/audio_core/sink.h
+++ /dev/null
@@ -1,30 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-#include <string>
-
-#include "audio_core/sink_stream.h"
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-constexpr char auto_device_name[] = "auto";
-
-/**
- * This class is an interface for an audio sink. An audio sink accepts samples in stereo signed
- * PCM16 format to be output. Sinks *do not* handle resampling and expect the correct sample rate.
- * They are dumb outputs.
- */
-class Sink {
-public:
- virtual ~Sink() = default;
- virtual SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels,
- const std::string& name) = 0;
-};
-
-using SinkPtr = std::unique_ptr<Sink>;
-
-} // namespace AudioCore
diff --git a/src/audio_core/sink/cubeb_sink.cpp b/src/audio_core/sink/cubeb_sink.cpp
new file mode 100644
index 000000000..a4e28de6d
--- /dev/null
+++ b/src/audio_core/sink/cubeb_sink.cpp
@@ -0,0 +1,651 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+#include <atomic>
+#include <span>
+
+#include "audio_core/audio_core.h"
+#include "audio_core/audio_event.h"
+#include "audio_core/audio_manager.h"
+#include "audio_core/sink/cubeb_sink.h"
+#include "audio_core/sink/sink_stream.h"
+#include "common/assert.h"
+#include "common/fixed_point.h"
+#include "common/logging/log.h"
+#include "common/reader_writer_queue.h"
+#include "common/ring_buffer.h"
+#include "common/settings.h"
+#include "core/core.h"
+
+#ifdef _WIN32
+#include <objbase.h>
+#undef CreateEvent
+#endif
+
+namespace AudioCore::Sink {
+/**
+ * Cubeb sink stream, responsible for sinking samples to hardware.
+ */
+class CubebSinkStream final : public SinkStream {
+public:
+ /**
+ * Create a new sink stream.
+ *
+ * @param ctx_ - Cubeb context to create this stream with.
+ * @param device_channels_ - Number of channels supported by the hardware.
+ * @param system_channels_ - Number of channels the audio systems expect.
+ * @param output_device - Cubeb output device id.
+ * @param input_device - Cubeb input device id.
+ * @param name_ - Name of this stream.
+ * @param type_ - Type of this stream.
+ * @param system_ - Core system.
+ * @param event - Event used only for audio renderer, signalled on buffer consume.
+ */
+ CubebSinkStream(cubeb* ctx_, const u32 device_channels_, const u32 system_channels_,
+ cubeb_devid output_device, cubeb_devid input_device, const std::string& name_,
+ const StreamType type_, Core::System& system_)
+ : ctx{ctx_}, type{type_}, system{system_} {
+#ifdef _WIN32
+ CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+#endif
+ name = name_;
+ device_channels = device_channels_;
+ system_channels = system_channels_;
+
+ cubeb_stream_params params{};
+ params.rate = TargetSampleRate;
+ params.channels = device_channels;
+ params.format = CUBEB_SAMPLE_S16LE;
+ params.prefs = CUBEB_STREAM_PREF_NONE;
+ switch (params.channels) {
+ case 1:
+ params.layout = CUBEB_LAYOUT_MONO;
+ break;
+ case 2:
+ params.layout = CUBEB_LAYOUT_STEREO;
+ break;
+ case 6:
+ params.layout = CUBEB_LAYOUT_3F2_LFE;
+ break;
+ }
+
+ u32 minimum_latency{0};
+ const auto latency_error = cubeb_get_min_latency(ctx, &params, &minimum_latency);
+ if (latency_error != CUBEB_OK) {
+ LOG_CRITICAL(Audio_Sink, "Error getting minimum latency, error: {}", latency_error);
+ minimum_latency = 256U;
+ }
+
+ minimum_latency = std::max(minimum_latency, 256u);
+
+ playing_buffer.consumed = true;
+
+ LOG_DEBUG(Service_Audio,
+ "Opening cubeb stream {} type {} with: rate {} channels {} (system channels {}) "
+ "latency {}",
+ name, type, params.rate, params.channels, system_channels, minimum_latency);
+
+ auto init_error{0};
+ if (type == StreamType::In) {
+ init_error = cubeb_stream_init(ctx, &stream_backend, name.c_str(), input_device,
+ &params, output_device, nullptr, minimum_latency,
+ &CubebSinkStream::DataCallback,
+ &CubebSinkStream::StateCallback, this);
+ } else {
+ init_error = cubeb_stream_init(ctx, &stream_backend, name.c_str(), input_device,
+ nullptr, output_device, &params, minimum_latency,
+ &CubebSinkStream::DataCallback,
+ &CubebSinkStream::StateCallback, this);
+ }
+
+ if (init_error != CUBEB_OK) {
+ LOG_CRITICAL(Audio_Sink, "Error initializing cubeb stream, error: {}", init_error);
+ return;
+ }
+ }
+
+ /**
+ * Destroy the sink stream.
+ */
+ ~CubebSinkStream() override {
+ LOG_DEBUG(Service_Audio, "Destructing cubeb stream {}", name);
+
+ if (!ctx) {
+ return;
+ }
+
+ Finalize();
+
+#ifdef _WIN32
+ CoUninitialize();
+#endif
+ }
+
+ /**
+ * Finalize the sink stream.
+ */
+ void Finalize() override {
+ Stop();
+ cubeb_stream_destroy(stream_backend);
+ }
+
+ /**
+ * Start the sink stream.
+ *
+ * @param resume - Set to true if this is resuming the stream a previously-active stream.
+ * Default false.
+ */
+ void Start(const bool resume = false) override {
+ if (!ctx) {
+ return;
+ }
+
+ if (resume && was_playing) {
+ if (cubeb_stream_start(stream_backend) != CUBEB_OK) {
+ LOG_CRITICAL(Audio_Sink, "Error starting cubeb stream");
+ }
+ paused = false;
+ } else if (!resume) {
+ if (cubeb_stream_start(stream_backend) != CUBEB_OK) {
+ LOG_CRITICAL(Audio_Sink, "Error starting cubeb stream");
+ }
+ paused = false;
+ }
+ }
+
+ /**
+ * Stop the sink stream.
+ */
+ void Stop() override {
+ if (!ctx) {
+ return;
+ }
+
+ if (cubeb_stream_stop(stream_backend) != CUBEB_OK) {
+ LOG_CRITICAL(Audio_Sink, "Error stopping cubeb stream");
+ }
+
+ was_playing.store(!paused);
+ paused = true;
+ }
+
+ /**
+ * Append a new buffer and its samples to a waiting queue to play.
+ *
+ * @param buffer - Audio buffer information to be queued.
+ * @param samples - The s16 samples to be queue for playback.
+ */
+ void AppendBuffer(::AudioCore::Sink::SinkBuffer& buffer, std::vector<s16>& samples) override {
+ if (type == StreamType::In) {
+ queue.enqueue(buffer);
+ queued_buffers++;
+ } else {
+ constexpr s32 min{std::numeric_limits<s16>::min()};
+ constexpr s32 max{std::numeric_limits<s16>::max()};
+
+ auto yuzu_volume{Settings::Volume()};
+ auto volume{system_volume * device_volume * yuzu_volume};
+
+ if (system_channels == 6 && device_channels == 2) {
+ // We're given 6 channels, but our device only outputs 2, so downmix.
+ constexpr std::array<f32, 4> down_mix_coeff{1.0f, 0.707f, 0.251f, 0.707f};
+
+ for (u32 read_index = 0, write_index = 0; read_index < samples.size();
+ read_index += system_channels, write_index += device_channels) {
+ const auto left_sample{
+ ((Common::FixedPoint<49, 15>(
+ samples[read_index + static_cast<u32>(Channels::FrontLeft)]) *
+ down_mix_coeff[0] +
+ samples[read_index + static_cast<u32>(Channels::Center)] *
+ down_mix_coeff[1] +
+ samples[read_index + static_cast<u32>(Channels::LFE)] *
+ down_mix_coeff[2] +
+ samples[read_index + static_cast<u32>(Channels::BackLeft)] *
+ down_mix_coeff[3]) *
+ volume)
+ .to_int()};
+
+ const auto right_sample{
+ ((Common::FixedPoint<49, 15>(
+ samples[read_index + static_cast<u32>(Channels::FrontRight)]) *
+ down_mix_coeff[0] +
+ samples[read_index + static_cast<u32>(Channels::Center)] *
+ down_mix_coeff[1] +
+ samples[read_index + static_cast<u32>(Channels::LFE)] *
+ down_mix_coeff[2] +
+ samples[read_index + static_cast<u32>(Channels::BackRight)] *
+ down_mix_coeff[3]) *
+ volume)
+ .to_int()};
+
+ samples[write_index + static_cast<u32>(Channels::FrontLeft)] =
+ static_cast<s16>(std::clamp(left_sample, min, max));
+ samples[write_index + static_cast<u32>(Channels::FrontRight)] =
+ static_cast<s16>(std::clamp(right_sample, min, max));
+ }
+
+ samples.resize(samples.size() / system_channels * device_channels);
+
+ } else if (system_channels == 2 && device_channels == 6) {
+ // We need moar samples! Not all games will provide 6 channel audio.
+ // TODO: Implement some upmixing here. Currently just passthrough, with other
+ // channels left as silence.
+ std::vector<s16> new_samples(samples.size() / system_channels * device_channels, 0);
+
+ for (u32 read_index = 0, write_index = 0; read_index < samples.size();
+ read_index += system_channels, write_index += device_channels) {
+ const auto left_sample{static_cast<s16>(std::clamp(
+ static_cast<s32>(
+ static_cast<f32>(
+ samples[read_index + static_cast<u32>(Channels::FrontLeft)]) *
+ volume),
+ min, max))};
+
+ new_samples[write_index + static_cast<u32>(Channels::FrontLeft)] = left_sample;
+
+ const auto right_sample{static_cast<s16>(std::clamp(
+ static_cast<s32>(
+ static_cast<f32>(
+ samples[read_index + static_cast<u32>(Channels::FrontRight)]) *
+ volume),
+ min, max))};
+
+ new_samples[write_index + static_cast<u32>(Channels::FrontRight)] =
+ right_sample;
+ }
+ samples = std::move(new_samples);
+
+ } else if (volume != 1.0f) {
+ for (u32 i = 0; i < samples.size(); i++) {
+ samples[i] = static_cast<s16>(std::clamp(
+ static_cast<s32>(static_cast<f32>(samples[i]) * volume), min, max));
+ }
+ }
+
+ samples_buffer.Push(samples);
+ queue.enqueue(buffer);
+ queued_buffers++;
+ }
+ }
+
+ /**
+ * Release a buffer. Audio In only, will fill a buffer with recorded samples.
+ *
+ * @param num_samples - Maximum number of samples to receive.
+ * @return Vector of recorded samples. May have fewer than num_samples.
+ */
+ std::vector<s16> ReleaseBuffer(const u64 num_samples) override {
+ static constexpr s32 min = std::numeric_limits<s16>::min();
+ static constexpr s32 max = std::numeric_limits<s16>::max();
+
+ auto samples{samples_buffer.Pop(num_samples)};
+
+ // TODO: Up-mix to 6 channels if the game expects it.
+ // For audio input this is unlikely to ever be the case though.
+
+ // Incoming mic volume seems to always be very quiet, so multiply by an additional 8 here.
+ // TODO: Play with this and find something that works better.
+ auto volume{system_volume * device_volume * 8};
+ for (u32 i = 0; i < samples.size(); i++) {
+ samples[i] = static_cast<s16>(
+ std::clamp(static_cast<s32>(static_cast<f32>(samples[i]) * volume), min, max));
+ }
+
+ if (samples.size() < num_samples) {
+ samples.resize(num_samples, 0);
+ }
+ return samples;
+ }
+
+ /**
+ * Check if a certain buffer has been consumed (fully played).
+ *
+ * @param tag - Unique tag of a buffer to check for.
+ * @return True if the buffer has been played, otherwise false.
+ */
+ bool IsBufferConsumed(const u64 tag) override {
+ if (released_buffer.tag == 0) {
+ if (!released_buffers.try_dequeue(released_buffer)) {
+ return false;
+ }
+ }
+
+ if (released_buffer.tag == tag) {
+ released_buffer.tag = 0;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Empty out the buffer queue.
+ */
+ void ClearQueue() override {
+ samples_buffer.Pop();
+ while (queue.pop()) {
+ }
+ while (released_buffers.pop()) {
+ }
+ queued_buffers = 0;
+ released_buffer = {};
+ playing_buffer = {};
+ playing_buffer.consumed = true;
+ }
+
+private:
+ /**
+ * Signal events back to the audio system that a buffer was played/can be filled.
+ *
+ * @param buffer - Consumed audio buffer to be released.
+ */
+ void SignalEvent(const ::AudioCore::Sink::SinkBuffer& buffer) {
+ auto& manager{system.AudioCore().GetAudioManager()};
+ switch (type) {
+ case StreamType::Out:
+ released_buffers.enqueue(buffer);
+ manager.SetEvent(Event::Type::AudioOutManager, true);
+ break;
+ case StreamType::In:
+ released_buffers.enqueue(buffer);
+ manager.SetEvent(Event::Type::AudioInManager, true);
+ break;
+ case StreamType::Render:
+ break;
+ }
+ }
+
+ /**
+ * Main callback from Cubeb. Either expects samples from us (audio render/audio out), or will
+ * provide samples to be copied (audio in).
+ *
+ * @param stream - Cubeb-specific data about the stream.
+ * @param user_data - Custom data pointer passed along, points to a CubebSinkStream.
+ * @param in_buff - Input buffer to be used if the stream is an input type.
+ * @param out_buff - Output buffer to be used if the stream is an output type.
+ * @param num_frames_ - Number of frames of audio in the buffers. Note: Not number of samples.
+ */
+ static long DataCallback([[maybe_unused]] cubeb_stream* stream, void* user_data,
+ [[maybe_unused]] const void* in_buff, void* out_buff,
+ long num_frames_) {
+ auto* impl = static_cast<CubebSinkStream*>(user_data);
+ if (!impl) {
+ return -1;
+ }
+
+ const std::size_t num_channels = impl->GetDeviceChannels();
+ const std::size_t frame_size = num_channels;
+ const std::size_t frame_size_bytes = frame_size * sizeof(s16);
+ const std::size_t num_frames{static_cast<size_t>(num_frames_)};
+ size_t frames_written{0};
+ [[maybe_unused]] bool underrun{false};
+
+ if (impl->type == StreamType::In) {
+ // INPUT
+ std::span<const s16> input_buffer{reinterpret_cast<const s16*>(in_buff),
+ num_frames * frame_size};
+
+ while (frames_written < num_frames) {
+ auto& playing_buffer{impl->playing_buffer};
+
+ // If the playing buffer has been consumed or has no frames, we need a new one
+ if (playing_buffer.consumed || playing_buffer.frames == 0) {
+ if (!impl->queue.try_dequeue(impl->playing_buffer)) {
+ // If no buffer was available we've underrun, just push the samples and
+ // continue.
+ underrun = true;
+ impl->samples_buffer.Push(&input_buffer[frames_written * frame_size],
+ (num_frames - frames_written) * frame_size);
+ frames_written = num_frames;
+ continue;
+ } else {
+ // Successfully got a new buffer, mark the old one as consumed and signal.
+ impl->queued_buffers--;
+ impl->SignalEvent(impl->playing_buffer);
+ }
+ }
+
+ // Get the minimum frames available between the currently playing buffer, and the
+ // amount we have left to fill
+ size_t frames_available{
+ std::min(playing_buffer.frames - playing_buffer.frames_played,
+ num_frames - frames_written)};
+
+ impl->samples_buffer.Push(&input_buffer[frames_written * frame_size],
+ frames_available * frame_size);
+
+ frames_written += frames_available;
+ playing_buffer.frames_played += frames_available;
+
+ // If that's all the frames in the current buffer, add its samples and mark it as
+ // consumed
+ if (playing_buffer.frames_played >= playing_buffer.frames) {
+ impl->AddPlayedSampleCount(playing_buffer.frames_played * num_channels);
+ impl->playing_buffer.consumed = true;
+ }
+ }
+
+ std::memcpy(&impl->last_frame[0], &input_buffer[(frames_written - 1) * frame_size],
+ frame_size_bytes);
+ } else {
+ // OUTPUT
+ std::span<s16> output_buffer{reinterpret_cast<s16*>(out_buff), num_frames * frame_size};
+
+ while (frames_written < num_frames) {
+ auto& playing_buffer{impl->playing_buffer};
+
+ // If the playing buffer has been consumed or has no frames, we need a new one
+ if (playing_buffer.consumed || playing_buffer.frames == 0) {
+ if (!impl->queue.try_dequeue(impl->playing_buffer)) {
+ // If no buffer was available we've underrun, fill the remaining buffer with
+ // the last written frame and continue.
+ underrun = true;
+ for (size_t i = frames_written; i < num_frames; i++) {
+ std::memcpy(&output_buffer[i * frame_size], &impl->last_frame[0],
+ frame_size_bytes);
+ }
+ frames_written = num_frames;
+ continue;
+ } else {
+ // Successfully got a new buffer, mark the old one as consumed and signal.
+ impl->queued_buffers--;
+ impl->SignalEvent(impl->playing_buffer);
+ }
+ }
+
+ // Get the minimum frames available between the currently playing buffer, and the
+ // amount we have left to fill
+ size_t frames_available{
+ std::min(playing_buffer.frames - playing_buffer.frames_played,
+ num_frames - frames_written)};
+
+ impl->samples_buffer.Pop(&output_buffer[frames_written * frame_size],
+ frames_available * frame_size);
+
+ frames_written += frames_available;
+ playing_buffer.frames_played += frames_available;
+
+ // If that's all the frames in the current buffer, add its samples and mark it as
+ // consumed
+ if (playing_buffer.frames_played >= playing_buffer.frames) {
+ impl->AddPlayedSampleCount(playing_buffer.frames_played * num_channels);
+ impl->playing_buffer.consumed = true;
+ }
+ }
+
+ std::memcpy(&impl->last_frame[0], &output_buffer[(frames_written - 1) * frame_size],
+ frame_size_bytes);
+ }
+
+ return num_frames_;
+ }
+
+ /**
+ * Cubeb callback for if a device state changes. Unused currently.
+ *
+ * @param stream - Cubeb-specific data about the stream.
+ * @param user_data - Custom data pointer passed along, points to a CubebSinkStream.
+ * @param state - New state of the device.
+ */
+ static void StateCallback([[maybe_unused]] cubeb_stream* stream,
+ [[maybe_unused]] void* user_data,
+ [[maybe_unused]] cubeb_state state) {}
+
+ /// Main Cubeb context
+ cubeb* ctx{};
+ /// Cubeb stream backend
+ cubeb_stream* stream_backend{};
+ /// Name of this stream
+ std::string name{};
+ /// Type of this stream
+ StreamType type;
+ /// Core system
+ Core::System& system;
+ /// Ring buffer of the samples waiting to be played or consumed
+ Common::RingBuffer<s16, 0x10000> samples_buffer;
+ /// Audio buffers queued and waiting to play
+ Common::ReaderWriterQueue<::AudioCore::Sink::SinkBuffer> queue;
+ /// The currently-playing audio buffer
+ ::AudioCore::Sink::SinkBuffer playing_buffer{};
+ /// Audio buffers which have been played and are in queue to be released by the audio system
+ Common::ReaderWriterQueue<::AudioCore::Sink::SinkBuffer> released_buffers{};
+ /// Currently released buffer waiting to be taken by the audio system
+ ::AudioCore::Sink::SinkBuffer released_buffer{};
+ /// The last played (or received) frame of audio, used when the callback underruns
+ std::array<s16, MaxChannels> last_frame{};
+};
+
+CubebSink::CubebSink(std::string_view target_device_name) {
+ // Cubeb requires COM to be initialized on the thread calling cubeb_init on Windows
+#ifdef _WIN32
+ com_init_result = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+#endif
+
+ if (cubeb_init(&ctx, "yuzu", nullptr) != CUBEB_OK) {
+ LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
+ return;
+ }
+
+ if (target_device_name != auto_device_name && !target_device_name.empty()) {
+ cubeb_device_collection collection;
+ if (cubeb_enumerate_devices(ctx, CUBEB_DEVICE_TYPE_OUTPUT, &collection) != CUBEB_OK) {
+ LOG_WARNING(Audio_Sink, "Audio output device enumeration not supported");
+ } else {
+ const auto collection_end{collection.device + collection.count};
+ const auto device{
+ std::find_if(collection.device, collection_end, [&](const cubeb_device_info& info) {
+ return info.friendly_name != nullptr &&
+ target_device_name == std::string(info.friendly_name);
+ })};
+ if (device != collection_end) {
+ output_device = device->devid;
+ }
+ cubeb_device_collection_destroy(ctx, &collection);
+ }
+ }
+
+ cubeb_get_max_channel_count(ctx, &device_channels);
+ device_channels = device_channels >= 6U ? 6U : 2U;
+}
+
+CubebSink::~CubebSink() {
+ if (!ctx) {
+ return;
+ }
+
+ for (auto& sink_stream : sink_streams) {
+ sink_stream.reset();
+ }
+
+ cubeb_destroy(ctx);
+
+#ifdef _WIN32
+ if (SUCCEEDED(com_init_result)) {
+ CoUninitialize();
+ }
+#endif
+}
+
+SinkStream* CubebSink::AcquireSinkStream(Core::System& system, const u32 system_channels,
+ const std::string& name, const StreamType type) {
+ SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<CubebSinkStream>(
+ ctx, device_channels, system_channels, output_device, input_device, name, type, system));
+
+ return stream.get();
+}
+
+void CubebSink::CloseStream(const SinkStream* stream) {
+ for (size_t i = 0; i < sink_streams.size(); i++) {
+ if (sink_streams[i].get() == stream) {
+ sink_streams[i].reset();
+ sink_streams.erase(sink_streams.begin() + i);
+ break;
+ }
+ }
+}
+
+void CubebSink::CloseStreams() {
+ sink_streams.clear();
+}
+
+void CubebSink::PauseStreams() {
+ for (auto& stream : sink_streams) {
+ stream->Stop();
+ }
+}
+
+void CubebSink::UnpauseStreams() {
+ for (auto& stream : sink_streams) {
+ stream->Start(true);
+ }
+}
+
+f32 CubebSink::GetDeviceVolume() const {
+ if (sink_streams.empty()) {
+ return 1.0f;
+ }
+
+ return sink_streams[0]->GetDeviceVolume();
+}
+
+void CubebSink::SetDeviceVolume(const f32 volume) {
+ for (auto& stream : sink_streams) {
+ stream->SetDeviceVolume(volume);
+ }
+}
+
+void CubebSink::SetSystemVolume(const f32 volume) {
+ for (auto& stream : sink_streams) {
+ stream->SetSystemVolume(volume);
+ }
+}
+
+std::vector<std::string> ListCubebSinkDevices(const bool capture) {
+ std::vector<std::string> device_list;
+ cubeb* ctx;
+
+ if (cubeb_init(&ctx, "yuzu Device Enumerator", nullptr) != CUBEB_OK) {
+ LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
+ return {};
+ }
+
+ auto type{capture ? CUBEB_DEVICE_TYPE_INPUT : CUBEB_DEVICE_TYPE_OUTPUT};
+ cubeb_device_collection collection;
+ if (cubeb_enumerate_devices(ctx, type, &collection) != CUBEB_OK) {
+ LOG_WARNING(Audio_Sink, "Audio output device enumeration not supported");
+ } else {
+ for (std::size_t i = 0; i < collection.count; i++) {
+ const cubeb_device_info& device = collection.device[i];
+ if (device.friendly_name && device.friendly_name[0] != '\0' &&
+ device.state == CUBEB_DEVICE_STATE_ENABLED) {
+ device_list.emplace_back(device.friendly_name);
+ }
+ }
+ cubeb_device_collection_destroy(ctx, &collection);
+ }
+
+ cubeb_destroy(ctx);
+ return device_list;
+}
+
+} // namespace AudioCore::Sink
diff --git a/src/audio_core/sink/cubeb_sink.h b/src/audio_core/sink/cubeb_sink.h
new file mode 100644
index 000000000..f0f43dfa1
--- /dev/null
+++ b/src/audio_core/sink/cubeb_sink.h
@@ -0,0 +1,110 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <cubeb/cubeb.h>
+
+#include "audio_core/sink/sink.h"
+
+namespace Core {
+class System;
+}
+
+namespace AudioCore::Sink {
+class SinkStream;
+
+/**
+ * Cubeb backend sink, holds multiple output streams and is responsible for sinking samples to
+ * hardware. Used by Audio Render, Audio In and Audio Out.
+ */
+class CubebSink final : public Sink {
+public:
+ explicit CubebSink(std::string_view device_id);
+ ~CubebSink() override;
+
+ /**
+ * Create a new sink stream.
+ *
+ * @param system - Core system.
+ * @param system_channels - Number of channels the audio system expects.
+ * May differ from the device's channel count.
+ * @param name - Name of this stream.
+ * @param type - Type of this stream, render/in/out.
+ * @param event - Audio render only, a signal used to prevent the renderer running too
+ * fast.
+ * @return A pointer to the created SinkStream
+ */
+ SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,
+ const std::string& name, StreamType type) override;
+
+ /**
+ * Close a given stream.
+ *
+ * @param stream - The stream to close.
+ */
+ void CloseStream(const SinkStream* stream) override;
+
+ /**
+ * Close all streams.
+ */
+ void CloseStreams() override;
+
+ /**
+ * Pause all streams.
+ */
+ void PauseStreams() override;
+
+ /**
+ * Unpause all streams.
+ */
+ void UnpauseStreams() override;
+
+ /**
+ * Get the device volume. Set from calls to the IAudioDevice service.
+ *
+ * @return Volume of the device.
+ */
+ f32 GetDeviceVolume() const override;
+
+ /**
+ * Set the device volume. Set from calls to the IAudioDevice service.
+ *
+ * @param volume - New volume of the device.
+ */
+ void SetDeviceVolume(f32 volume) override;
+
+ /**
+ * Set the system volume. Comes from the audio system using this stream.
+ *
+ * @param volume - New volume of the system.
+ */
+ void SetSystemVolume(f32 volume) override;
+
+private:
+ /// Backend Cubeb context
+ cubeb* ctx{};
+ /// Cubeb id of the actual hardware output device
+ cubeb_devid output_device{};
+ /// Cubeb id of the actual hardware input device
+ cubeb_devid input_device{};
+ /// Vector of streams managed by this sink
+ std::vector<SinkStreamPtr> sink_streams{};
+
+#ifdef _WIN32
+ /// Cubeb required COM to be initialized multi-threaded on Windows
+ u32 com_init_result = 0;
+#endif
+};
+
+/**
+ * Get a list of conencted devices from Cubeb.
+ *
+ * @param capture - Return input (capture) devices if true, otherwise output devices.
+ */
+std::vector<std::string> ListCubebSinkDevices(bool capture);
+
+} // namespace AudioCore::Sink
diff --git a/src/audio_core/sink/null_sink.h b/src/audio_core/sink/null_sink.h
new file mode 100644
index 000000000..47a342171
--- /dev/null
+++ b/src/audio_core/sink/null_sink.h
@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "audio_core/sink/sink.h"
+#include "audio_core/sink/sink_stream.h"
+
+namespace AudioCore::Sink {
+/**
+ * A no-op sink for when no audio out is wanted.
+ */
+class NullSink final : public Sink {
+public:
+ explicit NullSink(std::string_view) {}
+ ~NullSink() override = default;
+
+ SinkStream* AcquireSinkStream([[maybe_unused]] Core::System& system,
+ [[maybe_unused]] u32 system_channels,
+ [[maybe_unused]] const std::string& name,
+ [[maybe_unused]] StreamType type) override {
+ return &null_sink_stream;
+ }
+
+ void CloseStream([[maybe_unused]] const SinkStream* stream) override {}
+ void CloseStreams() override {}
+ void PauseStreams() override {}
+ void UnpauseStreams() override {}
+ f32 GetDeviceVolume() const override {
+ return 1.0f;
+ }
+ void SetDeviceVolume(f32 volume) override {}
+ void SetSystemVolume(f32 volume) override {}
+
+private:
+ struct NullSinkStreamImpl final : SinkStream {
+ void Finalize() override {}
+ void Start(bool resume = false) override {}
+ void Stop() override {}
+ void AppendBuffer([[maybe_unused]] ::AudioCore::Sink::SinkBuffer& buffer,
+ [[maybe_unused]] std::vector<s16>& samples) override {}
+ std::vector<s16> ReleaseBuffer([[maybe_unused]] u64 num_samples) override {
+ return {};
+ }
+ bool IsBufferConsumed([[maybe_unused]] const u64 tag) {
+ return true;
+ }
+ void ClearQueue() override {}
+ } null_sink_stream;
+};
+
+} // namespace AudioCore::Sink
diff --git a/src/audio_core/sink/sdl2_sink.cpp b/src/audio_core/sink/sdl2_sink.cpp
new file mode 100644
index 000000000..d6c9ec90d
--- /dev/null
+++ b/src/audio_core/sink/sdl2_sink.cpp
@@ -0,0 +1,556 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <algorithm>
+#include <atomic>
+
+#include "audio_core/audio_core.h"
+#include "audio_core/audio_event.h"
+#include "audio_core/audio_manager.h"
+#include "audio_core/sink/sdl2_sink.h"
+#include "audio_core/sink/sink_stream.h"
+#include "common/assert.h"
+#include "common/fixed_point.h"
+#include "common/logging/log.h"
+#include "common/reader_writer_queue.h"
+#include "common/ring_buffer.h"
+#include "common/settings.h"
+#include "core/core.h"
+
+// Ignore -Wimplicit-fallthrough due to https://github.com/libsdl-org/SDL/issues/4307
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
+#endif
+#include <SDL.h>
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+namespace AudioCore::Sink {
+/**
+ * SDL sink stream, responsible for sinking samples to hardware.
+ */
+class SDLSinkStream final : public SinkStream {
+public:
+ /**
+ * Create a new sink stream.
+ *
+ * @param device_channels_ - Number of channels supported by the hardware.
+ * @param system_channels_ - Number of channels the audio systems expect.
+ * @param output_device - Name of the output device to use for this stream.
+ * @param input_device - Name of the input device to use for this stream.
+ * @param type_ - Type of this stream.
+ * @param system_ - Core system.
+ * @param event - Event used only for audio renderer, signalled on buffer consume.
+ */
+ SDLSinkStream(u32 device_channels_, const u32 system_channels_,
+ const std::string& output_device, const std::string& input_device,
+ const StreamType type_, Core::System& system_)
+ : type{type_}, system{system_} {
+ system_channels = system_channels_;
+ device_channels = device_channels_;
+
+ SDL_AudioSpec spec;
+ spec.freq = TargetSampleRate;
+ spec.channels = static_cast<u8>(device_channels);
+ spec.format = AUDIO_S16SYS;
+ if (type == StreamType::Render) {
+ spec.samples = TargetSampleCount;
+ } else {
+ spec.samples = 1024;
+ }
+ spec.callback = &SDLSinkStream::DataCallback;
+ spec.userdata = this;
+
+ playing_buffer.consumed = true;
+
+ std::string device_name{output_device};
+ bool capture{false};
+ if (type == StreamType::In) {
+ device_name = input_device;
+ capture = true;
+ }
+
+ SDL_AudioSpec obtained;
+ if (device_name.empty()) {
+ device = SDL_OpenAudioDevice(nullptr, capture, &spec, &obtained, false);
+ } else {
+ device = SDL_OpenAudioDevice(device_name.c_str(), capture, &spec, &obtained, false);
+ }
+
+ if (device == 0) {
+ LOG_CRITICAL(Audio_Sink, "Error opening SDL audio device: {}", SDL_GetError());
+ return;
+ }
+
+ LOG_DEBUG(Service_Audio,
+ "Opening sdl stream {} with: rate {} channels {} (system channels {}) "
+ " samples {}",
+ device, obtained.freq, obtained.channels, system_channels, obtained.samples);
+ }
+
+ /**
+ * Destroy the sink stream.
+ */
+ ~SDLSinkStream() override {
+ if (device == 0) {
+ return;
+ }
+
+ SDL_CloseAudioDevice(device);
+ }
+
+ /**
+ * Finalize the sink stream.
+ */
+ void Finalize() override {
+ if (device == 0) {
+ return;
+ }
+
+ SDL_CloseAudioDevice(device);
+ }
+
+ /**
+ * Start the sink stream.
+ *
+ * @param resume - Set to true if this is resuming the stream a previously-active stream.
+ * Default false.
+ */
+ void Start(const bool resume = false) override {
+ if (device == 0) {
+ return;
+ }
+
+ if (resume && was_playing) {
+ SDL_PauseAudioDevice(device, 0);
+ paused = false;
+ } else if (!resume) {
+ SDL_PauseAudioDevice(device, 0);
+ paused = false;
+ }
+ }
+
+ /**
+ * Stop the sink stream.
+ */
+ void Stop() {
+ if (device == 0) {
+ return;
+ }
+ SDL_PauseAudioDevice(device, 1);
+ paused = true;
+ }
+
+ /**
+ * Append a new buffer and its samples to a waiting queue to play.
+ *
+ * @param buffer - Audio buffer information to be queued.
+ * @param samples - The s16 samples to be queue for playback.
+ */
+ void AppendBuffer(::AudioCore::Sink::SinkBuffer& buffer, std::vector<s16>& samples) override {
+ if (type == StreamType::In) {
+ queue.enqueue(buffer);
+ queued_buffers++;
+ } else {
+ constexpr s32 min = std::numeric_limits<s16>::min();
+ constexpr s32 max = std::numeric_limits<s16>::max();
+
+ auto yuzu_volume{Settings::Volume()};
+ auto volume{system_volume * device_volume * yuzu_volume};
+
+ if (system_channels == 6 && device_channels == 2) {
+ // We're given 6 channels, but our device only outputs 2, so downmix.
+ constexpr std::array<f32, 4> down_mix_coeff{1.0f, 0.707f, 0.251f, 0.707f};
+
+ for (u32 read_index = 0, write_index = 0; read_index < samples.size();
+ read_index += system_channels, write_index += device_channels) {
+ const auto left_sample{
+ ((Common::FixedPoint<49, 15>(
+ samples[read_index + static_cast<u32>(Channels::FrontLeft)]) *
+ down_mix_coeff[0] +
+ samples[read_index + static_cast<u32>(Channels::Center)] *
+ down_mix_coeff[1] +
+ samples[read_index + static_cast<u32>(Channels::LFE)] *
+ down_mix_coeff[2] +
+ samples[read_index + static_cast<u32>(Channels::BackLeft)] *
+ down_mix_coeff[3]) *
+ volume)
+ .to_int()};
+
+ const auto right_sample{
+ ((Common::FixedPoint<49, 15>(
+ samples[read_index + static_cast<u32>(Channels::FrontRight)]) *
+ down_mix_coeff[0] +
+ samples[read_index + static_cast<u32>(Channels::Center)] *
+ down_mix_coeff[1] +
+ samples[read_index + static_cast<u32>(Channels::LFE)] *
+ down_mix_coeff[2] +
+ samples[read_index + static_cast<u32>(Channels::BackRight)] *
+ down_mix_coeff[3]) *
+ volume)
+ .to_int()};
+
+ samples[write_index + static_cast<u32>(Channels::FrontLeft)] =
+ static_cast<s16>(std::clamp(left_sample, min, max));
+ samples[write_index + static_cast<u32>(Channels::FrontRight)] =
+ static_cast<s16>(std::clamp(right_sample, min, max));
+ }
+
+ samples.resize(samples.size() / system_channels * device_channels);
+
+ } else if (system_channels == 2 && device_channels == 6) {
+ // We need moar samples! Not all games will provide 6 channel audio.
+ // TODO: Implement some upmixing here. Currently just passthrough, with other
+ // channels left as silence.
+ std::vector<s16> new_samples(samples.size() / system_channels * device_channels, 0);
+
+ for (u32 read_index = 0, write_index = 0; read_index < samples.size();
+ read_index += system_channels, write_index += device_channels) {
+ const auto left_sample{static_cast<s16>(std::clamp(
+ static_cast<s32>(
+ static_cast<f32>(
+ samples[read_index + static_cast<u32>(Channels::FrontLeft)]) *
+ volume),
+ min, max))};
+
+ new_samples[write_index + static_cast<u32>(Channels::FrontLeft)] = left_sample;
+
+ const auto right_sample{static_cast<s16>(std::clamp(
+ static_cast<s32>(
+ static_cast<f32>(
+ samples[read_index + static_cast<u32>(Channels::FrontRight)]) *
+ volume),
+ min, max))};
+
+ new_samples[write_index + static_cast<u32>(Channels::FrontRight)] =
+ right_sample;
+ }
+ samples = std::move(new_samples);
+
+ } else if (volume != 1.0f) {
+ for (u32 i = 0; i < samples.size(); i++) {
+ samples[i] = static_cast<s16>(std::clamp(
+ static_cast<s32>(static_cast<f32>(samples[i]) * volume), min, max));
+ }
+ }
+
+ samples_buffer.Push(samples);
+ queue.enqueue(buffer);
+ queued_buffers++;
+ }
+ }
+
+ /**
+ * Release a buffer. Audio In only, will fill a buffer with recorded samples.
+ *
+ * @param num_samples - Maximum number of samples to receive.
+ * @return Vector of recorded samples. May have fewer than num_samples.
+ */
+ std::vector<s16> ReleaseBuffer(const u64 num_samples) override {
+ static constexpr s32 min = std::numeric_limits<s16>::min();
+ static constexpr s32 max = std::numeric_limits<s16>::max();
+
+ auto samples{samples_buffer.Pop(num_samples)};
+
+ // TODO: Up-mix to 6 channels if the game expects it.
+ // For audio input this is unlikely to ever be the case though.
+
+ // Incoming mic volume seems to always be very quiet, so multiply by an additional 8 here.
+ // TODO: Play with this and find something that works better.
+ auto volume{system_volume * device_volume * 8};
+ for (u32 i = 0; i < samples.size(); i++) {
+ samples[i] = static_cast<s16>(
+ std::clamp(static_cast<s32>(static_cast<f32>(samples[i]) * volume), min, max));
+ }
+
+ if (samples.size() < num_samples) {
+ samples.resize(num_samples, 0);
+ }
+ return samples;
+ }
+
+ /**
+ * Check if a certain buffer has been consumed (fully played).
+ *
+ * @param tag - Unique tag of a buffer to check for.
+ * @return True if the buffer has been played, otherwise false.
+ */
+ bool IsBufferConsumed(const u64 tag) override {
+ if (released_buffer.tag == 0) {
+ if (!released_buffers.try_dequeue(released_buffer)) {
+ return false;
+ }
+ }
+
+ if (released_buffer.tag == tag) {
+ released_buffer.tag = 0;
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Empty out the buffer queue.
+ */
+ void ClearQueue() override {
+ samples_buffer.Pop();
+ while (queue.pop()) {
+ }
+ while (released_buffers.pop()) {
+ }
+ released_buffer = {};
+ playing_buffer = {};
+ playing_buffer.consumed = true;
+ queued_buffers = 0;
+ }
+
+private:
+ /**
+ * Signal events back to the audio system that a buffer was played/can be filled.
+ *
+ * @param buffer - Consumed audio buffer to be released.
+ */
+ void SignalEvent(const ::AudioCore::Sink::SinkBuffer& buffer) {
+ auto& manager{system.AudioCore().GetAudioManager()};
+ switch (type) {
+ case StreamType::Out:
+ released_buffers.enqueue(buffer);
+ manager.SetEvent(Event::Type::AudioOutManager, true);
+ break;
+ case StreamType::In:
+ released_buffers.enqueue(buffer);
+ manager.SetEvent(Event::Type::AudioInManager, true);
+ break;
+ case StreamType::Render:
+ break;
+ }
+ }
+
+ /**
+ * Main callback from SDL. Either expects samples from us (audio render/audio out), or will
+ * provide samples to be copied (audio in).
+ *
+ * @param userdata - Custom data pointer passed along, points to a SDLSinkStream.
+ * @param stream - Buffer of samples to be filled or read.
+ * @param len - Length of the stream in bytes.
+ */
+ static void DataCallback(void* userdata, Uint8* stream, int len) {
+ auto* impl = static_cast<SDLSinkStream*>(userdata);
+
+ if (!impl) {
+ return;
+ }
+
+ const std::size_t num_channels = impl->GetDeviceChannels();
+ const std::size_t frame_size = num_channels;
+ const std::size_t frame_size_bytes = frame_size * sizeof(s16);
+ const std::size_t num_frames{len / num_channels / sizeof(s16)};
+ size_t frames_written{0};
+ [[maybe_unused]] bool underrun{false};
+
+ if (impl->type == StreamType::In) {
+ std::span<s16> input_buffer{reinterpret_cast<s16*>(stream), num_frames * frame_size};
+
+ while (frames_written < num_frames) {
+ auto& playing_buffer{impl->playing_buffer};
+
+ // If the playing buffer has been consumed or has no frames, we need a new one
+ if (playing_buffer.consumed || playing_buffer.frames == 0) {
+ if (!impl->queue.try_dequeue(impl->playing_buffer)) {
+ // If no buffer was available we've underrun, just push the samples and
+ // continue.
+ underrun = true;
+ impl->samples_buffer.Push(&input_buffer[frames_written * frame_size],
+ (num_frames - frames_written) * frame_size);
+ frames_written = num_frames;
+ continue;
+ } else {
+ impl->queued_buffers--;
+ impl->SignalEvent(impl->playing_buffer);
+ }
+ }
+
+ // Get the minimum frames available between the currently playing buffer, and the
+ // amount we have left to fill
+ size_t frames_available{
+ std::min(playing_buffer.frames - playing_buffer.frames_played,
+ num_frames - frames_written)};
+
+ impl->samples_buffer.Push(&input_buffer[frames_written * frame_size],
+ frames_available * frame_size);
+
+ frames_written += frames_available;
+ playing_buffer.frames_played += frames_available;
+
+ // If that's all the frames in the current buffer, add its samples and mark it as
+ // consumed
+ if (playing_buffer.frames_played >= playing_buffer.frames) {
+ impl->AddPlayedSampleCount(playing_buffer.frames_played * num_channels);
+ impl->playing_buffer.consumed = true;
+ }
+ }
+
+ std::memcpy(&impl->last_frame[0], &input_buffer[(frames_written - 1) * frame_size],
+ frame_size_bytes);
+ } else {
+ std::span<s16> output_buffer{reinterpret_cast<s16*>(stream), num_frames * frame_size};
+
+ while (frames_written < num_frames) {
+ auto& playing_buffer{impl->playing_buffer};
+
+ // If the playing buffer has been consumed or has no frames, we need a new one
+ if (playing_buffer.consumed || playing_buffer.frames == 0) {
+ if (!impl->queue.try_dequeue(impl->playing_buffer)) {
+ // If no buffer was available we've underrun, fill the remaining buffer with
+ // the last written frame and continue.
+ underrun = true;
+ for (size_t i = frames_written; i < num_frames; i++) {
+ std::memcpy(&output_buffer[i * frame_size], &impl->last_frame[0],
+ frame_size_bytes);
+ }
+ frames_written = num_frames;
+ continue;
+ } else {
+ impl->queued_buffers--;
+ impl->SignalEvent(impl->playing_buffer);
+ }
+ }
+
+ // Get the minimum frames available between the currently playing buffer, and the
+ // amount we have left to fill
+ size_t frames_available{
+ std::min(playing_buffer.frames - playing_buffer.frames_played,
+ num_frames - frames_written)};
+
+ impl->samples_buffer.Pop(&output_buffer[frames_written * frame_size],
+ frames_available * frame_size);
+
+ frames_written += frames_available;
+ playing_buffer.frames_played += frames_available;
+
+ // If that's all the frames in the current buffer, add its samples and mark it as
+ // consumed
+ if (playing_buffer.frames_played >= playing_buffer.frames) {
+ impl->AddPlayedSampleCount(playing_buffer.frames_played * num_channels);
+ impl->playing_buffer.consumed = true;
+ }
+ }
+
+ std::memcpy(&impl->last_frame[0], &output_buffer[(frames_written - 1) * frame_size],
+ frame_size_bytes);
+ }
+ }
+
+ /// SDL device id of the opened input/output device
+ SDL_AudioDeviceID device{};
+ /// Type of this stream
+ StreamType type;
+ /// Core system
+ Core::System& system;
+ /// Ring buffer of the samples waiting to be played or consumed
+ Common::RingBuffer<s16, 0x10000> samples_buffer;
+ /// Audio buffers queued and waiting to play
+ Common::ReaderWriterQueue<::AudioCore::Sink::SinkBuffer> queue;
+ /// The currently-playing audio buffer
+ ::AudioCore::Sink::SinkBuffer playing_buffer{};
+ /// Audio buffers which have been played and are in queue to be released by the audio system
+ Common::ReaderWriterQueue<::AudioCore::Sink::SinkBuffer> released_buffers{};
+ /// Currently released buffer waiting to be taken by the audio system
+ ::AudioCore::Sink::SinkBuffer released_buffer{};
+ /// The last played (or received) frame of audio, used when the callback underruns
+ std::array<s16, MaxChannels> last_frame{};
+};
+
+SDLSink::SDLSink(std::string_view target_device_name) {
+ if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+ if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
+ LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
+ return;
+ }
+ }
+
+ if (target_device_name != auto_device_name && !target_device_name.empty()) {
+ output_device = target_device_name;
+ } else {
+ output_device.clear();
+ }
+
+ device_channels = 2;
+}
+
+SDLSink::~SDLSink() = default;
+
+SinkStream* SDLSink::AcquireSinkStream(Core::System& system, const u32 system_channels,
+ const std::string&, const StreamType type) {
+ SinkStreamPtr& stream = sink_streams.emplace_back(std::make_unique<SDLSinkStream>(
+ device_channels, system_channels, output_device, input_device, type, system));
+ return stream.get();
+}
+
+void SDLSink::CloseStream(const SinkStream* stream) {
+ for (size_t i = 0; i < sink_streams.size(); i++) {
+ if (sink_streams[i].get() == stream) {
+ sink_streams[i].reset();
+ sink_streams.erase(sink_streams.begin() + i);
+ break;
+ }
+ }
+}
+
+void SDLSink::CloseStreams() {
+ sink_streams.clear();
+}
+
+void SDLSink::PauseStreams() {
+ for (auto& stream : sink_streams) {
+ stream->Stop();
+ }
+}
+
+void SDLSink::UnpauseStreams() {
+ for (auto& stream : sink_streams) {
+ stream->Start();
+ }
+}
+
+f32 SDLSink::GetDeviceVolume() const {
+ if (sink_streams.empty()) {
+ return 1.0f;
+ }
+
+ return sink_streams[0]->GetDeviceVolume();
+}
+
+void SDLSink::SetDeviceVolume(const f32 volume) {
+ for (auto& stream : sink_streams) {
+ stream->SetDeviceVolume(volume);
+ }
+}
+
+void SDLSink::SetSystemVolume(const f32 volume) {
+ for (auto& stream : sink_streams) {
+ stream->SetSystemVolume(volume);
+ }
+}
+
+std::vector<std::string> ListSDLSinkDevices(const bool capture) {
+ std::vector<std::string> device_list;
+
+ if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+ if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
+ LOG_CRITICAL(Audio_Sink, "SDL_InitSubSystem audio failed: {}", SDL_GetError());
+ return {};
+ }
+ }
+
+ const int device_count = SDL_GetNumAudioDevices(capture);
+ for (int i = 0; i < device_count; ++i) {
+ device_list.emplace_back(SDL_GetAudioDeviceName(i, 0));
+ }
+
+ return device_list;
+}
+
+} // namespace AudioCore::Sink
diff --git a/src/audio_core/sink/sdl2_sink.h b/src/audio_core/sink/sdl2_sink.h
new file mode 100644
index 000000000..186bc2fa3
--- /dev/null
+++ b/src/audio_core/sink/sdl2_sink.h
@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "audio_core/sink/sink.h"
+
+namespace Core {
+class System;
+}
+
+namespace AudioCore::Sink {
+class SinkStream;
+
+/**
+ * SDL backend sink, holds multiple output streams and is responsible for sinking samples to
+ * hardware. Used by Audio Render, Audio In and Audio Out.
+ */
+class SDLSink final : public Sink {
+public:
+ explicit SDLSink(std::string_view device_id);
+ ~SDLSink() override;
+
+ /**
+ * Create a new sink stream.
+ *
+ * @param system - Core system.
+ * @param system_channels - Number of channels the audio system expects.
+ * May differ from the device's channel count.
+ * @param name - Name of this stream.
+ * @param type - Type of this stream, render/in/out.
+ * @param event - Audio render only, a signal used to prevent the renderer running too
+ * fast.
+ * @return A pointer to the created SinkStream
+ */
+ SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,
+ const std::string& name, StreamType type) override;
+
+ /**
+ * Close a given stream.
+ *
+ * @param stream - The stream to close.
+ */
+ void CloseStream(const SinkStream* stream) override;
+
+ /**
+ * Close all streams.
+ */
+ void CloseStreams() override;
+
+ /**
+ * Pause all streams.
+ */
+ void PauseStreams() override;
+
+ /**
+ * Unpause all streams.
+ */
+ void UnpauseStreams() override;
+
+ /**
+ * Get the device volume. Set from calls to the IAudioDevice service.
+ *
+ * @return Volume of the device.
+ */
+ f32 GetDeviceVolume() const override;
+
+ /**
+ * Set the device volume. Set from calls to the IAudioDevice service.
+ *
+ * @param volume - New volume of the device.
+ */
+ void SetDeviceVolume(f32 volume) override;
+
+ /**
+ * Set the system volume. Comes from the audio system using this stream.
+ *
+ * @param volume - New volume of the system.
+ */
+ void SetSystemVolume(f32 volume) override;
+
+private:
+ /// Name of the output device used by streams
+ std::string output_device;
+ /// Name of the input device used by streams
+ std::string input_device;
+ /// Vector of streams managed by this sink
+ std::vector<SinkStreamPtr> sink_streams;
+};
+
+/**
+ * Get a list of conencted devices from Cubeb.
+ *
+ * @param capture - Return input (capture) devices if true, otherwise output devices.
+ */
+std::vector<std::string> ListSDLSinkDevices(bool capture);
+
+} // namespace AudioCore::Sink
diff --git a/src/audio_core/sink/sink.h b/src/audio_core/sink/sink.h
new file mode 100644
index 000000000..91fe455e4
--- /dev/null
+++ b/src/audio_core/sink/sink.h
@@ -0,0 +1,106 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "audio_core/sink/sink_stream.h"
+#include "common/common_types.h"
+
+namespace Common {
+class Event;
+}
+namespace Core {
+class System;
+}
+
+namespace AudioCore::Sink {
+
+constexpr char auto_device_name[] = "auto";
+
+/**
+ * This class is an interface for an audio sink, holds multiple output streams and is responsible
+ * for sinking samples to hardware. Used by Audio Render, Audio In and Audio Out.
+ */
+class Sink {
+public:
+ virtual ~Sink() = default;
+ /**
+ * Close a given stream.
+ *
+ * @param stream - The stream to close.
+ */
+ virtual void CloseStream(const SinkStream* stream) = 0;
+
+ /**
+ * Close all streams.
+ */
+ virtual void CloseStreams() = 0;
+
+ /**
+ * Pause all streams.
+ */
+ virtual void PauseStreams() = 0;
+
+ /**
+ * Unpause all streams.
+ */
+ virtual void UnpauseStreams() = 0;
+
+ /**
+ * Create a new sink stream, kept within this sink, with a pointer returned for use.
+ * Do not free the returned pointer. When done with the stream, call CloseStream on the sink.
+ *
+ * @param system - Core system.
+ * @param system_channels - Number of channels the audio system expects.
+ * May differ from the device's channel count.
+ * @param name - Name of this stream.
+ * @param type - Type of this stream, render/in/out.
+ * @param event - Audio render only, a signal used to prevent the renderer running too
+ * fast.
+ * @return A pointer to the created SinkStream
+ */
+ virtual SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,
+ const std::string& name, StreamType type) = 0;
+
+ /**
+ * Get the number of channels the hardware device supports.
+ * Either 2 or 6.
+ *
+ * @return Number of device channels.
+ */
+ u32 GetDeviceChannels() const {
+ return device_channels;
+ }
+
+ /**
+ * Get the device volume. Set from calls to the IAudioDevice service.
+ *
+ * @return Volume of the device.
+ */
+ virtual f32 GetDeviceVolume() const = 0;
+
+ /**
+ * Set the device volume. Set from calls to the IAudioDevice service.
+ *
+ * @param volume - New volume of the device.
+ */
+ virtual void SetDeviceVolume(f32 volume) = 0;
+
+ /**
+ * Set the system volume. Comes from the audio system using this stream.
+ *
+ * @param volume - New volume of the system.
+ */
+ virtual void SetSystemVolume(f32 volume) = 0;
+
+protected:
+ /// Number of device channels supported by the hardware
+ u32 device_channels{2};
+};
+
+using SinkPtr = std::unique_ptr<Sink>;
+
+} // namespace AudioCore::Sink
diff --git a/src/audio_core/sink_details.cpp b/src/audio_core/sink/sink_details.cpp
index c4cc66111..253c0fd1e 100644
--- a/src/audio_core/sink_details.cpp
+++ b/src/audio_core/sink/sink_details.cpp
@@ -5,21 +5,21 @@
#include <memory>
#include <string>
#include <vector>
-#include "audio_core/null_sink.h"
-#include "audio_core/sink_details.h"
+#include "audio_core/sink/null_sink.h"
+#include "audio_core/sink/sink_details.h"
#ifdef HAVE_CUBEB
-#include "audio_core/cubeb_sink.h"
+#include "audio_core/sink/cubeb_sink.h"
#endif
#ifdef HAVE_SDL2
-#include "audio_core/sdl2_sink.h"
+#include "audio_core/sink/sdl2_sink.h"
#endif
#include "common/logging/log.h"
-namespace AudioCore {
+namespace AudioCore::Sink {
namespace {
struct SinkDetails {
using FactoryFn = std::unique_ptr<Sink> (*)(std::string_view);
- using ListDevicesFn = std::vector<std::string> (*)();
+ using ListDevicesFn = std::vector<std::string> (*)(bool);
/// Name for this sink.
const char* id;
@@ -49,17 +49,18 @@ constexpr SinkDetails sink_details[] = {
[](std::string_view device_id) -> std::unique_ptr<Sink> {
return std::make_unique<NullSink>(device_id);
},
- [] { return std::vector<std::string>{"null"}; }},
+ [](bool capture) { return std::vector<std::string>{"null"}; }},
};
-const SinkDetails& GetSinkDetails(std::string_view sink_id) {
+const SinkDetails& GetOutputSinkDetails(std::string_view sink_id) {
auto iter =
std::find_if(std::begin(sink_details), std::end(sink_details),
[sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; });
if (sink_id == "auto" || iter == std::end(sink_details)) {
if (sink_id != "auto") {
- LOG_ERROR(Audio, "AudioCore::SelectSink given invalid sink_id {}", sink_id);
+ LOG_ERROR(Audio, "AudioCore::Sink::GetOutputSinkDetails given invalid sink_id {}",
+ sink_id);
}
// Auto-select.
// sink_details is ordered in terms of desirability, with the best choice at the front.
@@ -79,12 +80,12 @@ std::vector<const char*> GetSinkIDs() {
return sink_ids;
}
-std::vector<std::string> GetDeviceListForSink(std::string_view sink_id) {
- return GetSinkDetails(sink_id).list_devices();
+std::vector<std::string> GetDeviceListForSink(std::string_view sink_id, bool capture) {
+ return GetOutputSinkDetails(sink_id).list_devices(capture);
}
std::unique_ptr<Sink> CreateSinkFromID(std::string_view sink_id, std::string_view device_id) {
- return GetSinkDetails(sink_id).factory(device_id);
+ return GetOutputSinkDetails(sink_id).factory(device_id);
}
-} // namespace AudioCore
+} // namespace AudioCore::Sink
diff --git a/src/audio_core/sink/sink_details.h b/src/audio_core/sink/sink_details.h
new file mode 100644
index 000000000..3ebdb1e30
--- /dev/null
+++ b/src/audio_core/sink/sink_details.h
@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace AudioCore {
+class AudioManager;
+
+namespace Sink {
+
+class Sink;
+
+/**
+ * Retrieves the IDs for all available audio sinks.
+ *
+ * @return Vector of available sink names.
+ */
+std::vector<const char*> GetSinkIDs();
+
+/**
+ * Gets the list of devices for a particular sink identified by the given ID.
+ *
+ * @param sink_id - Id of the sink to get devices from.
+ * @param capture - Get capture (input) devices, or output devices?
+ * @return Vector of device names.
+ */
+std::vector<std::string> GetDeviceListForSink(std::string_view sink_id, bool capture);
+
+/**
+ * Creates an audio sink identified by the given device ID.
+ *
+ * @param sink_id - Id of the sink to create.
+ * @param device_id - Name of the device to create.
+ * @return Pointer to the created sink.
+ */
+std::unique_ptr<Sink> CreateSinkFromID(std::string_view sink_id, std::string_view device_id);
+
+} // namespace Sink
+} // namespace AudioCore
diff --git a/src/audio_core/sink/sink_stream.h b/src/audio_core/sink/sink_stream.h
new file mode 100644
index 000000000..17ed6593f
--- /dev/null
+++ b/src/audio_core/sink/sink_stream.h
@@ -0,0 +1,224 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <atomic>
+#include <memory>
+#include <vector>
+
+#include "audio_core/common/common.h"
+#include "common/common_types.h"
+
+namespace AudioCore::Sink {
+
+enum class StreamType {
+ Render,
+ Out,
+ In,
+};
+
+struct SinkBuffer {
+ u64 frames;
+ u64 frames_played;
+ u64 tag;
+ bool consumed;
+};
+
+/**
+ * Contains a real backend stream for outputting samples to hardware,
+ * created only via a Sink (See Sink::AcquireSinkStream).
+ *
+ * Accepts a SinkBuffer and samples in PCM16 format to be output (see AppendBuffer).
+ * Appended buffers act as a FIFO queue, and will be held until played.
+ * You should regularly call IsBufferConsumed with the unique SinkBuffer tag to check if the buffer
+ * has been consumed.
+ *
+ * Since these are a FIFO queue, always check IsBufferConsumed in the same order you appended the
+ * buffers, skipping a buffer will result in all following buffers to never release.
+ *
+ * If the buffers appear to be stuck, you can stop and re-open an IAudioIn/IAudioOut service (this
+ * is what games do), or call ClearQueue to flush all of the buffers without a full restart.
+ */
+class SinkStream {
+public:
+ virtual ~SinkStream() = default;
+
+ /**
+ * Finalize the sink stream.
+ */
+ virtual void Finalize() = 0;
+
+ /**
+ * Start the sink stream.
+ *
+ * @param resume - Set to true if this is resuming the stream a previously-active stream.
+ * Default false.
+ */
+ virtual void Start(bool resume = false) = 0;
+
+ /**
+ * Stop the sink stream.
+ */
+ virtual void Stop() = 0;
+
+ /**
+ * Append a new buffer and its samples to a waiting queue to play.
+ *
+ * @param buffer - Audio buffer information to be queued.
+ * @param samples - The s16 samples to be queue for playback.
+ */
+ virtual void AppendBuffer(SinkBuffer& buffer, std::vector<s16>& samples) = 0;
+
+ /**
+ * Release a buffer. Audio In only, will fill a buffer with recorded samples.
+ *
+ * @param num_samples - Maximum number of samples to receive.
+ * @return Vector of recorded samples. May have fewer than num_samples.
+ */
+ virtual std::vector<s16> ReleaseBuffer(u64 num_samples) = 0;
+
+ /**
+ * Check if a certain buffer has been consumed (fully played).
+ *
+ * @param tag - Unique tag of a buffer to check for.
+ * @return True if the buffer has been played, otherwise false.
+ */
+ virtual bool IsBufferConsumed(u64 tag) = 0;
+
+ /**
+ * Empty out the buffer queue.
+ */
+ virtual void ClearQueue() = 0;
+
+ /**
+ * Check if the stream is paused.
+ *
+ * @return True if paused, otherwise false.
+ */
+ bool IsPaused() {
+ return paused;
+ }
+
+ /**
+ * Get the number of system channels in this stream.
+ *
+ * @return Number of system channels.
+ */
+ u32 GetSystemChannels() const {
+ return system_channels;
+ }
+
+ /**
+ * Set the number of channels the system expects.
+ *
+ * @param channels - New number of system channels.
+ */
+ void SetSystemChannels(u32 channels) {
+ system_channels = channels;
+ }
+
+ /**
+ * Get the number of channels the hardware supports.
+ *
+ * @return Number of channels supported.
+ */
+ u32 GetDeviceChannels() const {
+ return device_channels;
+ }
+
+ /**
+ * Get the total number of samples played by this stream.
+ *
+ * @return Number of samples played.
+ */
+ u64 GetPlayedSampleCount() const {
+ return played_sample_count;
+ }
+
+ /**
+ * Set the number of samples played.
+ * This is started and stopped on system start/stop.
+ *
+ * @param played_sample_count_ - Number of samples to set.
+ */
+ void SetPlayedSampleCount(u64 played_sample_count_) {
+ played_sample_count = played_sample_count_;
+ }
+
+ /**
+ * Add to the played sample count.
+ *
+ * @param num_samples - Number of samples to add.
+ */
+ void AddPlayedSampleCount(u64 num_samples) {
+ played_sample_count += num_samples;
+ }
+
+ /**
+ * Get the system volume.
+ *
+ * @return The current system volume.
+ */
+ f32 GetSystemVolume() const {
+ return system_volume;
+ }
+
+ /**
+ * Get the device volume.
+ *
+ * @return The current device volume.
+ */
+ f32 GetDeviceVolume() const {
+ return device_volume;
+ }
+
+ /**
+ * Set the system volume.
+ *
+ * @param volume_ - The new system volume.
+ */
+ void SetSystemVolume(f32 volume_) {
+ system_volume = volume_;
+ }
+
+ /**
+ * Set the device volume.
+ *
+ * @param volume_ - The new device volume.
+ */
+ void SetDeviceVolume(f32 volume_) {
+ device_volume = volume_;
+ }
+
+ /**
+ * Get the number of queued audio buffers.
+ *
+ * @return The number of queued buffers.
+ */
+ u32 GetQueueSize() {
+ return queued_buffers.load();
+ }
+
+protected:
+ /// Number of buffers waiting to be played
+ std::atomic<u32> queued_buffers{};
+ /// Total samples played by this stream
+ std::atomic<u64> played_sample_count{};
+ /// Set by the audio render/in/out system which uses this stream
+ f32 system_volume{1.0f};
+ /// Set via IAudioDevice service calls
+ f32 device_volume{1.0f};
+ /// Set by the audio render/in/out systen which uses this stream
+ u32 system_channels{2};
+ /// Channels supported by hardware
+ u32 device_channels{2};
+ /// Is this stream currently paused?
+ std::atomic<bool> paused{true};
+ /// Was this stream previously playing?
+ std::atomic<bool> was_playing{false};
+};
+
+using SinkStreamPtr = std::unique_ptr<SinkStream>;
+
+} // namespace AudioCore::Sink
diff --git a/src/audio_core/sink_context.cpp b/src/audio_core/sink_context.cpp
deleted file mode 100644
index 835e12f67..000000000
--- a/src/audio_core/sink_context.cpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "audio_core/sink_context.h"
-
-namespace AudioCore {
-SinkContext::SinkContext(std::size_t sink_count_) : sink_count{sink_count_} {}
-SinkContext::~SinkContext() = default;
-
-std::size_t SinkContext::GetCount() const {
- return sink_count;
-}
-
-void SinkContext::UpdateMainSink(const SinkInfo::InParams& in) {
- ASSERT(in.type == SinkTypes::Device);
-
- if (in.device.down_matrix_enabled) {
- downmix_coefficients = in.device.down_matrix_coef;
- } else {
- downmix_coefficients = {
- 1.0f, // front
- 0.707f, // center
- 0.0f, // lfe
- 0.707f, // back
- };
- }
-
- in_use = in.in_use;
- use_count = in.device.input_count;
- buffers = in.device.input;
-}
-
-bool SinkContext::InUse() const {
- return in_use;
-}
-
-std::vector<u8> SinkContext::OutputBuffers() const {
- std::vector<u8> buffer_ret(use_count);
- std::memcpy(buffer_ret.data(), buffers.data(), use_count);
- return buffer_ret;
-}
-
-const DownmixCoefficients& SinkContext::GetDownmixCoefficients() const {
- return downmix_coefficients;
-}
-
-} // namespace AudioCore
diff --git a/src/audio_core/sink_context.h b/src/audio_core/sink_context.h
deleted file mode 100644
index cc5a90d80..000000000
--- a/src/audio_core/sink_context.h
+++ /dev/null
@@ -1,95 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <array>
-#include <vector>
-#include "audio_core/common.h"
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-
-namespace AudioCore {
-
-using DownmixCoefficients = std::array<float_le, 4>;
-
-enum class SinkTypes : u8 {
- Invalid = 0,
- Device = 1,
- Circular = 2,
-};
-
-enum class SinkSampleFormat : u32_le {
- None = 0,
- Pcm8 = 1,
- Pcm16 = 2,
- Pcm24 = 3,
- Pcm32 = 4,
- PcmFloat = 5,
- Adpcm = 6,
-};
-
-class SinkInfo {
-public:
- struct CircularBufferIn {
- u64_le address;
- u32_le size;
- u32_le input_count;
- u32_le sample_count;
- u32_le previous_position;
- SinkSampleFormat sample_format;
- std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> input;
- bool in_use;
- INSERT_PADDING_BYTES_NOINIT(5);
- };
- static_assert(sizeof(CircularBufferIn) == 0x28,
- "SinkInfo::CircularBufferIn is in invalid size");
-
- struct DeviceIn {
- std::array<u8, 255> device_name;
- INSERT_PADDING_BYTES_NOINIT(1);
- s32_le input_count;
- std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> input;
- INSERT_PADDING_BYTES_NOINIT(1);
- bool down_matrix_enabled;
- DownmixCoefficients down_matrix_coef;
- };
- static_assert(sizeof(DeviceIn) == 0x11c, "SinkInfo::DeviceIn is an invalid size");
-
- struct InParams {
- SinkTypes type{};
- bool in_use{};
- INSERT_PADDING_BYTES(2);
- u32_le node_id{};
- INSERT_PADDING_WORDS(6);
- union {
- // std::array<u8, 0x120> raw{};
- DeviceIn device;
- CircularBufferIn circular_buffer;
- };
- };
- static_assert(sizeof(InParams) == 0x140, "SinkInfo::InParams are an invalid size!");
-};
-
-class SinkContext {
-public:
- explicit SinkContext(std::size_t sink_count_);
- ~SinkContext();
-
- [[nodiscard]] std::size_t GetCount() const;
-
- void UpdateMainSink(const SinkInfo::InParams& in);
- [[nodiscard]] bool InUse() const;
- [[nodiscard]] std::vector<u8> OutputBuffers() const;
-
- [[nodiscard]] const DownmixCoefficients& GetDownmixCoefficients() const;
-
-private:
- bool in_use{false};
- s32 use_count{};
- std::array<u8, AudioCommon::MAX_CHANNEL_COUNT> buffers{};
- std::size_t sink_count{};
- DownmixCoefficients downmix_coefficients{};
-};
-} // namespace AudioCore
diff --git a/src/audio_core/sink_details.h b/src/audio_core/sink_details.h
deleted file mode 100644
index 042766358..000000000
--- a/src/audio_core/sink_details.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <string>
-#include <string_view>
-#include <vector>
-
-namespace AudioCore {
-
-class Sink;
-
-/// Retrieves the IDs for all available audio sinks.
-std::vector<const char*> GetSinkIDs();
-
-/// Gets the list of devices for a particular sink identified by the given ID.
-std::vector<std::string> GetDeviceListForSink(std::string_view sink_id);
-
-/// Creates an audio sink identified by the given device ID.
-std::unique_ptr<Sink> CreateSinkFromID(std::string_view sink_id, std::string_view device_id);
-
-} // namespace AudioCore
diff --git a/src/audio_core/sink_stream.h b/src/audio_core/sink_stream.h
deleted file mode 100644
index 0449b90af..000000000
--- a/src/audio_core/sink_stream.h
+++ /dev/null
@@ -1,35 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include "common/common_types.h"
-
-namespace AudioCore {
-
-/**
- * Accepts samples in stereo signed PCM16 format to be output. Sinks *do not* handle resampling and
- * expect the correct sample rate. They are dumb outputs.
- */
-class SinkStream {
-public:
- virtual ~SinkStream() = default;
-
- /**
- * Feed stereo samples to sink.
- * @param num_channels Number of channels used.
- * @param samples Samples in interleaved stereo PCM16 format.
- */
- virtual void EnqueueSamples(u32 num_channels, const std::vector<s16>& samples) = 0;
-
- virtual std::size_t SamplesInQueue(u32 num_channels) const = 0;
-
- virtual void Flush() = 0;
-};
-
-using SinkStreamPtr = std::unique_ptr<SinkStream>;
-
-} // namespace AudioCore