mirror of
https://github.com/shadps4-emu/shadPS4.git
synced 2025-08-01 23:12:35 +00:00
493 lines
17 KiB
C++
493 lines
17 KiB
C++
// SPDX-FileCopyrightText: Copyright 2025 shadPS4 Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include <magic_enum/magic_enum.hpp>
|
|
|
|
#include "common/assert.h"
|
|
#include "common/logging/log.h"
|
|
#include "core/libraries/audio/audioout.h"
|
|
#include "core/libraries/audio3d/audio3d.h"
|
|
#include "core/libraries/audio3d/audio3d_error.h"
|
|
#include "core/libraries/error_codes.h"
|
|
#include "core/libraries/libs.h"
|
|
|
|
namespace Libraries::Audio3d {
|
|
|
|
static std::unique_ptr<Audio3dState> state;
|
|
|
|
int PS4_SYSV_ABI sceAudio3dAudioOutClose() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI
|
|
sceAudio3dAudioOutOpen(const OrbisAudio3dPortId port_id, const OrbisUserServiceUserId user_id,
|
|
s32 type, const s32 index, const u32 len, const u32 freq,
|
|
const AudioOut::OrbisAudioOutParamExtendedInformation param) {
|
|
LOG_INFO(Lib_Audio3d,
|
|
"called, port_id = {}, user_id = {}, type = {}, index = {}, len = {}, freq = {}",
|
|
port_id, user_id, type, index, len, freq);
|
|
|
|
if (!state->ports.contains(port_id)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
if (len != state->ports[port_id].parameters.granularity) {
|
|
LOG_ERROR(Lib_Audio3d, "len != state->ports[port_id].parameters.granularity");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return sceAudioOutOpen(user_id, static_cast<AudioOut::OrbisAudioOutPort>(type), index, len,
|
|
freq, param);
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dAudioOutOutput(const s32 handle, void* ptr) {
|
|
LOG_INFO(Lib_Audio3d, "called, handle = {}, ptr = {}", handle, ptr);
|
|
|
|
if (!state->ports.contains(handle)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(handle)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
state->ports[handle].queue.emplace(ptr);
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dAudioOutOutputs() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dBedWrite(const OrbisAudio3dPortId port_id, const u32 num_channels,
|
|
const OrbisAudio3dFormat format, void* buffer,
|
|
const u32 num_samples) {
|
|
return sceAudio3dBedWrite2(port_id, num_channels, format, buffer, num_samples,
|
|
ORBIS_AUDIO3D_OUTPUT_BOTH, false);
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dBedWrite2(OrbisAudio3dPortId port_id, u32 num_channels,
|
|
OrbisAudio3dFormat format, void* buffer, u32 num_samples,
|
|
OrbisAudio3dOutputRoute output_route, bool restricted) {
|
|
LOG_INFO(Lib_Audio3d,
|
|
"called, port_id = {}, num_channels = {}, format = {}, num_samples = {}, output_route "
|
|
"= {}, restricted = {}",
|
|
port_id, num_channels, magic_enum::enum_name(format), num_samples,
|
|
magic_enum::enum_name(output_route), restricted);
|
|
|
|
if (format <= ORBIS_AUDIO3D_FORMAT_FLOAT &&
|
|
((num_channels | 4) == 6 || (num_channels | 0x10) == 24) && buffer && num_samples) {
|
|
if (format == ORBIS_AUDIO3D_FORMAT_FLOAT) {
|
|
if ((reinterpret_cast<uintptr_t>(buffer) & 3) != 0) {
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
} else if (format == ORBIS_AUDIO3D_FORMAT_S16) {
|
|
if ((reinterpret_cast<uintptr_t>(buffer) & 1) != 0) {
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
if (output_route > ORBIS_AUDIO3D_OUTPUT_BOTH) {
|
|
LOG_INFO(Lib_Audio3d, "output_route > ORBIS_AUDIO3D_OUTPUT_BOTH");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (!state->ports.contains(port_id)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
state->ports[port_id].queue.emplace(buffer);
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dCreateSpeakerArray() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dDeleteSpeakerArray() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dGetDefaultOpenParameters() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMemorySize() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMixCoefficients() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMixCoefficients2() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dInitialize(const s64 reserved) {
|
|
LOG_INFO(Lib_Audio3d, "called, reserved = {}", reserved);
|
|
|
|
AudioOut::sceAudioOutInit();
|
|
|
|
if (reserved != 0) {
|
|
LOG_ERROR(Lib_Audio3d, "reserved != 0");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (state) {
|
|
LOG_ERROR(Lib_Audio3d, "already initialized");
|
|
return ORBIS_AUDIO3D_ERROR_NOT_READY;
|
|
}
|
|
|
|
state = std::make_unique<Audio3dState>();
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dObjectReserve(const OrbisAudio3dPortId port_id,
|
|
OrbisAudio3dObjectId* object_id) {
|
|
LOG_INFO(Lib_Audio3d, "called, port_id = {}, object_id = {}", port_id,
|
|
static_cast<void*>(object_id));
|
|
|
|
if (!state->ports.contains(port_id)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
if (!object_id) {
|
|
LOG_ERROR(Lib_Audio3d, "!object_id");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
static int last_id = 0;
|
|
*object_id = ++last_id;
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dObjectSetAttributes(OrbisAudio3dPortId port_id,
|
|
OrbisAudio3dObjectId object_id,
|
|
size_t num_attributes,
|
|
const OrbisAudio3dAttribute* attribute_array) {
|
|
if (!state->ports.contains(port_id)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
for (size_t i = 0; i < num_attributes; i++) {
|
|
const auto& attribute = attribute_array[i];
|
|
|
|
switch (attribute.attribute_id) {
|
|
case 0x00000001: { // PCM
|
|
const auto pcm_attribute = static_cast<OrbisAudio3dPcm*>(attribute.value);
|
|
state->ports[port_id].queue.emplace(pcm_attribute->sample_buffer);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dObjectUnreserve() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortAdvance(const OrbisAudio3dPortId port_id) {
|
|
LOG_INFO(Lib_Audio3d, "called, port_id = {}", port_id);
|
|
|
|
if (!state->ports.contains(port_id)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
if (state->ports[port_id].parameters.buffer_mode == ORBIS_AUDIO3D_BUFFER_NO_ADVANCE) {
|
|
LOG_ERROR(Lib_Audio3d, "port doesn't have advance capability");
|
|
return ORBIS_AUDIO3D_ERROR_NOT_SUPPORTED;
|
|
}
|
|
|
|
auto& queue = state->ports[port_id].queue;
|
|
|
|
if (queue.empty()) {
|
|
LOG_ERROR(Lib_Audio3d, "queue.empty()");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
// WHAT THE FUCK DO YOU DO
|
|
|
|
// queue.pop();
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortClose() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortCreate() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortDestroy() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortFlush() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortFreeState() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortGetAttributesSupported() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortGetList() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortGetParameters() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortGetQueueLevel(const OrbisAudio3dPortId port_id, u32* queue_level,
|
|
u32* queue_available) {
|
|
LOG_INFO(Lib_Audio3d, "called, port_id = {}, queue_level = {}, queue_available = {}", port_id,
|
|
static_cast<void*>(queue_level), static_cast<void*>(queue_available));
|
|
|
|
if (!state->ports.contains(port_id)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
if (!queue_level && !queue_available) {
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
const size_t size = state->ports[port_id].queue.size();
|
|
|
|
if (queue_level) {
|
|
*queue_level = size;
|
|
}
|
|
|
|
if (queue_available) {
|
|
*queue_available =
|
|
state->ports[port_id].parameters.queue_depth - state->ports[port_id].queue.size();
|
|
}
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortGetState() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortGetStatus() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortOpen(const OrbisUserServiceUserId user_id,
|
|
const OrbisAudio3dOpenParameters* parameters,
|
|
OrbisAudio3dPortId* port_id) {
|
|
LOG_INFO(Lib_Audio3d, "called, user_id = {}, parameters = {}, id = {}", user_id,
|
|
static_cast<const void*>(parameters), static_cast<void*>(port_id));
|
|
|
|
if (!state) {
|
|
LOG_ERROR(Lib_Audio3d, "!initialized");
|
|
return ORBIS_AUDIO3D_ERROR_NOT_READY;
|
|
}
|
|
|
|
if (!parameters || !port_id) {
|
|
LOG_ERROR(Lib_Audio3d, "!parameters || !id");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
const int id = static_cast<int>(state->ports.size()) + 1;
|
|
|
|
if (id > 3) {
|
|
LOG_ERROR(Lib_Audio3d, "id > 3");
|
|
return ORBIS_AUDIO3D_ERROR_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
*port_id = id;
|
|
std::memcpy(&state->ports[id].parameters, parameters, sizeof(OrbisAudio3dOpenParameters));
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortPush(const OrbisAudio3dPortId port_id,
|
|
const OrbisAudio3dBlocking blocking) {
|
|
LOG_INFO(Lib_Audio3d, "called, port_id = {}, blocking = {}", port_id,
|
|
magic_enum::enum_name(blocking));
|
|
|
|
if (!state->ports.contains(port_id)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
if (state->ports[port_id].parameters.buffer_mode != ORBIS_AUDIO3D_BUFFER_ADVANCE_AND_PUSH) {
|
|
LOG_ERROR(Lib_Audio3d, "port doesn't have push capability");
|
|
return ORBIS_AUDIO3D_ERROR_NOT_SUPPORTED;
|
|
}
|
|
|
|
auto& queue = state->ports[port_id].queue;
|
|
|
|
if (queue.empty()) {
|
|
LOG_ERROR(Lib_Audio3d, "queue.empty()");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
AudioOut::sceAudioOutOutput(1, queue.front());
|
|
|
|
queue.pop();
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortQueryDebug() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dPortSetAttribute(const OrbisAudio3dPortId port_id,
|
|
const OrbisAudio3dAttributeId attribute_id,
|
|
void* attribute, const size_t attribute_size) {
|
|
LOG_INFO(Lib_Audio3d,
|
|
"called, port_id = {}, attribute_id = {}, attribute = {}, attribute_size = {}",
|
|
port_id, attribute_id, attribute, attribute_size);
|
|
|
|
if (!state->ports.contains(port_id)) {
|
|
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
|
|
}
|
|
|
|
if (!attribute) {
|
|
LOG_ERROR(Lib_Audio3d, "!attribute");
|
|
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
/*switch (attribute_id) { // NOLINT(*-multiway-paths-covered)
|
|
case 0x00000001: { // PCM
|
|
const auto pcm_attribute = static_cast<OrbisAudio3dPcm*>(attribute);
|
|
state->ports[port_id].queue.emplace(pcm_attribute->sample_buffer);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}*/
|
|
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dReportRegisterHandler() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dReportUnregisterHandler() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dSetGpuRenderer() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dStrError() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
int PS4_SYSV_ABI sceAudio3dTerminate() {
|
|
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
|
|
return ORBIS_OK;
|
|
}
|
|
|
|
void RegisterlibSceAudio3d(Core::Loader::SymbolsResolver* sym) {
|
|
LIB_FUNCTION("pZlOm1aF3aA", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dAudioOutClose);
|
|
LIB_FUNCTION("ucEsi62soTo", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dAudioOutOpen);
|
|
LIB_FUNCTION("7NYEzJ9SJbM", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dAudioOutOutput);
|
|
LIB_FUNCTION("HbxYY27lK6E", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dAudioOutOutputs);
|
|
LIB_FUNCTION("9tEwE0GV0qo", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dBedWrite);
|
|
LIB_FUNCTION("xH4Q9UILL3o", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dBedWrite2);
|
|
LIB_FUNCTION("lvWMW6vEqFU", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dCreateSpeakerArray);
|
|
LIB_FUNCTION("8hm6YdoQgwg", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dDeleteSpeakerArray);
|
|
LIB_FUNCTION("Im+jOoa5WAI", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dGetDefaultOpenParameters);
|
|
LIB_FUNCTION("kEqqyDkmgdI", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dGetSpeakerArrayMemorySize);
|
|
LIB_FUNCTION("-R1DukFq7Dk", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dGetSpeakerArrayMixCoefficients);
|
|
LIB_FUNCTION("-Re+pCWvwjQ", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dGetSpeakerArrayMixCoefficients2);
|
|
LIB_FUNCTION("UmCvjSmuZIw", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dInitialize);
|
|
LIB_FUNCTION("jO2tec4dJ2M", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dObjectReserve);
|
|
LIB_FUNCTION("4uyHN9q4ZeU", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dObjectSetAttributes);
|
|
LIB_FUNCTION("1HXxo-+1qCw", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dObjectUnreserve);
|
|
LIB_FUNCTION("lw0qrdSjZt8", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortAdvance);
|
|
LIB_FUNCTION("OyVqOeVNtSk", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortClose);
|
|
LIB_FUNCTION("UHFOgVNz0kk", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortCreate);
|
|
LIB_FUNCTION("Mw9mRQtWepY", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortDestroy);
|
|
LIB_FUNCTION("ZOGrxWLgQzE", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortFlush);
|
|
LIB_FUNCTION("uJ0VhGcxCTQ", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortFreeState);
|
|
LIB_FUNCTION("9ZA23Ia46Po", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dPortGetAttributesSupported);
|
|
LIB_FUNCTION("SEggctIeTcI", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortGetList);
|
|
LIB_FUNCTION("flPcUaXVXcw", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dPortGetParameters);
|
|
LIB_FUNCTION("YaaDbDwKpFM", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dPortGetQueueLevel);
|
|
LIB_FUNCTION("CKHlRW2E9dA", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortGetState);
|
|
LIB_FUNCTION("iRX6GJs9tvE", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortGetStatus);
|
|
LIB_FUNCTION("XeDDK0xJWQA", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortOpen);
|
|
LIB_FUNCTION("VEVhZ9qd4ZY", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dPortPush);
|
|
LIB_FUNCTION("-pzYDZozm+M", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dPortQueryDebug);
|
|
LIB_FUNCTION("Yq9bfUQ0uJg", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dPortSetAttribute);
|
|
LIB_FUNCTION("QfNXBrKZeI0", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dReportRegisterHandler);
|
|
LIB_FUNCTION("psv2gbihC1A", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dReportUnregisterHandler);
|
|
LIB_FUNCTION("yEYXcbAGK14", "libSceAudio3d", 1, "libSceAudio3d", 1, 1,
|
|
sceAudio3dSetGpuRenderer);
|
|
LIB_FUNCTION("Aacl5qkRU6U", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dStrError);
|
|
LIB_FUNCTION("WW1TS2iz5yc", "libSceAudio3d", 1, "libSceAudio3d", 1, 1, sceAudio3dTerminate);
|
|
};
|
|
|
|
} // namespace Libraries::Audio3d
|