mirrors/yuzu
2
1
Fork 0
mirror of https://github.com/yuzu-emu/yuzu.git synced 2024-07-04 23:31:19 +01:00
Code Issues Releases Activity

Address issues

Browse source
This commit is contained in:
David Marcec 2020-07-25 12:32:05 +10:00
parent 8a497adf85
commit b924c71822
8 changed files with 104 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/audio_core/behavior_info.cpp
View file

@ -99,7 +99,7 @@ bool BehaviorInfo::IsSplitterBugFixed() const {
void BehaviorInfo::CopyErrorInfo(BehaviorInfo::OutParams& dst) {
dst.error_count = static_cast<u32>(error_count);
std::memcpy(dst.errors.data(), errors.data(), sizeof(ErrorInfo) * dst.errors.size());
std::copy(errors.begin(), errors.begin() + error_count, dst.errors.begin());
}
} // namespace AudioCore

155
src/audio_core/command_generator.cpp
View file

@ -10,12 +10,12 @@
namespace AudioCore {
namespace {
static constexpr std::size_t MIX_BUFFER_SIZE = 0x3f00;
static constexpr std::size_t SCALED_MIX_BUFFER_SIZE = MIX_BUFFER_SIZE << 15ULL;
constexpr std::size_t MIX_BUFFER_SIZE = 0x3f00;
constexpr std::size_t SCALED_MIX_BUFFER_SIZE = MIX_BUFFER_SIZE << 15ULL;
template <std::size_t N>
void ApplyMix(s32* output, const s32* input, s32 gain, s32 sample_count) {
for (s32 i = 0; i < sample_count; i += N) {
for (std::size_t i = 0; i < static_cast<std::size_t>(sample_count); i += N) {
for (std::size_t j = 0; j < N; j++) {
output[i + j] +=
static_cast<s32>((static_cast<s64>(input[i + j]) * gain + 0x4000) >> 15);
@ -59,13 +59,13 @@ CommandGenerator::CommandGenerator(AudioCommon::AudioRendererParameter& worker_p
CommandGenerator::~CommandGenerator() = default;
void CommandGenerator::ClearMixBuffers() {
std::memset(mix_buffer.data(), 0, mix_buffer.size() * sizeof(s32));
std::memset(sample_buffer.data(), 0, sample_buffer.size() * sizeof(s32));
std::fill(mix_buffer.begin(), mix_buffer.end(), 0);
std::fill(sample_buffer.begin(), sample_buffer.end(), 0);
}
void CommandGenerator::GenerateVoiceCommands() {
if (dumping_frame) {
LOG_CRITICAL(Audio, "(DSP_TRACE) GenerateVoiceCommands");
LOG_DEBUG(Audio, "(DSP_TRACE) GenerateVoiceCommands");
}
// Grab all our voices
const auto voice_count = voice_context.GetVoiceCount();
@ -168,24 +168,26 @@ void CommandGenerator::GenerateFinalMixCommands() {
}
void CommandGenerator::PreCommand() {
if (dumping_frame) {
for (std::size_t i = 0; i < splitter_context.GetInfoCount(); i++) {
const auto& base = splitter_context.GetInfo(i);
std::string graph = fmt::format("b[{}]", i);
auto* head = base.GetHead();
while (head != nullptr) {
graph += fmt::format("->{}", head->GetMixId());
head = head->GetNextDestination();
}
LOG_CRITICAL(Audio, "(DSP_TRACE) SplitterGraph splitter_info={}, {}", i, graph);
if (!dumping_frame) {
return;
}
for (std::size_t i = 0; i < splitter_context.GetInfoCount(); i++) {
const auto& base = splitter_context.GetInfo(i);
std::string graph = fmt::format("b[{}]", i);
auto* head = base.GetHead();
while (head != nullptr) {
graph += fmt::format("->{}", head->GetMixId());
head = head->GetNextDestination();
}
LOG_DEBUG(Audio, "(DSP_TRACE) SplitterGraph splitter_info={}, {}", i, graph);
}
}
void CommandGenerator::PostCommand() {
if (dumping_frame) {
dumping_frame = false;
if (!dumping_frame) {
return;
}
dumping_frame = false;
}
void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
@ -194,29 +196,31 @@ void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, Vo
const auto depop = in_params.should_depop;
if (in_params.mix_id != AudioCommon::NO_MIX) {
auto& mix_info = mix_context.GetInfo(in_params.mix_id);
[[maybe_unused]] auto& mix_info = mix_context.GetInfo(in_params.mix_id);
// mix_info.
// TODO(ogniK): Depop to destination mix
} else if (in_params.splitter_info_id != AudioCommon::NO_SPLITTER) {
// TODO(ogniK): Depop to splitter
}
if (!depop) {
switch (in_params.sample_format) {
case SampleFormat::Pcm16:
DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(channel), dsp_state, channel,
worker_params.sample_rate, worker_params.sample_count,
in_params.node_id);
break;
case SampleFormat::Adpcm:
ASSERT(channel == 0 && in_params.channel_count == 1);
DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(0), dsp_state, 0,
worker_params.sample_rate, worker_params.sample_count,
in_params.node_id);
break;
default:
UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
}
if (depop) {
return;
}
switch (in_params.sample_format) {
case SampleFormat::Pcm16:
DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(channel), dsp_state, channel,
worker_params.sample_rate, worker_params.sample_count,
in_params.node_id);
break;
case SampleFormat::Adpcm:
ASSERT(channel == 0 && in_params.channel_count == 1);
DecodeFromWaveBuffers(voice_info, GetChannelMixBuffer(0), dsp_state, 0,
worker_params.sample_rate, worker_params.sample_count,
in_params.node_id);
break;
default:
UNREACHABLE_MSG("Unimplemented sample format={}", in_params.sample_format);
}
}
@ -233,8 +237,7 @@ void CommandGenerator::GenerateBiquadFilterCommandForVoice(ServerVoiceInfo& voic
// Reinitialize our biquad filter state if it was enabled previously
if (!in_params.was_biquad_filter_enabled[i]) {
std::memset(dsp_state.biquad_filter_state.data(), 0,
dsp_state.biquad_filter_state.size() * sizeof(s64));
dsp_state.biquad_filter_state.fill(0);
}
// Generate biquad filter
@ -248,39 +251,34 @@ void AudioCore::CommandGenerator::GenerateBiquadFilterCommand(
s32 mix_buffer, const BiquadFilterParameter& params, std::array<s64, 2>& state,
std::size_t input_offset, std::size_t output_offset, s32 sample_count, s32 node_id) {
if (dumping_frame) {
LOG_CRITICAL(Audio,
"(DSP_TRACE) GenerateBiquadFilterCommand node_id={}, "
"input_mix_buffer={}, output_mix_buffer={}",
node_id, input_offset, output_offset);
LOG_DEBUG(Audio,
"(DSP_TRACE) GenerateBiquadFilterCommand node_id={}, "
"input_mix_buffer={}, output_mix_buffer={}",
node_id, input_offset, output_offset);
}
const auto* input = GetMixBuffer(input_offset);
auto* output = GetMixBuffer(output_offset);
// Biquad filter parameters
const auto n0 = params.numerator[0];
const auto n1 = params.numerator[1];
const auto n2 = params.numerator[2];
const auto d0 = params.denominator[0];
const auto d1 = params.denominator[1];
const auto [n0, n1, n2] = params.numerator;
const auto [d0, d1] = params.denominator;
// Biquad filter states
auto s0 = state[0];
auto s1 = state[1];
auto [s0, s1] = state;
constexpr s64 MIN = std::numeric_limits<int32_t>::min();
constexpr s64 MAX = std::numeric_limits<int32_t>::max();
constexpr s64 int32_min = std::numeric_limits<s32>::min();
constexpr s64 int32_max = std::numeric_limits<s32>::max();
for (int i = 0; i < sample_count; ++i) {
const auto sample = static_cast<int64_t>(input[i]);
const auto sample = static_cast<s64>(input[i]);
const auto f = (sample * n0 + s0 + 0x4000) >> 15;
const auto y = std::clamp(f, MIN, MAX);
const auto y = std::clamp(f, int32_min, int32_max);
s0 = sample * n1 + y * d0 + s1;
s1 = sample * n2 + y * d1;
output[i] = static_cast<s32>(y);
}
state[0] = s0;
state[1] = s1;
state = {s0, s1};
}
ServerSplitterDestinationData* CommandGenerator::GetDestinationData(s32 splitter_id, s32 index) {
@ -298,11 +296,11 @@ void CommandGenerator::GenerateVolumeRampCommand(float last_volume, float curren
static_cast<float>(worker_params.sample_count));
if (dumping_frame) {
LOG_CRITICAL(Audio,
"(DSP_TRACE) GenerateVolumeRampCommand node_id={}, input={}, output={}, "
"last_volume={}, current_volume={}",
node_id, GetMixChannelBufferOffset(channel),
GetMixChannelBufferOffset(channel), last_volume, current_volume);
LOG_DEBUG(Audio,
"(DSP_TRACE) GenerateVolumeRampCommand node_id={}, input={}, output={}, "
"last_volume={}, current_volume={}",
node_id, GetMixChannelBufferOffset(channel), GetMixChannelBufferOffset(channel),
last_volume, current_volume);
}
// Apply generic gain on samples
ApplyGain(GetChannelMixBuffer(channel), GetChannelMixBuffer(channel), last, delta,
@ -320,11 +318,11 @@ void CommandGenerator::GenerateVoiceMixCommand(const MixVolumeBuffer& mix_volume
static_cast<float>(worker_params.sample_count);
if (dumping_frame) {
LOG_CRITICAL(Audio,
"(DSP_TRACE) GenerateVoiceMixCommand node_id={}, input={}, "
"output={}, last_volume={}, current_volume={}",
node_id, voice_index, mix_buffer_offset + i, last_mix_volumes[i],
mix_volumes[i]);
LOG_DEBUG(Audio,
"(DSP_TRACE) GenerateVoiceMixCommand node_id={}, input={}, "
"output={}, last_volume={}, current_volume={}",
node_id, voice_index, mix_buffer_offset + i, last_mix_volumes[i],
mix_volumes[i]);
}
dsp_state.previous_samples[i] =
@ -338,7 +336,7 @@ void CommandGenerator::GenerateVoiceMixCommand(const MixVolumeBuffer& mix_volume
void CommandGenerator::GenerateSubMixCommand(ServerMixInfo& mix_info) {
if (dumping_frame) {
LOG_CRITICAL(Audio, "(DSP_TRACE) GenerateSubMixCommand");
LOG_DEBUG(Audio, "(DSP_TRACE) GenerateSubMixCommand");
}
// TODO(ogniK): Depop
// TODO(ogniK): Effects
@ -391,9 +389,9 @@ void CommandGenerator::GenerateMixCommand(std::size_t output_offset, std::size_t
float volume, s32 node_id) {
if (dumping_frame) {
LOG_CRITICAL(Audio,
"(DSP_TRACE) GenerateMixCommand node_id={}, input={}, output={}, volume={}",
node_id, input_offset, output_offset, volume);
LOG_DEBUG(Audio,
"(DSP_TRACE) GenerateMixCommand node_id={}, input={}, output={}, volume={}",
node_id, input_offset, output_offset, volume);
}
auto* output = GetMixBuffer(output_offset);
@ -412,7 +410,7 @@ void CommandGenerator::GenerateMixCommand(std::size_t output_offset, std::size_t
void CommandGenerator::GenerateFinalMixCommand() {
if (dumping_frame) {
LOG_CRITICAL(Audio, "(DSP_TRACE) GenerateFinalMixCommand");
LOG_DEBUG(Audio, "(DSP_TRACE) GenerateFinalMixCommand");
}
// TODO(ogniK): Depop
// TODO(ogniK): Effects
@ -421,7 +419,7 @@ void CommandGenerator::GenerateFinalMixCommand() {
for (s32 i = 0; i < in_params.buffer_count; i++) {
const s32 gain = static_cast<s32>(in_params.volume * 32768.0f);
if (dumping_frame) {
LOG_CRITICAL(
LOG_DEBUG(
Audio,
"(DSP_TRACE) ApplyGainWithoutDelta node_id={}, input={}, output={}, volume={}",
in_params.node_id, in_params.buffer_offset + i, in_params.buffer_offset + i,
@ -544,11 +542,11 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
s32 node_id) {
auto& in_params = voice_info.GetInParams();
if (dumping_frame) {
LOG_CRITICAL(Audio,
"(DSP_TRACE) DecodeFromWaveBuffers, node_id={}, channel={}, "
"format={}, sample_count={}, sample_rate={}, mix_id={}, splitter_id={}",
node_id, channel, in_params.sample_format, sample_count, in_params.sample_rate,
in_params.mix_id, in_params.splitter_info_id);
LOG_DEBUG(Audio,
"(DSP_TRACE) DecodeFromWaveBuffers, node_id={}, channel={}, "
"format={}, sample_count={}, sample_rate={}, mix_id={}, splitter_id={}",
node_id, channel, in_params.sample_format, sample_count, in_params.sample_rate,
in_params.mix_id, in_params.splitter_info_id);
}
ASSERT_OR_EXECUTE(output != nullptr, { return; });
@ -649,10 +647,11 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
if (in_params.behavior_flags.is_pitch_and_src_skipped.Value()) {
// No need to resample
memcpy(output, sample_buffer.data(), samples_read * sizeof(s32));
std::memcpy(output, sample_buffer.data(), samples_read * sizeof(s32));
} else {
std::memset(sample_buffer.data() + temp_mix_offset, 0,
sizeof(s32) * (samples_to_read - samples_read));
std::fill(sample_buffer.begin() + temp_mix_offset,
sample_buffer.begin() + temp_mix_offset + (samples_to_read - samples_read),
0);
AudioCore::Resample(output, sample_buffer.data(), resample_rate, dsp_state.fraction,
samples_to_output);
// Resample

2
src/audio_core/command_generator.h
View file

@ -19,7 +19,9 @@ class MixContext;
class SplitterContext;
class ServerSplitterDestinationData;
class ServerMixInfo;
using MixVolumeBuffer = std::array<float, AudioCommon::MAX_MIX_BUFFERS>;
class CommandGenerator {
public:
explicit CommandGenerator(AudioCommon::AudioRendererParameter& worker_params,

11
src/audio_core/effect_context.cpp
View file

@ -2,13 +2,14 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <algorithm>
#include "audio_core/effect_context.h"
namespace AudioCore {
EffectContext::EffectContext(std::size_t effect_count) : effect_count(effect_count) {
for (std::size_t i = 0; i < effect_count; i++) {
effects.push_back(std::make_unique<EffectStubbed>());
}
effects.reserve(effect_count);
std::generate_n(std::back_inserter(effects), effect_count,
[] { return std::make_unique<EffectStubbed>(); });
}
EffectContext::~EffectContext() = default;
@ -20,6 +21,10 @@ EffectBase* EffectContext::GetInfo(std::size_t i) {
return effects.at(i).get();
}
const EffectBase* EffectContext::GetInfo(std::size_t i) const {
return effects.at(i).get();
}
EffectStubbed::EffectStubbed() : EffectBase::EffectBase() {}
EffectStubbed::~EffectStubbed() = default;

1
src/audio_core/effect_context.h
View file

@ -106,6 +106,7 @@ public:
std::size_t GetCount() const;
EffectBase* GetInfo(std::size_t i);
const EffectBase* GetInfo(std::size_t i) const;
private:
std::size_t effect_count{};

1
src/audio_core/mix_context.cpp
View file

@ -16,6 +16,7 @@ void MixContext::Initialize(const BehaviorInfo& behavior_info, std::size_t mix_c
infos.resize(info_count);
auto& final_mix = GetInfo(AudioCommon::FINAL_MIX);
final_mix.GetInParams().mix_id = AudioCommon::FINAL_MIX;
sorted_info.reserve(infos.size());
for (auto& info : infos) {
sorted_info.push_back(&info);
}

10
src/audio_core/splitter_context.cpp
View file

@ -173,7 +173,7 @@ void SplitterContext::Initialize(BehaviorInfo& behavior_info, std::size_t _info_
bool SplitterContext::Update(const std::vector<u8>& input, std::size_t& input_offset,
std::size_t& bytes_read) {
auto UpdateOffsets = [&](std::size_t read) {
const auto UpdateOffsets = [&](std::size_t read) {
input_offset += read;
bytes_read += read;
};
@ -286,7 +286,7 @@ void SplitterContext::Setup(std::size_t _info_count, std::size_t _data_count,
bool SplitterContext::UpdateInfo(const std::vector<u8>& input, std::size_t& input_offset,
std::size_t& bytes_read, s32 in_splitter_count) {
auto UpdateOffsets = [&](std::size_t read) {
const auto UpdateOffsets = [&](std::size_t read) {
input_offset += read;
bytes_read += read;
};
@ -326,7 +326,7 @@ bool SplitterContext::UpdateInfo(const std::vector<u8>& input, std::size_t& inpu
bool SplitterContext::UpdateData(const std::vector<u8>& input, std::size_t& input_offset,
std::size_t& bytes_read, s32 in_data_count) {
auto UpdateOffsets = [&](std::size_t read) {
const auto UpdateOffsets = [&](std::size_t read) {
input_offset += read;
bytes_read += read;
};
@ -412,9 +412,9 @@ bool SplitterContext::RecomposeDestination(ServerSplitterInfo& info,
NodeStates::NodeStates() = default;
NodeStates::~NodeStates() = default;
void NodeStates::Initialize(std::size_t _node_count) {
void NodeStates::Initialize(std::size_t node_count_) {
// Setup our work parameters
node_count = _node_count;
node_count = node_count_;
was_node_found.resize(node_count);
was_node_completed.resize(node_count);
index_list.resize(node_count);

23
src/audio_core/voice_context.cpp
View file

@ -29,12 +29,12 @@ void ServerVoiceChannelResource::Update(VoiceChannelResource::InParams& in_param
in_use = in_params.in_use;
// Update our mix volumes only if it's in use
if (in_params.in_use) {
std::copy(in_params.mix_volume.begin(), in_params.mix_volume.end(), mix_volume.begin());
mix_volume = in_params.mix_volume;
}
}
void ServerVoiceChannelResource::UpdateLastMixVolumes() {
std::copy(mix_volume.begin(), mix_volume.end(), last_mix_volume.begin());
last_mix_volume = mix_volume;
}
const std::array<float, AudioCommon::MAX_MIX_BUFFERS>&
@ -64,8 +64,7 @@ void ServerVoiceInfo::Initialize() {
in_params.pitch = 0.0f;
in_params.volume = 0.0f;
in_params.last_volume = 0.0f;
std::memset(in_params.biquad_filter.data(), 0,
sizeof(BiquadFilterParameter) * in_params.biquad_filter.size());
in_params.biquad_filter.fill({});
in_params.wave_buffer_count = 0;
in_params.wave_bufffer_head = 0;
in_params.mix_id = AudioCommon::NO_MIX;
@ -78,8 +77,7 @@ void ServerVoiceInfo::Initialize() {
in_params.voice_drop_flag = false;
in_params.buffer_mapped = false;
in_params.wave_buffer_flush_request_count = 0;
std::fill(in_params.was_biquad_filter_enabled.begin(),
in_params.was_biquad_filter_enabled.end(), false);
in_params.was_biquad_filter_enabled.fill(false);
for (auto& wave_buffer : in_params.wave_buffer) {
wave_buffer.start_sample_offset = 0;
@ -126,8 +124,7 @@ void ServerVoiceInfo::UpdateParameters(const VoiceInfo::InParams& voice_in,
in_params.channel_count = voice_in.channel_count;
in_params.pitch = voice_in.pitch;
in_params.volume = voice_in.volume;
std::memcpy(in_params.biquad_filter.data(), voice_in.biquad_filter.data(),
sizeof(BiquadFilterParameter) * voice_in.biquad_filter.size());
in_params.biquad_filter = voice_in.biquad_filter;
in_params.wave_buffer_count = voice_in.wave_buffer_count;
in_params.wave_bufffer_head = voice_in.wave_buffer_head;
if (behavior_info.IsFlushVoiceWaveBuffersSupported()) {
@ -308,7 +305,7 @@ void ServerVoiceInfo::ResetResources(VoiceContext& voice_context) {
const auto channel_resource = in_params.voice_channel_resource_id[i];
auto& dsp_state =
voice_context.GetDspSharedState(static_cast<std::size_t>(channel_resource));
std::memset(&dsp_state, 0, sizeof(VoiceState));
dsp_state = {};
voice_context.GetChannelResource(static_cast<std::size_t>(channel_resource))
.UpdateLastMixVolumes();
}
@ -362,9 +359,8 @@ bool ServerVoiceInfo::UpdateParametersForCommandGeneration(
dsp_state->offset = 0;
dsp_state->played_sample_count = 0;
dsp_state->fraction = 0;
std::memset(dsp_state->sample_history.data(), 0,
sizeof(s32) * dsp_state->sample_history.size());
std::memset(&dsp_state->context, 0, sizeof(dsp_state->context));
dsp_state->sample_history.fill(0);
dsp_state->context = {};
}
in_params.current_playstate = ServerPlayState::Stop;
@ -524,8 +520,7 @@ void VoiceContext::SortInfo() {
}
void VoiceContext::UpdateStateByDspShared() {
std::memcpy(voice_states.data(), dsp_voice_states.data(),
sizeof(VoiceState) * dsp_voice_states.size());
voice_states = dsp_voice_states;
}
} // namespace AudioCore