Migrate Audio service to new IPC (#6285)

* Migrate audren to new IPC * Migrate audout * Migrate audin * Migrate hwopus * Bye bye old audio service * Switch volume control to IHardwareDeviceDriver * Somewhat unrelated changes * Remove Concentus reference from HLE * Implement OpenAudioRendererForManualExecution * Remove SetVolume/GetVolume methods that are not necessary * Remove SetVolume/GetVolume methods that are not necessary (2) * Fix incorrect volume update * PR feedback * PR feedback * Stub audrec * Init outParameter * Make FinalOutputRecorderParameter/Internal readonly * Make FinalOutputRecorder IDisposable * Fix HardwareOpusDecoderManager parameter buffers * Opus work buffer size and error handling improvements * Add AudioInProtocolName enum * Fix potential divisions by zero
2025-12-16 22:37:06 +00:00 · 2024-02-22 16:58:33 -03:00 · 2024-02-22 16:58:33 -03:00 · d4d0a48bfe
commit d4d0a48bfe
parent 57d8afd0c9
130 changed files with 3096 additions and 3174 deletions
--- a/src/Ryujinx.Horizon/Sdk/Codec/Detail/HardwareOpusDecoderManager.cs
+++ b/src/Ryujinx.Horizon/Sdk/Codec/Detail/HardwareOpusDecoderManager.cs
@ -0,0 +1,386 @@
+using Ryujinx.Common;
+using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Sdk.Sf;
+using Ryujinx.Horizon.Sdk.Sf.Hipc;
+using System;
+
+namespace Ryujinx.Horizon.Sdk.Codec.Detail
+{
+    partial class HardwareOpusDecoderManager : IHardwareOpusDecoderManager
+    {
+        [CmifCommand(0)]
+        public Result OpenHardwareOpusDecoder(
+            out IHardwareOpusDecoder decoder,
+            HardwareOpusDecoderParameterInternal parameter,
+            [CopyHandle] int workBufferHandle,
+            int workBufferSize)
+        {
+            decoder = null;
+
+            if (!IsValidSampleRate(parameter.SampleRate))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidSampleRate;
+            }
+
+            if (!IsValidChannelCount(parameter.ChannelsCount))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidChannelCount;
+            }
+
+            decoder = new HardwareOpusDecoder(parameter.SampleRate, parameter.ChannelsCount, workBufferHandle);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(1)]
+        public Result GetWorkBufferSize(out int size, HardwareOpusDecoderParameterInternal parameter)
+        {
+            size = 0;
+
+            if (!IsValidChannelCount(parameter.ChannelsCount))
+            {
+                return CodecResult.InvalidChannelCount;
+            }
+
+            if (!IsValidSampleRate(parameter.SampleRate))
+            {
+                return CodecResult.InvalidSampleRate;
+            }
+
+            int opusDecoderSize = GetOpusDecoderSize(parameter.ChannelsCount);
+
+            int sampleRateRatio = parameter.SampleRate != 0 ? 48000 / parameter.SampleRate : 0;
+            int frameSize = BitUtils.AlignUp(sampleRateRatio != 0 ? parameter.ChannelsCount * 1920 / sampleRateRatio : 0, 64);
+            size = opusDecoderSize + 1536 + frameSize;
+
+            return Result.Success;
+        }
+
+        [CmifCommand(2)] // 3.0.0+
+        public Result OpenHardwareOpusDecoderForMultiStream(
+            out IHardwareOpusDecoder decoder,
+            [Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer, 0x110)] in HardwareOpusMultiStreamDecoderParameterInternal parameter,
+            [CopyHandle] int workBufferHandle,
+            int workBufferSize)
+        {
+            decoder = null;
+
+            if (!IsValidSampleRate(parameter.SampleRate))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidSampleRate;
+            }
+
+            if (!IsValidMultiChannelCount(parameter.ChannelsCount))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidChannelCount;
+            }
+
+            if (!IsValidNumberOfStreams(parameter.NumberOfStreams, parameter.NumberOfStereoStreams, parameter.ChannelsCount))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidNumberOfStreams;
+            }
+
+            decoder = new HardwareOpusDecoder(
+                parameter.SampleRate,
+                parameter.ChannelsCount,
+                parameter.NumberOfStreams,
+                parameter.NumberOfStereoStreams,
+                parameter.ChannelMappings.AsSpan().ToArray(),
+                workBufferHandle);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(3)] // 3.0.0+
+        public Result GetWorkBufferSizeForMultiStream(
+            out int size,
+            [Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer, 0x110)] in HardwareOpusMultiStreamDecoderParameterInternal parameter)
+        {
+            size = 0;
+
+            if (!IsValidMultiChannelCount(parameter.ChannelsCount))
+            {
+                return CodecResult.InvalidChannelCount;
+            }
+
+            if (!IsValidSampleRate(parameter.SampleRate))
+            {
+                return CodecResult.InvalidSampleRate;
+            }
+
+            if (!IsValidNumberOfStreams(parameter.NumberOfStreams, parameter.NumberOfStereoStreams, parameter.ChannelsCount))
+            {
+                return CodecResult.InvalidSampleRate;
+            }
+
+            int opusDecoderSize = GetOpusMultistreamDecoderSize(parameter.NumberOfStreams, parameter.NumberOfStereoStreams);
+
+            int streamSize = BitUtils.AlignUp(parameter.NumberOfStreams * 1500, 64);
+            int sampleRateRatio = parameter.SampleRate != 0 ? 48000 / parameter.SampleRate : 0;
+            int frameSize = BitUtils.AlignUp(sampleRateRatio != 0 ? parameter.ChannelsCount * 1920 / sampleRateRatio : 0, 64);
+            size = opusDecoderSize + streamSize + frameSize;
+
+            return Result.Success;
+        }
+
+        [CmifCommand(4)] // 12.0.0+
+        public Result OpenHardwareOpusDecoderEx(
+            out IHardwareOpusDecoder decoder,
+            HardwareOpusDecoderParameterInternalEx parameter,
+            [CopyHandle] int workBufferHandle,
+            int workBufferSize)
+        {
+            decoder = null;
+
+            if (!IsValidChannelCount(parameter.ChannelsCount))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidChannelCount;
+            }
+
+            if (!IsValidSampleRate(parameter.SampleRate))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidSampleRate;
+            }
+
+            decoder = new HardwareOpusDecoder(parameter.SampleRate, parameter.ChannelsCount, workBufferHandle);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(5)] // 12.0.0+
+        public Result GetWorkBufferSizeEx(out int size, HardwareOpusDecoderParameterInternalEx parameter)
+        {
+            return GetWorkBufferSizeExImpl(out size, in parameter, fromDsp: false);
+        }
+
+        [CmifCommand(6)] // 12.0.0+
+        public Result OpenHardwareOpusDecoderForMultiStreamEx(
+            out IHardwareOpusDecoder decoder,
+            [Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer, 0x118)] in HardwareOpusMultiStreamDecoderParameterInternalEx parameter,
+            [CopyHandle] int workBufferHandle,
+            int workBufferSize)
+        {
+            decoder = null;
+
+            if (!IsValidSampleRate(parameter.SampleRate))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidSampleRate;
+            }
+
+            if (!IsValidMultiChannelCount(parameter.ChannelsCount))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidChannelCount;
+            }
+
+            if (!IsValidNumberOfStreams(parameter.NumberOfStreams, parameter.NumberOfStereoStreams, parameter.ChannelsCount))
+            {
+                HorizonStatic.Syscall.CloseHandle(workBufferHandle);
+
+                return CodecResult.InvalidNumberOfStreams;
+            }
+
+            decoder = new HardwareOpusDecoder(
+                parameter.SampleRate,
+                parameter.ChannelsCount,
+                parameter.NumberOfStreams,
+                parameter.NumberOfStereoStreams,
+                parameter.ChannelMappings.AsSpan().ToArray(),
+                workBufferHandle);
+
+            return Result.Success;
+        }
+
+        [CmifCommand(7)] // 12.0.0+
+        public Result GetWorkBufferSizeForMultiStreamEx(
+            out int size,
+            [Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer, 0x118)] in HardwareOpusMultiStreamDecoderParameterInternalEx parameter)
+        {
+            return GetWorkBufferSizeForMultiStreamExImpl(out size, in parameter, fromDsp: false);
+        }
+
+        [CmifCommand(8)] // 16.0.0+
+        public Result GetWorkBufferSizeExEx(out int size, HardwareOpusDecoderParameterInternalEx parameter)
+        {
+            return GetWorkBufferSizeExImpl(out size, in parameter, fromDsp: true);
+        }
+
+        [CmifCommand(9)] // 16.0.0+
+        public Result GetWorkBufferSizeForMultiStreamExEx(
+            out int size,
+            [Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer, 0x118)] in HardwareOpusMultiStreamDecoderParameterInternalEx parameter)
+        {
+            return GetWorkBufferSizeForMultiStreamExImpl(out size, in parameter, fromDsp: true);
+        }
+
+        private Result GetWorkBufferSizeExImpl(out int size, in HardwareOpusDecoderParameterInternalEx parameter, bool fromDsp)
+        {
+            size = 0;
+
+            if (!IsValidChannelCount(parameter.ChannelsCount))
+            {
+                return CodecResult.InvalidChannelCount;
+            }
+
+            if (!IsValidSampleRate(parameter.SampleRate))
+            {
+                return CodecResult.InvalidSampleRate;
+            }
+
+            int opusDecoderSize = fromDsp ? GetDspOpusDecoderSize(parameter.ChannelsCount) : GetOpusDecoderSize(parameter.ChannelsCount);
+
+            int frameSizeMono48KHz = parameter.Flags.HasFlag(OpusDecoderFlags.LargeFrameSize) ? 5760 : 1920;
+            int sampleRateRatio = parameter.SampleRate != 0 ? 48000 / parameter.SampleRate : 0;
+            int frameSize = BitUtils.AlignUp(sampleRateRatio != 0 ? parameter.ChannelsCount * frameSizeMono48KHz / sampleRateRatio : 0, 64);
+            size = opusDecoderSize + 1536 + frameSize;
+
+            return Result.Success;
+        }
+
+        private Result GetWorkBufferSizeForMultiStreamExImpl(out int size, in HardwareOpusMultiStreamDecoderParameterInternalEx parameter, bool fromDsp)
+        {
+            size = 0;
+
+            if (!IsValidMultiChannelCount(parameter.ChannelsCount))
+            {
+                return CodecResult.InvalidChannelCount;
+            }
+
+            if (!IsValidSampleRate(parameter.SampleRate))
+            {
+                return CodecResult.InvalidSampleRate;
+            }
+
+            if (!IsValidNumberOfStreams(parameter.NumberOfStreams, parameter.NumberOfStereoStreams, parameter.ChannelsCount))
+            {
+                return CodecResult.InvalidSampleRate;
+            }
+
+            int opusDecoderSize = fromDsp
+                ? GetDspOpusMultistreamDecoderSize(parameter.NumberOfStreams, parameter.NumberOfStereoStreams)
+                : GetOpusMultistreamDecoderSize(parameter.NumberOfStreams, parameter.NumberOfStereoStreams);
+
+            int frameSizeMono48KHz = parameter.Flags.HasFlag(OpusDecoderFlags.LargeFrameSize) ? 5760 : 1920;
+            int streamSize = BitUtils.AlignUp(parameter.NumberOfStreams * 1500, 64);
+            int sampleRateRatio = parameter.SampleRate != 0 ? 48000 / parameter.SampleRate : 0;
+            int frameSize = BitUtils.AlignUp(sampleRateRatio != 0 ? parameter.ChannelsCount * frameSizeMono48KHz / sampleRateRatio : 0, 64);
+            size = opusDecoderSize + streamSize + frameSize;
+
+            return Result.Success;
+        }
+
+        private static int GetDspOpusDecoderSize(int channelsCount)
+        {
+            // TODO: Figure out the size returned here.
+            // Not really important because we don't use the work buffer, and the size being lower is fine.
+
+            return 0;
+        }
+
+        private static int GetDspOpusMultistreamDecoderSize(int streams, int coupledStreams)
+        {
+            // TODO: Figure out the size returned here.
+            // Not really important because we don't use the work buffer, and the size being lower is fine.
+
+            return 0;
+        }
+
+        private static int GetOpusDecoderSize(int channelsCount)
+        {
+            const int SilkDecoderSize = 0x2160;
+
+            if (channelsCount < 1 || channelsCount > 2)
+            {
+                return 0;
+            }
+
+            int celtDecoderSize = GetCeltDecoderSize(channelsCount);
+            int opusDecoderSize = GetOpusDecoderAllocSize(channelsCount) | 0x50;
+
+            return opusDecoderSize + SilkDecoderSize + celtDecoderSize;
+        }
+
+        private static int GetOpusMultistreamDecoderSize(int streams, int coupledStreams)
+        {
+            if (streams < 1 || coupledStreams > streams || coupledStreams < 0)
+            {
+                return 0;
+            }
+
+            int coupledSize = GetOpusDecoderSize(2);
+            int monoSize = GetOpusDecoderSize(1);
+
+            return Align4(monoSize - GetOpusDecoderAllocSize(1)) * (streams - coupledStreams) +
+                Align4(coupledSize - GetOpusDecoderAllocSize(2)) * coupledStreams + 0xb920;
+        }
+
+        private static int Align4(int value)
+        {
+            return BitUtils.AlignUp(value, 4);
+        }
+
+        private static int GetOpusDecoderAllocSize(int channelsCount)
+        {
+            return channelsCount * 0x800 + 0x4800;
+        }
+
+        private static int GetCeltDecoderSize(int channelsCount)
+        {
+            const int DecodeBufferSize = 0x2030;
+            const int Overlap = 120;
+            const int EBandsCount = 21;
+
+            return (DecodeBufferSize + Overlap * 4) * channelsCount + EBandsCount * 16 + 0x54;
+        }
+
+        private static bool IsValidChannelCount(int channelsCount)
+        {
+            return channelsCount > 0 && channelsCount <= 2;
+        }
+
+        private static bool IsValidMultiChannelCount(int channelsCount)
+        {
+            return channelsCount > 0 && channelsCount <= 255;
+        }
+
+        private static bool IsValidSampleRate(int sampleRate)
+        {
+            switch (sampleRate)
+            {
+                case 8000:
+                case 12000:
+                case 16000:
+                case 24000:
+                case 48000:
+                    return true;
+            }
+
+            return false;
+        }
+
+        private static bool IsValidNumberOfStreams(int numberOfStreams, int numberOfStereoStreams, int channelsCount)
+        {
+            return numberOfStreams > 0 &&
+                numberOfStreams + numberOfStereoStreams <= channelsCount &&
+                numberOfStereoStreams >= 0 &&
+                numberOfStereoStreams <= numberOfStreams;
+        }
+    }
+}