Android #124

service: am: Set the correct album program id

.git-blame-ignore-revs

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+# CRLF -> LF
+90aa937593e53a5d5e070fb623b228578b0b225f

src/audio_core/adsp/apps/opus/opus_decode_object.cpp

@@ -1,107 +1,107 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-
+
-#include "audio_core/adsp/apps/opus/opus_decode_object.h"
+#include "audio_core/adsp/apps/opus/opus_decode_object.h"
-#include "common/assert.h"
+#include "common/assert.h"
-
+
-namespace AudioCore::ADSP::OpusDecoder {
+namespace AudioCore::ADSP::OpusDecoder {
-namespace {
+namespace {
-bool IsValidChannelCount(u32 channel_count) {
+bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
+    return channel_count == 1 || channel_count == 2;
-}
+}
-} // namespace
+} // namespace
-
+
-u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {
+u32 OpusDecodeObject::GetWorkBufferSize(u32 channel_count) {
-    if (!IsValidChannelCount(channel_count)) {
+    if (!IsValidChannelCount(channel_count)) {
-        return 0;
+        return 0;
-    }
+    }
-    return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
+    return static_cast<u32>(sizeof(OpusDecodeObject)) + opus_decoder_get_size(channel_count);
-}
+}
-
+
-OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {
+OpusDecodeObject& OpusDecodeObject::Initialize(u64 buffer, u64 buffer2) {
-    auto* new_decoder = reinterpret_cast<OpusDecodeObject*>(buffer);
+    auto* new_decoder = reinterpret_cast<OpusDecodeObject*>(buffer);
-    auto* comparison = reinterpret_cast<OpusDecodeObject*>(buffer2);
+    auto* comparison = reinterpret_cast<OpusDecodeObject*>(buffer2);
-
+
-    if (new_decoder->magic == DecodeObjectMagic) {
+    if (new_decoder->magic == DecodeObjectMagic) {
-        if (!new_decoder->initialized ||
+        if (!new_decoder->initialized ||
-            (new_decoder->initialized && new_decoder->self == comparison)) {
+            (new_decoder->initialized && new_decoder->self == comparison)) {
-            new_decoder->state_valid = true;
+            new_decoder->state_valid = true;
-        }
+        }
-    } else {
+    } else {
-        new_decoder->initialized = false;
+        new_decoder->initialized = false;
-        new_decoder->state_valid = true;
+        new_decoder->state_valid = true;
-    }
+    }
-    return *new_decoder;
+    return *new_decoder;
-}
+}
-
+
-s32 OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {
+s32 OpusDecodeObject::InitializeDecoder(u32 sample_rate, u32 channel_count) {
-    if (!state_valid) {
+    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+        return OPUS_INVALID_STATE;
-    }
+    }
-
+
-    if (initialized) {
+    if (initialized) {
-        return OPUS_OK;
+        return OPUS_OK;
-    }
+    }
-
+
-    // Unfortunately libopus does not expose the OpusDecoder struct publicly, so we can't include
+    // 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
+    // it in this class. Nintendo does not allocate memory, which is why we have a workbuffer
-    // provided.
+    // provided.
-    // We could use _create and have libopus allocate it for us, but then we have to separately
+    // 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
+    // track which decoder is being used between this and multistream in order to call the correct
-    // destroy from the host side.
+    // destroy from the host side.
-    // This is a bit cringe, but is safe as these objects are only ever initialized inside the given
+    // 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.
+    // workbuffer, and GetWorkBufferSize will guarantee there's enough space to follow.
-    decoder = (LibOpusDecoder*)(this + 1);
+    decoder = (LibOpusDecoder*)(this + 1);
-    s32 ret = opus_decoder_init(decoder, sample_rate, channel_count);
+    s32 ret = opus_decoder_init(decoder, sample_rate, channel_count);
-    if (ret == OPUS_OK) {
+    if (ret == OPUS_OK) {
-        magic = DecodeObjectMagic;
+        magic = DecodeObjectMagic;
-        initialized = true;
+        initialized = true;
-        state_valid = true;
+        state_valid = true;
-        self = this;
+        self = this;
-        final_range = 0;
+        final_range = 0;
-    }
+    }
-    return ret;
+    return ret;
-}
+}
-
+
-s32 OpusDecodeObject::Shutdown() {
+s32 OpusDecodeObject::Shutdown() {
-    if (!state_valid) {
+    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+        return OPUS_INVALID_STATE;
-    }
+    }
-
+
-    if (initialized) {
+    if (initialized) {
-        magic = 0x0;
+        magic = 0x0;
-        initialized = false;
+        initialized = false;
-        state_valid = false;
+        state_valid = false;
-        self = nullptr;
+        self = nullptr;
-        final_range = 0;
+        final_range = 0;
-        decoder = nullptr;
+        decoder = nullptr;
-    }
+    }
-    return OPUS_OK;
+    return OPUS_OK;
-}
+}
-
+
-s32 OpusDecodeObject::ResetDecoder() {
+s32 OpusDecodeObject::ResetDecoder() {
-    return opus_decoder_ctl(decoder, OPUS_RESET_STATE);
+    return opus_decoder_ctl(decoder, OPUS_RESET_STATE);
-}
+}
-
+
-s32 OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size,
+s32 OpusDecodeObject::Decode(u32& out_sample_count, u64 output_data, u64 output_data_size,
-                             u64 input_data, u64 input_data_size) {
+                             u64 input_data, u64 input_data_size) {
-    ASSERT(initialized);
+    ASSERT(initialized);
-    out_sample_count = 0;
+    out_sample_count = 0;
-
+
-    if (!state_valid) {
+    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+        return OPUS_INVALID_STATE;
-    }
+    }
-
+
-    auto ret_code_or_samples = opus_decode(
+    auto ret_code_or_samples = opus_decode(
-        decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),
+        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);
+        reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);
-
+
-    if (ret_code_or_samples < OPUS_OK) {
+    if (ret_code_or_samples < OPUS_OK) {
-        return ret_code_or_samples;
+        return ret_code_or_samples;
-    }
+    }
-
+
-    out_sample_count = ret_code_or_samples;
+    out_sample_count = ret_code_or_samples;
-    return opus_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
+    return opus_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
-}
+}
-
+
-} // namespace AudioCore::ADSP::OpusDecoder
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/adsp/apps/opus/opus_multistream_decode_object.cpp

@@ -1,111 +1,111 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-
+
-#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
+#include "audio_core/adsp/apps/opus/opus_multistream_decode_object.h"
-#include "common/assert.h"
+#include "common/assert.h"
-
+
-namespace AudioCore::ADSP::OpusDecoder {
+namespace AudioCore::ADSP::OpusDecoder {
-
+
-namespace {
+namespace {
-bool IsValidChannelCount(u32 channel_count) {
+bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
+    return channel_count == 1 || channel_count == 2;
-}
+}
-
+
-bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
+bool IsValidStreamCounts(u32 total_stream_count, u32 stereo_stream_count) {
-    return total_stream_count > 0 && stereo_stream_count > 0 &&
+    return total_stream_count > 0 && stereo_stream_count > 0 &&
-           stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);
+           stereo_stream_count <= total_stream_count && IsValidChannelCount(total_stream_count);
-}
+}
-} // namespace
+} // namespace
-
+
-u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count,
+u32 OpusMultiStreamDecodeObject::GetWorkBufferSize(u32 total_stream_count,
-                                                   u32 stereo_stream_count) {
+                                                   u32 stereo_stream_count) {
-    if (IsValidStreamCounts(total_stream_count, stereo_stream_count)) {
+    if (IsValidStreamCounts(total_stream_count, stereo_stream_count)) {
-        return static_cast<u32>(sizeof(OpusMultiStreamDecodeObject)) +
+        return static_cast<u32>(sizeof(OpusMultiStreamDecodeObject)) +
-               opus_multistream_decoder_get_size(total_stream_count, stereo_stream_count);
+               opus_multistream_decoder_get_size(total_stream_count, stereo_stream_count);
-    }
+    }
-    return 0;
+    return 0;
-}
+}
-
+
-OpusMultiStreamDecodeObject& OpusMultiStreamDecodeObject::Initialize(u64 buffer, u64 buffer2) {
+OpusMultiStreamDecodeObject& OpusMultiStreamDecodeObject::Initialize(u64 buffer, u64 buffer2) {
-    auto* new_decoder = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer);
+    auto* new_decoder = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer);
-    auto* comparison = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer2);
+    auto* comparison = reinterpret_cast<OpusMultiStreamDecodeObject*>(buffer2);
-
+
-    if (new_decoder->magic == DecodeMultiStreamObjectMagic) {
+    if (new_decoder->magic == DecodeMultiStreamObjectMagic) {
-        if (!new_decoder->initialized ||
+        if (!new_decoder->initialized ||
-            (new_decoder->initialized && new_decoder->self == comparison)) {
+            (new_decoder->initialized && new_decoder->self == comparison)) {
-            new_decoder->state_valid = true;
+            new_decoder->state_valid = true;
-        }
+        }
-    } else {
+    } else {
-        new_decoder->initialized = false;
+        new_decoder->initialized = false;
-        new_decoder->state_valid = true;
+        new_decoder->state_valid = true;
-    }
+    }
-    return *new_decoder;
+    return *new_decoder;
-}
+}
-
+
-s32 OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count,
+s32 OpusMultiStreamDecodeObject::InitializeDecoder(u32 sample_rate, u32 total_stream_count,
-                                                   u32 channel_count, u32 stereo_stream_count,
+                                                   u32 channel_count, u32 stereo_stream_count,
-                                                   u8* mappings) {
+                                                   u8* mappings) {
-    if (!state_valid) {
+    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+        return OPUS_INVALID_STATE;
-    }
+    }
-
+
-    if (initialized) {
+    if (initialized) {
-        return OPUS_OK;
+        return OPUS_OK;
-    }
+    }
-
+
-    // See OpusDecodeObject::InitializeDecoder for an explanation of this
+    // See OpusDecodeObject::InitializeDecoder for an explanation of this
-    decoder = (LibOpusMSDecoder*)(this + 1);
+    decoder = (LibOpusMSDecoder*)(this + 1);
-    s32 ret = opus_multistream_decoder_init(decoder, sample_rate, channel_count, total_stream_count,
+    s32 ret = opus_multistream_decoder_init(decoder, sample_rate, channel_count, total_stream_count,
-                                            stereo_stream_count, mappings);
+                                            stereo_stream_count, mappings);
-    if (ret == OPUS_OK) {
+    if (ret == OPUS_OK) {
-        magic = DecodeMultiStreamObjectMagic;
+        magic = DecodeMultiStreamObjectMagic;
-        initialized = true;
+        initialized = true;
-        state_valid = true;
+        state_valid = true;
-        self = this;
+        self = this;
-        final_range = 0;
+        final_range = 0;
-    }
+    }
-    return ret;
+    return ret;
-}
+}
-
+
-s32 OpusMultiStreamDecodeObject::Shutdown() {
+s32 OpusMultiStreamDecodeObject::Shutdown() {
-    if (!state_valid) {
+    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+        return OPUS_INVALID_STATE;
-    }
+    }
-
+
-    if (initialized) {
+    if (initialized) {
-        magic = 0x0;
+        magic = 0x0;
-        initialized = false;
+        initialized = false;
-        state_valid = false;
+        state_valid = false;
-        self = nullptr;
+        self = nullptr;
-        final_range = 0;
+        final_range = 0;
-        decoder = nullptr;
+        decoder = nullptr;
-    }
+    }
-    return OPUS_OK;
+    return OPUS_OK;
-}
+}
-
+
-s32 OpusMultiStreamDecodeObject::ResetDecoder() {
+s32 OpusMultiStreamDecodeObject::ResetDecoder() {
-    return opus_multistream_decoder_ctl(decoder, OPUS_RESET_STATE);
+    return opus_multistream_decoder_ctl(decoder, OPUS_RESET_STATE);
-}
+}
-
+
-s32 OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data,
+s32 OpusMultiStreamDecodeObject::Decode(u32& out_sample_count, u64 output_data,
-                                        u64 output_data_size, u64 input_data, u64 input_data_size) {
+                                        u64 output_data_size, u64 input_data, u64 input_data_size) {
-    ASSERT(initialized);
+    ASSERT(initialized);
-    out_sample_count = 0;
+    out_sample_count = 0;
-
+
-    if (!state_valid) {
+    if (!state_valid) {
-        return OPUS_INVALID_STATE;
+        return OPUS_INVALID_STATE;
-    }
+    }
-
+
-    auto ret_code_or_samples = opus_multistream_decode(
+    auto ret_code_or_samples = opus_multistream_decode(
-        decoder, reinterpret_cast<const u8*>(input_data), static_cast<opus_int32>(input_data_size),
+        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);
+        reinterpret_cast<opus_int16*>(output_data), static_cast<opus_int32>(output_data_size), 0);
-
+
-    if (ret_code_or_samples < OPUS_OK) {
+    if (ret_code_or_samples < OPUS_OK) {
-        return ret_code_or_samples;
+        return ret_code_or_samples;
-    }
+    }
-
+
-    out_sample_count = ret_code_or_samples;
+    out_sample_count = ret_code_or_samples;
-    return opus_multistream_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
+    return opus_multistream_decoder_ctl(decoder, OPUS_GET_FINAL_RANGE_REQUEST, &final_range);
-}
+}
-
+
-} // namespace AudioCore::ADSP::OpusDecoder
+} // namespace AudioCore::ADSP::OpusDecoder

src/audio_core/opus/decoder.cpp

@@ -1,179 +1,179 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-
+
-#include "audio_core/opus/decoder.h"
+#include "audio_core/opus/decoder.h"
-#include "audio_core/opus/hardware_opus.h"
+#include "audio_core/opus/hardware_opus.h"
-#include "audio_core/opus/parameters.h"
+#include "audio_core/opus/parameters.h"
-#include "common/alignment.h"
+#include "common/alignment.h"
-#include "common/swap.h"
+#include "common/swap.h"
-#include "core/core.h"
+#include "core/core.h"
-
+
-namespace AudioCore::OpusDecoder {
+namespace AudioCore::OpusDecoder {
-using namespace Service::Audio;
+using namespace Service::Audio;
-namespace {
+namespace {
-OpusPacketHeader ReverseHeader(OpusPacketHeader header) {
+OpusPacketHeader ReverseHeader(OpusPacketHeader header) {
-    OpusPacketHeader out;
+    OpusPacketHeader out;
-    out.size = Common::swap32(header.size);
+    out.size = Common::swap32(header.size);
-    out.final_range = Common::swap32(header.final_range);
+    out.final_range = Common::swap32(header.final_range);
-    return out;
+    return out;
-}
+}
-} // namespace
+} // namespace
-
+
-OpusDecoder::OpusDecoder(Core::System& system_, HardwareOpus& hardware_opus_)
+OpusDecoder::OpusDecoder(Core::System& system_, HardwareOpus& hardware_opus_)
-    : system{system_}, hardware_opus{hardware_opus_} {}
+    : system{system_}, hardware_opus{hardware_opus_} {}
-
+
-OpusDecoder::~OpusDecoder() {
+OpusDecoder::~OpusDecoder() {
-    if (decode_object_initialized) {
+    if (decode_object_initialized) {
-        hardware_opus.ShutdownDecodeObject(shared_buffer.get(), shared_buffer_size);
+        hardware_opus.ShutdownDecodeObject(shared_buffer.get(), shared_buffer_size);
-    }
+    }
-}
+}
-
+
-Result OpusDecoder::Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,
+Result OpusDecoder::Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,
-                               u64 transfer_memory_size) {
+                               u64 transfer_memory_size) {
-    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
+    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
-    shared_buffer_size = transfer_memory_size;
+    shared_buffer_size = transfer_memory_size;
-    shared_buffer = std::make_unique<u8[]>(shared_buffer_size);
+    shared_buffer = std::make_unique<u8[]>(shared_buffer_size);
-    shared_memory_mapped = true;
+    shared_memory_mapped = true;
-
+
-    buffer_size =
+    buffer_size =
-        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 16);
+        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};
+    out_data = {shared_buffer.get() + shared_buffer_size - buffer_size, buffer_size};
-    size_t in_data_size{0x600u};
+    size_t in_data_size{0x600u};
-    in_data = {out_data.data() - in_data_size, in_data_size};
+    in_data = {out_data.data() - in_data_size, in_data_size};
-
+
-    ON_RESULT_FAILURE {
+    ON_RESULT_FAILURE {
-        if (shared_memory_mapped) {
+        if (shared_memory_mapped) {
-            shared_memory_mapped = false;
+            shared_memory_mapped = false;
-            ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));
+            ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));
-        }
+        }
-    };
+    };
-
+
-    R_TRY(hardware_opus.InitializeDecodeObject(params.sample_rate, params.channel_count,
+    R_TRY(hardware_opus.InitializeDecodeObject(params.sample_rate, params.channel_count,
-                                               shared_buffer.get(), shared_buffer_size));
+                                               shared_buffer.get(), shared_buffer_size));
-
+
-    sample_rate = params.sample_rate;
+    sample_rate = params.sample_rate;
-    channel_count = params.channel_count;
+    channel_count = params.channel_count;
-    use_large_frame_size = params.use_large_frame_size;
+    use_large_frame_size = params.use_large_frame_size;
-    decode_object_initialized = true;
+    decode_object_initialized = true;
-    R_SUCCEED();
+    R_SUCCEED();
-}
+}
-
+
-Result OpusDecoder::Initialize(OpusMultiStreamParametersEx& params,
+Result OpusDecoder::Initialize(OpusMultiStreamParametersEx& params,
-                               Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size) {
+                               Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size) {
-    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
+    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
-    shared_buffer_size = transfer_memory_size;
+    shared_buffer_size = transfer_memory_size;
-    shared_buffer = std::make_unique<u8[]>(shared_buffer_size);
+    shared_buffer = std::make_unique<u8[]>(shared_buffer_size);
-    shared_memory_mapped = true;
+    shared_memory_mapped = true;
-
+
-    buffer_size =
+    buffer_size =
-        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 16);
+        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};
+    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)};
+    size_t in_data_size{Common::AlignUp(1500ull * params.total_stream_count, 64u)};
-    in_data = {out_data.data() - in_data_size, in_data_size};
+    in_data = {out_data.data() - in_data_size, in_data_size};
-
+
-    ON_RESULT_FAILURE {
+    ON_RESULT_FAILURE {
-        if (shared_memory_mapped) {
+        if (shared_memory_mapped) {
-            shared_memory_mapped = false;
+            shared_memory_mapped = false;
-            ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));
+            ASSERT(R_SUCCEEDED(hardware_opus.UnmapMemory(shared_buffer.get(), shared_buffer_size)));
-        }
+        }
-    };
+    };
-
+
-    R_TRY(hardware_opus.InitializeMultiStreamDecodeObject(
+    R_TRY(hardware_opus.InitializeMultiStreamDecodeObject(
-        params.sample_rate, params.channel_count, params.total_stream_count,
+        params.sample_rate, params.channel_count, params.total_stream_count,
-        params.stereo_stream_count, params.mappings.data(), shared_buffer.get(),
+        params.stereo_stream_count, params.mappings.data(), shared_buffer.get(),
-        shared_buffer_size));
+        shared_buffer_size));
-
+
-    sample_rate = params.sample_rate;
+    sample_rate = params.sample_rate;
-    channel_count = params.channel_count;
+    channel_count = params.channel_count;
-    total_stream_count = params.total_stream_count;
+    total_stream_count = params.total_stream_count;
-    stereo_stream_count = params.stereo_stream_count;
+    stereo_stream_count = params.stereo_stream_count;
-    use_large_frame_size = params.use_large_frame_size;
+    use_large_frame_size = params.use_large_frame_size;
-    decode_object_initialized = true;
+    decode_object_initialized = true;
-    R_SUCCEED();
+    R_SUCCEED();
-}
+}
-
+
-Result OpusDecoder::DecodeInterleaved(u32* out_data_size, u64* out_time_taken,
+Result OpusDecoder::DecodeInterleaved(u32* out_data_size, u64* out_time_taken,
-                                      u32* out_sample_count, std::span<const u8> input_data,
+                                      u32* out_sample_count, std::span<const u8> input_data,
-                                      std::span<u8> output_data, bool reset) {
+                                      std::span<u8> output_data, bool reset) {
-    u32 out_samples;
+    u32 out_samples;
-    u64 time_taken{};
+    u64 time_taken{};
-
+
-    R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);
+    R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);
-
+
-    auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};
+    auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};
-    OpusPacketHeader header{ReverseHeader(*header_p)};
+    OpusPacketHeader header{ReverseHeader(*header_p)};
-
+
-    R_UNLESS(in_data.size_bytes() >= header.size &&
+    R_UNLESS(in_data.size_bytes() >= header.size &&
-                 header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),
+                 header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),
-             ResultBufferTooSmall);
+             ResultBufferTooSmall);
-
+
-    if (!shared_memory_mapped) {
+    if (!shared_memory_mapped) {
-        R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
+        R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
-        shared_memory_mapped = true;
+        shared_memory_mapped = true;
-    }
+    }
-
+
-    std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);
+    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(),
+    R_TRY(hardware_opus.DecodeInterleaved(out_samples, out_data.data(), out_data.size_bytes(),
-                                          channel_count, in_data.data(), header.size,
+                                          channel_count, in_data.data(), header.size,
-                                          shared_buffer.get(), time_taken, reset));
+                                          shared_buffer.get(), time_taken, reset));
-
+
-    std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));
+    std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));
-
+
-    *out_data_size = header.size + sizeof(OpusPacketHeader);
+    *out_data_size = header.size + sizeof(OpusPacketHeader);
-    *out_sample_count = out_samples;
+    *out_sample_count = out_samples;
-    if (out_time_taken) {
+    if (out_time_taken) {
-        *out_time_taken = time_taken / 1000;
+        *out_time_taken = time_taken / 1000;
-    }
+    }
-    R_SUCCEED();
+    R_SUCCEED();
-}
+}
-
+
-Result OpusDecoder::SetContext([[maybe_unused]] std::span<const u8> context) {
+Result OpusDecoder::SetContext([[maybe_unused]] std::span<const u8> context) {
-    R_SUCCEED_IF(shared_memory_mapped);
+    R_SUCCEED_IF(shared_memory_mapped);
-    shared_memory_mapped = true;
+    shared_memory_mapped = true;
-    R_RETURN(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
+    R_RETURN(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
-}
+}
-
+
-Result OpusDecoder::DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,
+Result OpusDecoder::DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,
-                                                    u32* out_sample_count,
+                                                    u32* out_sample_count,
-                                                    std::span<const u8> input_data,
+                                                    std::span<const u8> input_data,
-                                                    std::span<u8> output_data, bool reset) {
+                                                    std::span<u8> output_data, bool reset) {
-    u32 out_samples;
+    u32 out_samples;
-    u64 time_taken{};
+    u64 time_taken{};
-
+
-    R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);
+    R_UNLESS(input_data.size_bytes() > sizeof(OpusPacketHeader), ResultInputDataTooSmall);
-
+
-    auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};
+    auto* header_p{reinterpret_cast<const OpusPacketHeader*>(input_data.data())};
-    OpusPacketHeader header{ReverseHeader(*header_p)};
+    OpusPacketHeader header{ReverseHeader(*header_p)};
-
+
-    LOG_ERROR(Service_Audio, "header size 0x{:X} input data size 0x{:X} in_data size 0x{:X}",
+    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());
+              header.size, input_data.size_bytes(), in_data.size_bytes());
-
+
-    R_UNLESS(in_data.size_bytes() >= header.size &&
+    R_UNLESS(in_data.size_bytes() >= header.size &&
-                 header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),
+                 header.size + sizeof(OpusPacketHeader) <= input_data.size_bytes(),
-             ResultBufferTooSmall);
+             ResultBufferTooSmall);
-
+
-    if (!shared_memory_mapped) {
+    if (!shared_memory_mapped) {
-        R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
+        R_TRY(hardware_opus.MapMemory(shared_buffer.get(), shared_buffer_size));
-        shared_memory_mapped = true;
+        shared_memory_mapped = true;
-    }
+    }
-
+
-    std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);
+    std::memcpy(in_data.data(), input_data.data() + sizeof(OpusPacketHeader), header.size);
-
+
-    R_TRY(hardware_opus.DecodeInterleavedForMultiStream(
+    R_TRY(hardware_opus.DecodeInterleavedForMultiStream(
-        out_samples, out_data.data(), out_data.size_bytes(), channel_count, in_data.data(),
+        out_samples, out_data.data(), out_data.size_bytes(), channel_count, in_data.data(),
-        header.size, shared_buffer.get(), time_taken, reset));
+        header.size, shared_buffer.get(), time_taken, reset));
-
+
-    std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));
+    std::memcpy(output_data.data(), out_data.data(), out_samples * channel_count * sizeof(s16));
-
+
-    *out_data_size = header.size + sizeof(OpusPacketHeader);
+    *out_data_size = header.size + sizeof(OpusPacketHeader);
-    *out_sample_count = out_samples;
+    *out_sample_count = out_samples;
-    if (out_time_taken) {
+    if (out_time_taken) {
-        *out_time_taken = time_taken / 1000;
+        *out_time_taken = time_taken / 1000;
-    }
+    }
-    R_SUCCEED();
+    R_SUCCEED();
-}
+}
-
+
-} // namespace AudioCore::OpusDecoder
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/decoder.h

