jaby
/
jabyengine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Update SPU IO way

This commit is contained in:
Jaby 2024-09-22 16:10:18 +02:00
parent 1b241184fc
commit 8b6921cba5
8 changed files with 258 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
include/PSX/SPU/spu.hpp
View File

@ -3,27 +3,28 @@
namespace JabyEngine { namespace JabyEngine {
namespace SPU { namespace SPU {
using SRAM_Adr = SPU_IO::SRAM_Adr; using SRAMAdr = SPU_IO::SRAMAdr;
// TODO: Rename to sample...?
struct Voice { struct Voice {
size_t get_id() const { size_t get_id() const {
return reinterpret_cast<size_t>(this); return reinterpret_cast<size_t>(this);
} }
SRAM_Adr allocate(size_t size) const; SRAMAdr allocate(size_t size) const;
SRAM_Adr allocate(SPU_IO::SampleRate frequency, size_t size) const; SRAMAdr allocate(SPU_IO::SampleRate frequency, size_t size) const;
void deallocate() const; void deallocate() const;
void set_sample_rate(SPU_IO::SampleRate frequency) const { void set_sample_rate(SPU_IO::SampleRate frequency) const {
SPU_IO::Voice[Voice::get_id()].sampleRate.write(frequency); SPU_IO::Voice[Voice::get_id()].sampleRate.write(frequency);
} }
void play() const { void play() const {
SPU_IO::Key::On.write(1 << Voice::get_id()); SPU_IO::Key::On.write(SPU_IO::KeyOn::for_specific(Voice::get_id()));
} }
void stop() const { void stop() const {
SPU_IO::Key::Off.write(1 << Voice::get_id()); SPU_IO::Key::Off.write(SPU_IO::KeyOff::for_specific(Voice::get_id()));
} }
}; };

167
include/PSX/System/IOPorts/IOValues/spu_io_values.hpp
View File

@ -1,5 +1,6 @@
#pragma once #pragma once
#include "../ioport.hpp" #include "../ioport.hpp"
#include <limits.hpp>
namespace JabyEngine { namespace JabyEngine {
namespace SPU_IO_Values { namespace SPU_IO_Values {
@ -20,6 +21,22 @@ namespace JabyEngine {
struct IOPort<type> : public SPU_IO_Values::internal::AliasUbus32IOPort<type> {} struct IOPort<type> : public SPU_IO_Values::internal::AliasUbus32IOPort<type> {}
} }
namespace MemoryMap {
static constexpr uintptr_t ADPCM = 0x01000;
}
__declare_io_value(AD, uint16_t) {
static constexpr auto AttackMode = Bit(15);
static constexpr auto AttackShift = BitRange::from_to(10, 14);
static constexpr auto AttackStep = BitRange::from_to(8, 9);
static constexpr auto DecayShift = BitRange::from_to(4, 7);
static constexpr auto SustainLevel = BitRange::from_to(0, 3);
static constexpr AD none() {
return AD{0};
}
};
__declare_io_value(ControlRegister, uint16_t) { __declare_io_value(ControlRegister, uint16_t) {
enum RAMTransferMode { enum RAMTransferMode {
Stop = 0, Stop = 0,
@ -41,6 +58,12 @@ namespace JabyEngine {
static constexpr auto CDAudioEnable = Bit(0); static constexpr auto CDAudioEnable = Bit(0);
}; };
__declare_io_value(DataTransferControl, uint16_t) {
static constexpr DataTransferControl NormalTransferMode() {
return DataTransferControl{0x0004};
}
};
__declare_io_value(Echo, ubus32_t) { __declare_io_value(Echo, ubus32_t) {
static constexpr auto EchoBits = BitRange::from_to(0, 23); static constexpr auto EchoBits = BitRange::from_to(0, 23);
@ -49,12 +72,109 @@ namespace JabyEngine {
} }
}; };
__declare_io_value(SRAM_Adr, uint16_t) { __declare_io_value(KeyOff, ubus32_t) {
static constexpr KeyOff for_specific(uint32_t id) {
return KeyOff{ubus32_t::from(1 << id)};
}
static constexpr KeyOff all() {
return KeyOff{ubus32_t::from(UI32_MAX)};
}
};
__declare_io_value(KeyOn, ubus32_t) {
static constexpr KeyOn for_specific(uint32_t id) {
return KeyOn{ubus32_t::from(1 << id)};
}
static constexpr KeyOn all() {
return KeyOn{ubus32_t::from(UI32_MAX)};
}
};
__declare_io_value(KeyStatus, ubus32_t) {
};
__declare_io_value(Noise, uint16_t) {
static constexpr auto NoiseBits = BitRange::from_to(0, 23);
static constexpr Noise AllOff() {
return Noise{0};
}
};
__declare_io_value(PitchModulation, ubus32_t) {
static constexpr auto EnableBits = BitRange::from_to(1, 23);
static constexpr PitchModulation AllOff() {
return PitchModulation{0};
}
};
__declare_io_value(SampleRate, uint16_t) {
static constexpr SampleRate stop() {
return SampleRate{0};
}
static constexpr SampleRate from_HZ(uint32_t freq) {
constexpr uint32_t Base1024Hz = static_cast<uint32_t>((4096.0/44100.0)*1024.0);
return SampleRate{static_cast<uint16_t>((freq >> 10)*Base1024Hz)};
}
static constexpr SampleRate from_HZ(double freq) {
//4096 == 44100Hz
constexpr double Base = (4096.0 / 44100.0);
return SampleRate{static_cast<uint16_t>((freq*Base))};
}
};
__declare_io_value(SimpleVolume, int16_t) {
static constexpr auto MaxVolume = I16_MAX;
static constexpr SimpleVolume mute() {
return SimpleVolume{0};
}
constexpr operator int16_t() const {
return this->raw;
}
};
static constexpr SimpleVolume operator""_vol(long double fraction) {
return {static_cast<int16_t>(static_cast<long double>(SimpleVolume::MaxVolume)*fraction)};
}
__declare_io_value(SR, uint16_t) {
static constexpr auto SustainMode = Bit(31 - 16);
static constexpr auto SustainDirection = Bit(30 - 16);
static constexpr auto SustainShift = BitRange::from_to((24 - 16), (28 - 16));
static constexpr auto SustainStep = BitRange::from_to((22 - 16), (23 - 16));
static constexpr auto ReleaseMode = Bit(21 - 16);
static constexpr auto ReleaseShift = BitRange::from_to((16 - 16), (20 - 16));
static constexpr SR none() {
return SR{0};
}
};
__declare_io_value(SRAMAdr, uint16_t) {
static constexpr SRAMAdr null() {
return SRAMAdr{0x0};
}
static constexpr SRAMAdr adpcm_start() {
return SRAMAdr{MemoryMap::ADPCM};
}
}; };
__declare_io_value(StatusRegister, uint16_t) { __declare_io_value(StatusRegister, uint16_t) {
enum CapureBufferHalf {
First = 0,
Second = 1
};
static constexpr auto Unused = BitRange::from_to(12, 15); static constexpr auto Unused = BitRange::from_to(12, 15);
static constexpr auto CaputreBufferHalf = Bit(11); // TODO: Turn into enum?; Writing to First/Second half of Capture Buffers (0=First, 1=Second) static constexpr auto CaputreBufferHalf = Bit(11);
static constexpr auto TransferBusy = Bit(10); static constexpr auto TransferBusy = Bit(10);
static constexpr auto IsDMARead = Bit(9); static constexpr auto IsDMARead = Bit(9);
static constexpr auto isDMAWrite = Bit(8); static constexpr auto isDMAWrite = Bit(8);
@ -66,7 +186,48 @@ namespace JabyEngine {
static constexpr auto CDAudioReverb = Bit(2); static constexpr auto CDAudioReverb = Bit(2);
static constexpr auto ExternalAudioEnable = Bit(1); static constexpr auto ExternalAudioEnable = Bit(1);
static constexpr auto CDAudioEnable = Bit(0); static constexpr auto CDAudioEnable = Bit(0);
}; };
__declare_io_value(SweepVolume, int16_t) {
struct VolumeMode {
static constexpr auto MaxVolume = (I16_MAX >> 1);
static constexpr auto EnableSweep = Bit(15);
static constexpr auto Enable = !EnableSweep;
static constexpr auto Volume = BitRange::from_to(0, 14);
};
struct SweepMode {
enum Mode {
Linear = 0,
Exponential = 1,
};
enum Direction {
Increase = 0,
Decrease = 1,
};
enum Phase {
Posititve = 0,
Negative = 1,
};
static constexpr auto Mode = Bit(14);
static constexpr auto Direction = Bit(13);
static constexpr auto Phase = Bit(12);
static constexpr auto Shift = BitRange::from_to(2, 6);
static constexpr auto Step = BitRange::from_to(0, 1);
};
static constexpr SweepVolume mute() {
return SweepVolume{0};
}
};
} }
alias_ioport_ubus32(SPU_IO_Values::Echo); alias_ioport_ubus32(SPU_IO_Values::Echo);
alias_ioport_ubus32(SPU_IO_Values::Noise);
alias_ioport_ubus32(SPU_IO_Values::KeyOff);
alias_ioport_ubus32(SPU_IO_Values::KeyOn);
alias_ioport_ubus32(SPU_IO_Values::KeyStatus);
alias_ioport_ubus32(SPU_IO_Values::PitchModulation);
} }

5
include/PSX/System/IOPorts/ioport.hpp
View File

@ -69,7 +69,7 @@ namespace JabyEngine {
uint16_t low; uint16_t low;
uint16_t high; uint16_t high;
static ubus32_t from(uint32_t value) { static constexpr ubus32_t from(uint32_t value) {
return {.low = static_cast<uint16_t>(value & 0xFFFF), .high = static_cast<uint16_t>(value >> 16)}; return {.low = static_cast<uint16_t>(value & 0xFFFF), .high = static_cast<uint16_t>(value >> 16)};
} }
}; };
@ -117,4 +117,7 @@ namespace JabyEngine {
#define __declare_io_port_w_type(cv, type, name, adr) __declare_value_at(cv, ::JabyEngine::IOPort<type>, name, adr) #define __declare_io_port_w_type(cv, type, name, adr) __declare_value_at(cv, ::JabyEngine::IOPort<type>, name, adr)
#define __declare_io_port(cv, name, adr) __declare_io_port_w_type(cv, struct name, name, adr) #define __declare_io_port(cv, name, adr) __declare_io_port_w_type(cv, struct name, name, adr)
#define __declare_io_port_array(cv, name, size, adr) __declare_array_at(cv, struct name, name, size, adr) #define __declare_io_port_array(cv, name, size, adr) __declare_array_at(cv, struct name, name, size, adr)
#define __new_declare_io_port(type, adr) *reinterpret_cast<type*>(adr)
#define __new_declare_io_port_array(type, size, adr) reinterpret_cast<type(&)[size]>(*reinterpret_cast<type*>(adr))
} }

219
include/PSX/System/IOPorts/spu_io.hpp
View File

@ -6,151 +6,9 @@ namespace JabyEngine {
namespace SPU_IO { namespace SPU_IO {
using namespace SPU_IO_Values; using namespace SPU_IO_Values;
namespace MemoryMap {
static constexpr uintptr_t ADPCM = 0x01000;
}
enum struct Mode {
Linear = 0,
Exponential = 1,
};
enum struct Direction {
Increase = 0,
Decrease = 1,
};
enum struct Phase {
Posititve = 0,
Negative = 1,
};
//0..0x1F = Fast..Slow
typedef uint8_t Shift;
//0..3 = +7, +6, +5, +4 or -6, -7, -6, -5
typedef uint8_t Step;
__declare_io_value(DataTransferControl, uint16_t) {
static constexpr DataTransferControl NormalTransferMode() {
return DataTransferControl{0x0004};
}
};
__declare_io_value(SimpleVolume, int16_t) {
constexpr operator int16_t() const {
return this->raw;
}
};
__declare_io_value(SampleRate, uint16_t) {
static constexpr SampleRate from_HZ(uint32_t freq) {
constexpr uint32_t Base1024Hz = static_cast<uint32_t>((4096.0/44100.0)*1024.0);
return {static_cast<uint16_t>((freq >> 10)*Base1024Hz)};
}
static constexpr SampleRate from_HZ(double freq) {
//4096 == 44100Hz
constexpr double Base = (4096.0 / 44100.0);
return {static_cast<uint16_t>((freq*Base))};
}
};
__declare_io_value(SweepVolume, int16_t) {
// For Volume Mode
static constexpr auto SweepEnable = Bit(15);
static constexpr auto VolumeEnable = !SweepEnable;
static constexpr auto Volume = BitRange::from_to(0, 14);
// For Sweep Mode
static constexpr auto SweepMode = Bit(14);
static constexpr auto SweepDirection = Bit(13);
static constexpr auto SweepPhase = Bit(12);
static constexpr auto SweepShift = BitRange::from_to(2, 6);
static constexpr auto SweepStep = BitRange::from_to(0, 1);
};
__declare_io_value(SR, uint16_t) {
static constexpr auto SustainMode = Bit(31 - 16);
static constexpr auto SustainDirection = Bit(30 - 16);
static constexpr auto SustainShift = BitRange::from_to((24 - 16), (28 - 16));
static constexpr auto SustainStep = BitRange::from_to((22 - 16), (23 - 16));
static constexpr auto ReleaseMode = Bit(21 - 16);
static constexpr auto ReleaseShift = BitRange::from_to((16 - 16), (20 - 16));
};
__declare_io_value(AD, uint16_t) {
static constexpr auto AttackMode = Bit(15);
static constexpr auto AttackShift = BitRange::from_to(10, 14);
static constexpr auto AttackStep = BitRange::from_to(8, 9);
static constexpr auto DecayShift = BitRange::from_to(4, 7);
static constexpr auto SustainLevel = BitRange::from_to(0, 3);
};
#pragma pack(push, 1)
struct Voice {
IOPort<SweepVolume> volumeLeft; //Offset: 0x0
IOPort<SweepVolume> volumeRight; //Offset: 0x2
IOPort<SampleRate> sampleRate; //Offset: 0x4;
IOPort<SRAM_Adr> adr; //Offset: 0x6
IOPort<AD> ad; //Offset: 0x8
IOPort<SR> sr; //Offset: 0xA
IOPort<SimpleVolume> currentVolume; //Offset: 0xC
IOPort<SRAM_Adr> repeatAdr; //Offset: 0xE
static constexpr SRAM_Adr start_adr() {
return {0x200};
}
};
#pragma pack(pop)
// TODO: This is ubus32_t
__declare_io_value(PMON, uint16_t) {
static constexpr auto EnableBits = BitRange::from_to(1, 23);
};
// TODO: This is ubus32_t
__declare_io_value(NON, uint16_t) {
static constexpr auto NoiseBits = BitRange::from_to(0, 23);
};
static constexpr size_t VoiceCount = 24; static constexpr size_t VoiceCount = 24;
static constexpr size_t ReverbCount = 1; static constexpr size_t ReverbCount = 1;
struct Key {
__declare_io_port_w_type(inline, ubus32_t, On, 0x1F801D88);
__declare_io_port_w_type(inline, ubus32_t, Off, 0x1F801D8C);
__declare_io_port_w_type(inline, ubus32_t, Status, 0x1F801D9C);
};
struct MainVolume {
__declare_io_port_w_type(inline, SweepVolume, Left, 0x1F801D80);
__declare_io_port_w_type(inline, SweepVolume, Right, 0x1F801D82);
};
struct CDVolume {
__declare_io_port_w_type(inline, SimpleVolume, Left, 0x1F801DB0);
__declare_io_port_w_type(inline, SimpleVolume, Right, 0x1F801DB2);
};
struct ExternalAudioInputVolume {
__declare_io_port_w_type(inline, SimpleVolume, Left, 0x1F801DB4);
__declare_io_port_w_type(inline, SimpleVolume, Right, 0x1F801DB6);
};
struct Reverb {
struct Volume {
__declare_io_port_w_type(inline, SimpleVolume, Left, 0x1F801D84);
__declare_io_port_w_type(inline, SimpleVolume, Right, 0x1F801D86);
};
__declare_io_port_w_type(inline, SRAM_Adr, WorkAreaAdr, 0x1F801DA2);
};
static constexpr SimpleVolume operator""_vol(long double fraction) {
return {static_cast<int16_t>(static_cast<long double>(I16_MAX)*fraction)};
}
//---------------------------------------------------------------------------------------------------
struct ControlRegisterIO : public IOPort<SPU_IO_Values::ControlRegister> { struct ControlRegisterIO : public IOPort<SPU_IO_Values::ControlRegister> {
using TransferMode = Value::RAMTransferMode; using TransferMode = Value::RAMTransferMode;
@ -160,30 +18,71 @@ namespace JabyEngine {
} }
}; };
struct EchoIO : public IOPort<SPU_IO_Values::Echo> { using ADIO = IOPort<SPU_IO_Values::AD>;
using DataTransferControlIO = IOPort<SPU_IO_Values::DataTransferControl>;
using EchoIO = IOPort<SPU_IO_Values::Echo>;
using KeyOffIO = IOPort<SPU_IO_Values::KeyOff>;
using KeyOnIO = IOPort<SPU_IO_Values::KeyOn>;
using KeyStatusIO = IOPort<SPU_IO_Values::KeyStatus>;
using NoiseIO = IOPort<SPU_IO_Values::Noise>;
using PitchModulationIO = IOPort<SPU_IO_Values::PitchModulation>;
using SampleRateIO = IOPort<SPU_IO_Values::SampleRate>;
using SimpleVolumeIO = IOPort<SPU_IO_Values::SimpleVolume>;
using StatusRegisterIO = IOPort<SPU_IO_Values::StatusRegister>;
using SRIO = IOPort<SPU_IO_Values::SR>;
using SRAMAdrIO = IOPort<SPU_IO_Values::SRAMAdr>;
using SweepVolumeIO = IOPort<SweepVolume>;
#pragma pack(push, 1)
struct Voice {
SweepVolumeIO volumeLeft; //Offset: 0x0
SweepVolumeIO volumeRight; //Offset: 0x2
SampleRateIO sampleRate; //Offset: 0x4;
SRAMAdrIO adr; //Offset: 0x6
ADIO ad; //Offset: 0x8
SRIO sr; //Offset: 0xA
SimpleVolumeIO currentVolume; //Offset: 0xC
SRAMAdrIO repeatAdr; //Offset: 0xE
};
#pragma pack(pop)
static auto& Voice = __new_declare_io_port_array(struct Voice, VoiceCount, 0x1F801C00);
static auto& PMON = __new_declare_io_port(PitchModulationIO, 0x1F801D90);
static auto& NON = __new_declare_io_port(NoiseIO, 0x1F801D94);
static auto& EON = __new_declare_io_port(EchoIO, 0x1F801D98);
static auto& SRAMTransferAdr = __new_declare_io_port(SRAMAdrIO, 0x1F801DA6);
static auto& ControlRegister = __new_declare_io_port(ControlRegisterIO, 0x1F801DAA);
static auto& DataTransferControl = __new_declare_io_port(DataTransferControlIO, 0x1F801DAC);
static auto& StatusRegister = __new_declare_io_port(StatusRegisterIO, 0x1F801DAE);
struct CDVolume {
static inline auto& Left = __new_declare_io_port(SimpleVolumeIO, 0x1F801DB0);
static inline auto& Right = __new_declare_io_port(SimpleVolumeIO, 0x1F801DB2);
}; };
struct StatusRegisterIO : public IOPort<SPU_IO_Values::StatusRegister> { struct ExternalAudioInputVolume {
static inline auto& Left = __new_declare_io_port(SimpleVolumeIO, 0x1F801DB4);
static inline auto& Right = __new_declare_io_port(SimpleVolumeIO, 0x1F801DB6);
}; };
struct SRAMTransferAddressIO : public IOPort<SPU_IO_Values::SRAM_Adr> { struct Key {
static inline auto& On = __new_declare_io_port(KeyOnIO, 0x1F801D88);
static inline auto& Off = __new_declare_io_port(KeyOffIO, 0x1F801D8C);
static inline auto& Status = __new_declare_io_port(KeyStatusIO, 0x1F801D9C);
}; };
// TODO: The new way? v Parse with a Macro? struct MainVolume {
static auto& EON = *reinterpret_cast<EchoIO*>(0x1F801D98); static inline auto& Left = __new_declare_io_port(SweepVolumeIO, 0x1F801D80);
static auto& SRAMTransferAdr = *reinterpret_cast<SRAMTransferAddressIO*>(0x1F801DA6); static inline auto& Right = __new_declare_io_port(SweepVolumeIO, 0x1F801D82);
static auto& ControlRegister = *reinterpret_cast<ControlRegisterIO*>(0x1F801DAA); };
static auto& StatusRegister = *reinterpret_cast<StatusRegisterIO*>(0x1F801DAE);
//---------------------------------------------------------------------------------------------------
//__declare_io_port(, ControlRegister, 0x1F801DAA); struct Reverb {
__declare_io_port(, DataTransferControl, 0x1F801DAC); struct Volume {
__declare_io_port(, PMON, 0x1F801D90); static inline auto& Left = __new_declare_io_port(SimpleVolumeIO, 0x1F801D84);
__declare_io_port(, NON, 0x1F801D94); static inline auto& Right = __new_declare_io_port(SimpleVolumeIO, 0x1F801D86);
//__declare_io_port(, EON, 0x1F801D98); };
static inline auto& On = EON;
__declare_io_port_array(, Voice, VoiceCount, 0x1F801C00); static inline auto& WorkAreaAdr = __new_declare_io_port(SRAMAdrIO, 0x1F801DA2);
};
} }
} }

2
src/Library/internal-include/SPU/spu_internal.hpp
View File

@ -26,7 +26,7 @@ namespace JabyEngine {
DMA_IO::SPU.set_adr(adr); DMA_IO::SPU.set_adr(adr);
} }
static void set_dst(SPU::SRAM_Adr adr) { static void set_dst(SPU::SRAMAdr adr) {
SPU_IO::SRAMTransferAdr.write(adr); SPU_IO::SRAMTransferAdr.write(adr);
SPU_IO::ControlRegister.set_transfer_mode(SPU_IO::ControlRegister::DMAWrite); SPU_IO::ControlRegister.set_transfer_mode(SPU_IO::ControlRegister::DMAWrite);
} }

