thirdpartymirrors/UnleashedRecomp
1
0
Fork 0
mirror of https://github.com/hedge-dev/UnleashedRecomp.git synced 2026-04-27 21:01:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Replace miniaudio with SDL mixer.

Browse source
This commit is contained in:
Skyth 2024-12-19 16:28:11 +03:00
parent 8e602837e8
commit 41d25ba891
10 changed files with 110 additions and 279 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
.gitmodules vendored
View file

@ -16,9 +16,6 @@
[submodule "thirdparty/msdf-atlas-gen"] [submodule "thirdparty/msdf-atlas-gen"]
path = thirdparty/msdf-atlas-gen path = thirdparty/msdf-atlas-gen
url = https://github.com/Chlumsky/msdf-atlas-gen.git url = https://github.com/Chlumsky/msdf-atlas-gen.git
[submodule "thirdparty/miniaudio"]
path = thirdparty/miniaudio
url = https://github.com/mackron/miniaudio
[submodule "thirdparty/vcpkg"] [submodule "thirdparty/vcpkg"]
path = thirdparty/vcpkg path = thirdparty/vcpkg
url = https://github.com/microsoft/vcpkg url = https://github.com/microsoft/vcpkg
@ -58,9 +55,6 @@
[submodule "thirdparty/unordered_dense"] [submodule "thirdparty/unordered_dense"]
path = thirdparty/unordered_dense path = thirdparty/unordered_dense
url = https://github.com/martinus/unordered_dense.git url = https://github.com/martinus/unordered_dense.git
[submodule "thirdparty/vorbis"] [submodule "thirdparty/SDL_mixer"]
path = thirdparty/vorbis path = thirdparty/SDL_mixer
url = https://gitlab.xiph.org/xiph/vorbis.git url = https://github.com/libsdl-org/SDL_mixer
[submodule "thirdparty/ogg"]
path = thirdparty/ogg
url = https://gitlab.xiph.org/xiph/ogg.git

5
UnleashedRecomp/CMakeLists.txt
View file

