VERY experimental Nintendo Switch 2 emulator
C++
Convert files to LF eol
Kelebek1539b99379d3a
diff --git a/src/audio_core/adsp/apps/opus/opus_decode_object.cpp b/src/audio_core/adsp/apps/opus/opus_decode_object.cppindex 2c16d37692..e2b9eb566c 100644--- a/src/audio_core/adsp/apps/opus/opus_decode_object.cpp+++ b/src/audio_core/adsp/apps/opus/opus_decode_object.cpp@@ -1,107 +1,107 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include "audio_core/adsp/apps/opus/opus_decode_object.h"-#include "common/assert.h"--namespace AudioCore::ADSP::OpusDecoder {-namespace {-bool IsValidChannelCount(u32 channel_count) {- return channel_count == 1 || channel_count == 2;-}-} // namespace--u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {- if (!IsValidChannelCount(channel_count)) {- return 0;- }- return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);-}--OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {- auto* new_decoder = reinterpret_cast<OpusDecodeObject*>(buffer);- auto* comparison = reinterpret_cast<OpusDecodeObject*>(buffer2);-- if (new_decoder->magic == DecodeObjectMagic) {- if (!new_decoder->initialized ||- (new_decoder->initialized && new_decoder->self == comparison)) {- new_decoder->state_valid = true;- }- } else {- new_decoder->initialized = false;- new_decoder->state_valid = true;- }- return *new_decoder;-}--s32 OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {- if (!state_valid) {- return OPUS_INVALID_STATE;- }-- if (initialized) {- return OPUS_OK;- }-- // Unfortunately libopus does not expose the OpusDecoder struct publicly, so we can't include- // it in this class. Nintendo does not allocate memory, which is why we have a workbuffer- // provided.- // We could use _create and have libopus allocate it for us, but then we have to separately- // track which decoder is being used between this and multistream in order to call the correct- // destroy from the host side.- // This is a bit cringe, but is safe as these objects are only ever initialized inside the given- // workbuffer, and GetWorkBufferSize will guarantee there's enough space to follow.- decoder = (LibOpusDecoder*)(this + 1);- s32 ret = opus_decoder_init(decoder, sample_rate, channel_count);- if (ret == OPUS_OK) {- magic = DecodeObjectMagic;- initialized = true;- state_valid = true;- self = this;- final_range = 0;- }- return ret;-}--s32 OpusDecodeObject::Shutdown() {- if (!state_valid) {- return OPUS_INVALID_STATE;- }-- if (initialized) {- magic = 0x0;- initialized = false;- state_valid = false;- self = nullptr;- final_range = 0;- decoder = nullptr;- }- return OPUS_OK;-}--s32 OpusDecodeObject::ResetDecoder() {- return opus_decoder_ctl(decoder, OPUS_RESET_STATE);-}--s32 OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size,- u64 input_data, u64 input_data_size) {- ASSERT(initialized);- out_sample_count = 0;-- if (!state_valid) {- return OPUS_INVALID_STATE;- }-- auto ret_code_or_samples = opus_decode(- decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),- reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);-- if (ret_code_or_samples < OPUS_OK) {- return ret_code_or_samples;- }-- out_sample_count = ret_code_or_samples;- return opus_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);-}--} // namespace AudioCore::ADSP::OpusDecoder+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#include "audio_core/adsp/apps/opus/opus_decode_object.h"+#include "common/assert.h"++namespace AudioCore::ADSP::OpusDecoder {+namespace {+bool IsValidChannelCount(u32 channel_count) {+ return channel_count == 1 || channel_count == 2;+}+} // namespace++u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {+ if (!IsValidChannelCount(channel_count)) {+ return 0;+ }+ return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);+}++OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {+ auto* new_decoder = reinterpret_cast<OpusDecodeObject*>(buffer);+ auto* comparison = reinterpret_cast<OpusDecodeObject*>(buffer2);++ if (new_decoder->magic == DecodeObjectMagic) {+ if (!new_decoder->initialized ||+ (new_decoder->initialized && new_decoder->self == comparison)) {+ new_decoder->state_valid = true;+ }+ } else {+ new_decoder->initialized = false;+ new_decoder->state_valid = true;+ }+ return *new_decoder;+}++s32 OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {+ if (!state_valid) {+ return OPUS_INVALID_STATE;+ }++ if (initialized) {+ return OPUS_OK;+ }++ // Unfortunately libopus does not expose the OpusDecoder struct publicly, so we can't include+ // it in this class. Nintendo does not allocate memory, which is why we have a workbuffer+ // provided.+ // We could use _create and have libopus allocate it for us, but then we have to separately+ // track which decoder is being used between this and multistream in order to call the correct+ // destroy from the host side.+ // This is a bit cringe, but is safe as these objects are only ever initialized inside the given+ // workbuffer, and GetWorkBufferSize will guarantee there's enough space to follow.+ decoder = (LibOpusDecoder*)(this + 1);+ s32 ret = opus_decoder_init(decoder, sample_rate, channel_count);+ if (ret == OPUS_OK) {+ magic = DecodeObjectMagic;+ initialized = true;+ state_valid = true;+ self = this;+ final_range = 0;+ }+ return ret;+}++s32 OpusDecodeObject::Shutdown() {+ if (!state_valid) {+ return OPUS_INVALID_STATE;+ }++ if (initialized) {+ magic = 0x0;+ initialized = false;+ state_valid = false;+ self = nullptr;+ final_range = 0;+ decoder = nullptr;+ }+ return OPUS_OK;+}++s32 OpusDecodeObject::ResetDecoder() {+ return opus_decoder_ctl(decoder, OPUS_RESET_STATE);+}++s32 OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size,+ u64 input_data, u64 input_data_size) {+ ASSERT(initialized);+ out_sample_count = 0;++ if (!state_valid) {+ return OPUS_INVALID_STATE;+ }++ auto ret_code_or_samples = opus_decode(+ decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),+ reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);++ if (ret_code_or_samples < OPUS_OK) {+ return ret_code_or_samples;+ }++ out_sample_count = ret_code_or_samples;+ return opus_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);+}++} // namespace AudioCore::ADSP::OpusDecoderdiff --git a/src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp b/src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cppindex f6d362e68c..7f1ed04509 100644--- a/src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp+++ b/src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp@@ -1,111 +1,111 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"-#include "common/assert.h"--namespace AudioCore::ADSP::OpusDecoder {--namespace {-bool IsValidChannelCount(u32 channel_count) {- return channel_count == 1 || channel_count == 2;-}--bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {- return total_stream_count > 0 && stereo_stream_count > 0 &&- stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);-}-} // namespace--u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count,- u32 stereo_stream_count) {- if (IsValidStreamCounts(total_stream_count, stereo_stream_count)) {- return static_cast<u32>(sizeof(OpusMultiStreamDecodeObject)) +- opus_multistream_decoder_get_size(total_stream_count, stereo_stream_count);- }- return 0;-}--OpusMultiStreamDecodeObject& OpusMultiStreamDecodeObject::Initialize(u64 buffer, u64 buffer2) {- auto* new_decoder = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer);- auto* comparison = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer2);-- if (new_decoder->magic == DecodeMultiStreamObjectMagic) {- if (!new_decoder->initialized ||- (new_decoder->initialized && new_decoder->self == comparison)) {- new_decoder->state_valid = true;- }- } else {- new_decoder->initialized = false;- new_decoder->state_valid = true;- }- return *new_decoder;-}--s32 OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count,- u32 channel_count, u32 stereo_stream_count,- u8* mappings) {- if (!state_valid) {- return OPUS_INVALID_STATE;- }-- if (initialized) {- return OPUS_OK;- }-- // See OpusDecodeObject::InitializeDecoder for an explanation of this- decoder = (LibOpusMSDecoder*)(this + 1);- s32 ret = opus_multistream_decoder_init(decoder, sample_rate, channel_count, total_stream_count,- stereo_stream_count, mappings);- if (ret == OPUS_OK) {- magic = DecodeMultiStreamObjectMagic;- initialized = true;- state_valid = true;- self = this;- final_range = 0;- }- return ret;-}--s32 OpusMultiStreamDecodeObject::Shutdown() {- if (!state_valid) {- return OPUS_INVALID_STATE;- }-- if (initialized) {- magic = 0x0;- initialized = false;- state_valid = false;- self = nullptr;- final_range = 0;- decoder = nullptr;- }- return OPUS_OK;-}--s32 OpusMultiStreamDecodeObject::ResetDecoder() {- return opus_multistream_decoder_ctl(decoder, OPUS_RESET_STATE);-}--s32 OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data,- u64 output_data_size, u64 input_data, u64 input_data_size) {- ASSERT(initialized);- out_sample_count = 0;-- if (!state_valid) {- return OPUS_INVALID_STATE;- }-- auto ret_code_or_samples = opus_multistream_decode(- decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),- reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);-- if (ret_code_or_samples < OPUS_OK) {- return ret_code_or_samples;- }-- out_sample_count = ret_code_or_samples;- return opus_multistream_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);-}--} // namespace AudioCore::ADSP::OpusDecoder+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"+#include "common/assert.h"++namespace AudioCore::ADSP::OpusDecoder {++namespace {+bool IsValidChannelCount(u32 channel_count) {+ return channel_count == 1 || channel_count == 2;+}++bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {+ return total_stream_count > 0 && stereo_stream_count > 0 &&+ stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);+}+} // namespace++u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count,+ u32 stereo_stream_count) {+ if (IsValidStreamCounts(total_stream_count, stereo_stream_count)) {+ return static_cast<u32>(sizeof(OpusMultiStreamDecodeObject)) ++ opus_multistream_decoder_get_size(total_stream_count, stereo_stream_count);+ }+ return 0;+}++OpusMultiStreamDecodeObject& OpusMultiStreamDecodeObject::Initialize(u64 buffer, u64 buffer2) {+ auto* new_decoder = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer);+ auto* comparison = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer2);++ if (new_decoder->magic == DecodeMultiStreamObjectMagic) {+ if (!new_decoder->initialized ||+ (new_decoder->initialized && new_decoder->self == comparison)) {+ new_decoder->state_valid = true;+ }+ } else {+ new_decoder->initialized = false;+ new_decoder->state_valid = true;+ }+ return *new_decoder;+}++s32 OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count,+ u32 channel_count, u32 stereo_stream_count,+ u8* mappings) {+ if (!state_valid) {+ return OPUS_INVALID_STATE;+ }++ if (initialized) {+ return OPUS_OK;+ }++ // See OpusDecodeObject::InitializeDecoder for an explanation of this+ decoder = (LibOpusMSDecoder*)(this + 1);+ s32 ret = opus_multistream_decoder_init(decoder, sample_rate, channel_count, total_stream_count,+ stereo_stream_count, mappings);+ if (ret == OPUS_OK) {+ magic = DecodeMultiStreamObjectMagic;+ initialized = true;+ state_valid = true;+ self = this;+ final_range = 0;+ }+ return ret;+}++s32 OpusMultiStreamDecodeObject::Shutdown() {+ if (!state_valid) {+ return OPUS_INVALID_STATE;+ }++ if (initialized) {+ magic = 0x0;+ initialized = false;+ state_valid = false;+ self = nullptr;+ final_range = 0;+ decoder = nullptr;+ }+ return OPUS_OK;+}++s32 OpusMultiStreamDecodeObject::ResetDecoder() {+ return opus_multistream_decoder_ctl(decoder, OPUS_RESET_STATE);+}++s32 OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data,+ u64 output_data_size, u64 input_data, u64 input_data_size) {+ ASSERT(initialized);+ out_sample_count = 0;++ if (!state_valid) {+ return OPUS_INVALID_STATE;+ }++ auto ret_code_or_samples = opus_multistream_decode(+ decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),+ reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);++ if (ret_code_or_samples < OPUS_OK) {+ return ret_code_or_samples;+ }++ out_sample_count = ret_code_or_samples;+ return opus_multistream_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);+}++} // namespace AudioCore::ADSP::OpusDecoderdiff --git a/src/audio_core/opus/decoder.cpp b/src/audio_core/opus/decoder.cppindex 5b23fce148..c6fd45f474 100644--- a/src/audio_core/opus/decoder.cpp+++ b/src/audio_core/opus/decoder.cpp@@ -1,179 +1,179 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include "audio_core/opus/decoder.h"-#include "audio_core/opus/hardware_opus.h"-#include "audio_core/opus/parameters.h"-#include "common/alignment.h"-#include "common/swap.h"-#include "core/core.h"--namespace AudioCore::OpusDecoder {-using namespace Service::Audio;-namespace {-OpusPacketHeader ReverseHeader(OpusPacketHeader header) {- OpusPacketHeader out;- out.size = Common::swap32(header.size);- out.final_range = Common::swap32(header.final_range);- return out;-}-} // namespace--OpusDecoder::OpusDecoder(Core::System& system_, HardwareOpus& hardware_opus_)- : system{system_}, hardware_opus{hardware_opus_} {}--OpusDecoder::~OpusDecoder() {- if (decode_object_initialized) {- hardware_opus.ShutdownDecodeObject(shared_buffer.get(), shared_buffer_size);- }-}--Result OpusDecoder::Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,- u64 transfer_memory_size) {- auto frame_size{params.use_large_frame_size ? 5760 : 1920};- shared_buffer_size = transfer_memory_size;- shared_buffer = std::make_unique<u8[]>(shared_buffer_size);- shared_memory_mapped = true;-- buffer_size =- Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 16);-- out_data = {shared_buffer.get() + shared_buffer_size - buffer_size, buffer_size};- size_t in_data_size{0x600u};- in_data = {out_data.data() - in_data_size, in_data_size};-- ON_RESULT_FAILURE {- if (shared_memory_mapped) {- shared_memory_mapped = false;- ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));- }- };-- R_TRY(hardware_opus.InitializeDecodeObject(params.sample_rate, params.channel_count,- shared_buffer.get(), shared_buffer_size));-- sample_rate = params.sample_rate;- channel_count = params.channel_count;- use_large_frame_size = params.use_large_frame_size;- decode_object_initialized = true;- R_SUCCEED();-}--Result OpusDecoder::Initialize(OpusMultiStreamParametersEx& params,- Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size) {- auto frame_size{params.use_large_frame_size ? 5760 : 1920};- shared_buffer_size = transfer_memory_size;- shared_buffer = std::make_unique<u8[]>(shared_buffer_size);- shared_memory_mapped = true;-- buffer_size =- Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 16);-- out_data = {shared_buffer.get() + shared_buffer_size - buffer_size, buffer_size};- size_t in_data_size{Common::AlignUp(1500ull * params.total_stream_count, 64u)};- in_data = {out_data.data() - in_data_size, in_data_size};-- ON_RESULT_FAILURE {- if (shared_memory_mapped) {- shared_memory_mapped = false;- ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));- }- };-- R_TRY(hardware_opus.InitializeMultiStreamDecodeObject(- params.sample_rate, params.channel_count, params.total_stream_count,- params.stereo_stream_count, params.mappings.data(), shared_buffer.get(),- shared_buffer_size));-- sample_rate = params.sample_rate;- channel_count = params.channel_count;- total_stream_count = params.total_stream_count;- stereo_stream_count = params.stereo_stream_count;- use_large_frame_size = params.use_large_frame_size;- decode_object_initialized = true;- R_SUCCEED();-}--Result OpusDecoder::DecodeInterleaved(u32* out_data_size, u64* out_time_taken,- u32* out_sample_count, std::span<const u8> input_data,- std::span<u8> output_data, bool reset) {- u32 out_samples;- u64 time_taken{};-- R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);-- auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};- OpusPacketHeader header{ReverseHeader(*header_p)};-- R_UNLESS(in_data.size_bytes() >= header.size &&- header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),- ResultBufferTooSmall);-- if (!shared_memory_mapped) {- R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));- shared_memory_mapped = true;- }-- std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);-- R_TRY(hardware_opus.DecodeInterleaved(out_samples, out_data.data(), out_data.size_bytes(),- channel_count, in_data.data(), header.size,- shared_buffer.get(), time_taken, reset));-- std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));-- *out_data_size = header.size + sizeof(OpusPacketHeader);- *out_sample_count = out_samples;- if (out_time_taken) {- *out_time_taken = time_taken / 1000;- }- R_SUCCEED();-}--Result OpusDecoder::SetContext([[maybe_unused]] std::span<const u8> context) {- R_SUCCEED_IF(shared_memory_mapped);- shared_memory_mapped = true;- R_RETURN(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));-}--Result OpusDecoder::DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,- u32* out_sample_count,- std::span<const u8> input_data,- std::span<u8> output_data, bool reset) {- u32 out_samples;- u64 time_taken{};-- R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);-- auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};- OpusPacketHeader header{ReverseHeader(*header_p)};-- LOG_ERROR(Service_Audio, "header size 0x{:X} input data size 0x{:X} in_data size 0x{:X}",- header.size, input_data.size_bytes(), in_data.size_bytes());-- R_UNLESS(in_data.size_bytes() >= header.size &&- header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),- ResultBufferTooSmall);-- if (!shared_memory_mapped) {- R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));- shared_memory_mapped = true;- }-- std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);-- R_TRY(hardware_opus.DecodeInterleavedForMultiStream(- out_samples, out_data.data(), out_data.size_bytes(), channel_count, in_data.data(),- header.size, shared_buffer.get(), time_taken, reset));-- std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));-- *out_data_size = header.size + sizeof(OpusPacketHeader);- *out_sample_count = out_samples;- if (out_time_taken) {- *out_time_taken = time_taken / 1000;- }- R_SUCCEED();-}--} // namespace AudioCore::OpusDecoder+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#include "audio_core/opus/decoder.h"+#include "audio_core/opus/hardware_opus.h"+#include "audio_core/opus/parameters.h"+#include "common/alignment.h"+#include "common/swap.h"+#include "core/core.h"++namespace AudioCore::OpusDecoder {+using namespace Service::Audio;+namespace {+OpusPacketHeader ReverseHeader(OpusPacketHeader header) {+ OpusPacketHeader out;+ out.size = Common::swap32(header.size);+ out.final_range = Common::swap32(header.final_range);+ return out;+}+} // namespace++OpusDecoder::OpusDecoder(Core::System& system_, HardwareOpus& hardware_opus_)+ : system{system_}, hardware_opus{hardware_opus_} {}++OpusDecoder::~OpusDecoder() {+ if (decode_object_initialized) {+ hardware_opus.ShutdownDecodeObject(shared_buffer.get(), shared_buffer_size);+ }+}++Result OpusDecoder::Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,+ u64 transfer_memory_size) {+ auto frame_size{params.use_large_frame_size ? 5760 : 1920};+ shared_buffer_size = transfer_memory_size;+ shared_buffer = std::make_unique<u8[]>(shared_buffer_size);+ shared_memory_mapped = true;++ buffer_size =+ Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 16);++ out_data = {shared_buffer.get() + shared_buffer_size - buffer_size, buffer_size};+ size_t in_data_size{0x600u};+ in_data = {out_data.data() - in_data_size, in_data_size};++ ON_RESULT_FAILURE {+ if (shared_memory_mapped) {+ shared_memory_mapped = false;+ ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));+ }+ };++ R_TRY(hardware_opus.InitializeDecodeObject(params.sample_rate, params.channel_count,+ shared_buffer.get(), shared_buffer_size));++ sample_rate = params.sample_rate;+ channel_count = params.channel_count;+ use_large_frame_size = params.use_large_frame_size;+ decode_object_initialized = true;+ R_SUCCEED();+}++Result OpusDecoder::Initialize(OpusMultiStreamParametersEx& params,+ Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size) {+ auto frame_size{params.use_large_frame_size ? 5760 : 1920};+ shared_buffer_size = transfer_memory_size;+ shared_buffer = std::make_unique<u8[]>(shared_buffer_size);+ shared_memory_mapped = true;++ buffer_size =+ Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 16);++ out_data = {shared_buffer.get() + shared_buffer_size - buffer_size, buffer_size};+ size_t in_data_size{Common::AlignUp(1500ull * params.total_stream_count, 64u)};+ in_data = {out_data.data() - in_data_size, in_data_size};++ ON_RESULT_FAILURE {+ if (shared_memory_mapped) {+ shared_memory_mapped = false;+ ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));+ }+ };++ R_TRY(hardware_opus.InitializeMultiStreamDecodeObject(+ params.sample_rate, params.channel_count, params.total_stream_count,+ params.stereo_stream_count, params.mappings.data(), shared_buffer.get(),+ shared_buffer_size));++ sample_rate = params.sample_rate;+ channel_count = params.channel_count;+ total_stream_count = params.total_stream_count;+ stereo_stream_count = params.stereo_stream_count;+ use_large_frame_size = params.use_large_frame_size;+ decode_object_initialized = true;+ R_SUCCEED();+}++Result OpusDecoder::DecodeInterleaved(u32* out_data_size, u64* out_time_taken,+ u32* out_sample_count, std::span<const u8> input_data,+ std::span<u8> output_data, bool reset) {+ u32 out_samples;+ u64 time_taken{};++ R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);++ auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};+ OpusPacketHeader header{ReverseHeader(*header_p)};++ R_UNLESS(in_data.size_bytes() >= header.size &&+ header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),+ ResultBufferTooSmall);++ if (!shared_memory_mapped) {+ R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));+ shared_memory_mapped = true;+ }++ std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);++ R_TRY(hardware_opus.DecodeInterleaved(out_samples, out_data.data(), out_data.size_bytes(),+ channel_count, in_data.data(), header.size,+ shared_buffer.get(), time_taken, reset));++ std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));++ *out_data_size = header.size + sizeof(OpusPacketHeader);+ *out_sample_count = out_samples;+ if (out_time_taken) {+ *out_time_taken = time_taken / 1000;+ }+ R_SUCCEED();+}++Result OpusDecoder::SetContext([[maybe_unused]] std::span<const u8> context) {+ R_SUCCEED_IF(shared_memory_mapped);+ shared_memory_mapped = true;+ R_RETURN(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));+}++Result OpusDecoder::DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,+ u32* out_sample_count,+ std::span<const u8> input_data,+ std::span<u8> output_data, bool reset) {+ u32 out_samples;+ u64 time_taken{};++ R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);++ auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};+ OpusPacketHeader header{ReverseHeader(*header_p)};++ LOG_ERROR(Service_Audio, "header size 0x{:X} input data size 0x{:X} in_data size 0x{:X}",+ header.size, input_data.size_bytes(), in_data.size_bytes());++ R_UNLESS(in_data.size_bytes() >= header.size &&+ header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),+ ResultBufferTooSmall);++ if (!shared_memory_mapped) {+ R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));+ shared_memory_mapped = true;+ }++ std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);++ R_TRY(hardware_opus.DecodeInterleavedForMultiStream(+ out_samples, out_data.data(), out_data.size_bytes(), channel_count, in_data.data(),+ header.size, shared_buffer.get(), time_taken, reset));++ std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));++ *out_data_size = header.size + sizeof(OpusPacketHeader);+ *out_sample_count = out_samples;+ if (out_time_taken) {+ *out_time_taken = time_taken / 1000;+ }+ R_SUCCEED();+}++} // namespace AudioCore::OpusDecoderdiff --git a/src/audio_core/opus/decoder.h b/src/audio_core/opus/decoder.hindex d08d8a4a4d..fd728958a4 100644--- a/src/audio_core/opus/decoder.h+++ b/src/audio_core/opus/decoder.h@@ -1,53 +1,53 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#pragma once--#include <span>--#include "audio_core/opus/parameters.h"-#include "common/common_types.h"-#include "core/hle/kernel/k_transfer_memory.h"-#include "core/hle/service/audio/errors.h"--namespace Core {-class System;-}--namespace AudioCore::OpusDecoder {-class HardwareOpus;--class OpusDecoder {-public:- explicit OpusDecoder(Core::System& system, HardwareOpus& hardware_opus_);- ~OpusDecoder();-- Result Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,- u64 transfer_memory_size);- Result Initialize(OpusMultiStreamParametersEx& params, Kernel::KTransferMemory* transfer_memory,- u64 transfer_memory_size);- Result DecodeInterleaved(u32* out_data_size, u64* out_time_taken, u32* out_sample_count,- std::span<const u8> input_data, std::span<u8> output_data, bool reset);- Result SetContext([[maybe_unused]] std::span<const u8> context);- Result DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,- u32* out_sample_count, std::span<const u8> input_data,- std::span<u8> output_data, bool reset);--private:- Core::System& system;- HardwareOpus& hardware_opus;- std::unique_ptr<u8[]> shared_buffer{};- u64 shared_buffer_size;- std::span<u8> in_data{};- std::span<u8> out_data{};- u64 buffer_size{};- s32 sample_rate{};- s32 channel_count{};- bool use_large_frame_size{false};- s32 total_stream_count{};- s32 stereo_stream_count{};- bool shared_memory_mapped{false};- bool decode_object_initialized{false};-};--} // namespace AudioCore::OpusDecoder+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#pragma once++#include <span>++#include "audio_core/opus/parameters.h"+#include "common/common_types.h"+#include "core/hle/kernel/k_transfer_memory.h"+#include "core/hle/service/audio/errors.h"++namespace Core {+class System;+}++namespace AudioCore::OpusDecoder {+class HardwareOpus;++class OpusDecoder {+public:+ explicit OpusDecoder(Core::System& system, HardwareOpus& hardware_opus_);+ ~OpusDecoder();++ Result Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,+ u64 transfer_memory_size);+ Result Initialize(OpusMultiStreamParametersEx& params, Kernel::KTransferMemory* transfer_memory,+ u64 transfer_memory_size);+ Result DecodeInterleaved(u32* out_data_size, u64* out_time_taken, u32* out_sample_count,+ std::span<const u8> input_data, std::span<u8> output_data, bool reset);+ Result SetContext([[maybe_unused]] std::span<const u8> context);+ Result DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,+ u32* out_sample_count, std::span<const u8> input_data,+ std::span<u8> output_data, bool reset);++private:+ Core::System& system;+ HardwareOpus& hardware_opus;+ std::unique_ptr<u8[]> shared_buffer{};+ u64 shared_buffer_size;+ std::span<u8> in_data{};+ std::span<u8> out_data{};+ u64 buffer_size{};+ s32 sample_rate{};+ s32 channel_count{};+ bool use_large_frame_size{false};+ s32 total_stream_count{};+ s32 stereo_stream_count{};+ bool shared_memory_mapped{false};+ bool decode_object_initialized{false};+};++} // namespace AudioCore::OpusDecoderdiff --git a/src/audio_core/opus/decoder_manager.cpp b/src/audio_core/opus/decoder_manager.cppindex fdeccdf50b..1464880a1b 100644--- a/src/audio_core/opus/decoder_manager.cpp+++ b/src/audio_core/opus/decoder_manager.cpp@@ -1,102 +1,102 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include "audio_core/adsp/apps/opus/opus_decoder.h"-#include "audio_core/opus/decoder_manager.h"-#include "common/alignment.h"-#include "core/core.h"--namespace AudioCore::OpusDecoder {-using namespace Service::Audio;--namespace {-bool IsValidChannelCount(u32 channel_count) {- return channel_count == 1 || channel_count == 2;-}--bool IsValidMultiStreamChannelCount(u32 channel_count) {- return channel_count > 0 && channel_count <= OpusStreamCountMax;-}--bool IsValidSampleRate(u32 sample_rate) {- return sample_rate == 8'000 || sample_rate == 12'000 || sample_rate == 16'000 ||- sample_rate == 24'000 || sample_rate == 48'000;-}--bool IsValidStreamCount(u32 channel_count, u32 total_stream_count, u32 stereo_stream_count) {- return total_stream_count > 0 && static_cast<s32>(stereo_stream_count) >= 0 &&- stereo_stream_count <= total_stream_count &&- total_stream_count + stereo_stream_count <= channel_count;-}--} // namespace--OpusDecoderManager::OpusDecoderManager(Core::System& system_)- : system{system_}, hardware_opus{system} {- for (u32 i = 0; i < MaxChannels; i++) {- required_workbuffer_sizes[i] = hardware_opus.GetWorkBufferSize(1 + i);- }-}--Result OpusDecoderManager::GetWorkBufferSize(OpusParameters& params, u64& out_size) {- OpusParametersEx ex{- .sample_rate = params.sample_rate,- .channel_count = params.channel_count,- .use_large_frame_size = false,- };- R_RETURN(GetWorkBufferSizeExEx(ex, out_size));-}--Result OpusDecoderManager::GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size) {- R_RETURN(GetWorkBufferSizeExEx(params, out_size));-}--Result OpusDecoderManager::GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size) {- R_UNLESS(IsValidChannelCount(params.channel_count), ResultInvalidOpusChannelCount);- R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);-- auto work_buffer_size{required_workbuffer_sizes[params.channel_count - 1]};- auto frame_size{params.use_large_frame_size ? 5760 : 1920};- work_buffer_size +=- Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);- out_size = work_buffer_size + 0x600;- R_SUCCEED();-}--Result OpusDecoderManager::GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params,- u64& out_size) {- OpusMultiStreamParametersEx ex{- .sample_rate = params.sample_rate,- .channel_count = params.channel_count,- .total_stream_count = params.total_stream_count,- .stereo_stream_count = params.stereo_stream_count,- .use_large_frame_size = false,- .mappings = {},- };- R_RETURN(GetWorkBufferSizeForMultiStreamExEx(ex, out_size));-}--Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params,- u64& out_size) {- R_RETURN(GetWorkBufferSizeForMultiStreamExEx(params, out_size));-}--Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params,- u64& out_size) {- R_UNLESS(IsValidMultiStreamChannelCount(params.channel_count), ResultInvalidOpusChannelCount);- R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);- R_UNLESS(IsValidStreamCount(params.channel_count, params.total_stream_count,- params.stereo_stream_count),- ResultInvalidOpusSampleRate);-- auto work_buffer_size{hardware_opus.GetWorkBufferSizeForMultiStream(- params.total_stream_count, params.stereo_stream_count)};- auto frame_size{params.use_large_frame_size ? 5760 : 1920};- work_buffer_size += Common::AlignUp(1500 * params.total_stream_count, 64);- work_buffer_size +=- Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);- out_size = work_buffer_size;- R_SUCCEED();-}--} // namespace AudioCore::OpusDecoder+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#include "audio_core/adsp/apps/opus/opus_decoder.h"+#include "audio_core/opus/decoder_manager.h"+#include "common/alignment.h"+#include "core/core.h"++namespace AudioCore::OpusDecoder {+using namespace Service::Audio;++namespace {+bool IsValidChannelCount(u32 channel_count) {+ return channel_count == 1 || channel_count == 2;+}++bool IsValidMultiStreamChannelCount(u32 channel_count) {+ return channel_count > 0 && channel_count <= OpusStreamCountMax;+}++bool IsValidSampleRate(u32 sample_rate) {+ return sample_rate == 8'000 || sample_rate == 12'000 || sample_rate == 16'000 ||+ sample_rate == 24'000 || sample_rate == 48'000;+}++bool IsValidStreamCount(u32 channel_count, u32 total_stream_count, u32 stereo_stream_count) {+ return total_stream_count > 0 && static_cast<s32>(stereo_stream_count) >= 0 &&+ stereo_stream_count <= total_stream_count &&+ total_stream_count + stereo_stream_count <= channel_count;+}++} // namespace++OpusDecoderManager::OpusDecoderManager(Core::System& system_)+ : system{system_}, hardware_opus{system} {+ for (u32 i = 0; i < MaxChannels; i++) {+ required_workbuffer_sizes[i] = hardware_opus.GetWorkBufferSize(1 + i);+ }+}++Result OpusDecoderManager::GetWorkBufferSize(OpusParameters& params, u64& out_size) {+ OpusParametersEx ex{+ .sample_rate = params.sample_rate,+ .channel_count = params.channel_count,+ .use_large_frame_size = false,+ };+ R_RETURN(GetWorkBufferSizeExEx(ex, out_size));+}++Result OpusDecoderManager::GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size) {+ R_RETURN(GetWorkBufferSizeExEx(params, out_size));+}++Result OpusDecoderManager::GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size) {+ R_UNLESS(IsValidChannelCount(params.channel_count), ResultInvalidOpusChannelCount);+ R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);++ auto work_buffer_size{required_workbuffer_sizes[params.channel_count - 1]};+ auto frame_size{params.use_large_frame_size ? 5760 : 1920};+ work_buffer_size +=+ Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);+ out_size = work_buffer_size + 0x600;+ R_SUCCEED();+}++Result OpusDecoderManager::GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params,+ u64& out_size) {+ OpusMultiStreamParametersEx ex{+ .sample_rate = params.sample_rate,+ .channel_count = params.channel_count,+ .total_stream_count = params.total_stream_count,+ .stereo_stream_count = params.stereo_stream_count,+ .use_large_frame_size = false,+ .mappings = {},+ };+ R_RETURN(GetWorkBufferSizeForMultiStreamExEx(ex, out_size));+}++Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params,+ u64& out_size) {+ R_RETURN(GetWorkBufferSizeForMultiStreamExEx(params, out_size));+}++Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params,+ u64& out_size) {+ R_UNLESS(IsValidMultiStreamChannelCount(params.channel_count), ResultInvalidOpusChannelCount);+ R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);+ R_UNLESS(IsValidStreamCount(params.channel_count, params.total_stream_count,+ params.stereo_stream_count),+ ResultInvalidOpusSampleRate);++ auto work_buffer_size{hardware_opus.GetWorkBufferSizeForMultiStream(+ params.total_stream_count, params.stereo_stream_count)};+ auto frame_size{params.use_large_frame_size ? 5760 : 1920};+ work_buffer_size += Common::AlignUp(1500 * params.total_stream_count, 64);+ work_buffer_size +=+ Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);+ out_size = work_buffer_size;+ R_SUCCEED();+}++} // namespace AudioCore::OpusDecoderdiff --git a/src/audio_core/opus/decoder_manager.h b/src/audio_core/opus/decoder_manager.hindex 466e1967b8..70ebc4babd 100644--- a/src/audio_core/opus/decoder_manager.h+++ b/src/audio_core/opus/decoder_manager.h@@ -1,38 +1,38 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#pragma once--#include "audio_core/opus/hardware_opus.h"-#include "audio_core/opus/parameters.h"-#include "common/common_types.h"-#include "core/hle/service/audio/errors.h"--namespace Core {-class System;-}--namespace AudioCore::OpusDecoder {--class OpusDecoderManager {-public:- OpusDecoderManager(Core::System& system);-- HardwareOpus& GetHardwareOpus() {- return hardware_opus;- }-- Result GetWorkBufferSize(OpusParameters& params, u64& out_size);- Result GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size);- Result GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size);- Result GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params, u64& out_size);- Result GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params, u64& out_size);- Result GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params, u64& out_size);--private:- Core::System& system;- HardwareOpus hardware_opus;- std::array<u64, MaxChannels> required_workbuffer_sizes{};-};--} // namespace AudioCore::OpusDecoder+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#pragma once++#include "audio_core/opus/hardware_opus.h"+#include "audio_core/opus/parameters.h"+#include "common/common_types.h"+#include "core/hle/service/audio/errors.h"++namespace Core {+class System;+}++namespace AudioCore::OpusDecoder {++class OpusDecoderManager {+public:+ OpusDecoderManager(Core::System& system);++ HardwareOpus& GetHardwareOpus() {+ return hardware_opus;+ }++ Result GetWorkBufferSize(OpusParameters& params, u64& out_size);+ Result GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size);+ Result GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size);+ Result GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params, u64& out_size);+ Result GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params, u64& out_size);+ Result GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params, u64& out_size);++private:+ Core::System& system;+ HardwareOpus hardware_opus;+ std::array<u64, MaxChannels> required_workbuffer_sizes{};+};++} // namespace AudioCore::OpusDecoderdiff --git a/src/audio_core/opus/hardware_opus.cpp b/src/audio_core/opus/hardware_opus.cppindex d6544dcb05..5ff71ab2d0 100644--- a/src/audio_core/opus/hardware_opus.cpp+++ b/src/audio_core/opus/hardware_opus.cpp@@ -1,241 +1,241 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#include <array>--#include "audio_core/audio_core.h"-#include "audio_core/opus/hardware_opus.h"-#include "core/core.h"--namespace AudioCore::OpusDecoder {-namespace {-using namespace Service::Audio;--static constexpr Result ResultCodeFromLibOpusErrorCode(u64 error_code) {- s32 error{static_cast<s32>(error_code)};- ASSERT(error <= OPUS_OK);- switch (error) {- case OPUS_ALLOC_FAIL:- R_THROW(ResultLibOpusAllocFail);- case OPUS_INVALID_STATE:- R_THROW(ResultLibOpusInvalidState);- case OPUS_UNIMPLEMENTED:- R_THROW(ResultLibOpusUnimplemented);- case OPUS_INVALID_PACKET:- R_THROW(ResultLibOpusInvalidPacket);- case OPUS_INTERNAL_ERROR:- R_THROW(ResultLibOpusInternalError);- case OPUS_BUFFER_TOO_SMALL:- R_THROW(ResultBufferTooSmall);- case OPUS_BAD_ARG:- R_THROW(ResultLibOpusBadArg);- case OPUS_OK:- R_RETURN(ResultSuccess);- }- UNREACHABLE();-}--} // namespace--HardwareOpus::HardwareOpus(Core::System& system_)- : system{system_}, opus_decoder{system.AudioCore().ADSP().OpusDecoder()} {- opus_decoder.SetSharedMemory(shared_memory);-}--u64 HardwareOpus::GetWorkBufferSize(u32 channel) {- if (!opus_decoder.IsRunning()) {- return 0;- }- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = channel;- opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::GetWorkBufferSize);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeOK) {- LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",- ADSP::OpusDecoder::Message::GetWorkBufferSizeOK, msg);- return 0;- }- return shared_memory.dsp_return_data[0];-}--u64 HardwareOpus::GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = total_stream_count;- shared_memory.host_send_data[1] = stereo_stream_count;- opus_decoder.Send(ADSP::Direction::DSP,- ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStream);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK) {- LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",- ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK, msg);- return 0;- }- return shared_memory.dsp_return_data[0];-}--Result HardwareOpus::InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,- u64 buffer_size) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = (u64)buffer;- shared_memory.host_send_data[1] = buffer_size;- shared_memory.host_send_data[2] = sample_rate;- shared_memory.host_send_data[3] = channel_count;-- opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::InitializeDecodeObject);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- if (msg != ADSP::OpusDecoder::Message::InitializeDecodeObjectOK) {- LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",- ADSP::OpusDecoder::Message::InitializeDecodeObjectOK, msg);- R_THROW(ResultInvalidOpusDSPReturnCode);- }-- R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));-}--Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,- u32 total_stream_count,- u32 stereo_stream_count, void* mappings,- void* buffer, u64 buffer_size) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = (u64)buffer;- shared_memory.host_send_data[1] = buffer_size;- shared_memory.host_send_data[2] = sample_rate;- shared_memory.host_send_data[3] = channel_count;- shared_memory.host_send_data[4] = total_stream_count;- shared_memory.host_send_data[5] = stereo_stream_count;-- ASSERT(channel_count <= MaxChannels);- std::memcpy(shared_memory.channel_mapping.data(), mappings, channel_count * sizeof(u8));-- opus_decoder.Send(ADSP::Direction::DSP,- ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObject);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- if (msg != ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK) {- LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",- ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK, msg);- R_THROW(ResultInvalidOpusDSPReturnCode);- }-- R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));-}--Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = (u64)buffer;- shared_memory.host_send_data[1] = buffer_size;-- opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::ShutdownDecodeObject);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK,- "Expected Opus shutdown code {}, got {}",- ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK, msg);-- R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));-}--Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = (u64)buffer;- shared_memory.host_send_data[1] = buffer_size;-- opus_decoder.Send(ADSP::Direction::DSP,- ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObject);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK,- "Expected Opus shutdown code {}, got {}",- ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK, msg);-- R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));-}--Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,- u64 output_data_size, u32 channel_count, void* input_data,- u64 input_data_size, void* buffer, u64& out_time_taken,- bool reset) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = (u64)buffer;- shared_memory.host_send_data[1] = (u64)input_data;- shared_memory.host_send_data[2] = input_data_size;- shared_memory.host_send_data[3] = (u64)output_data;- shared_memory.host_send_data[4] = output_data_size;- shared_memory.host_send_data[5] = 0;- shared_memory.host_send_data[6] = reset;-- opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::DecodeInterleaved);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedOK) {- LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",- ADSP::OpusDecoder::Message::DecodeInterleavedOK, msg);- R_THROW(ResultInvalidOpusDSPReturnCode);- }-- auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};- if (error_code == OPUS_OK) {- out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);- out_time_taken = 1000 * shared_memory.dsp_return_data[2];- }- R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));-}--Result HardwareOpus::DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,- u64 output_data_size, u32 channel_count,- void* input_data, u64 input_data_size,- void* buffer, u64& out_time_taken,- bool reset) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = (u64)buffer;- shared_memory.host_send_data[1] = (u64)input_data;- shared_memory.host_send_data[2] = input_data_size;- shared_memory.host_send_data[3] = (u64)output_data;- shared_memory.host_send_data[4] = output_data_size;- shared_memory.host_send_data[5] = 0;- shared_memory.host_send_data[6] = reset;-- opus_decoder.Send(ADSP::Direction::DSP,- ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStream);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK) {- LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",- ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK, msg);- R_THROW(ResultInvalidOpusDSPReturnCode);- }-- auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};- if (error_code == OPUS_OK) {- out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);- out_time_taken = 1000 * shared_memory.dsp_return_data[2];- }- R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));-}--Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = (u64)buffer;- shared_memory.host_send_data[1] = buffer_size;-- opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::MapMemory);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- if (msg != ADSP::OpusDecoder::Message::MapMemoryOK) {- LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",- ADSP::OpusDecoder::Message::MapMemoryOK, msg);- R_THROW(ResultInvalidOpusDSPReturnCode);- }- R_SUCCEED();-}--Result HardwareOpus::UnmapMemory(void* buffer, u64 buffer_size) {- std::scoped_lock l{mutex};- shared_memory.host_send_data[0] = (u64)buffer;- shared_memory.host_send_data[1] = buffer_size;-- opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::UnmapMemory);- auto msg = opus_decoder.Receive(ADSP::Direction::Host);- if (msg != ADSP::OpusDecoder::Message::UnmapMemoryOK) {- LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",- ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);- R_THROW(ResultInvalidOpusDSPReturnCode);- }- R_SUCCEED();-}--} // namespace AudioCore::OpusDecoder+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#include <array>++#include "audio_core/audio_core.h"+#include "audio_core/opus/hardware_opus.h"+#include "core/core.h"++namespace AudioCore::OpusDecoder {+namespace {+using namespace Service::Audio;++static constexpr Result ResultCodeFromLibOpusErrorCode(u64 error_code) {+ s32 error{static_cast<s32>(error_code)};+ ASSERT(error <= OPUS_OK);+ switch (error) {+ case OPUS_ALLOC_FAIL:+ R_THROW(ResultLibOpusAllocFail);+ case OPUS_INVALID_STATE:+ R_THROW(ResultLibOpusInvalidState);+ case OPUS_UNIMPLEMENTED:+ R_THROW(ResultLibOpusUnimplemented);+ case OPUS_INVALID_PACKET:+ R_THROW(ResultLibOpusInvalidPacket);+ case OPUS_INTERNAL_ERROR:+ R_THROW(ResultLibOpusInternalError);+ case OPUS_BUFFER_TOO_SMALL:+ R_THROW(ResultBufferTooSmall);+ case OPUS_BAD_ARG:+ R_THROW(ResultLibOpusBadArg);+ case OPUS_OK:+ R_RETURN(ResultSuccess);+ }+ UNREACHABLE();+}++} // namespace++HardwareOpus::HardwareOpus(Core::System& system_)+ : system{system_}, opus_decoder{system.AudioCore().ADSP().OpusDecoder()} {+ opus_decoder.SetSharedMemory(shared_memory);+}++u64 HardwareOpus::GetWorkBufferSize(u32 channel) {+ if (!opus_decoder.IsRunning()) {+ return 0;+ }+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = channel;+ opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::GetWorkBufferSize);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeOK) {+ LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",+ ADSP::OpusDecoder::Message::GetWorkBufferSizeOK, msg);+ return 0;+ }+ return shared_memory.dsp_return_data[0];+}++u64 HardwareOpus::GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = total_stream_count;+ shared_memory.host_send_data[1] = stereo_stream_count;+ opus_decoder.Send(ADSP::Direction::DSP,+ ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStream);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK) {+ LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",+ ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK, msg);+ return 0;+ }+ return shared_memory.dsp_return_data[0];+}++Result HardwareOpus::InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,+ u64 buffer_size) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = (u64)buffer;+ shared_memory.host_send_data[1] = buffer_size;+ shared_memory.host_send_data[2] = sample_rate;+ shared_memory.host_send_data[3] = channel_count;++ opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::InitializeDecodeObject);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ if (msg != ADSP::OpusDecoder::Message::InitializeDecodeObjectOK) {+ LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",+ ADSP::OpusDecoder::Message::InitializeDecodeObjectOK, msg);+ R_THROW(ResultInvalidOpusDSPReturnCode);+ }++ R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));+}++Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,+ u32 total_stream_count,+ u32 stereo_stream_count, void* mappings,+ void* buffer, u64 buffer_size) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = (u64)buffer;+ shared_memory.host_send_data[1] = buffer_size;+ shared_memory.host_send_data[2] = sample_rate;+ shared_memory.host_send_data[3] = channel_count;+ shared_memory.host_send_data[4] = total_stream_count;+ shared_memory.host_send_data[5] = stereo_stream_count;++ ASSERT(channel_count <= MaxChannels);+ std::memcpy(shared_memory.channel_mapping.data(), mappings, channel_count * sizeof(u8));++ opus_decoder.Send(ADSP::Direction::DSP,+ ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObject);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ if (msg != ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK) {+ LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",+ ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK, msg);+ R_THROW(ResultInvalidOpusDSPReturnCode);+ }++ R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));+}++Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = (u64)buffer;+ shared_memory.host_send_data[1] = buffer_size;++ opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::ShutdownDecodeObject);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK,+ "Expected Opus shutdown code {}, got {}",+ ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK, msg);++ R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));+}++Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = (u64)buffer;+ shared_memory.host_send_data[1] = buffer_size;++ opus_decoder.Send(ADSP::Direction::DSP,+ ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObject);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK,+ "Expected Opus shutdown code {}, got {}",+ ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK, msg);++ R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));+}++Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,+ u64 output_data_size, u32 channel_count, void* input_data,+ u64 input_data_size, void* buffer, u64& out_time_taken,+ bool reset) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = (u64)buffer;+ shared_memory.host_send_data[1] = (u64)input_data;+ shared_memory.host_send_data[2] = input_data_size;+ shared_memory.host_send_data[3] = (u64)output_data;+ shared_memory.host_send_data[4] = output_data_size;+ shared_memory.host_send_data[5] = 0;+ shared_memory.host_send_data[6] = reset;++ opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::DecodeInterleaved);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedOK) {+ LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",+ ADSP::OpusDecoder::Message::DecodeInterleavedOK, msg);+ R_THROW(ResultInvalidOpusDSPReturnCode);+ }++ auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};+ if (error_code == OPUS_OK) {+ out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);+ out_time_taken = 1000 * shared_memory.dsp_return_data[2];+ }+ R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));+}++Result HardwareOpus::DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,+ u64 output_data_size, u32 channel_count,+ void* input_data, u64 input_data_size,+ void* buffer, u64& out_time_taken,+ bool reset) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = (u64)buffer;+ shared_memory.host_send_data[1] = (u64)input_data;+ shared_memory.host_send_data[2] = input_data_size;+ shared_memory.host_send_data[3] = (u64)output_data;+ shared_memory.host_send_data[4] = output_data_size;+ shared_memory.host_send_data[5] = 0;+ shared_memory.host_send_data[6] = reset;++ opus_decoder.Send(ADSP::Direction::DSP,+ ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStream);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK) {+ LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",+ ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK, msg);+ R_THROW(ResultInvalidOpusDSPReturnCode);+ }++ auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};+ if (error_code == OPUS_OK) {+ out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);+ out_time_taken = 1000 * shared_memory.dsp_return_data[2];+ }+ R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));+}++Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = (u64)buffer;+ shared_memory.host_send_data[1] = buffer_size;++ opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::MapMemory);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ if (msg != ADSP::OpusDecoder::Message::MapMemoryOK) {+ LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",+ ADSP::OpusDecoder::Message::MapMemoryOK, msg);+ R_THROW(ResultInvalidOpusDSPReturnCode);+ }+ R_SUCCEED();+}++Result HardwareOpus::UnmapMemory(void* buffer, u64 buffer_size) {+ std::scoped_lock l{mutex};+ shared_memory.host_send_data[0] = (u64)buffer;+ shared_memory.host_send_data[1] = buffer_size;++ opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::UnmapMemory);+ auto msg = opus_decoder.Receive(ADSP::Direction::Host);+ if (msg != ADSP::OpusDecoder::Message::UnmapMemoryOK) {+ LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",+ ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);+ R_THROW(ResultInvalidOpusDSPReturnCode);+ }+ R_SUCCEED();+}++} // namespace AudioCore::OpusDecoderdiff --git a/src/audio_core/opus/hardware_opus.h b/src/audio_core/opus/hardware_opus.hindex 7013a6b404..b10184baa7 100644--- a/src/audio_core/opus/hardware_opus.h+++ b/src/audio_core/opus/hardware_opus.h@@ -1,45 +1,45 @@-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project-// SPDX-License-Identifier: GPL-2.0-or-later--#pragma once--#include <mutex>-#include <opus.h>--#include "audio_core/adsp/apps/opus/opus_decoder.h"-#include "audio_core/adsp/apps/opus/shared_memory.h"-#include "audio_core/adsp/mailbox.h"-#include "core/hle/service/audio/errors.h"--namespace AudioCore::OpusDecoder {-class HardwareOpus {-public:- HardwareOpus(Core::System& system);-- u64 GetWorkBufferSize(u32 channel);- u64 GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count);-- Result InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,- u64 buffer_size);- Result InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,- u32 totaL_stream_count, u32 stereo_stream_count,- void* mappings, void* buffer, u64 buffer_size);- Result ShutdownDecodeObject(void* buffer, u64 buffer_size);- Result ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size);- Result DecodeInterleaved(u32& out_sample_count, void* output_data, u64 output_data_size,- u32 channel_count, void* input_data, u64 input_data_size, void* buffer,- u64& out_time_taken, bool reset);- Result DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,- u64 output_data_size, u32 channel_count,- void* input_data, u64 input_data_size, void* buffer,- u64& out_time_taken, bool reset);- Result MapMemory(void* buffer, u64 buffer_size);- Result UnmapMemory(void* buffer, u64 buffer_size);--private:- Core::System& system;- std::mutex mutex;- ADSP::OpusDecoder::OpusDecoder& opus_decoder;- ADSP::OpusDecoder::SharedMemory shared_memory;-};-} // namespace AudioCore::OpusDecoder+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#pragma once++#include <mutex>+#include <opus.h>++#include "audio_core/adsp/apps/opus/opus_decoder.h"+#include "audio_core/adsp/apps/opus/shared_memory.h"+#include "audio_core/adsp/mailbox.h"+#include "core/hle/service/audio/errors.h"++namespace AudioCore::OpusDecoder {+class HardwareOpus {+public:+ HardwareOpus(Core::System& system);++ u64 GetWorkBufferSize(u32 channel);+ u64 GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count);++ Result InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,+ u64 buffer_size);+ Result InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,+ u32 totaL_stream_count, u32 stereo_stream_count,+ void* mappings, void* buffer, u64 buffer_size);+ Result ShutdownDecodeObject(void* buffer, u64 buffer_size);+ Result ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size);+ Result DecodeInterleaved(u32& out_sample_count, void* output_data, u64 output_data_size,+ u32 channel_count, void* input_data, u64 input_data_size, void* buffer,+ u64& out_time_taken, bool reset);+ Result DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,+ u64 output_data_size, u32 channel_count,+ void* input_data, u64 input_data_size, void* buffer,+ u64& out_time_taken, bool reset);+ Result MapMemory(void* buffer, u64 buffer_size);+ Result UnmapMemory(void* buffer, u64 buffer_size);++private:+ Core::System& system;+ std::mutex mutex;+ ADSP::OpusDecoder::OpusDecoder& opus_decoder;+ ADSP::OpusDecoder::SharedMemory shared_memory;+};+} // namespace AudioCore::OpusDecoderdiff --git a/src/yuzu/configuration/config.h b/src/yuzu/configuration/config.hindex 74ec4f771e..1589ba0577 100644--- a/src/yuzu/configuration/config.h+++ b/src/yuzu/configuration/config.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: 2014 Citra Emulator Project+// SPDX-FileCopyrightText: 2014 Citra Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#pragma oncediff --git a/src/yuzu/configuration/configure_camera.h b/src/yuzu/configuration/configure_camera.hindex 9a90512b3e..3d822da7bb 100644--- a/src/yuzu/configuration/configure_camera.h+++ b/src/yuzu/configuration/configure_camera.h@@ -1,4 +1,4 @@-// Text : Copyright 2022 yuzu Emulator Project+// Text : Copyright 2022 yuzu Emulator Project// SPDX-License-Identifier: GPL-3.0-or-later#pragma oncediff --git a/src/yuzu/configuration/configure_input.h b/src/yuzu/configuration/configure_input.hindex 136cd3a0a3..beb503dae0 100644--- a/src/yuzu/configuration/configure_input.h+++ b/src/yuzu/configuration/configure_input.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: 2016 Citra Emulator Project+// SPDX-FileCopyrightText: 2016 Citra Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#pragma oncediff --git a/src/yuzu/configuration/configure_input_player.h b/src/yuzu/configuration/configure_input_player.hindex d3255d2b44..fda09e9257 100644--- a/src/yuzu/configuration/configure_input_player.h+++ b/src/yuzu/configuration/configure_input_player.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: 2016 Citra Emulator Project+// SPDX-FileCopyrightText: 2016 Citra Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#pragma oncediff --git a/src/yuzu/configuration/configure_per_game.h b/src/yuzu/configuration/configure_per_game.hindex 1a727f32c0..cc2513001d 100644--- a/src/yuzu/configuration/configure_per_game.h+++ b/src/yuzu/configuration/configure_per_game.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#pragma oncediff --git a/src/yuzu/configuration/configure_ringcon.h b/src/yuzu/configuration/configure_ringcon.hindex b23c279061..6fd95e2b8d 100644--- a/src/yuzu/configuration/configure_ringcon.h+++ b/src/yuzu/configuration/configure_ringcon.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#pragma oncediff --git a/src/yuzu/configuration/configure_tas.h b/src/yuzu/configuration/configure_tas.hindex 4a6b0ba4ef..a918919064 100644--- a/src/yuzu/configuration/configure_tas.h+++ b/src/yuzu/configuration/configure_tas.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project+// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#pragma oncediff --git a/src/yuzu/configuration/configure_touchscreen_advanced.h b/src/yuzu/configuration/configure_touchscreen_advanced.hindex 034dc0d465..b6fdffdc83 100644--- a/src/yuzu/configuration/configure_touchscreen_advanced.h+++ b/src/yuzu/configuration/configure_touchscreen_advanced.h@@ -1,4 +1,4 @@-// SPDX-FileCopyrightText: 2016 Citra Emulator Project+// SPDX-FileCopyrightText: 2016 Citra Emulator Project// SPDX-License-Identifier: GPL-2.0-or-later#pragma once