Merge pull request #61 from AvionBlock/dev

v1.6.7 update.

Author: SineVector241

Directory.Build.props

@@ -1,8 +1,8 @@
 <Project>
   <PropertyGroup>
-    <OpusSharpVersion>1.6.6</OpusSharpVersion>
-    <OpusSharpCoreVersion>1.6.1.2</OpusSharpCoreVersion>
-    <OpusSharpNativesVersion>1.6.1.2</OpusSharpNativesVersion>
+    <OpusSharpVersion>1.6.7</OpusSharpVersion>
+    <OpusSharpCoreVersion>1.6.1.3</OpusSharpCoreVersion>
+    <OpusSharpNativesVersion>1.6.1.3</OpusSharpNativesVersion>
     <PackageProjectUrl>https://avionblock.github.io/OpusSharp/index.html</PackageProjectUrl>
     <RepositoryUrl>https://github.com/AvionBlock/OpusSharp</RepositoryUrl>
   </PropertyGroup>

OpusSharp.Core.Tests/NativeLibrarySmokeTests.cs

@@ -1,4 +1,7 @@
 using System.Runtime.InteropServices;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
 using OpusSharp.Core;
 using Xunit;
 
@@ -53,6 +56,283 @@ public void DefaultOpusExceptionCtor_ProducesExceptionInstance()
         Assert.NotNull(exception);
     }
 
