From 5f59815f39f7f9817ea0b55885e89fdf02189f78 Mon Sep 17 00:00:00 2001
From: bunnei <bunneidev@gmail.com>
Date: Fri, 27 Jul 2018 19:17:27 -0400
Subject: [PATCH 1/5] externals: Add cubeb for audio output.

---
 .gitmodules     | 3 +++
 externals/cubeb | 1 +
 2 files changed, 4 insertions(+)
 create mode 160000 externals/cubeb

diff --git a/.gitmodules b/.gitmodules
index 4de47fa6b..0f94613c4 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -7,6 +7,9 @@
 [submodule "catch"]
     path = externals/catch
     url = https://github.com/philsquared/Catch.git
+[submodule "cubeb"]
+    path = externals/cubeb
+    url = https://github.com/kinetiknz/cubeb.git
 [submodule "dynarmic"]
     path = externals/dynarmic
     url = https://github.com/MerryMage/dynarmic.git
diff --git a/externals/cubeb b/externals/cubeb
new file mode 160000
index 000000000..12b78c0ed
--- /dev/null
+++ b/externals/cubeb
@@ -0,0 +1 @@
+Subproject commit 12b78c0edfa40007e41dbdcd9dfe367fbb98d018

From eaf66b4c9f9517bcb4f417260ad460fca4254bec Mon Sep 17 00:00:00 2001
From: bunnei <bunneidev@gmail.com>
Date: Sat, 28 Jul 2018 13:27:59 -0400
Subject: [PATCH 2/5] audio_core: Move to audout_u impl.

- This is necessary so streams are created on the same thread.
---
 src/core/core.cpp                       | 2 --
 src/core/core.h                         | 7 -------
 src/core/hle/service/audio/audout_u.cpp | 8 ++++----
 src/core/hle/service/audio/audout_u.h   | 2 ++
 4 files changed, 6 insertions(+), 13 deletions(-)

diff --git a/src/core/core.cpp b/src/core/core.cpp
index 186fa46df..b7f4b4532 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -177,7 +177,6 @@ System::ResultStatus System::Init(EmuWindow* emu_window, u32 system_mode) {
     }
 
     gpu_core = std::make_unique<Tegra::GPU>();
-    audio_core = std::make_unique<AudioCore::AudioOut>();
     telemetry_session = std::make_unique<Core::TelemetrySession>();
     service_manager = std::make_shared<Service::SM::ServiceManager>();
 
@@ -229,7 +228,6 @@ void System::Shutdown() {
     service_manager.reset();
     telemetry_session.reset();
     gpu_core.reset();
-    audio_core.reset();
 
     // Close all CPU/threading state
     cpu_barrier->NotifyEnd();
diff --git a/src/core/core.h b/src/core/core.h
index 6f4df775f..c123fe401 100644
--- a/src/core/core.h
+++ b/src/core/core.h
@@ -8,7 +8,6 @@
 #include <memory>
 #include <string>
 #include <thread>
-#include "audio_core/audio_out.h"
 #include "common/common_types.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core_cpu.h"
@@ -132,11 +131,6 @@ public:
         return *gpu_core;
     }
 
