Compare commits
3 commits
master
...
regression
| Author | SHA1 | Date | |
|---|---|---|---|
|
790f78e0ec | ||
|
|
daa5f94915 | ||
|
|
17556bf64b |
51 changed files with 540 additions and 911 deletions
|
|
@ -253,16 +253,16 @@
|
|||
<item>@string/scaling_filter_nearest_neighbor</item>
|
||||
<item>@string/scaling_filter_bilinear</item>
|
||||
<item>@string/scaling_filter_bicubic</item>
|
||||
<item>@string/scaling_filter_zero_tangent</item>
|
||||
<item>@string/scaling_filter_bspline</item>
|
||||
<item>@string/scaling_filter_mitchell</item>
|
||||
<item>@string/scaling_filter_spline1</item>
|
||||
<item>@string/scaling_filter_gaussian</item>
|
||||
<item>@string/scaling_filter_lanczos</item>
|
||||
<item>@string/scaling_filter_scale_force</item>
|
||||
<item>@string/scaling_filter_fsr</item>
|
||||
<item>@string/scaling_filter_area</item>
|
||||
<item>@string/scaling_filter_mmpx</item>
|
||||
<item>@string/scaling_filter_zero_tangent</item>
|
||||
<item>@string/scaling_filter_bspline</item>
|
||||
<item>@string/scaling_filter_mitchell</item>
|
||||
<item>@string/scaling_filter_spline1</item>
|
||||
</string-array>
|
||||
|
||||
<integer-array name="rendererScalingFilterValues">
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@
|
|||
#include <ranges>
|
||||
|
||||
namespace AudioCore {
|
||||
constexpr u32 CurrentRevision = 15;
|
||||
constexpr u32 CurrentRevision = 16;
|
||||
|
||||
enum class SupportTags {
|
||||
CommandProcessingTimeEstimatorVersion4,
|
||||
|
|
@ -47,10 +47,6 @@ enum class SupportTags {
|
|||
DelayChannelMappingChange,
|
||||
ReverbChannelMappingChange,
|
||||
I3dl2ReverbChannelMappingChange,
|
||||
SplitterPrevVolumeReset,
|
||||
SplitterBiquadFilterParameter,
|
||||
SplitterDestinationV2b,
|
||||
VoiceInParameterV2,
|
||||
|
||||
// Not a real tag, just here to get the count.
|
||||
Size
|
||||
|
|
@ -95,10 +91,6 @@ 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,20 +193,4 @@ 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,6 +1,3 @@
|
|||
// 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
|
||||
|
||||
|
|
@ -364,38 +361,6 @@ 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,6 +64,8 @@ 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};
|
||||
|
||||
|
|
@ -74,104 +76,8 @@ 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++) {
|
||||
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;
|
||||
const auto& in_param{in_params[i]};
|
||||
std::array<VoiceState*, MaxChannels> voice_states{};
|
||||
|
||||
if (!in_param.in_use) {
|
||||
|
|
@ -195,14 +101,6 @@ 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);
|
||||
}
|
||||
|
|
@ -223,7 +121,7 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
|
|||
new_voice_count += in_param.channel_count;
|
||||
}
|
||||
|
||||
auto consumed_input_size{voice_count * in_stride};
|
||||
auto consumed_input_size{voice_count * static_cast<u32>(sizeof(VoiceInfo::InParameter))};
|
||||
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={}",
|
||||
|
|
@ -359,31 +257,18 @@ 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,13 +237,6 @@ 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));
|
||||
|
||||
|
|
@ -270,9 +263,6 @@ 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));
|
||||
|
||||
|
|
@ -668,13 +658,6 @@ 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,40 +51,6 @@ 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.
|
||||
*
|
||||
|
|
@ -132,14 +98,8 @@ void BiquadFilterCommand::Process(const AudioRenderer::CommandListProcessor& pro
|
|||
processor.mix_buffers.subspan(output * processor.sample_count, processor.sample_count)};
|
||||
|
||||
if (use_float_processing) {
|
||||
// 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,6 +1,3 @@
|
|||
// 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
|
||||
|
||||
|
|
@ -53,16 +50,12 @@ 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;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -79,18 +72,4 @@ 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,6 +1,3 @@
|
|||
// 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
|
||||
|
||||
|
|
@ -36,16 +33,10 @@ void MultiTapBiquadFilterCommand::Process(const AudioRenderer::CommandListProces
|
|||
*state = {};
|
||||
}
|
||||
|
||||
// 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool MultiTapBiquadFilterCommand::Verify(const AudioRenderer::CommandListProcessor& processor) {
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// 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
|
||||
|
||||
|
|
@ -52,16 +49,12 @@ 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,16 +35,12 @@ 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 BehaviorInfo& behavior) {
|
||||
const u32 destination_count_, const bool splitter_bug_fixed_) {
|
||||
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 {
|
||||
|
|
@ -88,7 +84,7 @@ bool SplitterContext::Initialize(const BehaviorInfo& behavior,
|
|||
}
|
||||
|
||||
Setup(splitter_infos, params.splitter_infos, splitter_destinations,
|
||||
params.splitter_destinations, behavior.IsSplitterBugFixed(), behavior);
|
||||
params.splitter_destinations, behavior.IsSplitterBugFixed());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
|
@ -141,104 +137,19 @@ 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++) {
|
||||
// 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);
|
||||
auto data_header{
|
||||
reinterpret_cast<const SplitterDestinationData::InParameter*>(input + offset)};
|
||||
|
||||
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);
|
||||
splitter_destinations[data_header->id].Update(*data_header);
|
||||
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));
|
||||
}
|
||||
}
|
||||
|
||||
return offset;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// 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
|
||||
|
||||
|
|
@ -171,11 +168,10 @@ 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, const BehaviorInfo& behavior);
|
||||
bool splitter_bug_fixed);
|
||||
|
||||
/// Workbuffer for splitters
|
||||
std::span<SplitterInfo> splitter_infos{};
|
||||
|
|
@ -187,12 +183,6 @@ 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,6 +1,3 @@
|
|||
// 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
|
||||
|
||||
|
|
@ -87,14 +84,4 @@ 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,6 +1,3 @@
|
|||
// 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
|
||||
|
||||
|
|
@ -19,72 +16,16 @@ 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);
|
||||
|
||||
/**
|
||||
|
|
@ -137,7 +78,7 @@ public:
|
|||
f32 GetMixVolumePrev(u32 index) const;
|
||||
|
||||
/**
|
||||
* Get the previous mix volumes for all mix buffers.
|
||||
* Get the previous mix volumes for all mix buffers in this destination.
|
||||
*
|
||||
* @return Span of previous mix buffer volumes.
|
||||
*/
|
||||
|
|
@ -174,20 +115,6 @@ 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;
|
||||
|
|
@ -197,8 +124,6 @@ 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,6 +1,3 @@
|
|||
// 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
|
||||
|
||||
|
|
@ -138,17 +135,6 @@ 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;
|
||||
|
|
@ -182,43 +168,6 @@ 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;
|
||||
|
|
@ -400,10 +349,6 @@ 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
|
||||
|
|
|
|||
|
|
@ -143,7 +143,7 @@ ENUM(ConfirmStop, Ask_Always, Ask_Based_On_Game, Ask_Never);
|
|||
ENUM(FullscreenMode, Borderless, Exclusive);
|
||||
ENUM(NvdecEmulation, Off, Cpu, Gpu);
|
||||
ENUM(ResolutionSetup, Res1_4X, Res1_2X, Res3_4X, Res1X, Res5_4X, Res3_2X, Res2X, Res3X, Res4X, Res5X, Res6X, Res7X, Res8X);
|
||||
ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Gaussian, Lanczos, ScaleForce, Fsr, Area, ZeroTangent, BSpline, Mitchell, Spline1, Mmpx, MaxEnum);
|
||||
ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, ZeroTangent, BSpline, Mitchell, Spline1, Gaussian, Lanczos, ScaleForce, Fsr, Area, Mmpx, MaxEnum);
|
||||
ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
|
||||
ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
|
||||
ENUM(ConsoleMode, Handheld, Docked);
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -109,6 +112,9 @@ public:
|
|||
|
||||
void ReadBlock(DAddr address, void* dest_pointer, size_t size);
|
||||
void ReadBlockUnsafe(DAddr address, void* dest_pointer, size_t size);
|
||||
#ifdef YUZU_DEBUG
|
||||
bool ReadBlockFastChecked(DAddr address, void* dest_pointer, size_t size);
|
||||
#endif
|
||||
void WriteBlock(DAddr address, const void* src_pointer, size_t size);
|
||||
void WriteBlockUnsafe(DAddr address, const void* src_pointer, size_t size);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -467,6 +470,29 @@ void DeviceMemoryManager<Traits>::ReadBlockUnsafe(DAddr address, void* dest_poin
|
|||
});
|
||||
}
|
||||
|
||||
#ifdef YUZU_DEBUG
|
||||
template <typename Traits>
|
||||
bool DeviceMemoryManager<Traits>::ReadBlockFastChecked(DAddr address, void* dest_pointer,
|
||||
size_t size) {
|
||||
bool success = true;
|
||||
WalkBlock(
|
||||
address, size,
|
||||
[&](size_t copy_amount, DAddr current_vaddr) {
|
||||
LOG_CRITICAL(Render, "DeviceMemory OOB/unmapped: addr=0x{:x} size={}", current_vaddr,
|
||||
size);
|
||||
std::memset(dest_pointer, 0, copy_amount);
|
||||
success = false;
|
||||
},
|
||||
[&](size_t copy_amount, const u8* const src_ptr) {
|
||||
std::memcpy(dest_pointer, src_ptr, copy_amount);
|
||||
},
|
||||
[&](const std::size_t copy_amount) {
|
||||
dest_pointer = static_cast<u8*>(dest_pointer) + copy_amount;
|
||||
});
|
||||
return success;
|
||||
}
|
||||
#endif
|
||||
|
||||
template <typename Traits>
|
||||
void DeviceMemoryManager<Traits>::WriteBlockUnsafe(DAddr address, const void* src_pointer,
|
||||
size_t size) {
|
||||
|
|
|
|||
|
|
@ -509,9 +509,6 @@ std::vector<std::string> ProfileManager::FindOrphanedProfiles()
|
|||
good_uuids.emplace_back(uuid_string);
|
||||
}
|
||||
|
||||
// used for acnh, etc
|
||||
good_uuids.emplace_back("00000000000000000000000000000000");
|
||||
|
||||
// TODO: fetch save_id programmatically
|
||||
const auto path = Common::FS::GetEdenPath(Common::FS::EdenPath::NANDDir)
|
||||
/ "user/save/0000000000000000";
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -71,6 +68,42 @@ std::string ResolveURL(const std::string& url) {
|
|||
return url.substr(0, index) + "lp1" + url.substr(index + 1);
|
||||
}
|
||||
|
||||
WebArgInputTLVMap ReadWebArgs(const std::vector<u8>& web_arg, WebArgHeader& web_arg_header) {
|
||||
std::memcpy(&web_arg_header, web_arg.data(), sizeof(WebArgHeader));
|
||||
|
||||
if (web_arg.size() == sizeof(WebArgHeader)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
WebArgInputTLVMap input_tlv_map;
|
||||
|
||||
u64 current_offset = sizeof(WebArgHeader);
|
||||
|
||||
for (std::size_t i = 0; i < web_arg_header.total_tlv_entries; ++i) {
|
||||
if (web_arg.size() < current_offset + sizeof(WebArgInputTLV)) {
|
||||
return input_tlv_map;
|
||||
}
|
||||
|
||||
WebArgInputTLV input_tlv;
|
||||
std::memcpy(&input_tlv, web_arg.data() + current_offset, sizeof(WebArgInputTLV));
|
||||
|
||||
current_offset += sizeof(WebArgInputTLV);
|
||||
|
||||
if (web_arg.size() < current_offset + input_tlv.arg_data_size) {
|
||||
return input_tlv_map;
|
||||
}
|
||||
|
||||
std::vector<u8> data(input_tlv.arg_data_size);
|
||||
std::memcpy(data.data(), web_arg.data() + current_offset, input_tlv.arg_data_size);
|
||||
|
||||
current_offset += input_tlv.arg_data_size;
|
||||
|
||||
input_tlv_map.insert_or_assign(input_tlv.input_tlv_type, std::move(data));
|
||||
}
|
||||
|
||||
return input_tlv_map;
|
||||
}
|
||||
|
||||
FileSys::VirtualFile GetOfflineRomFS(Core::System& system, u64 title_id,
|
||||
FileSys::ContentRecordType nca_type) {
|
||||
if (nca_type == FileSys::ContentRecordType::Data) {
|
||||
|
|
@ -111,43 +144,6 @@ FileSys::VirtualFile GetOfflineRomFS(Core::System& system, u64 title_id,
|
|||
}
|
||||
}
|
||||
|
||||
#ifdef YUZU_USE_QT_WEB_ENGINE
|
||||
WebArgInputTLVMap ReadWebArgs(const std::vector<u8>& web_arg, WebArgHeader& web_arg_header) {
|
||||
std::memcpy(&web_arg_header, web_arg.data(), sizeof(WebArgHeader));
|
||||
|
||||
if (web_arg.size() == sizeof(WebArgHeader)) {
|
||||
return {};
|
||||
}
|
||||
|
||||
WebArgInputTLVMap input_tlv_map;
|
||||
|
||||
u64 current_offset = sizeof(WebArgHeader);
|
||||
|
||||
for (std::size_t i = 0; i < web_arg_header.total_tlv_entries; ++i) {
|
||||
if (web_arg.size() < current_offset + sizeof(WebArgInputTLV)) {
|
||||
return input_tlv_map;
|
||||
}
|
||||
|
||||
WebArgInputTLV input_tlv;
|
||||
std::memcpy(&input_tlv, web_arg.data() + current_offset, sizeof(WebArgInputTLV));
|
||||
|
||||
current_offset += sizeof(WebArgInputTLV);
|
||||
|
||||
if (web_arg.size() < current_offset + input_tlv.arg_data_size) {
|
||||
return input_tlv_map;
|
||||
}
|
||||
|
||||
std::vector<u8> data(input_tlv.arg_data_size);
|
||||
std::memcpy(data.data(), web_arg.data() + current_offset, input_tlv.arg_data_size);
|
||||
|
||||
current_offset += input_tlv.arg_data_size;
|
||||
|
||||
input_tlv_map.insert_or_assign(input_tlv.input_tlv_type, std::move(data));
|
||||
}
|
||||
|
||||
return input_tlv_map;
|
||||
}
|
||||
|
||||
void ExtractSharedFonts(Core::System& system) {
|
||||
static constexpr std::array<const char*, 7> DECRYPTED_SHARED_FONTS{
|
||||
"FontStandard.ttf",
|
||||
|
|
@ -225,7 +221,6 @@ void ExtractSharedFonts(Core::System& system) {
|
|||
FileSys::VfsRawCopy(decrypted_font, out_file);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
} // namespace
|
||||
|
||||
|
|
@ -237,7 +232,6 @@ WebBrowser::WebBrowser(Core::System& system_, std::shared_ptr<Applet> applet_,
|
|||
WebBrowser::~WebBrowser() = default;
|
||||
|
||||
void WebBrowser::Initialize() {
|
||||
#ifdef YUZU_USE_QT_WEB_ENGINE
|
||||
FrontendApplet::Initialize();
|
||||
|
||||
LOG_INFO(Service_AM, "Initializing Web Browser Applet.");
|
||||
|
|
@ -290,7 +284,6 @@ void WebBrowser::Initialize() {
|
|||
ASSERT_MSG(false, "Invalid ShimKind={}", web_arg_header.shim_kind);
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
Result WebBrowser::GetStatus() const {
|
||||
|
|
@ -302,7 +295,6 @@ void WebBrowser::ExecuteInteractive() {
|
|||
}
|
||||
|
||||
void WebBrowser::Execute() {
|
||||
#ifdef YUZU_USE_QT_WEB_ENGINE
|
||||
switch (web_arg_header.shim_kind) {
|
||||
case ShimKind::Shop:
|
||||
ExecuteShop();
|
||||
|
|
@ -330,10 +322,6 @@ void WebBrowser::Execute() {
|
|||
WebBrowserExit(WebExitReason::EndButtonPressed);
|
||||
break;
|
||||
}
|
||||
#else
|
||||
LOG_INFO(Service_AM, "Web Browser Applet disabled, skipping.");
|
||||
WebBrowserExit(WebExitReason::EndButtonPressed);
|
||||
#endif
|
||||
}
|
||||
|
||||
void WebBrowser::ExtractOfflineRomFS() {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -178,7 +175,6 @@ ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_, std::shared_
|
|||
{0, D<&ILibraryAppletCreator::CreateLibraryApplet>, "CreateLibraryApplet"},
|
||||
{1, nullptr, "TerminateAllLibraryApplets"},
|
||||
{2, nullptr, "AreAnyLibraryAppletsLeft"},
|
||||
{3, D<&ILibraryAppletCreator::CreateLibraryAppletEx>, "CreateLibraryAppletEx"},
|
||||
{10, D<&ILibraryAppletCreator::CreateStorage>, "CreateStorage"},
|
||||
{11, D<&ILibraryAppletCreator::CreateTransferMemoryStorage>, "CreateTransferMemoryStorage"},
|
||||
{12, D<&ILibraryAppletCreator::CreateHandleStorage>, "CreateHandleStorage"},
|
||||
|
|
@ -214,32 +210,6 @@ Result ILibraryAppletCreator::CreateLibraryApplet(
|
|||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ILibraryAppletCreator::CreateLibraryAppletEx(
|
||||
Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
|
||||
LibraryAppletMode library_applet_mode, u64 thread_id) {
|
||||
LOG_DEBUG(Service_AM, "called with applet_id={} applet_mode={} thread_id={}", applet_id,
|
||||
library_applet_mode, thread_id);
|
||||
|
||||
std::shared_ptr<ILibraryAppletAccessor> library_applet;
|
||||
if (ShouldCreateGuestApplet(applet_id)) {
|
||||
library_applet =
|
||||
CreateGuestApplet(system, m_window_system, m_applet, applet_id, library_applet_mode);
|
||||
}
|
||||
if (!library_applet) {
|
||||
library_applet =
|
||||
CreateFrontendApplet(system, m_window_system, m_applet, applet_id, library_applet_mode);
|
||||
}
|
||||
if (!library_applet) {
|
||||
LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", applet_id);
|
||||
R_THROW(ResultUnknown);
|
||||
}
|
||||
|
||||
// Applet is created, can now be launched.
|
||||
m_applet->library_applet_launchable_event.Signal();
|
||||
*out_library_applet_accessor = library_applet;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result ILibraryAppletCreator::CreateStorage(Out<SharedPointer<IStorage>> out_storage, s64 size) {
|
||||
LOG_DEBUG(Service_AM, "called, size={}", size);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -27,9 +24,6 @@ private:
|
|||
Result CreateLibraryApplet(
|
||||
Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
|
||||
LibraryAppletMode library_applet_mode);
|
||||
Result CreateLibraryAppletEx(
|
||||
Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
|
||||
LibraryAppletMode library_applet_mode, u64 thread_id);
|
||||
Result CreateStorage(Out<SharedPointer<IStorage>> out_storage, s64 size);
|
||||
Result CreateTransferMemoryStorage(
|
||||
Out<SharedPointer<IStorage>> out_storage, bool is_writable, s64 size,
|
||||
|
|
|
|||
|
|
@ -128,7 +128,6 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
|
|||
{406, nullptr, "GetApplicationControlProperty"},
|
||||
{407, nullptr, "ListApplicationTitle"},
|
||||
{408, nullptr, "ListApplicationIcon"},
|
||||
{419, D<&IApplicationManagerInterface::RequestDownloadApplicationControlDataInBackground>, "RequestDownloadApplicationControlDataInBackground"},
|
||||
{502, nullptr, "RequestCheckGameCardRegistration"},
|
||||
{503, nullptr, "RequestGameCardRegistrationGoldPoint"},
|
||||
{504, nullptr, "RequestRegisterGameCard"},
|
||||
|
|
@ -211,7 +210,6 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
|
|||
{1703, nullptr, "GetApplicationViewDownloadErrorContext"},
|
||||
{1704, D<&IApplicationManagerInterface::GetApplicationViewWithPromotionInfo>, "GetApplicationViewWithPromotionInfo"},
|
||||
{1705, nullptr, "IsPatchAutoDeletableApplication"},
|
||||
{1706, D<&IApplicationManagerInterface::Unknown1706>, "Unknown1706"},
|
||||
{1800, nullptr, "IsNotificationSetupCompleted"},
|
||||
{1801, nullptr, "GetLastNotificationInfoCount"},
|
||||
{1802, nullptr, "ListLastNotificationInfo"},
|
||||
|
|
@ -311,7 +309,6 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
|
|||
{4022, D<&IApplicationManagerInterface::Unknown4022>, "Unknown4022"},
|
||||
{4023, D<&IApplicationManagerInterface::Unknown4023>, "Unknown4023"},
|
||||
{4088, D<&IApplicationManagerInterface::Unknown4022>, "Unknown4088"},
|
||||
{4053, D<&IApplicationManagerInterface::Unknown4053>, "Unknown4053"},
|
||||
{9999, nullptr, "GetApplicationCertificate"},
|
||||
};
|
||||
// clang-format on
|
||||
|
|
@ -529,37 +526,6 @@ Result IApplicationManagerInterface::GetApplicationTerminateResult(Out<Result> o
|
|||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result IApplicationManagerInterface::RequestDownloadApplicationControlDataInBackground(
|
||||
u64 unk, u64 application_id) {
|
||||
LOG_WARNING(Service_NS, "(STUBBED), app={:016X} unk={}", application_id, unk);
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result IApplicationManagerInterface::Unknown1706(
|
||||
OutBuffer<BufferAttr_HipcAutoSelect> out_buffer_58,
|
||||
InBuffer<BufferAttr_HipcMapAlias> in_buffer_8) {
|
||||
LOG_WARNING(Service_NS, "(STUBBED) Unknown1706 called: out_size={} in_size={}",
|
||||
out_buffer_58.size(), in_buffer_8.size());
|
||||
|
||||
if (out_buffer_58.size() < 0x58 || in_buffer_8.size() < 0x8) {
|
||||
R_THROW(ResultUnknown);
|
||||
}
|
||||
|
||||
u64 application_id = 0;
|
||||
std::memcpy(&application_id, in_buffer_8.data(), sizeof(u64));
|
||||
|
||||
ApplicationView view{};
|
||||
view.application_id = application_id;
|
||||
view.unk = 0x70000;
|
||||
view.flags = 0x401f17;
|
||||
|
||||
std::memset(out_buffer_58.data(), 0, out_buffer_58.size());
|
||||
std::memcpy(out_buffer_58.data(), &view, sizeof(ApplicationView));
|
||||
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result IApplicationManagerInterface::Unknown4022(
|
||||
OutCopyHandle<Kernel::KReadableEvent> out_event) {
|
||||
LOG_WARNING(Service_NS, "(STUBBED) called");
|
||||
|
|
@ -573,9 +539,4 @@ Result IApplicationManagerInterface::Unknown4023(Out<u64> out_result) {
|
|||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result IApplicationManagerInterface::Unknown4053() {
|
||||
LOG_WARNING(Service_NS, "(STUBBED) called.");
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
} // namespace Service::NS
|
||||
|
|
|
|||
|
|
@ -55,12 +55,6 @@ public:
|
|||
Result GetApplicationTerminateResult(Out<Result> out_result, u64 application_id);
|
||||
Result Unknown4022(OutCopyHandle<Kernel::KReadableEvent> out_event);
|
||||
Result Unknown4023(Out<u64> out_result);
|
||||
Result Unknown4053();
|
||||
|
||||
Result RequestDownloadApplicationControlDataInBackground(u64 unk,
|
||||
u64 application_id);
|
||||
Result Unknown1706(OutBuffer<BufferAttr_HipcAutoSelect> out_buffer_58,
|
||||
InBuffer<BufferAttr_HipcMapAlias> in_buffer_8);
|
||||
|
||||
private:
|
||||
KernelHelpers::ServiceContext service_context;
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -86,9 +83,8 @@ static_assert(sizeof(PromotionInfo) == 0x20, "PromotionInfo has incorrect size."
|
|||
struct ApplicationViewWithPromotionInfo {
|
||||
ApplicationView view; ///< \ref NsApplicationView
|
||||
PromotionInfo promotion; ///< \ref NsPromotionInfo
|
||||
std::array<u8, 0x8> padding{}; ///< Extra padding for newer HOS versions
|
||||
};
|
||||
static_assert(sizeof(ApplicationViewWithPromotionInfo) == 0x78,
|
||||
static_assert(sizeof(ApplicationViewWithPromotionInfo) == 0x70,
|
||||
"ApplicationViewWithPromotionInfo has incorrect size.");
|
||||
|
||||
struct ApplicationOccupiedSizeEntity {
|
||||
|
|
@ -117,10 +113,4 @@ struct Uid {
|
|||
};
|
||||
static_assert(sizeof(Uid) == 0x10, "Uid has incorrect size.");
|
||||
|
||||
struct ApplicationDisplayData {
|
||||
std::array<char, 0x200> application_name;
|
||||
std::array<char, 0x100> developer_name;
|
||||
};
|
||||
static_assert(sizeof(ApplicationDisplayData) == 0x300, "ApplicationDisplayData has incorrect size.");
|
||||
|
||||
} // namespace Service::NS
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -10,7 +7,6 @@
|
|||
#include "core/file_sys/vfs/vfs.h"
|
||||
#include "core/hle/service/cmif_serialization.h"
|
||||
#include "core/hle/service/ns/language.h"
|
||||
#include "core/hle/service/ns/ns_types.h"
|
||||
#include "core/hle/service/ns/ns_results.h"
|
||||
#include "core/hle/service/ns/read_only_application_control_data_interface.h"
|
||||
#include "core/hle/service/set/settings_server.h"
|
||||
|
|
@ -27,7 +23,6 @@ IReadOnlyApplicationControlDataInterface::IReadOnlyApplicationControlDataInterfa
|
|||
{2, D<&IReadOnlyApplicationControlDataInterface::ConvertApplicationLanguageToLanguageCode>, "ConvertApplicationLanguageToLanguageCode"},
|
||||
{3, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
|
||||
{4, nullptr, "SelectApplicationDesiredLanguage"},
|
||||
{5, D<&IReadOnlyApplicationControlDataInterface::GetApplicationDisplayData>, "GetApplicationDisplayData"},
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
|
|
@ -124,33 +119,4 @@ Result IReadOnlyApplicationControlDataInterface::ConvertApplicationLanguageToLan
|
|||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result IReadOnlyApplicationControlDataInterface::GetApplicationDisplayData(
|
||||
OutBuffer<BufferAttr_HipcMapAlias> out_buffer, Out<u64> out_size, u64 language_code,
|
||||
u64 application_id) {
|
||||
LOG_INFO(Service_NS, "called with application_id={:016X}, language_code={:016X}",
|
||||
application_id, language_code);
|
||||
|
||||
constexpr u64 payload_size = sizeof(ApplicationDisplayData);
|
||||
|
||||
if (out_buffer.size() < payload_size) {
|
||||
LOG_ERROR(Service_NS, "output buffer is too small! (actual={}, expected_min={})",
|
||||
out_buffer.size(), payload_size);
|
||||
R_THROW(ResultUnknown);
|
||||
}
|
||||
|
||||
const FileSys::PatchManager pm{application_id, system.GetFileSystemController(),
|
||||
system.GetContentProvider()};
|
||||
const auto control = pm.GetControlMetadata();
|
||||
|
||||
ApplicationDisplayData display_data{};
|
||||
|
||||
std::memset(display_data.application_name.data(), 0, display_data.application_name.size());
|
||||
std::memset(display_data.developer_name.data(), 0, display_data.developer_name.size());
|
||||
|
||||
std::memcpy(out_buffer.data(), &display_data, payload_size);
|
||||
*out_size = payload_size;
|
||||
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
} // namespace Service::NS
|
||||
|
|
|
|||
|
|
@ -1,15 +1,12 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "core/hle/service/cmif_types.h"
|
||||
#include "core/hle/service/service.h"
|
||||
#include "core/hle/service/ns/language.h"
|
||||
#include "core/hle/service/ns/ns_types.h"
|
||||
#include "core/hle/service/service.h"
|
||||
|
||||
namespace Service::NS {
|
||||
|
||||
|
|
@ -19,6 +16,7 @@ public:
|
|||
explicit IReadOnlyApplicationControlDataInterface(Core::System& system_);
|
||||
~IReadOnlyApplicationControlDataInterface() override;
|
||||
|
||||
public:
|
||||
Result GetApplicationControlData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
|
||||
Out<u32> out_actual_size,
|
||||
ApplicationControlSource application_control_source,
|
||||
|
|
@ -27,10 +25,6 @@ public:
|
|||
u32 supported_languages);
|
||||
Result ConvertApplicationLanguageToLanguageCode(Out<u64> out_language_code,
|
||||
ApplicationLanguage application_language);
|
||||
|
||||
Result GetApplicationDisplayData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
|
||||
Out<u64> out_size, u64 language_code,
|
||||
u64 application_id);
|
||||
};
|
||||
|
||||
} // namespace Service::NS
|
||||
|
|
|
|||
|
|
@ -1,13 +1,8 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
#include "core/hle/service/cmif_serialization.h"
|
||||
#include "core/hle/service/ns/read_only_application_record_interface.h"
|
||||
#include "core/hle/service/ns/ns_types.h"
|
||||
#include "core/hle/service/ns/application_manager_interface.h"
|
||||
|
||||
namespace Service::NS {
|
||||
|
||||
|
|
@ -18,8 +13,6 @@ IReadOnlyApplicationRecordInterface::IReadOnlyApplicationRecordInterface(Core::S
|
|||
{1, nullptr, "NotifyApplicationFailure"},
|
||||
{2, D<&IReadOnlyApplicationRecordInterface::IsDataCorruptedResult>,
|
||||
"IsDataCorruptedResult"},
|
||||
{3, D<&IReadOnlyApplicationRecordInterface::ListApplicationRecord>,
|
||||
"ListApplicationRecord"},
|
||||
};
|
||||
// clang-format on
|
||||
|
||||
|
|
@ -42,14 +35,4 @@ Result IReadOnlyApplicationRecordInterface::IsDataCorruptedResult(
|
|||
R_SUCCEED();
|
||||
}
|
||||
|
||||
Result IReadOnlyApplicationRecordInterface::ListApplicationRecord(
|
||||
OutArray<ApplicationRecord, BufferAttr_HipcMapAlias> out_records, Out<s32> out_count,
|
||||
s32 entry_offset) {
|
||||
LOG_DEBUG(Service_NS, "delegating to IApplicationManagerInterface::ListApplicationRecord, offset={} limit={}",
|
||||
entry_offset, out_records.size());
|
||||
|
||||
R_RETURN(IApplicationManagerInterface(system).ListApplicationRecord(out_records, out_count,
|
||||
entry_offset));
|
||||
}
|
||||
|
||||
} // namespace Service::NS
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -8,7 +5,6 @@
|
|||
|
||||
#include "core/hle/service/cmif_types.h"
|
||||
#include "core/hle/service/service.h"
|
||||
#include "core/hle/service/ns/ns_types.h"
|
||||
|
||||
namespace Service::NS {
|
||||
|
||||
|
|
@ -21,9 +17,6 @@ public:
|
|||
private:
|
||||
Result HasApplicationRecord(Out<bool> out_has_application_record, u64 program_id);
|
||||
Result IsDataCorruptedResult(Out<bool> out_is_data_corrupted_result, Result result);
|
||||
Result ListApplicationRecord(
|
||||
OutArray<ApplicationRecord, BufferAttr_HipcMapAlias> out_records, Out<s32> out_count,
|
||||
s32 entry_offset);
|
||||
};
|
||||
|
||||
} // namespace Service::NS
|
||||
|
|
|
|||
|
|
@ -38,7 +38,6 @@ IParentalControlService::IParentalControlService(Core::System& system_, Capabili
|
|||
{1016, nullptr, "ConfirmShowNewsPermission"},
|
||||
{1017, D<&IParentalControlService::EndFreeCommunication>, "EndFreeCommunication"},
|
||||
{1018, D<&IParentalControlService::IsFreeCommunicationAvailable>, "IsFreeCommunicationAvailable"},
|
||||
{1019, D<&IParentalControlService::ConfirmLaunchApplicationPermission>, "ConfirmLaunchApplicationPermission"},
|
||||
{1031, D<&IParentalControlService::IsRestrictionEnabled>, "IsRestrictionEnabled"},
|
||||
{1032, D<&IParentalControlService::GetSafetyLevel>, "GetSafetyLevel"},
|
||||
{1033, nullptr, "SetSafetyLevel"},
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
|
|
@ -162,17 +159,6 @@ struct NpadGcTriggerState {
|
|||
};
|
||||
static_assert(sizeof(NpadGcTriggerState) == 0x10, "NpadGcTriggerState is an invalid size");
|
||||
|
||||
// This is nn::hid::NpadCondition (global controller condition structure)
|
||||
struct NpadCondition {
|
||||
u32 _00{};
|
||||
u32 is_initialized{1};
|
||||
u32 hold_type{static_cast<u32>(NpadJoyHoldType::Horizontal)};
|
||||
u32 is_valid{1};
|
||||
};
|
||||
static_assert(sizeof(NpadCondition) == 0x10, "NpadCondition is an invalid size");
|
||||
|
||||
|
||||
|
||||
// This is nn::hid::NpadSystemProperties
|
||||
struct NPadSystemProperties {
|
||||
union {
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -47,7 +44,8 @@ struct Lifo {
|
|||
buffer_count++;
|
||||
}
|
||||
buffer_tail = GetNextEntryIndex();
|
||||
entries[buffer_tail].sampling_number = new_state.sampling_number << 1;
|
||||
const auto& previous_entry = ReadPreviousEntry();
|
||||
entries[buffer_tail].sampling_number = previous_entry.sampling_number + 1;
|
||||
entries[buffer_tail].state = new_state;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
|
|
@ -204,9 +201,7 @@ static_assert(sizeof(ConsoleSixAxisSensorSharedMemoryFormat) == 0x20,
|
|||
|
||||
// This is nn::hid::detail::SharedMemoryFormat
|
||||
struct SharedMemoryFormat {
|
||||
void Initialize() {
|
||||
npad_condition = NpadCondition{};
|
||||
}
|
||||
void Initialize() {}
|
||||
|
||||
DebugPadSharedMemoryFormat debug_pad;
|
||||
TouchScreenSharedMemoryFormat touch_screen;
|
||||
|
|
@ -223,9 +218,7 @@ struct SharedMemoryFormat {
|
|||
ConsoleSixAxisSensorSharedMemoryFormat console;
|
||||
INSERT_PADDING_BYTES(0x19E0);
|
||||
MouseSharedMemoryFormat debug_mouse;
|
||||
INSERT_PADDING_BYTES(0x200);
|
||||
NpadCondition npad_condition;
|
||||
INSERT_PADDING_BYTES(0x1DF0);
|
||||
INSERT_PADDING_BYTES(0x2000);
|
||||
};
|
||||
static_assert(offsetof(SharedMemoryFormat, debug_pad) == 0x0, "debug_pad has wrong offset");
|
||||
static_assert(offsetof(SharedMemoryFormat, touch_screen) == 0x400, "touch_screen has wrong offset");
|
||||
|
|
@ -243,8 +236,6 @@ static_assert(offsetof(SharedMemoryFormat, npad) == 0x9A00, "npad has wrong offs
|
|||
static_assert(offsetof(SharedMemoryFormat, gesture) == 0x3BA00, "gesture has wrong offset");
|
||||
static_assert(offsetof(SharedMemoryFormat, console) == 0x3C200, "console has wrong offset");
|
||||
static_assert(offsetof(SharedMemoryFormat, debug_mouse) == 0x3DC00, "debug_mouse has wrong offset");
|
||||
static_assert(offsetof(SharedMemoryFormat, npad_condition) == 0x3E200,
|
||||
"npad_condition has wrong offset");
|
||||
static_assert(sizeof(SharedMemoryFormat) == 0x40000, "SharedMemoryFormat is an invalid size");
|
||||
|
||||
} // namespace Service::HID
|
||||
|
|
|
|||
|
|
@ -45,10 +45,6 @@ if (NOT APPLE AND ENABLE_OPENGL)
|
|||
target_compile_definitions(qt_common PUBLIC HAS_OPENGL)
|
||||
endif()
|
||||
|
||||
if (UNIX AND NOT APPLE)
|
||||
if (TARGET Qt6::GuiPrivate)
|
||||
target_link_libraries(qt_common PRIVATE Qt6::GuiPrivate)
|
||||
else()
|
||||
if (NOT WIN32)
|
||||
target_include_directories(qt_common PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
|
||||
endif()
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -549,16 +549,16 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent)
|
|||
PAIR(ScalingFilter, NearestNeighbor, tr("Nearest Neighbor")),
|
||||
PAIR(ScalingFilter, Bilinear, tr("Bilinear")),
|
||||
PAIR(ScalingFilter, Bicubic, tr("Bicubic")),
|
||||
PAIR(ScalingFilter, ZeroTangent, tr("Zero-Tangent")),
|
||||
PAIR(ScalingFilter, BSpline, tr("B-Spline")),
|
||||
PAIR(ScalingFilter, Mitchell, tr("Mitchell")),
|
||||
PAIR(ScalingFilter, Spline1, tr("Spline-1")),
|
||||
PAIR(ScalingFilter, Gaussian, tr("Gaussian")),
|
||||
PAIR(ScalingFilter, Lanczos, tr("Lanczos")),
|
||||
PAIR(ScalingFilter, ScaleForce, tr("ScaleForce")),
|
||||
PAIR(ScalingFilter, Fsr, tr("AMD FidelityFX™️ Super Resolution")),
|
||||
PAIR(ScalingFilter, Area, tr("Area")),
|
||||
PAIR(ScalingFilter, Mmpx, tr("MMPX")),
|
||||
PAIR(ScalingFilter, ZeroTangent, tr("Zero-Tangent")),
|
||||
PAIR(ScalingFilter, BSpline, tr("B-Spline")),
|
||||
PAIR(ScalingFilter, Mitchell, tr("Mitchell")),
|
||||
PAIR(ScalingFilter, Spline1, tr("Spline-1")),
|
||||
}});
|
||||
translations->insert({Settings::EnumMetadata<Settings::AntiAliasing>::Index(),
|
||||
{
|
||||
|
|
|
|||
|
|
@ -9,6 +9,8 @@
|
|||
#include <algorithm>
|
||||
#include <memory>
|
||||
#include <numeric>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
#include "common/range_sets.inc"
|
||||
#include "video_core/buffer_cache/buffer_cache_base.h"
|
||||
|
|
@ -19,6 +21,43 @@ namespace VideoCommon {
|
|||
|
||||
using Core::DEVICE_PAGESIZE;
|
||||
|
||||
namespace staging_detail {
|
||||
template <typename T, typename = void>
|
||||
struct has_flush_range : std::false_type {};
|
||||
template <typename T>
|
||||
struct has_flush_range<
|
||||
T, std::void_t<decltype(std::declval<T&>().FlushRange(size_t{}, size_t{}))>> : std::true_type {};
|
||||
|
||||
template <typename T, typename = void>
|
||||
struct has_invalidate_range : std::false_type {};
|
||||
template <typename T>
|
||||
struct has_invalidate_range<
|
||||
T, std::void_t<decltype(std::declval<T&>().InvalidateRange(size_t{}, size_t{}))>>
|
||||
: std::true_type {};
|
||||
} // namespace staging_detail
|
||||
|
||||
template <typename Ref>
|
||||
inline void StagingFlushRange(Ref& ref, size_t offset, size_t size) {
|
||||
if constexpr (staging_detail::has_flush_range<Ref>::value) {
|
||||
ref.FlushRange(offset, size);
|
||||
} else {
|
||||
(void)ref;
|
||||
(void)offset;
|
||||
(void)size;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Ref>
|
||||
inline void StagingInvalidateRange(Ref& ref, size_t offset, size_t size) {
|
||||
if constexpr (staging_detail::has_invalidate_range<Ref>::value) {
|
||||
ref.InvalidateRange(offset, size);
|
||||
} else {
|
||||
(void)ref;
|
||||
(void)offset;
|
||||
(void)size;
|
||||
}
|
||||
}
|
||||
|
||||
template <class P>
|
||||
BufferCache<P>::BufferCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, Runtime& runtime_)
|
||||
: runtime{runtime_}, device_memory{device_memory_}, memory_tracker{device_memory} {
|
||||
|
|
@ -386,7 +425,8 @@ void BufferCache<P>::BindHostComputeBuffers() {
|
|||
template <class P>
|
||||
void BufferCache<P>::SetUniformBuffersState(const std::array<u32, NUM_STAGES>& mask,
|
||||
const UniformBufferSizes* sizes) {
|
||||
if (channel_state->enabled_uniform_buffer_masks != mask) {
|
||||
const bool mask_changed = channel_state->enabled_uniform_buffer_masks != mask;
|
||||
if (mask_changed) {
|
||||
channel_state->fast_bound_uniform_buffers.fill(0);
|
||||
if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
|
||||
channel_state->dirty_uniform_buffers.fill(~u32{0});
|
||||
|
|
@ -632,6 +672,7 @@ void BufferCache<P>::PopAsyncBuffers() {
|
|||
u8* base = async_buffer->mapped_span.data();
|
||||
const size_t base_offset = async_buffer->offset;
|
||||
for (const auto& copy : downloads) {
|
||||
StagingInvalidateRange(*async_buffer, copy.dst_offset, copy.size);
|
||||
const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
|
||||
const u64 dst_offset = copy.dst_offset - base_offset;
|
||||
const u8* read_mapped_memory = base + dst_offset;
|
||||
|
|
@ -695,6 +736,7 @@ void BufferCache<P>::BindHostIndexBuffer() {
|
|||
{BufferCopy{.src_offset = upload_staging.offset, .dst_offset = 0, .size = size}}};
|
||||
std::memcpy(upload_staging.mapped_span.data(),
|
||||
draw_state.inline_index_draw_indexes.data(), size);
|
||||
StagingFlushRange(upload_staging, upload_staging.offset, size);
|
||||
runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true);
|
||||
} else {
|
||||
buffer.ImmediateUpload(0, draw_state.inline_index_draw_indexes);
|
||||
|
|
@ -817,7 +859,18 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
|
|||
channel_state->uniform_buffer_binding_sizes[stage][binding_index] = size;
|
||||
// Stream buffer path to avoid stalling on non-Nvidia drivers or Vulkan
|
||||
const std::span<u8> span = runtime.BindMappedUniformBuffer(stage, binding_index, size);
|
||||
#ifdef YUZU_DEBUG
|
||||
ASSERT(binding_index < NUM_GRAPHICS_UNIFORM_BUFFERS);
|
||||
ASSERT(span.size() >= size && "UBO stream span too small");
|
||||
if (!device_memory.ReadBlockFastChecked(device_addr, span.data(), size)) {
|
||||
LOG_CRITICAL(Render, "DeviceMemory OOB/unmapped: addr=0x{:x} size={}", device_addr, size);
|
||||
channel_state->fast_bound_uniform_buffers[stage] &= ~(1u << binding_index);
|
||||
ASSERT(false);
|
||||
return;
|
||||
}
|
||||
#else
|
||||
device_memory.ReadBlockUnsafe(device_addr, span.data(), size);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
// Classic cached path
|
||||
|
|
@ -826,7 +879,8 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
|
|||
}
|
||||
// Skip binding if it's not needed and if the bound buffer is not the fast version
|
||||
// This exists to avoid instances where the fast buffer is bound and a GPU write happens
|
||||
needs_bind |= HasFastUniformBufferBound(stage, binding_index);
|
||||
const bool was_fast_bound = HasFastUniformBufferBound(stage, binding_index);
|
||||
needs_bind |= was_fast_bound;
|
||||
if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
|
||||
needs_bind |= channel_state->uniform_buffer_binding_sizes[stage][binding_index] != size;
|
||||
}
|
||||
|
|
@ -1517,6 +1571,7 @@ void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
|
|||
// Apply the staging offset
|
||||
copy.src_offset += upload_staging.offset;
|
||||
}
|
||||
StagingFlushRange(upload_staging, upload_staging.offset, total_size_bytes);
|
||||
const bool can_reorder = runtime.CanReorderUpload(buffer, copies);
|
||||
runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true, can_reorder);
|
||||
}
|
||||
|
|
@ -1559,6 +1614,7 @@ void BufferCache<P>::InlineMemoryImplementation(DAddr dest_address, size_t copy_
|
|||
}};
|
||||
u8* const src_pointer = upload_staging.mapped_span.data();
|
||||
std::memcpy(src_pointer, inlined_buffer.data(), copy_size);
|
||||
StagingFlushRange(upload_staging, upload_staging.offset, copy_size);
|
||||
const bool can_reorder = runtime.CanReorderUpload(buffer, copies);
|
||||
runtime.CopyBuffer(buffer, upload_staging.buffer, copies, true, can_reorder);
|
||||
} else {
|
||||
|
|
@ -1613,6 +1669,7 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
|
|||
}
|
||||
runtime.CopyBuffer(download_staging.buffer, buffer, copies_span, true);
|
||||
runtime.Finish();
|
||||
StagingInvalidateRange(download_staging, download_staging.offset, total_size_bytes);
|
||||
for (const BufferCopy& copy : copies) {
|
||||
const DAddr copy_device_addr = buffer.CpuAddr() + copy.src_offset;
|
||||
// Undo the modified offset
|
||||
|
|
|
|||
|
|
@ -53,7 +53,6 @@ constexpr u32 NUM_COMPUTE_UNIFORM_BUFFERS = 8;
|
|||
constexpr u32 NUM_STORAGE_BUFFERS = 16;
|
||||
constexpr u32 NUM_TEXTURE_BUFFERS = 32;
|
||||
constexpr u32 NUM_STAGES = 5;
|
||||
|
||||
static_assert(NUM_GRAPHICS_UNIFORM_BUFFERS <= 32, "fast bitmask must fit u32");
|
||||
|
||||
using UniformBufferSizes = std::array<std::array<u32, NUM_GRAPHICS_UNIFORM_BUFFERS>, NUM_STAGES>;
|
||||
|
|
|
|||
|
|
@ -166,7 +166,7 @@ try
|
|||
|
||||
if (Settings::values.renderer_force_max_clock.GetValue() && device.ShouldBoostClocks()) {
|
||||
turbo_mode.emplace(instance, dld);
|
||||
scheduler.RegisterOnSubmit([this] { turbo_mode->QueueSubmitted(); });
|
||||
scheduler.AddOnSubmit([this] { turbo_mode->QueueSubmitted(); });
|
||||
}
|
||||
|
||||
Report();
|
||||
|
|
@ -176,7 +176,7 @@ try
|
|||
}
|
||||
|
||||
RendererVulkan::~RendererVulkan() {
|
||||
scheduler.RegisterOnSubmit([] {});
|
||||
scheduler.RegisterOnSubmit(std::function<void()>{});
|
||||
void(device.GetLogical().WaitIdle());
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -179,6 +179,11 @@ public:
|
|||
}();
|
||||
|
||||
u8* staging_data = host_visible ? buffer.Mapped().data() : staging.mapped_span.data();
|
||||
#ifdef YUZU_DEBUG
|
||||
if (!host_visible) {
|
||||
ASSERT(staging.mapped_span.size() >= size_bytes);
|
||||
}
|
||||
#endif
|
||||
const size_t quad_size = bytes_per_index * 6;
|
||||
|
||||
for (u32 first = 0; first < num_first_offset_copies; ++first) {
|
||||
|
|
@ -189,6 +194,7 @@ public:
|
|||
}
|
||||
|
||||
if (!host_visible) {
|
||||
staging.FlushRange(staging.offset, static_cast<VkDeviceSize>(size_bytes));
|
||||
scheduler.RequestOutsideRenderPassOperationContext();
|
||||
scheduler.Record([src_buffer = staging.buffer, src_offset = staging.offset,
|
||||
dst_buffer = *buffer, size_bytes](vk::CommandBuffer cmdbuf) {
|
||||
|
|
@ -337,11 +343,6 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
|
|||
uint8_pass = std::make_unique<Uint8Pass>(device, scheduler, descriptor_pool, staging_pool,
|
||||
compute_pass_descriptor_queue);
|
||||
}
|
||||
const u32 ubo_align = static_cast<u32>(
|
||||
device.GetUniformBufferAlignment() //check if the device has it
|
||||
);
|
||||
// add the ability to change the size in settings in future
|
||||
uniform_ring.Init(device, memory_allocator, 8 * 1024 * 1024 /* 8 MiB */, ubo_align ? ubo_align : 256);
|
||||
quad_array_index_buffer = std::make_shared<QuadArrayIndexBuffer>(device_, memory_allocator_,
|
||||
scheduler_, staging_pool_);
|
||||
quad_strip_index_buffer = std::make_shared<QuadStripIndexBuffer>(device_, memory_allocator_,
|
||||
|
|
@ -360,42 +361,6 @@ void BufferCacheRuntime::FreeDeferredStagingBuffer(StagingBufferRef& ref) {
|
|||
staging_pool.FreeDeferred(ref);
|
||||
}
|
||||
|
||||
void BufferCacheRuntime::UniformRing::Init(const Device& device,
|
||||
MemoryAllocator& alloc,
|
||||
u64 bytes, u32 alignment) {
|
||||
for (size_t i = 0; i < NUM_FRAMES; ++i) {
|
||||
VkBufferCreateInfo ci{
|
||||
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
|
||||
.pNext = nullptr,
|
||||
.flags = 0,
|
||||
.size = bytes,
|
||||
.usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
|
||||
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
|
||||
.queueFamilyIndexCount = 0,
|
||||
.pQueueFamilyIndices = nullptr,
|
||||
};
|
||||
buffers[i] = alloc.CreateBuffer(ci, MemoryUsage::Upload);
|
||||
mapped[i] = buffers[i].Mapped().data();
|
||||
}
|
||||
size = bytes;
|
||||
align = alignment ? alignment : 256;
|
||||
head = 0;
|
||||
current_frame = 0;
|
||||
}
|
||||
|
||||
std::span<u8> BufferCacheRuntime::UniformRing::Alloc(u32 bytes, u32& out_offset) {
|
||||
const u64 aligned = Common::AlignUp(head, static_cast<u64>(align));
|
||||
u64 end = aligned + bytes;
|
||||
|
||||
if (end > size) {
|
||||
return {}; // Fallback to staging pool
|
||||
}
|
||||
|
||||
out_offset = static_cast<u32>(aligned);
|
||||
head = end;
|
||||
return {mapped[current_frame] + out_offset, bytes};
|
||||
}
|
||||
|
||||
u64 BufferCacheRuntime::GetDeviceLocalMemory() const {
|
||||
return device.GetDeviceLocalMemory();
|
||||
}
|
||||
|
|
@ -416,7 +381,6 @@ void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noe
|
|||
for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
|
||||
it->ResetUsageTracking();
|
||||
}
|
||||
uniform_ring.BeginFrame();
|
||||
}
|
||||
|
||||
void BufferCacheRuntime::Finish() {
|
||||
|
|
@ -556,6 +520,10 @@ void BufferCacheRuntime::BindIndexBuffer(PrimitiveTopology topology, IndexFormat
|
|||
ReserveNullBuffer();
|
||||
vk_buffer = *null_buffer;
|
||||
}
|
||||
#ifdef YUZU_DEBUG
|
||||
const size_t bytes_per_index = BytesPerIndex(vk_index_type);
|
||||
ASSERT(bytes_per_index == 0 || (vk_offset % bytes_per_index) == 0);
|
||||
#endif
|
||||
scheduler.Record([vk_buffer, vk_offset, vk_index_type](vk::CommandBuffer cmdbuf) {
|
||||
cmdbuf.BindIndexBuffer(vk_buffer, vk_offset, vk_index_type);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -1,6 +1,3 @@
|
|||
// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
|
||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
|
||||
|
|
@ -127,60 +124,52 @@ public:
|
|||
|
||||
void BindTransformFeedbackBuffers(VideoCommon::HostBindings<Buffer>& bindings);
|
||||
|
||||
std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t /*stage*/,
|
||||
[[maybe_unused]] u32 /*binding_index*/,
|
||||
u32 size) {
|
||||
u32 offset = 0;
|
||||
if (auto span = uniform_ring.Alloc(size, offset); !span.empty()) {
|
||||
BindBuffer(*uniform_ring.buffers[uniform_ring.current_frame], offset, size);
|
||||
return span;
|
||||
}
|
||||
// Fallback for giant requests
|
||||
std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t stage,
|
||||
[[maybe_unused]] u32 binding_index, u32 size) {
|
||||
const StagingBufferRef ref = staging_pool.Request(size, MemoryUsage::Upload);
|
||||
BindBuffer(ref.buffer, static_cast<u32>(ref.offset), size);
|
||||
BindBuffer(ref.buffer, ref.offset, static_cast<VkDeviceSize>(size));
|
||||
#ifdef YUZU_DEBUG
|
||||
ASSERT(ref.mapped_span.size() >= size);
|
||||
const VkDeviceSize ubo_align = device.GetUniformBufferAlignment();
|
||||
ASSERT(ubo_align == 0 || (ref.offset % ubo_align) == 0);
|
||||
#endif
|
||||
return ref.mapped_span;
|
||||
}
|
||||
|
||||
void BindUniformBuffer(VkBuffer buffer, u32 offset, u32 size) {
|
||||
void BindUniformBuffer(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size) {
|
||||
#ifdef YUZU_DEBUG
|
||||
const VkDeviceSize ubo_align = device.GetUniformBufferAlignment();
|
||||
ASSERT(ubo_align == 0 || (offset % ubo_align) == 0);
|
||||
#endif
|
||||
BindBuffer(buffer, offset, size);
|
||||
}
|
||||
|
||||
void BindStorageBuffer(VkBuffer buffer, u32 offset, u32 size,
|
||||
void BindStorageBuffer(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size,
|
||||
[[maybe_unused]] bool is_written) {
|
||||
#ifdef YUZU_DEBUG
|
||||
const VkDeviceSize ssbo_align = device.GetStorageBufferAlignment();
|
||||
ASSERT(ssbo_align == 0 || (offset % ssbo_align) == 0);
|
||||
#endif
|
||||
BindBuffer(buffer, offset, size);
|
||||
}
|
||||
|
||||
void BindTextureBuffer(Buffer& buffer, u32 offset, u32 size,
|
||||
VideoCore::Surface::PixelFormat format) {
|
||||
#ifdef YUZU_DEBUG
|
||||
const VkDeviceSize texel_align = device.GetTexelBufferAlignment();
|
||||
ASSERT(texel_align == 0 || (offset % texel_align) == 0);
|
||||
#endif
|
||||
guest_descriptor_queue.AddTexelBuffer(buffer.View(offset, size, format));
|
||||
}
|
||||
|
||||
private:
|
||||
void BindBuffer(VkBuffer buffer, u32 offset, u32 size) {
|
||||
void BindBuffer(VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size) {
|
||||
guest_descriptor_queue.AddBuffer(buffer, offset, size);
|
||||
}
|
||||
|
||||
void ReserveNullBuffer();
|
||||
vk::Buffer CreateNullBuffer();
|
||||
|
||||
struct UniformRing {
|
||||
static constexpr size_t NUM_FRAMES = 3;
|
||||
std::array<vk::Buffer, NUM_FRAMES> buffers{};
|
||||
std::array<u8*, NUM_FRAMES> mapped{};
|
||||
u64 size = 0;
|
||||
u64 head = 0;
|
||||
u32 align = 256;
|
||||
size_t current_frame = 0;
|
||||
|
||||
void Init(const Device& device, MemoryAllocator& alloc, u64 bytes, u32 alignment);
|
||||
void BeginFrame() {
|
||||
current_frame = (current_frame + 1) % NUM_FRAMES;
|
||||
head = 0;
|
||||
}
|
||||
std::span<u8> Alloc(u32 bytes, u32& out_offset);
|
||||
};
|
||||
UniformRing uniform_ring;
|
||||
|
||||
const Device& device;
|
||||
MemoryAllocator& memory_allocator;
|
||||
Scheduler& scheduler;
|
||||
|
|
|
|||
|
|
@ -850,10 +850,17 @@ public:
|
|||
pending_flush_sets.pop_front();
|
||||
}
|
||||
|
||||
const VkDeviceSize read_size =
|
||||
static_cast<VkDeviceSize>(flushed_queries.size() * TFBQueryBank::QUERY_SIZE);
|
||||
staging_ref.InvalidateRange(staging_ref.offset, read_size);
|
||||
|
||||
size_t offset_base = staging_ref.offset;
|
||||
for (auto q : flushed_queries) {
|
||||
auto* query = GetQuery(q);
|
||||
u32 result = 0;
|
||||
#ifdef YUZU_DEBUG
|
||||
ASSERT(staging_ref.mapped_span.size() >= offset_base + sizeof(u32));
|
||||
#endif
|
||||
std::memcpy(&result, staging_ref.mapped_span.data() + offset_base, sizeof(u32));
|
||||
query->value = static_cast<u64>(result);
|
||||
query->flags |= VideoCommon::QueryFlagBits::IsFinalValueSynced;
|
||||
|
|
@ -1567,10 +1574,14 @@ void QueryCacheRuntime::SyncValues(std::span<SyncValuesType> values, VkBuffer ba
|
|||
impl->little_cache[which_copy].first,
|
||||
.size = values[i].size,
|
||||
});
|
||||
#ifdef YUZU_DEBUG
|
||||
ASSERT(ref.mapped_span.size() >= accumulated_size + values[i].size);
|
||||
#endif
|
||||
std::memcpy(ref.mapped_span.data() + accumulated_size, &values[i].value,
|
||||
values[i].size);
|
||||
accumulated_size += values[i].size;
|
||||
}
|
||||
ref.FlushRange(ref.offset, static_cast<VkDeviceSize>(accumulated_size));
|
||||
src_buffer = ref.buffer;
|
||||
} else {
|
||||
for (size_t i = 0; i < values.size(); i++) {
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
#include "video_core/renderer_vulkan/vk_command_pool.h"
|
||||
#include "video_core/renderer_vulkan/vk_master_semaphore.h"
|
||||
#include "video_core/renderer_vulkan/vk_scheduler.h"
|
||||
#include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
|
||||
#include "video_core/renderer_vulkan/vk_state_tracker.h"
|
||||
#include "video_core/renderer_vulkan/vk_texture_cache.h"
|
||||
#include "video_core/vulkan_common/vulkan_device.h"
|
||||
|
|
@ -233,8 +234,14 @@ u64 Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_se
|
|||
upload_cmdbuf.End();
|
||||
cmdbuf.End();
|
||||
|
||||
if (on_submit) {
|
||||
on_submit();
|
||||
if (staging_buffer_pool) {
|
||||
staging_buffer_pool->FlushStream();
|
||||
}
|
||||
|
||||
for (const auto& callback : on_submit_callbacks) {
|
||||
if (callback) {
|
||||
callback();
|
||||
}
|
||||
}
|
||||
|
||||
std::scoped_lock lock{submit_mutex};
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@
|
|||
#include <thread>
|
||||
#include <utility>
|
||||
#include <queue>
|
||||
#include <vector>
|
||||
|
||||
#include "common/alignment.h"
|
||||
#include "common/common_types.h"
|
||||
|
|
@ -29,6 +30,7 @@ class Device;
|
|||
class Framebuffer;
|
||||
class GraphicsPipeline;
|
||||
class StateTracker;
|
||||
class StagingBufferPool;
|
||||
|
||||
struct QueryCacheParams;
|
||||
|
||||
|
|
@ -73,9 +75,23 @@ public:
|
|||
query_cache = &query_cache_;
|
||||
}
|
||||
|
||||
// Registers a callback to perform on queue submission.
|
||||
void SetStagingBufferPool(StagingBufferPool* pool) {
|
||||
staging_buffer_pool = pool;
|
||||
}
|
||||
|
||||
// Registers a callback to perform on queue submission, replacing existing callbacks.
|
||||
void RegisterOnSubmit(std::function<void()>&& func) {
|
||||
on_submit = std::move(func);
|
||||
on_submit_callbacks.clear();
|
||||
if (func) {
|
||||
on_submit_callbacks.emplace_back(std::move(func));
|
||||
}
|
||||
}
|
||||
|
||||
// Adds an additional callback to perform on queue submission.
|
||||
void AddOnSubmit(std::function<void()>&& func) {
|
||||
if (func) {
|
||||
on_submit_callbacks.emplace_back(std::move(func));
|
||||
}
|
||||
}
|
||||
|
||||
/// Send work to a separate thread.
|
||||
|
|
@ -237,12 +253,13 @@ private:
|
|||
std::unique_ptr<CommandPool> command_pool;
|
||||
|
||||
VideoCommon::QueryCacheBase<QueryCacheParams>* query_cache = nullptr;
|
||||
StagingBufferPool* staging_buffer_pool = nullptr;
|
||||
|
||||
vk::CommandBuffer current_cmdbuf;
|
||||
vk::CommandBuffer current_upload_cmdbuf;
|
||||
|
||||
std::unique_ptr<CommandChunk> chunk;
|
||||
std::function<void()> on_submit;
|
||||
std::vector<std::function<void()>> on_submit_callbacks;
|
||||
|
||||
State state;
|
||||
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@
|
|||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
|
||||
#include <algorithm>
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
|
|
@ -25,35 +26,52 @@ namespace {
|
|||
|
||||
using namespace Common::Literals;
|
||||
|
||||
// Maximum potential alignment of a Vulkan buffer
|
||||
constexpr VkDeviceSize MAX_ALIGNMENT = 256;
|
||||
// Minimum alignment we want to enforce for the streaming ring
|
||||
constexpr VkDeviceSize MIN_STREAM_ALIGNMENT = 256;
|
||||
// Stream buffer size in bytes
|
||||
constexpr VkDeviceSize MAX_STREAM_BUFFER_SIZE = 128_MiB;
|
||||
|
||||
size_t GetStreamBufferSize(const Device& device) {
|
||||
VkDeviceSize GetStreamAlignment(const Device& device) {
|
||||
return (std::max)({device.GetUniformBufferAlignment(), device.GetStorageBufferAlignment(),
|
||||
device.GetTexelBufferAlignment(), MIN_STREAM_ALIGNMENT});
|
||||
}
|
||||
|
||||
size_t GetStreamBufferSize(const Device& device, VkDeviceSize alignment) {
|
||||
VkDeviceSize size{0};
|
||||
if (device.HasDebuggingToolAttached()) {
|
||||
ForEachDeviceLocalHostVisibleHeap(device, [&size](size_t index, VkMemoryHeap& heap) {
|
||||
bool found_heap = false;
|
||||
ForEachDeviceLocalHostVisibleHeap(device, [&size, &found_heap](size_t /*index*/, VkMemoryHeap& heap) {
|
||||
size = (std::max)(size, heap.size);
|
||||
found_heap = true;
|
||||
});
|
||||
// If no suitable heap was found fall back to the default cap to avoid creating a zero-sized stream buffer.
|
||||
if (!found_heap) {
|
||||
size = MAX_STREAM_BUFFER_SIZE;
|
||||
} else if (size <= 256_MiB) {
|
||||
// If rebar is not supported, cut the max heap size to 40%. This will allow 2 captures to be
|
||||
// loaded at the same time in RenderDoc. If rebar is supported, this shouldn't be an issue
|
||||
// as the heap will be much larger.
|
||||
if (size <= 256_MiB) {
|
||||
size = size * 40 / 100;
|
||||
}
|
||||
} else {
|
||||
size = MAX_STREAM_BUFFER_SIZE;
|
||||
}
|
||||
return (std::min)(Common::AlignUp(size, MAX_ALIGNMENT), MAX_STREAM_BUFFER_SIZE);
|
||||
|
||||
// Clamp to the configured maximum, align up for safety, and ensure a sane minimum so
|
||||
// region_size (stream_buffer_size / NUM_SYNCS) never becomes zero.
|
||||
const VkDeviceSize aligned =
|
||||
(std::min)(Common::AlignUp(size, alignment), MAX_STREAM_BUFFER_SIZE);
|
||||
const VkDeviceSize min_size = alignment * StagingBufferPool::NUM_SYNCS;
|
||||
return static_cast<size_t>((std::max)(aligned, min_size));
|
||||
}
|
||||
} // Anonymous namespace
|
||||
|
||||
StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& memory_allocator_,
|
||||
Scheduler& scheduler_)
|
||||
: device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
|
||||
stream_buffer_size{GetStreamBufferSize(device)}, region_size{stream_buffer_size /
|
||||
StagingBufferPool::NUM_SYNCS} {
|
||||
stream_alignment{GetStreamAlignment(device_)},
|
||||
stream_buffer_size{GetStreamBufferSize(device_, stream_alignment)},
|
||||
region_size{stream_buffer_size / StagingBufferPool::NUM_SYNCS} {
|
||||
VkBufferCreateInfo stream_ci = {
|
||||
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
|
||||
.pNext = nullptr,
|
||||
|
|
@ -74,9 +92,18 @@ StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& mem
|
|||
}
|
||||
stream_pointer = stream_buffer.Mapped();
|
||||
ASSERT_MSG(!stream_pointer.empty(), "Stream buffer must be host visible!");
|
||||
stream_is_coherent = stream_buffer.IsHostCoherent();
|
||||
non_coherent_atom_size = std::max<VkDeviceSize>(device.GetNonCoherentAtomSize(),
|
||||
static_cast<VkDeviceSize>(1));
|
||||
dirty_begin = stream_buffer_size;
|
||||
dirty_end = 0;
|
||||
stream_dirty = false;
|
||||
scheduler.SetStagingBufferPool(this);
|
||||
}
|
||||
|
||||
StagingBufferPool::~StagingBufferPool() = default;
|
||||
StagingBufferPool::~StagingBufferPool() {
|
||||
scheduler.SetStagingBufferPool(nullptr);
|
||||
}
|
||||
|
||||
StagingBufferRef StagingBufferPool::Request(size_t size, MemoryUsage usage, bool deferred) {
|
||||
if (!deferred && usage == MemoryUsage::Upload && size <= region_size) {
|
||||
|
|
@ -106,41 +133,118 @@ void StagingBufferPool::TickFrame() {
|
|||
}
|
||||
|
||||
StagingBufferRef StagingBufferPool::GetStreamBuffer(size_t size) {
|
||||
if (AreRegionsActive(Region(free_iterator) + 1,
|
||||
(std::min)(Region(iterator + size) + 1, NUM_SYNCS))) {
|
||||
const size_t alignment = static_cast<size_t>(stream_alignment);
|
||||
const size_t aligned_size = Common::AlignUp(size, alignment);
|
||||
const size_t capacity = static_cast<size_t>(stream_buffer_size);
|
||||
const bool wraps = iterator + aligned_size > capacity;
|
||||
const size_t new_iterator =
|
||||
wraps ? aligned_size : Common::AlignUp(iterator + aligned_size, alignment);
|
||||
const size_t begin_region = wraps ? 0 : Region(iterator);
|
||||
const size_t last_byte = new_iterator == 0 ? 0 : new_iterator - 1;
|
||||
const size_t end_region = (std::min)(Region(last_byte) + 1, NUM_SYNCS);
|
||||
const size_t guard_begin = (std::min)(Region(free_iterator) + 1, NUM_SYNCS);
|
||||
|
||||
if (!wraps) {
|
||||
if (guard_begin < end_region && AreRegionsActive(guard_begin, end_region)) {
|
||||
// Avoid waiting for the previous usages to be free
|
||||
return GetStagingBuffer(size, MemoryUsage::Upload);
|
||||
}
|
||||
} else if (guard_begin < NUM_SYNCS && AreRegionsActive(guard_begin, NUM_SYNCS)) {
|
||||
// Avoid waiting for the previous usages to be free
|
||||
return GetStagingBuffer(size, MemoryUsage::Upload);
|
||||
}
|
||||
|
||||
const u64 current_tick = scheduler.CurrentTick();
|
||||
std::fill(sync_ticks.begin() + Region(used_iterator), sync_ticks.begin() + Region(iterator),
|
||||
current_tick);
|
||||
used_iterator = iterator;
|
||||
free_iterator = (std::max)(free_iterator, iterator + size);
|
||||
|
||||
if (iterator + size >= stream_buffer_size) {
|
||||
if (wraps) {
|
||||
std::fill(sync_ticks.begin() + Region(used_iterator), sync_ticks.begin() + NUM_SYNCS,
|
||||
current_tick);
|
||||
used_iterator = 0;
|
||||
iterator = 0;
|
||||
free_iterator = size;
|
||||
|
||||
if (AreRegionsActive(0, Region(size) + 1)) {
|
||||
free_iterator = aligned_size;
|
||||
const size_t head_last_byte = aligned_size == 0 ? 0 : aligned_size - 1;
|
||||
const size_t head_end_region = (std::min)(Region(head_last_byte) + 1, NUM_SYNCS);
|
||||
if (AreRegionsActive(0, head_end_region)) {
|
||||
// Avoid waiting for the previous usages to be free
|
||||
return GetStagingBuffer(size, MemoryUsage::Upload);
|
||||
}
|
||||
}
|
||||
const size_t offset = iterator;
|
||||
iterator = Common::AlignUp(iterator + size, MAX_ALIGNMENT);
|
||||
|
||||
std::fill(sync_ticks.begin() + begin_region, sync_ticks.begin() + end_region, current_tick);
|
||||
|
||||
const size_t offset = wraps ? 0 : iterator;
|
||||
iterator = new_iterator;
|
||||
|
||||
if (!wraps) {
|
||||
free_iterator = (std::max)(free_iterator, offset + aligned_size);
|
||||
}
|
||||
|
||||
TrackStreamWrite(static_cast<VkDeviceSize>(offset), static_cast<VkDeviceSize>(aligned_size));
|
||||
|
||||
return StagingBufferRef{
|
||||
.buffer = *stream_buffer,
|
||||
.offset = static_cast<VkDeviceSize>(offset),
|
||||
.mapped_span = stream_pointer.subspan(offset, size),
|
||||
.usage{},
|
||||
.log2_level{},
|
||||
.index{},
|
||||
.usage = MemoryUsage::Upload,
|
||||
.log2_level = 0,
|
||||
.index = 0,
|
||||
.owner = &stream_buffer,
|
||||
.atom_size = non_coherent_atom_size,
|
||||
.is_coherent = stream_is_coherent,
|
||||
.is_stream_ring = true,
|
||||
};
|
||||
}
|
||||
|
||||
void StagingBufferPool::TrackStreamWrite(VkDeviceSize offset, VkDeviceSize size) {
|
||||
if (stream_is_coherent || size == 0) {
|
||||
return;
|
||||
}
|
||||
const VkDeviceSize clamped_offset = (std::min)(offset, stream_buffer_size);
|
||||
const VkDeviceSize clamped_end = (std::min)(clamped_offset + size, stream_buffer_size);
|
||||
std::scoped_lock lock{stream_mutex};
|
||||
if (!stream_dirty) {
|
||||
dirty_begin = clamped_offset;
|
||||
dirty_end = clamped_end;
|
||||
stream_dirty = true;
|
||||
return;
|
||||
}
|
||||
dirty_begin = (std::min)(dirty_begin, clamped_offset);
|
||||
dirty_end = (std::max)(dirty_end, clamped_end);
|
||||
}
|
||||
|
||||
void StagingBufferPool::FlushStream() {
|
||||
if (stream_is_coherent) {
|
||||
return;
|
||||
}
|
||||
|
||||
VkDeviceSize flush_begin = 0;
|
||||
VkDeviceSize flush_end = 0;
|
||||
{
|
||||
std::scoped_lock lock{stream_mutex};
|
||||
if (!stream_dirty) {
|
||||
return;
|
||||
}
|
||||
flush_begin = dirty_begin;
|
||||
flush_end = dirty_end;
|
||||
stream_dirty = false;
|
||||
dirty_begin = stream_buffer_size;
|
||||
dirty_end = 0;
|
||||
}
|
||||
|
||||
if (flush_begin >= flush_end) {
|
||||
return;
|
||||
}
|
||||
|
||||
const VkDeviceSize atom = non_coherent_atom_size;
|
||||
const VkDeviceSize aligned_begin = Common::AlignDown(flush_begin, atom);
|
||||
const VkDeviceSize aligned_end = Common::AlignUp(flush_end, atom);
|
||||
const VkDeviceSize flush_size = aligned_end - aligned_begin;
|
||||
stream_buffer.FlushRange(aligned_begin, flush_size);
|
||||
}
|
||||
|
||||
bool StagingBufferPool::AreRegionsActive(size_t region_begin, size_t region_end) const {
|
||||
const u64 gpu_tick = scheduler.GetMasterSemaphore().KnownGpuTick();
|
||||
return std::any_of(sync_ticks.begin() + region_begin, sync_ticks.begin() + region_end,
|
||||
|
|
@ -202,15 +306,19 @@ StagingBufferRef StagingBufferPool::CreateStagingBuffer(size_t size, MemoryUsage
|
|||
++buffer_index;
|
||||
buffer.SetObjectNameEXT(fmt::format("Staging Buffer {}", buffer_index).c_str());
|
||||
}
|
||||
const bool is_coherent = buffer.IsHostCoherent();
|
||||
const std::span<u8> mapped_span = buffer.Mapped();
|
||||
auto buffer_ptr = std::make_unique<vk::Buffer>(std::move(buffer));
|
||||
StagingBuffer& entry = GetCache(usage)[log2].entries.emplace_back(StagingBuffer{
|
||||
.buffer = std::move(buffer),
|
||||
.buffer = std::move(buffer_ptr),
|
||||
.mapped_span = mapped_span,
|
||||
.usage = usage,
|
||||
.log2_level = log2,
|
||||
.index = unique_ids++,
|
||||
.tick = deferred ? (std::numeric_limits<u64>::max)() : scheduler.CurrentTick(),
|
||||
.deferred = deferred,
|
||||
.is_coherent = is_coherent,
|
||||
.atom_size = is_coherent ? 1 : non_coherent_atom_size,
|
||||
});
|
||||
return entry.Ref();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,12 +1,18 @@
|
|||
// 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-3.0-or-later
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <climits>
|
||||
#include <mutex>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
#include "common/common_types.h"
|
||||
#include "common/alignment.h"
|
||||
|
||||
#include "video_core/vulkan_common/vulkan_memory_allocator.h"
|
||||
#include "video_core/vulkan_common/vulkan_wrapper.h"
|
||||
|
|
@ -23,10 +29,54 @@ struct StagingBufferRef {
|
|||
MemoryUsage usage;
|
||||
u32 log2_level;
|
||||
u64 index;
|
||||
const vk::Buffer* owner = nullptr;
|
||||
VkDeviceSize atom_size = 1;
|
||||
bool is_coherent = true;
|
||||
bool is_stream_ring = false;
|
||||
|
||||
void FlushRange(VkDeviceSize range_offset, VkDeviceSize size) const {
|
||||
if (!owner || is_coherent || size == 0 || is_stream_ring) {
|
||||
return;
|
||||
}
|
||||
if (size == VK_WHOLE_SIZE) {
|
||||
owner->FlushRange(range_offset, size);
|
||||
return;
|
||||
}
|
||||
const VkDeviceSize atom = atom_size ? atom_size : 1;
|
||||
const VkDeviceSize range_end = range_offset + size;
|
||||
if (range_end < range_offset) {
|
||||
owner->FlushRange(range_offset, size);
|
||||
return;
|
||||
}
|
||||
const VkDeviceSize aligned_begin = Common::AlignDown(range_offset, atom);
|
||||
const VkDeviceSize aligned_end = Common::AlignUp(range_end, atom);
|
||||
owner->FlushRange(aligned_begin, aligned_end - aligned_begin);
|
||||
}
|
||||
|
||||
void InvalidateRange(VkDeviceSize range_offset, VkDeviceSize size) const {
|
||||
if (!owner || is_coherent || size == 0 || is_stream_ring) {
|
||||
return;
|
||||
}
|
||||
if (size == VK_WHOLE_SIZE) {
|
||||
owner->InvalidateRange(range_offset, size);
|
||||
return;
|
||||
}
|
||||
const VkDeviceSize atom = atom_size ? atom_size : 1;
|
||||
const VkDeviceSize range_end = range_offset + size;
|
||||
if (range_end < range_offset) {
|
||||
owner->InvalidateRange(range_offset, size);
|
||||
return;
|
||||
}
|
||||
const VkDeviceSize aligned_begin = Common::AlignDown(range_offset, atom);
|
||||
const VkDeviceSize aligned_end = Common::AlignUp(range_end, atom);
|
||||
owner->InvalidateRange(aligned_begin, aligned_end - aligned_begin);
|
||||
}
|
||||
};
|
||||
|
||||
class StagingBufferPool {
|
||||
public:
|
||||
friend class Scheduler;
|
||||
|
||||
static constexpr size_t NUM_SYNCS = 16;
|
||||
|
||||
explicit StagingBufferPool(const Device& device, MemoryAllocator& memory_allocator,
|
||||
|
|
@ -49,22 +99,28 @@ private:
|
|||
};
|
||||
|
||||
struct StagingBuffer {
|
||||
vk::Buffer buffer;
|
||||
std::unique_ptr<vk::Buffer> buffer;
|
||||
std::span<u8> mapped_span;
|
||||
MemoryUsage usage;
|
||||
u32 log2_level;
|
||||
u64 index;
|
||||
u64 tick = 0;
|
||||
bool deferred{};
|
||||
bool is_coherent = true;
|
||||
VkDeviceSize atom_size = 1;
|
||||
|
||||
StagingBufferRef Ref() const noexcept {
|
||||
return {
|
||||
.buffer = *buffer,
|
||||
.buffer = buffer ? **buffer : VkBuffer{},
|
||||
.offset = 0,
|
||||
.mapped_span = mapped_span,
|
||||
.usage = usage,
|
||||
.log2_level = log2_level,
|
||||
.index = index,
|
||||
.owner = buffer.get(),
|
||||
.atom_size = atom_size,
|
||||
.is_coherent = is_coherent,
|
||||
.is_stream_ring = false,
|
||||
};
|
||||
}
|
||||
};
|
||||
|
|
@ -80,6 +136,9 @@ private:
|
|||
|
||||
StagingBufferRef GetStreamBuffer(size_t size);
|
||||
|
||||
void TrackStreamWrite(VkDeviceSize offset, VkDeviceSize size);
|
||||
void FlushStream();
|
||||
|
||||
bool AreRegionsActive(size_t region_begin, size_t region_end) const;
|
||||
|
||||
StagingBufferRef GetStagingBuffer(size_t size, MemoryUsage usage, bool deferred = false);
|
||||
|
|
@ -102,10 +161,17 @@ private:
|
|||
MemoryAllocator& memory_allocator;
|
||||
Scheduler& scheduler;
|
||||
|
||||
VkDeviceSize stream_alignment;
|
||||
vk::Buffer stream_buffer;
|
||||
std::span<u8> stream_pointer;
|
||||
VkDeviceSize stream_buffer_size;
|
||||
VkDeviceSize region_size;
|
||||
bool stream_is_coherent = true;
|
||||
VkDeviceSize non_coherent_atom_size = 1;
|
||||
VkDeviceSize dirty_begin = 0;
|
||||
VkDeviceSize dirty_end = 0;
|
||||
bool stream_dirty = false;
|
||||
std::mutex stream_mutex;
|
||||
|
||||
size_t iterator = 0;
|
||||
size_t used_iterator = 0;
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
#pragma once
|
||||
|
||||
#include <unordered_set>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
#include <boost/container/small_vector.hpp>
|
||||
|
||||
#include "common/alignment.h"
|
||||
|
|
@ -30,6 +32,42 @@ using VideoCore::Surface::PixelFormat;
|
|||
using VideoCore::Surface::SurfaceType;
|
||||
using namespace Common::Literals;
|
||||
|
||||
namespace staging_detail {
|
||||
template <typename T, typename = void>
|
||||
struct has_flush_range : std::false_type {};
|
||||
template <typename T>
|
||||
struct has_flush_range<
|
||||
T, std::void_t<decltype(std::declval<T&>().FlushRange(size_t{}, size_t{}))>> : std::true_type {};
|
||||
template <typename T, typename = void>
|
||||
struct has_invalidate_range : std::false_type {};
|
||||
template <typename T>
|
||||
struct has_invalidate_range<
|
||||
T, std::void_t<decltype(std::declval<T&>().InvalidateRange(size_t{}, size_t{}))>>
|
||||
: std::true_type {};
|
||||
} // namespace staging_detail
|
||||
|
||||
template <typename Ref>
|
||||
inline void StagingFlushRange(Ref& ref, size_t offset, size_t size) {
|
||||
if constexpr (staging_detail::has_flush_range<Ref>::value) {
|
||||
ref.FlushRange(offset, size);
|
||||
} else {
|
||||
(void)ref;
|
||||
(void)offset;
|
||||
(void)size;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename Ref>
|
||||
inline void StagingInvalidateRange(Ref& ref, size_t offset, size_t size) {
|
||||
if constexpr (staging_detail::has_invalidate_range<Ref>::value) {
|
||||
ref.InvalidateRange(offset, size);
|
||||
} else {
|
||||
(void)ref;
|
||||
(void)offset;
|
||||
(void)size;
|
||||
}
|
||||
}
|
||||
|
||||
template <class P>
|
||||
TextureCache<P>::TextureCache(Runtime& runtime_, Tegra::MaxwellDeviceMemoryManager& device_memory_)
|
||||
: runtime{runtime_}, device_memory{device_memory_} {
|
||||
|
|
@ -111,6 +149,7 @@ void TextureCache<P>::RunGarbageCollector() {
|
|||
const auto copies = FullDownloadCopies(image.info);
|
||||
image.DownloadMemory(map, copies);
|
||||
runtime.Finish();
|
||||
StagingInvalidateRange(map, map.offset, image.unswizzled_size_bytes);
|
||||
SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span,
|
||||
swizzle_data_buffer);
|
||||
}
|
||||
|
|
@ -567,6 +606,7 @@ void TextureCache<P>::DownloadMemory(DAddr cpu_addr, size_t size) {
|
|||
const auto copies = FullDownloadCopies(image.info);
|
||||
image.DownloadMemory(map, copies);
|
||||
runtime.Finish();
|
||||
StagingInvalidateRange(map, map.offset, image.unswizzled_size_bytes);
|
||||
SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, map.mapped_span,
|
||||
swizzle_data_buffer);
|
||||
}
|
||||
|
|
@ -863,13 +903,17 @@ void TextureCache<P>::PopAsyncFlushes() {
|
|||
if (download_info.is_swizzle) {
|
||||
const ImageBase& image = slot_images[download_info.object_id];
|
||||
const auto copies = FullDownloadCopies(image.info);
|
||||
download_buffer.offset -= Common::AlignUp(image.unswizzled_size_bytes, 64);
|
||||
const size_t aligned_size =
|
||||
Common::AlignUp(image.unswizzled_size_bytes, static_cast<size_t>(64));
|
||||
download_buffer.offset -= aligned_size;
|
||||
StagingInvalidateRange(download_buffer, download_buffer.offset, aligned_size);
|
||||
std::span<u8> download_span =
|
||||
download_buffer.mapped_span.subspan(download_buffer.offset);
|
||||
SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, download_span,
|
||||
swizzle_data_buffer);
|
||||
} else {
|
||||
const BufferDownload& buffer_info = slot_buffer_downloads[download_info.object_id];
|
||||
StagingInvalidateRange(download_buffer, download_buffer.offset, buffer_info.size);
|
||||
std::span<u8> download_span =
|
||||
download_buffer.mapped_span.subspan(download_buffer.offset);
|
||||
gpu_memory->WriteBlockUnsafe(buffer_info.address, download_span.data(),
|
||||
|
|
@ -907,6 +951,7 @@ void TextureCache<P>::PopAsyncFlushes() {
|
|||
}
|
||||
// Wait for downloads to finish
|
||||
runtime.Finish();
|
||||
StagingInvalidateRange(download_map, original_offset, total_size_bytes);
|
||||
download_map.offset = original_offset;
|
||||
std::span<u8> download_span = download_map.mapped_span;
|
||||
for (const PendingDownload& download_info : download_ids) {
|
||||
|
|
@ -1081,6 +1126,7 @@ void TextureCache<P>::UploadImageContents(Image& image, StagingBuffer& staging)
|
|||
if (True(image.flags & ImageFlagBits::AcceleratedUpload)) {
|
||||
gpu_memory->ReadBlock(gpu_addr, mapped_span.data(), mapped_span.size_bytes(),
|
||||
VideoCommon::CacheType::NoTextureCache);
|
||||
StagingFlushRange(staging, staging.offset, mapped_span.size_bytes());
|
||||
const auto uploads = FullUploadSwizzles(image.info);
|
||||
runtime.AccelerateImageUpload(image, staging, uploads);
|
||||
return;
|
||||
|
|
@ -1094,10 +1140,12 @@ void TextureCache<P>::UploadImageContents(Image& image, StagingBuffer& staging)
|
|||
auto copies =
|
||||
UnswizzleImage(*gpu_memory, gpu_addr, image.info, swizzle_data, unswizzle_data_buffer);
|
||||
ConvertImage(unswizzle_data_buffer, image.info, mapped_span, copies);
|
||||
StagingFlushRange(staging, staging.offset, mapped_span.size_bytes());
|
||||
image.UploadMemory(staging, copies);
|
||||
} else {
|
||||
const auto copies =
|
||||
UnswizzleImage(*gpu_memory, gpu_addr, image.info, swizzle_data, mapped_span);
|
||||
StagingFlushRange(staging, staging.offset, mapped_span.size_bytes());
|
||||
image.UploadMemory(staging, copies);
|
||||
}
|
||||
}
|
||||
|
|
@ -1329,6 +1377,7 @@ void TextureCache<P>::TickAsyncDecode() {
|
|||
auto staging = runtime.UploadStagingBuffer(MapSizeBytes(image));
|
||||
std::memcpy(staging.mapped_span.data(), async_decode->decoded_data.data(),
|
||||
async_decode->decoded_data.size());
|
||||
StagingFlushRange(staging, staging.offset, async_decode->decoded_data.size());
|
||||
image.UploadMemory(staging, async_decode->copies);
|
||||
image.flags &= ~ImageFlagBits::IsDecoding;
|
||||
has_uploads = true;
|
||||
|
|
|
|||
|
|
@ -295,6 +295,16 @@ public:
|
|||
return properties.properties.limits.minStorageBufferOffsetAlignment;
|
||||
}
|
||||
|
||||
/// Returns texel buffer alignment requirement.
|
||||
VkDeviceSize GetTexelBufferAlignment() const {
|
||||
return properties.properties.limits.minTexelBufferOffsetAlignment;
|
||||
}
|
||||
|
||||
/// Returns the non-coherent atom size for memory flushes.
|
||||
VkDeviceSize GetNonCoherentAtomSize() const {
|
||||
return properties.properties.limits.nonCoherentAtomSize;
|
||||
}
|
||||
|
||||
/// Returns the maximum range for storage buffers.
|
||||
VkDeviceSize GetMaxStorageBufferRange() const {
|
||||
return properties.properties.limits.maxStorageBufferRange;
|
||||
|
|
|
|||
|
|
@ -499,14 +499,22 @@ void Image::Release() const noexcept {
|
|||
}
|
||||
|
||||
void Buffer::Flush() const {
|
||||
FlushRange(0, VK_WHOLE_SIZE);
|
||||
}
|
||||
|
||||
void Buffer::FlushRange(VkDeviceSize offset, VkDeviceSize size) const {
|
||||
if (!is_coherent) {
|
||||
vmaFlushAllocation(allocator, allocation, 0, VK_WHOLE_SIZE);
|
||||
vmaFlushAllocation(allocator, allocation, offset, size);
|
||||
}
|
||||
}
|
||||
|
||||
void Buffer::Invalidate() const {
|
||||
InvalidateRange(0, VK_WHOLE_SIZE);
|
||||
}
|
||||
|
||||
void Buffer::InvalidateRange(VkDeviceSize offset, VkDeviceSize size) const {
|
||||
if (!is_coherent) {
|
||||
vmaInvalidateAllocation(allocator, allocation, 0, VK_WHOLE_SIZE);
|
||||
vmaInvalidateAllocation(allocator, allocation, offset, size);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -772,10 +772,19 @@ public:
|
|||
return !mapped.empty();
|
||||
}
|
||||
|
||||
/// Returns true if the buffer memory is host coherent.
|
||||
bool IsHostCoherent() const noexcept {
|
||||
return is_coherent;
|
||||
}
|
||||
|
||||
void Flush() const;
|
||||
|
||||
void FlushRange(VkDeviceSize offset, VkDeviceSize size) const;
|
||||
|
||||
void Invalidate() const;
|
||||
|
||||
void InvalidateRange(VkDeviceSize offset, VkDeviceSize size) const;
|
||||
|
||||
void SetObjectNameEXT(const char* name) const;
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -393,8 +393,16 @@ target_link_libraries(yuzu PRIVATE common core input_common frontend_common netw
|
|||
target_link_libraries(yuzu PRIVATE Boost::headers glad Qt6::Widgets)
|
||||
target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
|
||||
|
||||
if (NOT WIN32)
|
||||
target_include_directories(yuzu PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
|
||||
endif()
|
||||
|
||||
if (UNIX AND NOT APPLE)
|
||||
target_link_libraries(yuzu PRIVATE Qt6::DBus)
|
||||
|
||||
if (TARGET Qt6::GuiPrivate)
|
||||
target_link_libraries(yuzu PRIVATE Qt6::GuiPrivate)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
target_compile_definitions(yuzu PRIVATE
|
||||
|
|
|
|||
|
|
@ -83,7 +83,8 @@ void ConfigureDebug::SetConfiguration() {
|
|||
#ifdef YUZU_USE_QT_WEB_ENGINE
|
||||
ui->disable_web_applet->setChecked(UISettings::values.disable_web_applet.GetValue());
|
||||
#else
|
||||
ui->disable_web_applet->setVisible(false);
|
||||
ui->disable_web_applet->setEnabled(false);
|
||||
ui->disable_web_applet->setText(tr("Web applet not compiled"));
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue