diff --git a/CMakeLists.txt b/CMakeLists.txt index 1cdda09..c0b70d2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -165,6 +165,8 @@ set (SOURCES ${CMAKE_SOURCE_DIR}/src/game/recomp_data_api.cpp ${CMAKE_SOURCE_DIR}/src/game/rom_decompression.cpp + ${CMAKE_SOURCE_DIR}/src/audio/sound_matrix_decoder.cpp + ${CMAKE_SOURCE_DIR}/src/ui/ui_renderer.cpp ${CMAKE_SOURCE_DIR}/src/ui/ui_state.cpp ${CMAKE_SOURCE_DIR}/src/ui/ui_launcher.cpp diff --git a/assets/config_menu/sound.rml b/assets/config_menu/sound.rml index badadce..30fa2c7 100644 --- a/assets/config_menu/sound.rml +++ b/assets/config_menu/sound.rml @@ -52,7 +52,7 @@ data-checked="low_health_beeps_enabled" value="1" id="lhb_on" - style="nav-up: #bgm_volume_input" + style="nav-up: #bgm_volume_input; nav-down: #surround_on;" /> @@ -64,11 +64,40 @@ data-checked="low_health_beeps_enabled" value="0" id="lhb_off" - style="nav-up: #bgm_volume_input" + style="nav-up: #bgm_volume_input; nav-down: #surround_on;" /> + +
+ +
+ + + + + +
+
@@ -81,6 +110,9 @@

Toggles whether or not the low-health beeping sound plays.

+

+ Enables 5.1 surround sound output using matrix decoding. Requires a surround sound system or virtual surround headphones. +

diff --git a/include/audio_channels.h b/include/audio_channels.h new file mode 100644 index 0000000..2dbcb22 --- /dev/null +++ b/include/audio_channels.h @@ -0,0 +1,21 @@ +#pragma once + +typedef enum AudioChannelsSetting { + audioStereo, + audioMatrix51, + audioRaw51, + audioMax +} AudioChannelsSetting; + +inline const char* AudioChannelsSettingName(AudioChannelsSetting setting) { + switch (setting) { + case audioStereo: + return "Stereo"; + case audioMatrix51: + return "5.1 Matrix"; + case audioRaw51: + return "5.1 Raw"; + default: + return "Unknown"; + } +} diff --git a/include/zelda_sound.h b/include/zelda_sound.h index 33bec01..fb1a652 100644 --- a/include/zelda_sound.h +++ b/include/zelda_sound.h @@ -9,6 +9,8 @@ namespace zelda64 { int get_bgm_volume(); void set_low_health_beeps_enabled(bool enabled); bool get_low_health_beeps_enabled(); + void set_surround_sound_enabled(bool enabled); + bool get_surround_sound_enabled(); } #endif diff --git a/patches/skip_sos.c b/patches/skip_sos.c index 3b1c0fa..0352d5f 100644 --- a/patches/skip_sos.c +++ b/patches/skip_sos.c @@ -24,6 +24,6 @@ RECOMP_PATCH void EnTest7_Update(Actor* thisx, PlayState* play) { // @recomp Allow skipping the Song of Soaring cutscene. Input* input = CONTROLLER1(&play->state); if (CHECK_BTN_ANY(input->press.button, BTN_A | BTN_B) && (OWL_WARP_CS_GET_OCARINA_MODE(&this->actor) != ENTEST7_ARRIVE)) { - func_80AF2350(thisx, play); + func_80AF2350(this, play); } } \ No newline at end of file diff --git a/patches/sound.h b/patches/sound.h index 0e05637..e194559 100644 --- a/patches/sound.h +++ b/patches/sound.h @@ -6,4 +6,9 @@ DECLARE_FUNC(float, recomp_get_bgm_volume); DECLARE_FUNC(u32, recomp_get_low_health_beeps_enabled); +// Surround sound support +// Audio channel settings: 0 = Stereo, 1 = 5.1 Matrix, 2 = 5.1 Raw +DECLARE_FUNC(void, recomp_set_audio_channels, s32 channels); +DECLARE_FUNC(s32, recomp_get_audio_channels); + #endif diff --git a/patches/sound_patches.c b/patches/sound_patches.c index 504f9ec..453df4c 100644 --- a/patches/sound_patches.c +++ b/patches/sound_patches.c @@ -5,6 +5,13 @@ void AudioSeq_ProcessSeqCmd(u32 cmd); void AudioThread_QueueCmd(u32 opArgs, void** data); +// Audio channel settings (must match AudioChannelsSetting enum in native code) +typedef enum { + AUDIO_CHANNELS_STEREO = 0, + AUDIO_CHANNELS_MATRIX_51 = 1, + AUDIO_CHANNELS_RAW_51 = 2 +} AudioChannelsSetting; + // Direct audio command (skips the queueing system) #define SEQCMD_SET_SEQPLAYER_VOLUME_NOW(seqPlayerIndex, duration, volume) \ AudioSeq_ProcessSeqCmd((SEQCMD_OP_SET_SEQPLAYER_VOLUME << 28) | ((u8)(seqPlayerIndex) << 24) | \ @@ -360,4 +367,40 @@ RECOMP_PATCH void LifeMeter_UpdateSizeAndBeep(PlayState* play) { } } } +extern s8 sSoundMode; +// @recomp Surround sound output is now controlled by the recomp's config menu +// (Sound -> Surround Sound 5.1), not by the in-game audio setting. +// This function still controls the game's internal sound processing mode. +RECOMP_PATCH void Audio_SetFileSelectSettings(s8 audioSetting) { + s8 soundMode; + + switch (audioSetting) { + case SAVE_AUDIO_STEREO: + soundMode = SOUNDMODE_STEREO; + sSoundMode = SOUNDMODE_STEREO; + break; + + case SAVE_AUDIO_MONO: + soundMode = SOUNDMODE_MONO; + sSoundMode = SOUNDMODE_MONO; + break; + + case SAVE_AUDIO_HEADSET: + soundMode = SOUNDMODE_HEADSET; + sSoundMode = SOUNDMODE_HEADSET; + break; + + case SAVE_AUDIO_SURROUND: + soundMode = SOUNDMODE_SURROUND; + // @recomp Use external surround mode - the actual 5.1 output is handled + // by the matrix decoder when enabled in the recomp's config menu + sSoundMode = SOUNDMODE_SURROUND_EXTERNAL; + break; + + default: + break; + } + + SEQCMD_SET_SOUND_MODE(soundMode); +} diff --git a/patches/syms.ld b/patches/syms.ld index 2efa2c9..e076507 100644 --- a/patches/syms.ld +++ b/patches/syms.ld @@ -53,3 +53,5 @@ recomp_create_actor_data = 0x8F0000C8; recomp_destroy_actor_data = 0x8F0000CC; recomp_get_actor_data = 0x8F0000D0; recomp_get_actor_spawn_index = 0x8F0000D4; +recomp_set_audio_channels = 0x8F0000D8; +recomp_get_audio_channels = 0x8F0000DC; diff --git a/src/audio/sound_matrix_decoder.cpp b/src/audio/sound_matrix_decoder.cpp new file mode 100644 index 0000000..49831f4 --- /dev/null +++ b/src/audio/sound_matrix_decoder.cpp @@ -0,0 +1,277 @@ +#include "sound_matrix_decoder.h" + +// Standard matrix decoding gains derived from psychoacoustic principles +namespace Gains { +constexpr float gCenter = 0.7071067811865476f * 0.5f; // -3dB (1/sqrt(2)) * 0.5 +constexpr float gFront = 0.5f; // -6dB +constexpr float gSurroundPrimary = 0.4359f; // Primary surround contribution +constexpr float gSurroundSecondary = 0.2449f; // Cross-feed surround contribution +} // namespace Gains + +// Timing constants +namespace Timing { +constexpr int gSurroundDelayMs = 10; // ITU-R BS.775 recommends 10-25ms +} + +SoundMatrixDecoder::SoundMatrixDecoder(int32_t sampleRate) { + // Compute delay length from sample rate + mDelayLength = (sampleRate * Timing::gSurroundDelayMs) / 1000; + if (mDelayLength > gMaxDelay) { + mDelayLength = gMaxDelay; + } + + // Precompute base rate for all-pass sweep + mAllPassBaseRate = std::pow(std::pow(2.0, 4.0), 0.1 / (sampleRate / 2.0)); + + // Design filters for this sample rate + mCoefCenterHP = DesignHighPass(70.0, sampleRate); // Remove rumble from center + mCoefCenterLP = DesignLowPass(20000.0, sampleRate); // Anti-alias center + mCoefSurroundHP = DesignHighPass(100.0, sampleRate); // Surround channels high-passed + mCoefSubLP = DesignLowPass(120.0, sampleRate); // LFE low-pass + + // Initialize phase chains with sample rate + mPhaseLeftMain = {}; + mPhaseLeftCross = {}; + mPhaseRightMain = {}; + mPhaseRightCross = {}; + PrepareAllPass(mPhaseLeftMain, sampleRate); + PrepareAllPass(mPhaseLeftCross, sampleRate); + PrepareAllPass(mPhaseRightMain, sampleRate); + PrepareAllPass(mPhaseRightCross, sampleRate); + + // Reset filter states + ResetState(); +} + +void SoundMatrixDecoder::ResetState() { + // Clear all filter states + mCenterHighPass = {}; + mCenterLowPass = {}; + mSurrLeftMainHP = {}; + mSurrLeftCrossHP = {}; + mSurrRightMainHP = {}; + mSurrRightCrossHP = {}; + mSubLowPass = {}; + + // Reset delay lines + mDelaySurrLeft = {}; + mDelaySurrLeft.Length = mDelayLength; + mDelaySurrRight = {}; + mDelaySurrRight.Length = mDelayLength; +} + +SoundMatrixDecoder::FilterCoefficients SoundMatrixDecoder::DesignLowPass(double frequency, int32_t sampleRate) { + FilterCoefficients coef = {}; + + // Clamp to safe range for bilinear transform stability + double maxFreq = sampleRate * 0.475; + if (frequency > maxFreq) { + frequency = maxFreq; + } + + // Linkwitz-Riley 4th order: two cascaded Butterworth 2nd order + double omega = 2.0 * M_PI * frequency; + double omega2 = omega * omega; + double omega3 = omega2 * omega; + double omega4 = omega2 * omega2; + + // Bilinear transform warping + double kVal = omega / std::tan(M_PI * frequency / sampleRate); + double k2 = kVal * kVal; + double k3 = k2 * kVal; + double k4 = k2 * k2; + + double rt2 = std::sqrt(2.0); + double term1 = rt2 * omega3 * kVal; + double term2 = rt2 * omega * k3; + double norm = 4.0 * omega2 * k2 + 2.0 * term1 + k4 + 2.0 * term2 + omega4; + + // Feedback coefficients + coef.B[0] = (4.0 * (omega4 + term1 - k4 - term2)) / norm; + coef.B[1] = (6.0 * omega4 - 8.0 * omega2 * k2 + 6.0 * k4) / norm; + coef.B[2] = (4.0 * (omega4 - term1 + term2 - k4)) / norm; + coef.B[3] = (k4 - 2.0 * term1 + omega4 - 2.0 * term2 + 4.0 * omega2 * k2) / norm; + + // Feedforward coefficients (low-pass response) + coef.A[0] = omega4 / norm; + coef.A[1] = 4.0 * omega4 / norm; + coef.A[2] = 6.0 * omega4 / norm; + coef.A[3] = coef.A[1]; + coef.A[4] = coef.A[0]; + + return coef; +} + +SoundMatrixDecoder::FilterCoefficients SoundMatrixDecoder::DesignHighPass(double frequency, int32_t sampleRate) { + FilterCoefficients coef = {}; + + double omega = 2.0 * M_PI * frequency; + double omega2 = omega * omega; + double omega3 = omega2 * omega; + double omega4 = omega2 * omega2; + + double kVal = omega / std::tan(M_PI * frequency / sampleRate); + double k2 = kVal * kVal; + double k3 = k2 * kVal; + double k4 = k2 * k2; + + double rt2 = std::sqrt(2.0); + double term1 = rt2 * omega3 * kVal; + double term2 = rt2 * omega * k3; + double norm = 4.0 * omega2 * k2 + 2.0 * term1 + k4 + 2.0 * term2 + omega4; + + coef.B[0] = (4.0 * (omega4 + term1 - k4 - term2)) / norm; + coef.B[1] = (6.0 * omega4 - 8.0 * omega2 * k2 + 6.0 * k4) / norm; + coef.B[2] = (4.0 * (omega4 - term1 + term2 - k4)) / norm; + coef.B[3] = (k4 - 2.0 * term1 + omega4 - 2.0 * term2 + 4.0 * omega2 * k2) / norm; + + // Feedforward coefficients (high-pass response) + coef.A[0] = k4 / norm; + coef.A[1] = -4.0 * k4 / norm; + coef.A[2] = 6.0 * k4 / norm; + coef.A[3] = coef.A[1]; + coef.A[4] = coef.A[0]; + + return coef; +} + +float SoundMatrixDecoder::ProcessFilter(float sample, BiquadCascade& state, const FilterCoefficients& coef) { + double in = sample; + double out = coef.A[0] * in + coef.A[1] * state.X[0] + coef.A[2] * state.X[1] + coef.A[3] * state.X[2] + + coef.A[4] * state.X[3] - coef.B[0] * state.Y[0] - coef.B[1] * state.Y[1] - coef.B[2] * state.Y[2] - + coef.B[3] * state.Y[3]; + + // Shift history + state.X[3] = state.X[2]; + state.X[2] = state.X[1]; + state.X[1] = state.X[0]; + state.X[0] = in; + state.Y[3] = state.Y[2]; + state.Y[2] = state.Y[1]; + state.Y[1] = state.Y[0]; + state.Y[0] = out; + + return static_cast(out); +} + +void SoundMatrixDecoder::PrepareAllPass(AllPassChain& chain, int32_t sampleRate) { + // Sweeping all-pass parameters for decorrelation + constexpr double depth = 4.0; + constexpr double baseDelay = 100.0; + constexpr double sweepSpeed = 0.1; + + chain.FreqMin = (M_PI * baseDelay) / sampleRate; + chain.Freq = chain.FreqMin; + + double range = std::pow(2.0, depth); + chain.FreqMax = (M_PI * baseDelay * range) / sampleRate; + chain.SweepRate = std::pow(range, sweepSpeed / (sampleRate / 2.0)); + chain.Ready = true; +} + +float SoundMatrixDecoder::ProcessAllPass(float sample, AllPassChain& chain, bool negate) { + // First-order all-pass coefficient + double c = (1.0 - chain.Freq) / (1.0 + chain.Freq); + double input = static_cast(sample); + + // Cascade of 4 first-order all-pass sections + chain.YHist[0] = c * (chain.YHist[0] + input) - chain.XHist[0]; + chain.XHist[0] = input; + + chain.YHist[1] = c * (chain.YHist[1] + chain.YHist[0]) - chain.XHist[1]; + chain.XHist[1] = chain.YHist[0]; + + chain.YHist[2] = c * (chain.YHist[2] + chain.YHist[1]) - chain.XHist[2]; + chain.XHist[2] = chain.YHist[1]; + + chain.YHist[3] = c * (chain.YHist[3] + chain.YHist[2]) - chain.XHist[3]; + chain.XHist[3] = chain.YHist[2]; + + double result = negate ? -chain.YHist[3] : chain.YHist[3]; + + // Sweep the frequency for time-varying decorrelation + chain.Freq *= chain.SweepRate; + + if (chain.Freq > chain.FreqMax) { + chain.SweepRate = 1.0 / mAllPassBaseRate; + } else if (chain.Freq < chain.FreqMin) { + chain.SweepRate = mAllPassBaseRate; + } + + return static_cast(result); +} + +float SoundMatrixDecoder::ProcessDelay(float sample, CircularDelay& buffer) { + float output = buffer.Data[buffer.Head]; + buffer.Data[buffer.Head] = sample; + buffer.Head = (buffer.Head + 1) % buffer.Length; + return output; +} + +float SoundMatrixDecoder::Saturate(float value) { + if (value > 1.0f) { + return 1.0f; + } + if (value < -1.0f) { + return -1.0f; + } + return value; +} + +std::tuple SoundMatrixDecoder::Process(const float* stereoInput, size_t samplePairs) { + // Resize output buffer if needed (6 channels per sample pair) + size_t samplesNeeded = samplePairs * 6; + if (mSurroundBuffer.size() < samplesNeeded) { + mSurroundBuffer.resize(samplesNeeded); + } + + for (size_t i = 0; i < samplePairs; ++i) { + float inL = stereoInput[i * 2]; + float inR = stereoInput[i * 2 + 1]; + + // Center: sum of L+R, band-limited + float ctr = (inL + inR) * Gains::gCenter; + ctr = ProcessFilter(ctr, mCenterHighPass, mCoefCenterHP); + ctr = ProcessFilter(ctr, mCenterLowPass, mCoefCenterLP); + + // Front channels: attenuated direct signal + float frontL = inL * Gains::gFront; + float frontR = inR * Gains::gFront; + + // Surround Left: L primary (inverted phase) + R secondary (shifted phase) + float slMain = inL * Gains::gSurroundPrimary; + slMain = ProcessFilter(slMain, mSurrLeftMainHP, mCoefSurroundHP); + slMain = ProcessAllPass(slMain, mPhaseLeftMain, true); + + float slCross = inR * Gains::gSurroundSecondary; + slCross = ProcessFilter(slCross, mSurrLeftCrossHP, mCoefSurroundHP); + slCross = ProcessAllPass(slCross, mPhaseLeftCross, false); + + float surrL = ProcessDelay(slMain + slCross, mDelaySurrLeft); + + // Surround Right: R primary (shifted phase) + L secondary (inverted phase) + float srMain = inR * Gains::gSurroundPrimary; + srMain = ProcessFilter(srMain, mSurrRightMainHP, mCoefSurroundHP); + srMain = ProcessAllPass(srMain, mPhaseRightMain, false); + + float srCross = inL * Gains::gSurroundSecondary; + srCross = ProcessFilter(srCross, mSurrRightCrossHP, mCoefSurroundHP); + srCross = ProcessAllPass(srCross, mPhaseRightCross, true); + + float surrR = ProcessDelay(srMain + srCross, mDelaySurrRight); + + // LFE: low-passed sum + float lfe = (inL + inR) * Gains::gCenter; + lfe = ProcessFilter(lfe, mSubLowPass, mCoefSubLP); + + // Output: FL, FR, C, LFE, SL, SR + mSurroundBuffer[i * 6 + 0] = Saturate(frontL); + mSurroundBuffer[i * 6 + 1] = Saturate(frontR); + mSurroundBuffer[i * 6 + 2] = Saturate(ctr); + mSurroundBuffer[i * 6 + 3] = Saturate(lfe); + mSurroundBuffer[i * 6 + 4] = Saturate(surrL); + mSurroundBuffer[i * 6 + 5] = Saturate(surrR); + } + + return { mSurroundBuffer.data(), samplesNeeded }; +} diff --git a/src/game/config.cpp b/src/game/config.cpp index 17ff9e4..f00bc09 100644 --- a/src/game/config.cpp +++ b/src/game/config.cpp @@ -460,6 +460,7 @@ bool save_sound_config(const std::filesystem::path& path) { config_json["main_volume"] = zelda64::get_main_volume(); config_json["bgm_volume"] = zelda64::get_bgm_volume(); config_json["low_health_beeps"] = zelda64::get_low_health_beeps_enabled(); + config_json["surround_sound"] = zelda64::get_surround_sound_enabled(); return save_json_with_backups(path, config_json); } @@ -474,6 +475,7 @@ bool load_sound_config(const std::filesystem::path& path) { call_if_key_exists(zelda64::set_main_volume, config_json, "main_volume"); call_if_key_exists(zelda64::set_bgm_volume, config_json, "bgm_volume"); call_if_key_exists(zelda64::set_low_health_beeps_enabled, config_json, "low_health_beeps"); + call_if_key_exists(zelda64::set_surround_sound_enabled, config_json, "surround_sound"); return true; } diff --git a/src/game/recomp_api.cpp b/src/game/recomp_api.cpp index 9ad08be..222f7e1 100644 --- a/src/game/recomp_api.cpp +++ b/src/game/recomp_api.cpp @@ -13,6 +13,11 @@ #include "../patches/sound.h" #include "ultramodern/ultramodern.hpp" #include "ultramodern/config.hpp" +#include "audio_channels.h" + +// Forward declarations for audio channel functions defined in main.cpp +void set_audio_channels(AudioChannelsSetting channels); +AudioChannelsSetting get_audio_channels(); extern "C" void recomp_update_inputs(uint8_t* rdram, recomp_context* ctx) { recomp::poll_inputs(); @@ -177,3 +182,17 @@ extern "C" void recomp_set_right_analog_suppressed(uint8_t* rdram, recomp_contex recomp::set_right_analog_suppressed(suppressed); } + +// Surround sound support +extern "C" void recomp_set_audio_channels(uint8_t* rdram, recomp_context* ctx) { + s32 channels = _arg<0, s32>(rdram, ctx); + + // Validate input + if (channels >= 0 && channels < audioMax) { + set_audio_channels(static_cast(channels)); + } +} + +extern "C" void recomp_get_audio_channels(uint8_t* rdram, recomp_context* ctx) { + _return(ctx, static_cast(get_audio_channels())); +} diff --git a/src/main/main.cpp b/src/main/main.cpp index 6c8262a..ba95b76 100644 --- a/src/main/main.cpp +++ b/src/main/main.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include "nfd.h" @@ -45,6 +46,9 @@ #include "../../patches/sound.h" #include "../../patches/misc_funcs.h" +#include "audio_channels.h" +#include "sound_matrix_decoder.h" + #include "mods/mm_recomp_dpad_builtin.h" #ifdef _WIN32 @@ -188,6 +192,10 @@ static uint32_t output_sample_rate = 48000; constexpr uint32_t input_channels = 2; static uint32_t output_channels = 2; +// Surround sound support +static AudioChannelsSetting audio_channel_setting = audioStereo; +static std::unique_ptr sound_matrix_decoder; + // Terminology: a frame is a collection of samples for each channel. e.g. 2 input samples is one input frame. This is unrelated to graphical frames. // Number of frames to duplicate for fixing interpolation at the start and end of a chunk. @@ -241,25 +249,64 @@ void queue_samples(int16_t* audio_data, size_t sample_count) { throw std::runtime_error("Error using SDL audio converter"); } - uint64_t cur_queued_microseconds = uint64_t(SDL_GetQueuedAudioSize(audio_device)) / bytes_per_frame * 1000000 / sample_rate; - uint32_t num_bytes_to_queue = audio_convert.len_cvt - output_channels * discarded_output_frames * sizeof(swap_buffer[0]); - float* samples_to_queue = swap_buffer.data() + output_channels * discarded_output_frames / 2; + // Calculate the number of stereo frames after resampling (for both stereo and surround paths) + size_t resampled_stereo_frames = audio_convert.len_cvt / sizeof(float) / input_channels; + size_t frames_after_discard = resampled_stereo_frames - discarded_output_frames; + float* stereo_samples = swap_buffer.data() + discarded_output_frames / 2; - // Prevent audio latency from building up by skipping samples in incoming audio when too many samples are already queued. - // Skip samples based on how many microseconds of samples are queued already. - uint32_t skip_factor = cur_queued_microseconds / 100000; - if (skip_factor != 0) { - uint32_t skip_ratio = 1 << skip_factor; - num_bytes_to_queue /= skip_ratio; - for (size_t i = 0; i < num_bytes_to_queue / (output_channels * sizeof(swap_buffer[0])); i++) { - samples_to_queue[2 * i + 0] = samples_to_queue[2 * skip_ratio * i + 0]; - samples_to_queue[2 * i + 1] = samples_to_queue[2 * skip_ratio * i + 1]; + // Handle surround sound matrix decoding + if (audio_channel_setting == audioMatrix51 && sound_matrix_decoder) { + static int surround_frame_count = 0; + if (surround_frame_count < 3) { + printf("Audio: Processing surround frame %d (matrix decoding active, %zu stereo frames)\n", + ++surround_frame_count, frames_after_discard); } - } + // Process stereo through the matrix decoder to get 5.1 surround + auto [surround_samples, surround_sample_count] = sound_matrix_decoder->Process(stereo_samples, frames_after_discard); + + uint64_t cur_queued_microseconds = uint64_t(SDL_GetQueuedAudioSize(audio_device)) / (6 * sizeof(float)) * 1000000 / output_sample_rate; + uint32_t num_bytes_to_queue = surround_sample_count * sizeof(float); - // Queue the swapped audio data. - // Offset the data start by only half the discarded frame count as the other half of the discarded frames are at the end of the buffer. - SDL_QueueAudio(audio_device, samples_to_queue, num_bytes_to_queue); + // Prevent audio latency from building up by skipping frames + uint32_t skip_factor = cur_queued_microseconds / 100000; + if (skip_factor != 0) { + uint32_t skip_ratio = 1 << skip_factor; + size_t frames_to_queue = surround_sample_count / 6; + size_t new_frames = frames_to_queue / skip_ratio; + // Surround buffer is const, so we need to copy to a temp buffer for skipping + static std::vector skip_buffer; + skip_buffer.resize(new_frames * 6); + for (size_t i = 0; i < new_frames; i++) { + for (size_t ch = 0; ch < 6; ch++) { + skip_buffer[i * 6 + ch] = surround_samples[i * skip_ratio * 6 + ch]; + } + } + SDL_QueueAudio(audio_device, skip_buffer.data(), new_frames * 6 * sizeof(float)); + } else { + SDL_QueueAudio(audio_device, surround_samples, num_bytes_to_queue); + } + } else { + // Stereo path (original behavior) + uint64_t cur_queued_microseconds = uint64_t(SDL_GetQueuedAudioSize(audio_device)) / bytes_per_frame * 1000000 / sample_rate; + uint32_t num_bytes_to_queue = audio_convert.len_cvt - output_channels * discarded_output_frames * sizeof(swap_buffer[0]); + float* samples_to_queue = swap_buffer.data() + output_channels * discarded_output_frames / 2; + + // Prevent audio latency from building up by skipping samples in incoming audio when too many samples are already queued. + // Skip samples based on how many microseconds of samples are queued already. + uint32_t skip_factor = cur_queued_microseconds / 100000; + if (skip_factor != 0) { + uint32_t skip_ratio = 1 << skip_factor; + num_bytes_to_queue /= skip_ratio; + for (size_t i = 0; i < num_bytes_to_queue / (output_channels * sizeof(swap_buffer[0])); i++) { + samples_to_queue[2 * i + 0] = samples_to_queue[2 * skip_ratio * i + 0]; + samples_to_queue[2 * i + 1] = samples_to_queue[2 * skip_ratio * i + 1]; + } + } + + // Queue the swapped audio data. + // Offset the data start by only half the discarded frame count as the other half of the discarded frames are at the end of the buffer. + SDL_QueueAudio(audio_device, samples_to_queue, num_bytes_to_queue); + } } size_t get_frames_remaining() { @@ -304,6 +351,26 @@ void set_frequency(uint32_t freq) { } void reset_audio(uint32_t output_freq) { + // Close existing audio device if open + if (audio_device != 0) { + SDL_PauseAudioDevice(audio_device, 1); + SDL_ClearQueuedAudio(audio_device); + SDL_CloseAudioDevice(audio_device); + audio_device = 0; + } + + // Set output channels based on audio channel setting + switch (audio_channel_setting) { + case audioMatrix51: + case audioRaw51: + output_channels = 6; + break; + case audioStereo: + default: + output_channels = 2; + break; + } + SDL_AudioSpec spec_desired{ .freq = (int)output_freq, .format = AUDIO_F32, @@ -316,7 +383,6 @@ void reset_audio(uint32_t output_freq) { .userdata = nullptr }; - audio_device = SDL_OpenAudioDevice(nullptr, false, &spec_desired, nullptr, 0); if (audio_device == 0) { exit_error("SDL error opening audio device: %s\n", SDL_GetError()); @@ -325,6 +391,37 @@ void reset_audio(uint32_t output_freq) { output_sample_rate = output_freq; update_audio_converter(); + + printf("Audio initialized: %d channels, %d Hz (%s)\n", output_channels, output_freq, AudioChannelsSettingName(audio_channel_setting)); +} + +AudioChannelsSetting get_audio_channels() { + return audio_channel_setting; +} + +void set_audio_channels(AudioChannelsSetting channels) { + if (audio_channel_setting == channels) { + return; // No change needed + } + + printf("Changing audio channels from %s to %s\n", + AudioChannelsSettingName(audio_channel_setting), + AudioChannelsSettingName(channels)); + + audio_channel_setting = channels; + + // Setup or teardown sound matrix decoder + if (channels == audioMatrix51) { + if (!sound_matrix_decoder) { + sound_matrix_decoder = std::make_unique(output_sample_rate); + } + } else { + // When switching away from matrix mode, release the decoder + sound_matrix_decoder.reset(); + } + + // Reinitialize audio device with new channel count + reset_audio(output_sample_rate); } extern RspUcodeFunc njpgdspMain; @@ -666,6 +763,8 @@ int main(int argc, char** argv) { REGISTER_FUNC(recomp_get_targeting_mode); REGISTER_FUNC(recomp_get_bgm_volume); REGISTER_FUNC(recomp_get_low_health_beeps_enabled); + REGISTER_FUNC(recomp_set_audio_channels); + REGISTER_FUNC(recomp_get_audio_channels); REGISTER_FUNC(recomp_get_gyro_deltas); REGISTER_FUNC(recomp_get_mouse_deltas); REGISTER_FUNC(recomp_get_inverted_axes); diff --git a/src/ui/ui_config.cpp b/src/ui/ui_config.cpp index 6832b22..80c35cf 100644 --- a/src/ui/ui_config.cpp +++ b/src/ui/ui_config.cpp @@ -3,6 +3,7 @@ #include "zelda_sound.h" #include "zelda_config.h" #include "zelda_debug.h" +#include "audio_channels.h" #include "zelda_render.h" #include "zelda_support.h" #include "promptfont.h" @@ -364,10 +365,12 @@ struct SoundOptionsContext { std::atomic main_volume; // Option to control the volume of all sound std::atomic bgm_volume; std::atomic low_health_beeps_enabled; // RmlUi doesn't seem to like "true"/"false" strings for setting variants so an int is used here instead. + std::atomic surround_sound_enabled; // Enable 5.1 surround sound matrix decoding void reset() { bgm_volume = 100; main_volume = 100; low_health_beeps_enabled = (int)true; + surround_sound_enabled = (int)false; } SoundOptionsContext() { reset(); @@ -416,6 +419,23 @@ bool zelda64::get_low_health_beeps_enabled() { return (bool)sound_options_context.low_health_beeps_enabled.load(); } +// Forward declaration from main.cpp +void set_audio_channels(AudioChannelsSetting channels); + +void zelda64::set_surround_sound_enabled(bool enabled) { + printf("UI: Setting surround sound to %s\n", enabled ? "enabled" : "disabled"); + sound_options_context.surround_sound_enabled.store((int)enabled); + if (sound_options_model_handle) { + sound_options_model_handle.DirtyVariable("surround_sound_enabled"); + } + // Update audio backend + set_audio_channels(enabled ? audioMatrix51 : audioStereo); +} + +bool zelda64::get_surround_sound_enabled() { + return (bool)sound_options_context.surround_sound_enabled.load(); +} + struct DebugContext { Rml::DataModelHandle model_handle; std::vector area_names; @@ -939,6 +959,17 @@ public: bind_atomic(constructor, sound_options_model_handle, "main_volume", &sound_options_context.main_volume); bind_atomic(constructor, sound_options_model_handle, "bgm_volume", &sound_options_context.bgm_volume); bind_atomic(constructor, sound_options_model_handle, "low_health_beeps_enabled", &sound_options_context.low_health_beeps_enabled); + + // Custom binding for surround sound that calls the setter to update audio channels + constructor.BindFunc("surround_sound_enabled", + [](Rml::Variant& out) { + out = sound_options_context.surround_sound_enabled.load(); + }, + [](const Rml::Variant& in) { + bool enabled = in.Get() != 0; + zelda64::set_surround_sound_enabled(enabled); + } + ); } void make_debug_bindings(Rml::Context* context) {