-    /// Gets the AudioCore interface
-    AudioCore::AudioOut& AudioCore() {
-        return *audio_core;
-    }
-
     /// Gets the scheduler for the CPU core that is currently running
     Kernel::Scheduler& CurrentScheduler() {
         return *CurrentCpuCore().Scheduler();
@@ -201,7 +195,6 @@ private:
     /// AppLoader used to load the current executing application
     std::unique_ptr<Loader::AppLoader> app_loader;
     std::unique_ptr<Tegra::GPU> gpu_core;
-    std::unique_ptr<AudioCore::AudioOut> audio_core;
     std::shared_ptr<Tegra::DebugContext> debug_context;
     Kernel::SharedPtr<Kernel::Process> current_process;
     std::shared_ptr<ExclusiveMonitor> cpu_exclusive_monitor;
diff --git a/src/core/hle/service/audio/audout_u.cpp b/src/core/hle/service/audio/audout_u.cpp
index a15d53ff8..ab37c2a69 100644
--- a/src/core/hle/service/audio/audout_u.cpp
+++ b/src/core/hle/service/audio/audout_u.cpp
@@ -25,9 +25,8 @@ constexpr int DefaultSampleRate{48000};
 
 class IAudioOut final : public ServiceFramework<IAudioOut> {
 public:
-    IAudioOut(AudoutParams audio_params)
-        : ServiceFramework("IAudioOut"), audio_params(audio_params),
-          audio_core(Core::System::GetInstance().AudioCore()) {
+    IAudioOut(AudoutParams audio_params, AudioCore::AudioOut& audio_core)
+        : ServiceFramework("IAudioOut"), audio_params(audio_params), audio_core(audio_core) {
 
         static const FunctionInfo functions[] = {
             {0, &IAudioOut::GetAudioOutState, "GetAudioOutState"},
@@ -195,7 +194,7 @@ void AudOutU::OpenAudioOutImpl(Kernel::HLERequestContext& ctx) {
     // TODO(bunnei): Support more than one IAudioOut interface. When we add this, ListAudioOutsImpl
     // will likely need to be updated as well.
     ASSERT_MSG(!audio_out_interface, "Unimplemented");
-    audio_out_interface = std::make_shared<IAudioOut>(std::move(params));
+    audio_out_interface = std::make_shared<IAudioOut>(std::move(params), *audio_core);
 
     IPC::ResponseBuilder rb{ctx, 6, 0, 1};
     rb.Push(RESULT_SUCCESS);
@@ -212,6 +211,7 @@ AudOutU::AudOutU() : ServiceFramework("audout:u") {
                                              {2, &AudOutU::ListAudioOutsImpl, "ListAudioOutsAuto"},
                                              {3, &AudOutU::OpenAudioOutImpl, "OpenAudioOutAuto"}};
     RegisterHandlers(functions);
+    audio_core = std::make_unique<AudioCore::AudioOut>();
 }
 
 } // namespace Service::Audio
diff --git a/src/core/hle/service/audio/audout_u.h b/src/core/hle/service/audio/audout_u.h
index bc43f1f44..e5c2184d5 100644
--- a/src/core/hle/service/audio/audout_u.h
+++ b/src/core/hle/service/audio/audout_u.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "audio_core/audio_out.h"
 #include "core/hle/service/service.h"
 
 namespace Kernel {
@@ -33,6 +34,7 @@ public:
 
 private:
     std::shared_ptr<IAudioOut> audio_out_interface;
+    std::unique_ptr<AudioCore::AudioOut> audio_core;
 
     void ListAudioOutsImpl(Kernel::HLERequestContext& ctx);
     void OpenAudioOutImpl(Kernel::HLERequestContext& ctx);

From 0e8a2c7222b978507f62d7e0b83187b16532eae8 Mon Sep 17 00:00:00 2001
From: bunnei <bunneidev@gmail.com>
Date: Sat, 28 Jul 2018 13:35:22 -0400
Subject: [PATCH 3/5] audio_core: Misc. improvements to
 stream/buffer/audio_out.

---
 src/audio_core/audio_out.cpp |  4 ++--
 src/audio_core/audio_out.h   |  6 ++----
 src/audio_core/buffer.h      |  3 +++
 src/audio_core/stream.cpp    | 24 ++++++++++++------------
 src/audio_core/stream.h      | 15 +++++++++++++--
 5 files changed, 32 insertions(+), 20 deletions(-)

diff --git a/src/audio_core/audio_out.cpp b/src/audio_core/audio_out.cpp
index 6d418a05b..43414f197 100644
--- a/src/audio_core/audio_out.cpp
+++ b/src/audio_core/audio_out.cpp
@@ -9,7 +9,7 @@
 namespace AudioCore {
 
 /// Returns the stream format from the specified number of channels
-static Stream::Format ChannelsToStreamFormat(int num_channels) {
+static Stream::Format ChannelsToStreamFormat(u32 num_channels) {
     switch (num_channels) {
     case 1:
         return Stream::Format::Mono16;
@@ -24,7 +24,7 @@ static Stream::Format ChannelsToStreamFormat(int num_channels) {
     return {};
 }
 
-StreamPtr AudioOut::OpenStream(int sample_rate, int num_channels,
+StreamPtr AudioOut::OpenStream(u32 sample_rate, u32 num_channels,
                                Stream::ReleaseCallback&& release_callback) {
     streams.push_back(std::make_shared<Stream>(sample_rate, ChannelsToStreamFormat(num_channels),
                                                std::move(release_callback)));
diff --git a/src/audio_core/audio_out.h b/src/audio_core/audio_out.h
index a86499d10..962360d09 100644
--- a/src/audio_core/audio_out.h
+++ b/src/audio_core/audio_out.h
@@ -13,15 +13,13 @@
 
 namespace AudioCore {
 
-using StreamPtr = std::shared_ptr<Stream>;
-
 /**
  * Represents an audio playback interface, used to open and play audio streams
  */
 class AudioOut {
 public:
     /// Opens a new audio stream
-    StreamPtr OpenStream(int sample_rate, int num_channels,
+    StreamPtr OpenStream(u32 sample_rate, u32 num_channels,
                          Stream::ReleaseCallback&& release_callback);
 
     /// Returns a vector of recently released buffers specified by tag for the specified stream
@@ -37,7 +35,7 @@ public:
     bool QueueBuffer(StreamPtr stream, Buffer::Tag tag, std::vector<u8>&& data);
 
 private:
-    /// Active audio streams on the interface
+    SinkPtr sink;
     std::vector<StreamPtr> streams;
 };
 
diff --git a/src/audio_core/buffer.h b/src/audio_core/buffer.h
index 874ec787e..4bf5fd58a 100644
--- a/src/audio_core/buffer.h
+++ b/src/audio_core/buffer.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <memory>
 #include <vector>
 
 #include "common/common_types.h"
@@ -34,4 +35,6 @@ private:
     std::vector<u8> data;
 };
 
+using BufferPtr = std::shared_ptr<Buffer>;
+
 } // namespace AudioCore
diff --git a/src/audio_core/stream.cpp b/src/audio_core/stream.cpp
index 82bff4b9e..63edc6c8d 100644
--- a/src/audio_core/stream.cpp
+++ b/src/audio_core/stream.cpp
@@ -13,24 +13,24 @@ namespace AudioCore {
 
 constexpr size_t MaxAudioBufferCount{32};
 
-/// Returns the sample size for the specified audio stream format
-static size_t SampleSizeFromFormat(Stream::Format format) {
+u32 Stream::GetNumChannels() const {
     switch (format) {
-    case Stream::Format::Mono16:
+    case Format::Mono16:
+        return 1;
+    case Format::Stereo16:
         return 2;
-    case Stream::Format::Stereo16:
-        return 4;
-    case Stream::Format::Multi51Channel16:
-        return 12;
-    };
-
+    case Format::Multi51Channel16:
+        return 6;
+    }
     LOG_CRITICAL(Audio, "Unimplemented format={}", static_cast<u32>(format));
     UNREACHABLE();
     return {};
 }
 
-Stream::Stream(int sample_rate, Format format, ReleaseCallback&& release_callback)
-    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)} {
+u32 Stream::GetSampleSize() const {
+    return GetNumChannels() * 2;
+}
+
     release_event = CoreTiming::RegisterEvent(
         "Stream::Release", [this](u64 userdata, int cycles_late) { ReleaseActiveBuffer(); });
 }
@@ -45,7 +45,7 @@ void Stream::Stop() {
 }
 
 s64 Stream::GetBufferReleaseCycles(const Buffer& buffer) const {
-    const size_t num_samples{buffer.GetData().size() / SampleSizeFromFormat(format)};
+    const size_t num_samples{buffer.GetData().size() / GetSampleSize()};
     return CoreTiming::usToCycles((static_cast<u64>(num_samples) * 1000000) / sample_rate);
 }
 
diff --git a/src/audio_core/stream.h b/src/audio_core/stream.h
index 5f43b0798..5c1005899 100644
--- a/src/audio_core/stream.h
+++ b/src/audio_core/stream.h
@@ -16,8 +16,6 @@
 
 namespace AudioCore {
 
-using BufferPtr = std::shared_ptr<Buffer>;
-
 /**
  * Represents an audio stream, which is a sequence of queued buffers, to be outputed by AudioOut
  */
@@ -60,6 +58,17 @@ public:
         return queued_buffers.size();
     }
 
+    /// Gets the sample rate
+    u32 GetSampleRate() const {
+        return sample_rate;
+    }
+
+    /// Gets the number of channels
+    u32 GetNumChannels() const;
+
+    /// Gets the sample size in bytes
+    u32 GetSampleSize() const;
+
 private:
     /// Current state of the stream
     enum class State {
@@ -86,4 +95,6 @@ private:
     std::queue<BufferPtr> released_buffers; ///< Buffers recently released from the stream
 };
 
+using StreamPtr = std::shared_ptr<Stream>;
+
 } // namespace AudioCore

From 9ef227e09d6e374008d9536935d01c11a6ca06bd Mon Sep 17 00:00:00 2001
From: bunnei <bunneidev@gmail.com>
Date: Sat, 28 Jul 2018 13:40:50 -0400
Subject: [PATCH 4/5] audio_core: Add interfaces for Sink and SinkStream.

---
 src/audio_core/CMakeLists.txt   |  5 +++++
 src/audio_core/null_sink.h      | 27 +++++++++++++++++++++++
 src/audio_core/sink.h           | 29 +++++++++++++++++++++++++
 src/audio_core/sink_details.cpp | 38 +++++++++++++++++++++++++++++++++
 src/audio_core/sink_details.h   | 32 +++++++++++++++++++++++++++
 src/audio_core/sink_stream.h    | 32 +++++++++++++++++++++++++++
 6 files changed, 163 insertions(+)
 create mode 100644 src/audio_core/null_sink.h
 create mode 100644 src/audio_core/sink.h
 create mode 100644 src/audio_core/sink_details.cpp
 create mode 100644 src/audio_core/sink_details.h
 create mode 100644 src/audio_core/sink_stream.h

diff --git a/src/audio_core/CMakeLists.txt b/src/audio_core/CMakeLists.txt
index f00a55994..6bc8f586a 100644
--- a/src/audio_core/CMakeLists.txt
+++ b/src/audio_core/CMakeLists.txt
@@ -2,8 +2,13 @@ add_library(audio_core STATIC
     audio_out.cpp
     audio_out.h
     buffer.h
+    null_sink.h
     stream.cpp
     stream.h
+    sink.h
+    sink_details.cpp
+    sink_details.h
+    sink_stream.h
 )
 
 create_target_directory_groups(audio_core)
diff --git a/src/audio_core/null_sink.h b/src/audio_core/null_sink.h
new file mode 100644
index 000000000..2e04438f7
--- /dev/null
+++ b/src/audio_core/null_sink.h
@@ -0,0 +1,27 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "audio_core/sink.h"
+
+namespace AudioCore {
+
+class NullSink final : public Sink {
+public:
+    explicit NullSink(std::string){};
+    ~NullSink() override = default;
+
+    SinkStream& AcquireSinkStream(u32 /*sample_rate*/, u32 /*num_channels*/) override {
+        return null_sink_stream;
+    }
+
+private:
+    struct NullSinkStreamImpl final : SinkStream {
+        void EnqueueSamples(u32 /*num_channels*/, const s16* /*samples*/,
+                            size_t /*sample_count*/) override {}
+    } null_sink_stream;
+};
+
+} // namespace AudioCore
diff --git a/src/audio_core/sink.h b/src/audio_core/sink.h
new file mode 100644
index 000000000..d1bb98c3d
--- /dev/null
+++ b/src/audio_core/sink.h
@@ -0,0 +1,29 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+
+#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) = 0;
+};
+
+using SinkPtr = std::unique_ptr<Sink>;
+
+} // namespace AudioCore
diff --git a/src/audio_core/sink_details.cpp b/src/audio_core/sink_details.cpp
new file mode 100644
index 000000000..6396d8065
--- /dev/null
+++ b/src/audio_core/sink_details.cpp
@@ -0,0 +1,38 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+#include "audio_core/null_sink.h"
+#include "audio_core/sink_details.h"
+#include "common/logging/log.h"
+
+namespace AudioCore {
+
+// g_sink_details is ordered in terms of desirability, with the best choice at the top.
+const std::vector<SinkDetails> g_sink_details = {
+    SinkDetails{"null", &std::make_unique<NullSink, std::string>,
+                [] { return std::vector<std::string>{"null"}; }},
+};
+
+const SinkDetails& GetSinkDetails(std::string sink_id) {
+    auto iter =
+        std::find_if(g_sink_details.begin(), g_sink_details.end(),
+                     [sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; });
+
+    if (sink_id == "auto" || iter == g_sink_details.end()) {
+        if (sink_id != "auto") {
+            LOG_ERROR(Audio, "AudioCore::SelectSink given invalid sink_id {}", sink_id);
+        }
+        // Auto-select.
+        // g_sink_details is ordered in terms of desirability, with the best choice at the front.
+        iter = g_sink_details.begin();
+    }
+
+    return *iter;
+}
+
+} // namespace AudioCore
diff --git a/src/audio_core/sink_details.h b/src/audio_core/sink_details.h
new file mode 100644
index 000000000..aa8aae1a9
--- /dev/null
+++ b/src/audio_core/sink_details.h
@@ -0,0 +1,32 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+namespace AudioCore {
+
+class Sink;
+
+struct SinkDetails {
+    SinkDetails(const char* id_, std::function<std::unique_ptr<Sink>(std::string)> factory_,
+                std::function<std::vector<std::string>()> list_devices_)
+        : id(id_), factory(factory_), list_devices(list_devices_) {}
+
+    /// Name for this sink.
+    const char* id;
+    /// A method to call to construct an instance of this type of sink.
+    std::function<std::unique_ptr<Sink>(std::string device_id)> factory;
+    /// A method to call to list available devices.
+    std::function<std::vector<std::string>()> list_devices;
+};
+
+extern const std::vector<SinkDetails> g_sink_details;
+
+const SinkDetails& GetSinkDetails(std::string sink_id);
+
+} // namespace AudioCore
diff --git a/src/audio_core/sink_stream.h b/src/audio_core/sink_stream.h
new file mode 100644
index 000000000..e7a3f01b0
--- /dev/null
+++ b/src/audio_core/sink_stream.h
@@ -0,0 +1,32 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+
+#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.
+     * @param sample_count Number of samples.
+     */
+    virtual void EnqueueSamples(u32 num_channels, const s16* samples, size_t sample_count) = 0;
+};
+
+using SinkStreamPtr = std::unique_ptr<SinkStream>;
+
+} // namespace AudioCore

From f437c11caf2c1afc0b7d0fdb808be10d7b1adfcf Mon Sep 17 00:00:00 2001
From: bunnei <bunneidev@gmail.com>
Date: Sat, 28 Jul 2018 13:44:50 -0400
Subject: [PATCH 5/5] audio_core: Implement Sink and SinkStream interfaces with
 cubeb.

---
 CMakeLists.txt                  |   2 +
 externals/CMakeLists.txt        |   6 +
 src/audio_core/CMakeLists.txt   |   7 ++
 src/audio_core/audio_out.cpp    |  13 ++-
 src/audio_core/audio_out.h      |   2 +-
 src/audio_core/cubeb_sink.cpp   | 190 ++++++++++++++++++++++++++++++++
 src/audio_core/cubeb_sink.h     |  31 ++++++
 src/audio_core/sink_details.cpp |   6 +
 src/audio_core/stream.cpp       |  11 ++
 src/audio_core/stream.h         |   7 +-
 10 files changed, 269 insertions(+), 6 deletions(-)
 create mode 100644 src/audio_core/cubeb_sink.cpp
 create mode 100644 src/audio_core/cubeb_sink.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 86d2423ed..3639b623c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,6 +17,8 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "EN
 
 option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
 
+option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
+
 if(NOT EXISTS ${CMAKE_SOURCE_DIR}/.git/hooks/pre-commit)
     message(STATUS "Copying pre-commit hook")
     file(COPY hooks/pre-commit
diff --git a/externals/CMakeLists.txt b/externals/CMakeLists.txt
index e51671cb8..4636761e5 100644
--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -54,3 +54,9 @@ endif()
 # Opus
 add_subdirectory(opus)
 target_include_directories(opus INTERFACE ./opus/include)
+
+# Cubeb
+if(ENABLE_CUBEB)
+    set(BUILD_TESTS OFF CACHE BOOL "")
+    add_subdirectory(cubeb)
+endif()
diff --git a/src/audio_core/CMakeLists.txt b/src/audio_core/CMakeLists.txt
index 6bc8f586a..81121167d 100644
--- a/src/audio_core/CMakeLists.txt
+++ b/src/audio_core/CMakeLists.txt
@@ -2,6 +2,8 @@ add_library(audio_core STATIC
     audio_out.cpp
     audio_out.h
     buffer.h
+    cubeb_sink.cpp
+    cubeb_sink.h
     null_sink.h
     stream.cpp
     stream.h
@@ -14,3 +16,8 @@ add_library(audio_core STATIC
 create_target_directory_groups(audio_core)
 
 target_link_libraries(audio_core PUBLIC common core)
+
+if(ENABLE_CUBEB)
+    target_link_libraries(audio_core PRIVATE cubeb)
+    target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
+endif()
diff --git a/src/audio_core/audio_out.cpp b/src/audio_core/audio_out.cpp
index 43414f197..77cedb6ba 100644
--- a/src/audio_core/audio_out.cpp
+++ b/src/audio_core/audio_out.cpp
@@ -3,6 +3,8 @@
 // Refer to the license.txt file included.
 
 #include "audio_core/audio_out.h"
+#include "audio_core/sink.h"
+#include "audio_core/sink_details.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
 
@@ -26,9 +28,14 @@ static Stream::Format ChannelsToStreamFormat(u32 num_channels) {
 
 StreamPtr AudioOut::OpenStream(u32 sample_rate, u32 num_channels,
                                Stream::ReleaseCallback&& release_callback) {
-    streams.push_back(std::make_shared<Stream>(sample_rate, ChannelsToStreamFormat(num_channels),
-                                               std::move(release_callback)));
-    return streams.back();
+    if (!sink) {
+        const SinkDetails& sink_details = GetSinkDetails("auto");
+        sink = sink_details.factory("");
+    }
+
+    return std::make_shared<Stream>(sample_rate, ChannelsToStreamFormat(num_channels),
+                                    std::move(release_callback),
+                                    sink->AcquireSinkStream(sample_rate, num_channels));
 }
 
 std::vector<u64> AudioOut::GetTagsAndReleaseBuffers(StreamPtr stream, size_t max_count) {
diff --git a/src/audio_core/audio_out.h b/src/audio_core/audio_out.h
index 962360d09..8d9b695d4 100644
--- a/src/audio_core/audio_out.h
+++ b/src/audio_core/audio_out.h
@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "audio_core/buffer.h"
+#include "audio_core/sink.h"
 #include "audio_core/stream.h"
 #include "common/common_types.h"
 
@@ -36,7 +37,6 @@ public:
 
 private:
     SinkPtr sink;
-    std::vector<StreamPtr> streams;
 };
 
 } // namespace AudioCore
diff --git a/src/audio_core/cubeb_sink.cpp b/src/audio_core/cubeb_sink.cpp
new file mode 100644
index 000000000..34ae5b062
--- /dev/null
+++ b/src/audio_core/cubeb_sink.cpp
@@ -0,0 +1,190 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <cstring>
+
+#include "audio_core/cubeb_sink.h"
+#include "audio_core/stream.h"
+#include "common/logging/log.h"
+
+namespace AudioCore {
+
+class SinkStreamImpl final : public SinkStream {
+public:
+    SinkStreamImpl(cubeb* ctx, cubeb_devid output_device) : ctx{ctx} {
+        cubeb_stream_params params;
+        params.rate = 48000;
+        params.channels = GetNumChannels();
+        params.format = CUBEB_SAMPLE_S16NE;
+        params.layout = CUBEB_LAYOUT_STEREO;
+
+        u32 minimum_latency = 0;
+        if (cubeb_get_min_latency(ctx, &params, &minimum_latency) != CUBEB_OK) {
+            LOG_CRITICAL(Audio_Sink, "Error getting minimum latency");
+        }
+
+        if (cubeb_stream_init(ctx, &stream_backend, "yuzu Audio Output", nullptr, nullptr,
+                              output_device, &params, std::max(512u, minimum_latency),
+                              &SinkStreamImpl::DataCallback, &SinkStreamImpl::StateCallback,
+                              this) != CUBEB_OK) {
+            LOG_CRITICAL(Audio_Sink, "Error initializing cubeb stream");
+            return;
+        }
+
+        if (cubeb_stream_start(stream_backend) != CUBEB_OK) {
+            LOG_CRITICAL(Audio_Sink, "Error starting cubeb stream");
+            return;
+        }
+    }
+
+    ~SinkStreamImpl() {
+        if (!ctx) {
+            return;
+        }
+
+        if (cubeb_stream_stop(stream_backend) != CUBEB_OK) {
+            LOG_CRITICAL(Audio_Sink, "Error stopping cubeb stream");
+        }
+
+        cubeb_stream_destroy(stream_backend);
+    }
+
+    void EnqueueSamples(u32 num_channels, const s16* samples, size_t sample_count) override {
+        if (!ctx) {
+            return;
+        }
+
+        queue.reserve(queue.size() + sample_count * GetNumChannels());
+
+        if (num_channels == 2) {
+            // Copy as-is
+            std::copy(samples, samples + sample_count * GetNumChannels(),
+                      std::back_inserter(queue));
+        } else if (num_channels == 6) {
+            // Downsample 6 channels to 2
+            const size_t sample_count_copy_size = sample_count * num_channels * 2;
+            queue.reserve(sample_count_copy_size);
+            for (size_t i = 0; i < sample_count * num_channels; i += num_channels) {
+                queue.push_back(samples[i]);
+                queue.push_back(samples[i + 1]);
+            }
+        } else {
+            ASSERT_MSG(false, "Unimplemented");
+        }
+    }
+
+    u32 GetNumChannels() const {
+        // Only support 2-channel stereo output for now
+        return 2;
+    }
+
+private:
+    std::vector<std::string> device_list;
+
+    cubeb* ctx{};
+    cubeb_stream* stream_backend{};
+
+    std::vector<s16> queue;
+
+    static long DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
+                             void* output_buffer, long num_frames);
+    static void StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state);
+};
+
+CubebSink::CubebSink(std::string target_device_name) {
+    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& device) {
+                                               return target_device_name == device.friendly_name;
+                                           })};
+            if (device != collection_end) {
+                output_device = device->devid;
+            }
+            cubeb_device_collection_destroy(ctx, &collection);
+        }
+    }
+}
+
+CubebSink::~CubebSink() {
+    if (!ctx) {
+        return;
+    }
+
+    for (auto& sink_stream : sink_streams) {
+        sink_stream.reset();
+    }
+
+    cubeb_destroy(ctx);
+}
+
+SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels) {
+    sink_streams.push_back(std::make_unique<SinkStreamImpl>(ctx, output_device));
+    return *sink_streams.back();
+}
+
+long SinkStreamImpl::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
+                                  void* output_buffer, long num_frames) {
+    SinkStreamImpl* impl = static_cast<SinkStreamImpl*>(user_data);
+    u8* buffer = reinterpret_cast<u8*>(output_buffer);
+
+    if (!impl) {
+        return {};
+    }
+
+    const size_t frames_to_write{
+        std::min(impl->queue.size() / impl->GetNumChannels(), static_cast<size_t>(num_frames))};
+
+    memcpy(buffer, impl->queue.data(), frames_to_write * sizeof(s16) * impl->GetNumChannels());
+    impl->queue.erase(impl->queue.begin(),
+                      impl->queue.begin() + frames_to_write * impl->GetNumChannels());
+
+    if (frames_to_write < num_frames) {
+        // Fill the rest of the frames with silence
+        memset(buffer + frames_to_write * sizeof(s16) * impl->GetNumChannels(), 0,
+               (num_frames - frames_to_write) * sizeof(s16) * impl->GetNumChannels());
+    }
+
+    return num_frames;
+}
+
+void SinkStreamImpl::StateCallback(cubeb_stream* stream, void* user_data, cubeb_state state) {}
+
+std::vector<std::string> ListCubebSinkDevices() {
+    std::vector<std::string> device_list;
+    cubeb* ctx;
+
+    if (cubeb_init(&ctx, "Citra Device Enumerator", nullptr) != CUBEB_OK) {
+        LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
+        return {};
+    }
+
+    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 {
+        for (size_t i = 0; i < collection.count; i++) {
+            const cubeb_device_info& device = collection.device[i];
+            if (device.friendly_name) {
+                device_list.emplace_back(device.friendly_name);
+            }
+        }
+        cubeb_device_collection_destroy(ctx, &collection);
+    }
+
+    cubeb_destroy(ctx);
+    return device_list;
+}
+
+} // namespace AudioCore
diff --git a/src/audio_core/cubeb_sink.h b/src/audio_core/cubeb_sink.h
new file mode 100644
index 000000000..d07113f1f
--- /dev/null
+++ b/src/audio_core/cubeb_sink.h
@@ -0,0 +1,31 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <cubeb/cubeb.h>
+
+#include "audio_core/sink.h"
+
+namespace AudioCore {
+
+class CubebSink final : public Sink {
+public:
+    explicit CubebSink(std::string device_id);
+    ~CubebSink() override;
+
+    SinkStream& AcquireSinkStream(u32 sample_rate, u32 num_channels) override;
+
+private:
+    cubeb* ctx{};
+    cubeb_devid output_device{};
+    std::vector<SinkStreamPtr> sink_streams;
+};
+
+std::vector<std::string> ListCubebSinkDevices();
+
+} // namespace AudioCore
diff --git a/src/audio_core/sink_details.cpp b/src/audio_core/sink_details.cpp
index 6396d8065..955ba20fb 100644
--- a/src/audio_core/sink_details.cpp
+++ b/src/audio_core/sink_details.cpp
@@ -8,12 +8,18 @@
 #include <vector>
 #include "audio_core/null_sink.h"
 #include "audio_core/sink_details.h"
