Implement audio output

include/audio/dsp_core.hpp

@@ -9,6 +9,7 @@
 #include "helpers.hpp"
 #include "logger.hpp"
 #include "scheduler.hpp"
+#include "ring_buffer.hpp"
 
 // The DSP core must have access to the DSP service to be able to trigger interrupts properly
 class DSPService;
@@ -23,16 +24,21 @@ namespace Audio {
 	static constexpr u64 lleSlice = 16384;
 
 	class DSPCore {
+		using Samples = Common::RingBuffer<s16, 1024>;
+
 	  protected:
 		Memory& mem;
 		Scheduler& scheduler;
 		DSPService& dspService;
 
+		Samples sampleBuffer;
+
 		MAKE_LOG_FUNCTION(log, dspLogger)
 
 	  public:
 		enum class Type { Null, Teakra };
-		DSPCore(Memory& mem, Scheduler& scheduler, DSPService& dspService) : mem(mem), scheduler(scheduler), dspService(dspService) {}
+		DSPCore(Memory& mem, Scheduler& scheduler, DSPService& dspService)
+			: mem(mem), scheduler(scheduler), dspService(dspService) {}
 
 		virtual void reset() = 0;
 		virtual void runAudioFrame() = 0;
@@ -49,6 +55,7 @@ namespace Audio {
 
 		static Audio::DSPCore::Type typeFromString(std::string inString);
 		static const char* typeToString(Audio::DSPCore::Type type);
+		Samples& getSamples() { return sampleBuffer; }
 	};
 
 	std::unique_ptr<DSPCore> makeDSPCore(DSPCore::Type type, Memory& mem, Scheduler& scheduler, DSPService& dspService);

include/audio/miniaudio_device.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include <string>
+#include <vector>
+
+#include "miniaudio.h"
+#include "ring_buffer.hpp"
+
+class MiniAudioDevice {
+	using Samples = Common::RingBuffer<ma_int16, 1024>;
+	// static constexpr ma_uint32 sampleRateIn = 32768; // 3DS sample rate
+	// static constexpr ma_uint32 sampleRateOut = 44100; // Output sample rate
+
+	ma_context context;
+	ma_device_config deviceConfig;
+	ma_device device;
+	ma_resampler resampler;
+	Samples* samples = nullptr;
+
+	bool initialized = false;
+	bool running = false;
+
+	std::vector<std::string> audioDevices;
+  public:
+	MiniAudioDevice();
+	// If safe is on, we create a null audio device
+	void init(Samples& samples, bool safe = false);
+	void start();
+};

include/emulator.hpp

@@ -8,6 +8,7 @@
 
 #include "PICA/gpu.hpp"
 #include "audio/dsp_core.hpp"
+#include "audio/miniaudio_device.hpp"
 #include "cheats.hpp"
 #include "config.hpp"
 #include "cpu.hpp"
@@ -47,6 +48,7 @@ class Emulator {
 	Scheduler scheduler;
 
 	Crypto::AESEngine aesEngine;
+	MiniAudioDevice audioDevice;
 	Cheats cheats;
 
 	// Variables to keep track of whether the user is controlling the 3DS analog stick with their keyboard

include/ring_buffer.hpp

@@ -0,0 +1,117 @@
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <cstddef>
+#include <cstring>
+#include <new>
+#include <span>
+#include <type_traits>
+#include <vector>
+
+namespace Common {
+
+/// SPSC ring buffer
+/// @tparam T            Element type
+/// @tparam capacity     Number of slots in ring buffer
+template <typename T, std::size_t capacity>
+class RingBuffer {
+    /// A "slot" is made of a single `T`.
+    static constexpr std::size_t slot_size = sizeof(T);
+    // T must be safely memcpy-able and have a trivial default constructor.
+    static_assert(std::is_trivial_v<T>);
+    // Ensure capacity is sensible.
+    static_assert(capacity < std::numeric_limits<std::size_t>::max() / 2);
+    static_assert((capacity & (capacity - 1)) == 0, "capacity must be a power of two");
+    // Ensure lock-free.
+    static_assert(std::atomic_size_t::is_always_lock_free);
+
+public:
+    /// Pushes slots into the ring buffer
+    /// @param new_slots   Pointer to the slots to push
+    /// @param slot_count  Number of slots to push
+    /// @returns The number of slots actually pushed
+    std::size_t push(const void* new_slots, std::size_t slot_count) {
+        const std::size_t write_index = m_write_index.load();
+        const std::size_t slots_free = capacity + m_read_index.load() - write_index;
+        const std::size_t push_count = std::min(slot_count, slots_free);
+
+        const std::size_t pos = write_index % capacity;
+        const std::size_t first_copy = std::min(capacity - pos, push_count);
+        const std::size_t second_copy = push_count - first_copy;
+
+        const char* in = static_cast<const char*>(new_slots);
+        std::memcpy(m_data.data() + pos, in, first_copy * slot_size);
+        in += first_copy * slot_size;
+        std::memcpy(m_data.data(), in, second_copy * slot_size);
+
+        m_write_index.store(write_index + push_count);
+
+        return push_count;
+    }
+
+    std::size_t push(std::span<const T> input) {
+        return push(input.data(), input.size());
+    }
+
+    /// Pops slots from the ring buffer
+    /// @param output     Where to store the popped slots
+    /// @param max_slots  Maximum number of slots to pop
+    /// @returns The number of slots actually popped
+    std::size_t pop(void* output, std::size_t max_slots = ~std::size_t(0)) {
+        const std::size_t read_index = m_read_index.load();
+        const std::size_t slots_filled = m_write_index.load() - read_index;
+        const std::size_t pop_count = std::min(slots_filled, max_slots);
+
+        const std::size_t pos = read_index % capacity;
+        const std::size_t first_copy = std::min(capacity - pos, pop_count);
+        const std::size_t second_copy = pop_count - first_copy;
+
+        char* out = static_cast<char*>(output);
+        std::memcpy(out, m_data.data() + pos, first_copy * slot_size);
+        out += first_copy * slot_size;
+        std::memcpy(out, m_data.data(), second_copy * slot_size);
+
+        m_read_index.store(read_index + pop_count);
+
+        return pop_count;
+    }
+
+    std::vector<T> pop(std::size_t max_slots = ~std::size_t(0)) {
+        std::vector<T> out(std::min(max_slots, capacity));
+        const std::size_t count = Pop(out.data(), out.size());
+        out.resize(count);
+        return out;
+    }
+
+    /// @returns Number of slots used
+    [[nodiscard]] std::size_t size() const {
+        return m_write_index.load() - m_read_index.load();
+    }
+
+    /// @returns Maximum size of ring buffer
+    [[nodiscard]] constexpr std::size_t Capacity() const {
+        return capacity;
+    }
+
+private:
+    // It is important to align the below variables for performance reasons:
+    // Having them on the same cache-line would result in false-sharing between them.
+    // TODO: Remove this ifdef whenever clang and GCC support
+    //       std::hardware_destructive_interference_size.
+#ifdef __cpp_lib_hardware_interference_size
+    alignas(std::hardware_destructive_interference_size) std::atomic_size_t m_read_index{0};
+    alignas(std::hardware_destructive_interference_size) std::atomic_size_t m_write_index{0};
+#else
+    alignas(128) std::atomic_size_t m_read_index{0};
+    alignas(128) std::atomic_size_t m_write_index{0};
+#endif
+
+    std::array<T, capacity> m_data;
+};
+
+} // namespace Common