mirror of
https://git.eden-emu.dev/eden-emu/eden
synced 2026-04-20 14:48:56 +02:00
[audio_core/hid] Audio REV12+15 support + HID fixes (#2719)
This fixes newer updates / games. Implements partial audio rev15, rev13, rev12 and HID issues on SDK20+ games. Credits to LotP (Ryubing) and Zephyron (Citron) for their research and implementation. Co-authored-by: Zephyron <zephyron@citron-emu.org> Co-authored-by: Shinmegumi <shinmegumi@eden-emu.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/2719 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: CamilleLaVey <camillelavey99@gmail.com> Co-authored-by: unknown <sahyno1996@gmail.com> Co-committed-by: unknown <sahyno1996@gmail.com>
This commit is contained in:
unknown
crueter
parent
1e1b8ad33f
commit
a3ef2cc183
27 changed files with 727 additions and 36 deletions
|
|
@ -16,7 +16,7 @@
|
|||
#include <ranges>
|
||||
|
||||
namespace AudioCore {
|
||||
constexpr u32 CurrentRevision = 16;
|
||||
constexpr u32 CurrentRevision = 15;
|
||||
|
||||
enum class SupportTags {
|
||||
CommandProcessingTimeEstimatorVersion4,
|
||||
|
|
@ -47,6 +47,10 @@ enum class SupportTags {
|
|||
DelayChannelMappingChange,
|
||||
ReverbChannelMappingChange,
|
||||
I3dl2ReverbChannelMappingChange,
|
||||
SplitterPrevVolumeReset,
|
||||
SplitterBiquadFilterParameter,
|
||||
SplitterDestinationV2b,
|
||||
VoiceInParameterV2,
|
||||
|
||||
// Not a real tag, just here to get the count.
|
||||
Size
|
||||
|
|
@ -91,6 +95,10 @@ constexpr bool CheckFeatureSupported(SupportTags tag, u32 user_revision) {
|
|||
{SupportTags::DelayChannelMappingChange, 11},
|
||||
{SupportTags::ReverbChannelMappingChange, 11},
|
||||
{SupportTags::I3dl2ReverbChannelMappingChange, 11},
|
||||
{SupportTags::SplitterBiquadFilterParameter, 12},
|
||||
{SupportTags::SplitterPrevVolumeReset, 13},
|
||||
{SupportTags::SplitterDestinationV2b, 15},
|
||||
{SupportTags::VoiceInParameterV2, 15},
|
||||
}};
|
||||
|
||||
const auto& feature =
|
||||
|
|
|
|||
|
|
@ -193,4 +193,20 @@ bool BehaviorInfo::IsI3dl2ReverbChannelMappingChanged() const {
|
|||
return CheckFeatureSupported(SupportTags::I3dl2ReverbChannelMappingChange, user_revision);
|
||||
}
|
||||
|
||||
bool BehaviorInfo::IsSplitterPrevVolumeResetSupported() const {
|
||||
return CheckFeatureSupported(SupportTags::SplitterPrevVolumeReset, user_revision);
|
||||
}
|
||||
|
||||
bool BehaviorInfo::IsSplitterDestinationV2bSupported() const {
|
||||
return CheckFeatureSupported(SupportTags::SplitterDestinationV2b, user_revision);
|
||||
}
|
||||
|
||||
bool BehaviorInfo::IsVoiceInParameterV2Supported() const {
|
||||
return CheckFeatureSupported(SupportTags::VoiceInParameterV2, user_revision);
|
||||
}
|
||||
|
||||
bool BehaviorInfo::IsBiquadFilterParameterForSplitterEnabled() const {
|
||||
return CheckFeatureSupported(SupportTags::SplitterBiquadFilterParameter, user_revision);
|
||||
}
|
||||
|
||||
} // namespace AudioCore::Renderer
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -361,6 +364,38 @@ public:
|
|||
*/
|
||||
bool IsI3dl2ReverbChannelMappingChanged() const;
|
||||
|
||||
/**
|
||||
* Check if explicit previous mix volume reset is supported for splitters.
|
||||
* This allows splitters to explicitly reset their previous mix volumes instead of
|
||||
* doing so implicitly on first use.
|
||||
*
|
||||
* @return True if supported, otherwise false.
|
||||
*/
|
||||
bool IsSplitterPrevVolumeResetSupported() const;
|
||||
|
||||
/**
|
||||
* Check if splitter destination v2b parameter format is supported (revision 15+).
|
||||
* This uses the extended parameter format with biquad filter fields.
|
||||
*
|
||||
* @return True if supported, otherwise false.
|
||||
*/
|
||||
bool IsSplitterDestinationV2bSupported() const;
|
||||
|
||||
/**
|
||||
* Check if voice input parameter v2 format is supported (revision 15+).
|
||||
* This uses the extended parameter format with float biquad filters.
|
||||
*
|
||||
* @return True if supported, otherwise false.
|
||||
*/
|
||||
bool IsVoiceInParameterV2Supported() const;
|
||||
|
||||
/**
|
||||
* Check if splitter destinations can carry biquad filter parameters (revision 12+).
|
||||
*
|
||||
* @return True if supported, otherwise false.
|
||||
*/
|
||||
bool IsBiquadFilterParameterForSplitterEnabled() const;
|
||||
|
||||
/// Host version
|
||||
u32 process_revision;
|
||||
/// User version
|
||||
|
|
|
|||
|
|
@ -64,8 +64,6 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
|
|||
const PoolMapper pool_mapper(process_handle, memory_pools, memory_pool_count,
|
||||
behaviour.IsMemoryForceMappingEnabled());
|
||||
const auto voice_count{voice_context.GetCount()};
|
||||
std::span<const VoiceInfo::InParameter> in_params{
|
||||
reinterpret_cast<const VoiceInfo::InParameter*>(input), voice_count};
|
||||
std::span<VoiceInfo::OutStatus> out_params{reinterpret_cast<VoiceInfo::OutStatus*>(output),
|
||||
voice_count};
|
||||
|
||||
|
|
@ -76,8 +74,104 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
|
|||
|
||||
u32 new_voice_count{0};
|
||||
|
||||
// Two input formats exist: legacy (0x170) and v2 with float biquad (0x188).
|
||||
const bool use_v2 = behaviour.IsVoiceInParameterV2Supported();
|
||||
const u32 in_stride = use_v2 ? 0x188u : static_cast<u32>(sizeof(VoiceInfo::InParameter));
|
||||
|
||||
for (u32 i = 0; i < voice_count; i++) {
|
||||
const auto& in_param{in_params[i]};
|
||||
VoiceInfo::InParameter local_in{};
|
||||
std::array<VoiceInfo::BiquadFilterParameter2, MaxBiquadFilters> float_biquads{};
|
||||
|
||||
if (!use_v2) {
|
||||
const auto* in_param_ptr = reinterpret_cast<const VoiceInfo::InParameter*>(
|
||||
input + i * sizeof(VoiceInfo::InParameter));
|
||||
local_in = *in_param_ptr;
|
||||
} else {
|
||||
struct VoiceInParameterV2 {
|
||||
u32 id;
|
||||
u32 node_id;
|
||||
bool is_new;
|
||||
bool in_use;
|
||||
PlayState play_state;
|
||||
SampleFormat sample_format;
|
||||
u32 sample_rate;
|
||||
u32 priority;
|
||||
u32 sort_order;
|
||||
u32 channel_count;
|
||||
f32 pitch;
|
||||
f32 volume;
|
||||
// Two BiquadFilterParameter2 (0x18 each) -> ignored/converted
|
||||
struct BiquadV2 {
|
||||
bool enable;
|
||||
u8 r1;
|
||||
u8 r2;
|
||||
u8 r3;
|
||||
std::array<f32, 3> b;
|
||||
std::array<f32, 2> a;
|
||||
} biquads[2];
|
||||
u32 wave_buffer_count;
|
||||
u32 wave_buffer_index;
|
||||
u32 reserved1;
|
||||
u64 src_data_address;
|
||||
u64 src_data_size;
|
||||
s32 mix_id;
|
||||
u32 splitter_id;
|
||||
std::array<VoiceInfo::WaveBufferInternal, MaxWaveBuffers> wavebuffers;
|
||||
std::array<u32, MaxChannels> channel_resource_ids;
|
||||
bool clear_voice_drop;
|
||||
u8 flush_wave_buffer_count;
|
||||
u16 reserved2;
|
||||
VoiceInfo::Flags flags;
|
||||
SrcQuality src_quality;
|
||||
u32 external_ctx;
|
||||
u32 external_ctx_size;
|
||||
u32 reserved3[2];
|
||||
};
|
||||
const auto* vin = reinterpret_cast<const VoiceInParameterV2*>(input + i * in_stride);
|
||||
local_in.id = vin->id;
|
||||
local_in.node_id = vin->node_id;
|
||||
local_in.is_new = vin->is_new;
|
||||
local_in.in_use = vin->in_use;
|
||||
local_in.play_state = vin->play_state;
|
||||
local_in.sample_format = vin->sample_format;
|
||||
local_in.sample_rate = vin->sample_rate;
|
||||
local_in.priority = static_cast<s32>(vin->priority);
|
||||
local_in.sort_order = static_cast<s32>(vin->sort_order);
|
||||
local_in.channel_count = vin->channel_count;
|
||||
local_in.pitch = vin->pitch;
|
||||
local_in.volume = vin->volume;
|
||||
|
||||
// For REV15+, we keep float coefficients separate and only convert for compatibility
|
||||
for (size_t filter_idx = 0; filter_idx < MaxBiquadFilters; filter_idx++) {
|
||||
const auto& src = vin->biquads[filter_idx];
|
||||
auto& dst = local_in.biquads[filter_idx];
|
||||
dst.enabled = src.enable;
|
||||
// Convert float coefficients to fixed-point Q2.14 for legacy path
|
||||
dst.b[0] = static_cast<s16>(std::clamp(src.b[0] * 16384.0f, -32768.0f, 32767.0f));
|
||||
dst.b[1] = static_cast<s16>(std::clamp(src.b[1] * 16384.0f, -32768.0f, 32767.0f));
|
||||
dst.b[2] = static_cast<s16>(std::clamp(src.b[2] * 16384.0f, -32768.0f, 32767.0f));
|
||||
dst.a[0] = static_cast<s16>(std::clamp(src.a[0] * 16384.0f, -32768.0f, 32767.0f));
|
||||
dst.a[1] = static_cast<s16>(std::clamp(src.a[1] * 16384.0f, -32768.0f, 32767.0f));
|
||||
|
||||
// Also store the native float version
|
||||
float_biquads[filter_idx].enabled = src.enable;
|
||||
float_biquads[filter_idx].numerator = src.b;
|
||||
float_biquads[filter_idx].denominator = src.a;
|
||||
}
|
||||
local_in.wave_buffer_count = vin->wave_buffer_count;
|
||||
local_in.wave_buffer_index = static_cast<u16>(vin->wave_buffer_index);
|
||||
local_in.src_data_address = static_cast<CpuAddr>(vin->src_data_address);
|
||||
local_in.src_data_size = vin->src_data_size;
|
||||
local_in.mix_id = static_cast<u32>(vin->mix_id);
|
||||
local_in.splitter_id = vin->splitter_id;
|
||||
local_in.wave_buffer_internal = vin->wavebuffers;
|
||||
local_in.channel_resource_ids = vin->channel_resource_ids;
|
||||
local_in.clear_voice_drop = vin->clear_voice_drop;
|
||||
local_in.flush_buffer_count = vin->flush_wave_buffer_count;
|
||||
local_in.flags = vin->flags;
|
||||
local_in.src_quality = vin->src_quality;
|
||||
}
|
||||
const auto& in_param = local_in;
|
||||
std::array<VoiceState*, MaxChannels> voice_states{};
|
||||
|
||||
if (!in_param.in_use) {
|
||||
|
|
@ -101,6 +195,14 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
|
|||
BehaviorInfo::ErrorInfo update_error{};
|
||||
voice_info.UpdateParameters(update_error, in_param, pool_mapper, behaviour);
|
||||
|
||||
// For REV15+, store the native float biquad coefficients
|
||||
if (use_v2) {
|
||||
voice_info.use_float_biquads = true;
|
||||
voice_info.biquads_float = float_biquads;
|
||||
} else {
|
||||
voice_info.use_float_biquads = false;
|
||||
}
|
||||
|
||||
if (!update_error.error_code.IsSuccess()) {
|
||||
behaviour.AppendError(update_error);
|
||||
}
|
||||
|
|
@ -121,7 +223,7 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
|
|||
new_voice_count += in_param.channel_count;
|
||||
}
|
||||
|
||||
auto consumed_input_size{voice_count * static_cast<u32>(sizeof(VoiceInfo::InParameter))};
|
||||
auto consumed_input_size{voice_count * in_stride};
|
||||
auto consumed_output_size{voice_count * static_cast<u32>(sizeof(VoiceInfo::OutStatus))};
|
||||
if (consumed_input_size != in_header->voices_size) {
|
||||
LOG_ERROR(Service_Audio, "Consumed an incorrect voices size, header size={}, consumed={}",
|
||||
|
|
@ -257,18 +359,31 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
|
|||
EffectContext& effect_context, SplitterContext& splitter_context) {
|
||||
s32 mix_count{0};
|
||||
u32 consumed_input_size{0};
|
||||
u32 input_mix_size{0};
|
||||
|
||||
if (behaviour.IsMixInParameterDirtyOnlyUpdateSupported()) {
|
||||
auto in_dirty_params{reinterpret_cast<const MixInfo::InDirtyParameter*>(input)};
|
||||
mix_count = in_dirty_params->count;
|
||||
|
||||
// Validate against expected header size to ensure structure is correct
|
||||
if (mix_count < 0 || mix_count > 0x100) {
|
||||
LOG_ERROR(
|
||||
Service_Audio,
|
||||
"Invalid mix count from dirty parameter: count={}, magic=0x{:X}, expected_size={}",
|
||||
mix_count, in_dirty_params->magic, in_header->mix_size);
|
||||
return Service::Audio::ResultInvalidUpdateInfo;
|
||||
}
|
||||
|
||||
consumed_input_size += static_cast<u32>(sizeof(MixInfo::InDirtyParameter));
|
||||
input += sizeof(MixInfo::InDirtyParameter);
|
||||
consumed_input_size = static_cast<u32>(sizeof(MixInfo::InDirtyParameter) +
|
||||
mix_count * sizeof(MixInfo::InParameter));
|
||||
} else {
|
||||
mix_count = mix_context.GetCount();
|
||||
consumed_input_size = static_cast<u32>(mix_count * sizeof(MixInfo::InParameter));
|
||||
}
|
||||
|
||||
input_mix_size = static_cast<u32>(mix_count * sizeof(MixInfo::InParameter));
|
||||
consumed_input_size += input_mix_size;
|
||||
|
||||
|
||||
if (mix_buffer_count == 0) {
|
||||
return Service::Audio::ResultInvalidUpdateInfo;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -237,6 +237,13 @@ void CommandBuffer::GenerateBiquadFilterCommand(const s32 node_id, VoiceInfo& vo
|
|||
|
||||
cmd.biquad = voice_info.biquads[biquad_index];
|
||||
|
||||
if (voice_info.use_float_biquads) {
|
||||
cmd.biquad_float = voice_info.biquads_float[biquad_index];
|
||||
cmd.use_float_coefficients = true;
|
||||
} else {
|
||||
cmd.use_float_coefficients = false;
|
||||
}
|
||||
|
||||
cmd.state = memory_pool->Translate(CpuAddr(voice_state.biquad_states[biquad_index].data()),
|
||||
MaxBiquadFilters * sizeof(VoiceState::BiquadFilterState));
|
||||
|
||||
|
|
@ -263,6 +270,9 @@ void CommandBuffer::GenerateBiquadFilterCommand(const s32 node_id, EffectInfoBas
|
|||
cmd.biquad.b = parameter.b;
|
||||
cmd.biquad.a = parameter.a;
|
||||
|
||||
// Effects use legacy fixed-point format
|
||||
cmd.use_float_coefficients = false;
|
||||
|
||||
cmd.state = memory_pool->Translate(CpuAddr(state),
|
||||
MaxBiquadFilters * sizeof(VoiceState::BiquadFilterState));
|
||||
|
||||
|
|
@ -658,6 +668,13 @@ void CommandBuffer::GenerateMultitapBiquadFilterCommand(const s32 node_id, Voice
|
|||
cmd.output = buffer_count + channel;
|
||||
cmd.biquads = voice_info.biquads;
|
||||
|
||||
if (voice_info.use_float_biquads) {
|
||||
cmd.biquads_float = voice_info.biquads_float;
|
||||
cmd.use_float_coefficients = true;
|
||||
} else {
|
||||
cmd.use_float_coefficients = false;
|
||||
}
|
||||
|
||||
cmd.states[0] =
|
||||
memory_pool->Translate(CpuAddr(voice_state.biquad_states[0].data()),
|
||||
MaxBiquadFilters * sizeof(VoiceState::BiquadFilterState));
|
||||
|
|
|
|||
|
|
@ -51,6 +51,40 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
|
|||
state.s3 = Common::BitCast<s64>(s[3]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Biquad filter float implementation with native float coefficients.
|
||||
*/
|
||||
void ApplyBiquadFilterFloat2(std::span<s32> output, std::span<const s32> input,
|
||||
std::array<f32, 3>& b, std::array<f32, 2>& a,
|
||||
VoiceState::BiquadFilterState& state, const u32 sample_count) {
|
||||
constexpr f64 min{std::numeric_limits<s32>::min()};
|
||||
constexpr f64 max{std::numeric_limits<s32>::max()};
|
||||
|
||||
std::array<f64, 3> b_double{static_cast<f64>(b[0]), static_cast<f64>(b[1]),
|
||||
static_cast<f64>(b[2])};
|
||||
std::array<f64, 2> a_double{static_cast<f64>(a[0]), static_cast<f64>(a[1])};
|
||||
std::array<f64, 4> s{Common::BitCast<f64>(state.s0), Common::BitCast<f64>(state.s1),
|
||||
Common::BitCast<f64>(state.s2), Common::BitCast<f64>(state.s3)};
|
||||
|
||||
for (u32 i = 0; i < sample_count; i++) {
|
||||
f64 in_sample{static_cast<f64>(input[i])};
|
||||
auto sample{in_sample * b_double[0] + s[0] * b_double[1] + s[1] * b_double[2] +
|
||||
s[2] * a_double[0] + s[3] * a_double[1]};
|
||||
|
||||
output[i] = static_cast<s32>(std::clamp(sample, min, max));
|
||||
|
||||
s[1] = s[0];
|
||||
s[0] = in_sample;
|
||||
s[3] = s[2];
|
||||
s[2] = sample;
|
||||
}
|
||||
|
||||
state.s0 = Common::BitCast<s64>(s[0]);
|
||||
state.s1 = Common::BitCast<s64>(s[1]);
|
||||
state.s2 = Common::BitCast<s64>(s[2]);
|
||||
state.s3 = Common::BitCast<s64>(s[3]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Biquad filter s32 implementation.
|
||||
*
|
||||
|
|
@ -98,8 +132,14 @@ void BiquadFilterCommand::Process(const AudioRenderer::CommandListProcessor& pro
|
|||
processor.mix_buffers.subspan(output * processor.sample_count, processor.sample_count)};
|
||||
|
||||
if (use_float_processing) {
|
||||
ApplyBiquadFilterFloat(output_buffer, input_buffer, biquad.b, biquad.a, *state_,
|
||||
processor.sample_count);
|
||||
// REV15+: Use native float coefficients if available
|
||||
if (use_float_coefficients) {
|
||||
ApplyBiquadFilterFloat2(output_buffer, input_buffer, biquad_float.numerator,
|
||||
biquad_float.denominator, *state_, processor.sample_count);
|
||||
} else {
|
||||
ApplyBiquadFilterFloat(output_buffer, input_buffer, biquad.b, biquad.a, *state_,
|
||||
processor.sample_count);
|
||||
}
|
||||
} else {
|
||||
ApplyBiquadFilterInt(output_buffer, input_buffer, biquad.b, biquad.a, *state_,
|
||||
processor.sample_count);
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -50,12 +53,16 @@ struct BiquadFilterCommand : ICommand {
|
|||
s16 output;
|
||||
/// Input parameters for biquad
|
||||
VoiceInfo::BiquadFilterParameter biquad;
|
||||
/// Input parameters for biquad (REV15+ native float)
|
||||
VoiceInfo::BiquadFilterParameter2 biquad_float;
|
||||
/// Biquad state, updated each call
|
||||
CpuAddr state;
|
||||
/// If true, reset the state
|
||||
bool needs_init;
|
||||
/// If true, use float processing rather than int
|
||||
bool use_float_processing;
|
||||
/// If true, use native float coefficients (REV15+)
|
||||
bool use_float_coefficients;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -72,4 +79,18 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
|
|||
std::array<s16, 3>& b, std::array<s16, 2>& a,
|
||||
VoiceState::BiquadFilterState& state, const u32 sample_count);
|
||||
|
||||
/**
|
||||
* Biquad filter float implementation with native float coefficients (SDK REV15+).
|
||||
*
|
||||
* @param output - Output container for filtered samples.
|
||||
* @param input - Input container for samples to be filtered.
|
||||
* @param b - Feedforward coefficients (float).
|
||||
* @param a - Feedback coefficients (float).
|
||||
* @param state - State to track previous samples.
|
||||
* @param sample_count - Number of samples to process.
|
||||
*/
|
||||
void ApplyBiquadFilterFloat2(std::span<s32> output, std::span<const s32> input,
|
||||
std::array<f32, 3>& b, std::array<f32, 2>& a,
|
||||
VoiceState::BiquadFilterState& state, const u32 sample_count);
|
||||
|
||||
} // namespace AudioCore::Renderer
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -33,8 +36,14 @@ void MultiTapBiquadFilterCommand::Process(const AudioRenderer::CommandListProces
|
|||
*state = {};
|
||||
}
|
||||
|
||||
ApplyBiquadFilterFloat(output_buffer, input_buffer, biquads[i].b, biquads[i].a, *state,
|
||||
processor.sample_count);
|
||||
// REV15+: Use native float coefficients if available
|
||||
if (use_float_coefficients) {
|
||||
ApplyBiquadFilterFloat2(output_buffer, input_buffer, biquads_float[i].numerator,
|
||||
biquads_float[i].denominator, *state, processor.sample_count);
|
||||
} else {
|
||||
ApplyBiquadFilterFloat(output_buffer, input_buffer, biquads[i].b, biquads[i].a, *state,
|
||||
processor.sample_count);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -49,12 +52,16 @@ struct MultiTapBiquadFilterCommand : ICommand {
|
|||
s16 output;
|
||||
/// Biquad parameters
|
||||
std::array<VoiceInfo::BiquadFilterParameter, MaxBiquadFilters> biquads;
|
||||
/// Biquad parameters (REV15+ native float)
|
||||
std::array<VoiceInfo::BiquadFilterParameter2, MaxBiquadFilters> biquads_float;
|
||||
/// Biquad states, updated each call
|
||||
std::array<CpuAddr, MaxBiquadFilters> states;
|
||||
/// If each biquad needs initialisation
|
||||
std::array<bool, MaxBiquadFilters> needs_init;
|
||||
/// Number of active biquads
|
||||
u8 filter_tap_count;
|
||||
/// If true, use native float coefficients (REV15+)
|
||||
bool use_float_coefficients;
|
||||
};
|
||||
|
||||
} // namespace AudioCore::Renderer
|
||||
|
|
|
|||
|
|
@ -35,12 +35,16 @@ SplitterDestinationData& SplitterContext::GetData(const u32 index) {
|
|||
|
||||
void SplitterContext::Setup(std::span<SplitterInfo> splitter_infos_, const u32 splitter_info_count_,
|
||||
SplitterDestinationData* splitter_destinations_,
|
||||
const u32 destination_count_, const bool splitter_bug_fixed_) {
|
||||
const u32 destination_count_, const bool splitter_bug_fixed_,
|
||||
const BehaviorInfo& behavior) {
|
||||
splitter_infos = splitter_infos_;
|
||||
info_count = splitter_info_count_;
|
||||
splitter_destinations = splitter_destinations_;
|
||||
destinations_count = destination_count_;
|
||||
splitter_bug_fixed = splitter_bug_fixed_;
|
||||
splitter_prev_volume_reset_supported = behavior.IsSplitterPrevVolumeResetSupported();
|
||||
splitter_biquad_param_supported = behavior.IsBiquadFilterParameterForSplitterEnabled();
|
||||
splitter_float_coeff_supported = behavior.IsSplitterDestinationV2bSupported();
|
||||
}
|
||||
|
||||
bool SplitterContext::UsingSplitter() const {
|
||||
|
|
@ -84,7 +88,7 @@ bool SplitterContext::Initialize(const BehaviorInfo& behavior,
|
|||
}
|
||||
|
||||
Setup(splitter_infos, params.splitter_infos, splitter_destinations,
|
||||
params.splitter_destinations, behavior.IsSplitterBugFixed());
|
||||
params.splitter_destinations, behavior.IsSplitterBugFixed(), behavior);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -137,19 +141,104 @@ u32 SplitterContext::UpdateInfo(const u8* input, u32 offset, const u32 splitter_
|
|||
|
||||
u32 SplitterContext::UpdateData(const u8* input, u32 offset, const u32 count) {
|
||||
for (u32 i = 0; i < count; i++) {
|
||||
auto data_header{
|
||||
reinterpret_cast<const SplitterDestinationData::InParameter*>(input + offset)};
|
||||
// Version selection based on feature flags:
|
||||
// - REV12: integer biquad params (Version2a)
|
||||
// - REV15: float coeff/biquad v2b
|
||||
// - older: no biquad fields
|
||||
if (!splitter_biquad_param_supported) {
|
||||
const auto* data_header =
|
||||
reinterpret_cast<const SplitterDestinationData::InParameter*>(input + offset);
|
||||
|
||||
if (data_header->magic != GetSplitterSendDataMagic()) {
|
||||
continue;
|
||||
if (data_header->magic != GetSplitterSendDataMagic()) {
|
||||
continue;
|
||||
}
|
||||
if (data_header->id < 0 || data_header->id > destinations_count) {
|
||||
continue;
|
||||
}
|
||||
|
||||
auto modified_params = *data_header;
|
||||
if (!splitter_prev_volume_reset_supported) {
|
||||
modified_params.reset_prev_volume = false;
|
||||
}
|
||||
splitter_destinations[data_header->id].Update(modified_params);
|
||||
offset += sizeof(SplitterDestinationData::InParameter);
|
||||
} else if (!splitter_float_coeff_supported) {
|
||||
// Version 2a: struct contains legacy fixed-point biquad filter fields (REV12+)
|
||||
const auto* data_header_v2a =
|
||||
reinterpret_cast<const SplitterDestinationData::InParameterVersion2a*>(input +
|
||||
offset);
|
||||
|
||||
if (data_header_v2a->magic != GetSplitterSendDataMagic()) {
|
||||
continue;
|
||||
}
|
||||
if (data_header_v2a->id < 0 || data_header_v2a->id > destinations_count) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Map common fields to the base format
|
||||
SplitterDestinationData::InParameter mapped{};
|
||||
mapped.magic = data_header_v2a->magic;
|
||||
mapped.id = data_header_v2a->id;
|
||||
mapped.mix_volumes = data_header_v2a->mix_volumes;
|
||||
mapped.mix_id = data_header_v2a->mix_id;
|
||||
mapped.in_use = data_header_v2a->in_use;
|
||||
mapped.reset_prev_volume =
|
||||
splitter_prev_volume_reset_supported ? data_header_v2a->reset_prev_volume : false;
|
||||
|
||||
auto& destination = splitter_destinations[data_header_v2a->id];
|
||||
destination.Update(mapped);
|
||||
|
||||
// Convert legacy fixed-point biquad params into float representation
|
||||
auto biquad_filters = destination.GetBiquadFilters();
|
||||
for (size_t filter_idx = 0; filter_idx < MaxBiquadFilters; filter_idx++) {
|
||||
const auto& legacy = data_header_v2a->biquad_filters[filter_idx];
|
||||
auto& out = biquad_filters[filter_idx];
|
||||
out.enabled = legacy.enabled;
|
||||
// s16 fixed-point scale: use Q14 like voices (b and a are s16, 1.0 ~= 1<<14)
|
||||
constexpr float scale = 1.0f / static_cast<float>(1 << 14);
|
||||
out.numerator[0] = static_cast<float>(legacy.b[0]) * scale;
|
||||
out.numerator[1] = static_cast<float>(legacy.b[1]) * scale;
|
||||
out.numerator[2] = static_cast<float>(legacy.b[2]) * scale;
|
||||
out.denominator[0] = static_cast<float>(legacy.a[0]) * scale;
|
||||
out.denominator[1] = static_cast<float>(legacy.a[1]) * scale;
|
||||
}
|
||||
|
||||
offset += static_cast<u32>(sizeof(SplitterDestinationData::InParameterVersion2a));
|
||||
} else {
|
||||
// Version 2b: struct contains extra biquad filter fields with float coeffs
|
||||
const auto* data_header_v2b =
|
||||
reinterpret_cast<const SplitterDestinationData::InParameterVersion2b*>(input +
|
||||
offset);
|
||||
|
||||
if (data_header_v2b->magic != GetSplitterSendDataMagic()) {
|
||||
continue;
|
||||
}
|
||||
if (data_header_v2b->id < 0 || data_header_v2b->id > destinations_count) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Map common fields to the old format
|
||||
SplitterDestinationData::InParameter mapped{};
|
||||
mapped.magic = data_header_v2b->magic;
|
||||
mapped.id = data_header_v2b->id;
|
||||
mapped.mix_volumes = data_header_v2b->mix_volumes;
|
||||
mapped.mix_id = data_header_v2b->mix_id;
|
||||
mapped.in_use = data_header_v2b->in_use;
|
||||
mapped.reset_prev_volume =
|
||||
splitter_prev_volume_reset_supported ? data_header_v2b->reset_prev_volume : false;
|
||||
|
||||
// Store biquad filters from V2b (REV15+)
|
||||
auto& destination = splitter_destinations[data_header_v2b->id];
|
||||
destination.Update(mapped);
|
||||
|
||||
// Copy biquad filter parameters
|
||||
auto biquad_filters = destination.GetBiquadFilters();
|
||||
for (size_t filter_idx = 0; filter_idx < MaxBiquadFilters; filter_idx++) {
|
||||
biquad_filters[filter_idx] = data_header_v2b->biquad_filters[filter_idx];
|
||||
}
|
||||
|
||||
offset += static_cast<u32>(sizeof(SplitterDestinationData::InParameterVersion2b));
|
||||
}
|
||||
|
||||
if (data_header->id < 0 || data_header->id > destinations_count) {
|
||||
continue;
|
||||
}
|
||||
|
||||
splitter_destinations[data_header->id].Update(*data_header);
|
||||
offset += sizeof(SplitterDestinationData::InParameter);
|
||||
}
|
||||
|
||||
return offset;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -168,10 +171,11 @@ private:
|
|||
* @param splitter_destinations - Workbuffer for splitter destinations.
|
||||
* @param destination_count - Number of destinations in the workbuffer.
|
||||
* @param splitter_bug_fixed - Is the splitter bug fixed?
|
||||
* @param behavior - Behavior info for feature support.
|
||||
*/
|
||||
void Setup(std::span<SplitterInfo> splitter_infos, u32 splitter_info_count,
|
||||
SplitterDestinationData* splitter_destinations, u32 destination_count,
|
||||
bool splitter_bug_fixed);
|
||||
bool splitter_bug_fixed, const BehaviorInfo& behavior);
|
||||
|
||||
/// Workbuffer for splitters
|
||||
std::span<SplitterInfo> splitter_infos{};
|
||||
|
|
@ -183,6 +187,12 @@ private:
|
|||
s32 destinations_count{};
|
||||
/// Is the splitter bug fixed?
|
||||
bool splitter_bug_fixed{};
|
||||
/// Is explicit previous mix volume reset supported?
|
||||
bool splitter_prev_volume_reset_supported{};
|
||||
/// Is biquad filter parameter for splitter (REV12) supported?
|
||||
bool splitter_biquad_param_supported{};
|
||||
/// Is float coefficient/biquad filter v2b parameter supported?
|
||||
bool splitter_float_coeff_supported{};
|
||||
};
|
||||
|
||||
} // namespace Renderer
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -84,4 +87,14 @@ void SplitterDestinationData::SetNext(SplitterDestinationData* next_) {
|
|||
next = next_;
|
||||
}
|
||||
|
||||
std::span<SplitterDestinationData::BiquadFilterParameter2>
|
||||
SplitterDestinationData::GetBiquadFilters() {
|
||||
return biquad_filters;
|
||||
}
|
||||
|
||||
std::span<const SplitterDestinationData::BiquadFilterParameter2>
|
||||
SplitterDestinationData::GetBiquadFilters() const {
|
||||
return biquad_filters;
|
||||
}
|
||||
|
||||
} // namespace AudioCore::Renderer
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -16,16 +19,72 @@ namespace AudioCore::Renderer {
|
|||
*/
|
||||
class SplitterDestinationData {
|
||||
public:
|
||||
/**
|
||||
* Biquad filter parameter with float coefficients (SDK REV15+).
|
||||
* Defined here to avoid circular dependency with VoiceInfo.
|
||||
*/
|
||||
struct BiquadFilterParameter2 {
|
||||
/* 0x00 */ bool enabled;
|
||||
/* 0x01 */ u8 reserved1;
|
||||
/* 0x02 */ u8 reserved2;
|
||||
/* 0x03 */ u8 reserved3;
|
||||
/* 0x04 */ std::array<f32, 3> numerator; // b0, b1, b2
|
||||
/* 0x10 */ std::array<f32, 2> denominator; // a1, a2 (a0 = 1)
|
||||
};
|
||||
static_assert(sizeof(BiquadFilterParameter2) == 0x18,
|
||||
"BiquadFilterParameter2 has the wrong size!");
|
||||
|
||||
/**
|
||||
* Legacy biquad filter parameter with fixed-point coefficients (SDK REV12+ for splitters).
|
||||
* Matches the old voice biquad format.
|
||||
*/
|
||||
struct BiquadFilterParameterLegacy {
|
||||
/* 0x00 */ bool enabled;
|
||||
/* 0x02 */ std::array<s16, 3> b; // numerator
|
||||
/* 0x08 */ std::array<s16, 2> a; // denominator (a0 = 1)
|
||||
};
|
||||
static_assert(sizeof(BiquadFilterParameterLegacy) == 0xC,
|
||||
"BiquadFilterParameterLegacy has the wrong size!");
|
||||
|
||||
struct InParameter {
|
||||
/* 0x00 */ u32 magic; // 'SNDD'
|
||||
/* 0x04 */ s32 id;
|
||||
/* 0x08 */ std::array<f32, MaxMixBuffers> mix_volumes;
|
||||
/* 0x68 */ u32 mix_id;
|
||||
/* 0x6C */ bool in_use;
|
||||
/* 0x6D */ bool reset_prev_volume;
|
||||
};
|
||||
static_assert(sizeof(InParameter) == 0x70,
|
||||
"SplitterDestinationData::InParameter has the wrong size!");
|
||||
|
||||
struct InParameterVersion2a {
|
||||
/* 0x00 */ u32 magic; // 'SNDD'
|
||||
/* 0x04 */ s32 id;
|
||||
/* 0x08 */ std::array<f32, MaxMixBuffers> mix_volumes;
|
||||
/* 0x68 */ u32 mix_id;
|
||||
/* 0x6C */ std::array<SplitterDestinationData::BiquadFilterParameterLegacy, MaxBiquadFilters>
|
||||
biquad_filters;
|
||||
/* 0x84 */ bool in_use;
|
||||
/* 0x85 */ bool reset_prev_volume; // only effective if supported
|
||||
/* 0x86 */ u8 reserved[10];
|
||||
};
|
||||
static_assert(sizeof(InParameterVersion2a) == 0x90,
|
||||
"SplitterDestinationData::InParameterVersion2a has the wrong size!");
|
||||
|
||||
struct InParameterVersion2b {
|
||||
/* 0x00 */ u32 magic; // 'SNDD'
|
||||
/* 0x04 */ s32 id;
|
||||
/* 0x08 */ std::array<f32, MaxMixBuffers> mix_volumes;
|
||||
/* 0x68 */ u32 mix_id;
|
||||
/* 0x6C */ std::array<SplitterDestinationData::BiquadFilterParameter2, MaxBiquadFilters>
|
||||
biquad_filters;
|
||||
/* 0x9C */ bool in_use;
|
||||
/* 0x9D */ bool reset_prev_volume;
|
||||
/* 0x9E */ u8 reserved[10];
|
||||
};
|
||||
static_assert(sizeof(InParameterVersion2b) == 0xA8,
|
||||
"SplitterDestinationData::InParameterVersion2b has the wrong size!");
|
||||
|
||||
SplitterDestinationData(s32 id);
|
||||
|
||||
/**
|
||||
|
|
@ -78,7 +137,7 @@ public:
|
|||
f32 GetMixVolumePrev(u32 index) const;
|
||||
|
||||
/**
|
||||
* Get the previous mix volumes for all mix buffers in this destination.
|
||||
* Get the previous mix volumes for all mix buffers.
|
||||
*
|
||||
* @return Span of previous mix buffer volumes.
|
||||
*/
|
||||
|
|
@ -115,6 +174,20 @@ public:
|
|||
*/
|
||||
void SetNext(SplitterDestinationData* next);
|
||||
|
||||
/**
|
||||
* Get biquad filter parameters for this destination (REV15+ or mapped from REV12).
|
||||
*
|
||||
* @return Span of biquad filter parameters.
|
||||
*/
|
||||
std::span<BiquadFilterParameter2> GetBiquadFilters();
|
||||
|
||||
/**
|
||||
* Get const biquad filter parameters for this destination (REV15+ or mapped from REV12).
|
||||
*
|
||||
* @return Const span of biquad filter parameters.
|
||||
*/
|
||||
std::span<const BiquadFilterParameter2> GetBiquadFilters() const;
|
||||
|
||||
private:
|
||||
/// Id of this destination
|
||||
const s32 id;
|
||||
|
|
@ -124,6 +197,8 @@ private:
|
|||
std::array<f32, MaxMixBuffers> mix_volumes{0.0f};
|
||||
/// Previous mix volumes
|
||||
std::array<f32, MaxMixBuffers> prev_mix_volumes{0.0f};
|
||||
/// Biquad filter parameters (REV15+ or mapped from REV12)
|
||||
std::array<BiquadFilterParameter2, MaxBiquadFilters> biquad_filters{};
|
||||
/// Next destination in the mix chain
|
||||
SplitterDestinationData* next{};
|
||||
/// Is this destination in use?
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -135,6 +138,17 @@ public:
|
|||
static_assert(sizeof(BiquadFilterParameter) == 0xC,
|
||||
"VoiceInfo::BiquadFilterParameter has the wrong size!");
|
||||
|
||||
struct BiquadFilterParameter2 {
|
||||
/* 0x00 */ bool enabled;
|
||||
/* 0x01 */ u8 reserved1;
|
||||
/* 0x02 */ u8 reserved2;
|
||||
/* 0x03 */ u8 reserved3;
|
||||
/* 0x04 */ std::array<f32, 3> numerator; // b0, b1, b2
|
||||
/* 0x10 */ std::array<f32, 2> denominator; // a1, a2 (a0 = 1)
|
||||
};
|
||||
static_assert(sizeof(BiquadFilterParameter2) == 0x18,
|
||||
"VoiceInfo::BiquadFilterParameter2 has the wrong size!");
|
||||
|
||||
struct InParameter {
|
||||
/* 0x000 */ u32 id;
|
||||
/* 0x004 */ u32 node_id;
|
||||
|
|
@ -168,6 +182,43 @@ public:
|
|||
};
|
||||
static_assert(sizeof(InParameter) == 0x170, "VoiceInfo::InParameter has the wrong size!");
|
||||
|
||||
struct InParameter2 {
|
||||
/* 0x000 */ u32 id;
|
||||
/* 0x004 */ u32 node_id;
|
||||
/* 0x008 */ bool is_new;
|
||||
/* 0x009 */ bool in_use;
|
||||
/* 0x00A */ PlayState play_state;
|
||||
/* 0x00B */ SampleFormat sample_format;
|
||||
/* 0x00C */ u32 sample_rate;
|
||||
/* 0x010 */ s32 priority;
|
||||
/* 0x014 */ s32 sort_order;
|
||||
/* 0x018 */ u32 channel_count;
|
||||
/* 0x01C */ f32 pitch;
|
||||
/* 0x020 */ f32 volume;
|
||||
/* 0x024 */ std::array<BiquadFilterParameter2, MaxBiquadFilters> biquads;
|
||||
/* 0x054 */ u32 wave_buffer_count;
|
||||
/* 0x058 */ u32 wave_buffer_index;
|
||||
/* 0x05C */ u32 reserved1;
|
||||
/* 0x060 */ CpuAddr src_data_address;
|
||||
/* 0x068 */ u64 src_data_size;
|
||||
/* 0x070 */ u32 mix_id;
|
||||
/* 0x074 */ u32 splitter_id;
|
||||
/* 0x078 */ std::array<WaveBufferInternal, MaxWaveBuffers> wave_buffer_internal;
|
||||
/* 0x158 */ std::array<s32, MaxChannels> channel_resource_ids;
|
||||
/* 0x170 */ bool clear_voice_drop;
|
||||
/* 0x171 */ u8 flush_buffer_count;
|
||||
/* 0x172 */ u16 reserved2;
|
||||
/* 0x174 */ Flags flags;
|
||||
/* 0x175 */ u8 reserved3;
|
||||
/* 0x176 */ SrcQuality src_quality;
|
||||
/* 0x177 */ u8 reserved4;
|
||||
/* 0x178 */ u32 external_context;
|
||||
/* 0x17C */ u32 external_context_size;
|
||||
/* 0x180 */ u32 reserved5;
|
||||
/* 0x184 */ u32 reserved6;
|
||||
};
|
||||
static_assert(sizeof(InParameter2) == 0x188, "VoiceInfo::InParameter2 has the wrong size!");
|
||||
|
||||
struct OutStatus {
|
||||
/* 0x00 */ u64 played_sample_count;
|
||||
/* 0x08 */ u32 wave_buffers_consumed;
|
||||
|
|
@ -349,6 +400,10 @@ public:
|
|||
f32 prev_volume{};
|
||||
/// Biquad filters for generating filter commands on this voice
|
||||
std::array<BiquadFilterParameter, MaxBiquadFilters> biquads{};
|
||||
/// Float biquad filters for REV15+ (native float coefficients)
|
||||
std::array<BiquadFilterParameter2, MaxBiquadFilters> biquads_float{};
|
||||
/// Use float biquad coefficients (REV15+)
|
||||
bool use_float_biquads{};
|
||||
/// Number of active wavebuffers
|
||||
u32 wave_buffer_count{};
|
||||
/// Current playing wavebuffer index
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue