PS2 games in the browser: static recompilation to WebAssembly with a native runtime
C++
#include "spu2.hpp"
#include "hw.hpp"
#include "iop.hpp"
#include "kernel.hpp"
#include "ps2/state.hpp"
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <deque>
#include <vector>
namespace ps2::iop::spu2 {
namespace {
constexpr std::uint32_t kRamWords = 1u << 20;
constexpr std::uint32_t kRamMask = kRamWords - 1;
constexpr std::uint64_t kCyclesPerSample = 768;
constexpr unsigned kBatch = 32;
constexpr unsigned kInputFrames = 512;
constexpr std::uint32_t kInputBase[2] = {0x2000u, 0x2400u};
constexpr unsigned kSpuLine = 9;
constexpr std::uint32_t kRingWords = 0x200;
static_assert(kRingWords % kBatch == 0, "a batch must not straddle the ring end");
enum Phase { kOff, kAttack, kDecay, kSustain, kRelease };
struct Envelope {
int counter = 0;
std::int32_t level = 0;
void step(int rate, bool decrease, bool exponential) {
const int shift = rate >> 2;
int cycles = 1 << std::max(0, shift - 11);
if (exponential && !decrease && level > 0x6000) cycles *= 4;
if (++counter < cycles) return;
counter = 0;
int delta = (decrease ? -8 + (rate & 3) : 7 - (rate & 3)) << std::max(0, 11 - shift);
if (exponential && decrease) delta = delta * level / 0x8000;
level = std::clamp(level + delta, 0, 0x7FFF);
}
};
struct Voice {
std::uint16_t voll = 0, volr = 0, pitch = 0, adsr1 = 0, adsr2 = 0;
Envelope vol[2];
std::uint32_t ssa = 0, lsax = 0, next = 0, block[2] = {};
bool lsax_written = false, key_on = false, end = false;
Phase phase = kOff;
Envelope env;
std::int16_t buffer[56] = {};
std::int32_t s1 = 0, s2 = 0;
std::uint32_t position = 0;
};
struct Transfer {
std::uint32_t madr = 0, bytes = 0;
int channel = -1;
};
struct Core {
Voice voices[24];
std::uint16_t attr = 0, admas = 0;
std::uint32_t irqa = 0x800u, tsa = 0;
std::uint16_t mvol[2] = {0x3FFF, 0x3FFF}, bvol[2] = {0x7FFF, 0x7FFF}, avol[2] = {0x7FFF, 0x7FFF}, evol[2] = {};
bool irq = false;
std::int16_t input[kInputFrames][2] = {};
unsigned input_read = 0, input_count = 0;
std::deque<Transfer> transfers;
std::uint16_t regs[0x200] = {};
};
std::vector<std::uint16_t> g_ram(kRamWords);
Core g_cores[2];
std::uint32_t g_statx_settling[2] = {};
bool g_block_end[2][24][2];
bool *block_end(const Voice &v) {
const int c = &v >= g_cores[1].voices ? 1 : 0;
return g_block_end[c][&v - g_cores[c].voices];
}
std::uint16_t g_spdif_out = 0, g_spdif_mode = 0, g_spdif_media = 0;
std::vector<std::int16_t> g_audio;
bool g_record = false;
std::function<void(const std::int16_t *, std::size_t)> g_sink;
std::uint64_t g_next_tick = 0;
bool g_tick_pending = false;
void check_irq(std::uint32_t address, std::uint32_t words) {
for (Core &k : g_cores) {
if (!(k.attr & 0x40u) || k.irq) continue;
if (((k.irqa - address) & kRamMask) >= words) continue;
k.irq = true;
static const bool trace = std::getenv("PS2_TRACE_SPU2") != nullptr;
if (trace) std::fprintf(stderr, "[spu2] core %d irq at 0x%05X (access 0x%05X+%u) time %llu\n", static_cast<int>(&k - g_cores), k.irqa, address, words,
static_cast<unsigned long long>(kernel::now()));
hw::raise_interrupt(kSpuLine);
}
}
void decode_block(Voice &v, std::int16_t *out) {
static const int kFilter[5][2] = {{0, 0}, {60, 0}, {115, -52}, {98, -55}, {122, -60}};
const std::uint32_t at = v.next & kRamMask;
const std::uint16_t header = g_ram[at];
const int shift = header & 0xF, filter = std::min((header >> 4) & 0xF, 4);
const unsigned flags = header >> 8;
for (int i = 0; i < 28; ++i) {
const std::uint16_t word = g_ram[(at + 1 + i / 4) & kRamMask];
std::int32_t sample = static_cast<std::int16_t>(((word >> ((i & 3) * 4)) & 0xF) << 12) >> shift;
sample += (v.s1 * kFilter[filter][0] + v.s2 * kFilter[filter][1] + 32) >> 6;
sample = std::clamp(sample, -32768, 32767);
v.s2 = v.s1;
v.s1 = sample;
out[i] = static_cast<std::int16_t>(sample);
}
v.block[out == v.buffer ? 0 : 1] = at;
block_end(v)[out == v.buffer ? 0 : 1] = (flags & 1u) != 0;
if ((flags & 4u) && !v.lsax_written) v.lsax = at;
v.next = (at + 8) & kRamMask;
if (flags & 1u) {
v.next = v.lsax;
if (!(flags & 2u)) {
v.phase = kRelease;
v.env.level = 0;
}
}
}
void key_on(Voice &v) {
v.key_on = false;
v.lsax_written = false;
v.end = false;
v.next = v.ssa;
v.s1 = v.s2 = 0;
v.position = 0;
v.phase = kAttack;
v.env = Envelope{};
decode_block(v, v.buffer);
decode_block(v, v.buffer + 28);
check_irq(v.block[0], 8);
}
void update_envelope(Voice &v) {
Envelope &e = v.env;
switch (v.phase) {
case kAttack:
e.step((v.adsr1 >> 8) & 0x7F, false, v.adsr1 & 0x8000u);
if (e.level >= 0x7FFF) v.phase = kDecay;
break;
case kDecay:
e.step(((v.adsr1 >> 4) & 0xF) << 2, true, true);
if (e.level <= ((v.adsr1 & 0xF) + 1) * 0x800) v.phase = kSustain;
break;
case kSustain:
e.step((v.adsr2 >> 6) & 0x7F, v.adsr2 & 0x4000u, v.adsr2 & 0x8000u);
break;
case kRelease:
e.step((v.adsr2 & 0x1F) << 2, true, v.adsr2 & 0x20u);
if (e.level <= 0) v.phase = kOff;
break;
default:
break;
}
}
std::int32_t volume(std::uint16_t reg, Envelope &e) {
if (!(reg & 0x8000u)) return static_cast<std::int16_t>(reg << 1);
e.step(reg & 0x7F, reg & 0x2000u, reg & 0x4000u);
return e.level;
}
std::int16_t clamp16(std::int32_t v) { return static_cast<std::int16_t>(std::clamp(v, -32768, 32767)); }
void render_voice(Voice &v, std::int32_t (*sum)[2], std::int16_t *raw) {
if (v.key_on) key_on(v);
const std::uint32_t step = std::min<std::uint32_t>(v.pitch, 0x3FFFu);
const bool sweep_l = v.voll & 0x8000u, sweep_r = v.volr & 0x8000u;
const std::int32_t fixed_l = static_cast<std::int16_t>(v.voll << 1), fixed_r = static_cast<std::int16_t>(v.volr << 1);
std::uint32_t position = v.position;
for (unsigned n = 0; n < kBatch; ++n) {
if (v.phase == kOff) break;
const std::uint32_t index = position >> 12, frac = position & 0xFFFu;
const std::int32_t sample = (v.buffer[index] * static_cast<std::int32_t>(0x1000 - frac) + v.buffer[index + 1] * static_cast<std::int32_t>(frac)) >> 12;
position += step;
while ((position >> 12) >= 28) {
position -= 28u << 12;
std::memmove(v.buffer, v.buffer + 28, 28 * sizeof(std::int16_t));
v.end |= block_end(v)[0];
v.block[0] = v.block[1];
block_end(v)[0] = block_end(v)[1];
v.position = position;
check_irq(v.block[0], 8);
decode_block(v, v.buffer + 28);
}
update_envelope(v);
const std::int32_t out = sample * v.env.level >> 15;
if (raw) raw[n] = clamp16(out);
sum[n][0] += out * (sweep_l ? volume(v.voll, v.vol[0]) : fixed_l) >> 15;
sum[n][1] += out * (sweep_r ? volume(v.volr, v.vol[1]) : fixed_r) >> 15;
}
v.position = position;
}
void feed_input(int core) {
Core &k = g_cores[core];
while (!k.transfers.empty() && k.input_count + 256 <= kInputFrames) {
Transfer &t = k.transfers.front();
const std::uint32_t chunk = std::min<std::uint32_t>(t.bytes, 1024);
const std::uint32_t frames = std::max<std::uint32_t>(chunk / 4, 1);
const std::uint8_t *src = ram_ptr(t.madr);
for (std::uint32_t i = 0; i < frames; ++i) {
std::int16_t l, r;
std::memcpy(&l, src + i * 2, 2);
std::memcpy(&r, src + chunk / 2 + i * 2, 2);
const unsigned slot = (k.input_read + k.input_count + i) % kInputFrames;
k.input[slot][0] = l;
k.input[slot][1] = r;
g_ram[kInputBase[core] + slot] = static_cast<std::uint16_t>(l);
g_ram[kInputBase[core] + 0x200 + slot] = static_cast<std::uint16_t>(r);
}
k.input_count += frames;
t.madr += chunk;
t.bytes -= chunk;
if (!t.bytes) {
const int channel = t.channel;
k.transfers.pop_front();
if (channel >= 0) kernel::schedule(kernel::now() + 32, kernel::Job{kernel::kJobDmaDone, static_cast<std::uint32_t>(channel)});
}
}
}
void render_input(int core, std::int32_t &left, std::int32_t &right, std::int16_t &raw_l, std::int16_t &raw_r) {
Core &k = g_cores[core];
if (!k.input_count) return;
const unsigned slot = k.input_read;
check_irq(kInputBase[core] + slot, 1);
raw_l = k.input[slot][0];
raw_r = k.input[slot][1];
left += k.input[slot][0] * static_cast<std::int16_t>(k.bvol[0]) >> 15;
right += k.input[slot][1] * static_cast<std::int16_t>(k.bvol[1]) >> 15;
k.input_read = (k.input_read + 1) % kInputFrames;
--k.input_count;
}
std::int32_t master(std::uint16_t reg) { return reg & 0x8000u ? 0x7FFF : static_cast<std::int16_t>(reg << 1); }
// Each core streams every sample into fixed rings in SPU RAM, per core c at c*0x800: input L/R (core 1's input is core 0's
// output), voice 1, voice 3; at 0x1000+c*0x800: dry L/R, wet L/R. Those writes trip IRQA, and some games (Burnout 3:
// IRQA 0x400) use that as their audio clock. One range check per ring per batch keeps it cheap.
void write_rings(int core, const std::int16_t (*rings)[kBatch]) {
const auto pos = static_cast<std::uint32_t>(g_next_tick / (kBatch * kCyclesPerSample) % (kRingWords / kBatch) * kBatch);
for (std::uint32_t r = 0; r < 8; ++r) {
const std::uint32_t at = (r < 4 ? 0u : 0x1000u) + core * 0x800u + (r & 3u) * kRingWords + pos;
for (unsigned n = 0; n < kBatch; ++n) g_ram[at + n] = static_cast<std::uint16_t>(rings[r][n]);
check_irq(at, kBatch);
}
}
void tick() {
std::int16_t out[kBatch * 2];
std::int32_t sum[2][kBatch][2] = {};
std::int16_t rings[2][8][kBatch] = {};
static const bool count = std::getenv("PS2_SPU2_COUNT") != nullptr;
static std::uint64_t ticks = 0, active = 0, phases[5] = {};
static const char *const mute = std::getenv("PS2_SPU2_MUTE");
static const bool mute_music = mute && std::strcmp(mute, "music") == 0, mute_voices = mute && std::strcmp(mute, "voices") == 0;
static const bool levels = std::getenv("PS2_SPU2_LEVELS") != nullptr;
static double voice_energy = 0, music_energy = 0;
static std::uint64_t level_samples = 0;
std::int32_t voices[2][kBatch][2] = {};
for (int c = 0; c < 2; ++c) {
for (int i = 0; i < 24; ++i) {
Voice &v = g_cores[c].voices[i];
if (!v.key_on && v.phase == kOff) continue;
if (count) {
++active;
++phases[v.phase];
}
render_voice(v, sum[c], i == 1 ? rings[c][2] : i == 3 ? rings[c][3] : nullptr);
}
std::memcpy(voices[c], sum[c], sizeof voices[c]);
// Reverb is not modelled, so the wet rings stay silent.
for (unsigned n = 0; n < kBatch; ++n) {
rings[c][4][n] = clamp16(sum[c][n][0]);
rings[c][5][n] = clamp16(sum[c][n][1]);
}
std::int16_t unused[2];
for (unsigned n = 0; n < kBatch; ++n)
render_input(c, sum[c][n][0], sum[c][n][1], c ? unused[0] : rings[0][0][n], c ? unused[1] : rings[0][1][n]);
for (unsigned n = 0; n < kBatch; ++n)
for (int s = 0; s < 2; ++s) {
const std::int32_t music = sum[c][n][s] - voices[c][n][s], scale = master(g_cores[c].mvol[s]);
if (levels) {
const double v = static_cast<double>(voices[c][n][s] * scale >> 15), m = static_cast<double>(music * scale >> 15);
voice_energy += v * v;
music_energy += m * m;
}
if (mute_music) sum[c][n][s] = voices[c][n][s];
else if (mute_voices) sum[c][n][s] = music;
}
}
if (levels && (level_samples += kBatch) >= 48000u * 2u) {
std::fprintf(stderr, "[spu2] levels: voices %.0f, music %.0f, mvol core0 %04X/%04X core1 %04X/%04X\n", std::sqrt(voice_energy / static_cast<double>(level_samples * 2)),
std::sqrt(music_energy / static_cast<double>(level_samples * 2)), g_cores[0].mvol[0], g_cores[0].mvol[1], g_cores[1].mvol[0], g_cores[1].mvol[1]);
voice_energy = music_energy = 0;
level_samples = 0;
}
for (unsigned n = 0; n < kBatch; ++n) {
std::int32_t mix[2] = {};
for (int c = 0; c < 2; ++c) {
const std::int32_t l = sum[c][n][0] * master(g_cores[c].mvol[0]) >> 15, r = sum[c][n][1] * master(g_cores[c].mvol[1]) >> 15;
if (!c) {
rings[1][0][n] = clamp16(l);
rings[1][1][n] = clamp16(r);
}
mix[0] += l;
mix[1] += r;
}
out[n * 2] = clamp16(mix[0]);
out[n * 2 + 1] = clamp16(mix[1]);
}
write_rings(0, rings[0]);
write_rings(1, rings[1]);
if (count && ++ticks % 15000 == 0)
std::fprintf(stderr, "[spu2] %.1f voices per batch (attack %.1f decay %.1f sustain %.1f release %.1f)\n", static_cast<double>(active) / ticks,
static_cast<double>(phases[1]) / ticks, static_cast<double>(phases[2]) / ticks, static_cast<double>(phases[3]) / ticks, static_cast<double>(phases[4]) / ticks);
if (g_record) g_audio.insert(g_audio.end(), out, out + kBatch * 2);
if (g_sink) g_sink(out, kBatch);
feed_input(0);
feed_input(1);
g_next_tick += kBatch * kCyclesPerSample;
kernel::schedule(g_next_tick, kernel::Job{kernel::kJobSpuTick});
}
void keep_ticking() {
if (g_tick_pending) return;
g_tick_pending = true;
g_next_tick = kernel::now() + kBatch * kCyclesPerSample;
kernel::schedule(g_next_tick, kernel::Job{kernel::kJobSpuTick});
}
std::uint32_t set_hi(std::uint32_t address, std::uint32_t v) { return ((v & 0xFu) << 16) | (address & 0xFFFFu); }
std::uint32_t set_lo(std::uint32_t address, std::uint32_t v) { return (address & 0xF0000u) | (v & 0xFFFFu); }
std::uint32_t read_voice(Core &k, std::uint32_t off) {
if (off < 0x180u) {
const Voice &v = k.voices[off >> 4];
switch (off & 0xFu) {
case 0x0: return v.voll;
case 0x2: return v.volr;
case 0x4: return v.pitch;
case 0x6: return v.adsr1;
case 0x8: return v.adsr2;
case 0xA: return static_cast<std::uint32_t>(v.env.level);
case 0xC: return static_cast<std::uint32_t>(v.vol[0].level);
default: return static_cast<std::uint32_t>(v.vol[1].level);
}
}
const Voice &v = k.voices[(off - 0x1C0u) / 12];
const std::uint32_t nax = (v.block[0] + 1 + (v.position >> 14)) & kRamMask;
switch ((off - 0x1C0u) % 12) {
case 0: return v.ssa >> 16;
case 2: return v.ssa & 0xFFFFu;
case 4: return v.lsax >> 16;
case 6: return v.lsax & 0xFFFFu;
case 8: return nax >> 16;
default: return nax & 0xFFFFu;
}
}
void write_voice(Core &k, std::uint32_t off, std::uint32_t value) {
if (off < 0x180u) {
Voice &v = k.voices[off >> 4];
switch (off & 0xFu) {
case 0x0:
v.voll = static_cast<std::uint16_t>(value);
if (!(value & 0x8000u)) v.vol[0].level = static_cast<std::int16_t>(value << 1);
break;
case 0x2:
v.volr = static_cast<std::uint16_t>(value);
if (!(value & 0x8000u)) v.vol[1].level = static_cast<std::int16_t>(value << 1);
break;
case 0x4: v.pitch = static_cast<std::uint16_t>(value); break;
case 0x6: v.adsr1 = static_cast<std::uint16_t>(value); break;
case 0x8: v.adsr2 = static_cast<std::uint16_t>(value); break;
case 0xA: v.env.level = static_cast<std::int16_t>(value); break;
default: break;
}
return;
}
Voice &v = k.voices[(off - 0x1C0u) / 12];
switch ((off - 0x1C0u) % 12) {
case 0: v.ssa = set_hi(v.ssa, value); break;
case 2: v.ssa = set_lo(v.ssa, value); break;
case 4: v.lsax = set_hi(v.lsax, value); v.lsax_written = true; break;
case 6: v.lsax = set_lo(v.lsax, value); v.lsax_written = true; break;
case 8: v.next = set_hi(v.next, value); break;
default: v.next = set_lo(v.next, value); break;
}
}
void key(Core &k, std::uint32_t mask, bool on) {
for (int i = 0; i < 24; ++i) {
if (!(mask & (1u << i))) continue;
Voice &v = k.voices[i];
if (on) v.key_on = true;
else if (v.key_on) v.key_on = false;
else if (v.phase != kOff) v.phase = kRelease;
}
}
std::uint32_t read_core(int core, std::uint32_t off) {
Core &k = g_cores[core];
if (off < 0x180u || (off >= 0x1C0u && off < 0x2E0u)) return read_voice(k, off);
switch (off) {
case 0x19A: return k.attr;
case 0x19C: return k.irqa >> 16;
case 0x19E: return k.irqa & 0xFFFFu;
case 0x1A8: return k.tsa >> 16;
case 0x1AA: return k.tsa & 0xFFFFu;
case 0x1B0: return k.admas;
case 0x340:
case 0x342: {
std::uint32_t endx = 0;
for (int i = 0; i < 24; ++i)
if (k.voices[i].end) endx |= 1u << i;
return off == 0x340 ? endx & 0xFFFFu : endx >> 16;
}
case 0x344:
if (g_statx_settling[core]) {
--g_statx_settling[core];
return 0;
}
return 0x80u;
default: return k.regs[off >> 1];
}
}
void write_core(int core, std::uint32_t off, std::uint32_t value) {
Core &k = g_cores[core];
static const bool trace = std::getenv("PS2_TRACE_SPU2") != nullptr;
if (trace && off >= 0x180u && !(off >= 0x1C0u && off < 0x2E0u) && off != 0x1AC)
std::fprintf(stderr, "[spu2] core %d reg 0x%03X = 0x%04X\n", core, off, value);
if (off < 0x180u || (off >= 0x1C0u && off < 0x2E0u)) {
write_voice(k, off, value);
return;
}
k.regs[off >> 1] = static_cast<std::uint16_t>(value);
switch (off) {
case 0x19A:
if ((value & 0x8000u) && !(k.attr & 0x8000u)) g_statx_settling[core] = 16;
k.attr = static_cast<std::uint16_t>(value);
if (!(value & 0x40u)) k.irq = false;
break;
case 0x19C: k.irqa = set_hi(k.irqa, value); break;
case 0x19E: k.irqa = set_lo(k.irqa, value); break;
case 0x1A0: key(k, value, true); break;
case 0x1A2: key(k, value << 16, true); break;
case 0x1A4: key(k, value, false); break;
case 0x1A6: key(k, value << 16, false); break;
case 0x1A8: k.tsa = set_hi(k.tsa, value); break;
case 0x1AA: k.tsa = set_lo(k.tsa, value); break;
case 0x1AC:
check_irq(k.tsa, 1);
g_ram[k.tsa] = static_cast<std::uint16_t>(value);
k.tsa = (k.tsa + 1) & kRamMask;
break;
case 0x1B0:
k.admas = static_cast<std::uint16_t>(value);
if (!value) k.input_count = k.input_read = 0;
break;
case 0x340:
for (int i = 0; i < 16; ++i) k.voices[i].end = false;
break;
case 0x342:
for (int i = 16; i < 24; ++i) k.voices[i].end = false;
break;
default: break;
}
}
std::uint16_t *master_reg(int core, std::uint32_t off) {
Core &k = g_cores[core];
switch (off) {
case 0x0: return &k.mvol[0];
case 0x2: return &k.mvol[1];
case 0x4: return &k.evol[0];
case 0x6: return &k.evol[1];
case 0x8: return &k.avol[0];
case 0xA: return &k.avol[1];
case 0xC: return &k.bvol[0];
case 0xE: return &k.bvol[1];
default: return nullptr;
}
}
std::uint32_t read_global(std::uint32_t off) {
switch (off) {
case 0x7C0: return g_spdif_out;
case 0x7C2: return (g_cores[0].irq ? 4u : 0u) | (g_cores[1].irq ? 8u : 0u);
case 0x7C6: return g_spdif_mode;
case 0x7C8: return g_spdif_media;
default: return 0;
}
}
void write_global(std::uint32_t off, std::uint32_t value) {
switch (off) {
case 0x7C0: g_spdif_out = static_cast<std::uint16_t>(value); break;
case 0x7C6: g_spdif_mode = static_cast<std::uint16_t>(value); break;
case 0x7C8: g_spdif_media = static_cast<std::uint16_t>(value); break;
default: break;
}
}
}
void reset() {
kernel::register_job(kernel::kJobSpuTick, [](const kernel::Job &) { tick(); });
std::fill(g_ram.begin(), g_ram.end(), 0);
for (Core &k : g_cores) k = Core{};
std::memset(g_block_end, 0, sizeof g_block_end);
g_spdif_out = g_spdif_mode = g_spdif_media = 0;
g_audio.clear();
g_record = std::getenv("PS2_DUMP_AUDIO") != nullptr;
g_next_tick = 0;
g_tick_pending = false;
}
std::uint16_t *ram() { return g_ram.data(); }
std::uint32_t read(std::uint32_t a, unsigned size) {
keep_ticking();
const std::uint32_t off = a & 0x7FEu;
std::uint32_t value = 0;
if (off < 0x760u) value = read_core((off & 0x400u) ? 1 : 0, off & 0x3FEu);
else if (off < 0x7B0u) {
if (const std::uint16_t *reg = master_reg((off - 0x760u) / 0x28, (off - 0x760u) % 0x28)) value = *reg;
} else value = read_global(off);
if (size == 4) value |= read(a + 2, 2) << 16;
return value;
}
void write(std::uint32_t a, std::uint32_t v, unsigned size) {
keep_ticking();
if (size == 4) {
write(a, v & 0xFFFFu, 2);
write(a + 2, v >> 16, 2);
return;
}
const std::uint32_t off = a & 0x7FEu;
v &= 0xFFFFu;
if (off < 0x760u) write_core((off & 0x400u) ? 1 : 0, off & 0x3FEu, v);
else if (off < 0x7B0u) {
if (std::uint16_t *reg = master_reg((off - 0x760u) / 0x28, (off - 0x760u) % 0x28)) *reg = static_cast<std::uint16_t>(v);
} else write_global(off, v);
}
void dma(int core, std::uint32_t madr, std::uint32_t words, bool to_spu, int channel) {
keep_ticking();
Core &k = g_cores[core];
if (to_spu && (k.admas & (1u << core))) {
k.transfers.push_back(Transfer{madr, words * 4, channel});
feed_input(core);
return;
}
const std::uint32_t halfwords = words * 2;
if (to_spu) check_irq(k.tsa, halfwords);
for (std::uint32_t i = 0; i < halfwords; ++i) {
std::uint16_t *spu = &g_ram[(k.tsa + i) & kRamMask];
std::uint8_t *iop = ram_ptr(madr + i * 2);
if (to_spu) std::memcpy(spu, iop, 2);
else std::memcpy(iop, spu, 2);
}
k.tsa = (k.tsa + halfwords) & kRamMask;
if (channel >= 0) kernel::schedule(kernel::now() + 64 + words / 4, kernel::Job{kernel::kJobDmaDone, static_cast<std::uint32_t>(channel)});
}
void stop_dma(int core) { g_cores[core].transfers.clear(); }
void set_sink(std::function<void(const std::int16_t *, std::size_t)> sink) { g_sink = std::move(sink); }
void dump_voices() {
for (int c = 0; c < 2; ++c)
for (int i = 0; i < 24; ++i) {
const Voice &v = g_cores[c].voices[i];
if (v.phase == kOff && !v.end) continue;
const std::uint16_t header = g_ram[v.block[0] & kRamMask];
std::fprintf(stderr, "[spu2] core %d voice %d phase %d ssa 0x%05X lsax 0x%05X block 0x%05X flags %X next 0x%05X pitch 0x%04X env %d end %d\n", c, i,
static_cast<int>(v.phase), v.ssa, v.lsax, v.block[0], header >> 8, v.next, v.pitch, v.env.level, v.end ? 1 : 0);
}
}
void dump_audio(const char *path) {
std::FILE *f = std::fopen(path, "wb");
if (!f) return;
const std::uint32_t bytes = static_cast<std::uint32_t>(g_audio.size() * 2);
const std::uint32_t header[] = {0x46464952u, 36 + bytes, 0x45564157u, 0x20746D66u, 16, 0x00020001u,
48000, 48000 * 4, 0x00100004u, 0x61746164u, bytes};
std::fwrite(header, 4, sizeof header / 4, f);
std::fwrite(g_audio.data(), 2, g_audio.size(), f);
std::fclose(f);
}
}
namespace ps2::iop::spu2 {
void state(ps2::state::Stream &s) {
s.tag("spu2");
s.vec(g_ram);
for (Core &k : g_cores) {
s.pod(k.voices);
if (s.loading())
for (const Voice &v : k.voices)
for (int i = 0; i < 2; ++i) block_end(v)[i] = (g_ram[v.block[i] & kRamMask] >> 8) & 1u;
s.pod(k.attr);
s.pod(k.admas);
s.pod(k.irqa);
s.pod(k.tsa);
s.pod(k.mvol);
s.pod(k.bvol);
s.pod(k.avol);
s.pod(k.evol);
s.pod(k.irq);
s.pod(k.input);
s.pod(k.input_read);
s.pod(k.input_count);
s.deque(k.transfers, [&s](Transfer &t) {
s.pod(t.madr);
s.pod(t.bytes);
s.pod(t.channel);
});
s.pod(k.regs);
}
s.pod(g_spdif_out);
s.pod(g_spdif_mode);
s.pod(g_spdif_media);
s.pod(g_next_tick);
s.pod(g_tick_pending);
}
}