@@ -1,53 +1,53 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-
+
-#pragma once
+#pragma once
-
+
-#include <span>
+#include <span>
-
+
-#include "audio_core/opus/parameters.h"
+#include "audio_core/opus/parameters.h"
-#include "common/common_types.h"
+#include "common/common_types.h"
-#include "core/hle/kernel/k_transfer_memory.h"
+#include "core/hle/kernel/k_transfer_memory.h"
-#include "core/hle/service/audio/errors.h"
+#include "core/hle/service/audio/errors.h"
-
+
-namespace Core {
+namespace Core {
-class System;
+class System;
-}
+}
-
+
-namespace AudioCore::OpusDecoder {
+namespace AudioCore::OpusDecoder {
-class HardwareOpus;
+class HardwareOpus;
-
+
-class OpusDecoder {
+class OpusDecoder {
-public:
+public:
-    explicit OpusDecoder(Core::System& system, HardwareOpus& hardware_opus_);
+    explicit OpusDecoder(Core::System& system, HardwareOpus& hardware_opus_);
-    ~OpusDecoder();
+    ~OpusDecoder();
-
+
-    Result Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,
+    Result Initialize(OpusParametersEx& params, Kernel::KTransferMemory* transfer_memory,
-                      u64 transfer_memory_size);
+                      u64 transfer_memory_size);
-    Result Initialize(OpusMultiStreamParametersEx& params, Kernel::KTransferMemory* transfer_memory,
+    Result Initialize(OpusMultiStreamParametersEx& params, Kernel::KTransferMemory* transfer_memory,
-                      u64 transfer_memory_size);
+                      u64 transfer_memory_size);
-    Result DecodeInterleaved(u32* out_data_size, u64* out_time_taken, u32* out_sample_count,
+    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);
+                             std::span<const u8> input_data, std::span<u8> output_data, bool reset);
-    Result SetContext([[maybe_unused]] std::span<const u8> context);
+    Result SetContext([[maybe_unused]] std::span<const u8> context);
-    Result DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,
+    Result DecodeInterleavedForMultiStream(u32* out_data_size, u64* out_time_taken,
-                                           u32* out_sample_count, std::span<const u8> input_data,
+                                           u32* out_sample_count, std::span<const u8> input_data,
-                                           std::span<u8> output_data, bool reset);
+                                           std::span<u8> output_data, bool reset);
-
+
-private:
+private:
-    Core::System& system;
+    Core::System& system;
-    HardwareOpus& hardware_opus;
+    HardwareOpus& hardware_opus;
-    std::unique_ptr<u8[]> shared_buffer{};
+    std::unique_ptr<u8[]> shared_buffer{};
-    u64 shared_buffer_size;
+    u64 shared_buffer_size;
-    std::span<u8> in_data{};
+    std::span<u8> in_data{};
-    std::span<u8> out_data{};
+    std::span<u8> out_data{};
-    u64 buffer_size{};
+    u64 buffer_size{};
-    s32 sample_rate{};
+    s32 sample_rate{};
-    s32 channel_count{};
+    s32 channel_count{};
-    bool use_large_frame_size{false};
+    bool use_large_frame_size{false};
-    s32 total_stream_count{};
+    s32 total_stream_count{};
-    s32 stereo_stream_count{};
+    s32 stereo_stream_count{};
-    bool shared_memory_mapped{false};
+    bool shared_memory_mapped{false};
-    bool decode_object_initialized{false};
+    bool decode_object_initialized{false};
-};
+};
-
+
-} // namespace AudioCore::OpusDecoder
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/decoder_manager.cpp

@@ -1,102 +1,102 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-
+
-#include "audio_core/adsp/apps/opus/opus_decoder.h"
+#include "audio_core/adsp/apps/opus/opus_decoder.h"
-#include "audio_core/opus/decoder_manager.h"
+#include "audio_core/opus/decoder_manager.h"
-#include "common/alignment.h"
+#include "common/alignment.h"
-#include "core/core.h"
+#include "core/core.h"
-
+
-namespace AudioCore::OpusDecoder {
+namespace AudioCore::OpusDecoder {
-using namespace Service::Audio;
+using namespace Service::Audio;
-
+
-namespace {
+namespace {
-bool IsValidChannelCount(u32 channel_count) {
+bool IsValidChannelCount(u32 channel_count) {
-    return channel_count == 1 || channel_count == 2;
+    return channel_count == 1 || channel_count == 2;
-}
+}
-
+
-bool IsValidMultiStreamChannelCount(u32 channel_count) {
+bool IsValidMultiStreamChannelCount(u32 channel_count) {
-    return channel_count > 0 && channel_count <= OpusStreamCountMax;
+    return channel_count > 0 && channel_count <= OpusStreamCountMax;
-}
+}
-
+
-bool IsValidSampleRate(u32 sample_rate) {
+bool IsValidSampleRate(u32 sample_rate) {
-    return sample_rate == 8'000 || sample_rate == 12'000 || sample_rate == 16'000 ||
+    return sample_rate == 8'000 || sample_rate == 12'000 || sample_rate == 16'000 ||
-           sample_rate == 24'000 || sample_rate == 48'000;
+           sample_rate == 24'000 || sample_rate == 48'000;
-}
+}
-
+
-bool IsValidStreamCount(u32 channel_count, u32 total_stream_count, u32 stereo_stream_count) {
+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 &&
+    return total_stream_count > 0 && static_cast<s32>(stereo_stream_count) >= 0 &&
-           stereo_stream_count <= total_stream_count &&
+           stereo_stream_count <= total_stream_count &&
-           total_stream_count + stereo_stream_count <= channel_count;
+           total_stream_count + stereo_stream_count <= channel_count;
-}
+}
-
+
-} // namespace
+} // namespace
-
+
-OpusDecoderManager::OpusDecoderManager(Core::System& system_)
+OpusDecoderManager::OpusDecoderManager(Core::System& system_)
-    : system{system_}, hardware_opus{system} {
+    : system{system_}, hardware_opus{system} {
-    for (u32 i = 0; i < MaxChannels; i++) {
+    for (u32 i = 0; i < MaxChannels; i++) {
-        required_workbuffer_sizes[i] = hardware_opus.GetWorkBufferSize(1 + i);
+        required_workbuffer_sizes[i] = hardware_opus.GetWorkBufferSize(1 + i);
-    }
+    }
-}
+}
-
+
-Result OpusDecoderManager::GetWorkBufferSize(OpusParameters& params, u64& out_size) {
+Result OpusDecoderManager::GetWorkBufferSize(OpusParameters& params, u64& out_size) {
-    OpusParametersEx ex{
+    OpusParametersEx ex{
-        .sample_rate = params.sample_rate,
+        .sample_rate = params.sample_rate,
-        .channel_count = params.channel_count,
+        .channel_count = params.channel_count,
-        .use_large_frame_size = false,
+        .use_large_frame_size = false,
-    };
+    };
-    R_RETURN(GetWorkBufferSizeExEx(ex, out_size));
+    R_RETURN(GetWorkBufferSizeExEx(ex, out_size));
-}
+}
-
+
-Result OpusDecoderManager::GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size) {
+Result OpusDecoderManager::GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size) {
-    R_RETURN(GetWorkBufferSizeExEx(params, out_size));
+    R_RETURN(GetWorkBufferSizeExEx(params, out_size));
-}
+}
-
+
-Result OpusDecoderManager::GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size) {
+Result OpusDecoderManager::GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size) {
-    R_UNLESS(IsValidChannelCount(params.channel_count), ResultInvalidOpusChannelCount);
+    R_UNLESS(IsValidChannelCount(params.channel_count), ResultInvalidOpusChannelCount);
-    R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);
+    R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);
-
+
-    auto work_buffer_size{required_workbuffer_sizes[params.channel_count - 1]};
+    auto work_buffer_size{required_workbuffer_sizes[params.channel_count - 1]};
-    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
+    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
-    work_buffer_size +=
+    work_buffer_size +=
-        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);
+        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);
-    out_size = work_buffer_size + 0x600;
+    out_size = work_buffer_size + 0x600;
-    R_SUCCEED();
+    R_SUCCEED();
-}
+}
-
+
-Result OpusDecoderManager::GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params,
+Result OpusDecoderManager::GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params,
-                                                           u64& out_size) {
+                                                           u64& out_size) {
-    OpusMultiStreamParametersEx ex{
+    OpusMultiStreamParametersEx ex{
-        .sample_rate = params.sample_rate,
+        .sample_rate = params.sample_rate,
-        .channel_count = params.channel_count,
+        .channel_count = params.channel_count,
-        .total_stream_count = params.total_stream_count,
+        .total_stream_count = params.total_stream_count,
-        .stereo_stream_count = params.stereo_stream_count,
+        .stereo_stream_count = params.stereo_stream_count,
-        .use_large_frame_size = false,
+        .use_large_frame_size = false,
-        .mappings = {},
+        .mappings = {},
-    };
+    };
-    R_RETURN(GetWorkBufferSizeForMultiStreamExEx(ex, out_size));
+    R_RETURN(GetWorkBufferSizeForMultiStreamExEx(ex, out_size));
-}
+}
-
+
-Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params,
+Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params,
-                                                             u64& out_size) {
+                                                             u64& out_size) {
-    R_RETURN(GetWorkBufferSizeForMultiStreamExEx(params, out_size));
+    R_RETURN(GetWorkBufferSizeForMultiStreamExEx(params, out_size));
-}
+}
-
+
-Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params,
+Result OpusDecoderManager::GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params,
-                                                               u64& out_size) {
+                                                               u64& out_size) {
-    R_UNLESS(IsValidMultiStreamChannelCount(params.channel_count), ResultInvalidOpusChannelCount);
+    R_UNLESS(IsValidMultiStreamChannelCount(params.channel_count), ResultInvalidOpusChannelCount);
-    R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);
+    R_UNLESS(IsValidSampleRate(params.sample_rate), ResultInvalidOpusSampleRate);
-    R_UNLESS(IsValidStreamCount(params.channel_count, params.total_stream_count,
+    R_UNLESS(IsValidStreamCount(params.channel_count, params.total_stream_count,
-                                params.stereo_stream_count),
+                                params.stereo_stream_count),
-             ResultInvalidOpusSampleRate);
+             ResultInvalidOpusSampleRate);
-
+
-    auto work_buffer_size{hardware_opus.GetWorkBufferSizeForMultiStream(
+    auto work_buffer_size{hardware_opus.GetWorkBufferSizeForMultiStream(
-        params.total_stream_count, params.stereo_stream_count)};
+        params.total_stream_count, params.stereo_stream_count)};
-    auto frame_size{params.use_large_frame_size ? 5760 : 1920};
+    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(1500 * params.total_stream_count, 64);
-    work_buffer_size +=
+    work_buffer_size +=
-        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);
+        Common::AlignUp((frame_size * params.channel_count) / (48'000 / params.sample_rate), 64);
-    out_size = work_buffer_size;
+    out_size = work_buffer_size;
-    R_SUCCEED();
+    R_SUCCEED();
-}
+}
-
+
-} // namespace AudioCore::OpusDecoder
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/decoder_manager.h

