mirrors/shadPS4
1
0
Fork 0
mirror of https://github.com/shadps4-emu/shadPS4.git synced 2025-08-02 15:32:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

audio3d: Clean up.

Browse Source
This commit is contained in:
squidbus 2025-04-12 22:39:23 -07:00
parent f75f4ca94f
commit 0f3d3eb8ae
2 changed files with 192 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
src/core/libraries/audio3d/audio3d.cpp
View File

@ -17,24 +17,19 @@ namespace Libraries::Audio3d {
static constexpr u32 AUDIO3D_SAMPLE_RATE = 48000; static constexpr u32 AUDIO3D_SAMPLE_RATE = 48000;
static constexpr u32 AUDIO3D_INPUT_NUM_CHANNELS = 8;
static constexpr u32 AUDIO3D_OBJECT_NUM_CHANNELS = 1;
static constexpr AudioOut::OrbisAudioOutParamFormat AUDIO3D_OUTPUT_FORMAT = static constexpr AudioOut::OrbisAudioOutParamFormat AUDIO3D_OUTPUT_FORMAT =
AudioOut::OrbisAudioOutParamFormat::S16Stereo; AudioOut::OrbisAudioOutParamFormat::S16Stereo;
static constexpr u32 AUDIO3D_OUTPUT_NUM_CHANNELS = 2; static constexpr u32 AUDIO3D_OUTPUT_NUM_CHANNELS = 2;
static constexpr u32 AUDIO3D_OUTPUT_BUFFER_FRAMES = 0x100; static constexpr u32 AUDIO3D_OUTPUT_BUFFER_FRAMES = 0x100;
static constexpr u32 AUDIO3D_OUTPUT_BUFFER_BYTES =
AUDIO3D_OUTPUT_BUFFER_FRAMES * AUDIO3D_OUTPUT_NUM_CHANNELS * sizeof(s16);
static std::unique_ptr<Audio3dState> state; static std::unique_ptr<Audio3dState> state;
int PS4_SYSV_ABI sceAudio3dAudioOutClose() { s32 PS4_SYSV_ABI sceAudio3dAudioOutClose(const s32 handle) {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_INFO(Lib_Audio3d, "called, handle = {}", handle);
return ORBIS_OK; return AudioOut::sceAudioOutClose(handle);
} }
int PS4_SYSV_ABI s32 PS4_SYSV_ABI
sceAudio3dAudioOutOpen(const OrbisAudio3dPortId port_id, const OrbisUserServiceUserId user_id, sceAudio3dAudioOutOpen(const OrbisAudio3dPortId port_id, const OrbisUserServiceUserId user_id,
s32 type, const s32 index, const u32 len, const u32 freq, s32 type, const s32 index, const u32 len, const u32 freq,
const AudioOut::OrbisAudioOutParamExtendedInformation param) { const AudioOut::OrbisAudioOutParamExtendedInformation param) {
@ -56,8 +51,8 @@ sceAudio3dAudioOutOpen(const OrbisAudio3dPortId port_id, const OrbisUserServiceU
freq, param); freq, param);
} }
int PS4_SYSV_ABI sceAudio3dAudioOutOutput(const s32 handle, void* ptr) { s32 PS4_SYSV_ABI sceAudio3dAudioOutOutput(const s32 handle, void* ptr) {
LOG_INFO(Lib_Audio3d, "called, handle = {}, ptr = {}", handle, ptr); LOG_DEBUG(Lib_Audio3d, "called, handle = {}, ptr = {}", handle, ptr);
if (!ptr) { if (!ptr) {
LOG_ERROR(Lib_Audio3d, "!ptr"); LOG_ERROR(Lib_Audio3d, "!ptr");
@ -72,9 +67,9 @@ int PS4_SYSV_ABI sceAudio3dAudioOutOutput(const s32 handle, void* ptr) {
return AudioOut::sceAudioOutOutput(handle, ptr); return AudioOut::sceAudioOutOutput(handle, ptr);
} }
int PS4_SYSV_ABI sceAudio3dAudioOutOutputs(AudioOut::OrbisAudioOutOutputParam* param, s32 PS4_SYSV_ABI sceAudio3dAudioOutOutputs(AudioOut::OrbisAudioOutOutputParam* param,
const u32 num) { const u32 num) {
LOG_INFO(Lib_Audio3d, "called, param = {}, num = {}", static_cast<void*>(param), num); LOG_DEBUG(Lib_Audio3d, "called, param = {}, num = {}", static_cast<void*>(param), num);
if (!param || !num) { if (!param || !num) {
LOG_ERROR(Lib_Audio3d, "!param || !num"); LOG_ERROR(Lib_Audio3d, "!param || !num");
@ -84,10 +79,12 @@ int PS4_SYSV_ABI sceAudio3dAudioOutOutputs(AudioOut::OrbisAudioOutOutputParam* p
return AudioOut::sceAudioOutOutputs(param, num); return AudioOut::sceAudioOutOutputs(param, num);
} }
static s32 PortQueueAudio(Port& port, const OrbisAudio3dPcm& pcm, int num_channels) { static s32 PortQueueAudio(Port& port, const OrbisAudio3dPcm& pcm, const u32 num_channels) {
// Audio3d output is configured for stereo signed 16-bit PCM. Convert the data to match.
const SDL_AudioSpec src_spec = { const SDL_AudioSpec src_spec = {
.format = pcm.format == ORBIS_AUDIO3D_FORMAT_S16 ? SDL_AUDIO_S16LE : SDL_AUDIO_F32LE, .format = pcm.format == OrbisAudio3dFormat::ORBIS_AUDIO3D_FORMAT_S16 ? SDL_AUDIO_S16LE
.channels = num_channels, : SDL_AUDIO_F32LE,
.channels = static_cast<int>(num_channels),
.freq = AUDIO3D_SAMPLE_RATE, .freq = AUDIO3D_SAMPLE_RATE,
}; };
constexpr SDL_AudioSpec dst_spec = { constexpr SDL_AudioSpec dst_spec = {
@ -95,14 +92,14 @@ static s32 PortQueueAudio(Port& port, const OrbisAudio3dPcm& pcm, int num_channe
.channels = AUDIO3D_OUTPUT_NUM_CHANNELS, .channels = AUDIO3D_OUTPUT_NUM_CHANNELS,
.freq = AUDIO3D_SAMPLE_RATE, .freq = AUDIO3D_SAMPLE_RATE,
}; };
const auto src_size = pcm.num_samples *
const auto pcm_size = (pcm.format == OrbisAudio3dFormat::ORBIS_AUDIO3D_FORMAT_S16 ? 2 : 4) *
pcm.num_samples * (pcm.format == ORBIS_AUDIO3D_FORMAT_S16 ? 2 : 4) * num_channels; num_channels;
u8* dst_data; u8* dst_data;
int dst_len; int dst_len;
if (!SDL_ConvertAudioSamples(&src_spec, static_cast<u8*>(pcm.sample_buffer), if (!SDL_ConvertAudioSamples(&src_spec, static_cast<u8*>(pcm.sample_buffer),
static_cast<int>(pcm_size), &dst_spec, &dst_data, &dst_len)) { static_cast<int>(src_size), &dst_spec, &dst_data, &dst_len)) {
LOG_ERROR(Lib_Audio3d, "SDL_ConvertAudioSamples failed: {}", SDL_GetError()); LOG_ERROR(Lib_Audio3d, "SDL_ConvertAudioSamples failed: {}", SDL_GetError());
return ORBIS_AUDIO3D_ERROR_OUT_OF_MEMORY; return ORBIS_AUDIO3D_ERROR_OUT_OF_MEMORY;
} }
@ -114,19 +111,20 @@ static s32 PortQueueAudio(Port& port, const OrbisAudio3dPcm& pcm, int num_channe
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dBedWrite(const OrbisAudio3dPortId port_id, const u32 num_channels, s32 PS4_SYSV_ABI sceAudio3dBedWrite(const OrbisAudio3dPortId port_id, const u32 num_channels,
const OrbisAudio3dFormat format, void* buffer, const OrbisAudio3dFormat format, void* buffer,
const u32 num_samples) { const u32 num_samples) {
return sceAudio3dBedWrite2(port_id, num_channels, format, buffer, num_samples, return sceAudio3dBedWrite2(port_id, num_channels, format, buffer, num_samples,
ORBIS_AUDIO3D_OUTPUT_BOTH, false); OrbisAudio3dOutputRoute::ORBIS_AUDIO3D_OUTPUT_BOTH, false);
} }
int PS4_SYSV_ABI sceAudio3dBedWrite2(const OrbisAudio3dPortId port_id, const u32 num_channels, s32 PS4_SYSV_ABI sceAudio3dBedWrite2(const OrbisAudio3dPortId port_id, const u32 num_channels,
const OrbisAudio3dFormat format, void* buffer, const OrbisAudio3dFormat format, void* buffer,
const u32 num_samples, const u32 num_samples,
const OrbisAudio3dOutputRoute output_route, const OrbisAudio3dOutputRoute output_route,
const bool restricted) { const bool restricted) {
LOG_INFO(Lib_Audio3d, LOG_DEBUG(
Lib_Audio3d,
"called, port_id = {}, num_channels = {}, format = {}, num_samples = {}, output_route " "called, port_id = {}, num_channels = {}, format = {}, num_samples = {}, output_route "
"= {}, restricted = {}", "= {}, restricted = {}",
port_id, num_channels, magic_enum::enum_name(format), num_samples, port_id, num_channels, magic_enum::enum_name(format), num_samples,
@ -137,65 +135,88 @@ int PS4_SYSV_ABI sceAudio3dBedWrite2(const OrbisAudio3dPortId port_id, const u32
return ORBIS_AUDIO3D_ERROR_INVALID_PORT; return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
} }
if (output_route > ORBIS_AUDIO3D_OUTPUT_BOTH) { if (output_route > OrbisAudio3dOutputRoute::ORBIS_AUDIO3D_OUTPUT_BOTH) {
LOG_INFO(Lib_Audio3d, "output_route > ORBIS_AUDIO3D_OUTPUT_BOTH"); LOG_ERROR(Lib_Audio3d, "output_route > ORBIS_AUDIO3D_OUTPUT_BOTH");
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER; return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
} }
if (format <= ORBIS_AUDIO3D_FORMAT_FLOAT && if (format > OrbisAudio3dFormat::ORBIS_AUDIO3D_FORMAT_FLOAT) {
((num_channels | 4) == 6 || (num_channels | 0x10) == 24) && buffer && num_samples) { LOG_ERROR(Lib_Audio3d, "format > ORBIS_AUDIO3D_FORMAT_FLOAT");
if (format == ORBIS_AUDIO3D_FORMAT_FLOAT) { return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
}
if (num_channels != 2 && num_channels != 8) {
LOG_ERROR(Lib_Audio3d, "num_channels != 2 && num_channels != 8");
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
}
if (!buffer || !num_samples) {
LOG_ERROR(Lib_Audio3d, "!buffer || !num_samples");
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
}
if (format == OrbisAudio3dFormat::ORBIS_AUDIO3D_FORMAT_FLOAT) {
if ((reinterpret_cast<uintptr_t>(buffer) & 3) != 0) { if ((reinterpret_cast<uintptr_t>(buffer) & 3) != 0) {
LOG_ERROR(Lib_Audio3d, "buffer & 3 != 0");
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER; return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
} }
} else if (format == ORBIS_AUDIO3D_FORMAT_S16) { } else if (format == OrbisAudio3dFormat::ORBIS_AUDIO3D_FORMAT_S16) {
if ((reinterpret_cast<uintptr_t>(buffer) & 1) != 0) { if ((reinterpret_cast<uintptr_t>(buffer) & 1) != 0) {
LOG_ERROR(Lib_Audio3d, "buffer & 1 != 0");
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER; return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
} }
} }
const OrbisAudio3dPcm pcm = { return PortQueueAudio(state->ports[port_id],
OrbisAudio3dPcm{
.format = format, .format = format,
.sample_buffer = buffer, .sample_buffer = buffer,
.num_samples = num_samples, .num_samples = num_samples,
},
num_channels);
}
s32 PS4_SYSV_ABI sceAudio3dCreateSpeakerArray() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceAudio3dDeleteSpeakerArray() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK;
}
s32 PS4_SYSV_ABI sceAudio3dGetDefaultOpenParameters(OrbisAudio3dOpenParameters* params) {
LOG_DEBUG(Lib_Audio3d, "called");
if (params) {
*params = OrbisAudio3dOpenParameters{
.size_this = 0x20,
.granularity = 0x100,
.rate = OrbisAudio3dRate::ORBIS_AUDIO3D_RATE_48000,
.max_objects = 512,
.queue_depth = 2,
.buffer_mode = OrbisAudio3dBufferMode::ORBIS_AUDIO3D_BUFFER_ADVANCE_AND_PUSH,
}; };
return PortQueueAudio(state->ports[port_id], pcm, AUDIO3D_INPUT_NUM_CHANNELS);
} }
return ORBIS_OK;
return ORBIS_AUDIO3D_ERROR_INVALID_PARAMETER;
} }
int PS4_SYSV_ABI sceAudio3dCreateSpeakerArray() { s32 PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMemorySize() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dDeleteSpeakerArray() { s32 PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMixCoefficients() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dGetDefaultOpenParameters() { s32 PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMixCoefficients2() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMemorySize() { s32 PS4_SYSV_ABI sceAudio3dInitialize(const s64 reserved) {
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); LOG_INFO(Lib_Audio3d, "called, reserved = {}", reserved);
if (reserved != 0) { if (reserved != 0) {
@ -210,8 +231,8 @@ int PS4_SYSV_ABI sceAudio3dInitialize(const s64 reserved) {
state = std::make_unique<Audio3dState>(); state = std::make_unique<Audio3dState>();
const auto init_ret = AudioOut::sceAudioOutInit(); if (const auto init_ret = AudioOut::sceAudioOutInit();
if (init_ret < 0 && init_ret != ORBIS_AUDIO_OUT_ERROR_ALREADY_INIT) { init_ret < 0 && init_ret != ORBIS_AUDIO_OUT_ERROR_ALREADY_INIT) {
return init_ret; return init_ret;
} }
@ -227,7 +248,7 @@ int PS4_SYSV_ABI sceAudio3dInitialize(const s64 reserved) {
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dObjectReserve(const OrbisAudio3dPortId port_id, s32 PS4_SYSV_ABI sceAudio3dObjectReserve(const OrbisAudio3dPortId port_id,
OrbisAudio3dObjectId* object_id) { OrbisAudio3dObjectId* object_id) {
LOG_INFO(Lib_Audio3d, "called, port_id = {}, object_id = {}", port_id, LOG_INFO(Lib_Audio3d, "called, port_id = {}, object_id = {}", port_id,
static_cast<void*>(object_id)); static_cast<void*>(object_id));
@ -248,10 +269,14 @@ int PS4_SYSV_ABI sceAudio3dObjectReserve(const OrbisAudio3dPortId port_id,
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dObjectSetAttributes(const OrbisAudio3dPortId port_id, s32 PS4_SYSV_ABI sceAudio3dObjectSetAttributes(const OrbisAudio3dPortId port_id,
OrbisAudio3dObjectId object_id, OrbisAudio3dObjectId object_id,
const size_t num_attributes, const u64 num_attributes,
const OrbisAudio3dAttribute* attribute_array) { const OrbisAudio3dAttribute* attribute_array) {
LOG_DEBUG(Lib_Audio3d,
"called, port_id = {}, object_id = {}, num_attributes = {}, attribute_array = {}",
port_id, object_id, num_attributes, fmt::ptr(attribute_array));
if (!state->ports.contains(port_id)) { if (!state->ports.contains(port_id)) {
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)"); LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
return ORBIS_AUDIO3D_ERROR_INVALID_PORT; return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
@ -259,20 +284,21 @@ int PS4_SYSV_ABI sceAudio3dObjectSetAttributes(const OrbisAudio3dPortId port_id,
auto& port = state->ports[port_id]; auto& port = state->ports[port_id];
for (size_t i = 0; i < num_attributes; i++) { for (u64 i = 0; i < num_attributes; i++) {
const auto& attribute = attribute_array[i]; const auto& attribute = attribute_array[i];
switch (attribute.attribute_id) { switch (attribute.attribute_id) {
case 0x00000001: { // PCM case OrbisAudio3dAttributeId::ORBIS_AUDIO3D_ATTRIBUTE_PCM: {
const auto pcm = static_cast<OrbisAudio3dPcm*>(attribute.value); const auto pcm = static_cast<OrbisAudio3dPcm*>(attribute.value);
if (const auto ret = PortQueueAudio(port, *pcm, AUDIO3D_OBJECT_NUM_CHANNELS); // Object audio has 1 channel.
ret != ORBIS_OK) { if (const auto ret = PortQueueAudio(port, *pcm, 1); ret != ORBIS_OK) {
return ret; return ret;
} }
break; break;
} }
default: default:
LOG_ERROR(Lib_Audio3d, "Unsupported attribute ID: {:#x}", attribute.attribute_id); LOG_ERROR(Lib_Audio3d, "Unsupported attribute ID: {:#x}",
static_cast<u32>(attribute.attribute_id));
break; break;
} }
} }
@ -280,20 +306,21 @@ int PS4_SYSV_ABI sceAudio3dObjectSetAttributes(const OrbisAudio3dPortId port_id,
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dObjectUnreserve() { s32 PS4_SYSV_ABI sceAudio3dObjectUnreserve() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortAdvance(const OrbisAudio3dPortId port_id) { s32 PS4_SYSV_ABI sceAudio3dPortAdvance(const OrbisAudio3dPortId port_id) {
LOG_INFO(Lib_Audio3d, "called, port_id = {}", port_id); LOG_DEBUG(Lib_Audio3d, "called, port_id = {}", port_id);
if (!state->ports.contains(port_id)) { if (!state->ports.contains(port_id)) {
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)"); LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
return ORBIS_AUDIO3D_ERROR_INVALID_PORT; return ORBIS_AUDIO3D_ERROR_INVALID_PORT;
} }
if (state->ports[port_id].parameters.buffer_mode == ORBIS_AUDIO3D_BUFFER_NO_ADVANCE) { if (state->ports[port_id].parameters.buffer_mode ==
OrbisAudio3dBufferMode::ORBIS_AUDIO3D_BUFFER_NO_ADVANCE) {
LOG_ERROR(Lib_Audio3d, "port doesn't have advance capability"); LOG_ERROR(Lib_Audio3d, "port doesn't have advance capability");
return ORBIS_AUDIO3D_ERROR_NOT_SUPPORTED; return ORBIS_AUDIO3D_ERROR_NOT_SUPPORTED;
} }
@ -316,49 +343,49 @@ int PS4_SYSV_ABI sceAudio3dPortAdvance(const OrbisAudio3dPortId port_id) {
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortClose() { s32 PS4_SYSV_ABI sceAudio3dPortClose() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortCreate() { s32 PS4_SYSV_ABI sceAudio3dPortCreate() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortDestroy() { s32 PS4_SYSV_ABI sceAudio3dPortDestroy() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortFlush() { s32 PS4_SYSV_ABI sceAudio3dPortFlush() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortFreeState() { s32 PS4_SYSV_ABI sceAudio3dPortFreeState() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortGetAttributesSupported() { s32 PS4_SYSV_ABI sceAudio3dPortGetAttributesSupported() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortGetList() { s32 PS4_SYSV_ABI sceAudio3dPortGetList() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortGetParameters() { s32 PS4_SYSV_ABI sceAudio3dPortGetParameters() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortGetQueueLevel(const OrbisAudio3dPortId port_id, u32* queue_level, s32 PS4_SYSV_ABI sceAudio3dPortGetQueueLevel(const OrbisAudio3dPortId port_id, u32* queue_level,
u32* queue_available) { u32* queue_available) {
LOG_INFO(Lib_Audio3d, "called, port_id = {}, queue_level = {}, queue_available = {}", port_id, LOG_DEBUG(Lib_Audio3d, "called, port_id = {}, queue_level = {}, queue_available = {}", port_id,
static_cast<void*>(queue_level), static_cast<void*>(queue_available)); static_cast<void*>(queue_level), static_cast<void*>(queue_available));
if (!state->ports.contains(port_id)) { if (!state->ports.contains(port_id)) {
@ -384,17 +411,17 @@ int PS4_SYSV_ABI sceAudio3dPortGetQueueLevel(const OrbisAudio3dPortId port_id, u
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortGetState() { s32 PS4_SYSV_ABI sceAudio3dPortGetState() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortGetStatus() { s32 PS4_SYSV_ABI sceAudio3dPortGetStatus() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortOpen(const OrbisUserServiceUserId user_id, s32 PS4_SYSV_ABI sceAudio3dPortOpen(const OrbisUserServiceUserId user_id,
const OrbisAudio3dOpenParameters* parameters, const OrbisAudio3dOpenParameters* parameters,
OrbisAudio3dPortId* port_id) { OrbisAudio3dPortId* port_id) {
LOG_INFO(Lib_Audio3d, "called, user_id = {}, parameters = {}, id = {}", user_id, LOG_INFO(Lib_Audio3d, "called, user_id = {}, parameters = {}, id = {}", user_id,
@ -423,9 +450,9 @@ int PS4_SYSV_ABI sceAudio3dPortOpen(const OrbisUserServiceUserId user_id,
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortPush(const OrbisAudio3dPortId port_id, s32 PS4_SYSV_ABI sceAudio3dPortPush(const OrbisAudio3dPortId port_id,
const OrbisAudio3dBlocking blocking) { const OrbisAudio3dBlocking blocking) {
LOG_INFO(Lib_Audio3d, "called, port_id = {}, blocking = {}", port_id, LOG_DEBUG(Lib_Audio3d, "called, port_id = {}, blocking = {}", port_id,
magic_enum::enum_name(blocking)); magic_enum::enum_name(blocking));
if (!state->ports.contains(port_id)) { if (!state->ports.contains(port_id)) {
@ -434,7 +461,8 @@ int PS4_SYSV_ABI sceAudio3dPortPush(const OrbisAudio3dPortId port_id,
} }
const auto& port = state->ports[port_id]; const auto& port = state->ports[port_id];
if (port.parameters.buffer_mode != ORBIS_AUDIO3D_BUFFER_ADVANCE_AND_PUSH) { if (port.parameters.buffer_mode !=
OrbisAudio3dBufferMode::ORBIS_AUDIO3D_BUFFER_ADVANCE_AND_PUSH) {
LOG_ERROR(Lib_Audio3d, "port doesn't have push capability"); LOG_ERROR(Lib_Audio3d, "port doesn't have push capability");
return ORBIS_AUDIO3D_ERROR_NOT_SUPPORTED; return ORBIS_AUDIO3D_ERROR_NOT_SUPPORTED;
} }
@ -450,17 +478,17 @@ int PS4_SYSV_ABI sceAudio3dPortPush(const OrbisAudio3dPortId port_id,
return AudioOut::sceAudioOutOutput(state->audio_out_handle, sample_buffer); return AudioOut::sceAudioOutOutput(state->audio_out_handle, sample_buffer);
} }
int PS4_SYSV_ABI sceAudio3dPortQueryDebug() { s32 PS4_SYSV_ABI sceAudio3dPortQueryDebug() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dPortSetAttribute(const OrbisAudio3dPortId port_id, s32 PS4_SYSV_ABI sceAudio3dPortSetAttribute(const OrbisAudio3dPortId port_id,
const OrbisAudio3dAttributeId attribute_id, const OrbisAudio3dAttributeId attribute_id,
void* attribute, const size_t attribute_size) { void* attribute, const u64 attribute_size) {
LOG_INFO(Lib_Audio3d, LOG_INFO(Lib_Audio3d,
"called, port_id = {}, attribute_id = {}, attribute = {}, attribute_size = {}", "called, port_id = {}, attribute_id = {}, attribute = {}, attribute_size = {}",
port_id, attribute_id, attribute, attribute_size); port_id, static_cast<u32>(attribute_id), attribute, attribute_size);
if (!state->ports.contains(port_id)) { if (!state->ports.contains(port_id)) {
LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)"); LOG_ERROR(Lib_Audio3d, "!state->ports.contains(port_id)");
@ -477,27 +505,27 @@ int PS4_SYSV_ABI sceAudio3dPortSetAttribute(const OrbisAudio3dPortId port_id,
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dReportRegisterHandler() { s32 PS4_SYSV_ABI sceAudio3dReportRegisterHandler() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dReportUnregisterHandler() { s32 PS4_SYSV_ABI sceAudio3dReportUnregisterHandler() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dSetGpuRenderer() { s32 PS4_SYSV_ABI sceAudio3dSetGpuRenderer() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dStrError() { s32 PS4_SYSV_ABI sceAudio3dStrError() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }
int PS4_SYSV_ABI sceAudio3dTerminate() { s32 PS4_SYSV_ABI sceAudio3dTerminate() {
LOG_ERROR(Lib_Audio3d, "(STUBBED) called"); LOG_ERROR(Lib_Audio3d, "(STUBBED) called");
return ORBIS_OK; return ORBIS_OK;
} }

116
src/core/libraries/audio3d/audio3d.h
View File

@ -17,16 +17,18 @@ namespace Libraries::Audio3d {
using OrbisUserServiceUserId = s32; using OrbisUserServiceUserId = s32;
enum OrbisAudio3dRate { ORBIS_AUDIO3D_RATE_48000 = 0 }; enum class OrbisAudio3dRate : u32 {
ORBIS_AUDIO3D_RATE_48000 = 0,
};
enum OrbisAudio3dBufferMode { enum class OrbisAudio3dBufferMode : u32 {
ORBIS_AUDIO3D_BUFFER_NO_ADVANCE = 0, ORBIS_AUDIO3D_BUFFER_NO_ADVANCE = 0,
ORBIS_AUDIO3D_BUFFER_ADVANCE_NO_PUSH = 1, ORBIS_AUDIO3D_BUFFER_ADVANCE_NO_PUSH = 1,
ORBIS_AUDIO3D_BUFFER_ADVANCE_AND_PUSH = 2 ORBIS_AUDIO3D_BUFFER_ADVANCE_AND_PUSH = 2,
}; };
struct OrbisAudio3dOpenParameters { struct OrbisAudio3dOpenParameters {
size_t size_this; u64 size_this;
u32 granularity; u32 granularity;
OrbisAudio3dRate rate; OrbisAudio3dRate rate;
u32 max_objects; u32 max_objects;
@ -36,15 +38,21 @@ struct OrbisAudio3dOpenParameters {
u32 num_beds; u32 num_beds;
}; };
enum OrbisAudio3dFormat { ORBIS_AUDIO3D_FORMAT_S16 = 0, ORBIS_AUDIO3D_FORMAT_FLOAT = 1 }; enum class OrbisAudio3dFormat : u32 {
ORBIS_AUDIO3D_FORMAT_S16 = 0,
enum OrbisAudio3dOutputRoute { ORBIS_AUDIO3D_FORMAT_FLOAT = 1,
ORBIS_AUDIO3D_OUTPUT_BOTH = 0,
ORBIS_AUDIO3D_OUTPUT_HMU_ONLY = 1,
ORBIS_AUDIO3D_OUTPUT_TV_ONLY = 2
}; };
enum OrbisAudio3dBlocking { ORBIS_AUDIO3D_BLOCKING_ASYNC = 0, ORBIS_AUDIO3D_BLOCKING_SYNC = 1 }; enum class OrbisAudio3dOutputRoute : u32 {
ORBIS_AUDIO3D_OUTPUT_BOTH = 0,
ORBIS_AUDIO3D_OUTPUT_HMU_ONLY = 1,
ORBIS_AUDIO3D_OUTPUT_TV_ONLY = 2,
};
enum class OrbisAudio3dBlocking : u32 {
ORBIS_AUDIO3D_BLOCKING_ASYNC = 0,
ORBIS_AUDIO3D_BLOCKING_SYNC = 1,
};
struct OrbisAudio3dPcm { struct OrbisAudio3dPcm {
OrbisAudio3dFormat format; OrbisAudio3dFormat format;
@ -52,15 +60,18 @@ struct OrbisAudio3dPcm {
u32 num_samples; u32 num_samples;
}; };
enum class OrbisAudio3dAttributeId : u32 {
ORBIS_AUDIO3D_ATTRIBUTE_PCM = 1,
};
using OrbisAudio3dPortId = u32; using OrbisAudio3dPortId = u32;
using OrbisAudio3dAttributeId = u32;
using OrbisAudio3dObjectId = u32; using OrbisAudio3dObjectId = u32;
struct OrbisAudio3dAttribute { struct OrbisAudio3dAttribute {
OrbisAudio3dAttributeId attribute_id; OrbisAudio3dAttributeId attribute_id;
int : 32; int : 32;
void* value; void* value;
size_t value_size; u64 value_size;
}; };
struct AudioData { struct AudioData {
@ -79,57 +90,56 @@ struct Audio3dState {
s32 audio_out_handle; s32 audio_out_handle;
}; };
int PS4_SYSV_ABI sceAudio3dAudioOutClose(); s32 PS4_SYSV_ABI sceAudio3dAudioOutClose(s32 handle);
int PS4_SYSV_ABI sceAudio3dAudioOutOpen(OrbisAudio3dPortId port_id, OrbisUserServiceUserId user_id, s32 PS4_SYSV_ABI sceAudio3dAudioOutOpen(OrbisAudio3dPortId port_id, OrbisUserServiceUserId user_id,
s32 type, s32 index, u32 len, u32 freq, s32 type, s32 index, u32 len, u32 freq,
AudioOut::OrbisAudioOutParamExtendedInformation param); AudioOut::OrbisAudioOutParamExtendedInformation param);
int PS4_SYSV_ABI sceAudio3dAudioOutOutput(s32 handle, void* ptr); s32 PS4_SYSV_ABI sceAudio3dAudioOutOutput(s32 handle, void* ptr);
int PS4_SYSV_ABI sceAudio3dAudioOutOutputs(AudioOut::OrbisAudioOutOutputParam* param, u32 num); s32 PS4_SYSV_ABI sceAudio3dAudioOutOutputs(AudioOut::OrbisAudioOutOutputParam* param, u32 num);
int PS4_SYSV_ABI sceAudio3dBedWrite(OrbisAudio3dPortId port_id, u32 num_channels, s32 PS4_SYSV_ABI sceAudio3dBedWrite(OrbisAudio3dPortId port_id, u32 num_channels,
OrbisAudio3dFormat format, void* buffer, u32 num_samples); OrbisAudio3dFormat format, void* buffer, u32 num_samples);
int PS4_SYSV_ABI sceAudio3dBedWrite2(OrbisAudio3dPortId port_id, u32 num_channels, s32 PS4_SYSV_ABI sceAudio3dBedWrite2(OrbisAudio3dPortId port_id, u32 num_channels,
OrbisAudio3dFormat format, void* buffer, u32 num_samples, OrbisAudio3dFormat format, void* buffer, u32 num_samples,
OrbisAudio3dOutputRoute output_route, bool restricted); OrbisAudio3dOutputRoute output_route, bool restricted);
int PS4_SYSV_ABI sceAudio3dCreateSpeakerArray(); s32 PS4_SYSV_ABI sceAudio3dCreateSpeakerArray();
int PS4_SYSV_ABI sceAudio3dDeleteSpeakerArray(); s32 PS4_SYSV_ABI sceAudio3dDeleteSpeakerArray();
int PS4_SYSV_ABI sceAudio3dGetDefaultOpenParameters(); s32 PS4_SYSV_ABI sceAudio3dGetDefaultOpenParameters(OrbisAudio3dOpenParameters* params);
int PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMemorySize(); s32 PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMemorySize();
int PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMixCoefficients(); s32 PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMixCoefficients();
int PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMixCoefficients2(); s32 PS4_SYSV_ABI sceAudio3dGetSpeakerArrayMixCoefficients2();
int PS4_SYSV_ABI sceAudio3dInitialize(s64 reserved); s32 PS4_SYSV_ABI sceAudio3dInitialize(s64 reserved);
int PS4_SYSV_ABI sceAudio3dObjectReserve(OrbisAudio3dPortId port_id, s32 PS4_SYSV_ABI sceAudio3dObjectReserve(OrbisAudio3dPortId port_id,
OrbisAudio3dObjectId* object_id); OrbisAudio3dObjectId* object_id);
int PS4_SYSV_ABI sceAudio3dObjectSetAttributes(OrbisAudio3dPortId port_id, s32 PS4_SYSV_ABI sceAudio3dObjectSetAttributes(OrbisAudio3dPortId port_id,
OrbisAudio3dObjectId object_id, OrbisAudio3dObjectId object_id, u64 num_attributes,
size_t num_attributes,
const OrbisAudio3dAttribute* attribute_array); const OrbisAudio3dAttribute* attribute_array);
int PS4_SYSV_ABI sceAudio3dObjectUnreserve(); s32 PS4_SYSV_ABI sceAudio3dObjectUnreserve();
int PS4_SYSV_ABI sceAudio3dPortAdvance(OrbisAudio3dPortId port_id); s32 PS4_SYSV_ABI sceAudio3dPortAdvance(OrbisAudio3dPortId port_id);
int PS4_SYSV_ABI sceAudio3dPortClose(); s32 PS4_SYSV_ABI sceAudio3dPortClose();
int PS4_SYSV_ABI sceAudio3dPortCreate(); s32 PS4_SYSV_ABI sceAudio3dPortCreate();
int PS4_SYSV_ABI sceAudio3dPortDestroy(); s32 PS4_SYSV_ABI sceAudio3dPortDestroy();
int PS4_SYSV_ABI sceAudio3dPortFlush(); s32 PS4_SYSV_ABI sceAudio3dPortFlush();
int PS4_SYSV_ABI sceAudio3dPortFreeState(); s32 PS4_SYSV_ABI sceAudio3dPortFreeState();
int PS4_SYSV_ABI sceAudio3dPortGetAttributesSupported(); s32 PS4_SYSV_ABI sceAudio3dPortGetAttributesSupported();
int PS4_SYSV_ABI sceAudio3dPortGetList(); s32 PS4_SYSV_ABI sceAudio3dPortGetList();
int PS4_SYSV_ABI sceAudio3dPortGetParameters(); s32 PS4_SYSV_ABI sceAudio3dPortGetParameters();
int PS4_SYSV_ABI sceAudio3dPortGetQueueLevel(OrbisAudio3dPortId port_id, u32* queue_level, s32 PS4_SYSV_ABI sceAudio3dPortGetQueueLevel(OrbisAudio3dPortId port_id, u32* queue_level,
u32* queue_available); u32* queue_available);
int PS4_SYSV_ABI sceAudio3dPortGetState(); s32 PS4_SYSV_ABI sceAudio3dPortGetState();
int PS4_SYSV_ABI sceAudio3dPortGetStatus(); s32 PS4_SYSV_ABI sceAudio3dPortGetStatus();
int PS4_SYSV_ABI sceAudio3dPortOpen(OrbisUserServiceUserId user_id, s32 PS4_SYSV_ABI sceAudio3dPortOpen(OrbisUserServiceUserId user_id,
const OrbisAudio3dOpenParameters* parameters, const OrbisAudio3dOpenParameters* parameters,
OrbisAudio3dPortId* port_id); OrbisAudio3dPortId* port_id);
int PS4_SYSV_ABI sceAudio3dPortPush(OrbisAudio3dPortId port_id, OrbisAudio3dBlocking blocking); s32 PS4_SYSV_ABI sceAudio3dPortPush(OrbisAudio3dPortId port_id, OrbisAudio3dBlocking blocking);
int PS4_SYSV_ABI sceAudio3dPortQueryDebug(); s32 PS4_SYSV_ABI sceAudio3dPortQueryDebug();
int PS4_SYSV_ABI sceAudio3dPortSetAttribute(OrbisAudio3dPortId port_id, s32 PS4_SYSV_ABI sceAudio3dPortSetAttribute(OrbisAudio3dPortId port_id,
OrbisAudio3dAttributeId attribute_id, void* attribute, OrbisAudio3dAttributeId attribute_id, void* attribute,
size_t attribute_size); u64 attribute_size);
int PS4_SYSV_ABI sceAudio3dReportRegisterHandler(); s32 PS4_SYSV_ABI sceAudio3dReportRegisterHandler();
int PS4_SYSV_ABI sceAudio3dReportUnregisterHandler(); s32 PS4_SYSV_ABI sceAudio3dReportUnregisterHandler();
int PS4_SYSV_ABI sceAudio3dSetGpuRenderer(); s32 PS4_SYSV_ABI sceAudio3dSetGpuRenderer();
int PS4_SYSV_ABI sceAudio3dStrError(); s32 PS4_SYSV_ABI sceAudio3dStrError();
int PS4_SYSV_ABI sceAudio3dTerminate(); s32 PS4_SYSV_ABI sceAudio3dTerminate();
void RegisterlibSceAudio3d(Core::Loader::SymbolsResolver* sym); void RegisterlibSceAudio3d(Core::Loader::SymbolsResolver* sym);
} // namespace Libraries::Audio3d } // namespace Libraries::Audio3d