@ -314,10 +314,11 @@ target_link_libraries(UnleashedRecomp PRIVATE
o1heap o1heap
PowerUtils PowerUtils
SDL2::SDL2-static SDL2::SDL2-static
SDL2_mixer
tomlplusplus::tomlplusplus tomlplusplus::tomlplusplus
UnleashedRecompLib UnleashedRecompLib
Vorbis::vorbisfile xxHash::xxhash
xxHash::xxhash ) )
target_include_directories(UnleashedRecomp PRIVATE target_include_directories(UnleashedRecomp PRIVATE
${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}

257
UnleashedRecomp/apu/embedded_player.cpp
View file

@ -10,82 +10,6 @@
#include <res/sounds/sys_actstg_pausewinclose.ogg.h> #include <res/sounds/sys_actstg_pausewinclose.ogg.h>
#include <res/sounds/sys_actstg_pausewinopen.ogg.h> #include <res/sounds/sys_actstg_pausewinopen.ogg.h>
#pragma region libvorbis
static ma_result ma_decoding_backend_init__libvorbis(void* pUserData, ma_read_proc onRead, ma_seek_proc onSeek, ma_tell_proc onTell, void* pReadSeekTellUserData, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
{
ma_result result;
ma_libvorbis* pVorbis;
(void)pUserData;
pVorbis = (ma_libvorbis*)ma_malloc(sizeof(*pVorbis), pAllocationCallbacks);
if (pVorbis == NULL) {
return MA_OUT_OF_MEMORY;
}
result = ma_libvorbis_init(onRead, onSeek, onTell, pReadSeekTellUserData, pConfig, pAllocationCallbacks, pVorbis);
if (result != MA_SUCCESS) {
ma_free(pVorbis, pAllocationCallbacks);
return result;
}
*ppBackend = pVorbis;
return MA_SUCCESS;
}
static ma_result ma_decoding_backend_init_file__libvorbis(void* pUserData, const char* pFilePath, const ma_decoding_backend_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_data_source** ppBackend)
{
ma_result result;
ma_libvorbis* pVorbis;
(void)pUserData;
pVorbis = (ma_libvorbis*)ma_malloc(sizeof(*pVorbis), pAllocationCallbacks);
if (pVorbis == NULL) {
return MA_OUT_OF_MEMORY;
}
result = ma_libvorbis_init_file(pFilePath, pConfig, pAllocationCallbacks, pVorbis);
if (result != MA_SUCCESS) {
ma_free(pVorbis, pAllocationCallbacks);
return result;
}
*ppBackend = pVorbis;
return MA_SUCCESS;
}
static void ma_decoding_backend_uninit__libvorbis(void* pUserData, ma_data_source* pBackend, const ma_allocation_callbacks* pAllocationCallbacks)
{
ma_libvorbis* pVorbis = (ma_libvorbis*)pBackend;
(void)pUserData;
ma_libvorbis_uninit(pVorbis, pAllocationCallbacks);
ma_free(pVorbis, pAllocationCallbacks);
}
static ma_result ma_decoding_backend_get_channel_map__libvorbis(void* pUserData, ma_data_source* pBackend, ma_channel* pChannelMap, size_t channelMapCap)
{
ma_libvorbis* pVorbis = (ma_libvorbis*)pBackend;
(void)pUserData;
return ma_libvorbis_get_data_format(pVorbis, NULL, NULL, NULL, pChannelMap, channelMapCap);
}
static ma_decoding_backend_vtable g_ma_decoding_backend_vtable_libvorbis =
{
ma_decoding_backend_init__libvorbis,
ma_decoding_backend_init_file__libvorbis,
NULL, /* onInitFileW() */
NULL, /* onInitMemory() */
ma_decoding_backend_uninit__libvorbis
};
#pragma endregion
enum class EmbeddedSound enum class EmbeddedSound
{ {
SysWorldMapCursor, SysWorldMapCursor,
@ -101,12 +25,10 @@ enum class EmbeddedSound
struct EmbeddedSoundData struct EmbeddedSoundData
{ {
static const int SimultaneousLimit = 4; static const int SimultaneousLimit = 4;
std::array<std::unique_ptr<ma_sound>, SimultaneousLimit> sounds; Mix_Chunk* chunk{};
std::array<std::unique_ptr<ma_decoder>, SimultaneousLimit> decoders; int channelIndex{};
int oldestIndex = 0;
}; };
static ma_engine g_audioEngine = {};
static std::array<EmbeddedSoundData, size_t(EmbeddedSound::Count)> g_embeddedSoundData = {}; static std::array<EmbeddedSoundData, size_t(EmbeddedSound::Count)> g_embeddedSoundData = {};
static const std::unordered_map<std::string_view, EmbeddedSound> g_embeddedSoundMap = static const std::unordered_map<std::string_view, EmbeddedSound> g_embeddedSoundMap =
{ {
@ -122,111 +44,56 @@ static const std::unordered_map<std::string_view, EmbeddedSound> g_embeddedSound
static void PlayEmbeddedSound(EmbeddedSound s) static void PlayEmbeddedSound(EmbeddedSound s)
{ {
EmbeddedSoundData &data = g_embeddedSoundData[size_t(s)]; EmbeddedSoundData &data = g_embeddedSoundData[size_t(s)];
int pickedIndex = -1; if (data.chunk == nullptr)
for (int i = 0; (i < EmbeddedSoundData::SimultaneousLimit) && (pickedIndex < 0); i++)
{ {
if (data.sounds[i] == nullptr) // The sound hasn't been created yet, create it and pick it.
const void *soundData = nullptr;
size_t soundDataSize = 0;
switch (s)
{ {
// The sound hasn't been created yet, create it and pick it. case EmbeddedSound::SysWorldMapCursor:
const void *soundData = nullptr; soundData = g_sys_worldmap_cursor;
size_t soundDataSize = 0; soundDataSize = sizeof(g_sys_worldmap_cursor);
switch (s) break;
{ case EmbeddedSound::SysWorldMapFinalDecide:
case EmbeddedSound::SysWorldMapCursor: soundData = g_sys_worldmap_finaldecide;
soundData = g_sys_worldmap_cursor; soundDataSize = sizeof(g_sys_worldmap_finaldecide);
soundDataSize = sizeof(g_sys_worldmap_cursor); break;
break; case EmbeddedSound::SysActStgPauseCansel:
case EmbeddedSound::SysWorldMapFinalDecide: soundData = g_sys_actstg_pausecansel;
soundData = g_sys_worldmap_finaldecide; soundDataSize = sizeof(g_sys_actstg_pausecansel);
soundDataSize = sizeof(g_sys_worldmap_finaldecide); break;
break; case EmbeddedSound::SysActStgPauseCursor:
case EmbeddedSound::SysActStgPauseCansel: soundData = g_sys_actstg_pausecursor;
soundData = g_sys_actstg_pausecansel; soundDataSize = sizeof(g_sys_actstg_pausecursor);
soundDataSize = sizeof(g_sys_actstg_pausecansel); break;
break; case EmbeddedSound::SysActStgPauseDecide:
case EmbeddedSound::SysActStgPauseCursor: soundData = g_sys_actstg_pausedecide;
soundData = g_sys_actstg_pausecursor; soundDataSize = sizeof(g_sys_actstg_pausedecide);
soundDataSize = sizeof(g_sys_actstg_pausecursor); break;
break; case EmbeddedSound::SysActStgPauseWinClose:
case EmbeddedSound::SysActStgPauseDecide: soundData = g_sys_actstg_pausewinclose;
soundData = g_sys_actstg_pausedecide; soundDataSize = sizeof(g_sys_actstg_pausewinclose);
soundDataSize = sizeof(g_sys_actstg_pausedecide); break;
break; case EmbeddedSound::SysActStgPauseWinOpen:
case EmbeddedSound::SysActStgPauseWinClose: soundData = g_sys_actstg_pausewinopen;
soundData = g_sys_actstg_pausewinclose; soundDataSize = sizeof(g_sys_actstg_pausewinopen);
soundDataSize = sizeof(g_sys_actstg_pausewinclose); break;
break; default:
case EmbeddedSound::SysActStgPauseWinOpen: assert(false && "Unknown embedded sound.");
soundData = g_sys_actstg_pausewinopen; return;
soundDataSize = sizeof(g_sys_actstg_pausewinopen);
break;
default:
assert(false && "Unknown embedded sound.");
return;
}
ma_decoding_backend_vtable* pCustomBackendVTables[] =
{
&g_ma_decoding_backend_vtable_libvorbis
};
ma_decoder_config decoderConfig = ma_decoder_config_init_default();
decoderConfig.pCustomBackendUserData = NULL;
decoderConfig.ppCustomBackendVTables = pCustomBackendVTables;
decoderConfig.customBackendCount = std::size(pCustomBackendVTables);
ma_result res;
data.decoders[i] = std::make_unique<ma_decoder>();
res = ma_decoder_init_memory(soundData, soundDataSize, &decoderConfig, data.decoders[i].get());
if (res != MA_SUCCESS)
{
fprintf(stderr, "ma_decoder_init_memory failed with error code %d.\n", res);
return;
}
data.sounds[i] = std::make_unique<ma_sound>();
res = ma_sound_init_from_data_source(&g_audioEngine, data.decoders[i].get(), MA_SOUND_FLAG_DECODE, nullptr, data.sounds[i].get());
if (res != MA_SUCCESS)
{
fprintf(stderr, "ma_sound_init_from_data_source failed with error code %d.\n", res);
return;
}
pickedIndex = i;
}
else if (ma_sound_at_end(data.sounds[i].get()))
{
// A sound has reached the end, pick it.
pickedIndex = i;
} }
data.chunk = Mix_LoadWAV_RW(SDL_RWFromConstMem(soundData, soundDataSize), 1);
} }
if (pickedIndex < 0) Mix_PlayChannel(data.channelIndex % EmbeddedSoundData::SimultaneousLimit, data.chunk, 0);
{ ++data.channelIndex;
// No free slots are available, pick the oldest one.
pickedIndex = data.oldestIndex;
data.oldestIndex = (data.oldestIndex + 1) % EmbeddedSoundData::SimultaneousLimit;
}
if (data.sounds[pickedIndex] != nullptr)
{
ma_sound_set_volume(data.sounds[pickedIndex].get(), Config::EffectsVolume);
ma_sound_seek_to_pcm_frame(data.sounds[pickedIndex].get(), 0);
ma_sound_start(data.sounds[pickedIndex].get());
}
} }
void EmbeddedPlayer::Init() void EmbeddedPlayer::Init()
{ {
ma_engine_config engineConfig = ma_engine_config_init(); Mix_OpenAudio(XAUDIO_SAMPLES_HZ, AUDIO_F32SYS, XAUDIO_NUM_CHANNELS, 256);
engineConfig.channels = XAUDIO_NUM_CHANNELS;
engineConfig.sampleRate = XAUDIO_SAMPLES_HZ;
ma_result res = ma_engine_init(&engineConfig, &g_audioEngine);
if (res != MA_SUCCESS)
{
fprintf(stderr, "ma_engine_init failed with error code %d.\n", res);
}
s_isActive = true; s_isActive = true;
} }
@ -241,11 +108,6 @@ void EmbeddedPlayer::Play(const char *name)
return; return;
} }
if (g_audioEngine.pDevice == nullptr)
{
return;
}
PlayEmbeddedSound(it->second); PlayEmbeddedSound(it->second);
} }
@ -253,37 +115,12 @@ void EmbeddedPlayer::Shutdown()
{ {
for (EmbeddedSoundData &data : g_embeddedSoundData) for (EmbeddedSoundData &data : g_embeddedSoundData)
{ {
for (auto &sound : data.sounds) if (data.chunk != nullptr)
{ Mix_FreeChunk(data.chunk);
if (sound != nullptr)
{
if (sound->pDataSource != nullptr)
{
ma_sound_uninit(sound.get());
}
sound.reset();
}
}
for (auto &decoder : data.decoders)
{
if (decoder != nullptr)
{
if (decoder->pBackend != nullptr)
{
ma_decoder_uninit(decoder.get());
}
decoder.reset();
}
}
} }
if (g_audioEngine.pDevice != nullptr) Mix_CloseAudio();
{ Mix_Quit();
ma_engine_uninit(&g_audioEngine);
}
s_isActive = false; s_isActive = false;
} }

6
UnleashedRecomp/stdafx.cpp
View file

@ -1,10 +1,4 @@
#define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h> #include <stb_image.h>
#define MINIAUDIO_IMPLEMENTATION
#include <miniaudio.h>
#define ma_offset_pcm_frames_ptr (char*)ma_offset_pcm_frames_ptr
#include <extras/miniaudio_libvorbis.h>
#include "stdafx.h" #include "stdafx.h"

3
UnleashedRecomp/stdafx.h
View file

@ -36,6 +36,7 @@ using Microsoft::WRL::ComPtr;
#include <stb_image.h> #include <stb_image.h>
#include <blockingconcurrentqueue.h> #include <blockingconcurrentqueue.h>
#include <SDL.h> #include <SDL.h>
#include <SDL_mixer.h>
#include <imgui.h> #include <imgui.h>
#include <imgui_internal.h> #include <imgui_internal.h>
#include <backends/imgui_impl_sdl2.h> #include <backends/imgui_impl_sdl2.h>
@ -43,8 +44,6 @@ using Microsoft::WRL::ComPtr;
#include <cstddef> #include <cstddef>
#include <smolv.h> #include <smolv.h>
#include <set> #include <set>
#include <miniaudio.h>
#include <extras/miniaudio_libvorbis.h>
#include <fmt/core.h> #include <fmt/core.h>
#include <list> #include <list>

12
thirdparty/CMakeLists.txt vendored
View file

@ -3,9 +3,17 @@ set(MSDF_ATLAS_USE_SKIA OFF)
set(MSDF_ATLAS_NO_ARTERY_FONT ON) set(MSDF_ATLAS_NO_ARTERY_FONT ON)
set(MSDFGEN_DISABLE_PNG ON) set(MSDFGEN_DISABLE_PNG ON)
set(SDL2MIXER_VENDORED ON)
set(SDL2MIXER_FLAC OFF)
set(SDL2MIXER_MOD OFF)
set(SDL2MIXER_MP3 OFF)
set(SDL2MIXER_MIDI OFF)
set(SDL2MIXER_OPUS OFF)
set(SDL2MIXER_VORBIS "VORBISFILE")
set(SDL2MIXER_WAVPACK OFF)
add_subdirectory("${SWA_THIRDPARTY_ROOT}/msdf-atlas-gen") add_subdirectory("${SWA_THIRDPARTY_ROOT}/msdf-atlas-gen")
add_subdirectory("${SWA_THIRDPARTY_ROOT}/nativefiledialog-extended") add_subdirectory("${SWA_THIRDPARTY_ROOT}/nativefiledialog-extended")
add_subdirectory("${SWA_THIRDPARTY_ROOT}/ogg")
add_subdirectory("${SWA_THIRDPARTY_ROOT}/o1heap") add_subdirectory("${SWA_THIRDPARTY_ROOT}/o1heap")
add_subdirectory("${SWA_THIRDPARTY_ROOT}/SDL") add_subdirectory("${SWA_THIRDPARTY_ROOT}/SDL")
add_subdirectory("${SWA_THIRDPARTY_ROOT}/vorbis") add_subdirectory("${SWA_THIRDPARTY_ROOT}/SDL_mixer")

1
thirdparty/SDL_mixer vendored Submodule

@ -0,0 +1 @@
Subproject commit 437992692cf9300f2b2f04be35adc7445a9055bf

1
thirdparty/miniaudio vendored

@ -1 +0,0 @@
Subproject commit 12a8d4e4911c5ab4f4c089b4d039433975ed8a66

1
thirdparty/ogg vendored

@ -1 +0,0 @@
Subproject commit 7cf42ea17aef7bc1b7b21af70724840a96c2e7d0

1
thirdparty/vorbis vendored

@ -1 +0,0 @@
Subproject commit 84c023699cdf023a32fa4ded32019f194afcdad0