@@ -1,38 +1,38 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-
+
-#pragma once
+#pragma once
-
+
-#include "audio_core/opus/hardware_opus.h"
+#include "audio_core/opus/hardware_opus.h"
-#include "audio_core/opus/parameters.h"
+#include "audio_core/opus/parameters.h"
-#include "common/common_types.h"
+#include "common/common_types.h"
-#include "core/hle/service/audio/errors.h"
+#include "core/hle/service/audio/errors.h"
-
+
-namespace Core {
+namespace Core {
-class System;
+class System;
-}
+}
-
+
-namespace AudioCore::OpusDecoder {
+namespace AudioCore::OpusDecoder {
-
+
-class OpusDecoderManager {
+class OpusDecoderManager {
-public:
+public:
-    OpusDecoderManager(Core::System& system);
+    OpusDecoderManager(Core::System& system);
-
+
-    HardwareOpus& GetHardwareOpus() {
+    HardwareOpus& GetHardwareOpus() {
-        return hardware_opus;
+        return hardware_opus;
-    }
+    }
-
+
-    Result GetWorkBufferSize(OpusParameters& params, u64& out_size);
+    Result GetWorkBufferSize(OpusParameters& params, u64& out_size);
-    Result GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size);
+    Result GetWorkBufferSizeEx(OpusParametersEx& params, u64& out_size);
-    Result GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size);
+    Result GetWorkBufferSizeExEx(OpusParametersEx& params, u64& out_size);
-    Result GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params, u64& out_size);
+    Result GetWorkBufferSizeForMultiStream(OpusMultiStreamParameters& params, u64& out_size);
-    Result GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params, u64& out_size);
+    Result GetWorkBufferSizeForMultiStreamEx(OpusMultiStreamParametersEx& params, u64& out_size);
-    Result GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params, u64& out_size);
+    Result GetWorkBufferSizeForMultiStreamExEx(OpusMultiStreamParametersEx& params, u64& out_size);
-
+
-private:
+private:
-    Core::System& system;
+    Core::System& system;
-    HardwareOpus hardware_opus;
+    HardwareOpus hardware_opus;
-    std::array<u64, MaxChannels> required_workbuffer_sizes{};
+    std::array<u64, MaxChannels> required_workbuffer_sizes{};
-};
+};
-
+
-} // namespace AudioCore::OpusDecoder
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/hardware_opus.cpp

