notsoyuzu
/
yuzu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

service/audio/hwopus: Move decoder state to its own class 

Moves the non-multistream specific state to its own class. This will be
necessary to support the multistream variants of opus decoding.
This commit is contained in:
Lioncash 2019-03-07 05:52:25 -05:00
parent 960057cba0
commit d03ae881fd
1 changed files with 87 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
src/core/hle/service/audio/hwopus.cpp
View File

@ -23,6 +23,8 @@ struct OpusDeleter {
} }
}; };
using OpusDecoderPtr = std::unique_ptr<OpusDecoder, OpusDeleter>;
struct OpusPacketHeader { struct OpusPacketHeader {
// Packet size in bytes. // Packet size in bytes.
u32_be size; u32_be size;
@ -31,29 +33,8 @@ struct OpusPacketHeader {
}; };
static_assert(sizeof(OpusPacketHeader) == 0x8, "OpusHeader is an invalid size"); static_assert(sizeof(OpusPacketHeader) == 0x8, "OpusHeader is an invalid size");
class IHardwareOpusDecoderManager final : public ServiceFramework<IHardwareOpusDecoderManager> { class OpusDecoderStateBase {
public: public:
IHardwareOpusDecoderManager(std::unique_ptr<OpusDecoder, OpusDeleter> decoder, u32 sample_rate,
u32 channel_count)
: ServiceFramework("IHardwareOpusDecoderManager"), decoder(std::move(decoder)),
sample_rate(sample_rate), channel_count(channel_count) {
// clang-format off
static const FunctionInfo functions[] = {
{0, &IHardwareOpusDecoderManager::DecodeInterleavedOld, "DecodeInterleavedOld"},
{1, nullptr, "SetContext"},
{2, nullptr, "DecodeInterleavedForMultiStreamOld"},
{3, nullptr, "SetContextForMultiStream"},
{4, &IHardwareOpusDecoderManager::DecodeInterleavedWithPerfOld, "DecodeInterleavedWithPerfOld"},
{5, nullptr, "DecodeInterleavedForMultiStreamWithPerfOld"},
{6, &IHardwareOpusDecoderManager::DecodeInterleaved, "DecodeInterleaved"},
{7, nullptr, "DecodeInterleavedForMultiStream"},
};
// clang-format on
RegisterHandlers(functions);
}
private:
/// Describes extra behavior that may be asked of the decoding context. /// Describes extra behavior that may be asked of the decoding context.
enum class ExtraBehavior { enum class ExtraBehavior {
/// No extra behavior. /// No extra behavior.
@ -63,30 +44,36 @@ private:
ResetContext, ResetContext,
}; };
void DecodeInterleavedOld(Kernel::HLERequestContext& ctx) { enum class PerfTime {
LOG_DEBUG(Audio, "called"); Disabled,
Enabled,
};
DecodeInterleavedHelper(ctx, nullptr, ExtraBehavior::None); virtual ~OpusDecoderStateBase() = default;
}
// Decodes interleaved Opus packets. Optionally allows reporting time taken to
void DecodeInterleavedWithPerfOld(Kernel::HLERequestContext& ctx) { // perform the decoding, as well as any relevant extra behavior.
LOG_DEBUG(Audio, "called"); virtual void DecodeInterleaved(Kernel::HLERequestContext& ctx, PerfTime perf_time,
ExtraBehavior extra_behavior) = 0;
u64 performance = 0; };
DecodeInterleavedHelper(ctx, &performance, ExtraBehavior::None);
} // Represents the decoder state for a non-multistream decoder.
class OpusDecoderState final : public OpusDecoderStateBase {
void DecodeInterleaved(Kernel::HLERequestContext& ctx) { public:
LOG_DEBUG(Audio, "called"); explicit OpusDecoderState(OpusDecoderPtr decoder, u32 sample_rate, u32 channel_count)
: decoder{std::move(decoder)}, sample_rate{sample_rate}, channel_count{channel_count} {}
IPC::RequestParser rp{ctx};
const auto extra_behavior = void DecodeInterleaved(Kernel::HLERequestContext& ctx, PerfTime perf_time,
rp.Pop<bool>() ? ExtraBehavior::ResetContext : ExtraBehavior::None; ExtraBehavior extra_behavior) override {
if (perf_time == PerfTime::Disabled) {
u64 performance = 0; DecodeInterleavedHelper(ctx, nullptr, extra_behavior);
DecodeInterleavedHelper(ctx, &performance, extra_behavior); } else {
u64 performance = 0;
DecodeInterleavedHelper(ctx, &performance, extra_behavior);
}
} }
private:
void DecodeInterleavedHelper(Kernel::HLERequestContext& ctx, u64* performance, void DecodeInterleavedHelper(Kernel::HLERequestContext& ctx, u64* performance,
ExtraBehavior extra_behavior) { ExtraBehavior extra_behavior) {
u32 consumed = 0; u32 consumed = 0;
@ -97,8 +84,7 @@ private:
ResetDecoderContext(); ResetDecoderContext();
} }
if (!Decoder_DecodeInterleaved(consumed, sample_count, ctx.ReadBuffer(), samples, if (!DecodeOpusData(consumed, sample_count, ctx.ReadBuffer(), samples, performance)) {
performance)) {
LOG_ERROR(Audio, "Failed to decode opus data"); LOG_ERROR(Audio, "Failed to decode opus data");
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
// TODO(ogniK): Use correct error code // TODO(ogniK): Use correct error code
@ -117,8 +103,8 @@ private:
ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16)); ctx.WriteBuffer(samples.data(), samples.size() * sizeof(s16));
} }
bool Decoder_DecodeInterleaved(u32& consumed, u32& sample_count, const std::vector<u8>& input, bool DecodeOpusData(u32& consumed, u32& sample_count, const std::vector<u8>& input,
std::vector<opus_int16>& output, u64* out_performance_time) { std::vector<opus_int16>& output, u64* out_performance_time) const {
const auto start_time = std::chrono::high_resolution_clock::now(); const auto start_time = std::chrono::high_resolution_clock::now();
const 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(OpusPacketHeader) > input.size()) { if (sizeof(OpusPacketHeader) > input.size()) {
@ -175,11 +161,61 @@ private:
opus_decoder_ctl(decoder.get(), OPUS_RESET_STATE); opus_decoder_ctl(decoder.get(), OPUS_RESET_STATE);
} }
std::unique_ptr<OpusDecoder, OpusDeleter> decoder; OpusDecoderPtr decoder;
u32 sample_rate; u32 sample_rate;
u32 channel_count; u32 channel_count;
}; };
class IHardwareOpusDecoderManager final : public ServiceFramework<IHardwareOpusDecoderManager> {
public:
explicit IHardwareOpusDecoderManager(std::unique_ptr<OpusDecoderStateBase> decoder_state)
: ServiceFramework("IHardwareOpusDecoderManager"), decoder_state{std::move(decoder_state)} {
// clang-format off
static const FunctionInfo functions[] = {
{0, &IHardwareOpusDecoderManager::DecodeInterleavedOld, "DecodeInterleavedOld"},
{1, nullptr, "SetContext"},
{2, nullptr, "DecodeInterleavedForMultiStreamOld"},
{3, nullptr, "SetContextForMultiStream"},
{4, &IHardwareOpusDecoderManager::DecodeInterleavedWithPerfOld, "DecodeInterleavedWithPerfOld"},
{5, nullptr, "DecodeInterleavedForMultiStreamWithPerfOld"},
{6, &IHardwareOpusDecoderManager::DecodeInterleaved, "DecodeInterleaved"},
{7, nullptr, "DecodeInterleavedForMultiStream"},
};
// clang-format on
RegisterHandlers(functions);
}
private:
void DecodeInterleavedOld(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Audio, "called");
decoder_state->DecodeInterleaved(ctx, OpusDecoderStateBase::PerfTime::Disabled,
OpusDecoderStateBase::ExtraBehavior::None);
}
void DecodeInterleavedWithPerfOld(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Audio, "called");
decoder_state->DecodeInterleaved(ctx, OpusDecoderStateBase::PerfTime::Enabled,
OpusDecoderStateBase::ExtraBehavior::None);
}
void DecodeInterleaved(Kernel::HLERequestContext& ctx) {
LOG_DEBUG(Audio, "called");
IPC::RequestParser rp{ctx};
const auto extra_behavior = rp.Pop<bool>()
? OpusDecoderStateBase::ExtraBehavior::ResetContext
: OpusDecoderStateBase::ExtraBehavior::None;
decoder_state->DecodeInterleaved(ctx, OpusDecoderStateBase::PerfTime::Enabled,
extra_behavior);
}
std::unique_ptr<OpusDecoderStateBase> decoder_state;
};
std::size_t WorkerBufferSize(u32 channel_count) { std::size_t WorkerBufferSize(u32 channel_count) {
ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count"); ASSERT_MSG(channel_count == 1 || channel_count == 2, "Invalid channel count");
return opus_decoder_get_size(static_cast<int>(channel_count)); return opus_decoder_get_size(static_cast<int>(channel_count));
@ -223,8 +259,7 @@ void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
const 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{ OpusDecoderPtr 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)) {
LOG_ERROR(Audio, "Failed to init opus decoder with error={}", err); LOG_ERROR(Audio, "Failed to init opus decoder with error={}", err);
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
@ -235,8 +270,8 @@ void HwOpus::OpenOpusDecoder(Kernel::HLERequestContext& ctx) {
IPC::ResponseBuilder rb{ctx, 2, 0, 1}; IPC::ResponseBuilder rb{ctx, 2, 0, 1};
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.PushIpcInterface<IHardwareOpusDecoderManager>(std::move(decoder), sample_rate, rb.PushIpcInterface<IHardwareOpusDecoderManager>(
channel_count); std::make_unique<OpusDecoderState>(std::move(decoder), sample_rate, channel_count));
} }
HwOpus::HwOpus() : ServiceFramework("hwopus") { HwOpus::HwOpus() : ServiceFramework("hwopus") {