mirrors/yuzu
2
1
Fork 0
mirror of https://github.com/yuzu-emu/yuzu.git synced 2024-07-04 23:31:19 +01:00
Code Issues Releases Activity

Merge pull request #2073 from lioncash/opus

Browse source 
hwopus: Implement DecodeInterleaved (the newest variant)
This commit is contained in:
bunnei 2019-02-01 13:02:16 -05:00 committed by GitHub
commit 4076d8fe3e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 76 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

119
src/core/hle/service/audio/hwopus.cpp
View file

@ -5,7 +5,6 @@
#include <chrono> #include <chrono>
#include <cstring> #include <cstring>
#include <memory> #include <memory>
#include <optional>
#include <vector> #include <vector>
#include <opus.h> #include <opus.h>
@ -30,48 +29,66 @@ public:
u32 channel_count) u32 channel_count)
: ServiceFramework("IHardwareOpusDecoderManager"), decoder(std::move(decoder)), : ServiceFramework("IHardwareOpusDecoderManager"), decoder(std::move(decoder)),
sample_rate(sample_rate), channel_count(channel_count) { sample_rate(sample_rate), channel_count(channel_count) {
// clang-format off
static const FunctionInfo functions[] = { static const FunctionInfo functions[] = {
{0, &IHardwareOpusDecoderManager::DecodeInterleaved, "DecodeInterleaved"}, {0, &IHardwareOpusDecoderManager::DecodeInterleavedOld, "DecodeInterleavedOld"},
{1, nullptr, "SetContext"}, {1, nullptr, "SetContext"},
{2, nullptr, "DecodeInterleavedForMultiStream"}, {2, nullptr, "DecodeInterleavedForMultiStreamOld"},
{3, nullptr, "SetContextForMultiStream"}, {3, nullptr, "SetContextForMultiStream"},
{4, &IHardwareOpusDecoderManager::DecodeInterleavedWithPerformance, {4, &IHardwareOpusDecoderManager::DecodeInterleavedWithPerfOld, "DecodeInterleavedWithPerfOld"},
"DecodeInterleavedWithPerformance"}, {5, nullptr, "DecodeInterleavedForMultiStreamWithPerfOld"},
{5, nullptr, "Unknown5"}, {6, &IHardwareOpusDecoderManager::DecodeInterleaved, "DecodeInterleaved"},
{6, nullptr, "Unknown6"}, {7, nullptr, "DecodeInterleavedForMultiStream"},
{7, nullptr, "Unknown7"},
}; };
// clang-format on
RegisterHandlers(functions); RegisterHandlers(functions);
} }
private: private:
/// Describes extra behavior that may be asked of the decoding context.
enum class ExtraBehavior {
/// No extra behavior.
None,
/// Resets the decoder context back to a freshly initialized state.
ResetContext,
};
void DecodeInterleavedOld(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Audio, "called");
DecodeInterleavedHelper(ctx, nullptr, ExtraBehavior::None);
}
void DecodeInterleavedWithPerfOld(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Audio, "called");
u64 performance = 0;
DecodeInterleavedHelper(ctx, &performance, ExtraBehavior::None);
}
void DecodeInterleaved(Kernel::HLERequestContext& ctx) { void DecodeInterleaved(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Audio, "called"); LOG_DEBUG(Audio, "called");
u32 consumed = 0; IPC::RequestParser rp{ctx};
u32 sample_count = 0; const auto extra_behavior =
std::vector<opus_int16> samples(ctx.GetWriteBufferSize() / sizeof(opus_int16)); rp.Pop<bool>() ? ExtraBehavior::ResetContext : ExtraBehavior::None;
if (!Decoder_DecodeInterleaved(consumed, sample_count, ctx.ReadBuffer(), samples)) {
LOG_ERROR(Audio, "Failed to decode opus data"); u64 performance = 0;
IPC::ResponseBuilder rb{ctx, 2}; DecodeInterleavedHelper(ctx, &performance, extra_behavior);
// TODO(ogniK): Use correct error code
rb.Push(ResultCode(-1));
return;
}
IPC::ResponseBuilder rb{ctx, 4};
rb.Push(RESULT_SUCCESS);
rb.Push<u32>(consumed);
rb.Push<u32>(sample_count);
ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
} }
void DecodeInterleavedWithPerformance(Kernel::HLERequestContext& ctx) { void DecodeInterleavedHelper(Kernel::HLERequestContext& ctx, u64* performance,
LOG_DEBUG(Audio, "called"); ExtraBehavior extra_behavior) {
u32 consumed = 0; u32 consumed = 0;
u32 sample_count = 0; u32 sample_count = 0;
u64 performance = 0;
std::vector<opus_int16> samples(ctx.GetWriteBufferSize() / sizeof(opus_int16)); std::vector<opus_int16> samples(ctx.GetWriteBufferSize() / sizeof(opus_int16));
if (extra_behavior == ExtraBehavior::ResetContext) {
ResetDecoderContext();
}
if (!Decoder_DecodeInterleaved(consumed, sample_count, ctx.ReadBuffer(), samples, if (!Decoder_DecodeInterleaved(consumed, sample_count, ctx.ReadBuffer(), samples,
performance)) { performance)) {
LOG_ERROR(Audio, "Failed to decode opus data"); LOG_ERROR(Audio, "Failed to decode opus data");
@ -80,25 +97,28 @@ private:
rb.Push(ResultCode(-1)); rb.Push(ResultCode(-1));
return; return;
} }
IPC::ResponseBuilder rb{ctx, 6};
const u32 param_size = performance != nullptr ? 6 : 4;
IPC::ResponseBuilder rb{ctx, param_size};
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.Push<u32>(consumed); rb.Push<u32>(consumed);
rb.Push<u32>(sample_count); rb.Push<u32>(sample_count);
rb.Push<u64>(performance); if (performance) {
rb.Push<u64>(*performance);
}
ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16)); ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
} }
bool Decoder_DecodeInterleaved( bool Decoder_DecodeInterleaved(u32& consumed, u32& sample_count, const std::vector<u8>& input,
u32& consumed, u32& sample_count, const std::vector<u8>& input, std::vector<opus_int16>& output, u64* out_performance_time) {
std::vector<opus_int16>& output,
std::optional<std::reference_wrapper<u64>> performance_time = std::nullopt) {
const auto start_time = std::chrono::high_resolution_clock::now(); const auto start_time = std::chrono::high_resolution_clock::now();
std::size_t raw_output_sz = output.size() * sizeof(opus_int16); const std::size_t raw_output_sz = output.size() * sizeof(opus_int16);
if (sizeof(OpusHeader) > input.size()) { if (sizeof(OpusHeader) > input.size()) {
LOG_ERROR(Audio, "Input is smaller than the header size, header_sz={}, input_sz={}", LOG_ERROR(Audio, "Input is smaller than the header size, header_sz={}, input_sz={}",
sizeof(OpusHeader), input.size()); sizeof(OpusHeader), input.size());
return false; return false;
} }
OpusHeader hdr{}; OpusHeader hdr{};
std::memcpy(&hdr, input.data(), sizeof(OpusHeader)); std::memcpy(&hdr, input.data(), sizeof(OpusHeader));
if (sizeof(OpusHeader) + static_cast<u32>(hdr.sz) > input.size()) { if (sizeof(OpusHeader) + static_cast<u32>(hdr.sz) > input.size()) {
@ -106,8 +126,9 @@ private:
sizeof(OpusHeader) + static_cast<u32>(hdr.sz), input.size()); sizeof(OpusHeader) + static_cast<u32>(hdr.sz), input.size());
return false; return false;
} }
auto frame = input.data() + sizeof(OpusHeader);
auto decoded_sample_count = opus_packet_get_nb_samples( const auto frame = input.data() + sizeof(OpusHeader);
const auto decoded_sample_count = opus_packet_get_nb_samples(
frame, static_cast<opus_int32>(input.size() - sizeof(OpusHeader)), frame, static_cast<opus_int32>(input.size() - sizeof(OpusHeader)),
static_cast<opus_int32>(sample_rate)); static_cast<opus_int32>(sample_rate));
if (decoded_sample_count * channel_count * sizeof(u16) > raw_output_sz) { if (decoded_sample_count * channel_count * sizeof(u16) > raw_output_sz) {
@ -117,8 +138,9 @@ private:
decoded_sample_count * channel_count * sizeof(u16), raw_output_sz); decoded_sample_count * channel_count * sizeof(u16), raw_output_sz);
return false; return false;
} }
const int frame_size = (static_cast<int>(raw_output_sz / sizeof(s16) / channel_count)); const int frame_size = (static_cast<int>(raw_output_sz / sizeof(s16) / channel_count));
auto out_sample_count = const auto out_sample_count =
opus_decode(decoder.get(), frame, hdr.sz, output.data(), frame_size, 0); opus_decode(decoder.get(), frame, hdr.sz, output.data(), frame_size, 0);
if (out_sample_count < 0) { if (out_sample_count < 0) {
LOG_ERROR(Audio, LOG_ERROR(Audio,
@ -127,16 +149,24 @@ private:
out_sample_count, frame_size, static_cast<u32>(hdr.sz)); out_sample_count, frame_size, static_cast<u32>(hdr.sz));
return false; return false;
} }
const auto end_time = std::chrono::high_resolution_clock::now() - start_time; const auto end_time = std::chrono::high_resolution_clock::now() - start_time;
sample_count = out_sample_count; sample_count = out_sample_count;
consumed = static_cast<u32>(sizeof(OpusHeader) + hdr.sz); consumed = static_cast<u32>(sizeof(OpusHeader) + hdr.sz);
if (performance_time.has_value()) { if (out_performance_time != nullptr) {
performance_time->get() = *out_performance_time =
std::chrono::duration_cast<std::chrono::milliseconds>(end_time).count(); std::chrono::duration_cast<std::chrono::milliseconds>(end_time).count();
} }
return true; return true;
} }
void ResetDecoderContext() {
ASSERT(decoder != nullptr);
opus_decoder_ctl(decoder.get(), OPUS_RESET_STATE);
}
struct OpusHeader { struct OpusHeader {
u32_be sz; // Needs to be BE for some odd reason u32_be sz; // Needs to be BE for some odd reason
INSERT_PADDING_WORDS(1); INSERT_PADDING_WORDS(1);
@ -157,6 +187,7 @@ void HwOpus::GetWorkBufferSize(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx}; IPC::RequestParser rp{ctx};
const auto sample_rate = rp.Pop<u32>(); const auto sample_rate = rp.Pop<u32>();
const auto channel_count = rp.Pop<u32>(); const auto channel_count = rp.Pop<u32>();
LOG_DEBUG(Audio, "called with sample_rate={}, channel_count={}", sample_rate, channel_count); LOG_DEBUG(Audio, "called with sample_rate={}, channel_count={}", sample_rate, channel_count);
ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 || ASSERT_MSG(sample_rate == 48000 || sample_rate == 24000 || sample_rate == 16000 ||
@ -174,9 +205,10 @@ void HwOpus::GetWorkBufferSize(Kernel::HLERequestContext& ctx) {
void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) { void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
IPC::RequestParser rp{ctx}; IPC::RequestParser rp{ctx};
auto sample_rate = rp.Pop<u32>(); const auto sample_rate = rp.Pop<u32>();
auto channel_count = rp.Pop<u32>(); const auto channel_count = rp.Pop<u32>();
auto buffer_sz = rp.Pop<u32>(); const auto buffer_sz = rp.Pop<u32>();
LOG_DEBUG(Audio, "called sample_rate={}, channel_count={}, buffer_size={}", sample_rate, LOG_DEBUG(Audio, "called sample_rate={}, channel_count={}, buffer_size={}", sample_rate,
channel_count, buffer_sz); channel_count, buffer_sz);
@ -185,8 +217,9 @@ void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
"Invalid sample rate"); "Invalid sample rate");
ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count"); ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
std::size_t worker_sz = WorkerBufferSize(channel_count); const std::size_t worker_sz = WorkerBufferSize(channel_count);
ASSERT_MSG(buffer_sz >= worker_sz, "Worker buffer too large"); ASSERT_MSG(buffer_sz >= worker_sz, "Worker buffer too large");
std::unique_ptr<OpusDecoder, OpusDeleter> decoder{ std::unique_ptr<OpusDecoder, OpusDeleter> decoder{
static_cast<OpusDecoder*>(operator new(worker_sz))}; static_cast<OpusDecoder*>(operator new(worker_sz))};
if (const int err = opus_decoder_init(decoder.get(), sample_rate, channel_count)) { if (const int err = opus_decoder_init(decoder.get(), sample_rate, channel_count)) {