jabyengine/include/PSX/System/IOPorts/spu_io.hpp

#pragma once
#include "IOValues/spu_io_values.hpp"
#include <limits.hpp>

namespace JabyEngine {
    namespace SPU_IO {
        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(Adr, uint16_t) {
        };

        __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<Adr>          adr;           //Offset: 0x6
            IOPort<AD>           ad;            //Offset: 0x8
            IOPort<SR>           sr;            //Offset: 0xA
            IOPort<SimpleVolume> currentVolume; //Offset: 0xC
            IOPort<Adr>          repeatAdr;     //Offset: 0xE

            static constexpr Adr start_adr() {
                return {0x200};
            }
        };
        #pragma pack(pop)

        __declare_io_value(PMON, uint16_t) {
            static constexpr auto EnableBits = BitRange::from_to(1, 23);
        };

        __declare_io_value(NON, uint16_t) {
            static constexpr auto NoiseBits = BitRange::from_to(0, 23);
        };

        __declare_io_value(EON, uint16_t) {
            static constexpr auto EchoBits = BitRange::from_to(0, 23);
        };

        static constexpr size_t VoiceCount  = 24;
        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, Adr, WorkAreaAdr, 0x1F801DA2);
        };

        static constexpr SimpleVolume operator""_vol(long double fraction) {
            return {static_cast<int16_t>(static_cast<long double>(I16_MAX)*fraction)};
        }

        struct SRAMTransferAddressIO : public IOPortX<SRAM_Adr, SRAM_Adr> {};

        struct ControlRegisterIO : public IOPortX<SPU_IO_Values::ControlRegister> {
            using TransferMode = Value::RAMTransferMode;

            void set_transfer_mode(TransferMode mode) {
                this->write(this->read().set(ControlRegister::TransferMode.with(mode)));
                while(this->read().get(ControlRegister::TransferMode) != mode);
            }
        };

        // TODO: The new way?                                                    v Parse with a Macro?
        static auto& ControlRegister =     *reinterpret_cast<ControlRegisterIO*>(0x1F801DAA);
        static auto& SRAMTransferAdr = *reinterpret_cast<SRAMTransferAddressIO*>(0x1F801DA6);

        //__declare_io_port(, ControlRegister,     0x1F801DAA);
        __declare_io_port(, DataTransferControl, 0x1F801DAC);
        __declare_io_port(, PMON,                0x1F801D90);
        __declare_io_port(, NON,                 0x1F801D94);
        __declare_io_port(, EON,                 0x1F801D98);
        
        __declare_io_port_array(, Voice, VoiceCount, 0x1F801C00);
    }
}