Merge branch 'main' into metal

CMakeLists.txt

@@ -2,6 +2,7 @@ cmake_minimum_required(VERSION 3.21.1)
 
 option(ENABLE_VCPKG "Enable the vcpkg package manager" ON)
 option(MACOS_BUNDLE "The executable when built on macOS will be created as an application bundle" OFF)
+option(ALLOW_PORTABLE "Allow Cemu to be run in portable mode" ON)
 
 # used by CI script to set version:
 set(EMULATOR_VERSION_MAJOR "0" CACHE STRING "")

src/Cafe/CafeSystem.cpp

@@ -9,6 +9,7 @@
 #include "audio/IAudioAPI.h"
 #include "audio/IAudioInputAPI.h"
 #include "config/ActiveSettings.h"
+#include "config/LaunchSettings.h"
 #include "Cafe/TitleList/GameInfo.h"
 #include "Cafe/GraphicPack/GraphicPack2.h"
 #include "util/helpers/SystemException.h"
@@ -852,7 +853,7 @@ namespace CafeSystem
 			module->TitleStart();
 		cemu_initForGame();
 		// enter scheduler
-		if (ActiveSettings::GetCPUMode() == CPUMode::MulticoreRecompiler)
+		if (ActiveSettings::GetCPUMode() == CPUMode::MulticoreRecompiler && !LaunchSettings::ForceInterpreter())
 			coreinit::OSSchedulerBegin(3);
 		else
 			coreinit::OSSchedulerBegin(1);

src/Cafe/HW/Espresso/Debugger/Debugger.cpp

@@ -575,7 +575,7 @@ void debugger_enterTW(PPCInterpreter_t* hCPU)
 	debuggerState.debugSession.stepInto = false;
 	debuggerState.debugSession.stepOver = false;
 	debuggerState.debugSession.run = false;