@@ -1,241 +1,241 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-
+
-#include <array>
+#include <array>
-
+
-#include "audio_core/audio_core.h"
+#include "audio_core/audio_core.h"
-#include "audio_core/opus/hardware_opus.h"
+#include "audio_core/opus/hardware_opus.h"
-#include "core/core.h"
+#include "core/core.h"
-
+
-namespace AudioCore::OpusDecoder {
+namespace AudioCore::OpusDecoder {
-namespace {
+namespace {
-using namespace Service::Audio;
+using namespace Service::Audio;
-
+
-static constexpr Result ResultCodeFromLibOpusErrorCode(u64 error_code) {
+static constexpr Result ResultCodeFromLibOpusErrorCode(u64 error_code) {
-    s32 error{static_cast<s32>(error_code)};
+    s32 error{static_cast<s32>(error_code)};
-    ASSERT(error <= OPUS_OK);
+    ASSERT(error <= OPUS_OK);
-    switch (error) {
+    switch (error) {
-    case OPUS_ALLOC_FAIL:
+    case OPUS_ALLOC_FAIL:
-        R_THROW(ResultLibOpusAllocFail);
+        R_THROW(ResultLibOpusAllocFail);
-    case OPUS_INVALID_STATE:
+    case OPUS_INVALID_STATE:
-        R_THROW(ResultLibOpusInvalidState);
+        R_THROW(ResultLibOpusInvalidState);
-    case OPUS_UNIMPLEMENTED:
+    case OPUS_UNIMPLEMENTED:
-        R_THROW(ResultLibOpusUnimplemented);
+        R_THROW(ResultLibOpusUnimplemented);
-    case OPUS_INVALID_PACKET:
+    case OPUS_INVALID_PACKET:
-        R_THROW(ResultLibOpusInvalidPacket);
+        R_THROW(ResultLibOpusInvalidPacket);
-    case OPUS_INTERNAL_ERROR:
+    case OPUS_INTERNAL_ERROR:
-        R_THROW(ResultLibOpusInternalError);
+        R_THROW(ResultLibOpusInternalError);
-    case OPUS_BUFFER_TOO_SMALL:
+    case OPUS_BUFFER_TOO_SMALL:
-        R_THROW(ResultBufferTooSmall);
+        R_THROW(ResultBufferTooSmall);
-    case OPUS_BAD_ARG:
+    case OPUS_BAD_ARG:
-        R_THROW(ResultLibOpusBadArg);
+        R_THROW(ResultLibOpusBadArg);
-    case OPUS_OK:
+    case OPUS_OK:
-        R_RETURN(ResultSuccess);
+        R_RETURN(ResultSuccess);
-    }
+    }
-    UNREACHABLE();
+    UNREACHABLE();
-}
+}
-
+
-} // namespace
+} // namespace
-
+
-HardwareOpus::HardwareOpus(Core::System& system_)
+HardwareOpus::HardwareOpus(Core::System& system_)
-    : system{system_}, opus_decoder{system.AudioCore().ADSP().OpusDecoder()} {
+    : system{system_}, opus_decoder{system.AudioCore().ADSP().OpusDecoder()} {
-    opus_decoder.SetSharedMemory(shared_memory);
+    opus_decoder.SetSharedMemory(shared_memory);
-}
+}
-
+
-u64 HardwareOpus::GetWorkBufferSize(u32 channel) {
+u64 HardwareOpus::GetWorkBufferSize(u32 channel) {
-    if (!opus_decoder.IsRunning()) {
+    if (!opus_decoder.IsRunning()) {
-        return 0;
+        return 0;
-    }
+    }
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = channel;
+    shared_memory.host_send_data[0] = channel;
-    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::GetWorkBufferSize);
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::GetWorkBufferSize);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeOK) {
+    if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::GetWorkBufferSizeOK, msg);
+                  ADSP::OpusDecoder::Message::GetWorkBufferSizeOK, msg);
-        return 0;
+        return 0;
-    }
+    }
-    return shared_memory.dsp_return_data[0];
+    return shared_memory.dsp_return_data[0];
-}
+}
-
+
-u64 HardwareOpus::GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count) {
+u64 HardwareOpus::GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = total_stream_count;
+    shared_memory.host_send_data[0] = total_stream_count;
-    shared_memory.host_send_data[1] = stereo_stream_count;
+    shared_memory.host_send_data[1] = stereo_stream_count;
-    opus_decoder.Send(ADSP::Direction::DSP,
+    opus_decoder.Send(ADSP::Direction::DSP,
-                      ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStream);
+                      ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStream);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK) {
+    if (msg != ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK, msg);
+                  ADSP::OpusDecoder::Message::GetWorkBufferSizeForMultiStreamOK, msg);
-        return 0;
+        return 0;
-    }
+    }
-    return shared_memory.dsp_return_data[0];
+    return shared_memory.dsp_return_data[0];
-}
+}
-
+
-Result HardwareOpus::InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,
+Result HardwareOpus::InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,
-                                            u64 buffer_size) {
+                                            u64 buffer_size) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = buffer_size;
+    shared_memory.host_send_data[1] = buffer_size;
-    shared_memory.host_send_data[2] = sample_rate;
+    shared_memory.host_send_data[2] = sample_rate;
-    shared_memory.host_send_data[3] = channel_count;
+    shared_memory.host_send_data[3] = channel_count;
-
+
-    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::InitializeDecodeObject);
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::InitializeDecodeObject);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    if (msg != ADSP::OpusDecoder::Message::InitializeDecodeObjectOK) {
+    if (msg != ADSP::OpusDecoder::Message::InitializeDecodeObjectOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::InitializeDecodeObjectOK, msg);
+                  ADSP::OpusDecoder::Message::InitializeDecodeObjectOK, msg);
-        R_THROW(ResultInvalidOpusDSPReturnCode);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
-    }
+    }
-
+
-    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
-}
+}
-
+
-Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,
+Result HardwareOpus::InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,
-                                                       u32 total_stream_count,
+                                                       u32 total_stream_count,
-                                                       u32 stereo_stream_count, void* mappings,
+                                                       u32 stereo_stream_count, void* mappings,
-                                                       void* buffer, u64 buffer_size) {
+                                                       void* buffer, u64 buffer_size) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = buffer_size;
+    shared_memory.host_send_data[1] = buffer_size;
-    shared_memory.host_send_data[2] = sample_rate;
+    shared_memory.host_send_data[2] = sample_rate;
-    shared_memory.host_send_data[3] = channel_count;
+    shared_memory.host_send_data[3] = channel_count;
-    shared_memory.host_send_data[4] = total_stream_count;
+    shared_memory.host_send_data[4] = total_stream_count;
-    shared_memory.host_send_data[5] = stereo_stream_count;
+    shared_memory.host_send_data[5] = stereo_stream_count;
-
+
-    ASSERT(channel_count <= MaxChannels);
+    ASSERT(channel_count <= MaxChannels);
-    std::memcpy(shared_memory.channel_mapping.data(), mappings, channel_count * sizeof(u8));
+    std::memcpy(shared_memory.channel_mapping.data(), mappings, channel_count * sizeof(u8));
-
+
-    opus_decoder.Send(ADSP::Direction::DSP,
+    opus_decoder.Send(ADSP::Direction::DSP,
-                      ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObject);
+                      ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObject);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    if (msg != ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK) {
+    if (msg != ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK, msg);
+                  ADSP::OpusDecoder::Message::InitializeMultiStreamDecodeObjectOK, msg);
-        R_THROW(ResultInvalidOpusDSPReturnCode);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
-    }
+    }
-
+
-    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
-}
+}
-
+
-Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {
+Result HardwareOpus::ShutdownDecodeObject(void* buffer, u64 buffer_size) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = buffer_size;
+    shared_memory.host_send_data[1] = buffer_size;
-
+
-    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::ShutdownDecodeObject);
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::ShutdownDecodeObject);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK,
+    ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK,
-               "Expected Opus shutdown code {}, got {}",
+               "Expected Opus shutdown code {}, got {}",
-               ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK, msg);
+               ADSP::OpusDecoder::Message::ShutdownDecodeObjectOK, msg);
-
+
-    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
-}
+}
-
+
-Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size) {
+Result HardwareOpus::ShutdownMultiStreamDecodeObject(void* buffer, u64 buffer_size) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = buffer_size;
+    shared_memory.host_send_data[1] = buffer_size;
-
+
-    opus_decoder.Send(ADSP::Direction::DSP,
+    opus_decoder.Send(ADSP::Direction::DSP,
-                      ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObject);
+                      ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObject);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK,
+    ASSERT_MSG(msg == ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK,
-               "Expected Opus shutdown code {}, got {}",
+               "Expected Opus shutdown code {}, got {}",
-               ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK, msg);
+               ADSP::OpusDecoder::Message::ShutdownMultiStreamDecodeObjectOK, msg);
-
+
-    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(shared_memory.dsp_return_data[0]));
-}
+}
-
+
-Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,
+Result HardwareOpus::DecodeInterleaved(u32& out_sample_count, void* output_data,
-                                       u64 output_data_size, u32 channel_count, void* input_data,
+                                       u64 output_data_size, u32 channel_count, void* input_data,
-                                       u64 input_data_size, void* buffer, u64& out_time_taken,
+                                       u64 input_data_size, void* buffer, u64& out_time_taken,
-                                       bool reset) {
+                                       bool reset) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = (u64)input_data;
+    shared_memory.host_send_data[1] = (u64)input_data;
-    shared_memory.host_send_data[2] = input_data_size;
+    shared_memory.host_send_data[2] = input_data_size;
-    shared_memory.host_send_data[3] = (u64)output_data;
+    shared_memory.host_send_data[3] = (u64)output_data;
-    shared_memory.host_send_data[4] = output_data_size;
+    shared_memory.host_send_data[4] = output_data_size;
-    shared_memory.host_send_data[5] = 0;
+    shared_memory.host_send_data[5] = 0;
-    shared_memory.host_send_data[6] = reset;
+    shared_memory.host_send_data[6] = reset;
-
+
-    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::DecodeInterleaved);
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::DecodeInterleaved);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedOK) {
+    if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::DecodeInterleavedOK, msg);
+                  ADSP::OpusDecoder::Message::DecodeInterleavedOK, msg);
-        R_THROW(ResultInvalidOpusDSPReturnCode);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
-    }
+    }
-
+
-    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
+    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
-    if (error_code == OPUS_OK) {
+    if (error_code == OPUS_OK) {
-        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
+        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
-        out_time_taken = 1000 * shared_memory.dsp_return_data[2];
+        out_time_taken = 1000 * shared_memory.dsp_return_data[2];
-    }
+    }
-    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
-}
+}
-
+
-Result HardwareOpus::DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,
+Result HardwareOpus::DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,
-                                                     u64 output_data_size, u32 channel_count,
+                                                     u64 output_data_size, u32 channel_count,
-                                                     void* input_data, u64 input_data_size,
+                                                     void* input_data, u64 input_data_size,
-                                                     void* buffer, u64& out_time_taken,
+                                                     void* buffer, u64& out_time_taken,
-                                                     bool reset) {
+                                                     bool reset) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = (u64)input_data;
+    shared_memory.host_send_data[1] = (u64)input_data;
-    shared_memory.host_send_data[2] = input_data_size;
+    shared_memory.host_send_data[2] = input_data_size;
-    shared_memory.host_send_data[3] = (u64)output_data;
+    shared_memory.host_send_data[3] = (u64)output_data;
-    shared_memory.host_send_data[4] = output_data_size;
+    shared_memory.host_send_data[4] = output_data_size;
-    shared_memory.host_send_data[5] = 0;
+    shared_memory.host_send_data[5] = 0;
-    shared_memory.host_send_data[6] = reset;
+    shared_memory.host_send_data[6] = reset;
-
+
-    opus_decoder.Send(ADSP::Direction::DSP,
+    opus_decoder.Send(ADSP::Direction::DSP,
-                      ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStream);
+                      ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStream);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK) {
+    if (msg != ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK, msg);
+                  ADSP::OpusDecoder::Message::DecodeInterleavedForMultiStreamOK, msg);
-        R_THROW(ResultInvalidOpusDSPReturnCode);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
-    }
+    }
-
+
-    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
+    auto error_code{static_cast<s32>(shared_memory.dsp_return_data[0])};
-    if (error_code == OPUS_OK) {
+    if (error_code == OPUS_OK) {
-        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
+        out_sample_count = static_cast<u32>(shared_memory.dsp_return_data[1]);
-        out_time_taken = 1000 * shared_memory.dsp_return_data[2];
+        out_time_taken = 1000 * shared_memory.dsp_return_data[2];
-    }
+    }
-    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
+    R_RETURN(ResultCodeFromLibOpusErrorCode(error_code));
-}
+}
-
+
-Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {
+Result HardwareOpus::MapMemory(void* buffer, u64 buffer_size) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = buffer_size;
+    shared_memory.host_send_data[1] = buffer_size;
-
+
-    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::MapMemory);
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::MapMemory);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    if (msg != ADSP::OpusDecoder::Message::MapMemoryOK) {
+    if (msg != ADSP::OpusDecoder::Message::MapMemoryOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::MapMemoryOK, msg);
+                  ADSP::OpusDecoder::Message::MapMemoryOK, msg);
-        R_THROW(ResultInvalidOpusDSPReturnCode);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
-    }
+    }
-    R_SUCCEED();
+    R_SUCCEED();
-}
+}
-
+
-Result HardwareOpus::UnmapMemory(void* buffer, u64 buffer_size) {
+Result HardwareOpus::UnmapMemory(void* buffer, u64 buffer_size) {
-    std::scoped_lock l{mutex};
+    std::scoped_lock l{mutex};
-    shared_memory.host_send_data[0] = (u64)buffer;
+    shared_memory.host_send_data[0] = (u64)buffer;
-    shared_memory.host_send_data[1] = buffer_size;
+    shared_memory.host_send_data[1] = buffer_size;
-
+
-    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::UnmapMemory);
+    opus_decoder.Send(ADSP::Direction::DSP, ADSP::OpusDecoder::Message::UnmapMemory);
-    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
+    auto msg = opus_decoder.Receive(ADSP::Direction::Host);
-    if (msg != ADSP::OpusDecoder::Message::UnmapMemoryOK) {
+    if (msg != ADSP::OpusDecoder::Message::UnmapMemoryOK) {
-        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
+        LOG_ERROR(Service_Audio, "OpusDecoder returned invalid message. Expected {} got {}",
-                  ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);
+                  ADSP::OpusDecoder::Message::UnmapMemoryOK, msg);
-        R_THROW(ResultInvalidOpusDSPReturnCode);
+        R_THROW(ResultInvalidOpusDSPReturnCode);
-    }
+    }
-    R_SUCCEED();
+    R_SUCCEED();
-}
+}
-
+
-} // namespace AudioCore::OpusDecoder
+} // namespace AudioCore::OpusDecoder

src/audio_core/opus/hardware_opus.h

