summaryrefslogtreecommitdiffstats
path: root/src/audio_core/renderer/system.cpp
diff options
context:
space:
mode:
authorKelebek1 <eeeedddccc@hotmail.co.uk>2022-07-17 00:48:45 +0200
committerKelebek1 <eeeedddccc@hotmail.co.uk>2022-07-22 02:11:32 +0200
commit458da8a94877677f086f06cdeecf959ec4283a33 (patch)
tree583166d77602ad90a0d552f37de8729ad80fd6c1 /src/audio_core/renderer/system.cpp
parentMerge pull request #8598 from Link4565/recv-dontwait (diff)
downloadyuzu-458da8a94877677f086f06cdeecf959ec4283a33.tar
yuzu-458da8a94877677f086f06cdeecf959ec4283a33.tar.gz
yuzu-458da8a94877677f086f06cdeecf959ec4283a33.tar.bz2
yuzu-458da8a94877677f086f06cdeecf959ec4283a33.tar.lz
yuzu-458da8a94877677f086f06cdeecf959ec4283a33.tar.xz
yuzu-458da8a94877677f086f06cdeecf959ec4283a33.tar.zst
yuzu-458da8a94877677f086f06cdeecf959ec4283a33.zip
Diffstat (limited to 'src/audio_core/renderer/system.cpp')
-rw-r--r--src/audio_core/renderer/system.cpp802
1 files changed, 802 insertions, 0 deletions
diff --git a/src/audio_core/renderer/system.cpp b/src/audio_core/renderer/system.cpp
new file mode 100644
index 000000000..7a217969e
--- /dev/null
+++ b/src/audio_core/renderer/system.cpp
@@ -0,0 +1,802 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+#include <span>
+
+#include "audio_core/audio_core.h"
+#include "audio_core/common/audio_renderer_parameter.h"
+#include "audio_core/common/common.h"
+#include "audio_core/common/feature_support.h"
+#include "audio_core/common/workbuffer_allocator.h"
+#include "audio_core/renderer/adsp/adsp.h"
+#include "audio_core/renderer/behavior/info_updater.h"
+#include "audio_core/renderer/command/command_buffer.h"
+#include "audio_core/renderer/command/command_generator.h"
+#include "audio_core/renderer/command/command_list_header.h"
+#include "audio_core/renderer/effect/effect_info_base.h"
+#include "audio_core/renderer/effect/effect_result_state.h"
+#include "audio_core/renderer/memory/memory_pool_info.h"
+#include "audio_core/renderer/memory/pool_mapper.h"
+#include "audio_core/renderer/mix/mix_info.h"
+#include "audio_core/renderer/nodes/edge_matrix.h"
+#include "audio_core/renderer/nodes/node_states.h"
+#include "audio_core/renderer/sink/sink_info_base.h"
+#include "audio_core/renderer/system.h"
+#include "audio_core/renderer/upsampler/upsampler_info.h"
+#include "audio_core/renderer/voice/voice_channel_resource.h"
+#include "audio_core/renderer/voice/voice_info.h"
+#include "audio_core/renderer/voice/voice_state.h"
+#include "common/alignment.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_transfer_memory.h"
+#include "core/memory.h"
+
+namespace AudioCore::AudioRenderer {
+
+u64 System::GetWorkBufferSize(const AudioRendererParameterInternal& params) {
+ BehaviorInfo behavior;
+ behavior.SetUserLibRevision(params.revision);
+
+ u64 size{0};
+
+ size += Common::AlignUp(params.mixes * sizeof(s32), 0x40);
+ size += params.sub_mixes * MaxEffects * sizeof(s32);
+ size += (params.sub_mixes + 1) * sizeof(MixInfo);
+ size += params.voices * (sizeof(VoiceInfo) + sizeof(VoiceChannelResource) + sizeof(VoiceState));
+ size += Common::AlignUp((params.sub_mixes + 1) * sizeof(MixInfo*), 0x10);
+ size += Common::AlignUp(params.voices * sizeof(VoiceInfo*), 0x10);
+ size += Common::AlignUp(((params.sinks + params.sub_mixes) * TargetSampleCount * sizeof(s32) +
+ params.sample_count * sizeof(s32)) *
+ (params.mixes + MaxChannels),
+ 0x40);
+
+ if (behavior.IsSplitterSupported()) {
+ const auto node_size{NodeStates::GetWorkBufferSize(params.sub_mixes + 1)};
+ const auto edge_size{EdgeMatrix::GetWorkBufferSize(params.sub_mixes + 1)};
+ size += Common::AlignUp(node_size + edge_size, 0x10);
+ }
+
+ size += SplitterContext::CalcWorkBufferSize(behavior, params);
+ size += (params.effects + params.voices * MaxWaveBuffers) * sizeof(MemoryPoolInfo);
+
+ if (behavior.IsEffectInfoVersion2Supported()) {
+ size += params.effects * sizeof(EffectResultState);
+ }
+ size += 0x50;
+
+ size = Common::AlignUp(size, 0x40);
+
+ size += (params.sinks + params.sub_mixes) * sizeof(UpsamplerInfo);
+ size += params.effects * sizeof(EffectInfoBase);
+ size += Common::AlignUp(params.voices * sizeof(VoiceState), 0x40);
+ size += params.sinks * sizeof(SinkInfoBase);
+
+ if (behavior.IsEffectInfoVersion2Supported()) {
+ size += params.effects * sizeof(EffectResultState);
+ }
+
+ if (params.perf_frames > 0) {
+ auto perf_size{PerformanceManager::GetRequiredBufferSizeForPerformanceMetricsPerFrame(
+ behavior, params)};
+ size += Common::AlignUp(perf_size * (params.perf_frames + 1) + 0xC0, 0x100);
+ }
+
+ if (behavior.IsVariadicCommandBufferSizeSupported()) {
+ size += CommandGenerator::CalculateCommandBufferSize(behavior, params) + (0x40 - 1) * 2;
+ } else {
+ size += 0x18000 + (0x40 - 1) * 2;
+ }
+
+ size = Common::AlignUp(size, 0x1000);
+ return size;
+}
+
+System::System(Core::System& core_, Kernel::KEvent* adsp_rendered_event_)
+ : core{core_}, adsp{core.AudioCore().GetADSP()}, adsp_rendered_event{adsp_rendered_event_} {}
+
+Result System::Initialize(const AudioRendererParameterInternal& params,
+ Kernel::KTransferMemory* transfer_memory, const u64 transfer_memory_size,
+ const u32 process_handle_, const u64 applet_resource_user_id_,
+ const s32 session_id_) {
+ if (!CheckValidRevision(params.revision)) {
+ return Service::Audio::ERR_INVALID_REVISION;
+ }
+
+ if (GetWorkBufferSize(params) > transfer_memory_size) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ if (process_handle_ == 0) {
+ return Service::Audio::ERR_INVALID_PROCESS_HANDLE;
+ }
+
+ behavior.SetUserLibRevision(params.revision);
+
+ process_handle = process_handle_;
+ applet_resource_user_id = applet_resource_user_id_;
+ session_id = session_id_;
+
+ sample_rate = params.sample_rate;
+ sample_count = params.sample_count;
+ mix_buffer_count = static_cast<s16>(params.mixes);
+ voice_channels = MaxChannels;
+ upsampler_count = params.sinks + params.sub_mixes;
+ memory_pool_count = params.effects + params.voices * MaxWaveBuffers;
+ render_device = params.rendering_device;
+ execution_mode = params.execution_mode;
+
+ core.Memory().ZeroBlock(*core.Kernel().CurrentProcess(), transfer_memory->GetSourceAddress(),
+ transfer_memory_size);
+
+ // Note: We're not actually using the transfer memory because it's a pain to code for.
+ // Allocate the memory normally instead and hope the game doesn't try to read anything back
+ workbuffer = std::make_unique<u8[]>(transfer_memory_size);
+ workbuffer_size = transfer_memory_size;
+
+ PoolMapper pool_mapper(process_handle, false);
+ pool_mapper.InitializeSystemPool(memory_pool_info, workbuffer.get(), workbuffer_size);
+
+ WorkbufferAllocator allocator({workbuffer.get(), workbuffer_size}, workbuffer_size);
+
+ samples_workbuffer =
+ allocator.Allocate<s32>((voice_channels + mix_buffer_count) * sample_count, 0x10);
+ if (samples_workbuffer.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ auto upsampler_workbuffer{allocator.Allocate<s32>(
+ (voice_channels + mix_buffer_count) * TargetSampleCount * upsampler_count, 0x10)};
+ if (upsampler_workbuffer.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ depop_buffer =
+ allocator.Allocate<s32>(Common::AlignUp(static_cast<u32>(mix_buffer_count), 0x40), 0x40);
+ if (depop_buffer.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ // invalidate samples_workbuffer DSP cache
+
+ auto voice_infos{allocator.Allocate<VoiceInfo>(params.voices, 0x10)};
+ for (auto& voice_info : voice_infos) {
+ std::construct_at<VoiceInfo>(&voice_info);
+ }
+
+ if (voice_infos.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ auto sorted_voice_infos{allocator.Allocate<VoiceInfo*>(params.voices, 0x10)};
+ if (sorted_voice_infos.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ std::memset(sorted_voice_infos.data(), 0, sorted_voice_infos.size_bytes());
+
+ auto voice_channel_resources{allocator.Allocate<VoiceChannelResource>(params.voices, 0x10)};
+ u32 i{0};
+ for (auto& voice_channel_resource : voice_channel_resources) {
+ std::construct_at<VoiceChannelResource>(&voice_channel_resource, i++);
+ }
+
+ if (voice_channel_resources.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ auto voice_cpu_states{allocator.Allocate<VoiceState>(params.voices, 0x10)};
+ if (voice_cpu_states.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ for (auto& voice_state : voice_cpu_states) {
+ voice_state = {};
+ }
+
+ auto mix_infos{allocator.Allocate<MixInfo>(params.sub_mixes + 1, 0x10)};
+
+ if (mix_infos.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ u32 effect_process_order_count{0};
+ std::span<s32> effect_process_order_buffer{};
+
+ if (params.effects > 0) {
+ effect_process_order_count = params.effects * (params.sub_mixes + 1);
+ effect_process_order_buffer = allocator.Allocate<s32>(effect_process_order_count, 0x10);
+ if (effect_process_order_buffer.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+ }
+
+ i = 0;
+ for (auto& mix_info : mix_infos) {
+ std::construct_at<MixInfo>(
+ &mix_info, effect_process_order_buffer.subspan(i * params.effects, params.effects),
+ params.effects, this->behavior);
+ i++;
+ }
+
+ auto sorted_mix_infos{allocator.Allocate<MixInfo*>(params.sub_mixes + 1, 0x10)};
+ if (sorted_mix_infos.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ std::memset(sorted_mix_infos.data(), 0, sorted_mix_infos.size_bytes());
+
+ if (behavior.IsSplitterSupported()) {
+ u64 node_state_size{NodeStates::GetWorkBufferSize(params.sub_mixes + 1)};
+ u64 edge_matrix_size{EdgeMatrix::GetWorkBufferSize(params.sub_mixes + 1)};
+
+ auto node_states_workbuffer{allocator.Allocate<u8>(node_state_size, 1)};
+ auto edge_matrix_workbuffer{allocator.Allocate<u8>(edge_matrix_size, 1)};
+
+ if (node_states_workbuffer.empty() || edge_matrix_workbuffer.size() == 0) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ mix_context.Initialize(sorted_mix_infos, mix_infos, params.sub_mixes + 1,
+ effect_process_order_buffer, effect_process_order_count,
+ node_states_workbuffer, node_state_size, edge_matrix_workbuffer,
+ edge_matrix_size);
+ } else {
+ mix_context.Initialize(sorted_mix_infos, mix_infos, params.sub_mixes + 1,
+ effect_process_order_buffer, effect_process_order_count, {}, 0, {},
+ 0);
+ }
+
+ upsampler_manager = allocator.Allocate<UpsamplerManager>(1, 0x10).data();
+ if (upsampler_manager == nullptr) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ memory_pool_workbuffer = allocator.Allocate<MemoryPoolInfo>(memory_pool_count, 0x10);
+ for (auto& memory_pool : memory_pool_workbuffer) {
+ std::construct_at<MemoryPoolInfo>(&memory_pool, MemoryPoolInfo::Location::DSP);
+ }
+
+ if (memory_pool_workbuffer.empty() && memory_pool_count > 0) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ if (!splitter_context.Initialize(behavior, params, allocator)) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ std::span<EffectResultState> effect_result_states_cpu{};
+ if (behavior.IsEffectInfoVersion2Supported() && params.effects > 0) {
+ effect_result_states_cpu = allocator.Allocate<EffectResultState>(params.effects, 0x10);
+ if (effect_result_states_cpu.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+ std::memset(effect_result_states_cpu.data(), 0, effect_result_states_cpu.size_bytes());
+ }
+
+ allocator.Align(0x40);
+
+ unk_2B0 = allocator.GetSize() - allocator.GetCurrentOffset();
+ unk_2A8 = {&workbuffer[allocator.GetCurrentOffset()], unk_2B0};
+
+ upsampler_infos = allocator.Allocate<UpsamplerInfo>(upsampler_count, 0x40);
+ for (auto& upsampler_info : upsampler_infos) {
+ std::construct_at<UpsamplerInfo>(&upsampler_info);
+ }
+
+ std::construct_at<UpsamplerManager>(upsampler_manager, upsampler_count, upsampler_infos,
+ upsampler_workbuffer);
+
+ if (upsampler_infos.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ auto effect_infos{allocator.Allocate<EffectInfoBase>(params.effects, 0x40)};
+ for (auto& effect_info : effect_infos) {
+ std::construct_at<EffectInfoBase>(&effect_info);
+ }
+
+ if (effect_infos.empty() && params.effects > 0) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ std::span<EffectResultState> effect_result_states_dsp{};
+ if (behavior.IsEffectInfoVersion2Supported() && params.effects > 0) {
+ effect_result_states_dsp = allocator.Allocate<EffectResultState>(params.effects, 0x40);
+ if (effect_result_states_dsp.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+ std::memset(effect_result_states_dsp.data(), 0, effect_result_states_dsp.size_bytes());
+ }
+
+ effect_context.Initialize(effect_infos, params.effects, effect_result_states_cpu,
+ effect_result_states_dsp, effect_result_states_dsp.size());
+
+ auto sinks{allocator.Allocate<SinkInfoBase>(params.sinks, 0x10)};
+ for (auto& sink : sinks) {
+ std::construct_at<SinkInfoBase>(&sink);
+ }
+
+ if (sinks.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ sink_context.Initialize(sinks, params.sinks);
+
+ auto voice_dsp_states{allocator.Allocate<VoiceState>(params.voices, 0x40)};
+ if (voice_dsp_states.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ for (auto& voice_state : voice_dsp_states) {
+ voice_state = {};
+ }
+
+ voice_context.Initialize(sorted_voice_infos, voice_infos, voice_channel_resources,
+ voice_cpu_states, voice_dsp_states, params.voices);
+
+ if (params.perf_frames > 0) {
+ const auto perf_workbuffer_size{
+ PerformanceManager::GetRequiredBufferSizeForPerformanceMetricsPerFrame(behavior,
+ params) *
+ (params.perf_frames + 1) +
+ 0xC};
+ performance_workbuffer = allocator.Allocate<u8>(perf_workbuffer_size, 0x40);
+ if (performance_workbuffer.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+ std::memset(performance_workbuffer.data(), 0, performance_workbuffer.size_bytes());
+ performance_manager.Initialize(performance_workbuffer, performance_workbuffer.size_bytes(),
+ params, behavior, memory_pool_info);
+ }
+
+ render_time_limit_percent = 100;
+ drop_voice = params.voice_drop_enabled && params.execution_mode == ExecutionMode::Auto;
+
+ allocator.Align(0x40);
+ command_workbuffer_size = allocator.GetRemainingSize();
+ command_workbuffer = allocator.Allocate<u8>(command_workbuffer_size, 0x40);
+ if (command_workbuffer.empty()) {
+ return Service::Audio::ERR_INSUFFICIENT_BUFFER_SIZE;
+ }
+
+ command_buffer_size = 0;
+ reset_command_buffers = true;
+
+ // nn::audio::dsp::FlushDataCache(transferMemory, transferMemorySize);
+
+ if (behavior.IsCommandProcessingTimeEstimatorVersion5Supported()) {
+ command_processing_time_estimator =
+ std::make_unique<CommandProcessingTimeEstimatorVersion5>(sample_count,
+ mix_buffer_count);
+ } else if (behavior.IsCommandProcessingTimeEstimatorVersion4Supported()) {
+ command_processing_time_estimator =
+ std::make_unique<CommandProcessingTimeEstimatorVersion4>(sample_count,
+ mix_buffer_count);
+ } else if (behavior.IsCommandProcessingTimeEstimatorVersion3Supported()) {
+ command_processing_time_estimator =
+ std::make_unique<CommandProcessingTimeEstimatorVersion3>(sample_count,
+ mix_buffer_count);
+ } else if (behavior.IsCommandProcessingTimeEstimatorVersion2Supported()) {
+ command_processing_time_estimator =
+ std::make_unique<CommandProcessingTimeEstimatorVersion2>(sample_count,
+ mix_buffer_count);
+ } else {
+ command_processing_time_estimator =
+ std::make_unique<CommandProcessingTimeEstimatorVersion1>(sample_count,
+ mix_buffer_count);
+ }
+
+ initialized = true;
+ return ResultSuccess;
+}
+
+void System::Finalize() {
+ if (!initialized) {
+ return;
+ }
+
+ if (active) {
+ Stop();
+ }
+
+ applet_resource_user_id = 0;
+
+ PoolMapper pool_mapper(process_handle, false);
+ pool_mapper.Unmap(memory_pool_info);
+
+ if (process_handle) {
+ pool_mapper.ClearUseState(memory_pool_workbuffer, memory_pool_count);
+ for (auto& memory_pool : memory_pool_workbuffer) {
+ if (memory_pool.IsMapped()) {
+ pool_mapper.Unmap(memory_pool);
+ }
+ }
+
+ // dsp::ProcessCleanup
+ // close handle
+ }
+ initialized = false;
+}
+
+void System::Start() {
+ std::scoped_lock l{lock};
+ frames_elapsed = 0;
+ state = State::Started;
+ active = true;
+}
+
+void System::Stop() {
+ {
+ std::scoped_lock l{lock};
+ state = State::Stopped;
+ active = false;
+ }
+
+ if (execution_mode == ExecutionMode::Auto) {
+ // Should wait for the system to terminate here, but core timing (should have) already
+ // stopped, so this isn't needed. Find a way to make this definite.
+
+ // terminate_event.Wait();
+ }
+}
+
+Result System::Update(std::span<const u8> input, std::span<u8> performance, std::span<u8> output) {
+ std::scoped_lock l{lock};
+
+ const auto start_time{core.CoreTiming().GetClockTicks()};
+
+ InfoUpdater info_updater(input, output, process_handle, behavior);
+
+ auto result{info_updater.UpdateBehaviorInfo(behavior)};
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update BehaviorInfo!");
+ return result;
+ }
+
+ result = info_updater.UpdateMemoryPools(memory_pool_workbuffer, memory_pool_count);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update MemoryPools!");
+ return result;
+ }
+
+ result = info_updater.UpdateVoiceChannelResources(voice_context);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update VoiceChannelResources!");
+ return result;
+ }
+
+ result = info_updater.UpdateVoices(voice_context, memory_pool_workbuffer, memory_pool_count);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update Voices!");
+ return result;
+ }
+
+ result = info_updater.UpdateEffects(effect_context, active, memory_pool_workbuffer,
+ memory_pool_count);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update Effects!");
+ return result;
+ }
+
+ if (behavior.IsSplitterSupported()) {
+ result = info_updater.UpdateSplitterInfo(splitter_context);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update SplitterInfo!");
+ return result;
+ }
+ }
+
+ result =
+ info_updater.UpdateMixes(mix_context, mix_buffer_count, effect_context, splitter_context);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update Mixes!");
+ return result;
+ }
+
+ result = info_updater.UpdateSinks(sink_context, memory_pool_workbuffer, memory_pool_count);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update Sinks!");
+ return result;
+ }
+
+ PerformanceManager* perf_manager{nullptr};
+ if (performance_manager.IsInitialized()) {
+ perf_manager = &performance_manager;
+ }
+
+ result =
+ info_updater.UpdatePerformanceBuffer(performance, performance.size_bytes(), perf_manager);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update PerformanceBuffer!");
+ return result;
+ }
+
+ result = info_updater.UpdateErrorInfo(behavior);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update ErrorInfo!");
+ return result;
+ }
+
+ if (behavior.IsElapsedFrameCountSupported()) {
+ result = info_updater.UpdateRendererInfo(frames_elapsed);
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Failed to update RendererInfo!");
+ return result;
+ }
+ }
+
+ result = info_updater.CheckConsumedSize();
+ if (result.IsError()) {
+ LOG_ERROR(Service_Audio, "Invalid consume size!");
+ return result;
+ }
+
+ adsp_rendered_event->GetWritableEvent().Clear();
+ num_times_updated++;
+
+ const auto end_time{core.CoreTiming().GetClockTicks()};
+ ticks_spent_updating += end_time - start_time;
+
+ return ResultSuccess;
+}
+
+u32 System::GetRenderingTimeLimit() const {
+ return render_time_limit_percent;
+}
+
+void System::SetRenderingTimeLimit(const u32 limit) {
+ render_time_limit_percent = limit;
+}
+
+u32 System::GetSessionId() const {
+ return session_id;
+}
+
+u32 System::GetSampleRate() const {
+ return sample_rate;
+}
+
+u32 System::GetSampleCount() const {
+ return sample_count;
+}
+
+u32 System::GetMixBufferCount() const {
+ return mix_buffer_count;
+}
+
+ExecutionMode System::GetExecutionMode() const {
+ return execution_mode;
+}
+
+u32 System::GetRenderingDevice() const {
+ return render_device;
+}
+
+bool System::IsActive() const {
+ return active;
+}
+
+void System::SendCommandToDsp() {
+ std::scoped_lock l{lock};
+
+ if (initialized) {
+ if (active) {
+ terminate_event.Reset();
+ const auto remaining_command_count{adsp.GetRemainCommandCount(session_id)};
+ u64 command_size{0};
+
+ if (remaining_command_count) {
+ adsp_behind = true;
+ command_size = command_buffer_size;
+ } else {
+ command_size = GenerateCommand(command_workbuffer, command_workbuffer_size);
+ }
+
+ auto translated_addr{
+ memory_pool_info.Translate(CpuAddr(command_workbuffer.data()), command_size)};
+
+ auto time_limit_percent{70.0f};
+ if (behavior.IsAudioRendererProcessingTimeLimit80PercentSupported()) {
+ time_limit_percent = 80.0f;
+ } else if (behavior.IsAudioRendererProcessingTimeLimit75PercentSupported()) {
+ time_limit_percent = 75.0f;
+ } else {
+ // result ignored and 70 is used anyway
+ behavior.IsAudioRendererProcessingTimeLimit70PercentSupported();
+ time_limit_percent = 70.0f;
+ }
+
+ ADSP::CommandBuffer command_buffer{
+ .buffer{translated_addr},
+ .size{command_size},
+ .time_limit{
+ static_cast<u64>((time_limit_percent / 100) * 2'880'000.0 *
+ (static_cast<f32>(render_time_limit_percent) / 100.0f))},
+ .remaining_command_count{remaining_command_count},
+ .reset_buffers{reset_command_buffers},
+ .applet_resource_user_id{applet_resource_user_id},
+ .render_time_taken{adsp.GetRenderTimeTaken(session_id)},
+ };
+
+ adsp.SendCommandBuffer(session_id, command_buffer);
+ reset_command_buffers = false;
+ command_buffer_size = command_size;
+ if (remaining_command_count == 0) {
+ adsp_rendered_event->GetWritableEvent().Signal();
+ }
+ } else {
+ adsp.ClearRemainCount(session_id);
+ terminate_event.Set();
+ }
+ }
+}
+
+u64 System::GenerateCommand(std::span<u8> in_command_buffer,
+ [[maybe_unused]] const u64 command_buffer_size_) {
+ PoolMapper::ClearUseState(memory_pool_workbuffer, memory_pool_count);
+ const auto start_time{core.CoreTiming().GetClockTicks()};
+
+ auto command_list_header{reinterpret_cast<CommandListHeader*>(in_command_buffer.data())};
+
+ command_list_header->buffer_count = static_cast<s16>(voice_channels + mix_buffer_count);
+ command_list_header->sample_count = sample_count;
+ command_list_header->sample_rate = sample_rate;
+ command_list_header->samples_buffer = samples_workbuffer;
+
+ const auto performance_initialized{performance_manager.IsInitialized()};
+ if (performance_initialized) {
+ performance_manager.TapFrame(adsp_behind, num_voices_dropped, render_start_tick);
+ adsp_behind = false;
+ num_voices_dropped = 0;
+ render_start_tick = 0;
+ }
+
+ s8 channel_count{2};
+ if (execution_mode == ExecutionMode::Auto) {
+ const auto& sink{core.AudioCore().GetOutputSink()};
+ channel_count = static_cast<s8>(sink.GetDeviceChannels());
+ }
+
+ AudioRendererSystemContext render_context{
+ .session_id{session_id},
+ .channels{channel_count},
+ .mix_buffer_count{mix_buffer_count},
+ .behavior{&behavior},
+ .depop_buffer{depop_buffer},
+ .upsampler_manager{upsampler_manager},
+ .memory_pool_info{&memory_pool_info},
+ };
+
+ CommandBuffer command_buffer{
+ .command_list{in_command_buffer},
+ .sample_count{sample_count},
+ .sample_rate{sample_rate},
+ .size{sizeof(CommandListHeader)},
+ .count{0},
+ .estimated_process_time{0},
+ .memory_pool{&memory_pool_info},
+ .time_estimator{command_processing_time_estimator.get()},
+ .behavior{&behavior},
+ };
+
+ PerformanceManager* perf_manager{nullptr};
+ if (performance_initialized) {
+ perf_manager = &performance_manager;
+ }
+
+ CommandGenerator command_generator{command_buffer, *command_list_header, render_context,
+ voice_context, mix_context, effect_context,
+ sink_context, splitter_context, perf_manager};
+
+ voice_context.SortInfo();
+
+ const auto start_estimated_time{command_buffer.estimated_process_time};
+
+ command_generator.GenerateVoiceCommands();
+ command_generator.GenerateSubMixCommands();
+ command_generator.GenerateFinalMixCommands();
+ command_generator.GenerateSinkCommands();
+
+ if (drop_voice) {
+ f32 time_limit_percent{70.0f};
+ if (render_context.behavior->IsAudioRendererProcessingTimeLimit80PercentSupported()) {
+ time_limit_percent = 80.0f;
+ } else if (render_context.behavior
+ ->IsAudioRendererProcessingTimeLimit75PercentSupported()) {
+ time_limit_percent = 75.0f;
+ } else {
+ // result is ignored
+ render_context.behavior->IsAudioRendererProcessingTimeLimit70PercentSupported();
+ time_limit_percent = 70.0f;
+ }
+ const auto time_limit{static_cast<u32>(
+ static_cast<f32>(start_estimated_time - command_buffer.estimated_process_time) +
+ (((time_limit_percent / 100.0f) * 2'880'000.0) *
+ (static_cast<f32>(render_time_limit_percent) / 100.0f)))};
+ num_voices_dropped = DropVoices(command_buffer, start_estimated_time, time_limit);
+ }
+
+ command_list_header->buffer_size = command_buffer.size;
+ command_list_header->command_count = command_buffer.count;
+
+ voice_context.UpdateStateByDspShared();
+
+ if (render_context.behavior->IsEffectInfoVersion2Supported()) {
+ effect_context.UpdateStateByDspShared();
+ }
+
+ const auto end_time{core.CoreTiming().GetClockTicks()};
+ total_ticks_elapsed += end_time - start_time;
+ num_command_lists_generated++;
+ render_start_tick = adsp.GetRenderingStartTick(session_id);
+ frames_elapsed++;
+
+ return command_buffer.size;
+}
+
+u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_process_time,
+ const u32 time_limit) {
+ u32 i{0};
+ auto command_list{command_buffer.command_list.data() + sizeof(CommandListHeader)};
+ ICommand* cmd{};
+
+ for (; i < command_buffer.count; i++) {
+ cmd = reinterpret_cast<ICommand*>(command_list);
+ if (cmd->type != CommandId::Performance &&
+ cmd->type != CommandId::DataSourcePcmInt16Version1 &&
+ cmd->type != CommandId::DataSourcePcmInt16Version2 &&
+ cmd->type != CommandId::DataSourcePcmFloatVersion1 &&
+ cmd->type != CommandId::DataSourcePcmFloatVersion2 &&
+ cmd->type != CommandId::DataSourceAdpcmVersion1 &&
+ cmd->type != CommandId::DataSourceAdpcmVersion2) {
+ break;
+ }
+ command_list += cmd->size;
+ }
+
+ if (cmd == nullptr || command_buffer.count == 0 || i >= command_buffer.count) {
+ return 0;
+ }
+
+ auto voices_dropped{0};
+ while (i < command_buffer.count) {
+ const auto node_id{cmd->node_id};
+ const auto node_id_type{cmd->node_id >> 28};
+ const auto node_id_base{cmd->node_id & 0xFFF};
+
+ if (estimated_process_time <= time_limit) {
+ break;
+ }
+
+ if (node_id_type != 1) {
+ break;
+ }
+
+ auto& voice_info{voice_context.GetInfo(node_id_base)};
+ if (voice_info.priority == HighestVoicePriority) {
+ break;
+ }
+
+ voices_dropped++;
+ voice_info.voice_dropped = true;
+
+ if (i < command_buffer.count) {
+ while (cmd->node_id == node_id) {
+ if (cmd->type == CommandId::DepopPrepare) {
+ cmd->enabled = true;
+ } else if (cmd->type == CommandId::Performance || !cmd->enabled) {
+ cmd->enabled = false;
+ }
+ i++;
+ command_list += cmd->size;
+ cmd = reinterpret_cast<ICommand*>(command_list);
+ }
+ }
+ }
+ return voices_dropped;
+}
+
+} // namespace AudioCore::AudioRenderer