citra/src/audio_core/hle/hle.cpp

361 lines
12 KiB
C++
Raw Normal View History

2017-12-20 18:44:32 +00:00
// Copyright 2017 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include "audio_core/audio_types.h"
#include "audio_core/hle/common.h"
#include "audio_core/hle/hle.h"
#include "audio_core/hle/mixers.h"
#include "audio_core/hle/shared_memory.h"
#include "audio_core/hle/source.h"
#include "audio_core/sink.h"
#include "common/assert.h"
#include "common/common_types.h"
#include "common/logging/log.h"
#include "core/core_timing.h"
2018-07-24 20:54:33 +01:00
using InterruptType = Service::DSP::DSP_DSP::InterruptType;
using Service::DSP::DSP_DSP;
2017-12-20 18:44:32 +00:00
namespace AudioCore {
static constexpr u64 audio_frame_ticks = 1310252ull; ///< Units: ARM11 cycles
struct DspHle::Impl final {
public:
explicit Impl(DspHle& parent);
~Impl();
DspState GetDspState() const;
std::vector<u8> PipeRead(DspPipe pipe_number, u32 length);
size_t GetPipeReadableSize(DspPipe pipe_number) const;
void PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer);
std::array<u8, Memory::DSP_RAM_SIZE>& GetDspMemory();
void SetServiceToInterrupt(std::weak_ptr<DSP_DSP> dsp);
2018-07-24 20:54:33 +01:00
2017-12-20 18:44:32 +00:00
private:
void ResetPipes();
void WriteU16(DspPipe pipe_number, u16 value);
void AudioPipeWriteStructAddresses();
size_t CurrentRegionIndex() const;
HLE::SharedMemory& ReadRegion();
HLE::SharedMemory& WriteRegion();
StereoFrame16 GenerateCurrentFrame();
bool Tick();
2018-07-23 22:08:14 +01:00
void AudioTickCallback(s64 cycles_late);
2017-12-20 18:44:32 +00:00
DspState dsp_state = DspState::Off;
std::array<std::vector<u8>, num_dsp_pipe> pipe_data;
HLE::DspMemory dsp_memory;
std::array<HLE::Source, HLE::num_sources> sources{{
HLE::Source(0), HLE::Source(1), HLE::Source(2), HLE::Source(3), HLE::Source(4),
HLE::Source(5), HLE::Source(6), HLE::Source(7), HLE::Source(8), HLE::Source(9),
HLE::Source(10), HLE::Source(11), HLE::Source(12), HLE::Source(13), HLE::Source(14),
HLE::Source(15), HLE::Source(16), HLE::Source(17), HLE::Source(18), HLE::Source(19),
HLE::Source(20), HLE::Source(21), HLE::Source(22), HLE::Source(23),
}};
HLE::Mixers mixers;
DspHle& parent;
CoreTiming::EventType* tick_event;
2018-07-24 20:54:33 +01:00
std::weak_ptr<DSP_DSP> dsp_dsp;
2017-12-20 18:44:32 +00:00
};
DspHle::Impl::Impl(DspHle& parent_) : parent(parent_) {
2018-02-04 22:23:51 +00:00
dsp_memory.raw_memory.fill(0);
2017-12-20 18:44:32 +00:00
tick_event =
2018-07-23 22:08:14 +01:00
CoreTiming::RegisterEvent("AudioCore::DspHle::tick_event", [this](u64, s64 cycles_late) {
2017-12-20 18:44:32 +00:00
this->AudioTickCallback(cycles_late);
});
CoreTiming::ScheduleEvent(audio_frame_ticks, tick_event);
}
DspHle::Impl::~Impl() {
CoreTiming::UnscheduleEvent(tick_event, 0);
}
DspState DspHle::Impl::GetDspState() const {
return dsp_state;
}
std::vector<u8> DspHle::Impl::PipeRead(DspPipe pipe_number, u32 length) {
const size_t pipe_index = static_cast<size_t>(pipe_number);
if (pipe_index >= num_dsp_pipe) {
2018-06-29 12:18:07 +01:00
LOG_ERROR(Audio_DSP, "pipe_number = {} invalid", pipe_index);
2017-12-20 18:44:32 +00:00
return {};
}
if (length > UINT16_MAX) { // Can only read at most UINT16_MAX from the pipe
2018-06-29 12:18:07 +01:00
LOG_ERROR(Audio_DSP, "length of {} greater than max of {}", length, UINT16_MAX);
2017-12-20 18:44:32 +00:00
return {};
}
std::vector<u8>& data = pipe_data[pipe_index];
if (length > data.size()) {
2018-06-29 12:18:07 +01:00
LOG_WARNING(
2017-12-20 18:44:32 +00:00
Audio_DSP,
"pipe_number = {} is out of data, application requested read of {} but {} remain",
2017-12-20 18:44:32 +00:00
pipe_index, length, data.size());
length = static_cast<u32>(data.size());
}
if (length == 0)
return {};
std::vector<u8> ret(data.begin(), data.begin() + length);
data.erase(data.begin(), data.begin() + length);
return ret;
}
size_t DspHle::Impl::GetPipeReadableSize(DspPipe pipe_number) const {
const size_t pipe_index = static_cast<size_t>(pipe_number);
if (pipe_index >= num_dsp_pipe) {
2018-06-29 12:18:07 +01:00
LOG_ERROR(Audio_DSP, "pipe_number = {} invalid", pipe_index);
2017-12-20 18:44:32 +00:00
return 0;
}
return pipe_data[pipe_index].size();
}
void DspHle::Impl::PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
switch (pipe_number) {
case DspPipe::Audio: {
if (buffer.size() != 4) {
2018-06-29 12:18:07 +01:00
LOG_ERROR(Audio_DSP, "DspPipe::Audio: Unexpected buffer length {} was written",
2018-06-29 14:56:12 +01:00
buffer.size());
2017-12-20 18:44:32 +00:00
return;
}
enum class StateChange {
Initialize = 0,
Shutdown = 1,
Wakeup = 2,
Sleep = 3,
};
// The difference between Initialize and Wakeup is that Input state is maintained
// when sleeping but isn't when turning it off and on again. (TODO: Implement this.)
// Waking up from sleep garbles some of the structs in the memory region. (TODO:
// Implement this.) Applications store away the state of these structs before
// sleeping and reset it back after wakeup on behalf of the DSP.
switch (static_cast<StateChange>(buffer[0])) {
case StateChange::Initialize:
2018-06-29 12:18:07 +01:00
LOG_INFO(Audio_DSP, "Application has requested initialization of DSP hardware");
2017-12-20 18:44:32 +00:00
ResetPipes();
AudioPipeWriteStructAddresses();
dsp_state = DspState::On;
break;
case StateChange::Shutdown:
2018-06-29 12:18:07 +01:00
LOG_INFO(Audio_DSP, "Application has requested shutdown of DSP hardware");
2017-12-20 18:44:32 +00:00
dsp_state = DspState::Off;
break;
case StateChange::Wakeup:
2018-06-29 12:18:07 +01:00
LOG_INFO(Audio_DSP, "Application has requested wakeup of DSP hardware");
2017-12-20 18:44:32 +00:00
ResetPipes();
AudioPipeWriteStructAddresses();
dsp_state = DspState::On;
break;
case StateChange::Sleep:
2018-06-29 12:18:07 +01:00
LOG_INFO(Audio_DSP, "Application has requested sleep of DSP hardware");
2017-12-20 18:44:32 +00:00
UNIMPLEMENTED();
dsp_state = DspState::Sleeping;
break;
default:
2018-06-29 12:18:07 +01:00
LOG_ERROR(Audio_DSP,
2018-06-29 14:56:12 +01:00
"Application has requested unknown state transition of DSP hardware {}",
buffer[0]);
2017-12-20 18:44:32 +00:00
dsp_state = DspState::Off;
break;
}
return;
}
default:
2018-06-29 14:56:12 +01:00
LOG_CRITICAL(Audio_DSP, "pipe_number = {} unimplemented", static_cast<size_t>(pipe_number));
2017-12-20 18:44:32 +00:00
UNIMPLEMENTED();
return;
}
}
std::array<u8, Memory::DSP_RAM_SIZE>& DspHle::Impl::GetDspMemory() {
return dsp_memory.raw_memory;
}
void DspHle::Impl::SetServiceToInterrupt(std::weak_ptr<DSP_DSP> dsp) {
2018-07-24 20:54:33 +01:00
dsp_dsp = std::move(dsp);
}
2017-12-20 18:44:32 +00:00
void DspHle::Impl::ResetPipes() {
for (auto& data : pipe_data) {
data.clear();
}
dsp_state = DspState::Off;
}
void DspHle::Impl::WriteU16(DspPipe pipe_number, u16 value) {
const size_t pipe_index = static_cast<size_t>(pipe_number);
std::vector<u8>& data = pipe_data.at(pipe_index);
// Little endian
data.emplace_back(value & 0xFF);
data.emplace_back(value >> 8);
}
void DspHle::Impl::AudioPipeWriteStructAddresses() {
// These struct addresses are DSP dram addresses.
// See also: DSP_DSP::ConvertProcessAddressFromDspDram
static const std::array<u16, 15> struct_addresses = {
0x8000 + offsetof(HLE::SharedMemory, frame_counter) / 2,
0x8000 + offsetof(HLE::SharedMemory, source_configurations) / 2,
0x8000 + offsetof(HLE::SharedMemory, source_statuses) / 2,
0x8000 + offsetof(HLE::SharedMemory, adpcm_coefficients) / 2,
0x8000 + offsetof(HLE::SharedMemory, dsp_configuration) / 2,
0x8000 + offsetof(HLE::SharedMemory, dsp_status) / 2,
0x8000 + offsetof(HLE::SharedMemory, final_samples) / 2,
0x8000 + offsetof(HLE::SharedMemory, intermediate_mix_samples) / 2,
0x8000 + offsetof(HLE::SharedMemory, compressor) / 2,
0x8000 + offsetof(HLE::SharedMemory, dsp_debug) / 2,
0x8000 + offsetof(HLE::SharedMemory, unknown10) / 2,
0x8000 + offsetof(HLE::SharedMemory, unknown11) / 2,
0x8000 + offsetof(HLE::SharedMemory, unknown12) / 2,
0x8000 + offsetof(HLE::SharedMemory, unknown13) / 2,
0x8000 + offsetof(HLE::SharedMemory, unknown14) / 2,
};
// Begin with a u16 denoting the number of structs.
WriteU16(DspPipe::Audio, static_cast<u16>(struct_addresses.size()));
// Then write the struct addresses.
for (u16 addr : struct_addresses) {
WriteU16(DspPipe::Audio, addr);
}
// Signal that we have data on this pipe.
if (auto service = dsp_dsp.lock()) {
service->SignalInterrupt(InterruptType::Pipe, DspPipe::Audio);
}
2017-12-20 18:44:32 +00:00
}
size_t DspHle::Impl::CurrentRegionIndex() const {
// The region with the higher frame counter is chosen unless there is wraparound.
// This function only returns a 0 or 1.
const u16 frame_counter_0 = dsp_memory.region_0.frame_counter;
const u16 frame_counter_1 = dsp_memory.region_1.frame_counter;
if (frame_counter_0 == 0xFFFFu && frame_counter_1 != 0xFFFEu) {
// Wraparound has occurred.
return 1;
}
if (frame_counter_1 == 0xFFFFu && frame_counter_0 != 0xFFFEu) {
// Wraparound has occurred.
return 0;
}
return (frame_counter_0 > frame_counter_1) ? 0 : 1;
}
HLE::SharedMemory& DspHle::Impl::ReadRegion() {
return CurrentRegionIndex() == 0 ? dsp_memory.region_0 : dsp_memory.region_1;
}
HLE::SharedMemory& DspHle::Impl::WriteRegion() {
return CurrentRegionIndex() != 0 ? dsp_memory.region_0 : dsp_memory.region_1;
}
StereoFrame16 DspHle::Impl::GenerateCurrentFrame() {
HLE::SharedMemory& read = ReadRegion();
HLE::SharedMemory& write = WriteRegion();
std::array<QuadFrame32, 3> intermediate_mixes = {};
// Generate intermediate mixes
for (size_t i = 0; i < HLE::num_sources; i++) {
write.source_statuses.status[i] =
sources[i].Tick(read.source_configurations.config[i], read.adpcm_coefficients.coeff[i]);
for (size_t mix = 0; mix < 3; mix++) {
sources[i].MixInto(intermediate_mixes[mix], mix);
}
}
// Generate final mix
write.dsp_status = mixers.Tick(read.dsp_configuration, read.intermediate_mix_samples,
write.intermediate_mix_samples, intermediate_mixes);
StereoFrame16 output_frame = mixers.GetOutput();
// Write current output frame to the shared memory region
for (size_t samplei = 0; samplei < output_frame.size(); samplei++) {
for (size_t channeli = 0; channeli < output_frame[0].size(); channeli++) {
write.final_samples.pcm16[samplei][channeli] = s16_le(output_frame[samplei][channeli]);
}
}
return output_frame;
}
bool DspHle::Impl::Tick() {
StereoFrame16 current_frame = {};
// TODO: Check dsp::DSP semaphore (which indicates emulated application has finished writing to
// shared memory region)
current_frame = GenerateCurrentFrame();
parent.OutputFrame(current_frame);
return true;
}
2018-07-23 22:08:14 +01:00
void DspHle::Impl::AudioTickCallback(s64 cycles_late) {
2017-12-20 18:44:32 +00:00
if (Tick()) {
// TODO(merry): Signal all the other interrupts as appropriate.
if (auto service = dsp_dsp.lock()) {
service->SignalInterrupt(InterruptType::Pipe, DspPipe::Audio);
2018-07-24 20:54:33 +01:00
// HACK(merry): Added to prevent regressions. Will remove soon.
service->SignalInterrupt(InterruptType::Pipe, DspPipe::Binary);
2018-07-24 20:54:33 +01:00
}
2017-12-20 18:44:32 +00:00
}
// Reschedule recurrent event
CoreTiming::ScheduleEvent(audio_frame_ticks - cycles_late, tick_event);
}
DspHle::DspHle() : impl(std::make_unique<Impl>(*this)) {}
DspHle::~DspHle() = default;
DspState DspHle::GetDspState() const {
return impl->GetDspState();
}
std::vector<u8> DspHle::PipeRead(DspPipe pipe_number, u32 length) {
return impl->PipeRead(pipe_number, length);
}
size_t DspHle::GetPipeReadableSize(DspPipe pipe_number) const {
return impl->GetPipeReadableSize(pipe_number);
}
void DspHle::PipeWrite(DspPipe pipe_number, const std::vector<u8>& buffer) {
impl->PipeWrite(pipe_number, buffer);
}
std::array<u8, Memory::DSP_RAM_SIZE>& DspHle::GetDspMemory() {
return impl->GetDspMemory();
}
void DspHle::SetServiceToInterrupt(std::weak_ptr<DSP_DSP> dsp) {
impl->SetServiceToInterrupt(std::move(dsp));
2018-07-24 20:54:33 +01:00
}
2017-12-20 18:44:32 +00:00
} // namespace AudioCore