@@ -1,45 +1,45 @@
-// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
+// SPDX-License-Identifier: GPL-2.0-or-later
-
+
-#pragma once
+#pragma once
-
+
-#include <mutex>
+#include <mutex>
-#include <opus.h>
+#include <opus.h>
-
+
-#include "audio_core/adsp/apps/opus/opus_decoder.h"
+#include "audio_core/adsp/apps/opus/opus_decoder.h"
-#include "audio_core/adsp/apps/opus/shared_memory.h"
+#include "audio_core/adsp/apps/opus/shared_memory.h"
-#include "audio_core/adsp/mailbox.h"
+#include "audio_core/adsp/mailbox.h"
-#include "core/hle/service/audio/errors.h"
+#include "core/hle/service/audio/errors.h"
-
+
-namespace AudioCore::OpusDecoder {
+namespace AudioCore::OpusDecoder {
-class HardwareOpus {
+class HardwareOpus {
-public:
+public:
-    HardwareOpus(Core::System& system);
+    HardwareOpus(Core::System& system);
-
+
-    u64 GetWorkBufferSize(u32 channel);
+    u64 GetWorkBufferSize(u32 channel);
-    u64 GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count);
+    u64 GetWorkBufferSizeForMultiStream(u32 total_stream_count, u32 stereo_stream_count);
-
+
-    Result InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,
+    Result InitializeDecodeObject(u32 sample_rate, u32 channel_count, void* buffer,
-                                  u64 buffer_size);
+                                  u64 buffer_size);
-    Result InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,
+    Result InitializeMultiStreamDecodeObject(u32 sample_rate, u32 channel_count,
-                                             u32 totaL_stream_count, u32 stereo_stream_count,
+                                             u32 totaL_stream_count, u32 stereo_stream_count,
-                                             void* mappings, void* buffer, u64 buffer_size);
+                                             void* mappings, void* buffer, u64 buffer_size);
-    Result ShutdownDecodeObject(void* buffer, u64 buffer_size);
+    Result ShutdownDecodeObject(void* buffer, u64 buffer_size);
-    Result ShutdownMultiStreamDecodeObject(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,
+    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,
+                             u32 channel_count, void* input_data, u64 input_data_size, void* buffer,
-                             u64& out_time_taken, bool reset);
+                             u64& out_time_taken, bool reset);
-    Result DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,
+    Result DecodeInterleavedForMultiStream(u32& out_sample_count, void* output_data,
-                                           u64 output_data_size, u32 channel_count,
+                                           u64 output_data_size, u32 channel_count,
-                                           void* input_data, u64 input_data_size, void* buffer,
+                                           void* input_data, u64 input_data_size, void* buffer,
-                                           u64& out_time_taken, bool reset);
+                                           u64& out_time_taken, bool reset);
-    Result MapMemory(void* buffer, u64 buffer_size);
+    Result MapMemory(void* buffer, u64 buffer_size);
-    Result UnmapMemory(void* buffer, u64 buffer_size);
+    Result UnmapMemory(void* buffer, u64 buffer_size);
-
+
-private:
+private:
-    Core::System& system;
+    Core::System& system;
-    std::mutex mutex;
+    std::mutex mutex;
-    ADSP::OpusDecoder::OpusDecoder& opus_decoder;
+    ADSP::OpusDecoder::OpusDecoder& opus_decoder;
-    ADSP::OpusDecoder::SharedMemory shared_memory;
+    ADSP::OpusDecoder::SharedMemory shared_memory;
-};
+};
-} // namespace AudioCore::OpusDecoder
+} // namespace AudioCore::OpusDecoder

src/core/hid/emulated_controller.cpp

@@ -96,18 +96,7 @@ void EmulatedController::ReloadFromSettings() {
     }
 
     controller.color_values = {};
-    controller.colors_state.fullkey = {
+    ReloadColorsFromSettings();
-        .body = GetNpadColor(player.body_color_left),
-        .button = GetNpadColor(player.button_color_left),
-    };
-    controller.colors_state.left = {
-        .body = GetNpadColor(player.body_color_left),
-        .button = GetNpadColor(player.button_color_left),
-    };
-    controller.colors_state.right = {
-        .body = GetNpadColor(player.body_color_right),
-        .button = GetNpadColor(player.button_color_right),
-    };
 
     ring_params[0] = Common::ParamPackage(Settings::values.ringcon_analogs);
 
@@ -128,6 +117,30 @@ void EmulatedController::ReloadFromSettings() {
     ReloadInput();
 }
 