-	while (true)
+	while (debuggerState.debugSession.isTrapped)
 	{
 		std::this_thread::sleep_for(std::chrono::milliseconds(1));
 		// check for step commands

src/Cafe/HW/Latte/Core/LatteShader.cpp

@@ -460,9 +460,8 @@ void LatteShader_DumpShader(uint64 baseHash, uint64 auxHash, LatteDecompilerShad
 		suffix = "gs";
 	else if (shader->shaderType == LatteConst::ShaderType::Pixel)
 		suffix = "ps";
-	fs::path dumpPath = "dump/shaders";
-	dumpPath /= fmt::format("{:016x}_{:016x}_{}.txt", baseHash, auxHash, suffix);
-	FileStream* fs = FileStream::createFile2(dumpPath);
+
+	FileStream* fs = FileStream::createFile2(ActiveSettings::GetUserDataPath("dump/shaders/{:016x}_{:016x}_{}.txt", baseHash, auxHash, suffix));
 	if (fs)
 	{
 		if (shader->strBuf_shaderSource)
@@ -488,9 +487,8 @@ void LatteShader_DumpRawShader(uint64 baseHash, uint64 auxHash, uint32 type, uin
 		suffix = "copy";
 	else if (type == SHADER_DUMP_TYPE_COMPUTE)
 		suffix = "compute";
-	fs::path dumpPath = "dump/shaders";
-	dumpPath /= fmt::format("{:016x}_{:016x}_{}.bin", baseHash, auxHash, suffix);
-	FileStream* fs = FileStream::createFile2(dumpPath);
+
+	FileStream* fs = FileStream::createFile2(ActiveSettings::GetUserDataPath("dump/shaders/{:016x}_{:016x}_{}.bin", baseHash, auxHash, suffix));
 	if (fs)
 	{
 		fs->writeData(programCode, programLen);

src/Cafe/HW/Latte/Core/LatteShaderCache.cpp

@@ -29,6 +29,9 @@
 #include "util/helpers/Serializer.h"
 
 #include <wx/msgdlg.h>
+#include <audio/IAudioAPI.h>
+#include <util/bootSound/BootSoundReader.h>
+#include <thread>
 
 #if BOOST_OS_WINDOWS
 #include <psapi.h>
@@ -159,6 +162,118 @@ bool LoadTGAFile(const std::vector<uint8>& buffer, TGAFILE *tgaFile)
 	return true;
 }
 
+class BootSoundPlayer
+{
+  public:
+	BootSoundPlayer() = default;
+	~BootSoundPlayer()
+	{
+		m_stopRequested = true;
+	}
+
+	void StartSound()
+	{
+		if (!m_bootSndPlayThread.joinable())
+		{
+			m_fadeOutRequested = false;
+			m_stopRequested = false;
+			m_bootSndPlayThread = std::thread{[this]() {
+				StreamBootSound();
+			}};
+		}
+	}
+
+	void FadeOutSound()
+	{
+		m_fadeOutRequested = true;
+	}
+
+	void ApplyFadeOutEffect(std::span<sint16> samples, uint64& fadeOutSample, uint64 fadeOutDuration)
+	{
+		for (size_t i = 0; i < samples.size(); i += 2)
+		{
+			const float decibel = (float)fadeOutSample / fadeOutDuration * -60.0f;
+			const float volumeFactor = pow(10, decibel / 20);
+			samples[i] *= volumeFactor;
+			samples[i + 1] *= volumeFactor;
+			fadeOutSample++;
+		}
+	}
+
+	void StreamBootSound()
+	{
+		SetThreadName("bootsnd");
+		constexpr sint32 sampleRate = 48'000;
+		constexpr sint32 bitsPerSample = 16;
+		constexpr sint32 samplesPerBlock = sampleRate / 10; // block is 1/10th of a second
+		constexpr sint32 nChannels = 2;
+		static_assert(bitsPerSample % 8 == 0, "bits per sample is not a multiple of 8");
+
+		AudioAPIPtr bootSndAudioDev;
+
+		try
+		{
+			bootSndAudioDev = IAudioAPI::CreateDeviceFromConfig(true, sampleRate, nChannels, samplesPerBlock, bitsPerSample);
+			if(!bootSndAudioDev)
+				return;
+		}
+		catch (const std::runtime_error& ex)
+		{
+			cemuLog_log(LogType::Force, "Failed to initialise audio device for bootup sound");
+			return;
+		}
+		bootSndAudioDev->SetAudioDelayOverride(4);
+		bootSndAudioDev->Play();
+
+		std::string sndPath = fmt::format("{}/meta/{}", CafeSystem::GetMlcStoragePath(CafeSystem::GetForegroundTitleId()), "bootSound.btsnd");
+		sint32 fscStatus = FSC_STATUS_UNDEFINED;
+
+		if(!fsc_doesFileExist(sndPath.c_str()))
+			return;
+
+		FSCVirtualFile* bootSndFileHandle = fsc_open(sndPath.c_str(), FSC_ACCESS_FLAG::OPEN_FILE | FSC_ACCESS_FLAG::READ_PERMISSION, &fscStatus);
+		if(!bootSndFileHandle)
+		{
+			cemuLog_log(LogType::Force, "failed to open bootSound.btsnd");
+			return;
+		}
+
+		constexpr sint32 audioBlockSize = samplesPerBlock * (bitsPerSample/8) * nChannels;
+		BootSoundReader bootSndFileReader(bootSndFileHandle, audioBlockSize);
+
+		uint64 fadeOutSample = 0; // track how far into the fadeout
+		constexpr uint64 fadeOutDuration = sampleRate * 2; // fadeout should last 2 seconds
+		while(fadeOutSample < fadeOutDuration && !m_stopRequested)
+		{
+			while (bootSndAudioDev->NeedAdditionalBlocks())
+			{
+				sint16* data = bootSndFileReader.getSamples();
+				if(data == nullptr)
+				{
+					// break outer loop
+					m_stopRequested = true;
+					break;
+				}
+				if(m_fadeOutRequested)
+					ApplyFadeOutEffect({data, samplesPerBlock * nChannels}, fadeOutSample, fadeOutDuration);
+
+				bootSndAudioDev->FeedBlock(data);
+			}
+			// sleep for the duration of a single block
+			std::this_thread::sleep_for(std::chrono::milliseconds(samplesPerBlock / (sampleRate/ 1'000)));
+		}
+
+		if(bootSndFileHandle)
+			fsc_close(bootSndFileHandle);
+	}
+
+  private:
+	std::thread m_bootSndPlayThread;
+	std::atomic_bool m_fadeOutRequested = false;
+	std::atomic_bool m_stopRequested = false;
+};
+static BootSoundPlayer g_bootSndPlayer;
+
 void LatteShaderCache_finish()
 {
     if (g_renderer->GetType() == RendererAPI::Vulkan)
@@ -316,6 +431,9 @@ void LatteShaderCache_Load()
 	loadBackgroundTexture(true, g_shaderCacheLoaderState.textureTVId);
 	loadBackgroundTexture(false, g_shaderCacheLoaderState.textureDRCId);
 
+	if(GetConfig().play_boot_sound)
+		g_bootSndPlayer.StartSound();
+
 	sint32 numLoadedShaders = 0;
 	uint32 loadIndex = 0;
 
@@ -382,6 +500,8 @@ void LatteShaderCache_Load()
 		g_renderer->DeleteTexture(g_shaderCacheLoaderState.textureTVId);
 	if (g_shaderCacheLoaderState.textureDRCId)
 		g_renderer->DeleteTexture(g_shaderCacheLoaderState.textureDRCId);
+
+	g_bootSndPlayer.FadeOutSound();
 }
 
 void LatteShaderCache_ShowProgress(const std::function <bool(void)>& loadUpdateFunc, bool isPipelines)
@@ -846,4 +966,4 @@ void LatteShaderCache_handleDeprecatedCacheFiles(fs::path pathGeneric, fs::path
 			fs::remove(pathGenericPre1_25_0, ec);
 		}
 	}
-}
+}

src/Cafe/OS/libs/snd_core/ax_out.cpp

@@ -396,90 +396,35 @@ namespace snd_core
 
 	void AXOut_init()
 	{
-		auto& config = GetConfig();
-		const auto audio_api = (IAudioAPI::AudioAPI)config.audio_api;
 
 		numQueuedFramesSndGeneric = 0;
 
 		std::unique_lock lock(g_audioMutex);
 		if (!g_tvAudio)
 		{
-			sint32 channels;
-			switch (config.tv_channels)
+			try
 			{
-			case 0:
-				channels = 1; // will mix mono sound on both output channels
-				break;
-			case 2:
-				channels = 6;
-				break;
-			default: // stereo
-				channels = 2;
-				break;
+				g_tvAudio = IAudioAPI::CreateDeviceFromConfig(true, 48000, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
 			}
-
-			IAudioAPI::DeviceDescriptionPtr device_description;
-			if (IAudioAPI::IsAudioAPIAvailable(audio_api))
-			{
-				auto devices = IAudioAPI::GetDevices(audio_api);
-				const auto it = std::find_if(devices.begin(), devices.end(), [&config](const auto& d) {return d->GetIdentifier() == config.tv_device; });
-				if (it != devices.end())
-					device_description = *it;
-			}
-
-			if (device_description)
+			catch (std::runtime_error& ex)
 			{
-				try
-				{
-					g_tvAudio = IAudioAPI::CreateDevice((IAudioAPI::AudioAPI)config.audio_api, device_description, 48000, channels, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
-					g_tvAudio->SetVolume(config.tv_volume);
-				}
-				catch (std::runtime_error& ex)
-				{
-					cemuLog_log(LogType::Force, "can't initialize tv audio: {}", ex.what());
-					exit(0);
-				}
+				cemuLog_log(LogType::Force, "can't initialize tv audio: {}", ex.what());
+				exit(0);
 			}
 		}
 
 		if (!g_padAudio)
 		{
-			sint32 channels;
-			switch (config.pad_channels)
+			try
 			{
-			case 0:
-				channels = 1; // will mix mono sound on both output channels
-				break;
-			case 2:
-				channels = 6;
-				break;
-			default: // stereo
-				channels = 2;
-				break;
+				g_padAudio = IAudioAPI::CreateDeviceFromConfig(false, 48000, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
+				if(g_padAudio)
+					g_padVolume = g_padAudio->GetVolume();
 			}
-
-			IAudioAPI::DeviceDescriptionPtr device_description;
-			if (IAudioAPI::IsAudioAPIAvailable(audio_api))
-			{
-				auto devices = IAudioAPI::GetDevices(audio_api);
-				const auto it = std::find_if(devices.begin(), devices.end(), [&config](const auto& d) {return d->GetIdentifier() == config.pad_device; });
-				if (it != devices.end())
-					device_description = *it;
-			}
-
-			if (device_description)
+			catch (std::runtime_error& ex)
 			{
-				try
-				{
-					g_padAudio = IAudioAPI::CreateDevice((IAudioAPI::AudioAPI)config.audio_api, device_description, 48000, channels, snd_core::AX_SAMPLES_PER_3MS_48KHZ * AX_FRAMES_PER_GROUP, 16);
-					g_padAudio->SetVolume(config.pad_volume);
-					g_padVolume = config.pad_volume;
-				}
-				catch (std::runtime_error& ex)
-				{
-					cemuLog_log(LogType::Force, "can't initialize pad audio: {}", ex.what());
-					exit(0);
-				}
+				cemuLog_log(LogType::Force, "can't initialize pad audio: {}", ex.what());
+				exit(0);
 			}
 		}
 	}

src/audio/CubebAPI.cpp

@@ -114,7 +114,7 @@ CubebAPI::~CubebAPI()
 bool CubebAPI::NeedAdditionalBlocks() const
 {
 	std::shared_lock lock(m_mutex);
-	return m_buffer.size() < s_audioDelay * m_bytesPerBlock;
+	return m_buffer.size() < GetAudioDelay() * m_bytesPerBlock;
 }
 
 bool CubebAPI::FeedBlock(sint16* data)

src/audio/DirectSoundAPI.cpp

@@ -210,7 +210,7 @@ void DirectSoundAPI::SetVolume(sint32 volume)
 bool DirectSoundAPI::NeedAdditionalBlocks() const
 {
 	std::shared_lock lock(m_mutex);
-	return m_buffer.size() < s_audioDelay;
+	return m_buffer.size() < GetAudioDelay();
 }
 
 std::vector<DirectSoundAPI::DeviceDescriptionPtr> DirectSoundAPI::GetDevices()

src/audio/IAudioAPI.cpp

@@ -97,7 +97,40 @@ bool IAudioAPI::IsAudioAPIAvailable(AudioAPI api)
 	return false;
 }
 
+AudioAPIPtr IAudioAPI::CreateDeviceFromConfig(bool TV, sint32 rate, sint32 samples_per_block, sint32 bits_per_sample)
+{
+	auto& config = GetConfig();
+	sint32 channels = CemuConfig::AudioChannelsToNChannels(TV ? config.tv_channels : config.pad_channels);
+	return CreateDeviceFromConfig(TV, rate, channels, samples_per_block, bits_per_sample);
+}
+
+AudioAPIPtr IAudioAPI::CreateDeviceFromConfig(bool TV, sint32 rate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample)
+{
+	AudioAPIPtr audioAPIDev;
+
+	auto& config = GetConfig();
 
+	const auto audio_api = (IAudioAPI::AudioAPI)config.audio_api;
+	auto& selectedDevice = TV ? config.tv_device : config.pad_device;
+
+	if(selectedDevice.empty())
+		return {};
+
+	IAudioAPI::DeviceDescriptionPtr device_description;
+	if (IAudioAPI::IsAudioAPIAvailable(audio_api))
+	{
+		auto devices = IAudioAPI::GetDevices(audio_api);
+		const auto it = std::find_if(devices.begin(), devices.end(), [&selectedDevice](const auto& d) {return d->GetIdentifier() == selectedDevice; });
+		if (it != devices.end())
+			device_description = *it;
+	}
+	if (!device_description)
+		throw std::runtime_error("failed to find selected device while trying to create audio device");
+
+	audioAPIDev = CreateDevice(audio_api, device_description, rate, channels, samples_per_block, bits_per_sample);
+	audioAPIDev->SetVolume(TV ? config.tv_volume : config.pad_volume);
+	return audioAPIDev;
+}
 
 AudioAPIPtr IAudioAPI::CreateDevice(AudioAPI api, const DeviceDescriptionPtr& device, sint32 samplerate, sint32 channels, sint32 samples_per_block, sint32 bits_per_sample)
 {
@@ -167,3 +200,12 @@ std::vector<IAudioAPI::DeviceDescriptionPtr> IAudioAPI::GetDevices(AudioAPI api)
 	}
 }
 
+void IAudioAPI::SetAudioDelayOverride(uint32 delay)
+{
+	m_audioDelayOverride = delay;
+}
+
+uint32 IAudioAPI::GetAudioDelay() const
+{
+	return m_audioDelayOverride > 0 ? m_audioDelayOverride : s_audioDelay;
+}