mirror of
https://github.com/boykopovar/AnyPS5.git
synced 2026-11-05 13:20:11 +00:00
659 lines
44 KiB
C++
659 lines
44 KiB
C++
#include "prx/libSceAudioPropagation/include/Api.hpp"
|
|
#include "prx/libSceAudioPropagation/AudioPropagation.hpp"
|
|
|
|
#include <atomic>
|
|
#include <chrono>
|
|
#include <cstdarg>
|
|
#include <cstdint>
|
|
#include <thread>
|
|
#include <vector>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <limits>
|
|
#include <stdexcept>
|
|
|
|
#ifdef _WIN32
|
|
#include <windows.h>
|
|
#else
|
|
#include <dlfcn.h>
|
|
#endif
|
|
|
|
namespace {
|
|
|
|
void Require(bool condition, const char* message) {
|
|
if (!condition) {
|
|
std::fprintf(stderr, "AudioPropagation: %s\n", message);
|
|
std::abort();
|
|
}
|
|
}
|
|
|
|
template<typename TException, typename TCall>
|
|
void RequireThrows(TCall call, const char* message) {
|
|
try {
|
|
call();
|
|
} catch (const TException&) {
|
|
return;
|
|
} catch (...) {
|
|
Require(false, message);
|
|
}
|
|
Require(false, message);
|
|
}
|
|
|
|
void* Resolve(const char* name) {
|
|
#ifdef _WIN32
|
|
const HMODULE module = GetModuleHandleA("libSceAudioPropagation.prx");
|
|
Require(module != nullptr, "library module");
|
|
return reinterpret_cast<void*>(GetProcAddress(module, name));
|
|
#else
|
|
return dlsym(RTLD_DEFAULT, name);
|
|
#endif
|
|
}
|
|
|
|
AudioPropagationSystemMemory Memory() {
|
|
AudioPropagationSystemMemory memory{};
|
|
memory.desc = {AudioPropagation::SystemMemoryId, AudioPropagation::SystemMemorySize};
|
|
return memory;
|
|
}
|
|
|
|
AudioPropagation::Attribute Attribute(const void* value, std::size_t size) {
|
|
AudioPropagation::Attribute attribute{};
|
|
attribute.id = 0x20000;
|
|
attribute.value = value;
|
|
attribute.valueSize = size;
|
|
return attribute;
|
|
}
|
|
|
|
struct ReportProbe {
|
|
std::uint32_t calls = 0;
|
|
bool fieldsMatch = false;
|
|
int integerArgument = 0;
|
|
const char* stringArgument = nullptr;
|
|
double floatingArgument = 0.0;
|
|
};
|
|
|
|
#ifdef _WIN32
|
|
using TestVaList = __builtin_sysv_va_list;
|
|
#else
|
|
using TestVaList = std::va_list;
|
|
#endif
|
|
|
|
static_assert(sizeof(TestVaList) == sizeof(AudioPropagation::ReportArguments));
|
|
|
|
TestVaList& ReportArguments(AudioPropagation::ReportInfo* report) {
|
|
return *reinterpret_cast<TestVaList*>(&report->arguments);
|
|
}
|
|
|
|
struct MixedReportProbe {
|
|
std::uint32_t calls = 0;
|
|
int integer = 0;
|
|
double floating = 0.0;
|
|
const char* text = nullptr;
|
|
};
|
|
|
|
void APS5_VABI CaptureMixedReport(const AudioPropagation::ReportInfo* report, void* userData) {
|
|
auto& probe = *static_cast<MixedReportProbe*>(userData);
|
|
auto& arguments = ReportArguments(const_cast<AudioPropagation::ReportInfo*>(report));
|
|
probe.integer = va_arg(arguments, int);
|
|
probe.floating = va_arg(arguments, double);
|
|
probe.text = va_arg(arguments, const char*);
|
|
++probe.calls;
|
|
}
|
|
|
|
struct FloatingReportProbe {
|
|
std::uint32_t calls = 0;
|
|
std::array<double, 9> values{};
|
|
};
|
|
|
|
void APS5_VABI CaptureFloatingReport(const AudioPropagation::ReportInfo* report, void* userData) {
|
|
auto& probe = *static_cast<FloatingReportProbe*>(userData);
|
|
auto& arguments = ReportArguments(const_cast<AudioPropagation::ReportInfo*>(report));
|
|
for (auto& value : probe.values) value = va_arg(arguments, double);
|
|
++probe.calls;
|
|
}
|
|
|
|
struct IntegerReportProbe {
|
|
std::uint32_t calls = 0;
|
|
int integer = 0;
|
|
const char* text = nullptr;
|
|
};
|
|
|
|
void APS5_VABI CaptureIntegerReport(const AudioPropagation::ReportInfo* report, void* userData) {
|
|
auto& probe = *static_cast<IntegerReportProbe*>(userData);
|
|
auto& arguments = ReportArguments(const_cast<AudioPropagation::ReportInfo*>(report));
|
|
probe.integer = va_arg(arguments, int);
|
|
probe.text = va_arg(arguments, const char*);
|
|
++probe.calls;
|
|
}
|
|
|
|
void APS5_VABI CountReport(const AudioPropagation::ReportInfo*, void* userData) {
|
|
++*static_cast<std::uint32_t*>(userData);
|
|
}
|
|
|
|
void APS5_VABI CaptureReport(const AudioPropagation::ReportInfo* report, void* userData) {
|
|
auto& probe = *static_cast<ReportProbe*>(userData);
|
|
++probe.calls;
|
|
probe.fieldsMatch = report && report->size == sizeof(*report) && report->handle == 0x1234 &&
|
|
report->category == 0 && report->result == -7 && report->operation == 9 &&
|
|
report->function && std::strcmp(report->function, "sceAudioPropagationTest") == 0 &&
|
|
report->format && std::strcmp(report->format, "%d %s %f") == 0;
|
|
std::memcpy(&probe.integerArgument, report->arguments.overflowArguments, sizeof(probe.integerArgument));
|
|
std::memcpy(&probe.stringArgument, static_cast<const std::byte*>(report->arguments.overflowArguments) + sizeof(std::uint64_t), sizeof(probe.stringArgument));
|
|
std::memcpy(&probe.floatingArgument, static_cast<const std::byte*>(report->arguments.savedRegisters) + 48, sizeof(probe.floatingArgument));
|
|
}
|
|
|
|
struct SelfUnregisterProbe {
|
|
AudioPropagation::ReportRegistration* registration = nullptr;
|
|
std::uint32_t calls = 0;
|
|
};
|
|
|
|
void APS5_VABI SelfUnregisterReport(const AudioPropagation::ReportInfo*, void* userData) {
|
|
auto& probe = *static_cast<SelfUnregisterProbe*>(userData);
|
|
++probe.calls;
|
|
Require(sceAudioPropagationReportUnregisterHandler(probe.registration) == 0, "report self-unregister failed");
|
|
}
|
|
|
|
struct BlockingReportProbe {
|
|
std::atomic<bool> entered{false};
|
|
std::atomic<bool> release{false};
|
|
std::atomic<std::uint32_t> calls{0};
|
|
};
|
|
|
|
void APS5_VABI BlockingReport(const AudioPropagation::ReportInfo*, void* userData) {
|
|
auto& probe = *static_cast<BlockingReportProbe*>(userData);
|
|
probe.calls.fetch_add(1, std::memory_order_relaxed);
|
|
probe.entered.store(true, std::memory_order_release);
|
|
while (!probe.release.load(std::memory_order_acquire)) std::this_thread::yield();
|
|
}
|
|
|
|
}
|
|
|
|
int main() {
|
|
const AudioPropagation::SystemOptions options{{AudioPropagation::SystemOptionsId, AudioPropagation::SystemOptionsSize}, 2, 2, 6, 1, 256, 343.0f, 343.0f, 0, {}};
|
|
|
|
auto memory = Memory();
|
|
Require(sceAudioPropagationSystemQueryMemory(&options, &memory) == 0, "query memory failed");
|
|
Require(memory.size_cpu_mem == 557264, "native CPU memory size mismatch");
|
|
std::vector<std::uint64_t> arenaStorage((memory.size_cpu_mem + 7) / 8);
|
|
auto* arena = reinterpret_cast<std::uint8_t*>(arenaStorage.data());
|
|
Require(memory.size_gpu_mem == 0 && memory.p_cpu_mem == nullptr && memory.p_gpu_mem == nullptr, "query wrote more than the sizes");
|
|
Require(sceAudioPropagationSystemQueryMemory(nullptr, &memory) == AudioPropagation::ErrorNullPointer, "null options");
|
|
Require(sceAudioPropagationSystemQueryMemory(&options, nullptr) == AudioPropagation::ErrorNullPointer, "null memory");
|
|
auto wrong = Memory();
|
|
wrong.desc.size = 0x28;
|
|
Require(sceAudioPropagationSystemQueryMemory(&options, &wrong) == static_cast<std::int32_t>(0x8A700007), "wrong descriptor size");
|
|
wrong = Memory();
|
|
wrong.desc.id = AudioPropagation::RayId;
|
|
Require(sceAudioPropagationSystemQueryMemory(&options, &wrong) == static_cast<std::int32_t>(0x8A700007), "wrong descriptor id");
|
|
|
|
auto probeOptions = options;
|
|
auto probeMemory = Memory();
|
|
probeMemory.p_cpu_mem = arena;
|
|
probeMemory.p_gpu_mem = arena;
|
|
probeOptions.maxSources = 0;
|
|
Require(sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory) == AudioPropagation::ErrorInvalidArgument, "zero source capacity accepted");
|
|
Require(probeMemory.p_cpu_mem == nullptr && probeMemory.p_gpu_mem == nullptr && probeMemory.size_cpu_mem == 0 && probeMemory.size_gpu_mem == 0, "invalid options did not clear memory output");
|
|
probeOptions = options;
|
|
probeOptions.parameter24 = 7;
|
|
Require(sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory) == AudioPropagation::ErrorInvalidArgument, "unsupported parameter accepted");
|
|
probeOptions = options;
|
|
probeOptions.frameSamples = 768;
|
|
Require(sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory) == AudioPropagation::ErrorInvalidArgument, "unsupported frame size accepted");
|
|
probeOptions = options;
|
|
probeOptions.propagationSpeed = 0x1p-23f;
|
|
Require(sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory) == AudioPropagation::ErrorInvalidArgument, "invalid propagation speed accepted");
|
|
probeOptions = options;
|
|
probeOptions.frameSamples = 512;
|
|
Require(sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory) == 0 && probeMemory.size_cpu_mem == 524432, "512 sample memory size mismatch");
|
|
probeOptions = options;
|
|
probeOptions.reflectionOrder = 2;
|
|
Require(sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory) == 0 && probeMemory.size_cpu_mem == 1110608, "second order memory size mismatch");
|
|
probeOptions = options;
|
|
probeOptions.flags = 30;
|
|
Require(sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory) == 0 && probeMemory.size_cpu_mem == 2604064, "option memory sizes mismatch");
|
|
probeOptions.flags = 1;
|
|
Require(sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory) == AudioPropagation::ErrorInvalidArgument, "GPU frame size constraint ignored");
|
|
probeOptions.frameSamples = 512;
|
|
RequireThrows<std::runtime_error>([&] { sceAudioPropagationSystemQueryMemory(&probeOptions, &probeMemory); }, "unknown GPU memory query returned a size");
|
|
|
|
AudioPropagationHandle system = 0;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemCreate(&options, &memory, &system); }, "create without cpu memory");
|
|
memory.p_cpu_mem = arena + 1;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemCreate(&options, &memory, &system); }, "misaligned cpu memory");
|
|
memory.p_cpu_mem = arena;
|
|
memory.size_gpu_mem = 16;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemCreate(&options, &memory, &system); }, "unrequested gpu memory");
|
|
memory.size_gpu_mem = 0;
|
|
const auto required = memory.size_cpu_mem;
|
|
memory.size_cpu_mem = required - 1;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemCreate(&options, &memory, &system); }, "cpu memory too small");
|
|
memory.size_cpu_mem = required;
|
|
Require(sceAudioPropagationSystemCreate(&options, &memory, &system) == 0, "create failed");
|
|
Require(system == reinterpret_cast<std::uintptr_t>(arena), "system handle is not its memory");
|
|
AudioPropagation::SystemInfo systemInfo{};
|
|
systemInfo.reserved44 = 0xdeadbeef;
|
|
Require(sceAudioPropagationSystemQueryInfo(system, &systemInfo, sizeof(systemInfo)) == 0, "system query info failed");
|
|
Require(systemInfo.cpuMemory == arena && systemInfo.cpuMemorySize == memory.size_cpu_mem && systemInfo.index == 0, "system query info memory or index");
|
|
Require(systemInfo.frameSamples == options.frameSamples && systemInfo.parameter24 == 1 && systemInfo.maxSources == options.maxSources, "system query info options");
|
|
Require(systemInfo.maxMaterials == options.maxMaterials && systemInfo.pathCapacityPerSource == 6 && systemInfo.propagationSpeed == options.propagationSpeed, "system query info capacities");
|
|
Require(systemInfo.reserved44 == 0xdeadbeef, "system query info overwrote reserved output");
|
|
Require(sceAudioPropagationSystemQueryInfo(system, &systemInfo, sizeof(systemInfo) - 1) == AudioPropagation::ErrorInvalidHandle, "system query info accepted wrong size");
|
|
Require(sceAudioPropagationSystemQueryInfo(system, nullptr, sizeof(systemInfo)) == AudioPropagation::ErrorInvalidHandle, "system query info accepted null output");
|
|
Require(sceAudioPropagationSystemUnlock(system) == AudioPropagation::ErrorInvalidArgument, "unbalanced system unlock was accepted");
|
|
Require(sceAudioPropagationSystemLock(system) == 0, "system lock failed");
|
|
Require(sceAudioPropagationSystemLock(system) == 0, "recursive system lock failed");
|
|
Require(sceAudioPropagationSystemDestroy(system) == AudioPropagation::ErrorInvalidArgument, "same-thread destroy under system lock was accepted");
|
|
std::atomic<std::int32_t> crossThreadUnlock{0};
|
|
std::thread wrongUnlocker([&] { crossThreadUnlock.store(sceAudioPropagationSystemUnlock(system), std::memory_order_release); });
|
|
wrongUnlocker.join();
|
|
Require(crossThreadUnlock.load(std::memory_order_acquire) == AudioPropagation::ErrorInvalidArgument, "cross-thread system unlock was accepted");
|
|
Require(sceAudioPropagationSystemUnlock(system) == 0, "first recursive system unlock failed");
|
|
Require(sceAudioPropagationSystemUnlock(system) == 0, "system unlock failed");
|
|
Require(sceAudioPropagationSystemLock(system + 16) == AudioPropagation::ErrorInvalidHandle, "invalid system lock result");
|
|
Require(sceAudioPropagationSystemUnlock(system + 16) == AudioPropagation::ErrorInvalidHandle, "invalid system unlock result");
|
|
Require(sceAudioPropagationSystemEnumHandles(nullptr, 0) == 1, "system handle count");
|
|
Require(sceAudioPropagationSystemEnumHandles(nullptr, 1) == AudioPropagation::ErrorInvalidArgument, "null handle array with capacity");
|
|
AudioPropagationHandle enumerated[2]{};
|
|
Require(sceAudioPropagationSystemEnumHandles(enumerated, 1) == 1 && enumerated[0] == system, "single system enumeration");
|
|
AudioPropagationHandle twice = 0;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemCreate(&options, &memory, &twice); }, "second system in the same memory");
|
|
|
|
const std::uint64_t value = 1;
|
|
const auto attribute = Attribute(&value, sizeof(value));
|
|
const auto empty = Attribute(nullptr, sizeof(value));
|
|
Require(sceAudioPropagationSystemSetAttributes(system, &attribute, 1) == 0, "system attributes failed");
|
|
Require(sceAudioPropagationSystemSetAttributes(system, nullptr, 0) == 0, "empty system attributes failed");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemSetAttributes(system, &empty, 1); }, "attribute without value");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemSetAttributes(system + 16, &attribute, 1); }, "unknown system");
|
|
|
|
std::uint8_t materialBytes[AudioPropagation::MaterialSize]{};
|
|
auto* material = reinterpret_cast<AudioPropagationStructDescriptor*>(materialBytes);
|
|
AudioPropagationHandle materialHandle = 0;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemRegisterMaterial(system, material, &materialHandle); }, "material without descriptor");
|
|
*material = {AudioPropagation::MaterialId, AudioPropagation::MaterialSize};
|
|
Require(sceAudioPropagationSystemRegisterMaterial(system, material, &materialHandle) == 0 && materialHandle != 0, "register material failed");
|
|
Require(sceAudioPropagationSystemUnregisterMaterial(materialHandle) == 0, "unregister material failed");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemUnregisterMaterial(materialHandle); }, "unregister twice");
|
|
|
|
AudioPropagationHandle rooms[2]{};
|
|
Require(sceAudioPropagationRoomCreate(system, &rooms[0]) == 0 && sceAudioPropagationRoomCreate(system, &rooms[1]) == 0, "room create failed");
|
|
Require(rooms[0] != 0 && rooms[0] != rooms[1], "room handles are not distinct");
|
|
AudioPropagation::PortalParams portalParams{};
|
|
portalParams.desc = {AudioPropagation::PortalParamsId, AudioPropagation::PortalParamsSize};
|
|
portalParams.rooms[0] = rooms[0];
|
|
portalParams.rooms[1] = materialHandle;
|
|
AudioPropagationHandle portal = 0;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationPortalCreate(system, &portalParams, &portal); }, "portal to a non-room");
|
|
portalParams.rooms[1] = rooms[1];
|
|
Require(sceAudioPropagationPortalCreate(system, &portalParams, &portal) == 0, "portal create failed");
|
|
const AudioPropagation::Attribute portalAttributes[4]{attribute, attribute, attribute, attribute};
|
|
Require(sceAudioPropagationPortalSetAttributes(portal, portalAttributes, 4) == 0, "portal attributes failed");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationPortalSetAttributes(rooms[0], portalAttributes, 4); }, "portal attributes on a room");
|
|
|
|
AudioPropagationHandle source = 0;
|
|
Require(sceAudioPropagationSourceCreate(system, &source) == 0, "source create failed");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceCreate(system, nullptr); }, "source without output");
|
|
Require(sceAudioPropagationSourceSetAttributes(source, portalAttributes, 3) == 0, "source attributes failed");
|
|
std::uint32_t count = 7;
|
|
Require(sceAudioPropagationSourceGetAudioPathCount(source, &count) == 0 && count == AudioPropagation::MaxPaths, "source path pool size");
|
|
AudioPropagationHandle path = 0;
|
|
Require(sceAudioPropagationSourceGetAudioPath(source, 0, &path) == 0 && path != 0, "path lookup immediately after source creation");
|
|
AudioPropagationHandle repeated = 0;
|
|
Require(sceAudioPropagationSourceGetAudioPath(source, 0, &repeated) == 0 && repeated == path, "path handle is unstable");
|
|
AudioPropagationHandle lastPath = 0;
|
|
Require(sceAudioPropagationSourceGetAudioPath(source, AudioPropagation::MaxPaths - 1, &lastPath) == 0 && lastPath != path, "last path slot");
|
|
Require(sceAudioPropagationSourceGetAudioPath(source, AudioPropagation::MaxPaths, &repeated) == AudioPropagation::ErrorInvalidArgument, "out of range path slot");
|
|
Require(repeated == path, "rejected path lookup changed the output");
|
|
Require(sceAudioPropagationSourceGetAudioPath(source, 0, nullptr) == AudioPropagation::ErrorNullPointer, "null path output");
|
|
Require(sceAudioPropagationSourceGetAudioPath(0, 0, nullptr) == AudioPropagation::ErrorInvalidHandle, "path lookup handle precedence");
|
|
Require(sceAudioPropagationPathGetNumPoints(path, &count) == 0 && count == 0, "initial path has points");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationPathGetNumPoints(source, &count); }, "source used as a path");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationPathGetNumPoints(path, nullptr); }, "null point-count output");
|
|
AudioPropagation::AudioPath configured{};
|
|
configured.desc = {AudioPropagation::PathId, sizeof(configured)};
|
|
configured.pointCount = 2;
|
|
configured.flags = AudioPropagation::PathInvalid;
|
|
for (auto& point : configured.points) {
|
|
point.desc = {AudioPropagation::PathPointId, sizeof(point)};
|
|
point.gain = 1.0f;
|
|
}
|
|
configured.points[0].room = rooms[0];
|
|
configured.points[0].opaque[0] = std::byte{0x7f};
|
|
configured.opaque[0] = std::byte{0x55};
|
|
configured.points[0].position[0] = 3.0f;
|
|
Require(sceAudioPropagationSourceSetAudioPath(path, &configured, 1.0f) == 0, "path configuration");
|
|
configured.pointCount = 0;
|
|
Require(sceAudioPropagationPathGetNumPoints(path, &count) == 0 && count == 2, "path configuration aliases caller memory");
|
|
configured.pointCount = 2;
|
|
auto badPath = configured;
|
|
badPath.desc.size--;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAudioPath(path, &badPath, 1.0f); }, "wrong path size");
|
|
badPath = configured;
|
|
badPath.pointCount = AudioPropagation::MaxPathPoints + 1;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAudioPath(path, &badPath, 1.0f); }, "too many path points");
|
|
badPath = configured;
|
|
AudioPropagationHandle pathMaterial = 0;
|
|
Require(sceAudioPropagationSystemRegisterMaterial(system, material, &pathMaterial) == 0, "path material creation");
|
|
badPath.points[0].room = pathMaterial;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAudioPath(path, &badPath, 1.0f); }, "material used as a path room");
|
|
Require(sceAudioPropagationSystemUnregisterMaterial(pathMaterial) == 0, "path material cleanup");
|
|
badPath = configured;
|
|
badPath.points[0].position[0] = std::numeric_limits<float>::infinity();
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAudioPath(path, &badPath, 1.0f); }, "nonfinite point position");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAudioPath(path, &configured, std::numeric_limits<float>::quiet_NaN()); }, "nonfinite path gain");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAudioPath(path, nullptr, 1.0f); }, "null path data");
|
|
Require(sceAudioPropagationPathGetNumPoints(path, &count) == 0 && count == 2, "rejected update changed path state");
|
|
|
|
std::uint8_t rays[AudioPropagation::RaySize * 2]{};
|
|
count = 7;
|
|
Require(sceAudioPropagationSystemGetRays(system, rays, &count) == 0 && count == 0, "system requested rays");
|
|
count = 7;
|
|
Require(sceAudioPropagationSourceGetRays(source, rays, &count) == 0 && count == 0, "source requested rays");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceGetRays(source, rays, nullptr); }, "rays without count");
|
|
Require(sceAudioPropagationSystemSetRays(system, rays, 0) == 0, "empty ray results failed");
|
|
RequireThrows<std::runtime_error>([&] { sceAudioPropagationSystemSetRays(system, rays, 1); }, "unrequested ray results");
|
|
Require(sceAudioPropagationSourceCalculateAudioPaths(source, rays, 0, 1, nullptr, 0) == AudioPropagation::ErrorNullPointer, "path calculation null output");
|
|
Require(sceAudioPropagationSourceCalculateAudioPaths(0, nullptr, 0, 0, nullptr, 0) == AudioPropagation::ErrorInvalidHandle, "path calculation handle precedence");
|
|
Require(sceAudioPropagationSourceCalculateAudioPaths(source, rays, 0, 1, rays, 6) == AudioPropagation::ErrorInvalidArgument, "path calculation empty rays");
|
|
Require(sceAudioPropagationSourceCalculateAudioPaths(source, rays, 6, 0, rays, 6) == AudioPropagation::ErrorInvalidArgument, "path calculation zero reflection order");
|
|
Require(sceAudioPropagationSourceCalculateAudioPaths(source, rays, 6, 1, rays, 0) == AudioPropagation::ErrorInvalidArgument, "path calculation zero output capacity");
|
|
Require(sceAudioPropagationSourceSetAudioPaths(source, nullptr, 0) == 0, "empty audio paths failed");
|
|
RequireThrows<std::runtime_error>([&] { sceAudioPropagationSourceSetAudioPaths(source, rays, 1); }, "set audio paths");
|
|
|
|
std::vector<std::uint64_t> otherArenaStorage(arenaStorage.size());
|
|
auto* otherArena = reinterpret_cast<std::uint8_t*>(otherArenaStorage.data());
|
|
auto otherMemory = Memory();
|
|
Require(sceAudioPropagationSystemQueryMemory(&options, &otherMemory) == 0, "second query memory failed");
|
|
otherMemory.p_cpu_mem = otherArena;
|
|
AudioPropagationHandle otherSystem = 0;
|
|
Require(sceAudioPropagationSystemCreate(&options, &otherMemory, &otherSystem) == 0, "second system create failed");
|
|
AudioPropagationHandle enumeratedSystems[2]{};
|
|
Require(sceAudioPropagationSystemEnumHandles(enumeratedSystems, 2) == 2 && enumeratedSystems[0] == otherSystem && enumeratedSystems[1] == system, "system enumeration is not newest first");
|
|
Require(sceAudioPropagationSystemQueryInfo(otherSystem, &systemInfo, sizeof(systemInfo)) == 0 && systemInfo.index == 1, "second system slot index");
|
|
AudioPropagationHandle otherSource = 0;
|
|
Require(sceAudioPropagationSourceCreate(otherSystem, &otherSource) == 0, "second system source create failed");
|
|
AudioPropagationHandle foreignRoom = 0;
|
|
Require(sceAudioPropagationRoomCreate(otherSystem, &foreignRoom) == 0, "foreign room create failed");
|
|
badPath = configured;
|
|
badPath.points[0].room = foreignRoom;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAudioPath(path, &badPath, 1.0f); }, "room from another system");
|
|
Require(sceAudioPropagationRoomDestroy(otherSystem, foreignRoom) == 0, "foreign room cleanup");
|
|
Require(sceAudioPropagationPathGetNumPoints(path, &count) == 0 && count == 2, "cross-system rejection changed path state");
|
|
AudioPropagationHandle secondSource = 0;
|
|
Require(sceAudioPropagationSourceCreate(system, &secondSource) == 0, "second source create failed");
|
|
|
|
constexpr std::size_t frameValues = 256 * 16;
|
|
float outputs[2][frameValues + 16];
|
|
float expected[2][frameValues + 16];
|
|
const auto fill = [&] {
|
|
for (std::size_t channel = 0; channel < 2; ++channel) {
|
|
for (std::size_t sample = 0; sample < frameValues + 16; ++sample) {
|
|
outputs[channel][sample] = static_cast<float>(sample + 1) / (channel == 0 ? 128.0f : -128.0f);
|
|
}
|
|
}
|
|
std::memcpy(expected, outputs, sizeof(outputs));
|
|
};
|
|
const auto untouched = [&] { return std::memcmp(outputs, expected, sizeof(outputs)) == 0; };
|
|
AudioPropagation::RenderInfo infos[2]{};
|
|
const auto reset = [&] {
|
|
infos[0] = {{AudioPropagation::RenderInfoId, AudioPropagation::RenderInfoSize}, source, outputs[0], sizeof(outputs[0]), AudioPropagation::RenderFormat, 0};
|
|
infos[1] = {{AudioPropagation::RenderInfoId, AudioPropagation::RenderInfoSize}, secondSource, outputs[1], sizeof(outputs[1]), AudioPropagation::RenderFormat, 0};
|
|
fill();
|
|
};
|
|
reset();
|
|
Require(sceAudioPropagationSourceRender(system, infos, 1) == 0, "render failed");
|
|
Require(untouched(), "empty source erased an existing mix");
|
|
infos[0].channelCount = 99;
|
|
Require(sceAudioPropagationSourceRender(system, infos, 1) == 0 && infos[0].channelCount == 0, "fixed render format clears the channel count");
|
|
Require(untouched(), "render wrote past the output size");
|
|
reset();
|
|
infos[0].outputSize = sizeof(float) * (frameValues - 1);
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 2); }, "short frame output accepted");
|
|
Require(untouched(), "short output modified a render buffer");
|
|
reset();
|
|
infos[0].outputSize = sizeof(float) * frameValues;
|
|
Require(sceAudioPropagationSourceRender(system, infos, 2) == 0, "render of two sources failed");
|
|
Require(untouched(), "empty sources modified separate destination mixes or their tails");
|
|
reset();
|
|
infos[1].output = outputs[0];
|
|
Require(sceAudioPropagationSourceRender(system, infos, 2) == 0, "render into a shared mix failed");
|
|
Require(untouched(), "empty sources modified a shared destination mix");
|
|
reset();
|
|
infos[0].outputSize = sizeof(float) * frameValues;
|
|
infos[1].output = outputs[0] + 16;
|
|
infos[1].outputSize = sizeof(float) * frameValues;
|
|
Require(sceAudioPropagationSourceRender(system, infos, 2) == 0, "render into overlapping mixes failed");
|
|
Require(untouched(), "empty sources modified overlapping destination mixes");
|
|
reset();
|
|
std::memset(outputs, 0, sizeof(outputs));
|
|
std::memcpy(expected, outputs, sizeof(outputs));
|
|
Require(sceAudioPropagationSourceRender(system, infos, 2) == 0, "render into silence failed");
|
|
Require(untouched(), "empty sources modified a silent destination mix");
|
|
|
|
reset();
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 0); }, "render without infos");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 3); }, "render exceeds source capacity");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, nullptr, 1); }, "render with null infos");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system + 16, infos, 1); }, "render on an unknown system");
|
|
infos[1].desc.id = AudioPropagation::RayId;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 2); }, "render info with a wrong descriptor id");
|
|
Require(untouched(), "rejected render wrote an output");
|
|
reset();
|
|
infos[0].desc.size = 0x28;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 1); }, "render info with a wrong descriptor size");
|
|
reset();
|
|
infos[0].source = rooms[0];
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 1); }, "render of a room");
|
|
reset();
|
|
infos[0].source = otherSource;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 1); }, "render of another system's source");
|
|
reset();
|
|
infos[0].output = nullptr;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 1); }, "render without output");
|
|
reset();
|
|
infos[0].outputSize = 0;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 1); }, "render with an empty output");
|
|
for (const std::uint32_t format : {0u, 1u, 2u, 4u, 5u}) {
|
|
reset();
|
|
infos[0].format = format;
|
|
const std::size_t channels = format == 0 ? 4 : format == 1 ? 9 : format == 2 ? 16 : 8;
|
|
infos[0].outputSize = sizeof(float) * options.frameSamples * channels;
|
|
Require(sceAudioPropagationSourceRender(system, infos, 1) == 0, "render in a known format failed");
|
|
Require(untouched(), "empty source modified a mix in a known format");
|
|
infos[0].outputSize -= sizeof(float) * channels;
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 1); }, "known format accepted an undersized frame");
|
|
Require(untouched(), "undersized known-format output modified a mix");
|
|
}
|
|
reset();
|
|
infos[0].format = 1;
|
|
infos[0].outputSize = sizeof(float) * (options.frameSamples * 9 + 1);
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 1); }, "render of a partial nine-channel frame");
|
|
Require(untouched(), "render of a partial frame wrote an output");
|
|
for (const std::uint32_t format : {3u, 6u}) {
|
|
reset();
|
|
infos[1].format = format;
|
|
RequireThrows<std::runtime_error>([&] { sceAudioPropagationSourceRender(system, infos, 2); }, "render with an unknown format");
|
|
Require(untouched(), "render with an unknown format wrote an output");
|
|
}
|
|
|
|
reset();
|
|
configured.flags = 0;
|
|
Require(sceAudioPropagationSourceSetAudioPath(path, &configured, 1.0f) == 0, "active path configuration");
|
|
RequireThrows<std::runtime_error>([&] { sceAudioPropagationSourceRender(system, infos, 2); }, "active path silently rendered");
|
|
Require(untouched(), "unsupported active-path render modified output");
|
|
configured.flags = AudioPropagation::PathInvalid;
|
|
Require(sceAudioPropagationSourceSetAudioPath(path, &configured, 1.0f) == 0, "invalidating path");
|
|
|
|
Require(sceAudioPropagationSourceDestroy(system, secondSource) == 0, "second source destroy failed");
|
|
reset();
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceRender(system, infos, 2); }, "render of a destroyed source");
|
|
Require(sceAudioPropagationSystemDestroy(otherSystem) == 0, "second system destroy failed");
|
|
Require(sceAudioPropagationSystemEnumHandles(enumeratedSystems, 2) == 1 && enumeratedSystems[0] == system, "destroyed system remained enumerated");
|
|
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationRoomDestroy(system, source); }, "room destroy of a source");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceDestroy(system + 16, source); }, "source destroy with another system");
|
|
Require(sceAudioPropagationPortalDestroy(system, portal) == 0, "portal destroy failed");
|
|
Require(sceAudioPropagationSourceDestroy(system, source) == 0, "source destroy failed");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationPathGetNumPoints(path, &count); }, "path survived source destruction");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAudioPath(lastPath, &configured, 1.0f); }, "path update after source destruction");
|
|
Require(sceAudioPropagationRoomDestroy(system, rooms[0]) == 0, "room destroy failed");
|
|
|
|
AudioPropagationHandle lateSource = 0;
|
|
AudioPropagationHandle lateMaterial = 0;
|
|
Require(sceAudioPropagationSourceCreate(system, &lateSource) == 0, "late source create failed");
|
|
AudioPropagationHandle latePath = 0;
|
|
Require(sceAudioPropagationSourceGetAudioPath(lateSource, 0, &latePath) == 0 && latePath != path, "path handle reuse");
|
|
Require(sceAudioPropagationSystemRegisterMaterial(system, material, &lateMaterial) == 0, "late material register failed");
|
|
Require(sceAudioPropagationSystemDestroy(system) == 0, "system destroy failed");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationPathGetNumPoints(latePath, &count); }, "path survived system destruction");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceSetAttributes(lateSource, &attribute, 1); }, "source used after its system");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationRoomDestroy(system, lateSource); }, "orphan destroyed as the wrong kind");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceDestroy(system + 16, lateSource); }, "orphan destroyed with another system");
|
|
Require(sceAudioPropagationRoomDestroy(system, rooms[1]) == 0, "orphaned room destroy is not a no-op");
|
|
Require(sceAudioPropagationSourceDestroy(system, lateSource) == 0, "orphaned source destroy is not a no-op");
|
|
Require(sceAudioPropagationSystemUnregisterMaterial(lateMaterial) == 0, "orphaned material unregister is not a no-op");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSourceDestroy(system, lateSource); }, "orphan destroyed twice");
|
|
RequireThrows<std::invalid_argument>([&] { sceAudioPropagationSystemDestroy(system); }, "destroy twice");
|
|
Require(sceAudioPropagationSystemCreate(&options, &memory, &system) == 0, "memory reuse after destroy failed");
|
|
Require(sceAudioPropagationSystemQueryInfo(system, &systemInfo, sizeof(systemInfo)) == 0 && systemInfo.index == 0, "system slot was not reused");
|
|
Require(sceAudioPropagationSystemLock(system) == 0, "system lock before destroy failed");
|
|
std::atomic<bool> destroyStarted{false};
|
|
std::atomic<bool> destroyFinished{false};
|
|
std::thread destroyThread([&] {
|
|
destroyStarted.store(true, std::memory_order_release);
|
|
Require(sceAudioPropagationSystemDestroy(system) == 0, "concurrent system destroy failed");
|
|
destroyFinished.store(true, std::memory_order_release);
|
|
});
|
|
while (!destroyStarted.load(std::memory_order_acquire)) std::this_thread::yield();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(30));
|
|
Require(!destroyFinished.load(std::memory_order_acquire), "system destroy ignored the held lock");
|
|
Require(sceAudioPropagationSystemUnlock(system) == 0, "system unlock before destroy failed");
|
|
destroyThread.join();
|
|
Require(destroyFinished.load(std::memory_order_acquire), "system destroy did not finish");
|
|
|
|
Require(sceAudioPropagationSystemCreate(&options, &memory, &system) == 0, "create for stale lock waiter failed");
|
|
Require(sceAudioPropagationSystemLock(system) == 0, "system lock before stale waiter failed");
|
|
std::atomic<bool> waiterStarted{false};
|
|
std::atomic<bool> waiterFinished{false};
|
|
std::atomic<std::int32_t> waiterResult{0};
|
|
std::thread waiter([&] {
|
|
waiterStarted.store(true, std::memory_order_release);
|
|
const auto result = sceAudioPropagationSystemLock(system);
|
|
waiterResult.store(result, std::memory_order_release);
|
|
if (result == 0) Require(sceAudioPropagationSystemUnlock(system) == 0, "stale lock waiter cleanup failed");
|
|
waiterFinished.store(true, std::memory_order_release);
|
|
});
|
|
while (!waiterStarted.load(std::memory_order_acquire)) std::this_thread::yield();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(30));
|
|
std::atomic<bool> reuseDestroyStarted{false};
|
|
std::thread reuseDestroyer([&] {
|
|
reuseDestroyStarted.store(true, std::memory_order_release);
|
|
Require(sceAudioPropagationSystemDestroy(system) == 0, "destroy with a blocked lock waiter failed");
|
|
});
|
|
while (!reuseDestroyStarted.load(std::memory_order_acquire)) std::this_thread::yield();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(30));
|
|
Require(sceAudioPropagationSystemUnlock(system) == 0, "unlock before address reuse failed");
|
|
reuseDestroyer.join();
|
|
waiter.join();
|
|
Require(waiterFinished.load(std::memory_order_acquire) && waiterResult.load(std::memory_order_acquire) == AudioPropagation::ErrorInvalidHandle, "waiter acquired a destroyed system lock");
|
|
Require(sceAudioPropagationSystemCreate(&options, &memory, &system) == 0, "create at reused system address failed");
|
|
Require(sceAudioPropagationSystemLock(system) == 0 && sceAudioPropagationSystemUnlock(system) == 0, "new system lock was affected by a stale waiter");
|
|
Require(sceAudioPropagationSystemDestroy(system) == 0, "destroy after address reuse failed");
|
|
|
|
Require(sceAudioPropagationSystemLock(0) == AudioPropagation::ErrorInvalidHandle, "system lock invalid handle");
|
|
|
|
ReportProbe probe{};
|
|
AudioPropagation::ReportRegistration* registration = nullptr;
|
|
Require(sceAudioPropagationReportRegisterHandler(2, CaptureReport, &probe, ®istration) == -4, "invalid report category");
|
|
Require(sceAudioPropagationReportRegisterHandler(0, nullptr, &probe, ®istration) == -2, "null report handler");
|
|
Require(sceAudioPropagationReportRegisterHandler(0, CaptureReport, &probe, ®istration) == 0 && registration, "report handler registration");
|
|
Require(sceAudioPropagationReportApi(0, 0x1234, -7, 9, "sceAudioPropagationTest", "%d %s %f", 42, "ok", 3.25) == 0, "report dispatch");
|
|
Require(probe.calls == 1 && probe.fieldsMatch && probe.integerArgument == 42 && std::strcmp(probe.stringArgument, "ok") == 0 && probe.floatingArgument == 3.25, "report info or va_list capture");
|
|
Require(sceAudioPropagationReportUnregisterHandler(registration) == 0, "report handler unregister");
|
|
Require(sceAudioPropagationReportUnregisterHandler(registration) == -1, "duplicate report handler unregister");
|
|
Require(sceAudioPropagationReportUnregisterHandler(nullptr) == -1, "null report registration");
|
|
|
|
MixedReportProbe firstMixed{};
|
|
MixedReportProbe secondMixed{};
|
|
AudioPropagation::ReportRegistration* firstMixedRegistration = nullptr;
|
|
AudioPropagation::ReportRegistration* secondMixedRegistration = nullptr;
|
|
Require(sceAudioPropagationReportRegisterHandler(0, CaptureMixedReport, &firstMixed, &firstMixedRegistration) == 0, "first mixed report registration");
|
|
Require(sceAudioPropagationReportRegisterHandler(0, CaptureMixedReport, &secondMixed, &secondMixedRegistration) == 0, "second mixed report registration");
|
|
Require(sceAudioPropagationReportApi(0, 0, 0, 0, "mixed", "%d %f %s", 27, 6.5, "independent") == 0, "mixed report dispatch");
|
|
for (const auto* probeValue : {&firstMixed, &secondMixed}) {
|
|
Require(probeValue->calls == 1 && probeValue->integer == 27 && probeValue->floating == 6.5 && std::strcmp(probeValue->text, "independent") == 0, "handlers did not receive independent mixed varargs state");
|
|
}
|
|
Require(sceAudioPropagationReportUnregisterHandler(firstMixedRegistration) == 0, "first mixed report unregister");
|
|
Require(sceAudioPropagationReportUnregisterHandler(secondMixedRegistration) == 0, "second mixed report unregister");
|
|
|
|
FloatingReportProbe floatingProbe{};
|
|
AudioPropagation::ReportRegistration* floatingRegistration = nullptr;
|
|
Require(sceAudioPropagationReportRegisterHandler(0, CaptureFloatingReport, &floatingProbe, &floatingRegistration) == 0, "floating report registration");
|
|
Require(sceAudioPropagationReportApi(0, 0, 0, 0, "floating", "%f%f%f%f%f%f%f%f%f", 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0) == 0, "stack-spilled floating report dispatch");
|
|
Require(floatingProbe.calls == 1, "stack-spilled floating callback count");
|
|
for (std::size_t index = 0; index < floatingProbe.values.size(); ++index) Require(floatingProbe.values[index] == static_cast<double>(index + 1), "stack-spilled floating argument mismatch");
|
|
Require(sceAudioPropagationReportUnregisterHandler(floatingRegistration) == 0, "floating report unregister");
|
|
|
|
IntegerReportProbe integerProbe{};
|
|
AudioPropagation::ReportRegistration* integerRegistration = nullptr;
|
|
Require(sceAudioPropagationReportRegisterHandler(0, CaptureIntegerReport, &integerProbe, &integerRegistration) == 0, "integer-only report registration");
|
|
Require(sceAudioPropagationReportApi(0, 0, 0, 0, "integer-only", "%d %s", -19, "no-floats") == 0, "integer-only report dispatch");
|
|
Require(integerProbe.calls == 1 && integerProbe.integer == -19 && std::strcmp(integerProbe.text, "no-floats") == 0, "integer-only varargs mismatch");
|
|
Require(sceAudioPropagationReportUnregisterHandler(integerRegistration) == 0, "integer-only report unregister");
|
|
|
|
AudioPropagation::ReportRegistration* registrations[8]{};
|
|
for (auto& slot : registrations) Require(sceAudioPropagationReportRegisterHandler(1, CaptureReport, &probe, &slot) == 0 && slot, "report category slot allocation");
|
|
Require(sceAudioPropagationReportRegisterHandler(1, CaptureReport, &probe, nullptr) == -3, "report category capacity");
|
|
for (auto* slot : registrations) Require(sceAudioPropagationReportUnregisterHandler(slot) == 0, "report category slot release");
|
|
|
|
std::uint32_t oldHandlerCalls = 0;
|
|
std::uint32_t newHandlerCalls = 0;
|
|
AudioPropagation::ReportRegistration* oldRegistration = nullptr;
|
|
AudioPropagation::ReportRegistration* newRegistration = nullptr;
|
|
Require(sceAudioPropagationReportRegisterHandler(0, CountReport, &oldHandlerCalls, &oldRegistration) == 0, "old report registration");
|
|
Require(sceAudioPropagationReportUnregisterHandler(oldRegistration) == 0, "old report unregister");
|
|
Require(sceAudioPropagationReportRegisterHandler(0, CountReport, &newHandlerCalls, &newRegistration) == 0 && newRegistration == oldRegistration, "native report slot address was not reused");
|
|
Require(sceAudioPropagationReportUnregisterHandler(oldRegistration) == 0, "stale registration did not release the reused native slot");
|
|
Require(sceAudioPropagationReportApi(0, 0, 0, 0, "stale-registration", "") == 0 && newHandlerCalls == 0, "stale registration left the reused handler active");
|
|
|
|
SelfUnregisterProbe selfUnregister{};
|
|
Require(sceAudioPropagationReportRegisterHandler(0, SelfUnregisterReport, &selfUnregister, &selfUnregister.registration) == 0, "self-unregister handler registration");
|
|
Require(sceAudioPropagationReportApi(0, 0, 0, 0, "test", "") == 0 && selfUnregister.calls == 1, "self-unregister callback dispatch");
|
|
Require(sceAudioPropagationReportApi(0, 0, 0, 0, "test", "") == 0 && selfUnregister.calls == 1, "self-unregistered callback still dispatched");
|
|
|
|
BlockingReportProbe blocking{};
|
|
AudioPropagation::ReportRegistration* blockingRegistration = nullptr;
|
|
Require(sceAudioPropagationReportRegisterHandler(0, BlockingReport, &blocking, &blockingRegistration) == 0, "blocking handler registration");
|
|
std::thread reportThread([&] {
|
|
Require(sceAudioPropagationReportApi(0, 0, 0, 0, "test", "") == 0, "blocking report dispatch");
|
|
});
|
|
while (!blocking.entered.load(std::memory_order_acquire)) std::this_thread::yield();
|
|
std::atomic<bool> unregisterStarted{false};
|
|
std::atomic<bool> unregisterFinished{false};
|
|
std::thread unregisterThread([&] {
|
|
unregisterStarted.store(true, std::memory_order_release);
|
|
Require(sceAudioPropagationReportUnregisterHandler(blockingRegistration) == 0, "concurrent report unregister failed");
|
|
unregisterFinished.store(true, std::memory_order_release);
|
|
});
|
|
while (!unregisterStarted.load(std::memory_order_acquire)) std::this_thread::yield();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(30));
|
|
Require(!unregisterFinished.load(std::memory_order_acquire), "handler unregistered before in-flight callback completed");
|
|
blocking.release.store(true, std::memory_order_release);
|
|
reportThread.join();
|
|
unregisterThread.join();
|
|
Require(unregisterFinished.load(std::memory_order_acquire), "handler unregistration did not finish");
|
|
Require(sceAudioPropagationReportApi(0, 0, 0, 0, "test", "") == 0 && blocking.calls.load() == 1, "unregistered handler dispatched again");
|
|
|
|
std::uint32_t unreturnedRegistrationCalls = 0;
|
|
Require(sceAudioPropagationReportRegisterHandler(1, CountReport, &unreturnedRegistrationCalls, nullptr) == 0, "registration without output pointer failed");
|
|
Require(sceAudioPropagationReportApi(1, 0, 0, 0, "unreturned-registration", "") == 0 && unreturnedRegistrationCalls == 1, "registration without output pointer was not retained");
|
|
|
|
Require(Resolve("sceAudioPropagationSystemCreate") != nullptr && Resolve("sceAudioPropagationSourceSetAudioPath") != nullptr, "export lookup");
|
|
for (const char* name : {"sceAudioPropagationAudioPathInit", "sceAudioPropagationAudioPathPointInit", "sceAudioPropagationMaterialInit", "sceAudioPropagationPortalSettingsInit", "sceAudioPropagationRayInit", "sceAudioPropagationSourceRenderInfoInit", "sceAudioPropagationSourceSetAudioPathsParamInit", "sceAudioPropagationSystemMemoryInit", "sceAudioPropagationSystemOptionInit", "sceAudioPropagationSystem"}) {
|
|
Require(Resolve(name) == nullptr, name);
|
|
}
|
|
|
|
std::puts("AudioPropagation tests passed");
|
|
return 0;
|
|
}
|