Add DSP emulation interface

Co-Authored-By: PSISP <12768103+psi-rockin@users.noreply.github.com>

.gitmodules

@@ -55,3 +55,6 @@
 [submodule "third_party/libuv"]
 	path = third_party/libuv
 	url = https://github.com/libuv/libuv
+[submodule "third_party/teakra"]
+	path = third_party/teakra
+	url = https://github.com/wwylele/teakra

CMakeLists.txt

@@ -89,6 +89,7 @@ include_directories(third_party/toml11)
 include_directories(third_party/glm)
 
 add_subdirectory(third_party/cmrc)
+add_subdirectory(third_party/teakra EXCLUDE_FROM_ALL)
 
 set(BOOST_ROOT "${CMAKE_SOURCE_DIR}/third_party/boost")
 set(Boost_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/third_party/boost")
@@ -191,6 +192,7 @@ set(FS_SOURCE_FILES src/core/fs/archive_self_ncch.cpp src/core/fs/archive_save_d
 set(APPLET_SOURCE_FILES src/core/applets/applet.cpp src/core/applets/mii_selector.cpp src/core/applets/software_keyboard.cpp src/core/applets/applet_manager.cpp
                         src/core/applets/error_applet.cpp
 )
+set(AUDIO_SOURCE_FILES src/core/audio/dsp_core.cpp src/core/audio/null_core.cpp src/core/audio/teakra_core.cpp)
 set(RENDERER_SW_SOURCE_FILES src/core/renderer_sw/renderer_sw.cpp)
 
 # Frontend source files
@@ -247,6 +249,7 @@ set(HEADER_FILES include/emulator.hpp include/helpers.hpp include/termcolor.hpp
                  include/services/amiibo_device.hpp include/services/nfc_types.hpp include/swap.hpp include/services/csnd.hpp include/services/nwm_uds.hpp
                  include/fs/archive_system_save_data.hpp include/lua_manager.hpp include/memory_mapped_file.hpp include/hydra_icon.hpp
                  include/PICA/dynapica/shader_rec_emitter_arm64.hpp include/scheduler.hpp include/applets/error_applet.hpp
+                 include/audio/dsp_core.hpp include/audio/null_core.hpp include/audio/teakra_core.hpp
 )
 
 cmrc_add_resource_library(
@@ -299,6 +302,7 @@ source_group("Source Files\\Core\\Loader" FILES ${LOADER_SOURCE_FILES})
 source_group("Source Files\\Core\\Services" FILES ${SERVICE_SOURCE_FILES})
 source_group("Source Files\\Core\\Applets" FILES ${APPLET_SOURCE_FILES})
 source_group("Source Files\\Core\\PICA" FILES ${PICA_SOURCE_FILES})
+source_group("Source Files\\Core\\Audio" FILES ${AUDIO_SOURCE_FILES})
 source_group("Source Files\\Core\\Software Renderer" FILES ${RENDERER_SW_SOURCE_FILES})
 source_group("Source Files\\Third Party" FILES ${THIRD_PARTY_SOURCE_FILES})
 
@@ -397,7 +401,7 @@ endif()
 source_group("Header Files\\Core" FILES ${HEADER_FILES})
 set(ALL_SOURCES ${SOURCE_FILES} ${FRONTEND_SOURCE_FILES} ${FS_SOURCE_FILES} ${CRYPTO_SOURCE_FILES} ${KERNEL_SOURCE_FILES} 
     ${LOADER_SOURCE_FILES} ${SERVICE_SOURCE_FILES} ${APPLET_SOURCE_FILES} ${RENDERER_SW_SOURCE_FILES} ${PICA_SOURCE_FILES} ${THIRD_PARTY_SOURCE_FILES}
-    ${HEADER_FILES} ${FRONTEND_HEADER_FILES})
+    ${AUDIO_SOURCE_FILES} ${HEADER_FILES} ${FRONTEND_HEADER_FILES})
 
 if(ENABLE_OPENGL)
     # Add the OpenGL source files to ALL_SOURCES
@@ -429,7 +433,7 @@ if(ENABLE_LTO OR ENABLE_USER_BUILD)
     set_target_properties(Alber PROPERTIES INTERPROCEDURAL_OPTIMIZATION TRUE)
 endif()
 
-target_link_libraries(Alber PRIVATE dynarmic cryptopp glad resources_console_fonts)
+target_link_libraries(Alber PRIVATE dynarmic cryptopp glad resources_console_fonts teakra)
 
 if(NOT ANDROID)
     target_link_libraries(Alber PRIVATE SDL2-static)

include/audio/dsp_core.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include "helpers.hpp"
+#include "logger.hpp"
+#include "memory.hpp"
+
+namespace Audio {
+	class DSPCore {
+	  protected:
+		Memory& mem;
+		MAKE_LOG_FUNCTION(log, dspLogger)
+
+	  public:
+		enum class Type { Null, Teakra };
+		DSPCore(Memory& mem) : mem(mem) {}
+
+		virtual void reset() = 0;
+		virtual void runAudioFrame() = 0;
+		virtual u8* getDspMemory() = 0;
+
+		virtual u16 recvData(u32 regId) = 0;
+		virtual bool recvDataIsReady(u32 regId) = 0;
+		virtual void setSemaphore(u16 value) = 0;
+		virtual void writeProcessPipe(u32 channel, u32 size, u32 buffer) = 0;
+		virtual std::vector<u8> readPipe(u32 channel, u32 peer, u32 size, u32 buffer) = 0;
+		virtual void loadComponent(std::vector<u8>& data, u32 programMask, u32 dataMask) = 0;
+		virtual void unloadComponent() = 0;
+		virtual void setSemaphoreMask(u16 value) = 0;
+	};
+
+	std::unique_ptr<DSPCore> makeDSPCore(DSPCore::Type type, Memory& mem);
+}  // namespace Audio

include/audio/null_core.hpp

@@ -0,0 +1,41 @@
+#pragma once
+#include <array>
+#include "audio/dsp_core.hpp"
+
+namespace Audio {
+	class NullDSP : public DSPCore {
+		enum class DSPState : u32 {
+			Off,
+			On,
+			Slep,
+		};
+
+		// Number of DSP pipes
+		static constexpr size_t pipeCount = 8;
+		DSPState dspState;
+
+		std::array<std::vector<u8>, pipeCount> pipeData;  // The data of each pipe
+		std::array<u8, Memory::DSP_RAM_SIZE> dspRam;
+
+		void resetAudioPipe();
+
+	  public:
+		NullDSP(Memory& mem) : DSPCore(mem) {}
+
+		void reset() override;
+		void runAudioFrame() override {}
+		u8* getDspMemory() override { return dspRam.data(); }
+
+		u16 recvData(u32 regId) override;
+		bool recvDataIsReady(u32 regId) override { return true; } // Treat data as always ready
+		void writeProcessPipe(u32 channel, u32 size, u32 buffer) override;
+		std::vector<u8> readPipe(u32 channel, u32 peer, u32 size, u32 buffer) override;
+
+		// NOPs for null DSP core
+		void loadComponent(std::vector<u8>& data, u32 programMask, u32 dataMask) override {}
+		void unloadComponent() override {}
+		void setSemaphore(u16 value) override {}
+		void setSemaphoreMask(u16 value) override {}
+	};
+
+}  // namespace Audio

include/audio/teakra_core.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include "audio/dsp_core.hpp"
+#include "teakra/teakra.h"
+
+namespace Audio {
+	class TeakraDSP : public DSPCore {
+		Teakra::Teakra teakra;
+		u32 pipeBaseAddr;
+		bool running;
+
+	  public:
+		TeakraDSP(Memory& mem);
+
+		void reset() override;
+		void runAudioFrame() override;
+		u8* getDspMemory() override { return teakra.GetDspMemory().data(); }
+
+		u16 recvData(u32 regId) override { return teakra.RecvData(regId); }
+		bool recvDataIsReady(u32 regId) override { return teakra.RecvDataIsReady(regId); }
+		void setSemaphore(u16 value) override { return teakra.SetSemaphore(value); }
+		void setSemaphoreMask(u16 value) override { teakra.MaskSemaphore(value); }
+
+		void writeProcessPipe(u32 channel, u32 size, u32 buffer) override;
+		std::vector<u8> readPipe(u32 channel, u32 peer, u32 size, u32 buffer) override;
+		void loadComponent(std::vector<u8>& data, u32 programMask, u32 dataMask) override;
+		void unloadComponent() override;
+	};
+}  // namespace Audio

include/emulator.hpp

@@ -2,10 +2,12 @@
 
 #include <filesystem>
 #include <fstream>
+#include <memory>
 #include <optional>
 #include <span>
 
 #include "PICA/gpu.hpp"
+#include "audio/dsp_core.hpp"
 #include "cheats.hpp"
 #include "config.hpp"
 #include "cpu.hpp"
@@ -41,9 +43,11 @@ class Emulator {
 	GPU gpu;
 	Memory memory;
 	Kernel kernel;
+	std::unique_ptr<Audio::DSPCore> dsp;
+	Scheduler scheduler;
+
 	Crypto::AESEngine aesEngine;
 	Cheats cheats;
-	Scheduler scheduler;
 
 	// Variables to keep track of whether the user is controlling the 3DS analog stick with their keyboard
 	// This is done so when a gamepad is connected, we won't automatically override the 3DS analog stick settings with the gamepad's state

include/logger.hpp

@@ -36,6 +36,7 @@ namespace Log {
 	static Logger<false> gpuLogger;
 	static Logger<false> rendererLogger;
 	static Logger<false> shaderJITLogger;
+	static Logger<false> dspLogger;
 
 	// Service loggers
 	static Logger<false> acLogger;

include/memory.hpp

@@ -100,8 +100,8 @@ namespace KernelMemoryTypes {
 
 class Memory {
 	u8* fcram;
-	u8* dspRam;
+	u8* dspRam;  // Provided to us by Audio
-	u8* vram;  // Provided to the memory class by the GPU class
+	u8* vram;    // Provided to the memory class by the GPU class
 
 	u64& cpuTicks; // Reference to the CPU tick counter
 	using SharedMemoryBlock = KernelMemoryTypes::SharedMemoryBlock;
@@ -281,6 +281,8 @@ private:
 	u32 getUsedUserMem() { return usedUserMemory; }
 
 	void setVRAM(u8* pointer) { vram = pointer; }
+	void setDSPMem(u8* pointer) { dspRam = pointer; }
+
 	bool allocateMainThreadStack(u32 size);
 	Regions getConsoleRegion();
 	void copySharedFont(u8* ptr);

src/core/audio/dsp_core.cpp

@@ -0,0 +1,21 @@
+#include "audio/dsp_core.hpp"
+
+#include "audio/null_core.hpp"
+#include "audio/teakra_core.hpp"
+
+std::unique_ptr<Audio::DSPCore> Audio::makeDSPCore(DSPCore::Type type, Memory& mem) {
+	std::unique_ptr<DSPCore> core;
+
+	switch (type) {
+		case DSPCore::Type::Null: core = std::make_unique<NullDSP>(mem); break;
+		case DSPCore::Type::Teakra: core = std::make_unique<TeakraDSP>(mem); break;
+
+		default:
+			Helpers::warn("Invalid DSP core selected!");
+			core = std::make_unique<NullDSP>(mem);
+			break;
+	}
+
+	mem.setDSPMem(core->getDspMemory());
+	return core;
+}

src/core/audio/null_core.cpp

@@ -0,0 +1,129 @@
+#include "audio/null_core.hpp"
+
+namespace Audio {
+	namespace DSPPipeType {
+		enum : u32 {
+			Debug = 0,
+			DMA = 1,
+			Audio = 2,
+			Binary = 3,
+		};
+	}
+
+	void NullDSP::resetAudioPipe() {
+		// Hardcoded responses for now
+		// These are DSP DRAM offsets for various variables
+		// https://www.3dbrew.org/wiki/DSP_Memory_Region
+		static constexpr std::array<u16, 16> responses = {
+			0x000F,  // Number of responses
+			0xBFFF,  // Frame counter
+			0x9E92,  // Source configs
+			0x8680,  // Source statuses
+			0xA792,  // ADPCM coefficients
+			0x9430,  // DSP configs
+			0x8400,  // DSP status
+			0x8540,  // Final samples
+			0x9492,  // Intermediate mix samples
+			0x8710,  // Compressor
+			0x8410,  // Debug
+			0xA912,  // ??
+			0xAA12,  // ??
+			0xAAD2,  // ??
+			0xAC52,  // Surround sound biquad filter 1
+			0xAC5C   // Surround sound biquad filter 2
+		};
+
+		std::vector<u8>& audioPipe = pipeData[DSPPipeType::Audio];
+		audioPipe.resize(responses.size() * sizeof(u16));
+
+		// Push back every response to the audio pipe
+		size_t index = 0;
+		for (auto e : responses) {
+			audioPipe[index++] = e & 0xff;
+			audioPipe[index++] = e >> 8;
+		}
+	}
+
+	void NullDSP::reset() {
+		for (auto& e : pipeData) e.clear();
+
+		// Note: Reset audio pipe AFTER resetting all pipes, otherwise the new data will be yeeted
+		resetAudioPipe();
+	}
+	
+	u16 NullDSP::recvData(u32 regId) {
+		if (regId != 0) {
+			Helpers::panic("Audio: invalid register in null frontend");
+		}
+
+		return dspState == DSPState::On;
+	}
+
+	void NullDSP::writeProcessPipe(u32 channel, u32 size, u32 buffer) {
+		enum class StateChange : u8 {
+			Initialize = 0,
+			Shutdown = 1,
+			Wakeup = 2,
+			Sleep = 3,
+		};
+
+		switch (channel) {
+			case DSPPipeType::Audio: {
+				if (size != 4) {
+					printf("Invalid size written to DSP Audio Pipe\n");
+					break;
+				}
+
+				// Get new state
+				const u8 state = mem.read8(buffer);
+				if (state > 3) {
+					log("WriteProcessPipe::Audio: Unknown state change type");
+				} else {
+					switch (static_cast<StateChange>(state)) {
+						case StateChange::Initialize:
+							// TODO: Other initialization stuff here
+							dspState = DSPState::On;
+							resetAudioPipe();
+							break;
+
+						case StateChange::Shutdown:
+							dspState = DSPState::Off;
+							break;
+
+						default: Helpers::panic("Unimplemented DSP audio pipe state change %d", state);
+					}
+				}
+				break;
+			}
+
+			case DSPPipeType::Binary:
+				Helpers::warn("Unimplemented write to binary pipe! Size: %d\n", size);
+				break;
+
+			default: log("Audio::NullDSP: Wrote to unimplemented pipe %d\n", channel); break;
+		}
+	}
+
+	std::vector<u8> NullDSP::readPipe(u32 pipe, u32 peer, u32 size, u32 buffer) {
+		if (size & 1) Helpers::panic("Tried to read odd amount of bytes from DSP pipe");
+		if (pipe >= pipeCount || size > 0xffff) {
+			return {};
+		}
+
+		if (pipe != DSPPipeType::Audio) {
+			log("Reading from non-audio pipe! This might be broken, might need to check what pipe is being read from and implement writing to it\n");
+		}
+
+		std::vector<u8>& data = pipeData[pipe];
+		size = std::min<u32>(size, data.size());  // Clamp size to the maximum available data size
+
+		if (size == 0) {
+			return {};
+		}
+
+		// Return "size" bytes from the audio pipe and erase them
+		std::vector<u8> out(data.begin(), data.begin() + size);
+		data.erase(data.begin(), data.begin() + size);
+		return out;
+	}
+}  // namespace Audio

src/core/audio/teakra_core.cpp

@@ -0,0 +1,150 @@
+#include "audio/teakra_core.hpp"
+
+using namespace Audio;
+
+struct Dsp1 {
+	// All sizes are in bytes unless otherwise specified
+
+	u8 signature[0x100];
+	u8 magic[4];
+	u32 size;
+	u8 codeMemLayout;
+	u8 dataMemLayout;
+	u8 pad[3];
+	u8 specialType;
+	u8 segmentCount;
+	u8 flags;
+	u32 specialStart;
+	u32 specialSize;
+	u64 zeroBits;
+
+	struct Segment {
+		u32 offs;     // Offset of the segment data
+		u32 dspAddr;  // Start of the segment in 16-bit units
+		u32 size;
+		u8 pad[3];
+		u8 type;
+		u8 hash[0x20];
+	};
+
+	Segment segments[10];
+};
+
+TeakraDSP::TeakraDSP(Memory& mem) : DSPCore(mem), pipeBaseAddr(0), running(false) {
+	teakra.Reset();
+
+	// Set up callbacks for Teakra
+	Teakra::AHBMCallback ahbm;
+
+	ahbm.read8 = [&](u32 addr) -> u8 { return mem.read8(addr); };
+	ahbm.read16 = [&](u32 addr) -> u16 { return mem.read16(addr); };
+	ahbm.read32 = [&](u32 addr) -> u32 { return mem.read32(addr); };
+
+	ahbm.write8 = [&](u32 addr, u8 value) { mem.write8(addr, value); };
+	ahbm.write16 = [&](u32 addr, u16 value) { mem.write16(addr, value); };
+	ahbm.write32 = [&](u32 addr, u32 value) { mem.write32(addr, value); };
+
+	teakra.SetAHBMCallback(ahbm);
+	teakra.SetAudioCallback([=](std::array<s16, 2> sample) {
+		// NOP for now
+	});
+}
+
+void TeakraDSP::reset() {
+	teakra.Reset();
+	running = false;
+}
+
+void TeakraDSP::runAudioFrame() {
+	if (running) {
+		teakra.Run(16384);
+	}
+}
+
+void TeakraDSP::writeProcessPipe(u32 channel, u32 size, u32 buffer) {
+	// TODO
+}
+
+std::vector<u8> TeakraDSP::readPipe(u32 channel, u32 peer, u32 size, u32 buffer) {
+	// TODO
+	return std::vector<u8>();
+}
+
+void TeakraDSP::loadComponent(std::vector<u8>& data, u32 programMask, u32 dataMask) {
+	// TODO: maybe move this to the DSP service
+
+	u8* dspCode = teakra.GetDspMemory().data();
+	u8* dspData = dspCode + 0x40000;
+
+	Dsp1 dsp1;
+	memcpy(&dsp1, data.data(), sizeof(dsp1));
+
+	// TODO: verify DSP1 signature
+
+	// Load DSP segments to DSP RAM
+	// TODO: verify hashes
+	for (unsigned int i = 0; i < dsp1.segmentCount; i++) {
+		auto& segment = dsp1.segments[i];
+		u32 addr = segment.dspAddr << 1;
+		u8* src = data.data() + segment.offs;
+		u8* dst = nullptr;
+
+		switch (segment.type) {
+			case 0:
+			case 1: dst = dspCode + addr; break;
+			default: dst = dspData + addr; break;
+		}
+
+		memcpy(dst, src, segment.size);
+	}
+
+	bool syncWithDsp = dsp1.flags & 0x1;
+	bool loadSpecialSegment = (dsp1.flags >> 1) & 0x1;
+
+	// TODO: how does the special segment work?
+	if (loadSpecialSegment) {
+		log("LoadComponent: special segment not supported");
+	}
+
+	running = true;
+
+	if (syncWithDsp) {
+		// Wait for the DSP to reply with 1s in all RECV registers
+		for (int i = 0; i < 3; i++) {
+			do {
+				while (!teakra.RecvDataIsReady(i)) {
+					runAudioFrame();
+				}
+			} while (teakra.RecvData(i) != 1);
+		}
+	}
+
+	// Retrieve the pipe base address
+	while (!teakra.RecvDataIsReady(2)) {
+		runAudioFrame();
+	}
+
+	pipeBaseAddr = teakra.RecvData(2);
+}
+
+void TeakraDSP::unloadComponent() {
+	if (!running) {
+		Helpers::panic("Audio: unloadComponent called without a running program");
+	}
+
+	// Wait for SEND2 to be ready, then send the shutdown command to the DSP
+	while (!teakra.SendDataIsEmpty(2)) {
+		runAudioFrame();
+	}
+
+	teakra.SendData(2, 0x8000);
+
+	// Wait for shutdown to be acknowledged
+	while (!teakra.RecvDataIsReady(2)) {
+		runAudioFrame();
+	}
+
+	// Read the value and discard it, completing shutdown
+	teakra.RecvData(2);
+	running = false;
+}

src/core/memory.cpp

@@ -15,7 +15,6 @@ using namespace KernelMemoryTypes;
 
 Memory::Memory(u64& cpuTicks, const EmulatorConfig& config) : cpuTicks(cpuTicks), config(config) {
 	fcram = new uint8_t[FCRAM_SIZE]();
-	dspRam = new uint8_t[DSP_RAM_SIZE]();
 
 	readTable.resize(totalPageCount, 0);
 	writeTable.resize(totalPageCount, 0);

src/emulator.cpp

@@ -24,6 +24,8 @@ Emulator::Emulator()
 	  httpServer(this)
 #endif
 {
+	dsp = Audio::makeDSPCore(Audio::DSPCore::Type::Null, memory);
+
 #ifdef PANDA3DS_ENABLE_DISCORD_RPC
 	if (config.discordRpcEnabled) {
 		discordRpc.init();

third_party/teakra

@@ -0,0 +1 @@
+Subproject commit 01db7cdd00aabcce559a8dddce8798dabb71949b