+#ifdef HAVE_CUBEB
+#include "audio_core/cubeb_sink.h"
+#endif
 #include "common/logging/log.h"
 
 namespace AudioCore {
 
 // g_sink_details is ordered in terms of desirability, with the best choice at the top.
 const std::vector<SinkDetails> g_sink_details = {
+#ifdef HAVE_CUBEB
+    SinkDetails{"cubeb", &std::make_unique<CubebSink, std::string>, &ListCubebSinkDevices},
+#endif
     SinkDetails{"null", &std::make_unique<NullSink, std::string>,
                 [] { return std::vector<std::string>{"null"}; }},
 };
diff --git a/src/audio_core/stream.cpp b/src/audio_core/stream.cpp
index 63edc6c8d..689f51a1d 100644
--- a/src/audio_core/stream.cpp
+++ b/src/audio_core/stream.cpp
@@ -7,6 +7,8 @@
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 
+#include "audio_core/sink.h"
+#include "audio_core/sink_details.h"
 #include "audio_core/stream.h"
 
 namespace AudioCore {
@@ -31,6 +33,11 @@ u32 Stream::GetSampleSize() const {
     return GetNumChannels() * 2;
 }
 
+Stream::Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
+               SinkStream& sink_stream)
+    : sample_rate{sample_rate}, format{format}, release_callback{std::move(release_callback)},
+      sink_stream{sink_stream} {
+
     release_event = CoreTiming::RegisterEvent(
         "Stream::Release", [this](u64 userdata, int cycles_late) { ReleaseActiveBuffer(); });
 }
@@ -68,6 +75,10 @@ void Stream::PlayNextBuffer() {
     active_buffer = queued_buffers.front();
     queued_buffers.pop();
 
+    sink_stream.EnqueueSamples(GetNumChannels(),
+                               reinterpret_cast<const s16*>(active_buffer->GetData().data()),
+                               active_buffer->GetData().size() / GetSampleSize());
+
     CoreTiming::ScheduleEventThreadsafe(GetBufferReleaseCycles(*active_buffer), release_event, {});
 }
 
diff --git a/src/audio_core/stream.h b/src/audio_core/stream.h
index 5c1005899..35253920e 100644
--- a/src/audio_core/stream.h
+++ b/src/audio_core/stream.h
@@ -10,6 +10,7 @@
 #include <queue>
 
 #include "audio_core/buffer.h"
+#include "audio_core/sink_stream.h"
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "core/core_timing.h"
@@ -31,7 +32,8 @@ public:
     /// Callback function type, used to change guest state on a buffer being released
     using ReleaseCallback = std::function<void()>;
 
-    Stream(int sample_rate, Format format, ReleaseCallback&& release_callback);
+    Stream(u32 sample_rate, Format format, ReleaseCallback&& release_callback,
+           SinkStream& sink_stream);
 
     /// Plays the audio stream
     void Play();
@@ -85,7 +87,7 @@ private:
     /// Gets the number of core cycles when the specified buffer will be released
     s64 GetBufferReleaseCycles(const Buffer& buffer) const;
 
-    int sample_rate;                        ///< Sample rate of the stream
+    u32 sample_rate;                        ///< Sample rate of the stream
     Format format;                          ///< Format of the stream
     ReleaseCallback release_callback;       ///< Buffer release callback for the stream
     State state{State::Stopped};            ///< Playback state of the stream
@@ -93,6 +95,7 @@ private:
     BufferPtr active_buffer;                ///< Actively playing buffer in the stream
     std::queue<BufferPtr> queued_buffers;   ///< Buffers queued to be played in the stream
     std::queue<BufferPtr> released_buffers; ///< Buffers recently released from the stream
+    SinkStream& sink_stream;                ///< Output sink for the stream
 };
 
 using StreamPtr = std::shared_ptr<Stream>;