mirror of
https://github.com/mitch030504/Wiicompiled_VR_Frame.git
synced 2026-10-06 03:00:14 +02:00
Add ReverbHi audio processing functions and improve memory handling
This commit is contained in:
iChris4 committed
1 parent
d2fa3789b0
commit
5899114b4c
1 file changed
+580
-51
@@ -3,14 +3,19 @@
|
|||||||
#include "hle_stubs.h"
|
#include "hle_stubs.h"
|
||||||
#include "memory.h"
|
#include "memory.h"
|
||||||
#include "ppc_runtime.h"
|
#include "ppc_runtime.h"
|
||||||
|
#include "runtime_log.h"
|
||||||
|
|
||||||
#include <cmath>
|
#include <cmath>
|
||||||
#include <cstddef>
|
#include <cstddef>
|
||||||
#include <cstdint>
|
#include <cstdint>
|
||||||
|
#include <cstdlib>
|
||||||
#include <cstring>
|
#include <cstring>
|
||||||
|
#include <utility>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
|
||||||
extern "C" void func_8012B830(CpuContext* ctx);
|
extern "C" void func_8012B830(CpuContext* ctx);
|
||||||
|
extern "C" void func_801284B4(CpuContext* ctx);
|
||||||
|
|
||||||
#if defined(__clang__)
|
#if defined(__clang__)
|
||||||
// PowerPC uses discrete fmuls/fadds; a fused multiply-add would change sample rounding.
|
// PowerPC uses discrete fmuls/fadds; a fused multiply-add would change sample rounding.
|
||||||
@@ -18,6 +23,57 @@ extern "C" void func_8012B830(CpuContext* ctx);
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
namespace {
|
namespace {
|
||||||
|
inline float LoadFloat(const uint8_t* host) {
|
||||||
|
return BigEndian::ReadFloat32(host);
|
||||||
|
}
|
||||||
|
|
||||||
|
inline void StoreFloat(uint8_t* host, float value) {
|
||||||
|
BigEndian::WriteFloat32(host, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
inline int32_t LoadS32(const uint8_t* host) {
|
||||||
|
return static_cast<int32_t>(BigEndian::Read32(host));
|
||||||
|
}
|
||||||
|
|
||||||
|
inline void StoreS32(uint8_t* host, int32_t value) {
|
||||||
|
BigEndian::Write32(host, static_cast<uint32_t>(value));
|
||||||
|
}
|
||||||
|
|
||||||
|
// PowerPC fctiwz: round toward zero, saturating out-of-range and NaN exactly the
|
||||||
|
// way runtime/src/fpu_helpers.cpp does for the translated form.
|
||||||
|
inline int32_t ConvertToIntegerWord(float value) {
|
||||||
|
const double wide = static_cast<double>(value);
|
||||||
|
if (std::isnan(wide)) {
|
||||||
|
return static_cast<int32_t>(0x80000000u);
|
||||||
|
}
|
||||||
|
if (wide >= 2147483647.0) {
|
||||||
|
return 2147483647;
|
||||||
|
}
|
||||||
|
if (wide <= -2147483648.0) {
|
||||||
|
return static_cast<int32_t>(0x80000000u);
|
||||||
|
}
|
||||||
|
return static_cast<int32_t>(wide);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Guest-thread-only range resolver. Deliberately NOT the mix's MixResolveRange: this
|
||||||
|
// callback must materialize deferred GX reads through the page table, which the
|
||||||
|
// worker-safe resolver refuses to do by design.
|
||||||
|
uint8_t* ResolveGuestThreadRange(uint32_t addr, size_t bytes) {
|
||||||
|
if (addr == 0 || bytes == 0) {
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
if (uint8_t* fast = MemoryInline::GetPointerFast(addr, bytes)) {
|
||||||
|
return fast;
|
||||||
|
}
|
||||||
|
// A ring buffer may straddle the inline page granularity; the region lookup
|
||||||
|
// still returns one contiguous host mapping for the whole range.
|
||||||
|
try {
|
||||||
|
return Memory::GetPointer(addr, bytes);
|
||||||
|
} catch (const Memory::AccessViolation&) {
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
namespace ReverbStd {
|
namespace ReverbStd {
|
||||||
|
|
||||||
constexpr uint32_t kSamplesPerFrame = 96;
|
constexpr uint32_t kSamplesPerFrame = 96;
|
||||||
@@ -93,57 +149,6 @@ struct Frame {
|
|||||||
bool hasAuxOut = false;
|
bool hasAuxOut = false;
|
||||||
};
|
};
|
||||||
|
|
||||||
inline float LoadFloat(const uint8_t* host) {
|
|
||||||
return BigEndian::ReadFloat32(host);
|
|
||||||
}
|
|
||||||
|
|
||||||
inline void StoreFloat(uint8_t* host, float value) {
|
|
||||||
BigEndian::WriteFloat32(host, value);
|
|
||||||
}
|
|
||||||
|
|
||||||
inline int32_t LoadS32(const uint8_t* host) {
|
|
||||||
return static_cast<int32_t>(BigEndian::Read32(host));
|
|
||||||
}
|
|
||||||
|
|
||||||
inline void StoreS32(uint8_t* host, int32_t value) {
|
|
||||||
BigEndian::Write32(host, static_cast<uint32_t>(value));
|
|
||||||
}
|
|
||||||
|
|
||||||
// PowerPC fctiwz: round toward zero, saturating out-of-range and NaN exactly the
|
|
||||||
// way runtime/src/fpu_helpers.cpp does for the translated form.
|
|
||||||
inline int32_t ConvertToIntegerWord(float value) {
|
|
||||||
const double wide = static_cast<double>(value);
|
|
||||||
if (std::isnan(wide)) {
|
|
||||||
return static_cast<int32_t>(0x80000000u);
|
|
||||||
}
|
|
||||||
if (wide >= 2147483647.0) {
|
|
||||||
return 2147483647;
|
|
||||||
}
|
|
||||||
if (wide <= -2147483648.0) {
|
|
||||||
return static_cast<int32_t>(0x80000000u);
|
|
||||||
}
|
|
||||||
return static_cast<int32_t>(wide);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Guest-thread-only range resolver. Deliberately NOT the mix's MixResolveRange: this
|
|
||||||
// callback must materialize deferred GX reads through the page table, which the
|
|
||||||
// worker-safe resolver refuses to do by design.
|
|
||||||
uint8_t* ResolveGuestThreadRange(uint32_t addr, size_t bytes) {
|
|
||||||
if (addr == 0 || bytes == 0) {
|
|
||||||
return nullptr;
|
|
||||||
}
|
|
||||||
if (uint8_t* fast = MemoryInline::GetPointerFast(addr, bytes)) {
|
|
||||||
return fast;
|
|
||||||
}
|
|
||||||
// A ring buffer may straddle the inline page granularity; the region lookup
|
|
||||||
// still returns one contiguous host mapping for the whole range.
|
|
||||||
try {
|
|
||||||
return Memory::GetPointer(addr, bytes);
|
|
||||||
} catch (const Memory::AccessViolation&) {
|
|
||||||
return nullptr;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Collects everything the render loop needs. Returns false when the layout is
|
// Collects everything the render loop needs. Returns false when the layout is
|
||||||
// not one this port can serve bit-exactly, in which case the caller must run the
|
// not one this port can serve bit-exactly, in which case the caller must run the
|
||||||
// translated function instead.
|
// translated function instead.
|
||||||
@@ -332,6 +337,486 @@ void Render(uint32_t stateAddr, Frame& frame) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
} // namespace ReverbStd
|
} // namespace ReverbStd
|
||||||
|
|
||||||
|
namespace ReverbHi {
|
||||||
|
|
||||||
|
constexpr uint32_t kSamplesPerFrame = 96;
|
||||||
|
constexpr uint32_t kChannels = 3;
|
||||||
|
constexpr uint32_t kEarlyTaps = 3;
|
||||||
|
constexpr uint32_t kCombs = 3;
|
||||||
|
constexpr uint32_t kAllpasses = 2;
|
||||||
|
|
||||||
|
// .sdata2 constants the guest function loads through r2 (_SDA2_BASE_ = 0x8038EFA0).
|
||||||
|
constexpr uint32_t kZeroConstantAddr = 0x803884D4u; // 0.0f, the comb accumulator seed
|
||||||
|
constexpr uint32_t kOneConstantAddr = 0x803884D8u; // 1.0f
|
||||||
|
constexpr uint32_t kWetConstantAddr = 0x803884DCu; // 0.6f wet pre-scale
|
||||||
|
constexpr uint32_t kMixConstantAddr = 0x803884E0u; // 0.5f channel cross-mix
|
||||||
|
|
||||||
|
// AXFX_REVERBHI_EXP field offsets (byte offsets into the struct in r4). Every one
|
||||||
|
// is read off the translated body at 0x801284B4 rather than guessed: the arrays
|
||||||
|
// sit back to back, which is what makes the strides below self-checking.
|
||||||
|
constexpr uint32_t kFieldEarlyLine = 0x00; // + channel * 4
|
||||||
|
constexpr uint32_t kFieldEarlyPos = 0x0C; // + tap * 4, one set shared by all channels
|
||||||
|
constexpr uint32_t kFieldEarlyLength = 0x18;
|
||||||
|
constexpr uint32_t kFieldEarlyCoef = 0x20; // + tap * 4
|
||||||
|
constexpr uint32_t kFieldPreDelayLine = 0x2C; // + channel * 4
|
||||||
|
constexpr uint32_t kFieldPreDelayPos = 0x38;
|
||||||
|
constexpr uint32_t kFieldPreDelayLength = 0x3C; // 0 bypasses the pre-delay
|
||||||
|
constexpr uint32_t kFieldCombLine = 0x44; // + channel * 12 + comb * 4
|
||||||
|
constexpr uint32_t kFieldCombPos = 0x68; // + comb * 4
|
||||||
|
constexpr uint32_t kFieldCombLength = 0x74; // + comb * 4
|
||||||
|
constexpr uint32_t kFieldCombCoef = 0x8C; // + comb * 4
|
||||||
|
constexpr uint32_t kFieldAllpassLine = 0x98; // + channel * 8 + allpass * 4
|
||||||
|
constexpr uint32_t kFieldAllpassPos = 0xB0; // + allpass * 4
|
||||||
|
constexpr uint32_t kFieldAllpassLength = 0xB8; // + allpass * 4
|
||||||
|
constexpr uint32_t kFieldLastApLine = 0xC8; // + channel * 4
|
||||||
|
constexpr uint32_t kFieldLastApPos = 0xD4; // + channel * 4
|
||||||
|
constexpr uint32_t kFieldLastApLength = 0xE0; // + channel * 4
|
||||||
|
constexpr uint32_t kFieldAllpassCoef = 0xF8;
|
||||||
|
constexpr uint32_t kFieldLastLpfOut = 0xFC; // + channel * 4
|
||||||
|
constexpr uint32_t kFieldDamping = 0x108;
|
||||||
|
constexpr uint32_t kFieldFlags = 0x10C;
|
||||||
|
constexpr uint32_t kFieldMixPreScale = 0x12C;
|
||||||
|
constexpr uint32_t kFieldWetPreScale = 0x134;
|
||||||
|
constexpr uint32_t kFieldAuxInputBuffers = 0x138;
|
||||||
|
constexpr uint32_t kFieldAuxOutputBuffers = 0x13C;
|
||||||
|
constexpr uint32_t kFieldMainOutGain = 0x140;
|
||||||
|
constexpr uint32_t kFieldAuxOutGain = 0x144;
|
||||||
|
constexpr uint32_t kStateStructBytes = 0x148;
|
||||||
|
|
||||||
|
struct Frame {
|
||||||
|
uint8_t* early[kChannels]{};
|
||||||
|
uint8_t* preDelay[kChannels]{};
|
||||||
|
uint8_t* comb[kChannels][kCombs]{};
|
||||||
|
uint8_t* allpass[kChannels][kAllpasses]{};
|
||||||
|
uint8_t* lastAp[kChannels]{};
|
||||||
|
uint8_t* main[kChannels]{};
|
||||||
|
const uint8_t* auxIn[kChannels]{};
|
||||||
|
uint8_t* auxOut[kChannels]{};
|
||||||
|
|
||||||
|
uint32_t earlyPos[kEarlyTaps]{};
|
||||||
|
uint32_t earlyLength = 0;
|
||||||
|
float earlyCoef[kEarlyTaps]{};
|
||||||
|
|
||||||
|
uint32_t preDelayPos = 0;
|
||||||
|
uint32_t preDelayLength = 0;
|
||||||
|
|
||||||
|
uint32_t combPos[kCombs]{};
|
||||||
|
uint32_t combLength[kCombs]{};
|
||||||
|
float combCoef[kCombs]{};
|
||||||
|
|
||||||
|
uint32_t allpassPos[kAllpasses]{};
|
||||||
|
uint32_t allpassLength[kAllpasses]{};
|
||||||
|
|
||||||
|
uint32_t lastApPos[kChannels]{};
|
||||||
|
uint32_t lastApLength[kChannels]{};
|
||||||
|
float lastLpfOut[kChannels]{};
|
||||||
|
|
||||||
|
float zero = 0.0f;
|
||||||
|
float allpassCoef = 0.0f;
|
||||||
|
float damping = 0.0f;
|
||||||
|
float oneMinusDamping = 0.0f;
|
||||||
|
float wetScale = 0.0f;
|
||||||
|
float mixScale = 0.0f;
|
||||||
|
float mainGain = 0.0f;
|
||||||
|
float auxGain = 0.0f;
|
||||||
|
bool hasAuxIn = false;
|
||||||
|
bool hasAuxOut = false;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Same contract as ReverbStd::BuildFrame: false means this port cannot serve the
|
||||||
|
// layout bit-exactly, and the caller runs the translated function instead.
|
||||||
|
bool BuildFrame(uint32_t buffersAddr, uint32_t stateAddr, Frame& frame) {
|
||||||
|
if (buffersAddr == 0 || stateAddr == 0) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (!Memory::Contains(stateAddr, kStateStructBytes)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
const uint32_t auxInputBuffers = Memory::Read32(stateAddr + kFieldAuxInputBuffers);
|
||||||
|
const uint32_t auxOutputBuffers = Memory::Read32(stateAddr + kFieldAuxOutputBuffers);
|
||||||
|
frame.hasAuxIn = auxInputBuffers != 0;
|
||||||
|
frame.hasAuxOut = auxOutputBuffers != 0;
|
||||||
|
|
||||||
|
constexpr size_t kFrameBytes = kSamplesPerFrame * sizeof(int32_t);
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
frame.main[channel] =
|
||||||
|
ResolveGuestThreadRange(Memory::Read32(buffersAddr + channel * 4), kFrameBytes);
|
||||||
|
if (!frame.main[channel]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
if (frame.hasAuxIn) {
|
||||||
|
frame.auxIn[channel] =
|
||||||
|
ResolveGuestThreadRange(Memory::Read32(auxInputBuffers + channel * 4), kFrameBytes);
|
||||||
|
if (!frame.auxIn[channel]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (frame.hasAuxOut) {
|
||||||
|
frame.auxOut[channel] =
|
||||||
|
ResolveGuestThreadRange(Memory::Read32(auxOutputBuffers + channel * 4), kFrameBytes);
|
||||||
|
if (!frame.auxOut[channel]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Early reflections: three read taps into one per-channel line, all wrapping
|
||||||
|
// against a single shared length.
|
||||||
|
frame.earlyLength = Memory::Read32(stateAddr + kFieldEarlyLength);
|
||||||
|
if (frame.earlyLength == 0) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
for (uint32_t tap = 0; tap < kEarlyTaps; ++tap) {
|
||||||
|
frame.earlyPos[tap] = Memory::Read32(stateAddr + kFieldEarlyPos + tap * 4);
|
||||||
|
if (frame.earlyPos[tap] >= frame.earlyLength) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
frame.earlyCoef[tap] = Memory::ReadFloat32(stateAddr + kFieldEarlyCoef + tap * 4);
|
||||||
|
}
|
||||||
|
const size_t earlyBytes = static_cast<size_t>(frame.earlyLength) * sizeof(float);
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
frame.early[channel] = ResolveGuestThreadRange(
|
||||||
|
Memory::Read32(stateAddr + kFieldEarlyLine + channel * 4), earlyBytes);
|
||||||
|
if (!frame.early[channel]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// A zero pre-delay length is the guest's own bypass, not a broken layout, so
|
||||||
|
// the lines are only required when it is armed.
|
||||||
|
frame.preDelayLength = Memory::Read32(stateAddr + kFieldPreDelayLength);
|
||||||
|
frame.preDelayPos = Memory::Read32(stateAddr + kFieldPreDelayPos);
|
||||||
|
if (frame.preDelayLength != 0) {
|
||||||
|
if (frame.preDelayPos >= frame.preDelayLength) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
const size_t preDelayBytes = static_cast<size_t>(frame.preDelayLength) * sizeof(float);
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
frame.preDelay[channel] = ResolveGuestThreadRange(
|
||||||
|
Memory::Read32(stateAddr + kFieldPreDelayLine + channel * 4), preDelayBytes);
|
||||||
|
if (!frame.preDelay[channel]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (uint32_t comb = 0; comb < kCombs; ++comb) {
|
||||||
|
frame.combLength[comb] = Memory::Read32(stateAddr + kFieldCombLength + comb * 4);
|
||||||
|
frame.combPos[comb] = Memory::Read32(stateAddr + kFieldCombPos + comb * 4);
|
||||||
|
frame.combCoef[comb] = Memory::ReadFloat32(stateAddr + kFieldCombCoef + comb * 4);
|
||||||
|
if (frame.combLength[comb] == 0 || frame.combPos[comb] >= frame.combLength[comb]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
const size_t combBytes = static_cast<size_t>(frame.combLength[comb]) * sizeof(float);
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
frame.comb[channel][comb] = ResolveGuestThreadRange(
|
||||||
|
Memory::Read32(stateAddr + kFieldCombLine + channel * 12 + comb * 4), combBytes);
|
||||||
|
if (!frame.comb[channel][comb]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (uint32_t allpass = 0; allpass < kAllpasses; ++allpass) {
|
||||||
|
frame.allpassLength[allpass] = Memory::Read32(stateAddr + kFieldAllpassLength + allpass * 4);
|
||||||
|
frame.allpassPos[allpass] = Memory::Read32(stateAddr + kFieldAllpassPos + allpass * 4);
|
||||||
|
if (frame.allpassLength[allpass] == 0 ||
|
||||||
|
frame.allpassPos[allpass] >= frame.allpassLength[allpass]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
const size_t allpassBytes =
|
||||||
|
static_cast<size_t>(frame.allpassLength[allpass]) * sizeof(float);
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
frame.allpass[channel][allpass] = ResolveGuestThreadRange(
|
||||||
|
Memory::Read32(stateAddr + kFieldAllpassLine + channel * 8 + allpass * 4),
|
||||||
|
allpassBytes);
|
||||||
|
if (!frame.allpass[channel][allpass]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// The trailing allpass is the one stage whose index and length are per channel;
|
||||||
|
// the guest advances it inside the channel loop rather than once per sample.
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
frame.lastApLength[channel] = Memory::Read32(stateAddr + kFieldLastApLength + channel * 4);
|
||||||
|
frame.lastApPos[channel] = Memory::Read32(stateAddr + kFieldLastApPos + channel * 4);
|
||||||
|
if (frame.lastApLength[channel] == 0 ||
|
||||||
|
frame.lastApPos[channel] >= frame.lastApLength[channel]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
frame.lastAp[channel] = ResolveGuestThreadRange(
|
||||||
|
Memory::Read32(stateAddr + kFieldLastApLine + channel * 4),
|
||||||
|
static_cast<size_t>(frame.lastApLength[channel]) * sizeof(float));
|
||||||
|
if (!frame.lastAp[channel]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
frame.lastLpfOut[channel] = Memory::ReadFloat32(stateAddr + kFieldLastLpfOut + channel * 4);
|
||||||
|
}
|
||||||
|
|
||||||
|
const float one = Memory::ReadFloat32(kOneConstantAddr);
|
||||||
|
const float wetConstant = Memory::ReadFloat32(kWetConstantAddr);
|
||||||
|
const float mixConstant = Memory::ReadFloat32(kMixConstantAddr);
|
||||||
|
frame.zero = Memory::ReadFloat32(kZeroConstantAddr);
|
||||||
|
frame.damping = Memory::ReadFloat32(stateAddr + kFieldDamping);
|
||||||
|
frame.oneMinusDamping = one - frame.damping;
|
||||||
|
frame.wetScale = wetConstant * Memory::ReadFloat32(stateAddr + kFieldWetPreScale);
|
||||||
|
frame.mixScale = mixConstant * Memory::ReadFloat32(stateAddr + kFieldMixPreScale);
|
||||||
|
frame.allpassCoef = Memory::ReadFloat32(stateAddr + kFieldAllpassCoef);
|
||||||
|
frame.mainGain = Memory::ReadFloat32(stateAddr + kFieldMainOutGain);
|
||||||
|
frame.auxGain = Memory::ReadFloat32(stateAddr + kFieldAuxOutGain);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void Render(uint32_t stateAddr, Frame& frame) {
|
||||||
|
uint32_t earlyPos[kEarlyTaps];
|
||||||
|
for (uint32_t tap = 0; tap < kEarlyTaps; ++tap) {
|
||||||
|
earlyPos[tap] = frame.earlyPos[tap];
|
||||||
|
}
|
||||||
|
uint32_t preDelayPos = frame.preDelayPos;
|
||||||
|
uint32_t combPos[kCombs];
|
||||||
|
for (uint32_t comb = 0; comb < kCombs; ++comb) {
|
||||||
|
combPos[comb] = frame.combPos[comb];
|
||||||
|
}
|
||||||
|
uint32_t allpassPos[kAllpasses];
|
||||||
|
for (uint32_t allpass = 0; allpass < kAllpasses; ++allpass) {
|
||||||
|
allpassPos[allpass] = frame.allpassPos[allpass];
|
||||||
|
}
|
||||||
|
|
||||||
|
for (uint32_t sample = 0; sample < kSamplesPerFrame; ++sample) {
|
||||||
|
const uint32_t frameOffset = sample * 4u;
|
||||||
|
float mixed[kChannels];
|
||||||
|
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
uint8_t* const mainSlot = frame.main[channel] + frameOffset;
|
||||||
|
int32_t rawInput = LoadS32(mainSlot);
|
||||||
|
if (frame.hasAuxIn) {
|
||||||
|
rawInput = static_cast<int32_t>(
|
||||||
|
static_cast<uint32_t>(rawInput) +
|
||||||
|
static_cast<uint32_t>(LoadS32(frame.auxIn[channel] + frameOffset)));
|
||||||
|
}
|
||||||
|
const float input = static_cast<float>(rawInput);
|
||||||
|
|
||||||
|
// All three early taps read before the newest sample overwrites the
|
||||||
|
// third tap's slot. Every product is its own statement so the host
|
||||||
|
// compiler cannot fuse a multiply into the following add.
|
||||||
|
uint8_t* const earlyLine = frame.early[channel];
|
||||||
|
const float earlyTap0 = LoadFloat(earlyLine + earlyPos[0] * 4u);
|
||||||
|
const float earlyTap1 = LoadFloat(earlyLine + earlyPos[1] * 4u);
|
||||||
|
const float earlyTap2 = LoadFloat(earlyLine + earlyPos[2] * 4u);
|
||||||
|
StoreFloat(earlyLine + earlyPos[2] * 4u, input);
|
||||||
|
const float early0 = frame.earlyCoef[0] * earlyTap0;
|
||||||
|
const float early1 = frame.earlyCoef[1] * earlyTap1;
|
||||||
|
const float early2 = frame.earlyCoef[2] * earlyTap2;
|
||||||
|
const float earlySum = early0 + early1;
|
||||||
|
const float early = early2 + earlySum;
|
||||||
|
|
||||||
|
// Pure delay, no feedback coefficient.
|
||||||
|
float excite = input;
|
||||||
|
if (frame.preDelayLength != 0) {
|
||||||
|
uint8_t* const preDelaySlot = frame.preDelay[channel] + preDelayPos * 4u;
|
||||||
|
excite = LoadFloat(preDelaySlot);
|
||||||
|
StoreFloat(preDelaySlot, input);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Three combs, all fed the same pre-delay output; their taps sum into
|
||||||
|
// the allpass chain.
|
||||||
|
float combSum = frame.zero;
|
||||||
|
for (uint32_t comb = 0; comb < kCombs; ++comb) {
|
||||||
|
uint8_t* const combSlot = frame.comb[channel][comb] + combPos[comb] * 4u;
|
||||||
|
const float combTap = LoadFloat(combSlot);
|
||||||
|
const float combFeedback = combTap * frame.combCoef[comb];
|
||||||
|
combSum = combSum + combTap;
|
||||||
|
StoreFloat(combSlot, excite + combFeedback);
|
||||||
|
}
|
||||||
|
|
||||||
|
float allpassOut = combSum;
|
||||||
|
for (uint32_t allpass = 0; allpass < kAllpasses; ++allpass) {
|
||||||
|
uint8_t* const allpassSlot =
|
||||||
|
frame.allpass[channel][allpass] + allpassPos[allpass] * 4u;
|
||||||
|
const float allpassTap = LoadFloat(allpassSlot);
|
||||||
|
const float allpassFeedback = allpassTap * frame.allpassCoef;
|
||||||
|
const float allpassStore = allpassOut + allpassFeedback;
|
||||||
|
StoreFloat(allpassSlot, allpassStore);
|
||||||
|
const float allpassFeedforward = allpassStore * frame.allpassCoef;
|
||||||
|
allpassOut = allpassTap - allpassFeedforward;
|
||||||
|
}
|
||||||
|
|
||||||
|
const float dampedOld = frame.damping * frame.lastLpfOut[channel];
|
||||||
|
const float dampedNew = frame.oneMinusDamping * allpassOut;
|
||||||
|
const float damped = dampedNew + dampedOld;
|
||||||
|
frame.lastLpfOut[channel] = damped;
|
||||||
|
|
||||||
|
uint8_t* const lastSlot = frame.lastAp[channel] + frame.lastApPos[channel] * 4u;
|
||||||
|
const float lastTap = LoadFloat(lastSlot);
|
||||||
|
const float lastFeedback = lastTap * frame.allpassCoef;
|
||||||
|
const float lastStore = damped + lastFeedback;
|
||||||
|
StoreFloat(lastSlot, lastStore);
|
||||||
|
const float lastFeedforward = lastStore * frame.allpassCoef;
|
||||||
|
const float lastOut = lastTap - lastFeedforward;
|
||||||
|
|
||||||
|
const uint32_t nextLastPos = frame.lastApPos[channel] + 1u;
|
||||||
|
frame.lastApPos[channel] =
|
||||||
|
nextLastPos < frame.lastApLength[channel] ? nextLastPos : 0u;
|
||||||
|
|
||||||
|
const float wet = lastOut * frame.wetScale;
|
||||||
|
mixed[channel] = wet + early;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Each output channel takes the other two through the shared cross-mix.
|
||||||
|
const float sum12 = mixed[1] + mixed[2];
|
||||||
|
const float sum02 = mixed[0] + mixed[2];
|
||||||
|
const float sum01 = mixed[0] + mixed[1];
|
||||||
|
const float cross0 = sum12 * frame.mixScale;
|
||||||
|
const float cross1 = sum02 * frame.mixScale;
|
||||||
|
const float cross2 = sum01 * frame.mixScale;
|
||||||
|
const float out[kChannels] = {
|
||||||
|
mixed[0] + cross0,
|
||||||
|
mixed[1] + cross1,
|
||||||
|
mixed[2] + cross2,
|
||||||
|
};
|
||||||
|
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
const float mainSample = out[channel] * frame.mainGain;
|
||||||
|
StoreS32(frame.main[channel] + frameOffset, ConvertToIntegerWord(mainSample));
|
||||||
|
if (frame.hasAuxOut) {
|
||||||
|
const float auxSample = out[channel] * frame.auxGain;
|
||||||
|
StoreS32(frame.auxOut[channel] + frameOffset, ConvertToIntegerWord(auxSample));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (uint32_t tap = 0; tap < kEarlyTaps; ++tap) {
|
||||||
|
const uint32_t next = earlyPos[tap] + 1u;
|
||||||
|
earlyPos[tap] = next < frame.earlyLength ? next : 0u;
|
||||||
|
}
|
||||||
|
if (frame.preDelayLength != 0) {
|
||||||
|
const uint32_t next = preDelayPos + 1u;
|
||||||
|
preDelayPos = next < frame.preDelayLength ? next : 0u;
|
||||||
|
}
|
||||||
|
for (uint32_t comb = 0; comb < kCombs; ++comb) {
|
||||||
|
const uint32_t next = combPos[comb] + 1u;
|
||||||
|
combPos[comb] = next < frame.combLength[comb] ? next : 0u;
|
||||||
|
}
|
||||||
|
for (uint32_t allpass = 0; allpass < kAllpasses; ++allpass) {
|
||||||
|
const uint32_t next = allpassPos[allpass] + 1u;
|
||||||
|
allpassPos[allpass] = next < frame.allpassLength[allpass] ? next : 0u;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// The guest rewrites these every sample; nothing can observe the intermediate
|
||||||
|
// values, so one store per field at the end is equivalent.
|
||||||
|
for (uint32_t tap = 0; tap < kEarlyTaps; ++tap) {
|
||||||
|
Memory::Write32(stateAddr + kFieldEarlyPos + tap * 4, earlyPos[tap]);
|
||||||
|
}
|
||||||
|
if (frame.preDelayLength != 0) {
|
||||||
|
Memory::Write32(stateAddr + kFieldPreDelayPos, preDelayPos);
|
||||||
|
}
|
||||||
|
for (uint32_t comb = 0; comb < kCombs; ++comb) {
|
||||||
|
Memory::Write32(stateAddr + kFieldCombPos + comb * 4, combPos[comb]);
|
||||||
|
}
|
||||||
|
for (uint32_t allpass = 0; allpass < kAllpasses; ++allpass) {
|
||||||
|
Memory::Write32(stateAddr + kFieldAllpassPos + allpass * 4, allpassPos[allpass]);
|
||||||
|
}
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
Memory::Write32(stateAddr + kFieldLastApPos + channel * 4, frame.lastApPos[channel]);
|
||||||
|
Memory::WriteFloat32(stateAddr + kFieldLastLpfOut + channel * 4,
|
||||||
|
static_cast<double>(frame.lastLpfOut[channel]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Every byte this callback may write, so a differential run can snapshot, replay
|
||||||
|
// and compare it. Ring lines are listed once per channel because the guest gives
|
||||||
|
// each channel its own buffer.
|
||||||
|
void CollectWritableRegions(const Frame& frame,
|
||||||
|
std::vector<std::pair<uint8_t*, size_t>>& regions) {
|
||||||
|
constexpr size_t kFrameBytes = kSamplesPerFrame * sizeof(int32_t);
|
||||||
|
for (uint32_t channel = 0; channel < kChannels; ++channel) {
|
||||||
|
regions.emplace_back(frame.main[channel], kFrameBytes);
|
||||||
|
if (frame.hasAuxOut) {
|
||||||
|
regions.emplace_back(frame.auxOut[channel], kFrameBytes);
|
||||||
|
}
|
||||||
|
regions.emplace_back(frame.early[channel],
|
||||||
|
static_cast<size_t>(frame.earlyLength) * sizeof(float));
|
||||||
|
if (frame.preDelayLength != 0) {
|
||||||
|
regions.emplace_back(frame.preDelay[channel],
|
||||||
|
static_cast<size_t>(frame.preDelayLength) * sizeof(float));
|
||||||
|
}
|
||||||
|
for (uint32_t comb = 0; comb < kCombs; ++comb) {
|
||||||
|
regions.emplace_back(frame.comb[channel][comb],
|
||||||
|
static_cast<size_t>(frame.combLength[comb]) * sizeof(float));
|
||||||
|
}
|
||||||
|
for (uint32_t allpass = 0; allpass < kAllpasses; ++allpass) {
|
||||||
|
regions.emplace_back(frame.allpass[channel][allpass],
|
||||||
|
static_cast<size_t>(frame.allpassLength[allpass]) * sizeof(float));
|
||||||
|
}
|
||||||
|
regions.emplace_back(frame.lastAp[channel],
|
||||||
|
static_cast<size_t>(frame.lastApLength[channel]) * sizeof(float));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bool VerificationEnabled() {
|
||||||
|
static const bool enabled = [] {
|
||||||
|
const char* value = std::getenv("MKW_VERIFY_AXFX_REVERB");
|
||||||
|
return value != nullptr && value[0] == '1';
|
||||||
|
}();
|
||||||
|
return enabled;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Runs the translated body and this port over identical state and compares every
|
||||||
|
// byte either can write, so a wrong field offset surfaces as a loud mismatch
|
||||||
|
// instead of subtly wrong audio. Validation only; off unless the env var is set.
|
||||||
|
void RenderVerified(CpuContext* ctx, uint32_t stateAddr, Frame& frame) {
|
||||||
|
std::vector<std::pair<uint8_t*, size_t>> regions;
|
||||||
|
CollectWritableRegions(frame, regions);
|
||||||
|
|
||||||
|
uint8_t* const stateHost = ResolveGuestThreadRange(stateAddr, kStateStructBytes);
|
||||||
|
if (!stateHost) {
|
||||||
|
Render(stateAddr, frame);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
regions.emplace_back(stateHost, kStateStructBytes);
|
||||||
|
|
||||||
|
std::vector<std::vector<uint8_t>> before(regions.size());
|
||||||
|
for (size_t i = 0; i < regions.size(); ++i) {
|
||||||
|
before[i].assign(regions[i].first, regions[i].first + regions[i].second);
|
||||||
|
}
|
||||||
|
|
||||||
|
const CpuContext savedContext = *ctx;
|
||||||
|
func_801284B4(ctx);
|
||||||
|
*ctx = savedContext;
|
||||||
|
|
||||||
|
std::vector<std::vector<uint8_t>> expected(regions.size());
|
||||||
|
for (size_t i = 0; i < regions.size(); ++i) {
|
||||||
|
expected[i].assign(regions[i].first, regions[i].first + regions[i].second);
|
||||||
|
std::memcpy(regions[i].first, before[i].data(), before[i].size());
|
||||||
|
}
|
||||||
|
|
||||||
|
Render(stateAddr, frame);
|
||||||
|
|
||||||
|
static bool reported = false;
|
||||||
|
if (reported) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
for (size_t i = 0; i < regions.size(); ++i) {
|
||||||
|
if (std::memcmp(regions[i].first, expected[i].data(), expected[i].size()) == 0) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
size_t offset = 0;
|
||||||
|
while (offset < expected[i].size() && regions[i].first[offset] == expected[i][offset]) {
|
||||||
|
++offset;
|
||||||
|
}
|
||||||
|
reported = true;
|
||||||
|
RT_LOGF(RT_TAG_AUDIO,
|
||||||
|
"AXFXReverbHiExp native output diverges from the translated body: "
|
||||||
|
"region %zu of %zu, first differing byte %zu of %zu\n",
|
||||||
|
i, regions.size(), offset, expected[i].size());
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace ReverbHi
|
||||||
} // namespace
|
} // namespace
|
||||||
|
|
||||||
extern "C" void AXFXReverbStdExpCallback_8012b830(CpuContext* ctx) {
|
extern "C" void AXFXReverbStdExpCallback_8012b830(CpuContext* ctx) {
|
||||||
@@ -373,3 +858,47 @@ extern "C" void AXFXReverbStdExpCallback_8012b830(CpuContext* ctx) {
|
|||||||
|
|
||||||
REGISTER_NATIVE_FUNCTION_AS(0x8012B830, AXFXReverbStdExpCallback_8012b830,
|
REGISTER_NATIVE_FUNCTION_AS(0x8012B830, AXFXReverbStdExpCallback_8012b830,
|
||||||
"AXFXReverbStdExpCallback_8012b830");
|
"AXFXReverbStdExpCallback_8012b830");
|
||||||
|
|
||||||
|
extern "C" void AXFXReverbHiExpCallback_801284b4(CpuContext* ctx) {
|
||||||
|
if (!ctx) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
const uint32_t buffersAddr = ctx->gpr[3];
|
||||||
|
const uint32_t stateAddr = ctx->gpr[4];
|
||||||
|
|
||||||
|
uint32_t flags = 0;
|
||||||
|
try {
|
||||||
|
flags = Memory::Read32(stateAddr + ReverbHi::kFieldFlags);
|
||||||
|
} catch (const Memory::AccessViolation&) {
|
||||||
|
func_801284B4(ctx);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if (flags != 0) {
|
||||||
|
// Reset request: the guest clears the "in progress" bit and skips the
|
||||||
|
// frame entirely.
|
||||||
|
Memory::Write32(stateAddr + ReverbHi::kFieldFlags, flags & ~2u);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
ReverbHi::Frame frame;
|
||||||
|
bool built = false;
|
||||||
|
try {
|
||||||
|
built = ReverbHi::BuildFrame(buffersAddr, stateAddr, frame);
|
||||||
|
} catch (const Memory::AccessViolation&) {
|
||||||
|
built = false;
|
||||||
|
}
|
||||||
|
if (!built) {
|
||||||
|
func_801284B4(ctx);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ReverbHi::VerificationEnabled()) {
|
||||||
|
ReverbHi::RenderVerified(ctx, stateAddr, frame);
|
||||||
|
} else {
|
||||||
|
ReverbHi::Render(stateAddr, frame);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
REGISTER_NATIVE_FUNCTION_AS(0x801284B4, AXFXReverbHiExpCallback_801284b4,
|
||||||
|
"AXFXReverbHiExpCallback_801284b4");
|
||||||
Reference in new issue
Block a user