41
src/Library/src/BootLoader/spu_boot.cpp
View File

@ -8,7 +8,7 @@ namespace JabyEngine {
using namespace SPU_IO; using namespace SPU_IO;
static void clear_main_volume() { static void clear_main_volume() {
static constexpr auto StartVol = SweepVolume::from(SweepVolume::VolumeEnable, SweepVolume::Volume.with(static_cast<int16_t>(I16_MAX >> 2))); static constexpr auto StartVol = SweepVolume::from(SweepVolume::VolumeMode::Enable, SweepVolume::VolumeMode::Volume.with(SweepVolume::VolumeMode::MaxVolume >> 1));
MainVolume::Left.write(StartVol); MainVolume::Left.write(StartVol);
MainVolume::Right.write(StartVol); MainVolume::Right.write(StartVol);
@ -18,37 +18,37 @@ namespace JabyEngine {
CDVolume::Left.write(0.75_vol); CDVolume::Left.write(0.75_vol);
CDVolume::Right.write(0.75_vol); CDVolume::Right.write(0.75_vol);
ExternalAudioInputVolume::Left.write({0}); ExternalAudioInputVolume::Left.write(SimpleVolume::mute());
ExternalAudioInputVolume::Right.write({0}); ExternalAudioInputVolume::Right.write(SimpleVolume::mute());
} }
static void clear_voice() { static void clear_voice() {
for(auto& voice : SPU_IO::Voice) { for(auto& voice : SPU_IO::Voice) {
voice.volumeLeft.write({0}); voice.volumeLeft.write(SweepVolume::mute());
voice.volumeRight.write({0}); voice.volumeRight.write(SweepVolume::mute());
voice.sampleRate.write({0}); voice.sampleRate.write(SampleRate::stop());
voice.ad.write({0}); voice.ad.write(AD::none());
voice.sr.write({0}); voice.sr.write(SR::none());
voice.currentVolume.write({0}); voice.currentVolume.write(SimpleVolume::mute());
voice.adr.write(Voice::start_adr()); voice.adr.write(SRAMAdr::adpcm_start());
voice.repeatAdr.write(Voice::start_adr()); voice.repeatAdr.write(SRAMAdr::adpcm_start());
} }
} }
static void clear_pmon() { static void clear_pmon() {
SPU_IO::PMON.write({0}); SPU_IO::PMON.write(PitchModulation::AllOff());
} }
static void clear_noise_and_echo() { static void clear_noise_and_echo() {
SPU_IO::NON.write({0}); SPU_IO::NON.write(Noise::AllOff());
SPU_IO::EON.write(Echo::AllOff()); SPU_IO::EON.write(Echo::AllOff());
} }
static void clear_reverb() { static void clear_reverb() {
Reverb::Volume::Left.write({0}); Reverb::Volume::Left.write(SimpleVolume::mute());
Reverb::Volume::Right.write({0}); Reverb::Volume::Right.write(SimpleVolume::mute());
Reverb::WorkAreaAdr.write({0}); Reverb::WorkAreaAdr.write(SRAMAdr::null());
} }
static void setup_control_register() { static void setup_control_register() {
@ -57,12 +57,6 @@ namespace JabyEngine {
SPU_IO::ControlRegister.write(SetupValue); SPU_IO::ControlRegister.write(SetupValue);
} }
static void setup_data_transfer_control() {
static constexpr struct DataTransferControl RequiredValue{(2 << 1)};
DataTransferControl.write(RequiredValue);
}
static void wait_voices() { static void wait_voices() {
static constexpr SimpleVolume Treshhold{static_cast<int16_t>(I16_MAX*0.03)}; static constexpr SimpleVolume Treshhold{static_cast<int16_t>(I16_MAX*0.03)};
@ -75,7 +69,7 @@ namespace JabyEngine {
} }
void stop_voices() { void stop_voices() {
SPU_IO::Key::Off.write({UI32_MAX}); SPU_IO::Key::Off.write(KeyOff::all());
} }
void setup() { void setup() {
@ -88,7 +82,6 @@ namespace JabyEngine {
clear_noise_and_echo(); clear_noise_and_echo();
clear_reverb(); clear_reverb();
setup_data_transfer_control();
setup_control_register(); setup_control_register();
} }
} }

6
src/Library/src/File/Processor/vag_processor.cpp
View File

@ -31,9 +31,9 @@ namespace JabyEngine {
}; };
struct VAGState { struct VAGState {
uint32_t voice_id; uint32_t voice_id;
size_t words_left; size_t words_left;
SPU::SRAM_Adr adr; SPU::SRAMAdr adr;
static constexpr VAGState create(uint32_t voice_id) { static constexpr VAGState create(uint32_t voice_id) {
return VAGState{.voice_id = voice_id, .words_left = 0, .adr = 0}; return VAGState{.voice_id = voice_id, .words_left = 0, .adr = 0};

6
src/Library/src/SPU/spu.cpp
View File

@ -8,16 +8,16 @@
namespace JabyEngine { namespace JabyEngine {
namespace SPU { namespace SPU {
SRAM_Adr Voice :: allocate(size_t size) const { SRAMAdr Voice :: allocate(size_t size) const {
Voice::stop(); Voice::stop();
const auto voice_id = Voice::get_id(); const auto voice_id = Voice::get_id();
const auto adr = SRAM_Adr{static_cast<SRAM_Adr::UnderlyingType>(reinterpret_cast<uintptr_t>(SPU_MMU::allocate(voice_id, size)))}; const auto adr = SRAMAdr{static_cast<SRAMAdr::UnderlyingType>(reinterpret_cast<uintptr_t>(SPU_MMU::allocate(voice_id, size)))};
SPU_IO::Voice[voice_id].adr.write(adr); SPU_IO::Voice[voice_id].adr.write(adr);
return adr; return adr;
} }
SRAM_Adr Voice :: allocate(SPU_IO::SampleRate frequency, size_t size) const { SRAMAdr Voice :: allocate(SPU_IO::SampleRate frequency, size_t size) const {
const auto result = Voice::allocate(size); const auto result = Voice::allocate(size);
Voice::set_sample_rate(frequency); Voice::set_sample_rate(frequency);
return result; return result;