+    [Fact]
+    public void MultistreamCtlNoArgumentOverloads_AreManagedWrappers()
+    {
+        AssertPublicCtlOverloadIsManagedWrapper(typeof(NativeOpus), nameof(NativeOpus.opus_ms_encoder_ctl), 2);
+        AssertPublicCtlOverloadIsManagedWrapper(typeof(NativeOpus), nameof(NativeOpus.opus_ms_decoder_ctl), 2);
+        AssertPublicCtlOverloadIsManagedWrapper(typeof(StaticNativeOpus), nameof(StaticNativeOpus.opus_ms_encoder_ctl), 2);
+        AssertPublicCtlOverloadIsManagedWrapper(typeof(StaticNativeOpus), nameof(StaticNativeOpus.opus_ms_decoder_ctl), 2);
+
+        AssertPrivateLibraryImportSymbol(typeof(NativeOpus), "opus_multistream_encoder_ctl");
+        AssertPrivateLibraryImportSymbol(typeof(NativeOpus), "opus_multistream_decoder_ctl");
+        AssertPrivateLibraryImportSymbol(typeof(StaticNativeOpus), "opus_multistream_encoder_ctl");
+        AssertPrivateLibraryImportSymbol(typeof(StaticNativeOpus), "opus_multistream_decoder_ctl");
+    }
+
+    [Fact]
+    public void CtlOverloadsWithVariadicArguments_AreManagedWrappers()
+    {
+        foreach (var method in GetPublicCtlMethods(typeof(NativeOpus), typeof(StaticNativeOpus))
+                     .Where(method => method.GetParameters().Length > 2))
+        {
+            Assert.Empty(method.GetCustomAttributes<LibraryImportAttribute>());
+            Assert.Empty(method.GetCustomAttributes<DllImportAttribute>());
+        }
+    }
+
+    [Fact]
+    public void ManagedCtlShimImports_AreDeclaredInNativeShimSource()
+    {
+        var shimSource = File.ReadAllText(Path.Combine(
+            TestNativeLibraryBootstrapper.GetRepositoryRoot(),
+            "OpusSharp.Natives",
+            "opus_shim.c"));
+
+        foreach (var symbol in GetManagedCtlShimSymbols())
+        {
+            Assert.Contains($"SHIM_EXPORT int {symbol}(", shimSource);
+        }
+    }
+
+    [Fact]
+    public void NativeRuntimeLibrary_ExportsManagedCtlShimSymbols()
+    {
+        var libraryPath = TestNativeLibraryBootstrapper.GetOutputNativeLibraryPath();
+        var handle = NativeLibrary.Load(libraryPath);
+
+        try
+        {
+            foreach (var symbol in GetManagedCtlShimSymbols())
+            {
+                Assert.True(
+                    NativeLibrary.TryGetExport(handle, symbol, out _),
+                    $"Expected '{Path.GetFileName(libraryPath)}' to export '{symbol}'.");
+            }
+        }
+        finally
+        {
+            NativeLibrary.Free(handle);
+        }
+    }
+
+    [Fact]
+    public void IosNativeArchives_ContainManagedCtlShimSymbols()
+    {
+        var iosNativeRoot = Path.Combine(
+            TestNativeLibraryBootstrapper.GetRepositoryRoot(),
+            "OpusSharp.Natives",
+            "runtimes",
+            "ios",
+            "native",
+            "libopus.xcframework");
+        var archivePaths = Directory.GetFiles(iosNativeRoot, "libopus.a", SearchOption.AllDirectories);
+
+        Assert.NotEmpty(archivePaths);
+
+        foreach (var archivePath in archivePaths)
+        {
+            foreach (var symbol in GetManagedCtlShimSymbols())
+            {
+                AssertFileContainsAsciiSymbol(archivePath, symbol);
+            }
+        }
+    }
+
+    [Fact]
+    public void SupportedNativeRuntimeLibraries_ContainManagedCtlShimSymbols()
+    {
+        var nativeFiles = GetSupportedNativeRuntimeFiles().ToArray();
+
+        Assert.NotEmpty(nativeFiles);
+
+        foreach (var nativeFile in nativeFiles)
+        {
+            foreach (var symbol in GetManagedCtlShimSymbols())
+            {
+                AssertFileContainsAsciiSymbol(nativeFile, symbol);
+            }
+        }
+    }
+
+    [Fact]
+    public void PackageSmoke_UsesCurrentPackageVersion()
+    {
+        var props = File.ReadAllText(Path.Combine(
+            TestNativeLibraryBootstrapper.GetRepositoryRoot(),
+            "samples",
+            "PackageSmoke",
+            "Directory.Build.props"));
+
+        Assert.Contains(@"<Import Project=""..\..\Directory.Build.props"" />", props);
+        Assert.Contains("<OpusSharpSmokeVersion>$(OpusSharpVersion)</OpusSharpSmokeVersion>", props);
+    }
+
+    [Fact]
+    public void NativesPackage_ExcludesUnsupportedWindowsRuntimes()
+    {
+        var project = File.ReadAllText(Path.Combine(
+            TestNativeLibraryBootstrapper.GetRepositoryRoot(),
+            "OpusSharp.Natives",
+            "OpusSharp.Natives.csproj"));
+
+        Assert.Contains("runtimes\\win-arm\\**\\*", project);
+        Assert.Contains("runtimes\\win-x86\\**\\*", project);
+    }
+
+    [Fact]
+    public void WindowsNativeBuildWorkflow_HandlesDecoratedX86OpusSymbols()
+    {
+        var workflow = File.ReadAllText(Path.Combine(
+            TestNativeLibraryBootstrapper.GetRepositoryRoot(),
+            ".github",
+            "workflows",
+            "OpusCompile.yml"));
+
+        Assert.Contains("_?opus_\\S+", workflow);
+        Assert.Contains("$raw.Substring(1) + '=' + $raw", workflow);
+    }
+
+    private static void AssertPublicCtlOverloadIsManagedWrapper(Type type, string methodName, int parameterCount)
+    {
+        var method = Assert.Single(
+            type.GetMethods(BindingFlags.Public | BindingFlags.Static),
+            method => method.Name == methodName && method.GetParameters().Length == parameterCount);
+
+        Assert.Empty(method.GetCustomAttributes<LibraryImportAttribute>());
+        Assert.Empty(method.GetCustomAttributes<DllImportAttribute>());
+    }
+
+    private static void AssertPrivateLibraryImportSymbol(Type type, string methodName)
+    {
+        var method = Assert.Single(
+            type.GetMethods(BindingFlags.NonPublic | BindingFlags.Static),
+            method => method.Name == methodName && method.GetParameters().Length == 2);
+
+        Assert.Equal(methodName, GetImportedSymbol(method));
+    }
+
+    private static IEnumerable<MethodInfo> GetPublicCtlMethods(params Type[] types)
+    {
+        return types.SelectMany(type => type.GetMethods(BindingFlags.Public | BindingFlags.Static))
+            .Where(method =>
+                method.Name.StartsWith("opus_", StringComparison.Ordinal) &&
+                method.Name.EndsWith("_ctl", StringComparison.Ordinal));
+    }
+
+    private static IEnumerable<string> GetManagedCtlShimSymbols()
+    {
+        return GetCtlImportMethods(typeof(NativeOpus), typeof(StaticNativeOpus))
+            .Select(GetImportedSymbol)
+            .Where(symbol => symbol.StartsWith("opussharp_", StringComparison.Ordinal))
+            .Distinct()
+            .Order(StringComparer.Ordinal);
+    }
+
+    private static IEnumerable<MethodInfo> GetCtlImportMethods(params Type[] types)
+    {
+        return types.SelectMany(type => type.GetMethods(
+                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static))
+            .Where(method =>
+                method.Name.Contains("_ctl", StringComparison.Ordinal) &&
+                method.GetCustomAttributes<LibraryImportAttribute>().Any());
+    }
+
+    private static string GetImportedSymbol(MethodInfo method)
+    {
+        var importAttribute = Assert.Single(method.GetCustomAttributes<LibraryImportAttribute>());
+
+        return string.IsNullOrEmpty(importAttribute.EntryPoint)
+            ? method.Name
+            : importAttribute.EntryPoint;
+    }
+
+    private static IEnumerable<string> GetSupportedNativeRuntimeFiles()
+    {
+        var nativesRoot = Path.Combine(
+            TestNativeLibraryBootstrapper.GetRepositoryRoot(),
+            "OpusSharp.Natives");
+        var runtimesRoot = Path.Combine(nativesRoot, "runtimes");
+        var readmePath = Path.Combine(nativesRoot, "README.md");
+        var runtimePathPattern = new Regex(@"^- [^:]+: (?<path>\S+)$", RegexOptions.CultureInvariant);
+
+        foreach (var line in File.ReadLines(readmePath))
+        {
+            var match = runtimePathPattern.Match(line);
+
+            if (!match.Success)
+            {
+                continue;
+            }
+
+            var relativePath = match.Groups["path"].Value.Replace('/', Path.DirectorySeparatorChar);
+            var fullPath = Path.Combine(runtimesRoot, relativePath);
+
+            if (File.Exists(fullPath))
+            {
+                if (IsNativeLibraryFile(fullPath))
+                {
+                    yield return fullPath;
+                }
+
+                continue;
+            }
+
+            Assert.True(Directory.Exists(fullPath), $"Expected supported native runtime path '{fullPath}' to exist.");
+
+            foreach (var nativeFile in Directory.GetFiles(fullPath, "*", SearchOption.AllDirectories)
+                         .Where(IsNativeLibraryFile))
+            {
+                yield return nativeFile;
+            }
+        }
+    }
+
+    private static bool IsNativeLibraryFile(string filePath)
+    {
+        return Path.GetExtension(filePath) switch
+        {
+            ".a" or ".dll" or ".dylib" or ".so" => true,
+            _ => false
+        };
+    }
+
+    private static void AssertFileContainsAsciiSymbol(string filePath, string symbol)
+    {
+        var fileBytes = File.ReadAllBytes(filePath);
+        var symbolBytes = Encoding.ASCII.GetBytes(symbol);
+
+        Assert.True(
+            IndexOf(fileBytes, symbolBytes) >= 0,
+            $"Expected '{filePath}' to contain symbol '{symbol}'.");
+    }
+
+    private static int IndexOf(byte[] source, byte[] value)
+    {
+        for (var i = 0; i <= source.Length - value.Length; i++)
+        {
+            var found = true;
+
+            for (var j = 0; j < value.Length; j++)
+            {
+                if (source[i + j] == value[j])
+                {
+                    continue;
+                }
+
+                found = false;
+                break;
+            }
+
+            if (found)
+            {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
     private static class TestNativeLibraryBootstrapper
     {
         private static bool _initialized;
@@ -75,12 +355,29 @@ public static void EnsureInitialized()
             _initialized = true;
         }
 
+        public static string GetRepositoryRoot()
+        {
+            return Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../"));
+        }
+
+        public static string GetOutputNativeLibraryPath()
+        {
+            EnsureInitialized();
+
+            return Path.Combine(AppContext.BaseDirectory, Path.GetFileName(GetNativeLibraryPath()));
+        }
+
         private static string GetNativeLibraryPath()
         {
-            var repoRoot = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../"));
             var runtimeFolder = GetRuntimeFolder();
             var fileName = GetNativeLibraryFileName();
-            var path = Path.Combine(repoRoot, "OpusSharp.Natives", "runtimes", runtimeFolder, "native", fileName);
+            var path = Path.Combine(
+                GetRepositoryRoot(),
+                "OpusSharp.Natives",
+                "runtimes",
+                runtimeFolder,
+                "native",
+                fileName);
 
             if (!File.Exists(path))
             {

OpusSharp.Core/NativeOpus.cs

@@ -1070,11 +1070,20 @@ public static unsafe int opus_dred_decoder_ctl(OpusDREDDecoderSafeHandle dred_de
         /// <returns><see cref="OpusErrorCodes"/></returns>
 #if NET8_0_OR_GREATER
         [LibraryImport(DllName)]
-        public static partial int opus_ms_encoder_ctl(OpusMSEncoderSafeHandle st, int request); //Apparently GenericCTL.OPUS_RESET_STATE exists.
+        private static partial int opus_multistream_encoder_ctl(OpusMSEncoderSafeHandle st, int request);
 #else
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern int opus_ms_encoder_ctl(OpusMSEncoderSafeHandle st, int request); //Apparently GenericCTL.OPUS_RESET_STATE exists.
+        private static extern int opus_multistream_encoder_ctl(OpusMSEncoderSafeHandle st, int request);
 #endif
+
+        /// <summary>
+        /// Perform a CTL function on a <see cref="OpusMSEncoderSafeHandle"/>.
+        /// </summary>
+        /// <param name="st">Multistream encoder state.</param>
+        /// <param name="request">This and all remaining parameters should be replaced by one of the convenience macros in <see cref="GenericCTL"/>, <see cref="EncoderCTL"/>, or <see cref="MultistreamCTL"/> specific encoder and decoder CTLs.</param>
+        /// <returns><see cref="OpusErrorCodes"/></returns>
+        public static int opus_ms_encoder_ctl(OpusMSEncoderSafeHandle st, int request) =>
+            opus_multistream_encoder_ctl(st, request); //Apparently GenericCTL.OPUS_RESET_STATE exists.
 
 #if NET8_0_OR_GREATER
         [LibraryImport(DllName)]
@@ -1277,11 +1286,20 @@ public static unsafe int opus_ms_encoder_ctl(OpusMSEncoderSafeHandle st, int req
         /// <returns><see cref="OpusErrorCodes"/></returns>
 #if NET8_0_OR_GREATER
         [LibraryImport(DllName)]
-        public static partial int opus_ms_decoder_ctl(OpusMSDecoderSafeHandle st, int request); //Apparently GenericCTL.OPUS_RESET_STATE exists.
+        private static partial int opus_multistream_decoder_ctl(OpusMSDecoderSafeHandle st, int request);
 #else
         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern int opus_ms_decoder_ctl(OpusMSDecoderSafeHandle st, int request); //Apparently GenericCTL.OPUS_RESET_STATE exists.
+        private static extern int opus_multistream_decoder_ctl(OpusMSDecoderSafeHandle st, int request);
 #endif
+
+        /// <summary>
+        /// Perform a CTL function on a <see cref="OpusMSEncoderSafeHandle"/>.
+        /// </summary>
+        /// <param name="st">Multistream decoder state.</param>
+        /// <param name="request">This and all remaining parameters should be replaced by one of the convenience macros in <see cref="GenericCTL"/>, <see cref="DecoderCTL"/>, or <see cref="MultistreamCTL"/> specific encoder and decoder CTLs.</param>
+        /// <returns><see cref="OpusErrorCodes"/></returns>
+        public static int opus_ms_decoder_ctl(OpusMSDecoderSafeHandle st, int request) =>
+            opus_multistream_decoder_ctl(st, request); //Apparently GenericCTL.OPUS_RESET_STATE exists.
 
 #if NET8_0_OR_GREATER
         [LibraryImport(DllName)]
@@ -1356,4 +1374,4 @@ public static unsafe int opus_ms_decoder_ctl(OpusMSDecoderSafeHandle st, int req
 #endif
     }
 }
-#pragma warning restore CA1401
+#pragma warning restore CA1401