+void EmulatedController::ReloadColorsFromSettings() {
+    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    const auto& player = Settings::values.players.GetValue()[player_index];
+
+    // Avoid updating colors if overridden by physical controller
+    if (controller.color_values[LeftIndex].body != 0 &&
+        controller.color_values[RightIndex].body != 0) {
+        return;
+    }
+
+    controller.colors_state.fullkey = {
+        .body = GetNpadColor(player.body_color_left),
+        .button = GetNpadColor(player.button_color_left),
+    };
+    controller.colors_state.left = {
+        .body = GetNpadColor(player.body_color_left),
+        .button = GetNpadColor(player.button_color_left),
+    };
+    controller.colors_state.right = {
+        .body = GetNpadColor(player.body_color_right),
+        .button = GetNpadColor(player.button_color_right),
+    };
+}
+
 void EmulatedController::LoadDevices() {
     // TODO(german77): Use more buttons to detect the correct device
     const auto left_joycon = button_params[Settings::NativeButton::DRight];

src/core/hid/emulated_controller.h

@@ -253,6 +253,9 @@ public:
     /// Overrides current mapped devices with the stored configuration and reloads all input devices
     void ReloadFromSettings();
 
+    /// Updates current colors with the ones stored in the configuration
+    void ReloadColorsFromSettings();
+
     /// Saves the current mapped configuration
     void SaveCurrentConfig();
 

src/core/hle/service/acc/acc.cpp

@@ -3,11 +3,13 @@
 
 #include <algorithm>
 #include <array>
+
 #include "common/common_types.h"
 #include "common/fs/file.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
 #include "common/polyfill_ranges.h"
+#include "common/stb.h"
 #include "common/string_util.h"
 #include "common/swap.h"
 #include "core/constants.h"
@@ -38,9 +40,36 @@ static std::filesystem::path GetImagePath(const Common::UUID& uuid) {
            fmt::format("system/save/8000000000000010/su/avators/{}.jpg", uuid.FormattedString());
 }
 
-static constexpr u32 SanitizeJPEGSize(std::size_t size) {
+static void JPGToMemory(void* context, void* data, int len) {
+    std::vector<u8>* jpg_image = static_cast<std::vector<u8>*>(context);
+    unsigned char* jpg = static_cast<unsigned char*>(data);
+    jpg_image->insert(jpg_image->end(), jpg, jpg + len);
+}
+
+static void SanitizeJPEGImageSize(std::vector<u8>& image) {
     constexpr std::size_t max_jpeg_image_size = 0x20000;
-    return static_cast<u32>(std::min(size, max_jpeg_image_size));
+    constexpr int profile_dimensions = 256;
+    int original_width, original_height, color_channels;
+
+    const auto plain_image =
+        stbi_load_from_memory(image.data(), static_cast<int>(image.size()), &original_width,
+                              &original_height, &color_channels, STBI_rgb);
+
+    // Resize image to match 256*256
+    if (original_width != profile_dimensions || original_height != profile_dimensions) {
+        // Use vector instead of array to avoid overflowing the stack
+        std::vector<u8> out_image(profile_dimensions * profile_dimensions * STBI_rgb);
+        stbir_resize_uint8_srgb(plain_image, original_width, original_height, 0, out_image.data(),
+                                profile_dimensions, profile_dimensions, 0, STBI_rgb, 0,
+                                STBIR_FILTER_BOX);
+        image.clear();
+        if (!stbi_write_jpg_to_func(JPGToMemory, &image, profile_dimensions, profile_dimensions,
+                                    STBI_rgb, out_image.data(), 0)) {
+            LOG_ERROR(Service_ACC, "Failed to resize the user provided image.");
+        }
+    }
+
+    image.resize(std::min(image.size(), max_jpeg_image_size));
 }
 
 class IManagerForSystemService final : public ServiceFramework<IManagerForSystemService> {
@@ -339,19 +368,20 @@ protected:
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
             ctx.WriteBuffer(Core::Constants::ACCOUNT_BACKUP_JPEG);
-            rb.Push(SanitizeJPEGSize(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
+            rb.Push(static_cast<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
             return;
         }
 
-        const u32 size = SanitizeJPEGSize(image.GetSize());
+        std::vector<u8> buffer(image.GetSize());
-        std::vector<u8> buffer(size);
 
         if (image.Read(buffer) != buffer.size()) {
             LOG_ERROR(Service_ACC, "Failed to read all the bytes in the user provided image.");
         }
 
+        SanitizeJPEGImageSize(buffer);
+
         ctx.WriteBuffer(buffer);
-        rb.Push<u32>(size);
+        rb.Push(static_cast<u32>(buffer.size()));
     }
 
     void GetImageSize(HLERequestContext& ctx) {
@@ -365,10 +395,18 @@ protected:
         if (!image.IsOpen()) {
             LOG_WARNING(Service_ACC,
                         "Failed to load user provided image! Falling back to built-in backup...");
-            rb.Push(SanitizeJPEGSize(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
+            rb.Push(static_cast<u32>(Core::Constants::ACCOUNT_BACKUP_JPEG.size()));
-        } else {
+            return;
-            rb.Push(SanitizeJPEGSize(image.GetSize()));
         }
+
+        std::vector<u8> buffer(image.GetSize());
+
+        if (image.Read(buffer) != buffer.size()) {
+            LOG_ERROR(Service_ACC, "Failed to read all the bytes in the user provided image.");
+        }
+
+        SanitizeJPEGImageSize(buffer);
+        rb.Push(static_cast<u32>(buffer.size()));
     }
 
     void Store(HLERequestContext& ctx) {

src/core/hle/service/am/applets/applets.h

@@ -69,6 +69,30 @@ enum class AppletId : u32 {
     MyPage = 0x1A,
 };
 
+enum class AppletProgramId : u64 {
+    QLaunch = 0x0100000000001000ull,
+    Auth = 0x0100000000001001ull,
+    Cabinet = 0x0100000000001002ull,
+    Controller = 0x0100000000001003ull,
+    DataErase = 0x0100000000001004ull,
+    Error = 0x0100000000001005ull,
+    NetConnect = 0x0100000000001006ull,
+    ProfileSelect = 0x0100000000001007ull,
+    SoftwareKeyboard = 0x0100000000001008ull,
+    MiiEdit = 0x0100000000001009ull,
+    Web = 0x010000000000100Aull,
+    Shop = 0x010000000000100Bull,
+    OverlayDisplay = 0x010000000000100Cull,
+    PhotoViewer = 0x010000000000100Dull,
+    Settings = 0x010000000000100Eull,
+    OfflineWeb = 0x010000000000100Full,
+    LoginShare = 0x0100000000001010ull,
+    WebAuth = 0x0100000000001011ull,
+    Starter = 0x0100000000001012ull,
+    MyPage = 0x0100000000001013ull,
+    MaxProgramId = 0x0100000000001FFFull,
+};
+
 enum class LibraryAppletMode : u32 {
     AllForeground = 0,
     Background = 1,

src/video_core/renderer_null/null_rasterizer.cpp

@@ -3,6 +3,7 @@
 
 #include "common/alignment.h"
 #include "core/memory.h"
+#include "video_core/control/channel_state.h"
 #include "video_core/host1x/host1x.h"
 #include "video_core/memory_manager.h"
 #include "video_core/renderer_null/null_rasterizer.h"
@@ -99,8 +100,14 @@ bool RasterizerNull::AccelerateDisplay(const Tegra::FramebufferConfig& config,
 }
 void RasterizerNull::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
                                        const VideoCore::DiskResourceLoadCallback& callback) {}
-void RasterizerNull::InitializeChannel(Tegra::Control::ChannelState& channel) {}
+void RasterizerNull::InitializeChannel(Tegra::Control::ChannelState& channel) {
-void RasterizerNull::BindChannel(Tegra::Control::ChannelState& channel) {}
+    CreateChannel(channel);
-void RasterizerNull::ReleaseChannel(s32 channel_id) {}
+}
+void RasterizerNull::BindChannel(Tegra::Control::ChannelState& channel) {
+    BindToChannel(channel.bind_id);
+}
+void RasterizerNull::ReleaseChannel(s32 channel_id) {
+    EraseChannel(channel_id);
+}
 
 } // namespace Null

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -82,7 +82,7 @@ VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t in
     }
 
     if (y_negate) {
-        y += height;
+        y += conv(static_cast<f32>(regs.surface_clip.height));
         height = -height;
     }
 

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 once

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 once

src/yuzu/configuration/configure_input.cpp

@@ -152,7 +152,7 @@ void ConfigureInput::Initialize(InputCommon::InputSubsystem* input_subsystem,
     connect(player_controllers[0], &ConfigureInputPlayer::HandheldStateChanged,
             [this](bool is_handheld) { UpdateDockedState(is_handheld); });
 
-    advanced = new ConfigureInputAdvanced(this);
+    advanced = new ConfigureInputAdvanced(hid_core, this);
     ui->tabAdvanced->setLayout(new QHBoxLayout(ui->tabAdvanced));
     ui->tabAdvanced->layout()->addWidget(advanced);
 

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 once

src/yuzu/configuration/configure_input_advanced.cpp

@@ -4,11 +4,13 @@
 #include <QColorDialog>
 #include "common/settings.h"
 #include "core/core.h"
+#include "core/hid/emulated_controller.h"
+#include "core/hid/hid_core.h"
 #include "ui_configure_input_advanced.h"
 #include "yuzu/configuration/configure_input_advanced.h"
 
-ConfigureInputAdvanced::ConfigureInputAdvanced(QWidget* parent)
+ConfigureInputAdvanced::ConfigureInputAdvanced(Core::HID::HIDCore& hid_core_, QWidget* parent)
-    : QWidget(parent), ui(std::make_unique<Ui::ConfigureInputAdvanced>()) {
+    : QWidget(parent), ui(std::make_unique<Ui::ConfigureInputAdvanced>()), hid_core{hid_core_} {
     ui->setupUi(this);
 
     controllers_color_buttons = {{
@@ -123,6 +125,8 @@ void ConfigureInputAdvanced::ApplyConfiguration() {
         player.button_color_left = colors[1];
         player.body_color_right = colors[2];
         player.button_color_right = colors[3];
+
+        hid_core.GetEmulatedControllerByIndex(player_idx)->ReloadColorsFromSettings();
     }
 
     Settings::values.debug_pad_enabled = ui->debug_enabled->isChecked();

src/yuzu/configuration/configure_input_advanced.h

@@ -14,11 +14,15 @@ namespace Ui {
 class ConfigureInputAdvanced;
 }
 
+namespace Core::HID {
+class HIDCore;
+} // namespace Core::HID
+
 class ConfigureInputAdvanced : public QWidget {
     Q_OBJECT
 
 public:
-    explicit ConfigureInputAdvanced(QWidget* parent = nullptr);
+    explicit ConfigureInputAdvanced(Core::HID::HIDCore& hid_core_, QWidget* parent = nullptr);
     ~ConfigureInputAdvanced() override;
 
     void ApplyConfiguration();
@@ -44,4 +48,6 @@ private:
 
     std::array<std::array<QColor, 4>, 8> controllers_colors;
     std::array<std::array<QPushButton*, 4>, 8> controllers_color_buttons;
+
+    Core::HID::HIDCore& hid_core;
 };

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 once

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 once

src/yuzu/configuration/configure_profile_manager.cpp

@@ -306,10 +306,10 @@ void ConfigureProfileManager::SetUserImage() {
         return;
     }
 
-    // Some games crash when the profile image is too big. Resize any image bigger than 256x256
+    // Profile image must be 256x256
     QImage image(image_path);
-    if (image.width() > 256 || image.height() > 256) {
+    if (image.width() != 256 || image.height() != 256) {
-        image = image.scaled(256, 256, Qt::KeepAspectRatio);
+        image = image.scaled(256, 256, Qt::KeepAspectRatioByExpanding, Qt::SmoothTransformation);
         if (!image.save(image_path)) {
             QMessageBox::warning(this, tr("Error resizing user image"),
                                  tr("Unable to resize image"));

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 once

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 once

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

src/yuzu/main.cpp

@@ -1908,7 +1908,10 @@ void GMainWindow::ConfigureFilesystemProvider(const std::string& filepath) {
 void GMainWindow::BootGame(const QString& filename, u64 program_id, std::size_t program_index,
                            StartGameType type, AmLaunchType launch_type) {
     LOG_INFO(Frontend, "yuzu starting...");
-    StoreRecentFile(filename); // Put the filename on top of the list
+
+    if (program_id > static_cast<u64>(Service::AM::Applets::AppletProgramId::MaxProgramId)) {
+        StoreRecentFile(filename); // Put the filename on top of the list
+    }
 
     // Save configurations
     UpdateUISettings();
@@ -4273,7 +4276,7 @@ void GMainWindow::OnToggleStatusBar() {
 }
 
 void GMainWindow::OnAlbum() {
-    constexpr u64 AlbumId = 0x010000000000100Dull;
+    constexpr u64 AlbumId = static_cast<u64>(Service::AM::Applets::AppletProgramId::PhotoViewer);
     auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
     if (!bis_system) {
         QMessageBox::warning(this, tr("No firmware available"),
@@ -4296,7 +4299,7 @@ void GMainWindow::OnAlbum() {
 }
 
 void GMainWindow::OnCabinet(Service::NFP::CabinetMode mode) {
-    constexpr u64 CabinetId = 0x0100000000001002ull;
+    constexpr u64 CabinetId = static_cast<u64>(Service::AM::Applets::AppletProgramId::Cabinet);
     auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
     if (!bis_system) {
         QMessageBox::warning(this, tr("No firmware available"),
@@ -4320,7 +4323,7 @@ void GMainWindow::OnCabinet(Service::NFP::CabinetMode mode) {
 }
 
 void GMainWindow::OnMiiEdit() {
-    constexpr u64 MiiEditId = 0x0100000000001009ull;
+    constexpr u64 MiiEditId = static_cast<u64>(Service::AM::Applets::AppletProgramId::MiiEdit);
     auto bis_system = system->GetFileSystemController().GetSystemNANDContents();
     if (!bis_system) {
         QMessageBox::warning(this, tr("No firmware available"),