XAudio + Multimedia: Add SoundStream and RiffParser from SharpDX and improve XAudio CreateSourceVoice to allow events in more C# friendly way as well.

Author: amerkoleci

src/Vortice.DirectX/FourCC.cs

@@ -0,0 +1,192 @@
+// Copyright (c) Amer Koleci and contributors.
+// Distributed under the MIT license. See the LICENSE file in the project root for more information.
+
+using System;
+using System.Globalization;
+using System.Runtime.InteropServices;
+
+namespace Vortice
+{
+    /// <summary>
+    /// A FourCC descriptor.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Size = 4)]
+    public readonly struct FourCC : IEquatable<FourCC>, IFormattable
+    {
+        /// <summary>
+        /// Empty FourCC.
+        /// </summary>
+        public static readonly FourCC Empty = new(0);
+
+        private readonly uint _value;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FourCC" /> struct.
+        /// </summary>
+        /// <param name="fourCC">The fourCC value as a string .</param>
+        public FourCC(string fourCC)
+        {
+            if (fourCC.Length != 4)
+            {
+                throw new ArgumentException(string.Format(System.Globalization.CultureInfo.InvariantCulture, "Invalid length for FourCC(\"{0}\". Must be be 4 characters long ", fourCC), "fourCC");
+            }
+
+            _value = ((uint)fourCC[3]) << 24 | ((uint)fourCC[2]) << 16 | ((uint)fourCC[1]) << 8 | ((uint)fourCC[0]);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FourCC" /> struct.
+        /// </summary>
+        /// <param name="byte1">The byte1.</param>
+        /// <param name="byte2">The byte2.</param>
+        /// <param name="byte3">The byte3.</param>
+        /// <param name="byte4">The byte4.</param>
+        public FourCC(char byte1, char byte2, char byte3, char byte4)
+        {
+            _value = ((uint)byte4) << 24 | ((uint)byte3) << 16 | ((uint)byte2) << 8 | ((uint)byte1);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FourCC" /> struct.
+        /// </summary>
+        /// <param name="fourCC">The fourCC value as an uint.</param>
+        public FourCC(uint fourCC)
+        {
+            _value = fourCC;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="FourCC" /> struct.
+        /// </summary>
+        /// <param name="fourCC">The fourCC value as an int.</param>
+        public FourCC(int fourCC)
+        {
+            _value = unchecked((uint)fourCC);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="FourCC"/> to <see cref="int"/>.
+        /// </summary>
+        /// <param name="d">The d.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator uint(FourCC d)
+        {
+            return d._value;
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="FourCC"/> to <see cref="int"/>.
+        /// </summary>
+        /// <param name="d">The d.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator int(FourCC d)
+        {
+            return unchecked((int)d._value);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="int"/> to <see cref="FourCC"/>.
+        /// </summary>
+        /// <param name="d">The d.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator FourCC(uint d)
+        {
+            return new FourCC(d);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="int"/> to <see cref="FourCC"/>.
+        /// </summary>
+        /// <param name="d">The d.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator FourCC(int d)
+        {
+            return new FourCC(d);
+        }
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="FourCC"/> to <see cref="string"/>.
+        /// </summary>
+        /// <param name="value">The <see cref="FourCC"/> value.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator string(FourCC value) => value.ToString();
+
+        /// <summary>
+        /// Performs an implicit conversion from <see cref="string"/> to <see cref="FourCC"/>.
+        /// </summary>
+        /// <param name="d">The d.</param>
+        /// <returns>
+        /// The result of the conversion.
+        /// </returns>
+        public static implicit operator FourCC(string d) => new(d);
+
+        public override string ToString()
+        {
+            return string.Format("{0}", new string(new[]
+                                  {
+                                      (char) (_value & 0xFF),
+                                      (char) ((_value >> 8) & 0xFF),
+                                      (char) ((_value >> 16) & 0xFF),
+                                      (char) ((_value >> 24) & 0xFF),
+                                  }));
+        }
+
+        public bool Equals(FourCC other) => _value == other._value;
+
+        /// <inheritdoc/>
+		public override bool Equals(object? obj) => obj is FourCC value && Equals(value);
+
+        public override int GetHashCode() => (int)_value;
+
+        /// <summary>
+        /// Provides a custom string representation of the FourCC descriptor.
+        /// </summary>
+        /// <remarks>
+        /// The general format "G" is equivalent to the parameterless.
+        /// <see cref="FourCC.ToString()"/>. The special format "I" returns a
+        /// string representation which can be used to construct a Media
+        /// Foundation format GUID. It is equivalent to "X08".
+        /// </remarks>
+        /// <param name="format">The format descriptor, which can be "G" (empty
+        /// or <c>null</c> is equivalent to "G"), "I" or any valid standard
+        /// number format.</param>
+        /// <param name="formatProvider">The format provider for formatting
+        /// numbers.</param>
+        /// <returns>The requested string representation.</returns>
+        /// <exception cref="System.FormatException">In case of
+        /// <paramref name="format"/> is not "G", "I" or a valid number
+        /// format.</exception>
+        public string ToString(string format, IFormatProvider formatProvider)
+        {
+            if (string.IsNullOrEmpty(format))
+            {
+                format = "G";
+            }
+            if (formatProvider == null)
+            {
+                formatProvider = CultureInfo.CurrentCulture;
+            }
+
+            return format.ToUpperInvariant() switch
+            {
+                "G" => ToString(),
+                "I" => _value.ToString("X08", formatProvider),
+                _ => _value.ToString(format, formatProvider),
+            };
+        }
+
+        public static bool operator ==(FourCC left, FourCC right) => left.Equals(right);
+
+        public static bool operator !=(FourCC left, FourCC right) => !left.Equals(right);
+    }
+}

src/Vortice.Multimedia/RiffChunk.cs

@@ -0,0 +1,151 @@
+// Copyright (c) 2010-2014 SharpDX - Alexandre Mutel
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+// Copyright (c) Amer Koleci and contributors.
+// Distributed under the MIT license. See the LICENSE file in the project root for more information.
+
+using System;
+using System.IO;
+using SharpGen.Runtime;
+
+namespace Vortice.Multimedia
+{
+    /// <summary>
+    /// A chunk of a Riff stream.
+    /// </summary>
+    public class RiffChunk
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RiffChunk"/> class.
+        /// </summary>
+        /// <param name="stream">The stream holding this chunk</param>
+        /// <param name="type">The type.</param>
+        /// <param name="size">The size.</param>
+        /// <param name="dataPosition">The data offset.</param>
+        /// <param name="isList">if set to <c>true</c> [is list].</param>
+        /// <param name="isHeader">if set to <c>true</c> [is header].</param>
+        public RiffChunk(Stream stream, FourCC type, uint size, uint dataPosition, bool isList = false, bool isHeader = false)
+        {
+            Stream = stream;
+            Type = type;
+            Size = size;
+            DataPosition = dataPosition;
+            IsList = isList;
+            IsHeader = isHeader;
+        }
+
+        /// <summary>
+        /// Gets the type.
+        /// </summary>
+        public Stream Stream { get; }
+
+        /// <summary>
+        /// Gets the <see cref="FourCC"/> of this chunk.
+        /// </summary>
+        public FourCC Type { get; }
+
+        /// <summary>
+        /// Gets the size of the data embedded by this chunk.
+        /// </summary>
+        public uint Size { get; }
+
+        /// <summary>
+        /// Gets the position of the data embedded by this chunk relative to the stream.
+        /// </summary>
+        public uint DataPosition { get; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this instance is a list chunk.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance is list; otherwise, <c>false</c>.
+        /// </value>
+        public bool IsList { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether this instance is a header chunk.
+        /// </summary>
+        /// <value>
+        ///   <c>true</c> if this instance is a header; otherwise, <c>false</c>.
+        /// </value>
+        public bool IsHeader { get; }
+
+        /// <summary>
+        /// Gets the raw data contained in this chunk.
+        /// </summary>
+        /// <returns></returns>
+        public byte[] GetData()
+        {
+            byte[] data = new byte[Size];
+            Stream.Position = DataPosition;
+            Stream.Read(data, 0, (int)Size);
+            return data;
+        }
+
+        /// <summary>
+        /// Gets structured data contained in this chunk.
+        /// </summary>
+        /// <typeparam name="T">The type of the data to return</typeparam>
+        /// <returns>
+        /// A structure filled with the chunk data
+        /// </returns>
+        public unsafe T GetDataAs<T>() where T : unmanaged
+        {
+            T value = new();
+            byte[] data = GetData();
+            fixed (void* ptr = data)
+            {
+                MemoryHelpers.Read((IntPtr)ptr, ref value);
+            }
+            return value;
+        }
+
+        /// <summary>
+        /// Gets structured data contained in this chunk.
+        /// </summary>
+        /// <typeparam name="T">The type of the data to return</typeparam>
+        /// <returns>A structure filled with the chunk data</returns>
+        public unsafe T[] GetDataAsArray<T>() where T : unmanaged
+        {
+            int sizeOfT = sizeof(T);
+            if ((Size % sizeOfT) != 0)
+                throw new ArgumentException("Size of T is incompatible with size of chunk");
+
+            T[] values = new T[Size / sizeOfT];
+            byte[] data = GetData();
+            fixed (void* ptr = data)
+            {
+                MemoryHelpers.Read((IntPtr)ptr, values, 0, values.Length);
+            }
+
+            return values;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="string"/> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="string"/> that represents this instance.
+        /// </returns>
+        public override string ToString()
+        {
+            return $"Type: {Type}, Size: {Size}, Position: {DataPosition}, IsList: {IsList}, IsHeader: {IsHeader}";
+        }
+    }
+}