IWavePlayer and IWaveIn cross-platform implementations via SDL2

Docs/EnumerateOutputDevices.md

@@ -106,6 +106,29 @@ You can then use the driver name to open the device:
 new AsioOut(driverName);
 ```
 
+# WaveOutSdl
+
+Note that you must install the package with native libraries or distribute them manually (nuget NAudio.Sdl2.Library).
+
+To discover the number of output devices and discover its capabilities you can use `WaveOutSdl.GetCapabilitiesList`.
+
+Note that you can also pass an index of -1 which is the default audio device.
+
+```c#
+var capabilitiesList = WaveOutSdl.GetCapabilitiesList();
+foreach (var caps in capabilitiesList)
+{
+    Console.WriteLine(caps.ToString(Environment.NewLine));
+    Console.WriteLine();
+}
+```
+
+Once you've selected the device you want, you can open it by creating an instance of `WaveOutSdl` and specifying it as the `DeviceId`:
+
+```c#
+var outputDevice = new WaveOutSdl() { DeviceId = DeviceId };
+```
+
 # Management Objects
 
 Finally you can use Windows Management Objects to get hold of details of the sound devices installed. This doesn't map specifically to any of the NAudio output device types, but can be a source of useful information

Docs/Sdl2Playback.md

@@ -0,0 +1,42 @@
+# Playback with SDL2
+
+The `WaveOutSdl` class in NAudio allows you to playback audio using an SDL2. SDL2 is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D.
+
+To use SDL2 you will need native libraries. You can find these libraries on nuget or on official website.
+
+## Opening an SDL2 device for playback
+
+To discover the list of the accessible playback devices on your system you use `WaveOutSdl.GetCapabilitiesList()`.
+
+We can use 'DeviceNumber' property from 'WaveOutSdlCapabilities' instance and set this number via 'DeviceId' property on the 'WaveOutSdl' instance.
+
+```c#
+var waveOutSdl = new WaveOutSdl() 
+{ 
+    DeviceId = waveOutSdlCaps.DeviceNumber
+};
+```
+
+## Inititializing wave provider
+
+Call `Init`, this lets us pass the `IWaveProvider` we want to play. Note that the sample rate of the `WaveFormat` of the input provider must be one supported by the SDL2.
+
+```c#
+waveOutSdl.Init(myWaveProvider);
+```
+
+## Stop Playback
+
+We stop playing by calling Stop().
+
+```c#
+waveOutSdl.Stop(); // stop playing
+```
+
+As with other NAudio `IWavePlayer` implementations, we'll get a `PlaybackStopped` event firing when the playback stops.
+
+And of course we should remember to `Dispose` our instance of `WaveOutSdl` when we're done with it.
+
+```c#
+waveOutSdl.Dispose();
+```

Docs/Sdl2Recording.md

@@ -0,0 +1,63 @@
+# Recording with SDL2
+
+The `WaveInSdl` class in NAudio allows you to record audio using an SDL2. SDL2 is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D.
+
+To use SDL2 you will need native libraries. You can find these libraries on nuget or on official website.
+
+## Opening an SDL2 device for recording
+
+To discover the list of the accessible recording devices on your system you use `WaveInSdl.GetCapabilitiesList()`.
+
+We can use 'DeviceNumber' property from 'WaveInSdlCapabilities' instance and set this number via 'DeviceId' property on the 'WaveInSdl' instance.
+
+We can use 'Frequency', 'Bits', and 'Channels' properies from 'WaveInSdlCapabilities' instance and set 'WaveFormat' property on the 'WaveInSdl' instance.
+
+```c#
+var waveInSdl = new WaveInSdl() 
+{ 
+    DeviceId = waveInSdlCaps.DeviceNumber,
+    WaveFormat = new WaveFormat(waveInSdlCaps.Frequency, waveInSdlCaps.Bits, waveInSdlCaps.Channels)
+};
+```
+
+## Start Recording
+
+We need to subscribe to the `DataAvailable` event in order to process audio received in the SDL2 buffer callback.
+
+And we kick off recording by calling `StartRecording()`.
+
+```c#
+waveInSdl.DataAvailable += OnWaveInSdlDataAvailable;
+waveInSdl.StartRecording(); // start recording
+```
+
+## Handle received audio
+
+When we receive audio we get access to the byte array buffer in an `WaveInEventArgs` object.
+
+Here's the simplest handler for `DataAvailable` that just gets the audio as byte array and writes them to a `WaveFileWriter` that we've set up in advance.
+
+```c#
+void OnWaveInSdlDataAvailable(object sender, WaveInEventArgs e)
+{
+    waveFileWriter.Write(e.Buffer, 0, e.BytesRecorded);
+}
+```
+
+For a real application, you'd probably want to write your own logic in here.
+
+## Stop Recording
+
+We stop recording by calling `StopRecording()`.
+
+```c#
+waveInSdl.StopRecording();
+```
+
+As with other NAudio `IWaveIn` implementations, we'll get a `RecordingStopped` event firing when the recording stops.
+
+And of course we should remember to `Dispose` our instance of `WaveInSdl` when we're done with it.
+
+```c#
+waveInSdl.Dispose();
+```

NAudio.Sdl2/CHANGELOG.md

@@ -0,0 +1,28 @@
+### 2.2.6 (15 Nov 2024)
+* BREAKING CHANGES
+* Remove `AudioConversion`
+* Remove `ActualWaveFormat`
+* Remove `AdjustLatencyPercent`
+* Change `WaveInSdlCapabilities`, `WaveOutSdlCapabilities` classes to structs
+* Added automatic initialization and cleanup of SDL2 resources. `WaveInSdl`, `WaveOutSdl` constructors can throw exceptions
+* Added experimental android support which requires the `NAudio.Sdl2.Library.Android` package. Use the `NAudioAvaloniaDemo.Android` project as an example
+* Changes in NAudioAvaloniaDemo
+
+### 2.2.5 (24 May 2024)
+* Fix `WaveInSdl` bugs
+
+### 2.2.4 (23 May 2024)
+* Port NAudioWpfDemo to NAudioAvaloniaDemo
+* Fix `WaveOutSdl` bugs
+* Fix `AudioConversion` enum
+
+### 2.2.3 (20 May 2024)
+* Fix SDL version comparison
+
+### 2.2.2 (13 May 2024)
+* Added volume mixer for `WaveOutSdl`
+* More reliable audio format recognition
+* Added compatibility with versions lower than SDL-2.0.16
+
+### 2.2.1 (30 Apr 2024)
+* Initial version, `WaveInSdl` and `WaveOutSdl` implementations